Re: [Vxl-users] 10 bit image support

[Amitha P. <ami...@us...>]

On Mon 17 Sep 2007, Wouter Klouwen wrote:
> we're trying to use VXL for the purpose of mostly image I/O. Most pixel 
> formats seem to be supported, however we would like to read 10 bit RGB 
> images.
> We use another library to display the images. The display library uses 
> the trick of packing the 10 bit RGB into 32 bit greyscale (with 2 bits 
> left over for good luck).
> VIL doesn't seem to support this approach terribly well, from what I can 
> deduce from the documentation.

You are right: vil doesn't support dense and non-uniform pixel storage
*in memory* very well.  In it's defense, though, the purpose of vil is
to store and manage images for image processing applications.  In this
context, quick access to individual pixels is often assumed by the
algorithms.  Dense storage implies that accessing the value of a pixel
is more complex than simply indexing a memory location.  (Some detail
below of what I think you'd need to do to support such mechanism.)

> It appears as if one is forced to keep 
> greyscale data in a vil_rgb, which means a lot of conversion.

vil_rgb is not necessary.  Greyscale and multi-component images can be
represented as multi-"plane" vil_image_view<vxl_byte>s, so that
img(i,j,0), img(i,j,1), img(i,j,2) are the RGB components of the pixel
at (i,j).  This indexing scheme does *not* imply a planar storage of
the component data in memory.

> Does anyone have any experience with reading 10 bit RGB data, and if so, 
> how did they do it?

We generally store 10- and 12-bit pixels in vil_image_view<uint16>.
Wastes some memory, but makes life much easier elsewhere.

> Is there a way to have 32bit greyscale pixel data?

You would have to do essentially what vector<bool> does.  You'd have
to define a pixel type for the packed data (say
vil_pixel_format_packed), then specialize vil_image_view<T> for that
type, and write operator() to return a special type that understood
the particular packing structure.

If your type is always 10-bit RGB packed into 32-bits, life can be a
little more simple: define a pixel structure like

   struct rgb_packed_10bit
   {
      vxl_uint32 padding : 2;
      vxl_uint32 R : 10;
      vxl_uint32 G : 10;
      vxl_uint32 B : 10;
H   };

and use that as the pixel type.  You have to understand the endian
issues on your platform and all that, of course.  You may also want to
extend the various vil_convert routines to understand the new pixel
type.

Look at vgui/vgui_pixel.h for some examples of how similar structures
are used to deal with different OpenGL framebuffer formats.

Amitha.