Used by the Raster Class to represent the contents of one pixel. More...

#include <PixelValue.h>

Public Member Functions
	PixelValue ()
	Constructs a 'PixelValue' instance from the the three provided values. More...

	PixelValue (uchar _r, uchar _g, uchar _b)
	Constructs a 'PixelValue' instance using the provided values for the color components. More...

	PixelValue (const PixelValue &pixelValue)

bool	operator!= (const PixelValue &right) const

PixelValue	operator* (double fact) const

PixelValue &	operator= (const PixelValue &right)

bool	operator== (const PixelValue &right) const

void	ToHSI (float &hue, float &sat, float &intensity) const
	Computes the equivalent HSI values; RGB -> HSI. More...

KKStr	ToStr () const
	Creates a displayable string reflecting the values of the three RGB components. More...

Static Public Member Functions
static PixelValue	FromHSI (float hue, float sat, float intensity)
	Will create an instance of PixelValue from the HSI values provided (HSI -> RGB). More...

Public Attributes
uchar	b

uchar	g

uchar	r

Static Public Attributes
static PixelValue	Aqua

static PixelValue	Black

static PixelValue	Blue

static PixelValue	Brown

static PixelValue	Cyan

static PixelValue	FireBrick

static PixelValue	Green

static PixelValue	Indigo

static PixelValue	Magenta

static PixelValue	Orange

static PixelValue	Pink

static PixelValue	Purple

static PixelValue	Red

static PixelValue	Teal

static PixelValue	Violet

static PixelValue	White

static PixelValue	Yellow

Detailed Description

Used by the Raster Class to represent the contents of one pixel.

There are several predefined colors to pick from or you can work with the individual color channels separately.

See also: Raster

Definition at line 22 of file PixelValue.h.

Constructor & Destructor Documentation

PixelValue::PixelValue ( )

Constructs a 'PixelValue' instance from the the three provided values.

Definition at line 44 of file PixelValue.cpp.

References b, g, and r.

                        :
   r (0),
   g (0),
   b (0)
 {
 }

PixelValue::PixelValue	(	uchar	_r,
		uchar	_g,
		uchar	_b
	)

Constructs a 'PixelValue' instance using the provided values for the color components.

Definition at line 60 of file PixelValue.cpp.

References b, g, and r.

Referenced by KKB::SegmentorOTSU::ClassAverageRGB(), KKB::Chart::CreateRaster(), FromHSI(), operator*(), and KKB::Raster::ThresholdInHSI().

                                                      : 
     r(_r), g(_g), b(_b)  
 {
 }

PixelValue::PixelValue ( const PixelValue & pixelValue )

Definition at line 52 of file PixelValue.cpp.

References b, g, and r.

Referenced by KKB::Chart::Series::Series().

                                                      :
     r(pixelValue.r), 
     g(pixelValue.g), 
     b(pixelValue.b)  
 {
 }

Member Function Documentation

PixelValue PixelValue::FromHSI	(	float	hue,
		float	sat,
		float	intensity
	)

static

Will create an instance of PixelValue from the HSI values provided (HSI -> RGB).

Used "http://www.codeguru.com/forum/archive/index.php/t-134892.html" for inspiration.

Parameters

[in]	hue	Angle between 0 and (2 x Pi).
[in]	sat	Saturation of color, a number between 0.0 and 1.0.
[in]	intensity	Intensity.

Definition at line 133 of file PixelValue.cpp.

References Black, and PixelValue().

Referenced by KKB::Raster::CreateColor(), and KKB::Raster::CreateColorImageFromLabels().

 {
   // Used "http://www.codeguru.com/forum/archive/index.php/t-134892.html"  for inspiration.
   if  (intensity == 0.0f) 
     return PixelValue::Black;
 
   if  (sat == 0.0f) 
   {
     // gray-scale image
     kkint32  greyValue = (kkint32)(0.5f + intensity * 255.0f);
     uchar  gv = (uchar)greyValue;
     return  PixelValue (gv, gv, gv);
   }
 
   float  domainOffset = 0.0f;
   float  red = 0.0, green = 0.0, blue = 0.0;
   if  (hue < (1.0f / 6.0f)) 
   { 
     //domainOffset = H;
     //R = I;
     //B = I * (1-S);
     //G = B + (I-B)*domainOffset*6;
     domainOffset = hue;
     red  = intensity;
     blue = intensity * (1.0f - sat);
     green = blue + (intensity - blue) * domainOffset * 6.0f;
   }
   
   else if  (hue < (2.0f / 6.0f)) 
   {
     //domainOffset = H - 1.0/6.0;
     //G = I;
     //B = I * (1-S);
     //R = G - (I-B)*domainOffset*6;
 
     // yellow domain; red ascending
     domainOffset = hue - 1.0f / 6.0f;
     green = intensity;
     blue = intensity * (1.0f - sat);
     red = green - (intensity - blue) * domainOffset * 6.0f;
   }
 
   else if  (hue < (3.0f / 6.0f))
   {
     //domainOffset = H-2.0/6;
     //G = I;
     //R = I * (1-S);
     //B = R + (I-R)*domainOffset * 6;    // green domain; blue descending
     domainOffset = hue - (2.0f / 6.0f);
     green = intensity;
     red = intensity * (1.0f - sat);
     blue = red - (intensity - red) * domainOffset * 6.0f;
   }
 
   else if  (hue < (4.0f / 6.0f))
   {
     //domainOffset = H - 3.0/6;
     //B = I;
     //R = I * (1-S);
     //G = B - (I-R) * domainOffset * 6;
     // cyan domain, green ascending
     domainOffset = hue - (3.0f / 6.0f);
     blue = intensity;
     red = intensity * (1.0f - sat);
     green = blue - (intensity - red) * domainOffset * 6.0f;
   }
 
   else if  (hue < (5.0f / 6.0f))
   {
     //domainOffset = H - 4.0/6;
     //B = I;
     //G = I * (1-S);
     //R = G + (I-G) * domainOffset * 6;
     // blue domain, red ascending
     domainOffset = hue - (4.0f / 6.0f);
     blue = intensity;
     green = intensity * (1.0f - sat);
     red = green + (intensity - green) * domainOffset * 6.0f;
   }
 
   else 
   { 
     //domainOffset = H - 5.0/6;
     //R = I;
     //G = I * (1-S);
     //B = R - (I-G) * domainOffset * 6;
     // Magenta domain, blue descending
     domainOffset = hue - (5.0f / 6.0f);
     red = intensity;
     green = intensity * (1.0f - sat);
     blue = red - (intensity - green) * domainOffset * 6.0f;
   }
 
   return  PixelValue ((uchar)(0.5f + red   * 255.0f), 
                       (uchar)(0.5f + green * 255.0f), 
                       (uchar)(0.5f + blue  * 255.0f)
                      );
 }  /* FromHSI */

