Next: Creating Images, Previous: The FL_IMAGE Structure, Up: Part VI Images [Contents][Index]
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: Creating Images, Previous: The FL_IMAGE Structure, Up: Part VI Images [Contents][Index]