The new features and improvements in this release fall into three categories:
1) A major overhaul of the `kdu_region_decompressor' and `kdu_region_compositor' high level rendering objects, with the following important innovations:
a) All high level API's in Kakadu now support everything from fast low precision processing through to full floating-point precision processing. This has always been true of the core system, but is now true even for objects like `kdu_region_compositor' which perform sophisticated rescaling, re-orientation, compositing and animation of multiple images from multiple codestreams, with potentially very different internal properties.
b) These objects now implement completely arbitrary scaling (in each dimension) of the underlying imagery, selecting the most appropriate original resolution to decompress and using disciplined signal processing techniques to scale to any target resolution whatsoever, over any region of the original image. Previously, only bilinear upscaling was implemented. Now you can even render an image which only one native compressed resolution at any arbitrary size without having to worry about the mechanics. These features are demonstrated in a simple way by adding an arbitrary "-scale" argument to all six demonstration code fragments inside the "kdu_render" demo app. More significantly, "kdu_winshow" and "kdu_macshow" take advantage of the features to produce much higher quality compositions when images with non-power-of-2-related resolutions are composed on a single surface. Moreover, these tools now robustly scale to any resolution at all, providing all the appropriate safe guards as the scaled resolution approaches ridiculous values (ridiculously large or ridiculously small). Try zooming or out massively in one of these viewers if you like, while viewing the image size in the status bar (you may have to toggle the status mode using ^t or Cmd-t), or try zooming by small amounts by holding the shift key down together with the zoom accelerators.
c) The processing of metadata overlay imagery in `kdu_region_compositor' has been completely re-implemented so as to provide much higher throughput when there is a massive amount of metadata with regions of interest to be highlighted. The new implementation provides disciplined sequencing of the overlay painting process so that there is little or no risk of large overlay regions concealing smaller ones and the appearance of overlay data does not depend on the order in which metadata becomes available in an interactive client-server session. Dynamic adjustment of the overlay blending strength is now provided in a very efficient and almost transparent manner, so you can animate the overlay content in a display without much processing overhead -- this is what "kdu_winshow" and "kdu_macshow" now do by default, but you can (as always) toggle the overlay mode to a non-animated one. Finally, overlay painting now comes with a much more flexible customization interface so that you can generate lots of interesting effects without having to implement your own `kdu_region_compositor::paint_overlay' override.
d) The `kdu_region_compositor' object now offers a function which can synthesize the imagery aspects of a JPIP request to match its current configuration, over a defined region of interest on the rendering surface. This is very important, since correct synthesis of JPIP requests for complex compositions can be a very challenging matter, especially since JPIP's interpretation of resolution does not generally correspond to the resolution which will produce the highest quality rendition at a given (arbitrary) scale -- it is based on canvas coordinates, which may involve sampling factors that are not related to true resolution (in the signal processing sense).
2) There is a more robust and uniform approach to exception handling throughout Kakadu, involving a special exception type `kdu_exception' and preservation of exception codes across Java interfaces via the "kdu_jni/KduException" class. Everything is backward compatible, but there are some new guidelines for the throwing of exceptions within error handlers, which implementors are encouraged to review, the Kakadu demo applications adhere to these guidelines. As part of the overhaul of exception handling within Kakadu, close attention has been given to memory allocation, ensuring that appropriate exceptions std::bad_alloc in C++) will be thrown wherever memory allocation fails, ensuring that such exceptions are passed across thread boundaries during multi-threaded processing, and ensuring that memory allocation failure should not leave the system in a state where resources cannot be properly cleaned up after catching such an exception.
3) Enhancements to the various demo applications:
a) kdu_winshow and kdu_macshow have now completed there convergence, offering identical features in a uniform manner. Improvements have been made to: the rendering of region-of-interest overlays; the transporting of focus boxes across frame changes; the preservation of state during window duplication actions; presentation of and navigation within the metadata catalog side bar; and quite a few other things. The new arbitrary scaling features of the core workhorse `kdu_region_compositor' are now put to good use in each of these applications to produce high quality imagery under all circumstances.
b) kdu_merge offers the capability to easily merge a large number of codestreams (or other JPEG2000 compressed sources) into a single JPX/MJ2 file.
c) kdu_merge now offers a more powerful "-album" mode which creates multiple up-front splash sheets and adds a lot of metadata which can serve as a template for subsequent editing of the metadata in "kdu_winshow" or "kdu_macshow".
d) kdu_render now offers a "-scale" option and an additional demo fragment to illustrate high precsision processing with 'kdu_region_compsositor'.
e) kdu_server now properly supports case-sensitive serving of files, using a command-line switch which can be applied to change the default policy under Windows or Unix operating systems.
f) kdu_compress and kdu_expand now offer extended "-fprec" options for forcing the precision associated with the imagery which is read (kdu_compress) or written (kdu_expand). In particular, during compression, you can force the input image samples to be treated as though they had a different precision (larger or smaller than the one recorded in the input file) and you can specify that the original samples should be aligned at either the LSB position or the MSB position within the synthesized representation. Similar features are available during compression. Together, these capabilities allow you to do all kinds of useful manipulations to interpret or generate images in a manner that matches various exotic applications.
Finally, this version comes with quite a few bug fixes for the core system, as well as higher level API's and demo applications. There are some very important bug fixes for "kdu_server", for example. There are also some simple but critical bug fixes to the TIFF file I/O implementation used by the "kdu_compress" and "kdu_expand" demo apps.