bool PixelValue::operator!= ( const PixelValue & right ) const

Definition at line 95 of file PixelValue.cpp.

References b, g, and r.

 {
   return  ((r != right.r)  ||  (g != right.b)  ||  (b != right.b));
 }

PixelValue PixelValue::operator* ( double fact ) const

Will multiply the individual color channels by the right operand and return the resultant new PixelValue.

Definition at line 78 of file PixelValue.cpp.

References b, g, PixelValue(), and r.

 {
   uchar newR = (uchar)((double)r * fact + 0.5);
   uchar newG = (uchar)((double)g * fact + 0.5);
   uchar newB = (uchar)((double)b * fact + 0.5);
   return  PixelValue (newR, newG, newB);
 }

PixelValue & PixelValue::operator= ( const PixelValue & right )

Definition at line 66 of file PixelValue.cpp.

References b, g, and r.

Referenced by KKB::Raster::CreateColor(), KKB::Raster::CreateColorImageFromLabels(), and KKB::Raster::CreateColorWithBlobsLabeldByColor().

 {
   r = right.r;
   g = right.g;
   b = right.b;
   return *this;
 }

bool PixelValue::operator== ( const PixelValue & right ) const

Definition at line 88 of file PixelValue.cpp.

References b, g, and r.

 {
   return  ((r == right.r)  &&  (g == right.b)  &&  (b == right.b));
 }

void PixelValue::ToHSI	(	float &	hue,
		float &	sat,
		float &	intensity
	)		const

Computes the equivalent HSI values; RGB -> HSI.

Used "http://www.codeguru.com/forum/archive/index.php/t-134892.html" for inspiration.

Parameters

[out]	hue	Angle in radians.
[out]	sat	Saturation between 0.0 and 1.0.
[out]	intensity	Intensity between 0.0 and 1.0.

Definition at line 102 of file PixelValue.cpp.

References b, g, and r.

Referenced by KKB::Raster::ThresholdInHSI().

 {
   float  redF    = (float)r / 255.0f;
   float  greenF  = (float)g / 255.0f;
   float  blueF   = (float)b / 255.0f;
 
   if (blueF <= greenF)
   {
     // compute hue with this formula
     hue = (float)acos ((0.5 * ((redF - greenF) + (redF - blueF))) / sqrt ((pow ((redF - greenF), 2) + (redF - blueF) * (greenF - blueF))));
   }
 
   // Otherwise
   else
   {
     // compute hue with this formula
     hue = (float)(2.0f * 3.1415926535897932384626433832795 - acos ((0.5 * ((redF - greenF) + (redF - blueF)))) / sqrt ((pow ((redF - greenF), 2) + (redF - blueF) * (greenF - blueF))));
   }
 
   // compute saturation
   sat = 1 - 3 * min (min (redF, greenF), blueF) / (redF + greenF + blueF);
 
   // compute intensity
   intensity = (redF + greenF + blueF) / 3;
 }  /* ToHSI */

KKStr PixelValue::ToStr ( ) const

Creates a displayable string reflecting the values of the three RGB components.

Definition at line 237 of file PixelValue.cpp.

References b, KKB::KKStr::Concat(), g, KKB::KKStr::operator+(), KKB::operator+(), r, and KKB::StrFormatInt().

 {
   KKStr  s = "(" + KKB::StrFormatInt ((kkint32)r, "ZZ0") + ","
                  + KKB::StrFormatInt ((kkint32)g, "ZZ0") + ","
                  + KKB::StrFormatInt ((kkint32)b, "ZZ0") + ")";
   return s;
 }