COLOR(3TIFF)                                         COLOR(3TIFF)



NAME
       TIFFYCbCrToRGBInit,  TIFFYCbCrtoRGB,  TIFFCIELabToRGBInit,
       TIFFCIELabToXYZ, TIFFXYZToRGB - color conversion routines.

SYNOPSIS
       #include 

       int TIFFYCbCrToRGBInit(TIFFYCbCrToRGB *ycbcr, float *luma,
       float *refBlackWhite");"
       void TIFFYCbCrtoRGB(TIFFYCbCrToRGB *ycbcr, uint32 Y, int32
       Cb, int32 Cr, uint32 *R, uint32 *G, uint32 *B );

       int  TIFFCIELabToRGBInit(TIFFCIELabToRGB *cielab, TIFFDis-
       play *display, float *refWhite);
       void TIFFCIELabToXYZ(TIFFCIELabToRGB  *cielab,  uint32  L,
       int32 a, int32 b, float *X, float *Y, float *Z);
       void  TIFFXYZToRGB(TIFFCIELabToRGB *cielab, float X, float
       Y, float Z",uint32*"R, uint32 *G, uint32 *B);

DESCRIPTION
       TIFF supports several color spaces for  images  stored  in
       that  format. There is usually a problem of application to
       handle the data properly  and  convert  between  different
       colorspaces  for displaying and printing purposes. To sim-
       plify this task libtiff implements several  color  conver-
       sion  routines  itself. In particular, these routines used
       in TIFFRGBAImage(3TIFF) interface.

       TIFFYCbCrToRGBInit() used to initialize YCbCr to RGB  con-
       version  state. Allocating and freeing of the ycbcr struc-
       ture belongs to  programmer.   TIFFYCbCrToRGB  defined  in
       tiffio.h as

              typedef struct {                /* YCbCr->RGB support */
                      TIFFRGBValue* clamptab; /* range clamping table */
                      int*         Cr_r_tab;
                      int*         Cb_b_tab;
                      int32*       Cr_g_tab;
                      int32*       Cb_g_tab;
                      int32*        Y_tab;
              } TIFFYCbCrToRGB;

       luma is a float array of three values representing propor-
       tions of the red, green and blue in luminance, Y (see sec-
       tion  21  of  the  TIFF 6.0 specification, where the YCbCr
       images discussed).  TIFFTAG_YCBCRCOEFFICIENTS  holds  that
       values  in TIFF file.  refBlackWhite is a float array of 6
       values which specifies a pair  of  headroom  and  footroom
       image  data  values  (codes) for each image component (see
       section 20 of the TIFF 6.0 specification where the  color-
       inmetry fields discussed).  TIFFTAG_REFERENCEBLACKWHITE is
       responsible for storing these values in TIFF file. Follow-
       ing  code snippet should helps to understand the the tech-
       nique:

              float *luma, *refBlackWhite;
              uint16 hs, vs;

              /* Initialize structures */
              ycbcr = (TIFFYCbCrToRGB*)
                   _TIFFmalloc(TIFFroundup(sizeof(TIFFYCbCrToRGB), sizeof(long))
                        + 4*256*sizeof(TIFFRGBValue)
                        + 2*256*sizeof(int)
                        + 3*256*sizeof(int32));
              if (ycbcr == NULL) {
                      TIFFError("YCbCr->RGB",
                        "No space for YCbCr->RGB conversion state");
                      exit(0);
              }

              TIFFGetFieldDefaulted(tif, TIFFTAG_YCBCRCOEFFICIENTS, &luma);
              TIFFGetFieldDefaulted(tif, TIFFTAG_REFERENCEBLACKWHITE, &refBlackWhite);
              if (TIFFYCbCrToRGBInit(ycbcr, luma, refBlackWhite) < 0)
                   exit(0);

              /* Start conversion */
              uint32 r, g, b;
              uint32 Y;
              int32 Cb, Cr;

              for each pixel in image
                   TIFFYCbCrtoRGB(img->ycbcr, Y, Cb, Cr, &r, &g, &b);

              /* Free state structure */
              _TIFFfree(ycbcr);



       TIFFCIELabToRGBInit() initializes the CIE L*a*b*  1976  to
       RGB conversion state.  TIFFCIELabToRGB defined as

              #define CIELABTORGB_TABLE_RANGE 1500

              typedef struct {              /* CIE Lab 1976->RGB support */
                   int  range;              /* Size of conversion table */
                   float     rstep, gstep, bstep;
                   float     X0, Y0, Z0;         /* Reference white point */
                   TIFFDisplay display;
                   float     Yr2r[CIELABTORGB_TABLE_RANGE + 1]; /* Conversion of Yr to r */
                   float     Yg2g[CIELABTORGB_TABLE_RANGE + 1]; /* Conversion of Yg to g */
                   float     Yb2b[CIELABTORGB_TABLE_RANGE + 1]; /* Conversion of Yb to b */
              } TIFFCIELabToRGB;

       display is a display device description, declared as

              typedef struct {
                   float d_mat[3][3]; /* XYZ -> luminance matrix */
                   float d_YCR;       /* Light o/p for reference white */
                   float d_YCG;
                   float d_YCB;
                   uint32 d_Vrwr;     /* Pixel values for ref. white */
                   uint32 d_Vrwg;
                   uint32 d_Vrwb;
                   float d_Y0R;       /* Residual light for black pixel */
                   float d_Y0G;
                   float d_Y0B;
                   float d_gammaR;    /* Gamma values for the three guns */
                   float d_gammaG;
                   float d_gammaB;
              } TIFFDisplay;

       For  example,  the  one can use sRGB device, which has the
       following parameters:

              TIFFDisplay display_sRGB = {
                   {       /* XYZ -> luminance matrix */
                        {  3.2410F, -1.5374F, -0.4986F },
                        {  -0.9692F, 1.8760F, 0.0416F },
                        {  0.0556F, -0.2040F, 1.0570F }
                   },
                   100.0F, 100.0F, 100.0F, /* Light o/p for reference white */
                   255, 255, 255,      /* Pixel values for ref. white */
                   1.0F, 1.0F, 1.0F,   /* Residual light o/p for black pixel */
                   2.4F, 2.4F, 2.4F,   /* Gamma values for the three guns */
              };

       refWhite is a color temperature of  the  reference  white.
       The  TIFFTAG_WHITEPOINT  contains  the chromaticity of the
       white point of the image from where  the  reference  white
       can be calculated using following formulae:

              refWhite_Y = 100.0
              refWhite_X   =   whitePoint_x   /   whitePoint_y  *
              refWhite_Y
              refWhite_Z = (1.0 - whitePoint_x - whitePoint_y)  /
              whitePoint_y * refWhite_X

       The conversion itself performed in two steps: at the first
       one we will convert CIE L*a*b* 1976 to CIE XYZ using TIFF-
       CIELabToXYZ() routine, and at the second step we will con-
       vert CIE XYZ to RGB using  TIFFXYZToRGB().   Look  at  the
       code sample below:

              float   *whitePoint;
              float   refWhite[3];

              /* Initialize structures */
              img->cielab = (TIFFCIELabToRGB *)
                   _TIFFmalloc(sizeof(TIFFCIELabToRGB));
              if (!cielab) {
                   TIFFError("CIE L*a*b*->RGB",
                        "No space for CIE L*a*b*->RGB conversion state.");
                   exit(0);
              }

              TIFFGetFieldDefaulted(tif, TIFFTAG_WHITEPOINT, &whitePoint);
              refWhite[1] = 100.0F;
              refWhite[0] = whitePoint[0] / whitePoint[1] * refWhite[1];
              refWhite[2] = (1.0F - whitePoint[0] - whitePoint[1])
                         / whitePoint[1] * refWhite[1];
              if (TIFFCIELabToRGBInit(cielab, &display_sRGB, refWhite) < 0) {
                   TIFFError("CIE L*a*b*->RGB",
                        "Failed to initialize CIE L*a*b*->RGB conversion state.");
                   _TIFFfree(cielab);
                   exit(0);
              }

              /* Now we can start to convert */
              uint32 r, g, b;
              uint32 L;
              int32 a, b;
              float X, Y, Z;

              for each pixel in image
                   TIFFCIELabToXYZ(cielab, L, a, b, &X, &Y, &Z);
                   TIFFXYZToRGB(cielab, X, Y, Z, &r, &g, &b);

              /* Don't forget to free the state structure */
              _TIFFfree(cielab);



SEE ALSO
       libtiff(3TIFF), TIFFRGBAImage(3TIFF)