Next: , Previous: , Up: Part VI Images   [Contents][Index]


37.3 Supported image types

Forms Library supports all common and not-so-common image types. For example, the supported images range from the simple 1 bit bitmap to full 24 bit RGB images. 12 bit gray scale images (common in medical imaging) are also supported.

The supported image types are denoted using the following constants, all of them (except FL_IMAGE_FLEX) using a different bit, so they can be bitwise ORed together:

FL_IMAGE_MONO,    /* 1 bit bitmaps */
FL_IMAGE_GRAY,    /* gray-scale image (8 bit) */
FL_IMAGE_GRAY16,  /* gray-scale image (9 to 16 bit) */
FL_IMAGE_CI,      /* generic color index image */
FL_IMAGE_RGB,     /* 24 bit RGB(A) image */
FL_IMAGE_PACKED,  /* 24 bit RGB(A) image. Packed storage */
FL_IMAGE_FLEX,    /* All of the above */

For the 24 bit variety another 8 bit (image->alpha and the top-most byte of the packed integer) is available for the application, perhaps storing the alpha values into it. The Forms Library does not modify or reference this extra byte.

Mono (b&w) images are stored as a colormap image with a lut of length 2.

The FL_IMAGE_FLEX type is mainly for the reading and loading routines to indicate the types they are capable of handling. For example, if you’re coding an output routine, you use FL_IMAGE_FLEX to indicate that the output routine can take any type the image. Otherwise the driver will convert the image type before handing the image over to the actual output routine.

In displaying an image of type FL_IMAGE_GRAY16, window leveling, a technique to visualize specific ranges of the data, is employed. Basically, you specify a window level (level) and a window width (wwidth) and the display function will map all pixels that fall within level-width/2 and level+width/2 linearly to the whole dynamic range of the intensities the hardware is capable of displaying. For example, if the display device can only display 256 shades of gray, level-width/2 is mapped to 0 and level+width/2 is mapped to 255, and pixels values between level-width/2 and level+width/2 are linearly mapped to values between 0 and 255. Pixel values that fall below level-width/2 are mapped to zero and those that larger than level+width/2 are mapped to 255.

Use the following routine to set the window level

int flimage_windowlevel(FL_IMAGE *im, int level, int wwidth);

The function returns 1 if window level parameters are modified, otherwise 0 is returned. Setting wwidth to zero disables window leveling. Note that if im points to a multiple image, window level parameters are changed for all images.

To obtain the image type name in string format, e.g., for reporting purposes, use the following routine

const char *flimage_type_name(int type);

To convert between different types of images, the following routine is available

int flimage_convert(FL_IMAGE *image, int newtype, int ncolors);

The parameter newtype should be one of the supported image types mentioned earlier in this section. Parameter ncolors is meaningful only if newtype is FL_IMAGE_CI. In this case, it specifies the number of colors to generate, most likely from a color quantization process. If the conversion is successful a non-negative integer is returned, otherwise a negative integaer. Depending on which quantization function is used, the number of quantized colors may not be more than 256.

To keep information loss to a minimum, flimage_convert() may elect to keep the original image in memory even if the conversion is successful. For example, converting a full color image (24 bit) into a 8 bit image and then converting back can lose much information of the image if the converting function does not keep the original image.

What this means is that the following sequence gets back the original image

/* the current image is RGB. Now we reduce the full color
   image to 8 bit color index image. The conversion routine
   will keep the 24 bit color. */

flimage_convert(image, FL_IMAGE_CI, 256);

/* Now convert back to RGB for image processing. The con-
   version routine will notice that the input image was
   originally converted from a 24bit image. Instead of
   doing the conversion, it simply retrieves the saved
   image and returns. */

flimage_convert(image, FL_IMAGE_RGB, 0);

This behavior might not always be what the application wants. To override it, you can set image->force_convert to 1 before calling the conversion routine. Upon function return the flag is reset to zero.


Next: , Previous: , Up: Part VI Images   [Contents][Index]