Unix/Linux Go Back    

CentOS 7.0 - man page for tiffcolor (centos section 3TIFF)

Linux & Unix Commands - Search Man Pages
Man Page or Keyword Search:   man
Select Man Page Set:       apropos Keyword Search (sections above)

COLOR(3TIFF)									     COLOR(3TIFF)

       color conversion routines.

       #include <tiffio.h>

       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,  const  TIFFDisplay  *display,  float
       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);

       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 col-
       orspaces for displaying and printing purposes. To simplify this	task  libtiff  implements
       several	color  conversion  routines itself. In particular, these routines used in TIFFRG-
       BAImage(3TIFF) interface.

       TIFFYCbCrToRGBInit() used to initialize YCbCr to  RGB  conversion  state.  Allocating  and
       freeing	of the ycbcr structure belongs to programmer.  TIFFYCbCrToRGB defined in tiffio.h

	      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 proportions of the red, green and  blue
       in luminance, Y (see section 21 of the TIFF 6.0 specification, where the YCbCr images dis-
       cussed).  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
       colorinmetry  fields  discussed).   TIFFTAG_REFERENCEBLACKWHITE is responsible for storing
       these values in TIFF file. Following code snippet should helps to understand the the tech-

	      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) {
			"No space for YCbCr->RGB conversion state");

	      TIFFGetFieldDefaulted(tif, TIFFTAG_YCBCRCOEFFICIENTS, &luma);
	      TIFFGetFieldDefaulted(tif, TIFFTAG_REFERENCEBLACKWHITE, &refBlackWhite);
	      if (TIFFYCbCrToRGBInit(ycbcr, luma, refBlackWhite) < 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 */

       TIFFCIELabToRGBInit()  initializes  the	CIE  L*a*b*  1976 to RGB conversion state.  TIFF-
       CIELabToRGB 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 TIFFCIELabToXYZ() routine, and at the second step we will convert
       CIE XYZ to RGB using TIFFXYZToRGB().  Look at the code sample below:

	      float   *whitePoint;
	      float   refWhite[3];

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

	      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.");

	      /* 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 */

       TIFFRGBAImage(3TIFF) libtiff(3TIFF),

       Libtiff library home page: http://www.remotesensing.org/libtiff/

libtiff 				December 21, 2003			     COLOR(3TIFF)
Unix & Linux Commands & Man Pages : ©2000 - 2018 Unix and Linux Forums

All times are GMT -4. The time now is 07:48 AM.