KKB::Raster Class Reference

A class that is used by to represent a single image in memory. More...

#include <Raster.h>

Public Types
typedef Raster const	RasterConst
typedef RasterConst *	RasterConstPtr
typedef Raster *	RasterPtr

Public Member Functions
	Raster ()
	Raster (const Raster &_raster)
	Copy Constructor. More...
	Raster (kkint32 _height, kkint32 _width)
	Constructs a blank image with given dimensions; all pixels will be initialized to 0. More...
	Raster (kkint32 _height, kkint32 _width, bool _color)
	Constructs a blank image with given dimensions. More...
	Raster (const BmpImage &_bmpImage)
	Constructs a Raster from a BMP image loaded from disk. More...
	Raster (const Raster &_raster, kkint32 _row, kkint32 _col, kkint32 _height, kkint32 _width)
	Constructs a new Raster using a subset of the specified Raster as its source. The dimensions of the resultant raster will be '_height', and '_width'. More...
	Raster (const Raster &_raster, MaskTypes _mask, kkint32 _row, kkint32 _col)
	Constructs a Raster that will be the same size as the specified '_mask' with the top left specified by '_row' and '_col'. More...
	Raster (const KKStr &fileName, bool &validFile)
	Constructs a Raster image from by reading an existing image File such as a BMP file. More...
	Raster (kkint32 _height, kkint32 _width, uchar *_Data, uchar **_Rows)
	Construct a raster object that will utilize a image already in memory. More...
	Raster (kkint32 _height, kkint32 _width, const uchar *_Data)
	Construct a Raster object using provided raw data. More...
	Raster (kkint32 _height, kkint32 _width, const uchar *_redChannel, const uchar *_greenChannel, const uchar *_blueChannel)
	Construct a Color Raster object using provided raw data,. More...
virtual	~Raster ()
virtual RasterPtr	AllocateARasterInstance (kkint32 height, kkint32 width, bool color) const
virtual RasterPtr	AllocateARasterInstance (const Raster &r) const
virtual RasterPtr	AllocateARasterInstance (const Raster &_raster, kkint32 _row, kkint32 _col, kkint32 _height, kkint32 _width) const
bool	AreThereEdgePixels (kkint32 edgeWidth)
	returns true if there are any foreground pixels within 'edgeWidth' pixels of the top, bottom, left, or right edges of the image. More...
bool	BackgroundPixel (kkint32 row, kkint32 col) const
uchar	BackgroundPixelTH () const
void	BackgroundPixelTH (uchar _backgroundPixelTH)
uchar	BackgroundPixelValue () const
void	BackgroundPixelValue (uchar _backgroundPixelValue)
RasterPtr	BandPass (float lowerFreqBound, float upperFreqBound, bool retainBackground)
	Returns a image that is the result of a BandPass using Fourier Transforms. More...
RasterPtr	BinarizeByThreshold (uchar min, uchar max) const
kkint32	BlobId (kkint32 row, kkint32 col) const
	Return the ID of the blob that the specified pixel location belongs to. More...
uchar **	Blue () const
uchar *	BlueArea () const
kkint32	CalcArea ()
void	CalcAreaAndIntensityFeatures (kkint32 &area, float &weightedSize, kkuint32 intensityHistBuckets[8], kkint32 &areaWithWhiteSpace, kkuint32 intensityHistBucketsWhiteSpace[8]) const
	Calculates both Intensity Histograms, one not including internal background pixels and one with plus size and weighted size. More...
void	CalcAreaAndIntensityFeatures (kkint32 &area, float &weightedSize, kkuint32 intensityHistBuckets[8]) const
	Calculates both Intensity Histograms, one not including internal background pixels and one with plus size and weighted size. More...
void	CalcAreaAndIntensityFeatures16 (kkint32 &area, float &weighedSize, kkuint32 intensityHistBuckets[16])
void	CalcAreaAndIntensityHistogram (kkint32 &area, kkuint32 intensityHistBuckets[8]) const
	Calculates the occurrence of different intensity levels. More...
void	CalcAreaAndIntensityHistogramWhite (kkint32 &area, kkuint32 intensityHistBuckets[8])
	Calculates a Intensity Histogram including Background pixels in the image. More...
void	CalcCentroid (kkint32 &size, kkint32 &weight, float &rowCenter, float &colCenter, float &rowCenterWeighted, float &colCenterWeighted) const
void	CalcOrientationAndEigerRatio (float &eigenRatio, float &orientationAngle)
float	CalcWeightedArea () const
double	CenMoment (kkint32 colMoment, kkint32 rowMoment, double centerCol, double centerRow) const
float	CenMomentWeighted (kkint32 p, kkint32 q, float ew, float eh) const
void	CentralMoments (float features[9]) const
	returns in 'features' the 8 central moments as defined by Hu plus eccentricity in the eight bucket. More...
void	CentralMomentsWeighted (float features[9]) const
	Similar to 'CentralMoments' except each pixel position is weighted by its intensity value. More...
float	CentroidCol () const
float	CentroidRow () const
void	Closing ()
void	Closing (MaskTypes mask)
bool	Color () const
void	ComputeCentralMoments (kkint32 &foregroundPixelCount, float &weightedPixelCount, float centralMoments[9], float centralMomentsWeighted[9]) const
	Computes central moments; one set where each pixel is treated as 1 or 0(Foreground/Background) and the other where each pixel is weighted by intensity value. More...
void	ConnectedComponent (uchar connectedComponentDist)
void	ConnectedComponent8Conected ()
RasterPtr	CreateColor () const
RasterPtr	CreateColorImageFromLabels ()
	Produces a color image using the 'greenArea' channel, assuming that each unique value will be assigned a unique color. More...
RasterPtr	CreateColorWithBlobsLabeldByColor (BlobListPtr blobs)
	Returns image where each blob is labeled with a different color. More...
RasterPtr	CreateDilatedRaster () const
RasterPtr	CreateDilatedRaster (MaskTypes mask) const
RasterPtr	CreateErodedImage (MaskTypes mask) const
RasterPtr	CreateFromOrginalImageWithSpecifidBlobsOnly (RasterPtr origImage, BlobListPtr blobs)
	Returns a copy of 'origImage' where only the blobs specified in 'blobs' are copied over. More...
RasterPtr	CreateGaussianSmoothedImage (float sigma) const
RasterPtr	CreateGrayScale () const
RasterPtr	CreateGrayScaleKLT () const
	Creates a image using a KLT Transform with the goal of weighting in favor the color channels with greatest amount of variance. More...
RasterPtr	CreateGrayScaleKLTOnMaskedArea (const Raster &mask) const
	Same as 'CreateKLT' except it will only take into account pixels specified by the 'mask' image. More...
RasterPtr	CreateSmoothedMediumImage (kkint32 maskSize) const
RasterPtr	CreateSmoothImage (kkint32 maskSize=3) const
PointListPtr	DeriveImageLength () const
void	Dilation ()
void	Dilation (RasterPtr dest) const
void	Dilation (MaskTypes mask)
void	Dilation (RasterPtr dest, MaskTypes mask) const
void	Dilation (MorphOp::StructureType _structure, kkuint16 _structureSize, kkint32 _foregroundCountTH)
kkint32	Divisor () const
void	Divisor (kkint32 _divisor)
void	DrawCircle (const Point &point, kkint32 radius, const PixelValue &color)
	Draw a circle who's center is at 'point' and radius in pixels is 'radius' using color 'color'. More...
void	DrawCircle (float centerRow, float centerCol, float radius, const PixelValue &pixelValue)
void	DrawCircle (float centerRow, float centerCol, float radius, float startAngle, float endAngle, const PixelValue &pixelValue)
void	DrawConnectedPointList (Point offset, const PointList &borderPixs, const PixelValue &pixelValue, const PixelValue &linePixelValue)
void	DrawDot (const Point &point, const PixelValue &color, kkint32 size)
void	DrawFatLine (Point startPoint, Point endPoint, PixelValue pv, float alpha)
void	DrawGrid (float pixelsPerMinor, kkuint32 minorsPerMajor, const PixelValue &hashColor, const PixelValue &gridColor)
void	DrawLine (kkint32 bpRow, kkint32 bpCol, kkint32 epRow, kkint32 epCol)
void	DrawLine (kkint32 bpRow, kkint32 bpCol, kkint32 epRow, kkint32 epCol, uchar pixelVal)
void	DrawLine (const Point &beginPoint, const Point &endPoint, uchar pixelVal)
void	DrawLine (const Point &beginPoint, const Point &endPoint, const PixelValue &pixelVal)
void	DrawLine (kkint32 bpRow, kkint32 bpCol, kkint32 epRow, kkint32 epCol, uchar r, uchar g, uchar b)
void	DrawLine (kkint32 bpRow, kkint32 bpCol, kkint32 epRow, kkint32 epCol, uchar r, uchar g, uchar b, float alpha)
void	DrawLine (kkint32 bpRow, kkint32 bpCol, kkint32 epRow, kkint32 epCol, PixelValue pixelVal)
void	DrawLine (kkint32 bpRow, kkint32 bpCol, kkint32 epRow, kkint32 epCol, PixelValue pixelVal, float alpha)
void	DrawPointList (const PointList &borderPixs, const PixelValue &pixelValue)
void	DrawPointList (Point offset, const PointList &borderPixs, const PixelValue &pixelValue)
void	DrawPointList (const PointList &borderPixs, uchar redVal, uchar greenVal, uchar blueVal)
void	DrawPointList (Point offset, const PointList &borderPixs, uchar redVal, uchar greenVal, uchar blueVal)
void	Edge ()
	reduces image to edge pixels only. More...
void	Edge (RasterPtr dest)
void	ErodeSpurs ()
	removes spurs from image. More...
void	Erosion ()
void	Erosion (MaskTypes mask)
void	Erosion (MorphOp::StructureType _structure, kkuint16 _structureSize, kkint32 _backgroundCountTH)
void	Erosion (RasterPtr dest) const
	Place into destination a eroded version of this instances image. More...
void	Erosion (RasterPtr dest, MaskTypes mask) const
void	ErosionBoundary (MaskTypes mask, kkint32 blobrowstart, kkint32 blobrowend, kkint32 blobcolstart, kkint32 blobcolend)
void	ErosionChanged (MaskTypes mask, kkint32 row, kkint32 col)
void	ErosionChanged1 (MaskTypes mask, kkint32 row, kkint32 col)
RasterPtr	ExtractABlob (const BlobPtr blob) const
	Extracts a specified blob from this image; useful to extract individual detected blobs. More...
RasterPtr	ExtractABlobTightly (const BlobPtr blob, kkint32 padding) const
	Extracts a specified blob from this image into a tightly bounded image. More...
BlobListPtr	ExtractBlobs (kkint32 dist)
	Will extract a list of connected components from this instance. More...
RasterPtr	ExtractChannel (ColorChannels channel)
	Will return a gray-scale image consisting of the specified color channel only. More...
RasterPtr	ExtractUsingMask (RasterPtr mask)
	Extracts the pixel locations where the 'mask' images pixel location is a foreground pixel. More...
RasterPtr	FastFourier () const
RasterPtr	FastFourierKK () const
const KKStr &	FileName () const
void	FileName (const KKStr &_fileName)
void	FillBlob (RasterPtr origImage, BlobPtr blob, PixelValue color)
	Will paint the specified blob with the specified color. More...
void	FillHole ()
void	FillHole (RasterPtr mask)
	Fills holes in the image using the 'mask' raster as a work area. More...
void	FillRectangle (kkint32 tlRow, kkint32 tlCol, kkint32 brRow, kkint32 brCol, const PixelValue &fillColor)
void	FindBoundingBox (kkint32 &tlRow, kkint32 &tlCol, kkint32 &brRow, kkint32 &brCol) const
RasterPtr	FindMagnitudeDifferences (const Raster &r)
	Returns an image that reflects the differences between this image and the image supplied in the parameter. More...
void	FollowContour (float countourFreq[5]) const
bool	ForegroundPixel (kkint32 row, kkint32 col) const
kkint32	ForegroundPixelCount () const
void	ForegroundPixelCount (kkint32 _foregroundPixelCount)
uchar	ForegroundPixelValue () const
void	ForegroundPixelValue (uchar _foregroundPixelValue)
void	FourierExtractFeatures (float fourierFeatures[5]) const
float *	FourierMagArea () const
uchar	GetPixelValue (kkint32 row, kkint32 col) const
void	GetPixelValue (kkint32 row, kkint32 col, uchar &r, uchar &g, uchar &b) const
void	GetPixelValue (kkint32 row, kkint32 col, PixelValue &p) const
uchar	GetPixelValue (ColorChannels channel, kkint32 row, kkint32 col) const
uchar **	GetSubSet (uchar **_src, kkint32 _row, kkint32 _col, kkint32 _height, kkint32 _width) const
	Returns back a two dimension array that is a copy of the specified region in the image. More...
uchar **	Green () const
uchar *	GreenArea () const
RasterPtr	HalfSize ()
kkint32	Height () const
HistogramPtr	Histogram (ColorChannels channel) const
RasterPtr	HistogramEqualizedImage () const
RasterPtr	HistogramEqualizedImage (HistogramPtr equalizedHistogram) const
HistogramPtr	HistogramGrayscale () const
RasterPtr	HistogramGrayscaleImage () const
RasterPtr	HistogramImage (ColorChannels channel) const
void	Initialize (kkint32 _height, kkint32 _width, uchar *_Data, uchar **_Rows, bool _takeOwnership)
	Sets an existing instance to specific Raster Data of a image. More...
void	Initialize (kkint32 _height, kkint32 _width, uchar *_redArea, uchar **_red, uchar *_greenArea, uchar **_green, uchar *_blueArea, uchar **_blue, bool _takeOwnership)
	Sets an existing instance to specific Raster Data of a image. More...
uchar	MaxPixVal () const
void	MaxPixVal (uchar _maxPixVal)
kkint32	MemoryConsumedEstimated () const
void	Opening ()
void	Opening (MaskTypes mask)
RasterPtr	Padded (kkint32 padding)
void	PaintFatPoint (kkint32 row, kkint32 col, const PixelValue pv, float alpha)
void	PaintPoint (kkint32 row, kkint32 col, const PixelValue &pv, float alpha)
uchar **	Red () const
uchar *	RedArea () const
RasterPtr	ReduceByEvenMultiple (kkint32 multiple) const
RasterPtr	ReduceByFactor (float factor) const
void	ReduceToMostCompleteBlob (uchar connectedComponentDist)
	Locates most complete blob; that is the one with the largest (Height x Width); and removes all other images from the blob. More...
void	ReSize (kkint32 _height, kkint32 _width, bool _color)
	Lets you resize the raster dimensions; old image data will be lost. More...
RasterPtr	ReversedImage ()
void	ReverseImage ()
RasterPtr	Rotate (float turnAngle)
Point	RotateDerivePreRotatedPoint (kkint32 height, kkint32 width, Point &rotatedPoint, float turnAngle) const
uchar **	Rows () const
RasterPtr	SegmentImage (bool save=false)
void	SetPixelValue (const Point &point, const PixelValue &pixVal)
void	SetPixelValue (kkint32 row, kkint32 col, uchar pixVal)
void	SetPixelValue (kkint32 row, kkint32 col, const PixelValue &pixVal)
void	SetPixelValue (kkint32 row, kkint32 col, uchar r, uchar g, uchar b)
void	SetPixelValue (ColorChannels channel, kkint32 row, kkint32 col, uchar pixVal)
uchar *	SimpleCompression (kkuint32 &buffLen) const
	Compresses the image in Raster using a simple Run length algorithm and returns a pointer to compressed data. More...
RasterPtr	SobelEdgeDetector () const
RasterListPtr	SplitImageIntoEqualParts (kkint32 numColSplits, kkint32 numRowSplits) const
RasterPtr	StreatchImage (float rowFactor, float colFactor) const
RasterPtr	SwapQuadrants () const
void	TakeOwnershipOfAnotherRastersData (Raster &otherRaster)
	Will take ownership of 'otherRaster' raster dynamically allocated data and copy its non dynamically allocated data. More...
RasterPtr	ThinContour () const
RasterPtr	ThresholdInHSI (float thresholdH, float thresholdS, float thresholdI, float distance, const PixelValue &flagValue)
RasterPtr	TightlyBounded (kkuint32 borderPixels) const
const KKStr &	Title () const
void	Title (const KKStr &_title)
RasterPtr	ToColor () const
uchar *	ToCompressor (kkuint32 &compressedBuffLen) const
	Compresses the image in Raster using zlib library and returns a pointer to compressed data. More...
kkint32	TotalBackgroundPixels () const
kkint32	TotPixels () const
RasterPtr	Transpose () const
void	WeOwnRasterData (bool _weOwnRasterData)
void	WhiteOutBackground ()
	Sets all pixels that are in the Background Range ov values to BackgroundPixelValue. More...
kkint32	Width () const

Static Public Member Functions
static MatrixPtr	BuildGaussian2dKernel (float sigma)
	Builds a 2d Gaussian kernel. More...
static RasterPtr	CreatePaddedRaster (BmpImage &image, kkint32 padding)
static RasterPtr	FromCompressor (const uchar *compressedBuff, kkuint32 compressedBuffLen)
	Creates a new instance of Raster object from zLib compressed data. More...
static RasterPtr	FromSimpleCompression (const uchar *compressedBuff, kkuint32 compressedBuffLen)
	Creates a raster from a compressedBuff created by 'SimpleCompression'. More...
static void	PrintOutListOfAllocatedrasterInstances ()

Static Protected Member Functions
static void	AddRasterInstance (const RasterPtr r)
static void	FinalCleanUp ()
static void	Initialize ()
static void	RemoveRasterInstance (const RasterPtr r)

Protected Attributes
uchar	backgroundPixelTH
uchar	backgroundPixelValue
kkint32 **	blobIds
uchar **	blue
uchar *	blueArea
float	centroidCol
float	centroidRow
bool	color
kkint32	divisor
KKStr	fileName
kkint32	foregroundPixelCount
uchar	foregroundPixelValue
float **	fourierMag
float *	fourierMagArea
uchar **	green
uchar *	greenArea
kkint32	height
uchar	maxPixVal
uchar **	red
uchar *	redArea
KKStr	title
kkint32	totPixels
bool	weOwnRasterData
kkint32	width

Static Protected Attributes
static std::map< RasterPtr, RasterPtr >	allocatedRasterInstances
	Supports the tracking down of memory leaks in Raster; it will be called every time a new instance of a 'Raster' object is created. More...
static volatile GoalKeeperPtr	goalKeeper = NULL
static volatile bool	rasterInitialized = false

Detailed Description

A class that is used by to represent a single image in memory.

This class supports morphological operations and other tasks and can handle either Gray-scale or Color. The default is Gray-scale unless otherwise specified. Each color channel will be allocated as one continuous block of memory. If the image is only gray-scale the Green Channel (G) will be used leaving the Red and Blue channels set to NULL. Access to individual pixels through is through methods that will ensure memory integrity. If required can also access the pixel data directly in memory. Each channel can be accessed as a one or two dimensional array. For example the green channel can be accesses as either "GreenArea ()" which returns a pointer to a one dimensional array or "Green ()" which returns a two dimensional array. The imagery is stored in the one dimensional array while the two dimensional is a list of pointers to the beginning of each row.

See also

Blob

ContourFollower

ConvexHull

PixelValue

Point

PointList

RasterList()

Definition at line 108 of file Raster.h.

Member Typedef Documentation

typedef Raster const KKB::Raster::RasterConst

Definition at line 112 of file Raster.h.

typedef RasterConst* KKB::Raster::RasterConstPtr

Definition at line 113 of file Raster.h.

typedef Raster* KKB::Raster::RasterPtr

Definition at line 111 of file Raster.h.

Constructor & Destructor Documentation

Raster::Raster

(

)

Definition at line 287 of file Raster.cpp.

References backgroundPixelTH, backgroundPixelValue, blobIds, blue, blueArea, centroidCol, centroidRow, color, fileName, foregroundPixelCount, foregroundPixelValue, fourierMag, fourierMagArea, green, greenArea, height, KKB::KKStr::KKStr(), maxPixVal, red, redArea, title, totPixels, weOwnRasterData, and width.

               :
  backgroundPixelValue (0),
  backgroundPixelTH    (31),
  blobIds              (NULL),
  centroidCol          (0.0f),
  centroidRow          (0.0f),
  color                (false),
  fileName             (),
  foregroundPixelCount (0),
  foregroundPixelValue (255),
  fourierMag           (NULL),
  fourierMagArea       (NULL),
  height               (0),
  maxPixVal            (0),
  title                (),
  totPixels            (0),
  weOwnRasterData      (true),
  width                (0),

  redArea              (NULL),
  greenArea            (NULL),
  blueArea             (NULL),

  red                  (NULL),
  green                (NULL),
  blue                 (NULL)
{
}

Raster::Raster

(

const Raster &

_raster

)

Copy Constructor.

Definition at line 460 of file Raster.cpp.

References AddRasterInstance(), backgroundPixelTH, backgroundPixelValue, blobIds, blue, blueArea, centroidCol, centroidRow, color, divisor, fileName, foregroundPixelCount, foregroundPixelValue, fourierMag, fourierMagArea, green, greenArea, height, KKB::KKException::KKException(), KKB::KKStr::KKStr(), maxPixVal, red, redArea, title, totPixels, weOwnRasterData, and width.

Referenced by AllocateARasterInstance(), CalcAreaAndIntensityFeatures(), CalcAreaAndIntensityHistogramWhite(), CreateColor(), Edge(), ErodeSpurs(), Erosion(), ErosionBoundary(), ErosionChanged(), ErosionChanged1(), FillHole(), KKB::MorphOpDilation::PerformOperation(), KKB::MorphOpErosion::PerformOperation(), KKB::MorphOpMaskExclude::PerformOperation(), KKB::SaveImageInverted(), KKB::SegmentorOTSU::SegmentImage(), and KKB::SegmentorOTSU::SegmentMaskedImage().

                                     :

  backgroundPixelValue  (_raster.backgroundPixelValue),
  backgroundPixelTH     (_raster.backgroundPixelTH),
  blobIds               (NULL),
  centroidCol           (_raster.centroidCol),
  centroidRow           (_raster.centroidRow),
  color                 (_raster.color),
  divisor               (1),
  fileName              (_raster.fileName),
  foregroundPixelCount  (_raster.foregroundPixelCount),
  foregroundPixelValue  (_raster.foregroundPixelValue),
  fourierMag            (NULL),
  fourierMagArea        (NULL),
  height                (_raster.height),
  maxPixVal             (_raster.maxPixVal),
  title                 (),
  totPixels             (_raster.totPixels),
  weOwnRasterData       (true),
  width                 (_raster.width),

  redArea          (NULL),
  greenArea        (NULL),
  blueArea         (NULL),

  red              (NULL),
  green            (NULL),
  blue             (NULL)

{
  AddRasterInstance (this);

  AllocateImageArea ();
  if  (!greenArea)  throw KKException ("Raster::Raster  Failed to allocate 'greenArea'.");
  memcpy (greenArea, _raster.greenArea, totPixels);

  if  (color)
  {
    if  (!redArea)   throw KKException("Raster::Raster  Allocation of 'redArea'  failed.");
    if  (!blueArea)  throw KKException("Raster::Raster  Allocation of 'blueArea' failed.");
    memcpy (redArea,  _raster.redArea,  totPixels);
    memcpy (blueArea, _raster.blueArea, totPixels);
  }

  if  (_raster.fourierMagArea)
  {
    AllocateFourierMagnitudeTable ();
    if  (!fourierMagArea)  throw KKException ("Raster::Raster  Allocation of 'fourierMagArea' failed.");
    memcpy (fourierMagArea, _raster.fourierMagArea, sizeof (float) * totPixels);
  }
}

Raster::Raster	(	kkint32	_height,
		kkint32	_width
	)

Constructs a blank image with given dimensions; all pixels will be initialized to 0.

When working with images pixel value of '0' = Background and '255'= foreground. The green channel will be used to represent the value. When these raster images are saved to a image file such as a BMP file the pixel value of 0 will point to the color value of (255, 255, 255) and pixel value 255 will point to the color value of (0, 0, 0). This way when displaying the image background will appear as white.

Definition at line 318 of file Raster.cpp.

References AddRasterInstance(), backgroundPixelTH, backgroundPixelValue, blobIds, blue, blueArea, centroidCol, centroidRow, color, divisor, fileName, foregroundPixelCount, foregroundPixelValue, fourierMag, fourierMagArea, green, greenArea, height, KKB::KKStr::KKStr(), maxPixVal, red, redArea, title, totPixels, weOwnRasterData, and width.

Referenced by KKB::Histogram::CreateGraph(), FastFourier(), KKB::ConvexHull::Filter(), and KKB::MorphOpBinarize::PerformOperation().

                :

  backgroundPixelValue (0),
  backgroundPixelTH    (31),
  blobIds              (NULL),
  centroidCol          (0.0f),
  centroidRow          (0.0f),
  color                (false),
  divisor              (1),
  fileName             (),
  foregroundPixelCount (0),
  foregroundPixelValue (255),
  fourierMag           (NULL),
  fourierMagArea       (NULL),
  height               (_height),
  maxPixVal            (0),
  title                (),
  totPixels            (_height * _width),
  weOwnRasterData      (true),
  width                (_width),

  redArea              (NULL),
  greenArea            (NULL),
  blueArea             (NULL),

  red                  (NULL),
  green                (NULL),
  blue                 (NULL)

{
  AddRasterInstance (this);
  AllocateImageArea ();
}

Raster::Raster	(	kkint32	_height,
		kkint32	_width,
		bool	_color
	)

Constructs a blank image with given dimensions.

The third parameter determines whether it will be a color or image, If a Color image then all three color channel will be set to = 255 which stands for white. If the green channel will be set to 0.

Definition at line 356 of file Raster.cpp.

References AddRasterInstance(), backgroundPixelTH, backgroundPixelValue, blobIds, blue, blueArea, centroidCol, centroidRow, color, divisor, fileName, foregroundPixelCount, foregroundPixelValue, fourierMag, fourierMagArea, green, greenArea, height, KKB::KKStr::KKStr(), maxPixVal, red, redArea, title, totPixels, weOwnRasterData, and width.

Referenced by AllocateARasterInstance(), CreateColor(), CreatePaddedRaster(), KKB::Chart::CreateRaster(), ExtractUsingMask(), FindMagnitudeDifferences(), FromCompressor(), FromSimpleCompression(), KKB::MorphOpStretcher::PerformOperation(), KKB::MorphOpMaskExclude::PerformOperation(), KKB::ReadImagePGM(), KKB::ReadImagePPM(), KKB::SegmentorOTSU::SegmentImage(), KKB::SegmentorOTSU::SegmentMaskedImage(), and Transpose().

                :

  backgroundPixelValue (0),
  backgroundPixelTH    (31),
  blobIds              (NULL),
  centroidCol          (0.0f),
  centroidRow          (0.0f),
  color                (_color),
  divisor              (1),
  fileName             (),
  foregroundPixelCount (0),
  foregroundPixelValue (255),
  fourierMag           (NULL),
  fourierMagArea       (NULL),
  height               (_height),
  maxPixVal            (0),
  title                (),
  totPixels            (_height * _width),
  weOwnRasterData      (true),
  width                (_width),

  redArea              (NULL),
  greenArea            (NULL),
  blueArea             (NULL),

  red                  (NULL),
  green                (NULL),
  blue                 (NULL)

{
  AddRasterInstance (this);
  if  (color)
  {
    backgroundPixelValue = 255;
    foregroundPixelValue = 0;
    backgroundPixelTH    = 255 - 31;
  }

  AllocateImageArea ();
}

Raster::Raster

(

const BmpImage &

_bmpImage

)

Constructs a Raster from a BMP image loaded from disk.

If BMP Image is a gray-scale value pixel values will be reversed. See description of constructor.

If BMP Image is a gray-scale value pixel values will be reversed. See description of gray-scale constructor.

Definition at line 405 of file Raster.cpp.

References AddRasterInstance(), backgroundPixelTH, backgroundPixelValue, blobIds, blue, blueArea, KKB::BmpImage::BlueRow(), centroidCol, centroidRow, KKB::BmpImage::Color(), color, divisor, KKB::BmpImage::FileName(), fileName, foregroundPixelCount, foregroundPixelValue, fourierMag, fourierMagArea, green, greenArea, KKB::BmpImage::Height(), height, KKB::BmpImage::ImageRow(), KKB::KKStr::KKStr(), maxPixVal, red, redArea, KKB::BmpImage::RedRow(), title, totPixels, weOwnRasterData, KKB::BmpImage::Width(), and width.

Referenced by KKB::ReadImage().

                                         :

  backgroundPixelValue  (0),
  backgroundPixelTH     (31),
  blobIds               (NULL),
  centroidCol           (0.0f),
  centroidRow           (0.0f),
  color                 (false),
  divisor               (1),
  fileName              (_bmpImage.FileName ()),
  foregroundPixelCount  (0),
  foregroundPixelValue  (255),
  fourierMag            (NULL),
  fourierMagArea        (NULL),
  height                (_bmpImage.Height ()),
  maxPixVal             (0),
  title                 (),
  totPixels             (_bmpImage.Height () * _bmpImage.Width ()),
  weOwnRasterData       (true),
  width                 (_bmpImage.Width ()),

  redArea               (NULL),
  greenArea             (NULL),
  blueArea              (NULL),

  red                   (NULL),
  green                 (NULL),
  blue                  (NULL)

{
  AddRasterInstance (this);
  color = _bmpImage.Color ();
  AllocateImageArea ();

  kkint32  row;

  for  (row = 0; row < height; row++)
  {
    const uchar* imageRow = _bmpImage.ImageRow (row);
    memcpy (green[row], imageRow, width);
    if  (color)
    {
      const uchar*  blueRow = _bmpImage.BlueRow (row);
      memcpy (blue[row], blueRow, width);

      const uchar*  redRow = _bmpImage.RedRow (row);
      memcpy (red[row], redRow, width);
    }
  }
}

Raster::Raster	(	const Raster &	_raster,
		kkint32	_row,
		kkint32	_col,
		kkint32	_height,
		kkint32	_width
	)

Constructs a new Raster using a subset of the specified Raster as its source. The dimensions of the resultant raster will be '_height', and '_width'.

Parameters

_raster	Source Raster
_row	Starting Row in '_raster' to copy from.
_col	Starting Col in '_raster' to copy from.
_height	Height of resultant raster. Will start from '_row'
_width	Width of resultant raster.

Definition at line 514 of file Raster.cpp.

References AddRasterInstance(), backgroundPixelTH, backgroundPixelValue, blobIds, blue, blueArea, centroidCol, centroidRow, color, divisor, fileName, foregroundPixelCount, foregroundPixelValue, fourierMag, fourierMagArea, GetSubSet(), green, greenArea, height, KKB::KKStr::KKStr(), maxPixVal, red, redArea, title, totPixels, weOwnRasterData, and width.

Referenced by AllocateARasterInstance(), and SplitImageIntoEqualParts().

                :

  backgroundPixelValue (_raster.backgroundPixelValue),
  backgroundPixelTH    (_raster.backgroundPixelTH),
  blobIds              (NULL),
  centroidCol          (-1.0f),
  centroidRow          (-1.0f),
  color                (_raster.color),
  divisor              (1),
  fileName             (),
  foregroundPixelCount (0),
  foregroundPixelValue (_raster.foregroundPixelValue),
  fourierMag           (NULL),
  fourierMagArea       (NULL),
  height               (_height),
  maxPixVal            (0),
  title                (),
  totPixels            (_height * _width),
  weOwnRasterData      (true),
  width                (_width),

  redArea   (NULL),
  greenArea (NULL),
  blueArea  (NULL),

  red       (NULL),
  green     (NULL),
  blue      (NULL)

{
  AddRasterInstance (this);

  green = _raster.GetSubSet (_raster.green, _row, _col, _height, _width);
  greenArea = green[0];

  if  (color)
  {
    red = _raster.GetSubSet (_raster.red, _row, _col, _height, _width);
    redArea = red[0];

    blue = _raster.GetSubSet (_raster.blue, _row, _col, _height, _width);
    blueArea = blue[0];
  }
}

Raster::Raster	(	const Raster &	_raster,
		MaskTypes	_mask,
		kkint32	_row,
		kkint32	_col
	)

Constructs a Raster that will be the same size as the specified '_mask' with the top left specified by '_row' and '_col'.

The Height and Width of the resultant image will come from the bias of the specified mask. The Image data will come from the specified raster using '_row' and '_col' to specify the top left column.

Parameters

[in]	_raster	Source Raster to extract data from.
[in]	_mask	Used to derive height and with of resultant image.
[in]	_row	Starting row where image data is to be extracted from.
[in]	_col	Starting column where image data is to be extracted from.

See also

MorphOp::MaskTypes

Definition at line 566 of file Raster.cpp.

References AddRasterInstance(), backgroundPixelTH, backgroundPixelValue, KKB::MorphOp::Biases(), blobIds, blue, blueArea, centroidCol, centroidRow, color, divisor, fileName, foregroundPixelCount, foregroundPixelValue, fourierMag, fourierMagArea, GetSubSet(), green, greenArea, height, KKB::KKStr::KKStr(), maxPixVal, red, redArea, title, totPixels, weOwnRasterData, and width.

                :

  backgroundPixelValue (_raster.backgroundPixelValue),
  backgroundPixelTH    (_raster.backgroundPixelTH),
  blobIds              (NULL),
  centroidCol          (-1),
  centroidRow          (-1),
  color                (false),
  divisor              (1),
  fileName             (),
  foregroundPixelCount (0),
  foregroundPixelValue (_raster.foregroundPixelValue),
  fourierMag           (NULL),
  fourierMagArea       (NULL),
  height               (MorphOp::Biases (_mask) * 2 + 1),
  maxPixVal            (0),
  title                (),
  totPixels            (0),
  weOwnRasterData      (true),
  width                (MorphOp::Biases (_mask) * 2 + 1),

  redArea   (NULL),
  greenArea (NULL),
  blueArea  (NULL),

  red       (NULL),
  green     (NULL),
  blue      (NULL)

{
  AddRasterInstance (this);

  totPixels = height * width;

  kkint32  r = _row - MorphOp::Biases (_mask);
  kkint32  c = _col - MorphOp::Biases (_mask);

  green = _raster.GetSubSet (_raster.green, r, c, height, width);  
  greenArea = green[0];
  if  (color)
  {
    red = _raster.GetSubSet (_raster.red, r, c, height, width);
    redArea = red[0];

    blue = _raster.GetSubSet (_raster.blue, r, c, height, width);
    blueArea = blue[0];
  }
}

Raster::Raster	(	const KKStr &	fileName,
		bool &	validFile
	)

Constructs a Raster image from by reading an existing image File such as a BMP file.

Will read from the specified file (fileName) the existing image. If the load fails then the contents of this object will be undefined.

Parameters

[in]	fileName	Name of Image file to read.
[out]	validFile	If image successfully loaded will be set to 'True' otherwise 'False'.

Parameters

fileName
fileName	name of image file to load/
validFile
validFile	will return true if image successfully loaded.

Definition at line 622 of file Raster.cpp.

References AddRasterInstance(), backgroundPixelTH, backgroundPixelValue, blobIds, Blue(), blue, blueArea, centroidCol, centroidRow, color, divisor, fileName, ForegroundPixelCount(), foregroundPixelCount, foregroundPixelValue, fourierMag, fourierMagArea, Green(), green, greenArea, Height(), height, KKB::KKStr::KKStr(), MaxPixVal(), maxPixVal, KKB::ReadImage(), Red(), red, redArea, title, totPixels, weOwnRasterData, Width(), and width.

Referenced by KKMLL::GrayScaleImagesFVList::RecalcFeatureValuesFromImagesInDirTree().

                :

  backgroundPixelValue (0),
  backgroundPixelTH    (31),
  blobIds              (NULL),
  centroidCol          (-1),
  centroidRow          (-1),
  color                (false),
  divisor              (1),
  fileName             (_fileName),
  foregroundPixelCount (0),
  foregroundPixelValue (255),
  fourierMag           (NULL),
  fourierMagArea       (NULL),
  height               (0),
  maxPixVal            (0),
  title                (),
  totPixels            (0),
  weOwnRasterData      (true),
  width                (0),

  redArea   (NULL),
  greenArea (NULL),
  blueArea  (NULL),

  red       (NULL),
  green     (NULL),
  blue      (NULL)

{
  AddRasterInstance (this);

  validFile = true;
  
  RasterPtr r = ReadImage (fileName);

  if  (!r)
  {
    validFile = false;
    delete  r;
    r = NULL;
    return;
  }

  red       = r->Red   ();
  green     = r->Green ();
  blue      = r->Blue  ();
  height    = r->Height ();
  width     = r->Width ();
  redArea   = r->redArea;
  greenArea = r->greenArea;
  blueArea  = r->blueArea;
  maxPixVal = r->MaxPixVal ();
  totPixels = r->totPixels;
  color     = r->color;
  foregroundPixelCount = r->ForegroundPixelCount ();

  r->weOwnRasterData = false;
  weOwnRasterData = true;
  delete  r;
}

Raster::Raster	(	kkint32	_height,
		kkint32	_width,
		uchar *	_Data,
		uchar **	_Rows
	)

Construct a raster object that will utilize a image already in memory.

This instance will NOT OWN the raster data; it will only point to it. That means when this instance is destroyed the raster data will still be left intact.

Parameters

[in]	_height	Height of image.
[in]	_width	Width of image.
[in]	_Data	Source gray-scale raster data; needs to be continuous and of length (_height * _width) with data stored row major.
[in]	_Rows	Two dimensional array where each entry will point into the respective image row data in '_Data'.

Definition at line 689 of file Raster.cpp.

References AddRasterInstance(), backgroundPixelTH, backgroundPixelValue, blobIds, blue, blueArea, centroidCol, centroidRow, color, divisor, fileName, foregroundPixelCount, foregroundPixelValue, fourierMag, fourierMagArea, green, greenArea, height, KKB::KKStr::KKStr(), maxPixVal, red, redArea, title, totPixels, weOwnRasterData, and width.

Referenced by KKMLL::GrayScaleImagesFVProducer::ComputeFeatureVector().

                :
  backgroundPixelValue (0),
  backgroundPixelTH    (31),
  blobIds              (NULL),
  centroidCol          (0.0f),
  centroidRow          (0.0f),
  color                (false),
  divisor              (1),
  fileName             (),
  foregroundPixelCount (0),
  foregroundPixelValue (255),
  fourierMag           (NULL),
  fourierMagArea       (NULL),
  height               (_height),
  maxPixVal            (0),
  title                (),
  totPixels            (_height * _width),
  weOwnRasterData      (false),
  width                (_width),

  redArea              (NULL),
  greenArea            (_grayScaleData),
  blueArea             (NULL),

  red                  (NULL),
  green                (_grayScaleRows),
  blue                 (NULL)

{
  AddRasterInstance (this);
}

Raster::Raster	(	kkint32	_height,
		kkint32	_width,
		const uchar *	_Data
	)

Construct a Raster object using provided raw data.

Parameters

[in]	_height	Image Height.
[in]	_width	Image Width.
[in]	_Data	8 Bit data, Row Major, that is to be used to populate new instance.

Definition at line 727 of file Raster.cpp.

References AddRasterInstance(), backgroundPixelTH, backgroundPixelValue, blobIds, blue, blueArea, centroidCol, centroidRow, color, divisor, fileName, foregroundPixelCount, foregroundPixelValue, fourierMag, fourierMagArea, green, greenArea, height, KKB::KKException::KKException(), KKB::KKStr::KKStr(), maxPixVal, red, redArea, title, totPixels, weOwnRasterData, and width.

                :
  backgroundPixelValue (0),
  backgroundPixelTH    (31),
  blobIds              (NULL),
  centroidCol          (0.0f),
  centroidRow          (0.0f),
  color                (false),
  divisor              (1),
  fileName             (),
  foregroundPixelCount (0),
  foregroundPixelValue (255),
  fourierMag           (NULL),
  fourierMagArea       (NULL),
  height               (_height),
  maxPixVal            (0),
  title                (),
  totPixels            (_height * _width),
  weOwnRasterData      (true),
  width                (_width),

  redArea              (NULL),
  greenArea            (NULL),
  blueArea             (NULL),

  red                  (NULL),
  green                (NULL),
  blue                 (NULL)

{
  AddRasterInstance (this);
  AllocateImageArea ();
  if  (!greenArea)  throw KKException ("Raster::Raster   Failed to allocate 'greenArea'.");
  memcpy (greenArea, _grayScaleData, totPixels);
}

Raster::Raster	(	kkint32	_height,
		kkint32	_width,
		const uchar *	_redChannel,
		const uchar *	_greenChannel,
		const uchar *	_blueChannel
	)

Construct a Color Raster object using provided raw data,.

Parameters

[in]	_height	Image Height.
[in]	_width	Image Width.
[in]	_redChannel	8 Bit data, Row Major, that is to be used to populate the red channel.
[in]	_greenChannel	8 Bit data, Row Major, that is to be used to populate the green channel.
[in]	_blueChannel	8 Bit data, Row Major, that is to be used to populate the blue channel.

Definition at line 766 of file Raster.cpp.

References AddRasterInstance(), backgroundPixelTH, backgroundPixelValue, blobIds, blue, blueArea, centroidCol, centroidRow, color, KKB::KKStr::Concat(), divisor, fileName, foregroundPixelCount, foregroundPixelValue, fourierMag, fourierMagArea, green, greenArea, height, KKB::KKException::KKException(), KKB::KKStr::KKStr(), maxPixVal, red, redArea, title, totPixels, weOwnRasterData, and width.

                :
  backgroundPixelValue (0),
  backgroundPixelTH    (31),
  blobIds              (NULL),
  centroidCol          (0.0f),
  centroidRow          (0.0f),
  color                (true),
  divisor              (1),
  fileName             (),
  foregroundPixelCount (0),
  foregroundPixelValue (255),
  fourierMag           (NULL),
  fourierMagArea       (NULL),
  height               (_height),
  maxPixVal            (0),
  title                (),
  totPixels            (_height * _width),
  weOwnRasterData      (true),
  width                (_width),

  redArea              (NULL),
  greenArea            (NULL),
  blueArea             (NULL),

  red                  (NULL),
  green                (NULL),
  blue                 (NULL)

{
  AddRasterInstance (this);
  AllocateImageArea ();
  if  ((!_redChannel)  ||  (!_greenChannel)  ||  (!_blueChannel))
  {
    KKB::KKStr errMsg;
    errMsg << "Raster::Raster   ***ERROR***   One of the provided channels is 'NULL'.";
    cerr << std::endl << std::endl << errMsg << std::endl << std::endl;
    throw KKException (errMsg);
  }

  if ((!redArea) || (!greenArea) || (!blueArea))
  {
    KKB::KKStr errMsg;
    errMsg << "Raster::Raster   ***ERROR***   Not all channels were allocated.";
    cerr << std::endl << std::endl << errMsg << std::endl << std::endl;
    throw KKException(errMsg);
  }

  memcpy (redArea,   _redChannel,   totPixels);
  memcpy (greenArea, _greenChannel, totPixels);
  memcpy (blueArea,  _blueChannel,  totPixels);
}

Raster::~Raster ( )

virtual

Definition at line 826 of file Raster.cpp.

References RemoveRasterInstance().

{
  RemoveRasterInstance (this);
  CleanUpMemory ();
}

Member Function Documentation

void Raster::AddRasterInstance ( const RasterPtr  r )

staticprotected

Definition at line 106 of file Raster.cpp.

Referenced by Raster().

{
  /*
  if  (!rasterInitialized)
    Initialize ();

  goalKeeper->StartBlock ();

  map<RasterPtr, RasterPtr>::iterator  idx;
  idx = allocatedRasterInstances.find (r);
  if  (idx != allocatedRasterInstances.end ())
  {
    cerr << std::endl << "Raster::AddRasterInstance   ***ERROR***   Raster Instance[" << r << "] Already in list." << std::endl << std::endl;
  }
  else
  {
    allocatedRasterInstances.insert (pair<RasterPtr, RasterPtr> (r, r));
  }
  goalKeeper->EndBlock ();
  */
}

RasterPtr Raster::AllocateARasterInstance ( kkint32  height, kkint32  width, bool  color  ) const

virtual

Definition at line 1014 of file Raster.cpp.

References Raster().

Referenced by BandPass(), CreateColorImageFromLabels(), CreateColorWithBlobsLabeldByColor(), CreateFromOrginalImageWithSpecifidBlobsOnly(), CreateGrayScale(), CreateGrayScaleKLT(), CreateGrayScaleKLTOnMaskedArea(), KKB::RasterList::CreateSmoothedFrame(), ExtractABlob(), ExtractABlobTightly(), ExtractChannel(), FastFourierKK(), HalfSize(), HistogramEqualizedImage(), Padded(), ReduceByEvenMultiple(), ReduceByFactor(), Rotate(), SegmentImage(), TightlyBounded(), and ToColor().

{
  return new Raster (height, width, color);
}

RasterPtr Raster::AllocateARasterInstance ( const Raster &  r ) const

virtual

Definition at line 1024 of file Raster.cpp.

References Raster().

Referenced by CreateDilatedRaster(), CreateErodedImage(), CreateGaussianSmoothedImage(), CreateGrayScale(), CreateGrayScaleKLT(), CreateGrayScaleKLTOnMaskedArea(), CreateSmoothedMediumImage(), CreateSmoothImage(), ExtractChannel(), ReversedImage(), SegmentImage(), SwapQuadrants(), ThinContour(), ThresholdInHSI(), and ToColor().

{
  return new Raster (r);
}

RasterPtr Raster::AllocateARasterInstance ( const Raster &  _raster, kkint32  _row, kkint32  _col, kkint32  _height, kkint32  _width  ) const

virtual

Parameters

_raster	Source Raster
_row	Starting Row in '_raster' to copy from.
_col	Starting Col in '_raster' to copy from.
_height	Height of resultant raster. Will start from '_row'
_width	Width of resultant raster.

Definition at line 1031 of file Raster.cpp.

References Raster().

{
  return new Raster (_raster, _row, _col, _height, _width);
}

bool Raster::AreThereEdgePixels

(

kkint32

edgeWidth

)

returns true if there are any foreground pixels within 'edgeWidth' pixels of the top, bottom, left, or right edges of the image.

Definition at line 1516 of file Raster.cpp.

References ForegroundPixel(), height, and width.

{
  for  (kkint32 edgeIdx = 0;  edgeIdx < edgeWidth;  ++edgeIdx)
  {
    kkint32  topRow = edgeIdx;
    kkint32  botRow = height - (edgeIdx + 1);

    for  (int c = 0;  c < width;  ++c)
    {
      if  (ForegroundPixel (topRow, c)  ||  ForegroundPixel (botRow, c))
        return true;
    }

    kkint32  leftCol = edgeIdx;
    kkint32  rightCol = width - (1 + edgeIdx);

    for  (int r = 0;  r < height;  ++r)
    {
      if  (ForegroundPixel (r, leftCol)  ||  ForegroundPixel (r, rightCol))
        return true;
    }
  }
  return  false;
}  /* AreThereEdgePixels */

bool Raster::BackgroundPixel	(	kkint32	row,
		kkint32	col
	)		const

Definition at line 1074 of file Raster.cpp.

References backgroundPixelTH, backgroundPixelValue, and green.

Referenced by WhiteOutBackground().

{
  if  (backgroundPixelValue < 125)
     return (green[row][col] <= backgroundPixelTH);
  else
     return (green[row][col] >= backgroundPixelTH);
}  /* ForegroundPixel */

uchar KKB::Raster::BackgroundPixelTH ( ) const

inline

Definition at line 335 of file Raster.h.

References backgroundPixelTH.

Referenced by KKB::ContourFollower::ContourFollower(), ExtractUsingMask(), KKB::MorphOpBmiFiltering::PerformOperation(), KKB::MorphOpStretcher::PerformOperation(), KKB::SegmentorOTSU::SegmentMaskedImage(), and KKB::MorphOp::SetSrcRaster().

{return backgroundPixelTH;}

void KKB::Raster::BackgroundPixelTH ( uchar  _backgroundPixelTH )

inline

Definition at line 341 of file Raster.h.

References backgroundPixelTH.

Referenced by ExtractUsingMask(), and KKB::MorphOpStretcher::PerformOperation().

{backgroundPixelTH    = _backgroundPixelTH;}

uchar KKB::Raster::BackgroundPixelValue ( ) const

inline

Definition at line 336 of file Raster.h.

References backgroundPixelValue.

Referenced by ExtractUsingMask(), KKB::MorphOpBinarize::PerformOperation(), KKB::MorphOpErosion::PerformOperation(), KKB::MorphOpStretcher::PerformOperation(), and KKB::MorphOp::SetSrcRaster().

{return backgroundPixelValue;}

void KKB::Raster::BackgroundPixelValue ( uchar  _backgroundPixelValue )

inline

Definition at line 342 of file Raster.h.

References backgroundPixelValue.

Referenced by ExtractUsingMask(), KKB::MorphOpStretcher::PerformOperation(), and SegmentImage().

{backgroundPixelValue = _backgroundPixelValue;}

RasterPtr Raster::BandPass	(	float	lowerFreqBound,
		float	upperFreqBound,
		bool	retainBackground
	)

Returns a image that is the result of a BandPass using Fourier Transforms.

A 2D Fourier transform is performed. The range specified is from 0.0 to 1.0 where range is determined from the center of the image to the farthest corner where the center is 0.0 and the farthest corner is 1.0. Pixels in the resultant 2D Transform that are "NOT" in the specified range are set to 0.0. A reverse transform is then performed and the resultant image is returned.

Parameters

[in]	lowerFreqBound	Lower range of frequencies to retain; between 0.0 and 1.0.
[in]	upperFreqBound	Upper range of frequencies to retain; between 0.0 and 1.0.
[in]	retainBackground

Returns

The result image.

Parameters

lowerFreqBound	Number's between 0.0 and 1.0
upperFreqBound	Represent fraction.

Definition at line 8735 of file Raster.cpp.

References AllocateARasterInstance(), backgroundPixelValue, color, green, greenArea, height, totPixels, and width.

{
  #if  defined(FFTW_AVAILABLE)
    fftwf_complex*   src  = NULL;
    fftwf_complex*   dest = NULL;
    fftwf_plan       plan = NULL;
    src  = (fftwf_complex*)fftwf_malloc (sizeof (fftwf_complex) * totPixels);
    dest = (fftwf_complex*)fftwf_malloc (sizeof (fftwf_complex) * totPixels);
  #else
    KK_DFT2D_Float*  forwardPlan = new KK_DFT2D_Float (height, width, true);

    KK_DFT2D_Float::DftComplexType*   srcArea = NULL;
    KK_DFT2D_Float::DftComplexType**  src     = NULL;

    KK_DFT2D_Float::DftComplexType*   destArea = NULL;
    KK_DFT2D_Float::DftComplexType**  dest     = NULL;

    forwardPlan->AllocateArray (srcArea,  src);
    forwardPlan->AllocateArray (destArea, dest);
  #endif

  kkint32  col;
  kkint32  row;

  kkint32  idx = 0;


  double  centerCol = (double)width  / 2.0;
  double  centerRow = (double)height / 2.0;

  uchar  smallestPixelVal = 255;
  uchar  largestPixelVal  = 0;
  uchar  pixelVal         = 0;

  // float scalingFact = (float)255.0 / maxPixVal;   // kk  2004-May-18

  for  (row = 0; row < height; row++ )
  {
    for (col = 0; col < width; col++ )
    {     
      pixelVal = green[row][col];
      if  (pixelVal < smallestPixelVal)
        smallestPixelVal = pixelVal;
      if  (pixelVal > largestPixelVal)
        largestPixelVal = pixelVal;

      // src[idx].re = (float)green[row][col] * scalingFact;  // kk 2004-May-18

      #if  defined(FFTW_AVAILABLE)
        src[idx][0] = (float)green[row][col];                   // kk 2004-May-18
        src[idx][1] = 0.0;
      #else
        if  (color)
        {
          srcArea[idx].real ((float)(0.39f * redArea[idx] + 0.59f * greenArea[idx] + 0.11f * blueArea[idx]) / 3.0f);
        }
        else
        {
          srcArea[idx].real ((float)greenArea[idx]);
        }
        srcArea[idx].imag (0.0f);
      #endif

      idx++;
    }            
  }

  double  pixelValRange = largestPixelVal - smallestPixelVal;


  #if  defined(FFTW_AVAILABLE)
    plan = fftwCreateTwoDPlan (height, width, src, dest, FFTW_FORWARD, FFTW_ESTIMATE);
    fftwf_execute (plan);
    fftwDestroyPlan (plan);
  #else
    forwardPlan->Transform (src, dest);
    delete  forwardPlan;
    forwardPlan = NULL;
  #endif
    
  //  Will now perform the BandPass portion;  that is we will ZERO out all 
  // data that does not fall within the frequency range specified by
  // 'lowerFreqBound' and 'upperFreqBound'.
    
  double  deltaRow        = 0.0;
  double  deltaRowSquared = 0.0;
  double  deltaCol        = 0.0;
  double  deltaColSquared = 0.0;


  // Because the lower frequencies are further away from the center than higher frequencies
  // the 'lowerFreqBoundDistFromCenter' will be greater than 'upperFreqBoundDistFromCenter'
  
  double  zzz = sqrt ((double)(centerCol * centerCol + centerRow * centerRow));

  double  lowerFreqBoundDistFromCenter = (1.0 - (double)lowerFreqBound) * (double)zzz;
  double  upperFreqBoundDistFromCenter = (1.0 - (double)upperFreqBound) * (double)zzz;

  double  lowerFreqBoundDistFromCenterSquared = (lowerFreqBoundDistFromCenter * lowerFreqBoundDistFromCenter + 0.1f);
  double  upperFreqBoundDistFromCenterSquared = (upperFreqBoundDistFromCenter * upperFreqBoundDistFromCenter - 0.1f);

  idx = 0;

  for  (row = 0; row < height; row++ )
  {
    deltaRow = (double)row - centerRow;
    deltaRowSquared = deltaRow * deltaRow;

    for (col = 0; col < width; col++ )
    {     
      deltaCol = (double)col - centerCol;
      deltaColSquared = deltaCol* deltaCol;

      double  distFromCenterSquared = deltaRowSquared + deltaColSquared;

      if  ((distFromCenterSquared > lowerFreqBoundDistFromCenterSquared)  ||
           (distFromCenterSquared < upperFreqBoundDistFromCenterSquared)
          )
      {
        // We are out of the band so this data does not get passed through.
        #if  defined(FFTW_AVAILABLE)
          dest[idx][0] = 0.0f;
          dest[idx][1] = 0.0f;
        #else
          destArea[idx].real (0.0f);
          destArea[idx].imag (0.0f);
        #endif
      }
      idx++;
    }
  }

  #if  defined(FFTW_AVAILABLE)
    plan = fftwCreateTwoDPlan (height, width, src, dest, FFTW_BACKWARD, FFTW_ESTIMATE);
    fftwf_execute (plan);
    fftwDestroyPlan (plan);
  #else
    KK_DFT2D_Float*  reversePlan = new KK_DFT2D_Float (height, width, false);
    reversePlan->Transform (dest, src);
  #endif

  // We now need to transform the Fourier results back to GreayScale.
  double  smallestNum;
  double  largestNum;

  #if  defined(FFTW_AVAILABLE)
    smallestNum = largestNum = src[0][0];
  #else
    smallestNum = largestNum = srcArea[0].real ();
  #endif

  {
    double  zed = 0;
    for (idx = 0;  idx < totPixels;  idx++)
    {
      #if  defined(FFTW_AVAILABLE)
        zed = src[idx][0];
      #else
        zed = srcArea[idx].real ();
      #endif

      if  (zed < smallestNum)
        smallestNum = zed;
      else if  (zed > largestNum)
        largestNum = zed;
    }
  }

  double  range = largestNum - smallestNum;


  RasterPtr  result = AllocateARasterInstance (height, width, false);
  uchar*  destData = result->greenArea;
  
  {
    idx = 0;
    double  zed = 0;
    for (idx = 0;  idx < totPixels;  idx++)
    {     
      if  (retainBackground  &&  BackgroundPixel (greenArea[idx]))
      {
        // Since in the original source image this pixel was a background pixel;  we will
        // continue to let it be one.
        destData[idx] = backgroundPixelValue;
      }
      else
      {
        #if  defined(FFTW_AVAILABLE)
          zed = src[idx][0];
        #else
          zed = srcArea[idx].real ();
        #endif
        destData[idx] = smallestPixelVal + Min (largestPixelVal, (uchar)(0.5 + pixelValRange * (zed - smallestNum) / range));
      }
    }
  }

  #if  defined(FFTW_AVAILABLE)
    fftwf_free (src);
    fftwf_free (dest);
  #else
    reversePlan->DestroyArray (srcArea,  src);
    reversePlan->DestroyArray (destArea, dest);
    delete  reversePlan;
    reversePlan = NULL;
  #endif

  return  result;
}  /* BandPass */

RasterPtr Raster::BinarizeByThreshold	(	uchar	min,
		uchar	max
	)		const

Definition at line 7705 of file Raster.cpp.

References KKB::MorphOpBinarize::MorphOpBinarize(), and KKB::MorphOpBinarize::PerformOperation().

{
  MorphOpBinarize  binarizer (min, max);
  RasterPtr result = binarizer.PerformOperation (this);
  return  result;
}  /* BinarizeByThreshold */

kkint32 Raster::BlobId ( kkint32  row, kkint32  col  ) const

inline

Return the ID of the blob that the specified pixel location belongs to.

If a connected component (ExtractBlobs) was performed on this image then the pixels that belong to blobs were assigned a blob ID. These ID's are retained with the original image in 'blobIds'.

Parameters

[in]	row	Row in image.
[in]	col	Column in image.

Returns

BlobID of pixel location or -1 of does not belong to a blob.

See also

ExtractBlobs

Definition at line 3116 of file Raster.cpp.

References blobIds, height, and width.

{
  if  ((row < 0)  ||  (row >= height)  ||
       (col < 0)  ||  (col >= width))
    return  -1;

  if  (!blobIds)
    return -1;

  return  blobIds[row][col];
}

uchar** KKB::Raster::Blue ( ) const

inline

returns a pointer to two dimensional array for 'Blue' color channel.

Definition at line 328 of file Raster.h.

References blue.

Referenced by KKB::BmpImage::BmpImage(), CreateSmoothedMediumImage(), CreateSmoothImage(), ExtractUsingMask(), FindMagnitudeDifferences(), KKB::MorphOpStretcher::PerformOperation(), Raster(), KKB::SaveImageInverted(), KKB::MorphOp::SetSrcRaster(), TightlyBounded(), and Transpose().

uchar* KKB::Raster::BlueArea ( ) const

inline

Definition at line 331 of file Raster.h.

References blueArea.

Referenced by KKB::SegmentorOTSU::ClassAverageRGB(), CreateColorImageFromLabels(), KKB::RasterList::CreateSmoothedFrame(), ExtractChannel(), FromCompressor(), KKB::SegmentorOTSU::GetClassClosestToTargetColor(), KKB::MorphOpMaskExclude::PerformOperation(), ReduceByFactor(), KKB::SaveImagePNG(), KKB::SaveImagePPM(), KKB::MorphOp::SetSrcRaster(), and ToColor().

{return  blueArea;}

MatrixPtr Raster::BuildGaussian2dKernel ( float  sigma )

static

Builds a 2d Gaussian kernel.

Determines the size of the Gaussian kernel based off the specified sigma parameter. returns a 2D matrix representing the kernel which will have 'Len' x 'Len' dimensions. The caller will be responsible for deleting the kernel.

Parameters

[in]

sigma

parameter used to control the width of the Gaussian kernel

Returns

A 2-dimensional matrix representing the Gaussian kernel.

Definition at line 9331 of file Raster.cpp.

References KKB::Matrix::Matrix(), KKB::Matrix::operator[](), and KKB::Row::operator[]().

Referenced by CreateGaussianSmoothedImage().

{
  kkint32 row, col, x, y;

  double  prefix =  1.0 / (2.0 * PIE * sigma * sigma);
  double  twoSigmaSquared = 2.0 * sigma * sigma;


  // Determine size of kernel
  double z = 100;
  kkint32  delta = 0;
  while (true)
  {
    z = 256.0 * prefix * exp (-(delta * delta / twoSigmaSquared));
    if  (z < 1.0)
    {
      delta--;
      break;
    }
    ++delta;
  }

  kkint32 len = delta * 2 + 1;

  MatrixPtr  kernel = new Matrix (len, len);

  double  total = 0.0;
  x =  -delta;
  for (row = 0;  row < len;  row++, x++)
  {
    y = -delta;
    for  (col = 0;  col < len;  col++, y++)
    {
      double  v = exp (-( (x * x + y * y) / twoSigmaSquared));
      (*kernel)[row][col] = v;
      total += v;
    }
  }

  for (row = 0;  row < len;  row++)
  {
    for  (col = 0;  col < len;  col++)
    {
      (*kernel)[row][col] = ((*kernel)[row][col] / total);
    }
  }

  return  kernel;
}  /* BuildGaussian2dKernel */

kkint32 Raster::CalcArea

(

)

Definition at line 3789 of file Raster.cpp.

References foregroundPixelCount, green, height, maxPixVal, and width.

{
  kkint32  r, c;

  kkint32  area = 0;

  maxPixVal = 0;

  uchar  pixVal;

  for  (r = 0; r < height; r++)
  {
    for  (c = 0; c < width; c++)
    {
      pixVal = green[r][c];
      
      if  (ForegroundPixel (pixVal))
      {
        area++;

        if  (pixVal > maxPixVal)
          maxPixVal = pixVal;
      }
    }
  }

  foregroundPixelCount = area;

  return  area;
}  /* CalcArea */

void Raster::CalcAreaAndIntensityFeatures	(	kkint32 &	area,
		float &	weightedSize,
		kkuint32	intensityHistBuckets[8],
		kkint32 &	areaWithWhiteSpace,
		kkuint32	intensityHistBucketsWhiteSpace[8]
	)		const

Calculates both Intensity Histograms, one not including internal background pixels and one with plus size and weighted size.

This method incorporates the functionality of several methods at once. The idea being that while we are iterating through the raster image we might as well get all the data we can so as to save total overall processing time.

Histogram Ranges:
  0:   0  - 31    4: 128 - 159
  1:  31  - 63    5: 192 - 223
  2:  64  - 95    6: 192 - 223
  3:  96 - 127    7: 224 - 255

Parameters

[out]	area	Number of foreground pixels.
[out]	weightedSize	Area that takes intensity into account. The largest pixel will have a value of 1.0.
[out]	intensityHistBuckets	A 8 element array containing a histogram by intensity range.
[out]	areaWithWhiteSpace	Area including any whitespace enclosed inside the image.
[out]	intensityHistBucketsWhiteSpace	A 8 element array containing a histogram by intensity range, with enclosed whitespace pixels included.

Definition at line 3912 of file Raster.cpp.

References FillHole(), foregroundPixelCount, freqHistBucketIdx, GreenArea(), greenArea, maxPixVal, Raster(), and totPixels.

{
  kkint32  x;

  // We first need to determine what background pixels are not part of the image.  We assume
  // that any background pixels that are connected to the border of the image are not part
  // of the image.
  Raster  mask (*this);
  mask.FillHole ();
  
  long  totalPixelValues = 0;

  area               = 0;
  weightedSize       = 0.0f;
  areaWithWhiteSpace = 0;


  for  (x = 0;  x < 8;  x++)
  {
   intensityHistBuckets[x] = 0;
   intensityHistBucketsWhiteSpace[x] = 0;
  }


  maxPixVal = 0;
  uchar  pixVal;

  uchar*  maskGreenArea = mask.GreenArea ();

  for  (x = 0;  x < totPixels;  x++)
  {
    pixVal = greenArea [x];
    if  (ForegroundPixel (maskGreenArea[x]))
    {
      areaWithWhiteSpace++;
      if  (pixVal > maxPixVal)
        maxPixVal = pixVal;
      intensityHistBucketsWhiteSpace[freqHistBucketIdx[pixVal]]++;
      
      if  (ForegroundPixel (pixVal))
      {
        area++;
        intensityHistBuckets[freqHistBucketIdx[pixVal]]++;
        totalPixelValues += pixVal;
      }
    }
  }

  foregroundPixelCount = area;

  weightedSize = (float)totalPixelValues / (float)maxPixVal;
}  /* CalcAreaAndIntensityFeatures */

void Raster::CalcAreaAndIntensityFeatures	(	kkint32 &	area,
		float &	weightedSize,
		kkuint32	intensityHistBuckets[8]
	)		const

Calculates both Intensity Histograms, one not including internal background pixels and one with plus size and weighted size.

This method incorporates the functionality of several methods at once. The idea being that while we are iterating through the raster image we might as well get all the data we can so as to save total overall processing time.

Histogram Ranges:
  0:   0  - 31    4: 128 - 159
  1:  32  - 63    5: 192 - 223
  2:  64  - 95    6: 192 - 223
  3:  96 - 127    7: 224 - 255

Parameters

[out]	area	Number of foreground pixels.
[out]	weightedSize	Area that takes intensity into account. The largest pixel will have a value of 1.0.
[out]	intensityHistBuckets	A 8 element array containing a histogram by intensity range where each bucket represents a range of 32.

Definition at line 4018 of file Raster.cpp.

References foregroundPixelCount, freqHistBucketIdx, greenArea, maxPixVal, and totPixels.

Referenced by KKMLL::GrayScaleImagesFVProducer::ComputeFeatureVector().

{
  kkint32  x;

  long  totalPixelValues = 0;

  area          = 0;
  weightedSize  = 0.0f;

  for  (x = 0;  x < 8;  x++)
   intensityHistBuckets[x] = 0;

  maxPixVal = 0;
  uchar  pixVal;

  for  (x = 0;  x < totPixels;  x++)
  {
    pixVal = greenArea [x];
    if  (pixVal > 0)
    {
      if  (pixVal > maxPixVal)
        maxPixVal = pixVal;
      area++;
      intensityHistBuckets[freqHistBucketIdx[pixVal]]++;
      totalPixelValues += pixVal;
    }
  }

  foregroundPixelCount = area;

  weightedSize = (float)totalPixelValues / (float)255.0f;
}  /* CalcAreaAndIntensityFeatures */

void Raster::CalcAreaAndIntensityFeatures16	(	kkint32 &	area,
		float &	weighedSize,
		kkuint32	intensityHistBuckets[16]
	)

Definition at line 3975 of file Raster.cpp.

References foregroundPixelCount, freqHist16BucketIdx, greenArea, maxPixVal, and totPixels.

{
  kkint32  x;

  long  totalPixelValues = 0;

  area               = 0;
  weighedSize        = 0.0f;
  maxPixVal          = 0;

  for  (x = 0;  x < 16;  x++)
  {
   intensityHistBuckets[x] = 0;
  }

  maxPixVal = 0;
  uchar  pixVal;

  for  (x = 0;  x < totPixels;  x++)
  {
    pixVal = greenArea [x];
    if  (pixVal > maxPixVal)
      maxPixVal = pixVal;
    if  (ForegroundPixel (pixVal))
    {
      area++;
      intensityHistBuckets[freqHist16BucketIdx[pixVal]]++;
      totalPixelValues += pixVal;
    }
  }

  foregroundPixelCount = area;

  weighedSize = (float)totalPixelValues / (float)maxPixVal;
}  /* CalcAreaAndIntensityFeatures16 */

void Raster::CalcAreaAndIntensityHistogram	(	kkint32 &	area,
		kkuint32	intensityHistBuckets[8]
	)		const

Calculates the occurrence of different intensity levels.

The pixel values 0-255 are split into 8 ranges. (0-31), (32-63), (64-95), (96-127), (128-159), (160-191), (192-223), (224-255). The background range (0-31) are not counted.

Parameters

[out]	area	Total number of foreground pixels in the image.
[out]	intensityHistBuckets	An array of 8 buckets where each bucket represents an intensity range.

Definition at line 3872 of file Raster.cpp.

References foregroundPixelCount, freqHistBucketIdx, green, height, maxPixVal, and width.

{
  kkint32  r, c;

  area = 0;

  for  (kkint32 x = 0; x < 8; x++)
    intensityHistBuckets[x] = 0;

  maxPixVal = 0;

  uchar  pixVal;

  for  (r = 0; r < height; r++)
  {
    for  (c = 0; c < width; c++)
    {
      pixVal = green[r][c];
      
      if  (ForegroundPixel (pixVal))
      {
        area++;

        if  (pixVal > maxPixVal)
          maxPixVal = pixVal;

        intensityHistBuckets[freqHistBucketIdx[pixVal]]++;
      }
    }
  }

  foregroundPixelCount = area;
}  /* CalcAreaAndIntensityHistogram */

void Raster::CalcAreaAndIntensityHistogramWhite	(	kkint32 &	area,
		kkuint32	intensityHistBuckets[8]
	)

Calculates a Intensity Histogram including Background pixels in the image.

All background pixels that are inside the image will also be included in the counts. This is done by building a mask on the original image then performing a FillHole operation. This mask is then used to select pixels for inclusion in the histogram.

Definition at line 3825 of file Raster.cpp.

References FillHole(), freqHistBucketIdx, green, height, maxPixVal, Raster(), and width.

{
  kkint32  c;
  kkint32  r;
  kkint32  x;

  // We first need to determine what background pixels are not part of the image.  We assume
  // that any background pixels that are connected to the border of the image are not part
  // of the image.
  Raster  mask (*this);
  mask.FillHole ();


  area = 0;
  for  (x = 0;  x < 8;  x++)
   intensityHistBuckets[x] = 0;


  // Now that we know what pixels are background that are connected to
  // one of the boarders,  any other white pixel must be in a hole inside
  // the image.
  uchar*  curRow     = NULL;
  uchar*  curMaskRow = NULL;
  uchar   pixVal;
  for  (r = 0; r < height; r++)
  {
    curMaskRow = mask.green[r];
    curRow = green[r];
    for  (c = 0; c < width; c++)
    {
      if  (ForegroundPixel (curMaskRow[c]))
      {
        area++;
        pixVal = curRow[c];
        if  (pixVal > maxPixVal)
          maxPixVal = pixVal;
        intensityHistBuckets[freqHistBucketIdx[pixVal]]++;
      }
    }
  }
}  /* CalcAreaAndIntensityHistogramWhite */

void Raster::CalcCentroid	(	kkint32 &	size,
		kkint32 &	weight,
		float &	rowCenter,
		float &	colCenter,
		float &	rowCenterWeighted,
		float &	colCenterWeighted
	)		const

Definition at line 5977 of file Raster.cpp.

References centroidCol, centroidRow, green, height, and width.

Referenced by CalcOrientationAndEigerRatio(), CentroidCol(), and CentroidRow().

{
  size              = 0;
  weight            = 0;
  rowCenter         = 0;
  colCenter         = 0;
  rowCenterWeighted = 0;
  colCenterWeighted = 0;

  kkint32  row;  
  kkint32  col;

  uchar  intensity;

  for  (row = 0; row < height;  row++)
  {
    for  (col = 0; col < width; col++)
    {
      intensity = green[row][col];

      if  (intensity > 0)
      {
        rowCenter += row;
        colCenter += col;
        size++;

        rowCenterWeighted += row * intensity;
        colCenterWeighted += col * intensity;
        weight += intensity;
      }
    }
  }

  rowCenter /= size;
  colCenter /= size; 

  this->centroidCol = colCenter;
  this->centroidRow = rowCenter;
  
  rowCenterWeighted /= weight;
  colCenterWeighted /= weight; 
}  /* CalcCentroid */

void Raster::CalcOrientationAndEigerRatio	(	float &	eigenRatio,
		float &	orientationAngle
	)

Definition at line 5610 of file Raster.cpp.

References CalcCentroid(), centroidCol, centroidRow, green, height, KKB::tqli(), KKB::Tred2(), and width.

Referenced by DeriveImageLength().

{
#ifdef  WIN32

  float  centroidColWeighted;
  float  centroidRowWeighted;

  kkint32  size;
  kkint32  weight;

  CalcCentroid (size, weight, centroidRow, centroidCol, centroidRowWeighted, centroidColWeighted);

  double  cov[2][2];

  cov[0][0] = 0.0;
  cov[0][1] = 0.0;
  cov[1][0] = 0.0;
  cov[1][1] = 0.0;

  kkint32  col;
  uchar  pixVal;
  kkint32  row;

  double  colOffset = 0.0;
  double  rowOffset = 0.0;
  double  rowOffsetSquare = 0.0;

  for  (row = 0; row < height;  row++)
  {
    rowOffset = double (row) - centroidRow;
    rowOffsetSquare = rowOffset * rowOffset;

    for  (col = 0; col < width; col++)
    {
      pixVal = green[row][col];

      if  (ForegroundPixel (pixVal))
      {
        colOffset = double (col) - centroidCol;
        cov[0][0] += (colOffset * colOffset);
        cov[1][1] += (rowOffsetSquare);
        cov[0][1] += (colOffset * rowOffset);
      }
    }
  }

  cov[1][0] = cov[0][1];
  cov[0][0] /= size;
  cov[0][1] /= size;
  cov[1][0] /= size;
  cov[1][1] /= size;

  double  origCov00 = cov[0][0];
  double  origCov11 = cov[1][1];
  double  origCov10 = cov[1][0];

  double  d[2];
  double  e[2];

  d[0] = 0.0;
  d[1] = 0.0;
  e[0] = 0.0;
  e[1] = 0.0;

  Tred2 (2, cov, d, e);

  tqli (2, d, e, cov);

  double  ang0;

  if  (fabs (d[0]) > fabs (d[1]))
  {
    ang0 = atan2 (cov[0][0], cov[1][0]);
    eigenRatio = (d[0] == 0.0) ? 9999.0f : float (d[1] / d[0]);
  }
  else
  {
    ang0 = atan2 (cov[0][1], cov[1][1]);
    eigenRatio = (d[1] == 0.0) ? 9999.0f : float (d[0] / d[1]);
  }
  //double  ang1 = RadToDeg * atan2 (cov[0][1], cov[1][1]);

  orientationAngle = float (-ang0 - 1.57079632679f);
  if  (fabs (orientationAngle) > 1.57079632679f)
  {
    if  (orientationAngle < 0.0)
      orientationAngle += float (PIE);
    else
      orientationAngle -= float (PIE);
  }


  //if  (d[0] == 0.0)
  //  eigenRatio = (float)9999.0;
  //else
  //  eigenRatio = (float) (d[1] / d[0]);


  if  (origCov10 == 0)
  {
    // Appears we have a image that is standing up Straight, 
    // but may be fatter than it is tall.
    if  (origCov00 > origCov11)
    {
      orientationAngle = 0.0f;
    }
    else
    {
      orientationAngle = 1.57079632679f;
    }
  }

  return;

#endif
} /* CalcOrientation */

float Raster::CalcWeightedArea

(

)

const

Definition at line 4060 of file Raster.cpp.

References green, height, and width.

{
  kkint32  r, c;

  float  area = 0;

  uchar  pixVal = 0;
  kkint32  maxPixValFound = 0;

  //foregroundPixelCount = 0;

  for  (r = 0; r < height; r++)
  {
    for  (c = 0; c < width; c++)
    {
      pixVal = green[r][c];
      if  (ForegroundPixel (pixVal))
      {
        area = area + (float)pixVal;
        if  (pixVal > maxPixValFound)
          maxPixValFound = pixVal;
      }
    }
  }

  area = area / (float)maxPixValFound;

  return  area;
}  /* CalcWeightedArea */

double KKB::Raster::CenMoment	(	kkint32	colMoment,
		kkint32	rowMoment,
		double	centerCol,
		double	centerRow
	)		const

float KKB::Raster::CenMomentWeighted	(	kkint32	p,
		kkint32	q,
		float	ew,
		float	eh
	)		const

void Raster::CentralMoments

(

float

features[9]

)

const

returns in 'features' the 8 central moments as defined by Hu plus eccentricity in the eight bucket.

See M. K. Hu, Visual pattern recognition by moment invariants IRE Trans; Inform. Theory, vol. IT, no. 8, pp. 179�187, 1962.

Parameters

[in]

features

A array with 9 elements (0 through 8) that will receive the 8 central moments as defined by HU plus eccentricity in the eighth element.

Definition at line 4100 of file Raster.cpp.

References backgroundPixelTH, centroidCol, centroidRow, foregroundPixelCount, green, height, and width.

Referenced by KKMLL::GrayScaleImagesFVProducer::ComputeFeatureVector().

{
  kkint64  m00, m10, m01;
  Moment (m00, m10, m01);

  centroidCol = (float)m10 / (float)m00;   // Center Col
  centroidRow = (float)m01 / (float)m00;   // Center Row

  foregroundPixelCount = (kkint32)m00;

  float  cm00   = (float)m00;
  float  gamma2 = (float)m00 * (float)m00;
  float  gamma3 = gamma2 * (float)sqrt ((float)m00);
        
  float  cm20 = 0.0;
  float  cm02 = 0.0;
  float  cm11 = 0.0;

  float  cm30 = 0.0;
  float  cm03 = 0.0;
  float  cm12 = 0.0;
  float  cm21 = 0.0;

  {
    float   cm = 0.0;
    kkint32 col;
    kkint32 row;

    float   deltaCol = 0.0f;
    float   deltaRow = 0.0f;

    for  (row = 0;  row < height;  ++row)
    {
      deltaRow = row - centroidRow;
      float  rowPow0 = 1.0;
      float  rowPow1 = deltaRow;
      float  rowPow2 = deltaRow * deltaRow;
      float  rowPow3 = rowPow2  * deltaRow;
      uchar*  rowData = green[row];
      for  (col = 0;  col < width;  ++col)
      {
        if  (rowData[col] > backgroundPixelTH)
        {
          deltaCol = (float)col - centroidCol;
          float  colPow0 = 1.0f;
          float  colPow1 = deltaCol;
          float  colPow2 = deltaCol * deltaCol;
          float  colPow3 = colPow2  * deltaCol;

          cm20 += colPow2 * rowPow0;
          cm02 += colPow0 * rowPow2;
          cm11 += colPow1 * rowPow1;
          cm30 += colPow3 * rowPow0;
          cm03 += colPow0 * rowPow3;

          cm12 += colPow1 * rowPow2;
          cm21 += colPow2 * rowPow1;
        }
      }
    }
  }

  cm20 = cm20 / gamma2;
  cm02 = cm02 / gamma2;
  cm11 = cm11 / gamma2;

  cm30 = cm30 / gamma3;
  cm03 = cm03 / gamma3;
  cm12 = cm12 / gamma3;
  cm21 = cm21 / gamma3;

  features[0] = cm00;

  features[1] = cm20 + cm02;
 
  features[2] = (cm20 - cm02) * (cm20 - cm02) + 
                4.0f * cm11 * cm11;

  features[3] = (cm30 - 3.0f * cm12) * (cm30 - 3.0f * cm12) + 
                (3.0f * cm21 - cm03) * (3.0f * cm21 - cm03);

  features[4] = (cm30 + cm12) * (cm30 + cm12) + (cm21 + cm03) * (cm21 + cm03);

  features[5] = (cm30 - 3.0f * cm12) * (cm30 + cm12) * ((cm30 + cm12) * (cm30 + cm12) - 
                3.0f * (cm21 + cm03) * (cm21 + cm03))  +  (3.0f * cm21 - cm03) * (cm21 + cm03) * 
                (3.0f * (cm30 + cm12) * (cm30 + cm12) - (cm21 + cm03) * (cm21 + cm03));

  features[6] = (cm20 - cm02) * 
                ((cm30 + cm12) * (cm30 + cm12) - (cm21 + cm03) * (cm21 + cm03))
                + 4.0f * cm11 * (cm30 + cm12) * (cm21 + cm03);

  features[7] = (3.0f * cm21 - cm03) * (cm30 + cm12) * 
                ((cm30 + cm12) * (cm30 + cm12) - 3.0f * (cm21 + cm03) * (cm21 + cm03) )
               -(cm30 - 3.0f * cm12) * (cm21 + cm03) * 
               (3.0f * (cm30 + cm12) * (cm30 + cm12) - (cm21 + cm03) * (cm21 + cm03) );

  //added by baishali to calculate eccentricity
  features[8] = (((cm20 - cm02) * (cm20 - cm02)) - 
                (4.0f * cm11 * cm11))/((cm20 + cm02) * (cm20 + cm02));


  return;
}  /* CentralMoments */

void Raster::CentralMomentsWeighted

(

float

features[9]

)

const

Similar to 'CentralMoments' except each pixel position is weighted by its intensity value.

See M. K. Hu, Visual pattern recognition by moment invariants IRE Trans; Inform. Theory, vol. IT, no. 8, pp. 179, 187, 1962.

Parameters

[in]

features

A array with 9 elements (0 through 8) that will receive the 8 central moments as defined by HU plus eccentricity in the eighth element.

Definition at line 4243 of file Raster.cpp.

References backgroundPixelTH, green, height, and width.

{

  float  m00, m10, m01;
  MomentWeighted (m00, m10, m01);

  float ew  = m10 / m00;
  float eh  = m01 / m00;
        
  float cm00   = m00;
  float gamma2 = m00 * m00;
  float gamma3 = gamma2 * (float)sqrt (m00);
        
  float cm20 = 0.0f;
  float cm02 = 0.0f;
  float cm11 = 0.0f;

  float cm30 = 0.0f;
  float cm03 = 0.0f;
  float cm12 = 0.0f;
  float cm21 = 0.0f;

  {
    float  cm = 0.0;
    kkint32  col;
    kkint32  row;
   
    kkint32  maxPixVal = 0;

    for  (row = 0;  row < height;  ++row)
    {
      uchar*  rowData = green[row];
      float  deltaRow = row - eh;

      float  rowPow0 = 1;
      float  rowPow1 = deltaRow;
      float  rowPow2 = deltaRow * deltaRow;
      float  rowPow3 = rowPow2  * deltaRow;

      for  (col = 0;  col < width;  ++col)
      {
        uchar pv = rowData[col];
        if  (pv > backgroundPixelTH)
        {
          if  (pv > maxPixVal)
            maxPixVal = pv;

          float  deltaCol = col - ew;
          float  colPow0 = 1;
          float  colPow1 = deltaCol;
          float  colPow2 = deltaCol * deltaCol;
          float  colPow3 = colPow2  * deltaCol;

          float  pvFloat = (float)pv;

          cm20 += pvFloat * colPow2 * rowPow0;
          cm02 += pvFloat * colPow0 * rowPow2;
          cm30 += pvFloat * colPow3 * rowPow0;
          cm03 += pvFloat * colPow0 * rowPow3;
          cm12 += pvFloat * colPow1 * rowPow2;
          cm21 += pvFloat * colPow2 * rowPow1;
        }
      }
    }

    cm20 = cm20 / (float)maxPixVal;
    cm02 = cm02 / (float)maxPixVal;
    cm30 = cm30 / (float)maxPixVal;
    cm03 = cm03 / (float)maxPixVal;
    cm12 = cm12 / (float)maxPixVal;
    cm21 = cm21 / (float)maxPixVal;
  }

  cm20 = cm20 / gamma2;
  cm02 = cm02 / gamma2;
  cm11 = cm11 / gamma2;

  cm30 = cm30 / gamma3;
  cm03 = cm03 / gamma3;
  cm12 = cm12 / gamma3;
  cm21 = cm21 / gamma3;

  features[0] = cm00;

  features[1] = cm20 + cm02;
 
  features[2] = (cm20 - cm02) * (cm20 - cm02) + (float)4.0 * cm11 * cm11;

  features[3] = (cm30 - (float)3.0 * cm12) * 
                (cm30 - (float)3.0 * cm12) + 
                ((float)3.0 * cm21 - cm03) * 
                ((float)3.0 * cm21 - cm03);

  features[4] = (cm30 + cm12) * (cm30 + cm12) + (cm21 + cm03) * (cm21 + cm03);

  features[5] = (cm30 - (float)3.0 * cm12) * (cm30 + cm12) * 
                ((cm30 + cm12) * (cm30 + cm12) - 
                (float)3.0 * (cm21 + cm03) * (cm21 + cm03)) +
                ((float)3.0 * cm21 - cm03) * (cm21 + cm03) * 
                ((float)3.0 * (cm30 + cm12) * (cm30 + cm12) - 
                (cm21 + cm03) * (cm21 + cm03));

  features[6] = (cm20 - cm02) * 
                (
                 (cm30 + cm12) * (cm30 + cm12) - 
                 (cm21 + cm03) * (cm21 + cm03)
                ) +
                (float)4.0 * cm11 * (cm30 + cm12) * (cm21 + cm03);

  features[7] = ((float)3.0 * cm21 - cm03) * 
                (cm30 + cm12) * ((cm30 + cm12) * 
                (cm30 + cm12) - (float)3.0 * 
                (cm21 + cm03) * (cm21 + cm03)) -
                (cm30 - (float)3.0 * cm12) * 
                (cm21 + cm03) * ((float)3.0 * 
                (cm30 + cm12) * (cm30 + cm12) - 
                (cm21 + cm03) * (cm21 + cm03));

//added by Baishali to calculate eccentricity
  features[8] = (float)((((cm20 - cm02) * (cm20 - cm02)) - 
                (4.0 * cm11 * cm11))/((cm20 + cm02) * (cm20 + cm02)));

  return;
}  /* CentralMomentsWeighted */

float Raster::CentroidCol

(

)

const

Returns

returns the centroid's column

Definition at line 1100 of file Raster.cpp.

References CalcCentroid(), centroidCol, centroidRow, and totPixels.

{
  if  (centroidCol >= 0)
    return  centroidCol;

  float  centroidColWeighted;
  float  centroidRowWeighted;

  kkint32  weight = 0;
  CalcCentroid (totPixels, weight, centroidRow, centroidCol, centroidRowWeighted, centroidColWeighted);

  return  centroidCol;
} 

float Raster::CentroidRow

(

)

const

Returns

returns the centroid's row

Definition at line 1116 of file Raster.cpp.

References CalcCentroid(), centroidCol, centroidRow, and totPixels.

{
  if  (centroidRow >= 0)
    return  centroidRow;

  float  centroidColWeighted;
  float  centroidRowWeighted;
  kkint32  weight = 0;
  CalcCentroid (totPixels, weight, centroidRow, centroidCol, centroidRowWeighted, centroidColWeighted);
  return  centroidRow;
}

void Raster::Closing

(

)

Definition at line 2961 of file Raster.cpp.

References Dilation(), and Erosion().

{
  Dilation ();
  Erosion ();
}  /* Open */

void Raster::Closing

(

MaskTypes

mask

)

Definition at line 2971 of file Raster.cpp.

References Dilation(), and Erosion().

{
  Dilation (mask);
  Erosion (mask);
}  /* Open */

bool KKB::Raster::Color ( ) const

inline

Definition at line 310 of file Raster.h.

References color.

Referenced by KKB::BmpImage::BmpImage(), KKB::SegmentorOTSU::ClassAverageRGB(), KKB::RasterList::CreateSmoothedFrame(), Dilation(), KKB::SegmentorOTSU::GetClassClosestToTargetColor(), KKB::MorphOpSobel::PerformOperation(), KKB::MorphOpStretcher::PerformOperation(), KKB::ReadImage(), KKB::SaveImageInverted(), KKB::SaveImagePGM(), KKB::SaveImagePNG(), KKB::SaveImagePPM(), KKB::SegmentorOTSU::SegmentImage(), SegmentImage(), KKB::SegmentorOTSU::SegmentMaskedImage(), and KKB::MorphOp::SetSrcRaster().

{return  color;}

void Raster::ComputeCentralMoments	(	kkint32 &	foregroundPixelCount,
		float &	weightedPixelCount,
		float	centralMoments[9],
		float	centralMomentsWeighted[9]
	)		const

Computes central moments; one set where each pixel is treated as 1 or 0(Foreground/Background) and the other where each pixel is weighted by intensity value.

See M. K. Hu, Visual pattern recognition by moment invariants IRE Trans; Inform. Theory, vol. IT, no. 8, pp. 179?187, 1962. While performing this computation the mutable fields 'centroidRow' and 'centroidCol' will be recomputed and their values can be retrieved by their respective access methods.

Parameters

[out]	foregroundPixelCount	Number of pixels that are considered Foreground; as per the 'Foreground' method.
[out]	weightedPixelCount	The sum of all pixels that are Foreground pixels but weighted by their intensity; such that each foreground pixel will be divided by 255.
[out]	centralMoments
[out]	centralMomentsWeighted

Definition at line 4418 of file Raster.cpp.

References backgroundPixelTH, centroidCol, centroidRow, green, height, and width.

Referenced by KKMLL::GrayScaleImagesFVProducer::ComputeFeatureVector().

{
  kkint64  m00,  m10,  m01;
  float    mw00, mw10, mw01;
  Moments (m00, m10, m01, mw00, mw10, mw01);

  foregroundPixelCount = (kkint32)m00;
  weightedPixelCount   = mw00;

  centroidCol = (float)m10 / (float)m00;
  centroidRow = (float)m01 / (float)m00;

  float centroidColW  = mw10 / mw00;
  float centroidRowW  = mw01 / mw00;
        
  float  cm00   = (float)m00;
  float  gamma2 = (float)m00 * (float)m00;
  float  gamma3 = gamma2 * (float)sqrt ((float)m00);
        
  float  cm20 = 0.0;
  float  cm02 = 0.0;
  float  cm11 = 0.0;

  float  cm30 = 0.0;
  float  cm03 = 0.0;
  float  cm12 = 0.0;
  float  cm21 = 0.0;

  float cmw00   = mw00;
  float gammaW2 = (float)mw00 * (float)mw00;
  float gammaW3 = (float)gammaW2 * (float)sqrt ((float)mw00);
        
  float cmw20 = 0.0f;
  float cmw02 = 0.0f;
  float cmw11 = 0.0f;

  float cmw30 = 0.0f;
  float cmw03 = 0.0f;
  float cmw12 = 0.0f;
  float cmw21 = 0.0f;

  {
    float  cmw = 0.0;
    float  cm  = 0.0;
    kkint32  col;
    kkint32  row;

    float   deltaCol = 0.0f;
    float   deltaRow = 0.0f;
   
    kkint32  maxPixVal = 0;

    for  (row = 0;  row < height;  ++row)
    {
      uchar*  rowData = green[row];

      float  deltaRow  = row - centroidRow;
      float  deltaRowW = row - centroidRowW;

      float  rowPow0 = 1.0;
      float  rowPow1 = deltaRow;
      float  rowPow2 = deltaRow * deltaRow;
      float  rowPow3 = rowPow2  * deltaRow;

      float  rowPowW0 = 1;
      float  rowPowW1 = deltaRowW;
      float  rowPowW2 = deltaRowW * deltaRowW;
      float  rowPowW3 = rowPowW2  * deltaRowW;

      for  (col = 0;  col < width;  ++col)
      {
        uchar pv = rowData[col];
        if  (pv > backgroundPixelTH)
        {
          float  deltaCol = col - centroidCol;

          float  colPow0 = 1.0f;
          float  colPow1 = deltaCol;
          float  colPow2 = deltaCol * deltaCol;
          float  colPow3 = colPow2  * deltaCol;

          cm20 += colPow2 * rowPow0;
          cm02 += colPow0 * rowPow2;
          cm11 += colPow1 * rowPow1;
          cm30 += colPow3 * rowPow0;
          cm03 += colPow0 * rowPow3;

          cm12 += colPow1 * rowPow2;
          cm21 += colPow2 * rowPow1;

          if  (pv > maxPixVal)
            maxPixVal = pv;

          float  deltaColW = col - centroidColW;
          float  colPowW0 = 1;
          float  colPowW1 = deltaColW;
          float  colPowW2 = deltaColW * deltaColW;
          float  colPowW3 = colPowW2  * deltaColW;

          cmw20 += colPowW2 * rowPowW0;
          cmw02 += colPowW0 * rowPowW2;
          cmw30 += colPowW3 * rowPowW0;
          cmw03 += colPowW0 * rowPowW3;
          cmw12 += colPowW1 * rowPowW2;
          cmw21 += colPowW2 * rowPowW1;
        }
      }
    }

    cmw20 = cmw20 / (float)maxPixVal;
    cmw02 = cmw02 / (float)maxPixVal;
    cmw30 = cmw30 / (float)maxPixVal;
    cmw03 = cmw03 / (float)maxPixVal;
    cmw12 = cmw12 / (float)maxPixVal;
    cmw21 = cmw21 / (float)maxPixVal;
  }

  cm20  = cm20  / gamma2;
  cm02  = cm02  / gamma2;
  cm11  = cm11  / gamma2;

  cm30  = cm30  / gamma3;
  cm03  = cm03  / gamma3;
  cm12  = cm12  / gamma3;
  cm21  = cm21  / gamma3;

  cmw20 = cmw20 / gammaW2;
  cmw02 = cmw02 / gammaW2;
  cmw11 = cmw11 / gammaW2;

  cmw30 = cmw30 / gammaW3;
  cmw03 = cmw03 / gammaW3;
  cmw12 = cmw12 / gammaW3;
  cmw21 = cmw21 / gammaW3;


  centralMoments[0] = cm00;

  centralMoments[1] = cm20 + cm02;
 
  centralMoments[2] = (cm20 - cm02) * (cm20 - cm02) + 
                4.0f * cm11 * cm11;

  centralMoments[3] = (cm30 - 3.0f * cm12) * (cm30 - 3.0f * cm12) + 
                (3.0f * cm21 - cm03) * (3.0f * cm21 - cm03);

  centralMoments[4] = (cm30 + cm12) * (cm30 + cm12) + (cm21 + cm03) * (cm21 + cm03);

  centralMoments[5] = (cm30 - 3.0f * cm12) * (cm30 + cm12) * ((cm30 + cm12) * (cm30 + cm12) - 
                3.0f * (cm21 + cm03) * (cm21 + cm03))  +  (3.0f * cm21 - cm03) * (cm21 + cm03) * 
                (3.0f * (cm30 + cm12) * (cm30 + cm12) - (cm21 + cm03) * (cm21 + cm03));

  centralMoments[6] = (cm20 - cm02) * 
                ((cm30 + cm12) * (cm30 + cm12) - (cm21 + cm03) * (cm21 + cm03))
                + 4.0f * cm11 * (cm30 + cm12) * (cm21 + cm03);

  centralMoments[7] = (3.0f * cm21 - cm03) * (cm30 + cm12) * 
                ((cm30 + cm12) * (cm30 + cm12) - 3.0f * (cm21 + cm03) * (cm21 + cm03) )
               -(cm30 - 3.0f * cm12) * (cm21 + cm03) * 
               (3.0f * (cm30 + cm12) * (cm30 + cm12) - (cm21 + cm03) * (cm21 + cm03) );

  //added by baishali to calculate eccentricity
  centralMoments[8] = (((cm20 - cm02) * (cm20 - cm02)) - 
                (4.0f * cm11 * cm11))/((cm20 + cm02) * (cm20 + cm02));



  centralMomentsWeighted[0] = cmw00;

  centralMomentsWeighted[1] = cmw20 + cmw02;
 
  centralMomentsWeighted[2] = (cmw20 - cmw02) * (cmw20 - cmw02) + (float)4.0 * cmw11 * cmw11;

  centralMomentsWeighted[3] = (cmw30 - (float)3.0 * cmw12) * 
                (cmw30 - (float)3.0 * cmw12) + 
                ((float)3.0 * cmw21 - cmw03) * 
                ((float)3.0 * cmw21 - cmw03);

  centralMomentsWeighted[4] = (cmw30 + cmw12) * (cmw30 + cmw12) + (cmw21 + cmw03) * (cmw21 + cmw03);

  centralMomentsWeighted[5] = (cmw30 - (float)3.0 * cmw12) * (cmw30 + cmw12) * 
                ((cmw30 + cmw12) * (cmw30 + cmw12) - 
                 (float)3.0 * (cmw21 + cmw03) * (cmw21 + cmw03)) +
                ((float)3.0 * cmw21 - cmw03) * (cmw21 + cmw03) * 
                ((float)3.0 * (cmw30 + cmw12) * (cmw30 + cmw12) - 
                (cmw21 + cmw03) * (cmw21 + cmw03));

  centralMomentsWeighted[6] = (cmw20 - cmw02) * 
                (
                 (cmw30 + cmw12) * (cmw30 + cmw12) - 
                 (cmw21 + cmw03) * (cmw21 + cmw03)
                ) +
                (float)4.0 * cmw11 * (cmw30 + cmw12) * (cmw21 + cmw03);

  centralMomentsWeighted[7] = ((float)3.0 * cmw21 - cmw03) * 
                (cmw30 + cmw12) * ((cmw30 + cmw12) * 
                (cmw30 + cmw12) - (float)3.0 * 
                (cmw21 + cmw03) * (cmw21 + cmw03)) -
                (cmw30 - (float)3.0 * cmw12) * 
                (cmw21 + cmw03) * ((float)3.0 * 
                (cmw30 + cmw12) * (cmw30 + cmw12) - 
                (cmw21 + cmw03) * (cmw21 + cmw03));

//added by baishali to calculate eccentricity
  centralMomentsWeighted[8] = (float)((((cmw20 - cmw02) * (cmw20 - cmw02)) - 
                (4.0 * cmw11 * cmw11))/((cmw20 + cmw02) * (cmw20 + cmw02)));

  return;
}  /* CentralMoments */

void Raster::ConnectedComponent

(

uchar

connectedComponentDist

)

Definition at line 3466 of file Raster.cpp.

References blobIds, ExtractBlobs(), green, greenArea, height, KKB::Blob::Id(), KKB::BlobList::LocateLargestBlob(), totPixels, and width.

Referenced by DeriveImageLength(), and ThinContour().

{
  if  (connectedComponentDist < 1)
    connectedComponentDist = 3;

  kkint32  row = 0, col = 0;

  BlobListPtr  blobs = ExtractBlobs (connectedComponentDist);

  BlobPtr largestBlob = blobs->LocateLargestBlob ();
  if  (largestBlob)
  {
    kkint32  blobId = largestBlob->Id ();
     
    uchar*   newImageArea = new uchar[totPixels];
    memset (newImageArea, 0, totPixels);
    uchar*   newImageAreaPtr = newImageArea;

    uchar**  newRows = new uchar*[height];

    for  (row = 0; row < height; row++)
    {
      newRows[row] = newImageAreaPtr;
      
      for  (col = 0; col < width; col++)
      {
        if  (blobIds[row][col] == blobId)
        {
          newRows[row][col] = green[row][col];
        }
      }

      newImageAreaPtr = newImageAreaPtr + width;
    }

    delete  green;
    delete  greenArea;

    greenArea = newImageArea;
    green = newRows;
  }

  for  (row = 0; row < height; row++)
    delete  blobIds[row];
  delete  blobIds;
  blobIds = NULL;

  delete  blobs;  blobs = NULL;

  return;
}  /* ConnectedComponent */

void Raster::ConnectedComponent8Conected

(

)

Definition at line 3577 of file Raster.cpp.

References blobIds, KKB::BlobList::BlobList(), green, greenArea, height, KKB::Blob::Id(), KKB::Blob::id, KKB::BlobList::LocateLargestBlob(), KKB::BlobList::LookUpByBlobId(), KKB::BlobList::MergeBlobIds(), KKB::BlobList::NewBlob(), KKB::Blob::pixelCount, totPixels, and width.

{
  uchar*   curRow         = NULL;
  kkint32*   curRowBlobIds  = NULL;
  kkint32*   prevRowBlobIds = NULL;

  kkint32  col = 2;
  kkint32  row = 2;

  BlobPtr  curBlob    = NULL;
  kkint32  curBlobId  = 0;
  kkint32  nearBlobId = 0;

  kkint32  blankColsInARow = 0;

  // Initialize Blob ID's

  blobIds = new kkint32*[height];

  for  (row = 0; row < height; row++)
  {
    blobIds[row] = new kkint32[width];
    for  (col = 0; col < width; col++)
    {
      blobIds[row][col] = -1;
    }
  }

  BlobListPtr blobs = new BlobList (true);

  for  (row = 1; row < height - 1; row++)
  {
    curRow         = green[row];
    curRowBlobIds  = blobIds[row];
    prevRowBlobIds = blobIds[row - 1];


    curBlob = NULL;

    col = 1;
    while  (col < (width - 1))
    {
      if  (ForegroundPixel (curRow[col]))
      {
        blankColsInARow = 0;

        nearBlobId = Max (prevRowBlobIds[col - 1],
                          prevRowBlobIds[col],
                          prevRowBlobIds[col + 1]
                         );
        if  (curBlob)
        {
          if  (nearBlobId >= 0)
          {
            if  (nearBlobId != curBlobId)
            {
              blobs->MergeBlobIds (curBlob, nearBlobId, blobIds);
            }
          }

          curRowBlobIds[col] = curBlobId;
          curBlob->colRight  = Max (curBlob->colRight, col);
          curBlob->rowBot    = Max (curBlob->rowBot,   row);
          curBlob->pixelCount++;
        }
        else
        {
          // No Current Blob
          if  (nearBlobId >= 0)
          {
            curBlob   = blobs->LookUpByBlobId (nearBlobId);
            curBlobId = curBlob->id;
          }
          else
          {
            curBlob = blobs->NewBlob (row, col);
            curBlobId = curBlob->id;
          }

          curRowBlobIds[col] = curBlobId;
          curBlob->colLeft   = Min  (curBlob->colLeft,  col);
          curBlob->colRight  = Max (curBlob->colRight, col);
          curBlob->rowBot    = Max (curBlob->rowBot,   row);
          curBlob->rowTop    = Min  (curBlob->rowTop,   row);
          curBlob->pixelCount++;
        }
      }
      else
      {
        blankColsInARow++;
        curBlob = NULL;
        curBlobId = -1;
      }

      col++;
    }
  }

  BlobPtr largestBlob = blobs->LocateLargestBlob ();
  if  (largestBlob)
  {
    kkint32  blobId = largestBlob->Id ();
    
    uchar*   newImageArea = new uchar[totPixels];
    memset (newImageArea, 0, totPixels);
    uchar*   newImageAreaPtr = newImageArea;

    uchar**  newRows = new uchar*[height];

    for  (row = 0; row < height; row++)
    {
      newRows[row] = newImageAreaPtr;
      
      for  (col = 0; col < width; col++)
      {
        if  (blobIds[row][col] == blobId)
        {
          newRows[row][col] = green[row][col];
        }
      }

      newImageAreaPtr = newImageAreaPtr + width;
    }

    delete  green;
    delete  greenArea;

    greenArea = newImageArea;
    green = newRows;
  }

  for  (row = 0; row < height; row++)
    delete  blobIds[row];
  delete  blobIds;
  blobIds = NULL;

  delete  blobs;  blobs = NULL;

  return;
}  /* ConnectedComponent8Conected */

RasterPtr Raster::CreateColor

(

)

const

Definition at line 6028 of file Raster.cpp.

References color, KKB::PixelValue::FromHSI(), green, height, KKB::PixelValue::operator=(), Raster(), SetPixelValue(), KKB::PixelValue::White, and width.

{
  if  (color)
    return new Raster (*this);

  RasterPtr  colorImage = new Raster (height, width, true);

  uint  x = 0;
  PixelValue  pv[256];
  for  (x = 0;  x < 256;  ++x)
  {
    pv[x] = PixelValue::FromHSI ((float)x, 1.0f, 1.0f);
  }

  for  (int r = 0;  r < height;  ++r)
  {
    uchar*  rowData = green[r];
    for  (int c = 0;  c < width;  ++c)
    {
      uchar  intensity = rowData[c];
      if  (intensity == 0)
        colorImage->SetPixelValue (r, c, PixelValue::White);
      else
        colorImage->SetPixelValue (r, c, pv[rowData[c]]);
    }
  }

  return   colorImage;
}

RasterPtr Raster::CreateColorImageFromLabels

(

)

Produces a color image using the 'greenArea' channel, assuming that each unique value will be assigned a unique color.

Assuming that each value in the channel(GreenArea) will be assigned a different color useful for image created by "SegmentorOTSU::SegmentImage".

See also

Raster::CreateKLT

Definition at line 9837 of file Raster.cpp.

References AllocateARasterInstance(), KKB::PixelValue::b, KKB::PixelValue::Black, BlueArea(), KKB::PixelValue::FromHSI(), KKB::PixelValue::g, GreenArea(), greenArea, height, KKB::PixelValue::operator=(), KKB::PixelValue::r, RedArea(), totPixels, and width.

{
  kkint32  x = 0;

  // Determine number of unique values in greenArea channel.
  kkint32  freqCount[256];
  for  (x = 0;  x < 256;  ++x)
    freqCount[x] = 0;
  for  (x = 0;  x < totPixels;  ++x)
    freqCount[greenArea[x]]++;

  multimap<kkint32,uchar>  sortedFreqCounts;
  for  (x = 0;  x < 256;  ++x)
  {
    if  (freqCount[x] > 0)
      sortedFreqCounts.insert (pair<kkint32,uchar> (freqCount[x], (uchar)x));
  }

  PixelValue  colorAssignments[256];
  colorAssignments[0] = PixelValue::Black;
  kkint32  numUniqueValues = (kkint32)sortedFreqCounts.size ();
  multimap<kkint32,uchar>::reverse_iterator  idx;
  x = 0;
  for  (idx = sortedFreqCounts.rbegin ();  idx != sortedFreqCounts.rend ();  ++idx)
  {
    kkint32  pixelValue = idx->second;
    colorAssignments[pixelValue] = PixelValue::FromHSI ((float)x / (float)numUniqueValues, 1.0f, 1.0f);
    x++;
  }

  RasterPtr  colorImage = AllocateARasterInstance (height, width, true);
  uchar*  destRed   = colorImage->RedArea   ();
  uchar*  destGreen = colorImage->GreenArea ();
  uchar*  destBlue  = colorImage->BlueArea  ();
  for  (x = 0;  x < totPixels;  ++x)
  {
    PixelValue& pv = colorAssignments[greenArea[x]];
    destRed  [x] = pv.r;
    destGreen[x] = pv.g;
    destBlue [x] = pv.b;
  }

  return  colorImage;
}  /* CreateColorImageFromLabels */

RasterPtr Raster::CreateColorWithBlobsLabeldByColor

(

BlobListPtr

blobs

)

Returns image where each blob is labeled with a different color.

Only useful if 'ExtractBlobs' was performed on this instance. Eight different colors are used and they are selected by the modules of the blobId(blobId % 8). Assignments are 0:Red, 1:Green, 2:Blue, 3:Yellow, 4:Orange, 5:Magenta, 6:Purple, 7:Teal.Only useful if 'ExtractBlobs' was performed on this instance, the returned image will be color with each blob labeled a different color.

Only useful if 'ExtractBlobs' was performed on this instance.

Definition at line 3331 of file Raster.cpp.

References AllocateARasterInstance(), blobIds, KKB::PixelValue::Blue, KKB::PixelValue::Green, height, KKB::Blob::Id(), KKB::PixelValue::Magenta, KKB::PixelValue::operator=(), KKB::PixelValue::Orange, KKB::PixelValue::Purple, KKB::PixelValue::Red, SetPixelValue(), KKB::PixelValue::Teal, width, and KKB::PixelValue::Yellow.

{
  RasterPtr  colorImage = AllocateARasterInstance (height, width, true);
  if  (blobs == NULL)
    return colorImage;

  if  (blobIds == NULL)
    return colorImage;

  BlobList::iterator  idx;
  for  (idx = blobs->begin ();  idx != blobs->end ();  ++idx)
  {
    BlobPtr  blob = idx->second;
    kkint32  blobId = blob->Id ();
    kkint32  row = 0, col = 0;

    PixelValue  color;
    switch  (blobId % 8)
    {
    case  0:  color = PixelValue::Red;      break;
    case  1:  color = PixelValue::Green;    break;
    case  2:  color = PixelValue::Blue;     break;
    case  3:  color = PixelValue::Yellow;   break;
    case  4:  color = PixelValue::Orange;   break;
    case  5:  color = PixelValue::Magenta;  break;
    case  6:  color = PixelValue::Purple;   break;
    case  7:  color = PixelValue::Teal;     break;
    }

    kkint32  rowStart = Min (blob->RowTop   (), height - 1);
    kkint32  rowEnd   = Min (blob->RowBot   (), height - 1);
    kkint32  colStart = Min (blob->ColLeft  (), width  - 1);
    kkint32  colEnd   = Min (blob->ColRight (), width  - 1);

    for  (row = rowStart;  row <= rowEnd;  ++row)
    {
      for  (col = colStart;  col <= colEnd;  ++col)
      {
        if  (blobIds[row][col] == blobId)
        {
          colorImage->SetPixelValue (row, col, color);
        }
      }
    }
  }

  return  colorImage;
}  /* CreateColorWithBlobsLabeldByColor*/

RasterPtr Raster::CreateDilatedRaster

(

)

const

Definition at line 1623 of file Raster.cpp.

References AllocateARasterInstance(), foregroundPixelCount, green, height, and width.

Referenced by Dilation().

{
  kkint32  row;
  kkint32  col;

  kkint32  resultForegroundPixelCount = 0;

  RasterPtr  result = AllocateARasterInstance (*this);

  uchar** resultRows = result->green;

  kkint32  totValue     = 0;
  uchar  numNeighbors = 0;

  uchar*  resultRow = NULL;

  for  (row = 0; row < height; row++)
  {
    resultRow = resultRows[row];
    for  (col = 0; col < width; col++)
    {
      if  (BackgroundPixel (resultRow[col]))
      {
        // Since we are a blank cell we want our value to be set to the average value of our occupied neighbors.
        totValue     = 0;
        numNeighbors = 0;

        CalcDialatedValue (row - 1, col - 1, totValue, numNeighbors);
        CalcDialatedValue (row - 1, col,     totValue, numNeighbors);
        CalcDialatedValue (row - 1, col + 1, totValue, numNeighbors);

        CalcDialatedValue (row    , col - 1, totValue, numNeighbors);
        CalcDialatedValue (row    , col + 1, totValue, numNeighbors);

        CalcDialatedValue (row + 1, col - 1, totValue, numNeighbors);
        CalcDialatedValue (row + 1, col    , totValue, numNeighbors);
        CalcDialatedValue (row + 1, col + 1, totValue, numNeighbors);

        if  (numNeighbors > 0)
        {
          resultRow[col] = (uchar)(totValue / numNeighbors);
          resultForegroundPixelCount++;
        }
      }
      else
      {
        resultForegroundPixelCount++;
      }
    }
  }

  result->foregroundPixelCount = resultForegroundPixelCount;
  return  result;
}  /* CreateDilatedRaster */

RasterPtr Raster::CreateDilatedRaster

(

MaskTypes

mask

)

const

Definition at line 1702 of file Raster.cpp.

References AllocateARasterInstance(), foregroundPixelCount, green, height, and width.

Referenced by Dilation().

{
  kkint32 row;
  kkint32 col;

  RasterPtr  result = AllocateARasterInstance (*this);

  uchar** resultRows = result->green;

  //uchar  numNeighbors = 0;

  //for  (row = 1; row < (height - 1); row++)
  //{
  //  for  (col = 1; col < (width - 1); col++)
  //  {
  //    if  (resultRows[row][col] == 0)
  //    {
  //      resultRows[row][col] = Hit (mask, row, col);
  //    }
  //  }
  //}

  kkint32  resultForegroundPixelCount = 0;
  uchar*  resultRow = NULL;
  uchar   pixelValue;
  for  (row = 0; row < height; row++)
  {
    resultRow = resultRows[row];
    for  (col = 0; col < width; col++)
    {
      if  (BackgroundPixel (resultRow[col]))
      {
        pixelValue = Hit (mask, row, col);
        resultRow[col] = pixelValue;
        if  (!BackgroundPixel (pixelValue))
          resultForegroundPixelCount++;
      }
      else
      {
        resultForegroundPixelCount++;
      }
    }
  }

  result->foregroundPixelCount = resultForegroundPixelCount;

  return  result;
}  /* CreateDilatedRaster */

RasterPtr Raster::CreateErodedImage

(

MaskTypes

mask

)

const

Definition at line 2906 of file Raster.cpp.

References AllocateARasterInstance(), backgroundPixelValue, foregroundPixelCount, Green(), green, height, and width.

Referenced by DeriveImageLength().

{
  kkint32  r;
  kkint32  c;

  RasterPtr   erodedRaster = AllocateARasterInstance (*this);

  uchar*      srcRow    = NULL;
  uchar**     destGreen = erodedRaster->Green ();
  uchar*      destRow   = NULL;

  kkint32  erodedForegroundPixelCount = foregroundPixelCount;

  for  (r = 0;  r < height;  ++r)
  {
    destRow = destGreen[r];
    srcRow  = green[r];

    for  (c = 0;  c < width;  ++c)
    {
      if  (ForegroundPixel (srcRow[c]))
      {
        if  (!Fit (mask, r, c))
        {
          destRow[c] = backgroundPixelValue;
          erodedForegroundPixelCount--;
        }
      }
    }  /* for (c) */
  }  /* for (r) */

  erodedRaster->foregroundPixelCount = erodedForegroundPixelCount;

  return  erodedRaster;
}  /* Erosion  */

RasterPtr Raster::CreateFromOrginalImageWithSpecifidBlobsOnly	(	RasterPtr	origImage,
		BlobListPtr	blobs
	)

Returns a copy of 'origImage' where only the blobs specified in 'blobs' are copied over.

Example:
    origImage = image that we want to segment and get list of discrete blobs from.
    RasterPtr  segmentedImage = origImage->SegmentImage ();
    BlobListPtr  blobs = segmentedImage->ExtractBlobs (1);
    RasterPtr  imageWithBlobOnly = segmentedImage->CreateFromOrginalImageWithSpecifidBlobsOnly (blobs);

Parameters

[in]	origImage	Image that this instance was derived for, must have same dimensions.
[in]	blobs	List of blob's that you want copied into new Raster instance that is created..

Returns

Image consisting of specified blobs only.

Definition at line 3382 of file Raster.cpp.

References AllocateARasterInstance(), blobIds, GetPixelValue(), height, KKB::Blob::Id(), SetPixelValue(), and width.

{
  RasterPtr  resultImage = AllocateARasterInstance (height, width, true);
  if  (blobs == NULL)
    return resultImage;

  if  (blobIds == NULL)
    return resultImage;

  BlobList::iterator  idx;
  for  (idx = blobs->begin ();  idx != blobs->end ();  ++idx)
  {
    BlobPtr  blob = idx->second;
    kkint32  blobId = blob->Id ();
    kkint32  row = 0, col = 0;

    kkint32  rowStart = Min (blob->RowTop   (), height - 1);
    kkint32  rowEnd   = Min (blob->RowBot   (), height - 1);
    kkint32  colStart = Min (blob->ColLeft  (), width  - 1);
    kkint32  colEnd   = Min (blob->ColRight (), width  - 1);

    PixelValue  pixelValue;

    for  (row = rowStart;  row <= rowEnd;  ++row)
    {
      for  (col = colStart;  col <= colEnd;  ++col)
      {
        if  (blobIds[row][col] == blobId)
        {
          origImage->GetPixelValue (row, col, pixelValue);
          resultImage->SetPixelValue (row, col, pixelValue);
        }
      }
    }
  }

  return  resultImage;
}  /* CreateFromOrginalImageWithSpecifidBlobsOnly*/

RasterPtr Raster::CreateGaussianSmoothedImage

(

float

sigma

)

const

Definition at line 9433 of file Raster.cpp.

References AllocateARasterInstance(), blue, BuildGaussian2dKernel(), color, green, and red.

{
  MatrixPtr  kernel = BuildGaussian2dKernel (sigma);

  RasterPtr  result = AllocateARasterInstance (*this);

  SmoothUsingKernel (*kernel, this->green, result->green);
  if  (color)
  {
    SmoothUsingKernel (*kernel, red,  result->red);
    SmoothUsingKernel (*kernel, blue, result->blue);
  }

  delete  kernel;
  kernel = NULL;

  return  result;
}  /* CreateGaussianSmoothedImage */

RasterPtr Raster::CreateGrayScale

(

)

const

Definition at line 6060 of file Raster.cpp.

References AllocateARasterInstance(), blueArea, color, GreenArea(), greenArea, height, redArea, totPixels, and width.

Referenced by HistogramGrayscaleImage(), KKB::SaveImagePGM(), and SegmentImage().

{
  if  (!color)
  {
    // Already a gray-scale image,  Just return copy of self.
    return  (AllocateARasterInstance (*this));
  }

  kkint32  h = height;
  kkint32  w = width;

  RasterPtr  grayRaster = AllocateARasterInstance (h, w, false);
  uchar* grayPtr  = grayRaster->GreenArea ();
  uchar* redPtr   = redArea;
  uchar* greenPtr = greenArea;
  uchar* bluePtr  = blueArea;

  for  (kkint32 x = 0;  x < totPixels;  ++x, ++grayPtr, ++redPtr, ++greenPtr, ++bluePtr)
  {
    *grayPtr = (uchar)((kkuint32)((0.30f) * (float)(*redPtr)    +  
                              (0.59f) * (float)(*greenPtr)  +  
                              (0.11f) * (float)(*bluePtr)
                             )
                      );
  }
  return  grayRaster;
}  /* CreateGrayScale */

RasterPtr Raster::CreateGrayScaleKLT

(

)

const

Creates a image using a KLT Transform with the goal of weighting in favor the color channels with greatest amount of variance.

The idea is to weight each color channel by the amount of variance. This is accomplished by producing a covariance matrix of the three color channels and then taking the Eigen-Vector with the largest eigen value and using its components to derive weights for each channel for the conversion from RGB to grayscale.

Definition at line 9503 of file Raster.cpp.

References AllocateARasterInstance(), blueArea, color, KKB::Matrix::EigenVectors(), KKB::Matrix::GetCol(), GreenArea(), greenArea, Height(), KKB::Matrix::Matrix(), KKB::Matrix::operator[](), KKB::Row::operator[](), redArea, totPixels, and Width().

Referenced by KKB::MorphOpSobel::PerformOperation(), KKB::SegmentorOTSU::SegmentImage(), and KKB::SegmentorOTSU::SegmentMaskedImage().

{
  if  (!color)
  {
    // Already a Gray-scale image,  nothing much to do.
    return AllocateARasterInstance (*this);
  }

  kkuint32  x = 0;

  MatrixPtr  cov = new Matrix (3, 3);
  {
    // Build a covariance matrix.
    kkint32  col = 0, row = 0;

    double*   totals       = new double[3];
    double*   means        = new double[3];
    double**  centeredVals = new double*[3];
    for  (col = 0;  col < 3;  ++col)
    {
      totals[col] = 0.0;
      means [col] = 0.0;
      centeredVals[col] = new double[totPixels];
    }

    for  (row = 0;  row < totPixels;  ++row)
    {
      totals[0] += (double)redArea   [row];
      totals[1] += (double)greenArea [row];
      totals[2] += (double)blueArea  [row];
    }

    for  (col = 0;  col < 3;  ++col)
      means[col] = totals[col] / (double)totPixels;

    for  (row = 0;  row < totPixels;  ++row)
    {
      centeredVals[0][row] = (double)redArea   [row] - means[0];
      centeredVals[1][row] = (double)greenArea [row] - means[1];
      centeredVals[2][row] = (double)blueArea  [row] - means[2];
    }
 
    for  (kkint32 varIdxX = 0;  varIdxX < 3;  ++varIdxX)
    {
      double*  varXs = centeredVals[varIdxX];
      for  (kkint32 varIdxY = varIdxX;  varIdxY < 3;  ++varIdxY)
      {
        // Calculate the covariance between chanIdx0 and chanIdx1

        double*  varYs = centeredVals[varIdxY];
        double total = 0.0f;
        for  (row = 0;  row < totPixels;  ++row)
          total += varXs[row] * varYs[row];
        (*cov)[varIdxX][varIdxY] = total / (double)(totPixels - 1);
        (*cov)[varIdxY][varIdxX]  = (*cov)[varIdxX][varIdxY];
      }
    }

    for  (col = 0;  col < 3;  col++)
    {
      delete[]  centeredVals[col];
      centeredVals[col] = NULL;
    }
    delete[]  centeredVals;   centeredVals = NULL;
    delete[]  means;          means  = NULL;
    delete[]  totals;         totals = NULL;
  }
 
  MatrixPtr      eigenVectors = NULL;
  VectorDouble*  eigenValues  = NULL;

  cov->EigenVectors (eigenVectors, eigenValues);
  if  (!eigenVectors)
  {
    cerr << std::endl << std::endl 
      << "Raster::CreateGrayScaleKLT  ***ERROR***   Could not derive Eigen Vectors of covariance matrix." << std::endl
      << std::endl;
    delete  cov;
    cov = NULL;
    return NULL;
  }

  kkint32 eigenValueMaxIdx = 0;
  double  eigenValueMax    = (*eigenValues)[0];
  for  (x = 1;  x < eigenValues->size ();  ++x)
  {
    if  ((*eigenValues)[x] > eigenValueMax)
    {
      eigenValueMaxIdx = x;
      eigenValueMax = (*eigenValues)[x];
    }
  }

  VectorDouble  eigenVector = eigenVectors->GetCol (eigenValueMaxIdx);
  // We are now going to do Matrix multiplication between the original image and the eigenVector
  // but since the eigen vector may have negative values the resultant numbers can be negative for
  // some pixels and a magnitude greater than 255.  We will place temporarily into a floating 
  // array,  after which we will use the adjustment value and scaling factor.
  double  redFact   = eigenVector[0];
  double  greenFact = eigenVector[1];
  double  blueFact  = eigenVector[2];
  double  adjVal    = 0.0;

  double  valMin = DBL_MAX;
  double  valMax = DBL_MIN;
  double*  adjChannel = new double [totPixels];
  for  (kkint32 y = 0;  y < totPixels;  ++y)
  {
    adjVal = (double)redArea  [y] * redFact    +
             (double)greenArea[y] * greenFact  +
             (double)blueArea [y] * blueFact;
    if  (adjVal < valMin)  valMin = adjVal;
    if  (adjVal > valMax)  valMax = adjVal;
    adjChannel[y] = adjVal;
  }

  if  (valMax <= valMin)  valMax = valMin + 1.0;   // This would only happen if the whole image had the same GrayScale value.

  //double  adjScaleFact = 256.0 / (1 + valMax - valMin);
  double  adjScaleFact = 255.0 / (valMax - valMin);

  RasterPtr  result = AllocateARasterInstance (Height (), Width (), false);
  {
    uchar*  resultArea = result->GreenArea ();
    for  (kkint32 y = 0;  y < totPixels;  ++y)
    {
      resultArea[y] = (uchar)Min ((kkint32)((adjChannel[y] - valMin) * adjScaleFact + 0.5), (kkint32)255);
    }
  }
  delete[]  adjChannel;  adjChannel   = NULL;
  delete  cov;           cov          = NULL;
  delete  eigenValues;   eigenValues  = NULL;
  delete  eigenVectors;  eigenVectors = NULL;

  return  result;
}  /* CreateGrayScaleKLT */

RasterPtr Raster::CreateGrayScaleKLTOnMaskedArea

(

const Raster &

mask

)

const

Same as 'CreateKLT' except it will only take into account pixels specified by the 'mask' image.

Parameters

[in]

mask

Raster object where pixels that are greater than 'backgroundPixelTH' are to be considered.

Definition at line 9643 of file Raster.cpp.

References AllocateARasterInstance(), backgroundPixelTH, blueArea, color, KKB::Matrix::EigenVectors(), KKB::Matrix::GetCol(), GreenArea(), greenArea, Height(), height, KKB::Matrix::Matrix(), KKB::Matrix::operator[](), KKB::Row::operator[](), redArea, TotalBackgroundPixels(), totPixels, Width(), and width.

Referenced by KKB::SegmentorOTSU::SegmentMaskedImage().

{
  if  (!color)
  {
    // Already a Gray-scale image,  nothing much to do.
    return AllocateARasterInstance (*this);
  }

  if  ((mask.Height () != height)  ||  (mask.Width () != width))
  {
    cerr << std::endl << std::endl
      << "Raster::CreateGrayScaleKLTOnMaskedArea   ***ERROR***   Mask image dimensions must match !!!!" << std::endl
      << "                    Our[" << height << "," << width << "]  Mask[" << mask.height << "," << mask.width << "]." << std::endl
      << std::endl;
    return NULL;
  }

  uchar*  maskArea = mask.GreenArea ();
  uchar   maskTh   = mask.backgroundPixelTH;

  kkint32  totalMaskPixels = mask.TotalBackgroundPixels ();

  MatrixPtr  cov = new Matrix (3, 3);
  {
    // Build a covariance matrix.
    kkint32  col = 0, row = 0;

    double*   totals       = new double[3];
    double*   means        = new double[3];
    double**  centeredVals = new double*[3];
    for  (col = 0;  col < 3;  ++col)
    {
      totals[col] = 0.0;
      means [col] = 0.0;
      centeredVals[col] = new double[totPixels];
    }

    for  (row = 0;  row < totPixels;  ++row)
    {
      if  (maskArea[row] > maskTh)
      {
        totals[0] += (double)redArea   [row];
        totals[1] += (double)greenArea [row];
        totals[2] += (double)blueArea  [row];
      }
    }

    for  (col = 0;  col < 3;  ++col)
      means[col] = totals[col] / (double)totalMaskPixels;

    for  (row = 0;  row < totPixels;  ++row)
    {
      if  (maskArea[row] > maskTh)
      {
        centeredVals[0][row] = (double)redArea   [row] - means[0];
        centeredVals[1][row] = (double)greenArea [row] - means[1];
        centeredVals[2][row] = (double)blueArea  [row] - means[2];
      }
    }
 
    for  (kkint32 varIdxX = 0;  varIdxX < 3;  ++varIdxX)
    {
      double*  varXs = centeredVals[varIdxX];
      for  (kkint32 varIdxY = varIdxX;  varIdxY < 3;  ++varIdxY)
      {
        // Calculate the covariance between chanIdx0 and chanIdx1

        double*  varYs = centeredVals[varIdxY];
        double total = 0.0f;
        for  (row = 0;  row < totPixels;  ++row)
        {
          if  (maskArea[row] > maskTh)
            total += varXs[row] * varYs[row];
        }
        (*cov)[varIdxX][varIdxY] = total / (double)(totalMaskPixels - 1);
        (*cov)[varIdxY][varIdxX]  = (*cov)[varIdxX][varIdxY];
      }
    }

    for  (col = 0;  col < 3;  col++)
    {
      delete  centeredVals[col];
      centeredVals[col] = NULL;
    }
    delete[]  centeredVals;   centeredVals = NULL;
    delete[]  means;          means  = NULL;
    delete[]  totals;         totals = NULL;
  }
 
  MatrixPtr      eigenVectors = NULL;
  VectorDouble*  eigenValues  = NULL;

  cov->EigenVectors (eigenVectors, eigenValues);
  if  (!eigenVectors)
  {
    cerr << std::endl << std::endl 
      << "Raster::CreateGrayScaleKLT  ***ERROR***   Could not derive Eigen Vectors of covariance matrix." << std::endl
      << std::endl;
    delete  cov;
    cov = NULL;
    return NULL;
  }

  kkint32 eigenValueMaxIdx = 0;
  double  eigenValueMax    = (*eigenValues)[0];
  for  (kkuint32 y = 1;  y < eigenValues->size ();  ++y)
  {
    if  ((*eigenValues)[y] > eigenValueMax)
    {
      eigenValueMaxIdx = y;
      eigenValueMax = (*eigenValues)[y];
    }
  }

  VectorDouble  eigenVector = eigenVectors->GetCol (eigenValueMaxIdx);
  // We are now going to do Matrix multiplication between the original image and the eigenVector
  // but since the eigen vector may have negative values the resultant numbers can be negative for
  // some pixels and a magnitude greater than 255.  We will place temporarily into a floating 
  // array,  after which we will no the adjustment value and scaling factor.

  double  redFact   = eigenVector[0];
  double  greenFact = eigenVector[1];
  double  blueFact  = eigenVector[2];
  double  adjVal    = 0.0;

  double  valMin = DBL_MAX;
  double  valMax = -9999999999.99;
  double*  adjChannel = new double [totPixels];
  for  (kkint32 y = 0;  y < totPixels;  ++y)
  {
    if  (maskArea[y] > maskTh)
    {
      adjVal = (double)redArea  [y] * redFact    +
               (double)greenArea[y] * greenFact  +
               (double)blueArea [y] * blueFact;
      if  (adjVal < valMin)  valMin = adjVal;
      if  (adjVal > valMax)  valMax = adjVal;
      adjChannel[y] = adjVal;
    }
    else
    {
      adjChannel[y] = 0.0;
    }
  }

  if  (valMax <= valMin)  valMax = valMin + 1.0;   // This would only happen if the whole image had the same GrayScale value.

  //double  adjScaleFact = 256.0 / (1 + valMax - valMin);
  double  adjScaleFact = 255.0 / (valMax - valMin);

  RasterPtr  result = AllocateARasterInstance (Height (), Width (), false);
  {
    uchar*  resultArea = result->GreenArea ();
    for  (kkint32 y = 0;  y < totPixels;  ++y)
    {
      if  (maskArea[y] > maskTh)
        resultArea[y] = (uchar)Min ((kkint32)((adjChannel[y] - valMin) * adjScaleFact + 0.5), (kkint32)255);
      else
        resultArea[y] = 0;
    }
  }
  delete[] adjChannel;    adjChannel   = NULL;
  delete   cov;           cov          = NULL;
  delete   eigenValues;   eigenValues  = NULL;
  delete   eigenVectors;  eigenVectors = NULL;

  return  result;
}  /* CreateGrayScaleKLTOnMaskedArea */

RasterPtr Raster::CreatePaddedRaster ( BmpImage &  image, kkint32  padding  )

static

Definition at line 1131 of file Raster.cpp.

References foregroundPixelCount, green, KKB::BmpImage::Height(), KKB::BmpImage::ImageRow(), Raster(), and KKB::BmpImage::Width().

{
  kkint32  oldWidth  = image.Width  ();
  kkint32  oldHeight = image.Height ();

  kkint32  newWidth  = oldWidth  + 2 * padding;
  kkint32  newHeight = oldHeight + 2 * padding;

  RasterPtr  paddedRaster = new Raster (newHeight, newWidth, false);

  //const uchar**  oldRows = image.Image ();

  uchar**  newRows = paddedRaster->green;

  kkint32  newRow = padding;
  kkint32  row;
  kkint32  col;

  kkint32  paddedForgroudPixelCount = 0;

  for  (row = 0;  row < oldHeight;  row++)
  {
    const uchar* oldRow = image.ImageRow (row);
    
    kkint32  newCol = padding;
    for  (col = 0; col < oldWidth;  col++)
    {
      if  (oldRow[col] > 0)
         paddedForgroudPixelCount++;

      newRows[newRow][newCol] = oldRow[col];
      newCol++;
    }

    newRow++;
  }

  paddedRaster->foregroundPixelCount = paddedForgroudPixelCount;

  return  paddedRaster; 
}  /* CreatePaddedRaster */

RasterPtr Raster::CreateSmoothedMediumImage

(

kkint32

maskSize

)

const

Definition at line 7229 of file Raster.cpp.

References AllocateARasterInstance(), Blue(), color, Green(), green, height, Red(), and width.

{
  RasterPtr  result = AllocateARasterInstance (*this);
  if  (maskSize < 2)
    return result;

  uchar**  destR = result->Red   ();
  uchar**  destG = result->Green ();
  uchar**  destB = result->Blue  ();

  kkint32  maxCandidates = maskSize * maskSize;
  uchar*  candidatesRed   = NULL;
  uchar*  candidatesGreen = new uchar[maxCandidates];
  uchar*  candidatesBlue  = NULL;
  if  (color)
  {
    candidatesRed  = new uchar[maxCandidates];
    candidatesBlue = new uchar[maxCandidates];
  }

  kkint32  numCandidates = 0;
  kkint32  middleCandidate = 0;

  kkint32  row, col;

  kkint32  firstMaskRow, firstMaskCol;
  kkint32  lastMaskRow,  lastMaskCol;

  kkint32  maskRow,  maskCol;

  kkint32  maskOffset = maskSize / 2;

  //uchar*  srcRow = NULL;
  
  for  (row = 0;  row < height;  row++)
  {
    firstMaskRow = row - maskOffset;
    lastMaskRow  = firstMaskRow + maskSize - 1;

    firstMaskRow = Max ((kkint32)0, firstMaskRow);
    lastMaskRow  = Min (lastMaskRow, (kkint32)(height - 1));
    
    for  (col = 0;  col < width;  col++)
    {
      firstMaskCol = col - maskOffset;
      lastMaskCol = firstMaskCol + maskSize - 1;
      firstMaskCol = Max (firstMaskCol, (kkint32)0);
      lastMaskCol  = Min (lastMaskCol,  (kkint32)(width - 1));

      //if  (ForegroundPixel (row, col))
      //{
        numCandidates = 0;

        for  (maskRow = firstMaskRow;  maskRow <= lastMaskRow;  maskRow++)
        {
          for  (maskCol = firstMaskCol;  maskCol <= lastMaskCol;  maskCol++)
          {
            //if  (ForegroundPixel (maskRow, maskCol))
            //{
              candidatesGreen[numCandidates] = green[maskRow][maskCol];
              if  (color)
              {
                candidatesRed[numCandidates]  = green[maskRow][maskCol];
                candidatesBlue[numCandidates] = green[maskRow][maskCol];
              }
              numCandidates++;
            //}
          }
        }

        middleCandidate = numCandidates / 2;
        uchar  medium = FindKthValue (candidatesGreen, numCandidates, middleCandidate);
        destG[row][col] = medium;

        if  (color)
        {
          medium = FindKthValue (candidatesRed, numCandidates, middleCandidate);
          destR[row][col] = medium;
          medium = FindKthValue (candidatesBlue, numCandidates, middleCandidate);
          destB[row][col] = medium;
        }
        //}
    }
  }

  delete[]  candidatesRed;    candidatesRed   = NULL;
  delete[]  candidatesGreen;  candidatesGreen = NULL;
  delete[]  candidatesBlue;   candidatesBlue  = NULL;

  return  result;
} /* CreateSmoothedMediumImage */

RasterPtr Raster::CreateSmoothImage

(

kkint32

maskSize = 3

)

const

Definition at line 7152 of file Raster.cpp.

References AllocateARasterInstance(), Blue(), blue, Green(), green, Red(), and red.

Referenced by SegmentImage().

{
  RasterPtr  result = AllocateARasterInstance (*this);
  if  (maskSize < 2)
    return result;

  if  (red)
    SmoothImageChannel (red,   result->Red   (), maskSize);

  if  (green)
    SmoothImageChannel (green, result->Green (), maskSize);

  if  (blue)
    SmoothImageChannel (blue,  result->Blue  (), maskSize);

  return  result;
} /* CreateSmoothImage */

PointListPtr Raster::DeriveImageLength

(

)

const

Definition at line 9922 of file Raster.cpp.

References CalcOrientationAndEigerRatio(), ConnectedComponent(), CreateErodedImage(), Erosion(), FillHole(), FindBoundingBox(), Green(), height, KKB::Point::Point(), KKB::PointList::PointList(), Rotate(), RotateDerivePreRotatedPoint(), KKB::MorphOp::SQUARE3, KKB::MorphOp::SQUARE7, and width.

{
  PointListPtr  results = NULL;

  float  eigenRatio;
  float  orientationAngle;

  RasterPtr  workRaster = CreateErodedImage(MorphOp::MaskTypes::SQUARE3);
  workRaster->FillHole ();
  workRaster->Erosion(MorphOp::MaskTypes::SQUARE7);
  workRaster->ConnectedComponent (1);
  workRaster->CalcOrientationAndEigerRatio (eigenRatio,
                                            orientationAngle
                                           );
  if  ((orientationAngle > TwoPie)  ||  (orientationAngle < -TwoPie))
  {
    orientationAngle = 0.0;
    eigenRatio = 1.0;
  }
 
  RasterPtr rotatedImage = workRaster->Rotate (orientationAngle);
  kkint32  tlRow;
  kkint32  tlCol;
  kkint32  brRow;
  kkint32  brCol;

  rotatedImage->FindBoundingBox (tlRow, tlCol, brRow, brCol);
  if  (tlRow >= 0)
  {
    uchar**  imageData = rotatedImage->Green ();

    kkint32  boxWidth  = brCol - tlCol;
    kkint32  boxHeight = brRow - tlRow;

    kkint32  mark1Col = (kkint32)((float)boxWidth * 0.05f + 0.5f) + tlCol;
    kkint32  mark2Col = (kkint32)((float)boxWidth * 0.95f + 0.5f) + tlCol;

    kkint32  a1RowTot   = 0;
    kkint32  a1ColTot   = 0;
    kkint32  a1PixCount = 0l;

    kkint32  a2RowTot   = 0;
    kkint32  a2ColTot   = 0;
    kkint32  a2PixCount = 0l;

    kkint32  a3RowTot   = 0;
    kkint32  a3ColTot   = 0;
    kkint32  a3PixCount = 0;

    for  (kkint32 row = tlRow;  row <= brRow;  ++row)
    {
      kkint32 col = 0;

      uchar*  rowData = imageData[row];

      for  (col = tlCol;  col <= mark1Col;  ++col)
      {
        if  (rowData[col] > 2)
        {
          ++a1PixCount;
          a1RowTot += row;
          a1ColTot += col;
        }
      }

      for  (col = mark1Col + 1;  col <= mark2Col;  ++col)
      {
        if  (rowData[col] > 2)
        {
          ++a2PixCount;
          a2RowTot += row;
          a2ColTot += col;
        }
      }

      for  (col = mark2Col + 1;  col <= brCol;  ++col)
      {
        if  (rowData[col] > 2)
        {
          ++a3PixCount;
          a3RowTot += row;
          a3ColTot += col;
        }
      }
    }

    a1PixCount = Max ((kkint32)1, a1PixCount);
    a2PixCount = Max ((kkint32)1, a2PixCount);
    a3PixCount = Max ((kkint32)1, a3PixCount);

    Point p1 ((kkint16)(0.5f + a1RowTot / a1PixCount), (kkint16)(0.5f + a1ColTot / a1PixCount));
    Point p2 ((kkint16)(0.5f + a2RowTot / a2PixCount), (kkint16)(0.5f + a2ColTot / a2PixCount));
    Point p3 ((kkint16)(0.5f + a3RowTot / a3PixCount), (kkint16)(0.5f + a3ColTot / a3PixCount));

   
    Point p1Orig = RotateDerivePreRotatedPoint (height, width, p1, orientationAngle);
    Point p2Orig = RotateDerivePreRotatedPoint (height, width, p2, orientationAngle);
    Point p3Orig = RotateDerivePreRotatedPoint (height, width, p3, orientationAngle);

    results = new PointList (true);
    results->PushOnBack (new Point (p1Orig));
    results->PushOnBack (new Point (p2Orig));
    results->PushOnBack (new Point (p3Orig));
  }


  delete rotatedImage;  rotatedImage = NULL;
  delete workRaster;    workRaster   = NULL;

  return  results;

}  /* DeriveImageLength */

void Raster::Dilation

(

)

Definition at line 1681 of file Raster.cpp.

References CreateDilatedRaster(), foregroundPixelCount, green, and greenArea.

Referenced by Closing(), and Opening().

{
  RasterPtr  tempRaster = CreateDilatedRaster ();

  delete  greenArea;
  delete  green;

  greenArea = tempRaster->greenArea;
  green     = tempRaster->green;
 
  tempRaster->greenArea = NULL;
  tempRaster->green     = NULL;

  foregroundPixelCount = tempRaster->foregroundPixelCount;

  delete  tempRaster;
}  /* Dilation */

void Raster::Dilation

(

RasterPtr

dest

)

const

Definition at line 1804 of file Raster.cpp.

References backgroundPixelTH, Color(), color, foregroundPixelCount, Green(), GreenArea(), Height(), height, ReSize(), Width(), and width.

Referenced by KKMLL::GrayScaleImagesFVProducer::ComputeFeatureVector().

{
  if  ((dest->Height () != height)  ||  (dest->Width () != width)  ||  (dest->Color ()  != color))
    dest->ReSize (height, width, color);

  uchar*   srcArea  = GreenArea ();
  uchar**  srcRows  = Green     ();

  uchar*   destArea = dest->GreenArea ();
  uchar**  destRows = dest->Green     ();

  memset (destArea, 0, totPixels);
  kkint32  pixelCount = 0;

  int  c, r;

  //  Take care of Top and Bottom rows.
  {
    uchar*  srcRow0    = srcRows[0];
    uchar*  srcRow1    = srcRows[1];
    uchar*  srcRowBot0 = srcRows[height - 1];
    uchar*  srcRowBot1 = srcRows[height - 2];

    uchar*  destRow0 = destRows[0];
    uchar*  destRowBot = destRows[height - 1];
    for (c = 1;  c < (width  - 1);  ++c)
    {
      if  ((srcRow0[c - 1] > backgroundPixelTH)  ||  (srcRow0[c] > backgroundPixelTH)  ||  (srcRow0[c + 1] > backgroundPixelTH)  ||
           (srcRow1[c - 1] > backgroundPixelTH)  ||  (srcRow1[c] > backgroundPixelTH)  ||  (srcRow1[c + 1] > backgroundPixelTH)
          )
      {
        destRow0[c] = 255;
        ++pixelCount;
      }

      if  ((srcRowBot0[c - 1] > backgroundPixelTH)  ||                                           (srcRowBot0[c + 1] > backgroundPixelTH)  ||
           (srcRowBot1[c - 1] > backgroundPixelTH)  ||  (srcRowBot1[c] > backgroundPixelTH)  ||  (srcRowBot1[c + 1] > backgroundPixelTH)
          )
      {
        destRowBot[c] = 255;
        ++pixelCount;
      }
    }
  }


  // Take care of left and right columns
  {
    for  (r = 1;  r < (height - 1);  ++r)
    {
      if  ((srcRows[r - 1][0] > backgroundPixelTH)  ||  (srcRows[r - 1][1] > backgroundPixelTH)  ||
           (srcRows[r    ][0] > backgroundPixelTH)  ||  (srcRows[r    ][1] > backgroundPixelTH)  ||
           (srcRows[r + 1][0] > backgroundPixelTH)  ||  (srcRows[r + 1][1] > backgroundPixelTH)
          )
      {
        destRows[r][0] = 255;
        ++pixelCount;
      }


      if  ((srcRows[r - 1][width - 1] > backgroundPixelTH)  ||  (srcRows[r - 1][width - 2] > backgroundPixelTH)  ||
           (srcRows[r    ][width - 1] > backgroundPixelTH)  ||  (srcRows[r    ][width - 2] > backgroundPixelTH)  ||
           (srcRows[r + 1][width - 1] > backgroundPixelTH)  ||  (srcRows[r + 1][width - 2] > backgroundPixelTH)
          )
      {
        destRows[r][width - 1] = 255;
        ++pixelCount;
      }
    }
  }


  // Take care of main Body
  {
    for  (r = 1;  r < (height - 1);  ++r)
    {
      uchar*  srcRow0 = srcRows[r - 1];
      uchar*  srcRow1 = srcRows[r    ];
      uchar*  srcRow2 = srcRows[r + 1];

      for  (c = 1;  c < (width - 1);  ++c)
      {
        if  ((srcRow0[c - 1] > backgroundPixelTH)  ||  (srcRow0[c] > backgroundPixelTH)  ||  (srcRow0[c + 1] > backgroundPixelTH)  ||
             (srcRow1[c - 1] > backgroundPixelTH)  ||  (srcRow1[c] > backgroundPixelTH)  ||  (srcRow1[c + 1] > backgroundPixelTH)  ||
             (srcRow2[c - 1] > backgroundPixelTH)  ||  (srcRow2[c] > backgroundPixelTH)  ||  (srcRow2[c + 1] > backgroundPixelTH)
            )
        {
          destRows[r][c] = 255;
          ++pixelCount;
        }
      }
    }
  }

  dest->foregroundPixelCount = pixelCount;
}  /* Dilation */

void Raster::Dilation

(

MaskTypes

mask

)

Definition at line 1755 of file Raster.cpp.

References CreateDilatedRaster(), foregroundPixelCount, green, and greenArea.

Referenced by Closing(), Opening(), and KKB::MorphOpMaskExclude::PerformOperation().

{    
  RasterPtr tempRaster = CreateDilatedRaster (mask);

  delete  greenArea;
  delete  green;

  foregroundPixelCount = tempRaster->foregroundPixelCount;

  greenArea = tempRaster->greenArea;
  green     = tempRaster->green;

  tempRaster->greenArea = NULL;
  tempRaster->green     = NULL;

  delete  tempRaster;
} /* Dilation */

void Raster::Dilation	(	RasterPtr	dest,
		MaskTypes	mask
	)		const

Definition at line 1905 of file Raster.cpp.

References Color(), color, foregroundPixelCount, Green(), GreenArea(), Height(), height, ReSize(), Width(), and width.

Referenced by KKMLL::GrayScaleImagesFVProducer::ComputeFeatureVector().

{
  if  ((dest->Height () != height)  ||  (dest->Width () != width)  ||  (dest->Color ()  != color))
    dest->ReSize (height, width, color);

  uchar*   destArea = dest->GreenArea ();
  uchar**  destRows = dest->Green     ();

  memset (destArea, 0, totPixels);
  kkint32  pixelCount = 0;

  int  c, r;


  // Take care of main Body
  {
    for  (r = 0;  r < height;  ++r)
    {
      for  (c = 0;  c < width;  ++c)
      {
        if  (IsThereANeighbor (mask, r, c)) 
        {
          destRows[r][c] = 255;
          ++pixelCount;
        }
      }
    }
  }

  dest->foregroundPixelCount = pixelCount;
}  /* Dilation */

void Raster::Dilation	(	MorphOp::StructureType	_structure,
		kkuint16	_structureSize,
		kkint32	_foregroundCountTH
	)

Definition at line 1776 of file Raster.cpp.

References KKB::MorphOpStruct::ForegroundCountTH(), ForegroundPixelCount(), foregroundPixelCount, green, greenArea, KKB::MorphOpDilation::MorphOpDilation(), and KKB::MorphOpDilation::PerformOperation().

{
  MorphOpDilation  dialator (_structure, _structureSize);
  dialator.ForegroundCountTH (_foregroundCountTH);
  RasterPtr tempRaster = dialator.PerformOperation (this);

  delete  greenArea;
  delete  green;

  foregroundPixelCount = tempRaster->ForegroundPixelCount ();

  greenArea = tempRaster->greenArea;
  green     = tempRaster->green;

  tempRaster->greenArea = NULL;
  tempRaster->green     = NULL;

  delete  tempRaster;
} /* Dilation */

kkint32 KKB::Raster::Divisor ( ) const

inline

Definition at line 312 of file Raster.h.

References divisor.

{return  divisor;}

void KKB::Raster::Divisor ( kkint32  _divisor )

inline

Definition at line 343 of file Raster.h.

References divisor.

{divisor              = _divisor;}

void Raster::DrawCircle	(	const Point &	point,
		kkint32	radius,
		const PixelValue &	color
	)

Draw a circle who's center is at 'point' and radius in pixels is 'radius' using color 'color'.

Parameters

[in]	point	Location in image where the center of circle is to be located.
[in]	radius	The radius in pixels of the circle that is to be drawn.
[in]	color	The color that is to be used to draw the circle with.

Definition at line 7081 of file Raster.cpp.

References KKB::Point::Col(), DrawCircle(), and KKB::Point::Row().

{
  DrawCircle ((float)point.Row (),
              (float)point.Col (),
              (float)radius,
              color
             );
}  /* DrawCircle */

void Raster::DrawCircle	(	float	centerRow,
		float	centerCol,
		float	radius,
		const PixelValue &	pixelValue
	)

Definition at line 6991 of file Raster.cpp.

References SetPixelValue().

Referenced by DrawCircle().

{
  kkint32  row, col;
  float  x, y;

  float  start = -(float)ceil  (radius);
  float  end   = +(float)floor (radius);

  float  radiusSquare = radius * radius;

  for  (x = start;  x <= end;  x++)
  {
    y = (float)sqrt (radiusSquare - (x * x));
    col = (kkint32)(x + centerCol + 0.5);
    row = (kkint32)(centerRow + 0.5 + y);
    SetPixelValue (row, col, pixelValue);

    row = (kkint32)(centerRow + 0.5 - y);
    SetPixelValue (row, col, pixelValue);


    row = (kkint32)(x + centerRow + 0.5);
    col = (kkint32)(centerCol + 0.5 + y);
    SetPixelValue (row, col, pixelValue);

    col = (kkint32)(centerCol + 0.5 - y);
    SetPixelValue (row, col, pixelValue);

  }
}  /* DrawCircle */

void Raster::DrawCircle	(	float	centerRow,
		float	centerCol,
		float	radius,
		float	startAngle,
		float	endAngle,
		const PixelValue &	pixelValue
	)

Parameters

centerRow	Row that will contain the center of the circle.
centerCol	Column that will contain the center of the circle.
radius	The radius of the circle in pixels.
startAngle	Start and End angles should be given in radians
endAngle	Where the angles are with respect to the compass
pixelValue	Pixel value that is to be assigned to locations in the image that are part of the circle.

Definition at line 7030 of file Raster.cpp.

References height, SetPixelValue(), and width.

{
  float  row, col;

  while  (startAngle < 0.0f)
    startAngle += (float)TwoPie;

  while  (startAngle >= (float)TwoPie)
    startAngle -= (float)TwoPie;

  while  (endAngle < startAngle)
    endAngle += (float)TwoPie;
  
  while  ((endAngle - startAngle) >= (float)TwoPie)
    endAngle -= (float)TwoPie;

  float  angle = startAngle;
  float  angleIncrement = asin (0.5f / radius);

  while  (angle <= endAngle)
  {
    // 1st Determine Which Quarter we r in

    float  qtrAngle = angle;
    while  (qtrAngle > (float)TwoPie)
      qtrAngle -= (float)TwoPie;

    row = -(radius * cos (angle));
    col =  (radius * sin (angle));

    kkint32  adjRow = (kkint32)(centerRow + row + 0.5f);
    kkint32  adjCol = (kkint32)(centerCol + col + 0.5f);

    if  ((adjRow >= 0)  &&  (adjRow < height)  &&
         (adjCol >= 0)  &&  (adjCol < width))
      SetPixelValue ((kkint32)(centerRow + row + 0.5f), (kkint32)(centerCol + col + 0.5f), pixelValue);

    angle += angleIncrement;
  }
}  /* DrawCircle */

void Raster::DrawConnectedPointList	(	Point	offset,
		const PointList &	borderPixs,
		const PixelValue &	pixelValue,
		const PixelValue &	linePixelValue
	)

Definition at line 6894 of file Raster.cpp.

References KKB::PixelValue::b, blue, KKB::Point::Col(), color, DrawLine(), KKB::PixelValue::g, green, height, KKB::Point::operator+(), KKB::PixelValue::r, red, KKB::Point::Row(), and width.

{
  PointList::const_iterator  pIDX;

  PointPtr  pixel = NULL;
  PointPtr  lastPoint = NULL;

  kkint32  row = 0, col = 0;

  for  (pIDX = borderPixs.begin ();  pIDX != borderPixs.end ();  pIDX++)
  {
    pixel = *pIDX;
    if  (lastPoint)
    {
      kkint32  deltaRow = lastPoint->Row () - pixel->Row ();
      kkint32  deltaCol = lastPoint->Col () - pixel->Col ();

      kkint32  distSquared = deltaRow * deltaRow  +  deltaCol * deltaCol;

      if  (distSquared > 5)
      {
        // We need to draw a line between the two points.
        DrawLine (*lastPoint + offset, *pixel + offset, linePixelValue);
      }
    }

    if  (pixel != NULL)
    {
      row = pixel->Row () + offset.Row ();
      col = pixel->Col () + offset.Col ();
    }

    if  ((row <  height)  &&  (col <  width)   &&
         (row >= 0)       &&  (col >= 0)    
        )
    {
      green[row][col] = pixelValue.g;
      if  (color)
      {
        red [row][col] = pixelValue.r;
        blue[row][col] = pixelValue.b;
      }
    }

    lastPoint = pixel;
  }
}  /* DrawPointList */

void Raster::DrawDot	(	const Point &	point,
		const PixelValue &	color,
		kkint32	size
	)

Definition at line 6948 of file Raster.cpp.

References KKB::Point::Col(), KKB::Point::Row(), and SetPixelValue().

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

{
  SetPixelValue (point, color);
  
  double  radius = (double)size / 2.0;
  double  radiusSquared = radius * radius;

  kkint32  left  = Max ((kkint32)0,           (kkint32)floor ((double)point.Col () - radius));
  kkint32  right = Min ((kkint32)(width - 1), (kkint32)ceil  ((double)point.Col () + radius));

  kkint32  bot   = Max ((kkint32)0,            (kkint32)floor ((double)point.Row () - radius));
  kkint32  top   = Min ((kkint32)(height - 1), (kkint32)ceil  ((double)point.Row () + radius));

  kkint32  row, col;

  for  (row = bot;  row <= top;  row++)
  {
    kkint32  deltaRow = row - point.Row ();
    kkint32  deltaRowSquared = deltaRow * deltaRow;

    if  (deltaRowSquared <= radiusSquared)
    {
      for  (col = left;  col <= right;  col++)
      {
        kkint32  deltaCol = col - point.Col ();
        double  distFromCenterSquares = deltaRowSquared + deltaCol * deltaCol;

        if  (distFromCenterSquares <= radiusSquared)
        {
          // we are within the dot.
          SetPixelValue (row, col, color);
        }
      }
    }
  }
}  /* DrawDot */

void Raster::DrawFatLine	(	Point	startPoint,
		Point	endPoint,
		PixelValue	pv,
		float	alpha
	)

Definition at line 6636 of file Raster.cpp.

References KKB::Point::Col(), height, PaintFatPoint(), KKB::Point::Row(), and width.

{
  kkint32  bpRow = startPoint.Row ();
  kkint32  bpCol = startPoint.Col ();
  kkint32  epRow = endPoint.Row   ();
  kkint32  epCol = endPoint.Col   ();

  if  ((bpRow < 0)  ||  (bpRow >= height)  ||
       (bpCol < 0)  ||  (bpCol >= width)   ||
       (epRow < 0)  ||  (epRow >= height)  ||
       (epCol < 0)  ||  (epCol >= width)
      )
  {
    cerr << std::endl
         << "*** WARNING ***"
         << "Raster::DrawFatLine,  Out of Raster Boundaries   Height[" << height << "]  width[" << width << "]."  << std::endl
         << "                      BeginPoint" << startPoint << "   EndPoint" << endPoint << "." << std::endl
         << std::endl;
    return;
  }

  kkint32  deltaY = epRow - bpRow;
  kkint32  deltaX = epCol - bpCol;

  kkint32  row, col;

  if  (deltaY == 0)
  {
    // We have a Straight Horizontal Line

    row = bpRow;
    
    kkint32  startCol;
    kkint32  endCol;

    if  (bpCol < epCol)
    {
      startCol = bpCol;
      endCol   = epCol;
    }
    else
    {
      startCol = epCol;
      endCol   = bpCol;
    }

    for  (col = startCol;  col <= endCol;  col++)
      PaintFatPoint (row, col, pv, alpha);

    return;
  }

  if  (deltaX == 0)
  {
    // We have a Straight Vertical Line

    col = bpCol;
    
    kkint32  startRow;
    kkint32  endRow;

    if  (bpRow < epRow)
    {
      startRow = bpRow;
      endRow   = epRow;
    }
    else
    {
      startRow = epRow;
      endRow   = bpRow;
    }

    for  (row = startRow;  row <= endRow;  row++)
      PaintFatPoint (row, col, pv, alpha);

    return;
  }

  float  m = (float)deltaY / (float)deltaX;

  float  c = bpRow - m * bpCol;

  if  (fabs (m) < 0.5)
  {
    kkint32  startCol;
    kkint32  endCol;

    if  (bpCol < epCol)
    {
      startCol = bpCol;
      endCol   = epCol;
    }
    else
    {
      startCol = epCol;
      endCol   = bpCol;
    }

    for  (col = startCol;  col <= endCol;  col++)
    {
      row = (kkint32)(m * col + c + 0.5);
      PaintFatPoint (row, col, pv, alpha);
    }
  }
  else
  {
    kkint32  startRow;
    kkint32  endRow;

    if  (bpRow < epRow)
    {
      startRow = bpRow;
      endRow   = epRow;
    }
    else
    {
      startRow = epRow;
      endRow   = bpRow;
    }

    for  (row = startRow;  row <= endRow;  row++)
    {
      col = (kkint32)(((row - c) / m) + 0.5);
      PaintFatPoint (row, col, pv, alpha);
    }
  }
}  /* DrawFatLine */;

void Raster::DrawGrid	(	float	pixelsPerMinor,
		kkuint32	minorsPerMajor,
		const PixelValue &	hashColor,
		const PixelValue &	gridColor
	)

Definition at line 1543 of file Raster.cpp.

References DrawLine(), FillRectangle(), height, and width.

{
  int  x = 0;

  int  hashLen = 4;

  // Horizontal Hash Marks

  //kkint32  horzOffset = (width - (kkint32)(((float)width / pixelsPerMinor) * pixelsPerMinor) / 2);
  while  (true)
  {
    int  hashPos = (int)((float)x * pixelsPerMinor + 0.5f); // + horzOffset;
    if  (hashPos >= (height - hashLen))
      break;

    if  ((x % minorsPerMajor) == 0)
      hashLen = 10;
    else
      hashLen = 6;

    FillRectangle (hashPos,     0,               hashPos + 2, hashLen - 1, hashColor);
    FillRectangle (hashPos,     width - hashLen, hashPos + 2, width - 1,   hashColor);
    DrawLine      (hashPos + 1, 0,               hashPos + 1, width - 1,   gridColor, 0.2f);
    x++;
  }

  x = 0;

  // Vertical Hash Marks
  // kkint32  vertOffset = (height - (kkint32)((height / pixelsPerMinor) * pixelsPerMinor) / 2);
  while  (true)
  {
    int  hashPos = (int)((float)x * pixelsPerMinor + 0.5f); // + vertOffset;
    if  (hashPos >= width)
      break;

    if  ((x % minorsPerMajor) == 0)
      hashLen = 8;
    else
      hashLen = 4;

    FillRectangle (0,                 hashPos,     hashLen - 1, hashPos + 2, hashColor);
    FillRectangle (height - hashLen,  hashPos,     height - 1,  hashPos + 2, hashColor);
    DrawLine      (0,                 hashPos + 1, height - 1,  hashPos + 1, gridColor, 0.2f);

    x++;
  }
}  /* DrawGrid */

void Raster::DrawLine	(	kkint32	bpRow,
		kkint32	bpCol,
		kkint32	epRow,
		kkint32	epCol
	)

Definition at line 6239 of file Raster.cpp.

References DrawLine().

{
  DrawLine (bpRow, bpCol,  
            epRow, epCol,
            255
           );
}

void Raster::DrawLine	(	kkint32	bpRow,
		kkint32	bpCol,
		kkint32	epRow,
		kkint32	epCol,
		uchar	pixelVal
	)

Definition at line 6253 of file Raster.cpp.

References DrawLine().

Referenced by KKB::Histogram::CreateGraph(), and DrawLine().

{
  DrawLine (bpRow, bpCol, epRow, epCol, pixelVal, pixelVal, pixelVal);
}  /* DrawLine */;

void Raster::DrawLine	(	const Point &	beginPoint,
		const Point &	endPoint,
		uchar	pixelVal
	)

Definition at line 6794 of file Raster.cpp.

References KKB::Point::Col(), DrawLine(), and KKB::Point::Row().

{
  DrawLine (beginPoint.Row (), beginPoint.Col (), 
            endPoint.Row (),   endPoint.Col (), 
            pixelVal
           );
}  /* DrawLine */

void Raster::DrawLine	(	const Point &	beginPoint,
		const Point &	endPoint,
		const PixelValue &	pixelVal
	)

Definition at line 6807 of file Raster.cpp.

References KKB::Point::Col(), DrawLine(), and KKB::Point::Row().

Referenced by KKB::Chart::CreateRaster(), and DrawConnectedPointList().

{
  DrawLine (beginPoint.Row (), beginPoint.Col (), 
            endPoint.Row   (), endPoint.Col   (), 
            pixelVal
           );

}  /* DrawLine */

void Raster::DrawLine	(	kkint32	bpRow,
		kkint32	bpCol,
		kkint32	epRow,
		kkint32	epCol,
		uchar	r,
		uchar	g,
		uchar	b
	)

Definition at line 6264 of file Raster.cpp.

References blue, color, green, height, red, and width.

Referenced by DrawLine().

{

  if  ((bpRow < 0)  ||  (bpRow >= height)  ||
       (bpCol < 0)  ||  (bpCol >= width)   ||
       (epRow < 0)  ||  (epRow >= height)  ||
       (epCol < 0)  ||  (epCol >= width)
      )
  {
    cerr << std::endl
         << "*** WARNING ***"
         << "Raster::DrawLine,  Out of Raster Boundaries   Height[" << height << "]  width[" << width << "]."  << std::endl
         << "                   BeginPoint" << Point (bpRow, bpCol) << "   EndPoint" << Point (epRow, epCol) << "." << std::endl
         << std::endl;
    return;
  }

  kkint32  deltaY = epRow - bpRow;
  kkint32  deltaX = epCol - bpCol;

  kkint32  row, col;

  if  (deltaY == 0)
  {
    // We have a Straight Horizontal Line

    row = bpRow;
    
    kkint32  startCol;
    kkint32  endCol;

    if  (bpCol < epCol)
    {
      startCol = bpCol;
      endCol   = epCol;
    }
    else
    {
      startCol = epCol;
      endCol   = bpCol;
    }

    for  (col = startCol;  col <= endCol;  col++)
    {
      green[row][col] = g;
      if  (color)
      {
        red [row][col] = r;
        blue[row][col] = b;
      }
    }

    return;
  }

  if  (deltaX == 0)
  {
    // We have a Straight Vertical Line

    col = bpCol;
    
    kkint32  startRow;
    kkint32  endRow;

    if  (bpRow < epRow)
    {
      startRow = bpRow;
      endRow   = epRow;
    }
    else
    {
      startRow = epRow;
      endRow   = bpRow;
    }

    for  (row = startRow;  row <= endRow;  row++)
    {
      green[row][col] = g;
      if  (color)
      {
        red [row][col] = r;
        blue[row][col] = b;
      }
    }

    return;
  }

  float  m = (float)deltaY / (float)deltaX;

  float  c = bpRow - m * bpCol;

  if  (fabs (m) < 0.5)
  {
    kkint32  startCol;
    kkint32  endCol;

    if  (bpCol < epCol)
    {
      startCol = bpCol;
      endCol   = epCol;
    }
    else
    {
      startCol = epCol;
      endCol   = bpCol;
    }

    for  (col = startCol;  col <= endCol;  col++)
    {
      row = (kkint32)(m * col + c + 0.5);
      green[row][col] = g;
      if  (color)
      {
        red [row][col] = r;
        blue[row][col] = b;
      }
    }
  }
  else
  {
    kkint32  startRow;
    kkint32  endRow;

    if  (bpRow < epRow)
    {
      startRow = bpRow;
      endRow   = epRow;
    }
    else
    {
      startRow = epRow;
      endRow   = bpRow;
    }

    for  (row = startRow;  row <= endRow;  row++)
    {
      col = (kkint32)(((row - c) / m) + 0.5);
      green[row][col] = g;
      if  (color)
      {
        red [row][col] = r;
        blue[row][col] = b;
      }
    }
  }
}  /* DrawLine */;

void Raster::DrawLine	(	kkint32	bpRow,
		kkint32	bpCol,
		kkint32	epRow,
		kkint32	epCol,
		uchar	r,
		uchar	g,
		uchar	b,
		float	alpha
	)

Definition at line 6479 of file Raster.cpp.

References blue, color, green, height, MergeAlpfaBeta(), red, and width.

Referenced by DrawLine().

{
  float  beta = 1.0f - alpha;

  if  ((bpRow < 0)  ||  (bpRow >= height)  ||
       (bpCol < 0)  ||  (bpCol >= width)   ||
       (epRow < 0)  ||  (epRow >= height)  ||
       (epCol < 0)  ||  (epCol >= width)
      )
  {
    cerr << std::endl
         << "*** WARNING ***"
         << "Raster::DrawLine,  Out of Raster Boundaries   Height[" << height << "]  width[" << width << "]."  << std::endl
         << "                   BeginPoint" << Point (bpRow, bpCol) << "   EndPoint" << Point (epRow, epCol) << "." << std::endl
         << std::endl;
    return;
  }

  kkint32  deltaY = epRow - bpRow;
  kkint32  deltaX = epCol - bpCol;

  kkint32  row, col;

  if  (deltaY == 0)
  {
    // We have a Straight Horizontal Line

    row = bpRow;
    
    kkint32  startCol;
    kkint32  endCol;

    if  (bpCol < epCol)
    {
      startCol = bpCol;
      endCol   = epCol;
    }
    else
    {
      startCol = epCol;
      endCol   = bpCol;
    }

    for  (col = startCol;  col <= endCol;  col++)
    {
      green[row][col] = MergeAlpfaBeta (alpha, g, beta, green[row][col]);
      if  (color)
      {
        red [row][col] = MergeAlpfaBeta (alpha, r, beta, red [row][col]);
        blue[row][col] = MergeAlpfaBeta (alpha, b, beta, blue[row][col]);
      }
    }

    return;
  }

  if  (deltaX == 0)
  {
    // We have a Straight Vertical Line

    col = bpCol;
    
    kkint32  startRow;
    kkint32  endRow;

    if  (bpRow < epRow)
    {
      startRow = bpRow;
      endRow   = epRow;
    }
    else
    {
      startRow = epRow;
      endRow   = bpRow;
    }

    for  (row = startRow;  row <= endRow;  row++)
    {
      green[row][col] = MergeAlpfaBeta (alpha, g, beta, green[row][col]);
      if  (color)
      {
        red [row][col] = MergeAlpfaBeta (alpha, r, beta, red [row][col]);
        blue[row][col] = MergeAlpfaBeta (alpha, b, beta, blue[row][col]);
      }
    }

    return;
  }

  float  m = (float)deltaY / (float)deltaX;

  float  c = bpRow - m * bpCol;

  if  (fabs (m) < 0.5)
  {
    kkint32  startCol;
    kkint32  endCol;

    if  (bpCol < epCol)
    {
      startCol = bpCol;
      endCol   = epCol;
    }
    else
    {
      startCol = epCol;
      endCol   = bpCol;
    }

    for  (col = startCol;  col <= endCol;  col++)
    {
      row = (kkint32)(m * col + c + 0.5);
      green[row][col] = MergeAlpfaBeta (alpha, g, beta, green[row][col]);
      if  (color)
      {
        red [row][col] = MergeAlpfaBeta (alpha, r, beta, red [row][col]);
        blue[row][col] = MergeAlpfaBeta (alpha, b, beta, blue[row][col]);
      }
    }
  }
  else
  {
    kkint32  startRow;
    kkint32  endRow;

    if  (bpRow < epRow)
    {
      startRow = bpRow;
      endRow   = epRow;
    }
    else
    {
      startRow = epRow;
      endRow   = bpRow;
    }

    for  (row = startRow;  row <= endRow;  row++)
    {
      col = (kkint32)(((row - c) / m) + 0.5);
      green[row][col] = MergeAlpfaBeta (alpha, g, beta, green[row][col]);
      if  (color)
      {
        red [row][col] = MergeAlpfaBeta (alpha, r, beta, red [row][col]);
        blue[row][col] = MergeAlpfaBeta (alpha, b, beta, blue[row][col]);
      }
    }
  }
}  /* DrawLine */;

void Raster::DrawLine	(	kkint32	bpRow,
		kkint32	bpCol,
		kkint32	epRow,
		kkint32	epCol,
		PixelValue	pixelVal
	)

Definition at line 6771 of file Raster.cpp.

References KKB::PixelValue::b, DrawLine(), KKB::PixelValue::g, and KKB::PixelValue::r.

Referenced by KKB::Chart::CreateRaster(), and DrawLine().

{
  DrawLine (bpRow, bpCol, epRow, epCol, pixelVal.r, pixelVal.g, pixelVal.b);
}  /* DrawLine */;

void Raster::DrawLine	(	kkint32	bpRow,
		kkint32	bpCol,
		kkint32	epRow,
		kkint32	epCol,
		PixelValue	pixelVal,
		float	alpha
	)

Definition at line 6782 of file Raster.cpp.

References KKB::PixelValue::b, DrawLine(), KKB::PixelValue::g, and KKB::PixelValue::r.

Referenced by DrawGrid().

{
  DrawLine (bpRow, bpCol, epRow, epCol, pixelVal.r, pixelVal.g, pixelVal.b, alpha);
}  /* DrawLine */;

void Raster::DrawPointList	(	const PointList &	borderPixs,
		const PixelValue &	pixelValue
	)

Definition at line 6822 of file Raster.cpp.

References KKB::PixelValue::b, DrawPointList(), KKB::PixelValue::g, KKB::Point::Point(), and KKB::PixelValue::r.

{
  DrawPointList (Point ((kkint32)0, (kkint32)0), borderPixs, pixelValue.r, pixelValue.g, pixelValue.b);
}

void Raster::DrawPointList	(	Point	offset,
		const PointList &	borderPixs,
		const PixelValue &	pixelValue
	)

Definition at line 6830 of file Raster.cpp.

References KKB::PixelValue::b, DrawPointList(), KKB::PixelValue::g, and KKB::PixelValue::r.

{
  DrawPointList (offset, borderPixs, pixelValue.r, pixelValue.g, pixelValue.b);
}

void Raster::DrawPointList	(	const PointList &	borderPixs,
		uchar	redVal,
		uchar	greenVal,
		uchar	blueVal
	)

Definition at line 6841 of file Raster.cpp.

References DrawPointList(), and KKB::Point::Point().

{
  DrawPointList (Point ((kkint32)0, (kkint32)0), borderPixs, redVal, greenVal, blueVal);
}  /* DrawPointList */

void Raster::DrawPointList	(	Point	offset,
		const PointList &	borderPixs,
		uchar	redVal,
		uchar	greenVal,
		uchar	blueVal
	)

Definition at line 6853 of file Raster.cpp.

References blue, KKB::Point::Col(), color, green, height, red, KKB::Point::Row(), and width.

Referenced by DrawPointList().

{
  PointList::const_iterator  pIDX;

  PointPtr  pixel = NULL;

  kkint32  row, col;

  for  (pIDX = borderPixs.begin ();  pIDX != borderPixs.end ();  pIDX++)
  {
    pixel = *pIDX;
    row = pixel->Row () + offset.Row ();
    col = pixel->Col () + offset.Col ();

    if  ((row < height)  &&  
         (row >= 0)      &&
         (col < width)   &&
         (col >= 0)   
        )  
    {
      green[row][col] = greenVal;
      if  (color)
      {
        red [row][col] = redVal;
        blue[row][col] = blueVal;
      }
    }
    else
    {
      continue;
    }
  }
}  /* DrawPointList */

void Raster::Edge

(

)

reduces image to edge pixels only.

Definition at line 3043 of file Raster.cpp.

References Edge(), and Raster().

{
  Raster  orig (*this);
  orig.Edge (this);
}  /*  Edge */

void Raster::Edge

(

RasterPtr

dest

)

Definition at line 3052 of file Raster.cpp.

References backgroundPixelValue, foregroundPixelCount, foregroundPixelValue, Green(), GreenArea(), Height(), height, ReSize(), Width(), and width.

Referenced by KKMLL::GrayScaleImagesFVProducer::ComputeFeatureVector(), and Edge().

{
  if  ((dest->Height () != height)  |  (dest->Width () != width))
    dest->ReSize (height, width, false);

  kkint32  r;
  kkint32  c;

  kkint32  lastRow = height - 1;
  kkint32  lastCol = width - 1;

  uchar**  origRows = Green ();

  uchar*  origRowLast = NULL;
  uchar*  origRowCur  = NULL;
  uchar*  origRowNext = NULL;
   
  kkint32  pixelCount = 0;

  uchar*  destArea = dest->GreenArea ();
  uchar** destRows = dest->Green ();

  for  (r = 1;  r < lastRow;  ++r)
  {
    origRowLast = origRows[r - 1];
    origRowCur  = origRows[r];
    origRowNext = origRows[r + 1];

    uchar*  destRow = destRows[r];

    for  (c = 1; c < lastCol; c++)
    {
      if  (ForegroundPixel (origRowCur[c]))
      {
        if ((ForegroundPixel (origRowLast [c - 1])) &&
            (ForegroundPixel (origRowLast [c]    )) &&
            (ForegroundPixel (origRowLast [c + 1])) &&
            (ForegroundPixel (origRowCur  [c - 1])) &&
            (ForegroundPixel (origRowCur  [c]    )) &&
            (ForegroundPixel (origRowCur  [c + 1])) &&
            (ForegroundPixel (origRowNext [c - 1])) &&
            (ForegroundPixel (origRowNext [c]    )) &&
            (ForegroundPixel (origRowNext [c + 1]))
           )
        {
          destRow[c] = backgroundPixelValue;
        }
        else
        {
          destRow[c] = foregroundPixelValue;
          ++pixelCount;
        }
      }
    }
  }

  dest->foregroundPixelCount = pixelCount;
}  /*  Edge */

void Raster::ErodeSpurs

(

)

removes spurs from image.

Definition at line 8089 of file Raster.cpp.

References backgroundPixelValue, green, height, Raster(), and width.

Referenced by ThinContour().

{
  Raster  origRaster (*this);

  uchar**  origGreen = origRaster.green;

  kkint32  r;
  kkint32  c;

  kkint32  firstRow = 1;
  kkint32  firstCol = 1;
  kkint32  lastRow  = height - 1;
  kkint32  lastCol  = width - 1;

  for  (r = firstRow; r < lastRow; r++)
  {
    for  (c = firstCol; c < lastCol; c++)
    {
      if  (ForegroundPixel (green[r][c]))
      {
        // We have a foreground Pixel.

        if  ((BackgroundPixel (origGreen[r - 1][c - 1]))  &&
             (BackgroundPixel (origGreen[r - 1][c]    ))  &&
             (BackgroundPixel (origGreen[r - 1][c + 1]))  &&
             (BackgroundPixel (origGreen[r    ][c - 1]))  &&
             (BackgroundPixel (origGreen[r    ][c + 1])))
        {
          // Top Spur
          green[r][c] = backgroundPixelValue;
        }

        else
        if  ((BackgroundPixel (origGreen[r - 1][c - 1]))  &&
             (BackgroundPixel (origGreen[r    ][c - 1]))  &&
             (BackgroundPixel (origGreen[r + 1][c + 1]))  &&
             (BackgroundPixel (origGreen[r - 1][c    ]))  &&
             (BackgroundPixel (origGreen[r + 1][c    ])))
        {
          // Left Spur
          green[r][c] = backgroundPixelValue;
        }

        else
        if  ((BackgroundPixel (origGreen[r + 1][c - 1]))  &&
             (BackgroundPixel (origGreen[r + 1][c    ]))  &&
             (BackgroundPixel (origGreen[r + 1][c + 1]))  &&
             (BackgroundPixel (origGreen[r    ][c - 1]))  &&
             (BackgroundPixel (origGreen[r    ][c + 1])))
        {
          // Bottom Spur
          green[r][c] = backgroundPixelValue;
        }

        else
        if  ((BackgroundPixel (origGreen[r - 1][c + 1]))  &&
             (BackgroundPixel (origGreen[r    ][c + 1]))  &&
             (BackgroundPixel (origGreen[r + 1][c + 1]))  &&
             (BackgroundPixel (origGreen[r - 1][c    ]))  &&
             (BackgroundPixel (origGreen[r + 1][c    ])))
        {
          // Right Spur
          green[r][c] = backgroundPixelValue;
        }
      }
    }
  }
}  /* ErodeSpurs */

void Raster::Erosion

(

)

Definition at line 2241 of file Raster.cpp.

References backgroundPixelTH, backgroundPixelValue, foregroundPixelCount, green, height, Raster(), and width.

Referenced by Closing(), and Opening().

{
  Raster  origRaster (*this);

  uchar**  origRows = origRaster.green;

  foregroundPixelCount = 0;

  kkint32  r;
  kkint32  c;

  kkint32  lastRow = height - 1;
  kkint32  lastCol = width - 1;

  uchar*  rowLast = NULL;
  uchar*  rowCur  = NULL;
  uchar*  rowNext = NULL;

  for  (r = 1; r < lastRow; r++)
  {
    rowLast = origRows[r - 1];
    rowCur  = origRows[r    ];
    rowNext = origRows[r + 1];

    for  (c = 1; c < lastCol; c++)
    {
      if  (!BackgroundPixel (green[r][c]))
      {
        if  ((rowLast [c - 1] <= backgroundPixelTH)  ||
             (rowLast [c]     <= backgroundPixelTH)  ||
             (rowLast [c + 1] <= backgroundPixelTH)  ||

             (rowCur  [c - 1] <= backgroundPixelTH)  ||
             (rowCur  [c + 1] <= backgroundPixelTH)  ||

             (rowNext [c - 1] <= backgroundPixelTH)  ||
             (rowNext [c]     <= backgroundPixelTH)  ||
             (rowNext [c + 1] <= backgroundPixelTH))
        {
          green[r][c] = backgroundPixelValue;
        }
        else
        {
          foregroundPixelCount++;
        }
      }
    }
  }
}  /* Erosion */

void Raster::Erosion

(

MaskTypes

mask

)

Definition at line 2294 of file Raster.cpp.

References backgroundPixelValue, KKB::MorphOp::Biases(), foregroundPixelCount, Green(), green, height, KKB::MorphOp::MaskShapes(), Raster(), KKB::MorphOp::stSquare, and width.

Referenced by Closing(), DeriveImageLength(), and Opening().

{
  kkint32  r;
  kkint32  c;

  kkint32  bias = MorphOp::Biases (mask);

  kkint32  maskRowStart = 0 - bias;
  kkint32  maskRowEnd   = 0 + bias;
  kkint32  maskColStart = 0 - bias;
  kkint32  maskColEnd   = 0 + bias;
  kkint32  maskRow;
  kkint32  maskCol;
  bool   fit = false;

  foregroundPixelCount = 0;
  Raster  tempRaster (*this);
  uchar**     tempGreen = tempRaster.Green ();
  uchar*      tempRowData = NULL;
  StructureType  m = MorphOp::MaskShapes (mask);

  for  (r = 0;  r < height;  r++)
  {
    maskColStart = 0 - bias;
    maskColEnd   = 0 + bias;

    tempRowData = tempGreen[r];

    for  (c = 0; c < width; c++)
    {
      if  (ForegroundPixel (green[r][c]))
      {
        fit = true;
        if  ((maskRowStart < 0)  || (maskRowEnd >= height)  ||  (maskColStart < 0) ||  (maskColStart >= width))
          fit = false;

        else if  (m == StructureType::stSquare)
        {
          for  (maskRow = maskRowStart;  ((maskRow <= maskRowEnd)  &&  fit);  maskRow++)
          {
            tempRowData =  tempGreen[maskRow];
            for  (maskCol = maskColStart;  maskCol <= maskColEnd;  maskCol++)
            {
              if  (BackgroundPixel (tempRowData[maskCol]))
              {
                fit = false;
                break;
              }
            }
          }
        }
        else
        {
          //  Cross Structure
          for  (maskRow = maskRowStart;  maskRow <= maskRowEnd;  maskRow++)
          {
            if  (BackgroundPixel (tempGreen[maskRow][c]))
            {
              fit = false;
              break;
            }
          }

          tempRowData =  tempGreen[maskRow];
          for  (maskCol = maskColStart;  maskCol <= maskColEnd;  maskCol++)
          {
            if  (BackgroundPixel (tempRowData[maskCol]))
            {
              fit = false;
              break;
            }
          }
        }

        if  (!fit)
          green[r][c] = backgroundPixelValue;
        else
          foregroundPixelCount++;
      }

      maskColStart++;
      maskColEnd++;
    }   /* End of for(c) */

    maskRowStart++;
    maskRowEnd++;
  }   /* End of for(r) */

}  /* Erosion */

void Raster::Erosion	(	MorphOp::StructureType	_structure,
		kkuint16	_structureSize,
		kkint32	_backgroundCountTH
	)

Definition at line 2388 of file Raster.cpp.

References KKB::MorphOpStruct::BackgroundCountTH(), ForegroundPixelCount(), foregroundPixelCount, green, greenArea, KKB::MorphOpErosion::MorphOpErosion(), and KKB::MorphOpErosion::PerformOperation().

{
  MorphOpErosion  eroder (_structure, _structureSize);
  eroder.BackgroundCountTH (_backgroundCountTH);
  RasterPtr tempRaster = eroder.PerformOperation (this);
  delete  greenArea;
  delete  green;
  foregroundPixelCount = tempRaster->ForegroundPixelCount ();

  greenArea = tempRaster->greenArea;
  green     = tempRaster->green;

  tempRaster->greenArea = NULL;
  tempRaster->green     = NULL;

  delete  tempRaster;
} /* Erosion */

void Raster::Erosion

(

RasterPtr

dest

)

const

Place into destination a eroded version of this instances image.

Definition at line 2411 of file Raster.cpp.

References backgroundPixelTH, foregroundPixelCount, Green(), green, GreenArea(), greenArea, Height(), height, ReSize(), TotPixels(), Width(), and width.

Referenced by KKMLL::GrayScaleImagesFVProducer::ComputeFeatureVector().

{
  if  ((dest->Height () != height)  |  (dest->Width () != width))
    dest->ReSize (height, width, false);

  uchar*   destArea = dest->GreenArea ();
  uchar**  destRows = dest->Green ();

  uchar*   srcArea = greenArea;
  uchar**  srcRows = green;

  kkint32  totalArea = this->TotPixels ();

  memset (destArea, 0, totPixels);
  kkint32  pixelCount = 0;

  int  c, r;

  //  Take care of Top and Bottom rows.
  {
    uchar*  srcRow0         = srcRows[0];
    uchar*  srcRow1         = srcRows[1];
    uchar*  srcRowBot0      = srcRows[height - 1];
    uchar*  srcRowBot1      = srcRows[height - 2];

    uchar*  destRow0 = destRows[0];
    uchar*  destRowBot = destRows[height - 1];
    for (c = 1;  c < (width  - 1);  ++c)
    {
      if  ((srcRow0[c - 1] > backgroundPixelTH)  &&  (srcRow0[c] > backgroundPixelTH)  &&  (srcRow0[c + 1] > backgroundPixelTH)  &&
           (srcRow1[c - 1] > backgroundPixelTH)  &&  (srcRow1[c] > backgroundPixelTH)  &&  (srcRow1[c + 1] > backgroundPixelTH)
          )
      {
        destRow0[c] = 255;
        ++pixelCount;
      }

      if  ((srcRowBot0[c - 1] > backgroundPixelTH)  &&                                           (srcRowBot0[c + 1] > backgroundPixelTH)  &&
           (srcRowBot1[c - 1] > backgroundPixelTH)  &&  (srcRowBot1[c] > backgroundPixelTH)  &&  (srcRowBot1[c + 1] > backgroundPixelTH)
          )
      {
        destRowBot[c] = 255;
        ++pixelCount;
      }
    }
  }


  // Take care of left and right columns
  {
    for  (r = 1;  r < (height - 1);  ++r)
    {
      if  ((srcRows[r - 1][0] > backgroundPixelTH)  &&  (srcRows[r - 1][1] > backgroundPixelTH)  &&
           (srcRows[r    ][0] > backgroundPixelTH)  &&  (srcRows[r    ][1] > backgroundPixelTH)  &&
           (srcRows[r + 1][0] > backgroundPixelTH)  &&  (srcRows[r + 1][1] > backgroundPixelTH)
          )
      {
        destRows[r][0] = 255;
        ++pixelCount;
      }


      if  ((srcRows[r - 1][width - 1] > backgroundPixelTH)  &&  (srcRows[r - 1][width - 2] > backgroundPixelTH)  &&
           (srcRows[r    ][width - 1] > backgroundPixelTH)  &&  (srcRows[r    ][width - 2] > backgroundPixelTH)  &&
           (srcRows[r + 1][width - 1] > backgroundPixelTH)  &&  (srcRows[r + 1][width - 2] > backgroundPixelTH)
          )
      {
        destRows[r][width - 1] = 255;
        ++pixelCount;
      }
    }
  }


  // Take care of main Body
  {
    for  (r = 1;  r < (height - 1);  ++r)
    {
      uchar*  srcRow0 = srcRows[r - 1];
      uchar*  srcRow1 = srcRows[r    ];
      uchar*  srcRow2 = srcRows[r + 1];

      for  (c = 1;  c < (width - 1);  ++c)
      {
        if  ((srcRow0[c - 1] > backgroundPixelTH)  &&  (srcRow0[c] > backgroundPixelTH)  &&  (srcRow0[c + 1] > backgroundPixelTH)  &&
             (srcRow1[c - 1] > backgroundPixelTH)  &&  (srcRow1[c] > backgroundPixelTH)  &&  (srcRow1[c + 1] > backgroundPixelTH)  &&
             (srcRow2[c - 1] > backgroundPixelTH)  &&  (srcRow2[c] > backgroundPixelTH)  &&  (srcRow2[c + 1] > backgroundPixelTH)
            )
        {
          destRows[r][c] = 255;
          ++pixelCount;
        }
      }
    }
  }

  dest->foregroundPixelCount = pixelCount;
}  /* Erosion*/

void Raster::Erosion	(	RasterPtr	dest,
		MaskTypes	mask
	)		const

Definition at line 2514 of file Raster.cpp.

References foregroundPixelCount, Green(), green, GreenArea(), Height(), height, ReSize(), Width(), and width.

Referenced by KKMLL::GrayScaleImagesFVProducer::ComputeFeatureVector().

{
  if  ((dest->Height () != height)  |  (dest->Width () != width))
    dest->ReSize (height, width, false);

  uchar*   destArea = dest->GreenArea ();
  uchar**  destRows = dest->Green ();

  memset (destArea, 0, totPixels);
  kkint32  pixelCount = 0;

  int  c, r;

  // Take care of main Body
  {
    for  (r = 0;  r < height;  ++r)
    {
      uchar*  rowData = green[r];
      for  (c = 0;  c < width;  ++c)
      {
        if  (ForegroundPixel (rowData[c]))
        {
          if  (Fit (mask, r, c))
          {
            destRows[r][c] = 255;
            ++pixelCount;
          }
        }
      }
    }
  }

  dest->foregroundPixelCount = pixelCount;
}  /* Erosion*/

void Raster::ErosionBoundary	(	MaskTypes	mask,
		kkint32	blobrowstart,
		kkint32	blobrowend,
		kkint32	blobcolstart,
		kkint32	blobcolend
	)

Definition at line 2787 of file Raster.cpp.

References backgroundPixelValue, KKB::MorphOp::Biases(), foregroundPixelCount, Green(), green, height, KKB::MorphOp::MaskShapes(), Raster(), KKB::MorphOp::stSquare, and width.

{
  kkint32  r;
  kkint32  c;

  kkint32  bias = MorphOp::Biases (mask);

  kkint32  maskRowStart = 0 - bias;
  kkint32  maskRowEnd   = 0 + bias;
  kkint32  maskColStart = 0 - bias;
  kkint32  maskColEnd   = 0 + bias;

  kkint32  maskRow = 0;
  kkint32  maskCol = 0;
  bool  fit    = false;

  foregroundPixelCount = 0;
  Raster  tempRaster (*this);

  uchar**     tempGreen   = tempRaster.Green ();
  uchar*      tempRowData = NULL;

  StructureType  m = MorphOp::MaskShapes (mask);

  for  (r = 0;  r < height;  r++)
  {
    //if ((r>= blobrowstart+30) && (r<= blobrowend-30))
    // {
    // }
  // else
  // {
    maskColStart = 0 - bias;
    maskColEnd   = 0 + bias;

    tempRowData = tempGreen[r];

    for  (c = 0; c < width; c++)
    {
      if  ((c >= blobcolstart + 100)  &&  (c <= blobcolend - 100))
      {
      }
      else
      {
        if  (ForegroundPixel (green[r][c]))
        {
          fit = true;
          if  ((maskRowStart <  0)       || 
               (maskRowEnd   >= height)  ||  
               (maskColStart <  0)       ||
               (maskColStart >= width)
              )
          {
            fit = false;
          }

          else if  (m == StructureType::stSquare)
          {
            for  (maskRow = maskRowStart;  ((maskRow <= maskRowEnd)  &&  fit);  maskRow++)
            {
              tempRowData =  tempGreen[maskRow];
              for  (maskCol = maskColStart;  maskCol <= maskColEnd;  maskCol++)
              {
                if  (BackgroundPixel (tempRowData[maskCol]))
                {
                  fit = false;
                  break;
                }
              }
            }
          }
          else
          {
            //  Cross Structure
            for  (maskRow = maskRowStart;  maskRow <= maskRowEnd;  maskRow++)
            {
              if  (BackgroundPixel (tempGreen[maskRow][c]))
              {
                fit = false;
                break;
              }
            }

            tempRowData =  tempGreen[maskRow];
            for  (maskCol = maskColStart;  maskCol <= maskColEnd;  maskCol++)
            {
              if  (BackgroundPixel (tempRowData[maskCol]))
              {
                fit = false;
                break;
              }
            }
          }

          if  (!fit)
            green[r][c] = backgroundPixelValue;
          else
            foregroundPixelCount++;
        }

        maskColStart++;
        maskColEnd++;
      }
    }   /* End of for(c) */

    maskRowStart++;
    maskRowEnd++;
    //}
  }   /* End of for(r) */

}  /* ErosionBoundary */

void Raster::ErosionChanged	(	MaskTypes	mask,
		kkint32	row,
		kkint32	col
	)

Definition at line 2558 of file Raster.cpp.

References backgroundPixelValue, KKB::MorphOp::Biases(), foregroundPixelCount, Green(), green, KKB::MorphOp::MaskShapes(), Raster(), and KKB::MorphOp::stSquare.

{
  kkint32  r;
  kkint32  c;

  kkint32  bias = MorphOp::Biases (mask);

  kkint32  maskRowStart ;
  kkint32  maskRowEnd  ; 
  kkint32  maskColStart ;
  kkint32  maskColEnd  ;
  maskRowStart = 0 - bias;
  maskRowEnd   = 0+ bias;
  maskColStart = 0 - bias;
  maskColEnd   = 0 + bias;
  
  kkint32  maskRow;
  kkint32  maskCol;
  bool  fit;

  foregroundPixelCount = 0;
  Raster      tempRaster (*this);
  uchar**     tempGreen = tempRaster.Green ();
  uchar*      tempRowData = NULL;
  StructureType  m = MorphOp::MaskShapes (mask);

  for  (r = row- 150;  r < row+150;  r++)
  { 
    if (r<0)
    r =0;
    maskColStart = 0 - bias;
    maskColEnd   = 0 + bias;
    
    tempRowData = tempGreen[r];

    for  (c = col - 10; c < col + 10; c++)
    {
      if  (c < 0)
        c = 0;
      // cout << maskColStart <<" ";
        
      if  (ForegroundPixel (green[r][c]))
      {
        fit = true;
        if  ((maskRowStart <  row - 100)  || 
             (maskRowEnd   >= row + 100)  ||  
             (maskColStart <  col - 10)   ||
             (maskColStart >= col + 10)
            )
        {
          fit = false;
        }

        else if  (m == StructureType::stSquare)
        {
          for  (maskRow = row - 150;  ((maskRow <= row + 150)  &&  fit);  maskRow++)
          {
            tempRowData =  tempGreen[maskRow];
            for  (maskCol = col - 10;  maskCol <= col + 10 ; maskCol++)
            {
              if  (BackgroundPixel (tempRowData[maskCol]))
              {
                fit = false;
                break;
              }
            }
          } 
        }

        else
        {
          //  Cross Structure
          for  (maskRow = row-20;  maskRow <= row+20;  maskRow++)
          {
            if  (BackgroundPixel (tempGreen[maskRow][c]))
            {
              fit = false;
              break;
            }
          }

          tempRowData =  tempGreen[maskRow];
          for  (maskCol = col-20;  maskCol <= col+20;  maskCol++)
          {
            if  (BackgroundPixel (tempRowData[maskCol]))
            {
              fit = false;
              break;
            }
          }
        }

        if  (!fit)
          green[r][c] = backgroundPixelValue;
        else
          foregroundPixelCount++;
      }

      maskColStart++;
      maskColEnd++;
    }   /* End of for(c) */

    maskRowStart++;
    maskRowEnd++;
  }   /* End of for(r) */

}  /* ErosionChanged */

void Raster::ErosionChanged1	(	MaskTypes	mask,
		kkint32	row,
		kkint32	col
	)

Definition at line 2671 of file Raster.cpp.

References backgroundPixelValue, KKB::MorphOp::Biases(), foregroundPixelCount, Green(), green, KKB::MorphOp::MaskShapes(), Raster(), and KKB::MorphOp::stSquare.

{
  kkint32  r;
  kkint32  c;

  kkint32  bias = MorphOp::Biases (mask);

  kkint32  maskRowStart = 0;
  kkint32  maskRowEnd   = 0; 
  kkint32  maskColStart = 0;
  kkint32  maskColEnd   = 0;

  maskRowStart = 0 - bias;
  maskRowEnd   = 0 + bias;
  maskColStart = 0 - bias;
  maskColEnd   = 0 + bias;
  
  kkint32  maskRow;
  kkint32  maskCol;
  bool  fit;

  foregroundPixelCount = 0;

  Raster  tempRaster (*this);

  uchar**     tempGreen   = tempRaster.Green ();
  uchar*      tempRowData = NULL;
  StructureType  m = MorphOp::MaskShapes (mask);

  for  (r = row- 20;  r < row+20;  r++)
  { 
    if  (r < 0)
      r =0;
  
    maskColStart = 0 - bias;
    maskColEnd   = 0 + bias;
    
    tempRowData = tempGreen[r];

    for  (c = col - 150; c < col + 150; c++)
    {
      if  (c < 0)
        c=0;
      // cout << maskColStart <<" ";
        
      if  (ForegroundPixel (green[r][c]))
      {
        fit = true;
        if  ((maskRowStart <  row - 50)  || 
             (maskRowEnd   >= row + 50)  ||  
             (maskColStart <  col - 100) ||
             (maskColStart >= col+100)
            )
        {
          fit = false;
        }

        else if  (m == StructureType::stSquare)
        {
          for  (maskRow = row - 20;  ((maskRow <= row + 20)  &&  fit);  maskRow++)
          {
            tempRowData =  tempGreen[maskRow];
            for  (maskCol = col - 150;  maskCol <= col + 150 ; maskCol++)
            {
              if  (BackgroundPixel (tempRowData[maskCol]))
              {
                fit = false;
                break;
              }
            }
          } 
        }

        else
        {
          //  Cross Structure
          for  (maskRow = row-20;  maskRow <= row+20;  maskRow++)
          {
            if  (BackgroundPixel (tempGreen[maskRow][c]))
            {
              fit = false;
              break;
            }
          }

          tempRowData =  tempGreen[maskRow];
          for  (maskCol = col-20;  maskCol <= col+20;  maskCol++)
          {
            if  (BackgroundPixel (tempRowData[maskCol]))
            {
              fit = false;
              break;
            }
          }
        }

        if  (!fit)
          green[r][c] = backgroundPixelValue;
        else
          foregroundPixelCount++;
      }

      maskColStart++;
      maskColEnd++;
    }   /* End of for(c) */

    maskRowStart++;
    maskRowEnd++;
  }   /* End of for(r) */
}  /* ErosionChanged1 */

RasterPtr Raster::ExtractABlob

(

const BlobPtr

blob

)

const

Extracts a specified blob from this image; useful to extract individual detected blobs.

The 'ExtractBlobs' method needs to have been performed on this instance first. You would use this method after calling 'ExtractBlobs'. The extracted image will be of the same dimensions as the original image except it will extract the pixels that belong to the specified blob only.

// Example of processing extracted blobs
void  ProcessIndividulConectedComponents (RasterPtr  image)
{
  BlobListPtr blobs = image->ExtractBlobs (3);
  BlobList::iterator  idx;
  for  (idx = blobs->begin ();  idx != end ();  ++idx)
  {
    RasterPtr  individuleBlob = image->ExtractABlob (*idx);
    DoSomethingWithIndividuleBlob (individuleBlob);
    delete  individuleBlob;
    individuleBlob = NULL;
  )
  delete  blobs;
  blobs = NULL;
}

Definition at line 3761 of file Raster.cpp.

References AllocateARasterInstance(), blobIds, blue, KKB::Blob::colLeft, color, KKB::Blob::colRight, green, height, KKB::Blob::id, red, KKB::Blob::rowBot, KKB::Blob::rowTop, and width.

{
  RasterPtr  blobRaster = AllocateARasterInstance (height, width, color);

  kkint32  row;
  kkint32  col;

  for  (row = blob->rowTop;  row <= blob->rowBot;  row++)
  {
    for  (col = blob->colLeft;  col <= blob->colRight;  col++)
    {
      if  (blobIds[row][col] == blob->id)
      {
        blobRaster->green[row][col] = green[row][col];
        if  (color)
        {
          blobRaster->red [row][col] = red [row][col];
          blobRaster->blue[row][col] = blue[row][col];
        }
      }
    }
  }

  return  blobRaster;
}  /* ExtractABlob */

RasterPtr Raster::ExtractABlobTightly	(	const BlobPtr	blob,
		kkint32	padding
	)		const

Extracts a specified blob from this image into a tightly bounded image.

Similar to 'ExtractABlob' except that the returned image will have the dimension necessary to contain the specified blob with the specified number of padded row and columns.

Definition at line 3722 of file Raster.cpp.

References AllocateARasterInstance(), blobIds, blue, KKB::Blob::colLeft, color, KKB::Blob::colRight, green, KKB::Blob::Height(), KKB::Blob::id, red, KKB::Blob::rowBot, KKB::Blob::rowTop, and KKB::Blob::Width().

{
  if  (blob == NULL)
    return NULL;

  RasterPtr  blobRaster = AllocateARasterInstance (blob->Height () + 2 * padding, blob->Width () + 2 * padding, color);

  kkint32  blobRow = padding;
  kkint32  blobCol = padding;

  kkint32  row = 0;
  kkint32  col = 0;

  for  (row = blob->rowTop;  row <= blob->rowBot;  row++)
  {
    blobCol = padding;
    for  (col = blob->colLeft;  col <= blob->colRight;  col++)
    {
      if  (blobIds[row][col] == blob->id)
      {
        blobRaster->green[blobRow][blobCol] = green[row][col];
        if  (color)
        {
          blobRaster->red [blobRow][blobCol] = red [row][col];
          blobRaster->blue[blobRow][blobCol] = blue[row][col];
        }
      }
      blobCol++;
    }
    blobRow++;
  }
  return  blobRaster;
}  /* ExtractABlobTightly */

BlobListPtr Raster::ExtractBlobs

(

kkint32

dist

)

Will extract a list of connected components from this instance.

Will perform a connected component analysis and label each individual blob. A list of blob descriptors will be returned. These blob descriptors can then be used to access individual blobs. See 'ExtractABlob' for an example on how to use this method. The 'ForegroundPixel' method is used to determine if a given pixel is foreground or background.

Parameters

[in]

dist

The distance in pixels that two different pixel locations have to be for them to be considered connected. "dist = 1" would indicate that two pixels have to be directly connected.

Returns

A list of Blob descriptor instances.

See also

ExtractABlob, ExtractABlobTightly, Blob

Definition at line 3200 of file Raster.cpp.

References blobIds, KKB::BlobList::BlobList(), KKB::KKStr::Concat(), green, height, KKB::Blob::Id(), KKB::Blob::id, KKB::KKException::KKException(), KKB::BlobList::LookUpByBlobId(), KKB::BlobList::MergeIntoSingleBlob(), KKB::BlobList::NewBlob(), KKB::Blob::pixelCount, and width.

Referenced by KKMLL::GrayScaleImagesFVProducer::ComputeFeatureVector(), ConnectedComponent(), and ReduceToMostCompleteBlob().

{
  uchar*   curRow         = NULL;
  kkint32*   curRowBlobIds  = NULL;

  kkint32  col = 2;
  kkint32  row = 2;

  BlobPtr  curBlob    = NULL;
  kkint32  curBlobId  = 0;
  kkint32  nearBlobId = 0;

  kkint32  blankColsInARow = 0;

  AllocateBlobIds ();  

  BlobListPtr blobs = new BlobList (true);

  for  (row = 0;  row < height;  ++row)
  {
    curRow        = green[row];
    curRowBlobIds = blobIds[row];

    curBlob = NULL;

    col = 0;
    while  (col < width)
    {
      if  (ForegroundPixel (curRow[col]))
      {
        blankColsInARow = 0;

        nearBlobId = NearestNeighborUpperLeft (row, col, dist);
        if  (nearBlobId < 0)
          nearBlobId = NearestNeighborUpperRight (row, col, dist);


        if  (curBlob)
        {
          if  (nearBlobId >= 0)
          {
            if  (nearBlobId != curBlobId)
            {
              curBlob = blobs->MergeIntoSingleBlob (curBlob, nearBlobId, blobIds);
              curBlobId = curBlob->Id ();
            }
          }

          curRowBlobIds[col] = curBlobId;
          curBlob->colRight  = Max (curBlob->colRight, col);
          curBlob->rowBot    = Max (curBlob->rowBot,   row);
          curBlob->pixelCount++;
        }
        else
        {
          // No Current Blob
          if  (nearBlobId >= 0)
          {
            curBlob   = blobs->LookUpByBlobId (nearBlobId);
            if  (curBlob)
              curBlobId = curBlob->id;
            else
            {
              // If we get to this point there is something wrong with the 'blobs' data structure; for every blobId
              // specified in blobIds(via nearBlobId) there should be a entry in 'blobs'.
              curBlob = blobs->NewBlob(row, col);
              if  (!curBlob)  throw KKException(" Raster::ExtractBlobs   curBlob == NULL");

              curBlobId = curBlob->id;
            }
          }
          else
          {
            curBlob = blobs->NewBlob (row, col);
            if  (!curBlob)
            {
              KKStr errMsg = "Raster::ExtractBlobs   ***ERROR***   allocation of new 'curBlob' failed.";
              cerr << endl << errMsg << endl << endl;
              throw KKException (errMsg);
            }
            curBlobId = curBlob->id;
          }

          curRowBlobIds[col] = curBlobId;
          curBlob->colLeft   = Min (curBlob->colLeft,  col);
          curBlob->colRight  = Max (curBlob->colRight, col);
          curBlob->rowBot    = Max (curBlob->rowBot,   row);
          curBlob->rowTop    = Min (curBlob->rowTop,   row);
          curBlob->pixelCount++;
        }
      }
      else
      {
        // Background Pixel
        if  (curBlob)
        {
          nearBlobId = NearestNeighborUpperLeft (row, col, dist);

          if  (nearBlobId >= 0)
          {
            if  (nearBlobId != curBlobId)
            {
              curBlob = blobs->MergeIntoSingleBlob (curBlob, nearBlobId, blobIds);
              curBlobId = curBlob->Id ();
            }
          }
        }
        
        blankColsInARow++;
        if  (blankColsInARow > dist)
        {
          curBlob = NULL;
          curBlobId = -1;
        }
      }

      col++;
    }
  }

  return  blobs;
}  /* ExtractBlobs */

RasterPtr Raster::ExtractChannel

(

ColorChannels

channel

)

Will return a gray-scale image consisting of the specified color channel only.

Definition at line 7717 of file Raster.cpp.

References AllocateARasterInstance(), BlueArea(), color, KKB::KKStr::Concat(), FileName(), KKB::Green, GreenArea(), height, KKB::KKStr::operator+(), KKB::osGetRootName(), KKB::Red, RedArea(), and width.

Referenced by SegmentImage().

{
  if  (!color)
    return  AllocateARasterInstance (*this);

  RasterPtr  r = AllocateARasterInstance (height, width, false);

  uchar*  src = NULL;

  KKStr  rootName = osGetRootName (FileName ());

  if  (channel == ColorChannels::Red)
  {
    r->FileName (rootName + "_Red.bmp") ;
    src = RedArea ();
  }

  else if  (channel == ColorChannels::Green)
  {
    r->FileName (rootName + "_Green.bmp") ;
    src = GreenArea ();
  }

  else 
  {
    r->FileName (rootName + "_Blue.bmp") ;
    src = BlueArea ();
  }

  uchar*  dest = r->GreenArea ();

  memcpy (dest, src, totPixels);

  return  r;
}  /* ExtractChannel */

RasterPtr Raster::ExtractUsingMask

(

RasterPtr

mask

)

Extracts the pixel locations where the 'mask' images pixel location is a foreground pixel.

Definition at line 7759 of file Raster.cpp.

References BackgroundPixelTH(), BackgroundPixelValue(), Blue(), blue, color, ForegroundPixelValue(), Green(), green, height, Raster(), Red(), red, and width.

{
  RasterPtr  result = new Raster (height, width, color);
  result->BackgroundPixelTH    (this->BackgroundPixelTH    ());
  result->BackgroundPixelValue (this->BackgroundPixelValue ());
  result->ForegroundPixelValue (this->ForegroundPixelValue ());

  if  (!mask)
    return  result;

  int  heighToUse = Min (height, mask->Height ());
  int  widthToUse = Min (width,  mask->Width  ());

  uchar  maskBackgroundValue = mask->BackgroundPixelValue ();
  uchar  maskBackgroundTH    = mask->BackgroundPixelTH ();


  for  (int row = 0;  row < heighToUse;  ++row)
  {
    uchar*  maskRow = (mask->Green ())[row];

    uchar*  resultGreenRow = (result->Green ())[row];
    uchar*  srcGreenRow = green[row];

    uchar*  resultRedRow  = NULL;
    uchar*  srcRedRow     = NULL;

    uchar*  resultBlueRow = NULL;
    uchar*  srcBlueRow    = NULL;

    if  (color)
    {
      resultRedRow  = (result->Red  ())[row];
      srcRedRow     = red[row];
      resultBlueRow = (result->Blue ())[row];
      srcBlueRow    = blue[row];
    }

    for  (int col = 0;  col < widthToUse;  ++col)
    {
      bool  backgroundPix = (maskBackgroundValue < 125) ? (maskRow[col] <= maskBackgroundTH) : (maskRow[col] >= maskBackgroundTH);
      bool  usePixel = !backgroundPix;
      if  (usePixel)
      {
        resultGreenRow[col] = srcGreenRow[col];
        if  (color)
        {
          resultRedRow [col] = srcRedRow  [col];
          resultBlueRow[col] = srcBlueRow [col];
        }
      }
    }
  }
  return  result;
}  /* ExtractUsingMask */

RasterPtr Raster::FastFourier

(

)

const

Definition at line 5016 of file Raster.cpp.

References fourierMagArea, greenArea, height, Raster(), totPixels, and width.

{
  #if  defined(FFTW_AVAILABLE)
    fftwf_complex*   src  = NULL;
    fftwf_complex*   dest = NULL;
    fftwf_plan       plan = NULL;
  #else
    KK_DFT2D_Float  plan (height, width, true);

    KK_DFT2D_Float::DftComplexType*   srcArea = NULL;
    KK_DFT2D_Float::DftComplexType**  src     = NULL;

    KK_DFT2D_Float::DftComplexType*   destArea = NULL;
    KK_DFT2D_Float::DftComplexType**  dest     = NULL;
  #endif

  if  (totPixels <= 0)
  {
    cerr << std::endl << std::endl
      << "Raster::FastFourier   ***ERROR***      totPixels == 0." << std::endl
      << "              FileName[" << this->FileName () << "]"    << std::endl
      << std::endl;
    return NULL;
  }

  kkint32  col;
  kkint32  row;

  kkint32  idx = 0;

  #if  defined(FFTW_AVAILABLE)
    src  = (fftwf_complex*)fftwf_malloc (sizeof (fftwf_complex) * totPixels);
    dest = (fftwf_complex*)fftwf_malloc (sizeof (fftwf_complex) * totPixels);
  #else
    plan.AllocateArray (srcArea,  src);
    plan.AllocateArray (destArea, dest);
  #endif

  if  (src == NULL)
  {
    std::cerr 
        << std::endl << std::endl 
        << "Raster::FastFourier   ***ERROR***    Allocation of 'src' failed'" << std::endl
        << "              totPixels[" << totPixels << "]"    << std::endl
        << "              FileName[" << fileName   << "]"    << std::endl
        << std::endl;
    return NULL;
  }

  if  (dest == NULL)
  {
    std::cerr 
        << std::endl << std::endl
        << "Raster::FastFourier   ***ERROR***    Allocation of 'dest' failed'" << std::endl
        << "              totPixels[" << totPixels << "]"    << std::endl
        << "              FileName[" << fileName   << "]"    << std::endl
        << std::endl;
    return NULL;
  }

  // float scalingFact = (float)255.0 / maxPixVal;   // kk  2004-May-18

  for  (row = 0; row < height; row++ )
  {
    for (col = 0; col < width; col++ )
    {     
      // src[idx].re = (float)green[row][col] * scalingFact;
      #if  defined(FFTW_AVAILABLE)
        src[idx][0] = (float)green[row][col];
        src[idx][1] = 0.0;
      #else
        srcArea[idx].real ((float)greenArea[idx]);
        srcArea[idx].imag (0.0);
      #endif
      idx++;
    }
  }
  
  #if  defined(FFTW_AVAILABLE)
    plan = fftwCreateTwoDPlan (height, width, src, dest, FFTW_FORWARD, FFTW_ESTIMATE);
    fftwf_execute (plan);
    fftwDestroyPlan (plan);
  #else
    plan.Transform (src, dest);
  #endif


  RasterPtr fourierImage = new Raster (height, width);

  uchar*  destData = fourierImage->greenArea;

  fourierImage->AllocateFourierMagnitudeTable ();
  float* fourierMagArray = fourierImage->fourierMagArea;

  float  mag = (float)0;

  float  maxAmplitude = (float)0;

  for  (idx = 0; idx < totPixels; idx++)
  {
    #if  defined(FFTW_AVAILABLE)
      float real = dest[idx][0];
      float imag = dest[idx][1];
    #else
      float real = destArea[idx].real ();
      float imag = destArea[idx].imag ();
    #endif

    // mag = (float)log10 (sqrt (real * real + imag * imag));
    mag = (float)(sqrt (real * real + imag * imag));

    if  (mag > maxAmplitude)
      maxAmplitude = mag;

    fourierMagArray[idx] = mag;  // kk 2004-May-18
  }

  float  maxAmplitudeLog = log (maxAmplitude);

  idx = 0;
  for (idx = 0; idx < totPixels; idx++ )
  {
    //  mag = (float)sqrt (dest[idx].re * dest[idx].re + dest[idx].im * dest[idx].im);  // kk 2004-May-18
    mag = fourierMagArray[idx];                                                          // kk 2004-May-18

    // destData[idx] = (uchar)(dest[idx].re * maxPixVal / maxAmplitude);

    // kk  2004-May-18
    // Changed the above line to use the constant 255 instead of maxPixVal,  
    // If we have an image who's maxPixVal is less than 255 then the values
    // being calculated for the Fourier features will not be consistent.
    // destData[idx] = (uchar)(dest[idx].re * 255 / maxAmplitude);
    destData[idx] = (uchar)(log (fourierMagArray[idx]) * 255.0f / maxAmplitudeLog);
  }            

  #if  defined(FFTW_AVAILABLE)
    fftwf_free (src);   src  = NULL;
    fftwf_free (dest);  dest = NULL;
  #else
    plan.DestroyArray (srcArea,  src);
    plan.DestroyArray (destArea, dest);
  #endif

  return  fourierImage;
}  /* FastFourier */

RasterPtr Raster::FastFourierKK

(

)

const

Definition at line 4939 of file Raster.cpp.

References AllocateARasterInstance(), fourierMagArea, greenArea, height, totPixels, and width.

{

  KK_DFT2D_Float  plan (height, width, true);
  KK_DFT2D_Float::DftComplexType**  dest;
  KK_DFT2D_Float::DftComplexType*   destArea;
  plan.AllocateArray (destArea, dest);

  if  (destArea == NULL)
  {
    std::cerr 
        << std::endl << std::endl
        << "Raster::FastFourierKK   ***ERROR***    Allocation of 'dest' failed'" << std::endl
        << "              totPixels[" << totPixels << "]"    << std::endl
        << "              FileName[" << fileName   << "]"    << std::endl
        << std::endl;
    return NULL;
  }

  plan.Transform (green, dest);

  RasterPtr fourierImage = AllocateARasterInstance (height, width, false);

  uchar*  destData = fourierImage->greenArea;

  fourierImage->AllocateFourierMagnitudeTable ();
  float* fourierMagArray = fourierImage->fourierMagArea;

  float  mag = 0.0f;

  float  maxAmplitude = 0.0f;

  kkint32 idx = 0;
  for  (kkint32 row = 0; row < height; row++ )
  {
    for (kkint32 col = 0; col < width; col++ )
    {
      double  r = dest[row][col].real ();
      double  i = dest[row][col].imag ();

      mag = (float)(sqrt (r * r + i * i));
      if  (mag > maxAmplitude)
        maxAmplitude = mag;

      fourierMagArray[idx] = mag;  // kk 2004-May-18
      ++idx;
    }
  }

  float  maxAmplitudeLog = log (maxAmplitude);

  idx = 0;
  for (idx = 0; idx < totPixels; idx++ )
  {
    //  mag = (float)sqrt (dest[idx].re * dest[idx].re + dest[idx].im * dest[idx].im);  // kk 2004-May-18
    mag = fourierMagArray[idx];                                                         // kk 2004-May-18

    // destData[idx] = (uchar)(dest[idx].re * maxPixVal / maxAmplitude);

    // kk  2004-May-18
    // Changed the above line to use the constant 255 instead of maxPixVal,  
    // If we have an image who's maxPixVal is less than 255 then the values
    // being calculated for the Fourier features will not be consistent.
    // destData[idx] = (uchar)(dest[idx].re * 255 / maxAmplitude);
    destData[idx] = (uchar)(log (fourierMagArray[idx]) * 255.0f / maxAmplitudeLog);
  }

  delete  dest;      dest     = NULL;
  delete  destArea;  destArea = NULL;

  return  fourierImage;
}  /* FastFourierKK */

const KKStr& KKB::Raster::FileName ( ) const

inline

Definition at line 315 of file Raster.h.

References fileName.

Referenced by ExtractChannel().

{return  fileName;}

void KKB::Raster::FileName ( const KKStr &  _fileName )

inline

Definition at line 346 of file Raster.h.

References fileName, and KKB::KKStr::operator=().

Referenced by ExtractChannel().

{fileName             = _fileName;}

void Raster::FillBlob	(	RasterPtr	origImage,
		BlobPtr	blob,
		PixelValue	color
	)

Will paint the specified blob with the specified color.

Example Use:
   BlobListPtr  blobs = srcImage->ExctractBlobs (1);
   RasterPtr  labeledColorImage = new Raster (srcImage->Height (), srcImage->Width (), true);
   BlobList::iterator  idx;
   for  (idx = blobs->begin ();  idx != blobs->end ();  ++idx)
   {
     BlobPtr  blob = *idx;
     labeledColorImage->FillBlob (srcImage, blob, PixelValue::Red);
   }

Parameters

[in]	origImage	The image where the blob was extracted from.
[in]	blob	The specific blob that you want to fill in/ paint.
[in]	color	that is to be filled in.

Definition at line 9885 of file Raster.cpp.

References blobIds, Height(), height, KKB::Blob::Id(), SetPixelValue(), Width(), and width.

{
  if  (blob == NULL)
    return;

  if  (origImage->blobIds == NULL)
    return;

  if  ((origImage->Height () != height)  ||  (origImage->Width () != width))
    return;

  kkint32  blobId = blob->Id ();
  kkint32  row = 0, col = 0;

  kkint32  rowStart = Min (blob->RowTop   (), height - 1);
  kkint32  rowEnd   = Min (blob->RowBot   (), height - 1);
  kkint32  colStart = Min (blob->ColLeft  (), width  - 1);
  kkint32  colEnd   = Min (blob->ColRight (), width  - 1);

  for  (row = rowStart;  row <= rowEnd;  ++row)
  {
    for  (col = colStart;  col <= colEnd;  ++col)
    {
      if  (origImage->blobIds[row][col] == blobId)
      {
        SetPixelValue (row, col, color);
      }
    }
  }
}  /* FillBlob */

void Raster::FillHole

(

)

Definition at line 2047 of file Raster.cpp.

References foregroundPixelCount, foregroundPixelValue, green, height, Raster(), and width.

Referenced by CalcAreaAndIntensityFeatures(), CalcAreaAndIntensityHistogramWhite(), and DeriveImageLength().

{
  kkint32  r;
  kkint32  c;
  Raster  mask (*this);

  uchar**  maskRows = mask.green;

  kkint32  lastRow = height - 1;
  kkint32  lastCol = width  - 1;

  for  (c = 0; c < width; c++)
  {
    if  (BackgroundPixel (maskRows[0][c]))
      mask.FillHoleGrow (0, c);

    if  (BackgroundPixel (maskRows[lastRow][c]))
      mask.FillHoleGrow (lastRow, c);
  }

  for  (r = 0; r < height; r++)     
  {
    if  (BackgroundPixel (maskRows[r][0]))
      mask.FillHoleGrow (r, 0);

    if  (BackgroundPixel (maskRows[r][lastCol]))
      mask.FillHoleGrow (r, lastCol);
  }

  // Now that we know what pixels are background that are connected to one of the boarders,  any other white pixel
  // must be in a hole inside the image.
  foregroundPixelCount = 0;
  uchar*  curRow = NULL;
  for  (r = 0; r < height; r++)
  {
    curRow = green[r];
    for  (c = 0; c < width; c++)
    {
      if  (BackgroundPixel (curRow[c]))
      {
        if  (BackgroundPixel (maskRows[r][c]))
        {
          curRow[c] = foregroundPixelValue;
          foregroundPixelCount++;
        }
      }
      else
      {
        foregroundPixelCount++;
      }
    }
  }
  
  foregroundPixelCount = 0;
}  /* FillHole */

void Raster::FillHole

(

RasterPtr

mask

)

Fills holes in the image using the 'mask' raster as a work area.

Any pixel that is not a foreground pixels that has not path by a cross structure to the edge of the image will be painted with the foreground pixel value. The 'mask' raster instance provided will be used as a temporary work area. If its dimensions are not the same as this instance it will e resized.

Definition at line 2107 of file Raster.cpp.

References backgroundPixelTH, foregroundPixelCount, foregroundPixelValue, Green(), GreenArea(), Height(), height, ReSize(), totPixels, Width(), and width.

Referenced by KKMLL::GrayScaleImagesFVProducer::ComputeFeatureVector().

{
  if  ((mask->Height () != height)  |  (mask->Width () != width))
    mask->ReSize (height, width, false);

  uchar*   srcArea = this->GreenArea ();
  uchar**  srcRows = this->Green ();

  uchar*   maskArea = mask->GreenArea ();
  uchar**  maskRows = mask->Green ();

  memset (maskArea, 0, totPixels);

  kkint32 c, r, x;

  for  (x = 0;  x < totPixels;  ++x)
  {
    if  (srcArea[x] > backgroundPixelTH)
      maskArea[x] = 255;
  }

  {
    // Check Top and Bottom Mask Rows for background pixels and flag them as having access to the border.
    uchar*  rowTop = maskRows[0];
    uchar*  rowBot = maskRows[height - 1];

    for  (c = 0;  c < width;  ++c)
    {
      if  (rowTop[c] == 0)
        rowTop[c] = 1;
      if  (rowBot[c] == 0)
        rowBot[c] = 1;
    }
  }

  {
    // Check Left and Right columns for background pixels and flag them as having access to the border.
    uchar*  leftCol  = maskArea;
    uchar*  rightCol = maskArea + (width - 1);
    for  (r = 0;  r < height;  ++r)
    {
      if  (*leftCol == 0)
        *leftCol = 1;
      if  (*rightCol == 0)
        *rightCol = 1;

      leftCol  += width;
      rightCol += width;
    }
  }


  // We will not iteratively scan the Mask image for pixels that have access top the edge of the image.
  // We will repeat the following loop until no pixels get flagged.
  bool  fillInFound = false;
  do
  {
    fillInFound = false;

    // Scan from TopLeft  to  BotRight
    uchar*  rowPrev  = maskArea;
    uchar*  rowCur   = rowPrev + width;
    uchar*  rowNext  = rowCur  + width;

    for  (r = 1;  r < (height - 1);  ++r)
    {
      for  (c = 1;  c < (width - 1);  ++c)
      {
        if  (rowCur[c] == 0)
        {
          if  ((rowPrev[c    ] == 1)  ||  
               (rowCur [c - 1] == 1)  ||
               (rowCur [c + 1] == 1)  ||
               (rowNext[c    ] == 1)
              )
          {
            rowCur[c] = 1;
            fillInFound = true;
          }
        }
      }

      rowPrev += width;
      rowCur  += width;
      rowNext += width;
    }


    // Scan from Bot-Right  to  Top-Left
    rowPrev  = maskRows[height - 1];
    rowCur   = rowPrev - width;
    rowNext  = rowCur  - width;

    for  (r = (height - 2);  r > 0;  --r)
    {
      for  (c = (width - 2);  c > 0;  --c)
      {
        if  (rowCur[c] == 0)
        {
          if  ((rowPrev[c    ] == 1)  ||  
               (rowCur [c - 1] == 1)  ||
               (rowCur [c + 1] == 1)  ||
               (rowNext[c    ] == 1)
              )
          {
            rowCur[c] = 1;
            fillInFound = true;
          }
        }
      }

      rowPrev -= width;
      rowCur  -= width;
      rowNext -= width;
    }
  }  while  (fillInFound);


  // At this point the only pixels in the mask image that contain a '0' are the ones that are in holes.
  // We will now fill the corresponding pixel locations in the original image with the ForegroundPixelValue.
  for  (x = 0;  x < totPixels;  ++x)
  {
    if  (maskArea[x] == 0)
    {
      srcArea[x] = foregroundPixelValue;
      ++foregroundPixelCount;
    }
  }
}  /* FillHole */

void Raster::FillRectangle	(	kkint32	tlRow,
		kkint32	tlCol,
		kkint32	brRow,
		kkint32	brCol,
		const PixelValue &	fillColor
	)

Definition at line 1947 of file Raster.cpp.

References KKB::PixelValue::b, blue, color, KKB::PixelValue::g, green, KKB::PixelValue::r, and red.

Referenced by DrawGrid().

{
  tlRow = Min (tlRow, height - 1);
  brRow = Min (brRow, height - 1);

  tlCol = Min (tlCol, width - 1);
  brCol = Min (brCol, width - 1);

  for  (kkint32 row = tlRow;  row <= brRow;  ++row)
  {
    if  (color)
    {
      uchar*  rowRed   = red   [row];
      uchar*  rowGreen = green [row];
      uchar*  rowBlue  = blue  [row];
      for  (kkint32 col = tlCol;  col <= brCol;  ++col)
      {
        rowRed  [col] = fillColor.r;
        rowGreen[col] = fillColor.g;
        rowBlue [col] = fillColor.b;
      }
    }
    else
    {
      uchar*  rowGreen = green[row];
      for  (kkint32 col = tlCol;  col <= brCol;  ++col)
        rowGreen[col] = fillColor.g;
    }
  }
}  /* FillRectangle */

void Raster::FinalCleanUp ( )

staticprotected

Definition at line 93 of file Raster.cpp.

References KKB::GoalKeeper::Destroy(), and goalKeeper.

{
  GoalKeeper::Destroy (goalKeeper);
  goalKeeper = NULL;
}

void Raster::FindBoundingBox	(	kkint32 &	tlRow,
		kkint32 &	tlCol,
		kkint32 &	brRow,
		kkint32 &	brCol
	)		const

Definition at line 5823 of file Raster.cpp.

References green, height, and width.

Referenced by DeriveImageLength(), ThinContour(), and TightlyBounded().

{
  tlRow = INT_MAX;
  tlCol = INT_MAX;

  brRow = INT_MIN;
  brCol = INT_MIN;

  kkint32  col = 0;
  kkint32  row = 0;

  bool  firstPixelFound = false;

  // lets 1st find the very 1st Pixel Used.
  while  (row < height) 
  {
    while  (col < width)
    {
      if  (ForegroundPixel (green[row][col]))
      {
        tlRow = row;
        tlCol = col;
        brRow = row;
        brCol = col;
        firstPixelFound = true;
        break;
      }

      col++;
    }

    if  (firstPixelFound)
      break;
 
    row++; col = 0;
  }


  if  (!firstPixelFound)
  {
    // We have a Blank Image.
    tlRow = tlCol = brRow = brCol = -1;
    return;
  }

  while  (row < height)
  {
    // Lets find 1st Pixel used in Row.
    while  ((col < width)  &&  (BackgroundPixel (green[row][col])))
    {
      col++;
    }
 
    if  (col < width)
    {
      // We have some Data on this row.

      brRow = row;

      if  (col < tlCol)
        tlCol = col;

      kkint32  lastColUsed = 0;

      while  (col < width)
      {
        if  (ForegroundPixel (green[row][col]))
        {
          lastColUsed = col;
        }

        col++;
      }

      if  (lastColUsed > brCol)
        brCol = lastColUsed;
    }

    row++;  col = 0;
  }

  return;

}  /* FindBoundingBox */  

RasterPtr Raster::FindMagnitudeDifferences

(

const Raster &

r

)

Returns an image that reflects the differences between this image and the image supplied in the parameter.

Each pixel will represent the magnitude of the difference between the two raster instances for that pixel location. If there are no differences than a raster of all 0's will be returned. If dimensions are different then the largest dimensions will be sued.

Parameters

[in]

r

Raster to compare with.

Returns

A raster that will reflect the differences between the two instances where each pixel will represent the magnitude of the differences.

Definition at line 5924 of file Raster.cpp.

References Blue(), blue, color, Green(), green, Raster(), Red(), and red.

{
  kkint32  resultHeight = Max (height, r.Height ());
  kkint32  resultWidth  = Max (width,  r.Width  ());

  RasterPtr  result = new Raster (resultHeight, resultWidth, color);

  uchar**  otherRed   = r.Red   ();
  uchar**  otherGreen = r.Green ();
  uchar**  otherBlue  = r.Blue  ();

  uchar**  resultRed   = result->Red   ();
  uchar**  resultGreen = result->Green ();
  uchar**  resultBlue  = result->Blue  ();

  kkint32  minHeight = Min (height, r.Height ());
  kkint32  minWidth  = Min (width,  r.Width  ());

  kkint32  resultTotPixels = resultHeight * resultWidth;

  memset (result->GreenArea (), 255, resultTotPixels);
  if  (color)
  {
    memset (result->RedArea  (), 255, resultTotPixels);
    memset (result->BlueArea (), 255, resultTotPixels);
  }

  for  (kkint32  r = 0;  r < minHeight;  ++r)
  {
    for  (kkint32  c = 0;  c < minWidth;  ++c)
    {
      // resultGreen[r][c] = DeltaMagnitude (green[r][c], otherGreen[r][c]);
      int  deltaC = DeltaMagnitude (green[r][c], otherGreen[r][c]);
      if  (deltaC > 0)
        deltaC = Min (255, deltaC + 64);
      resultGreen[r][c] = deltaC;
      
      if  (color)
      {
        resultRed [r][c] = DeltaMagnitude (red [r][c], otherRed [r][c]);
        resultBlue[r][c] = DeltaMagnitude (blue[r][c], otherBlue[r][c]);
      }
    }
  }

  return  result;
}  /* FindMagnitudeDifferences */

void Raster::FollowContour

(

float

countourFreq[5]

)

const

Definition at line 5357 of file Raster.cpp.

References KKB::MovDir::col, green, height, movements, KKB::MovDir::row, and width.

{
  // startRow and startCol is assumed to come from the left (6)

  kkint32  startRow = 0;
  kkint32  startCol = 0;

  kkint32  lastDir = 1; // Last Movement was Up-Right

  kkint32  nextRow = 0;
  kkint32  nextCol = 0;

  kkint32  fromDir = 0;

  kkint32  edgeLen = 0;

  kkint32  maxNumOfAngles = 2 * height * width;
  kkint32  numOfAngles = 0;


  kkint32  x;
  kkint32  count[5];

  for  (x = 0; x < 5; x++)
  {
    countourFreq[x] = 0.0;
    count[x] = 0;
  }





  #if defined(FFTW_AVAILABLE)
    fftw_complex*  src = (fftw_complex*)fftw_malloc (sizeof (fftw_complex) * maxNumOfAngles);
  #else
    KK_DFT1D_Float::DftComplexType*  src = new KK_DFT1D_Float::DftComplexType[maxNumOfAngles];
  #endif

  startRow = height / 2;
  startCol = 0;

  while  ((startCol < width)  &&  (BackgroundPixel (green[startRow][startCol])))
  {
    startCol++;
  }

  // if  (green[startRow][startCol] == 0)
  if  (startCol >= width)
  {
    // We did not find a Pixel in the Middle Row(height / 2) so now we will
    // scan the image row, by row, Left to Right until we find an occupied 
    // pixel.

    bool  found = false;
    kkint32  row;
    kkint32  col;

    for  (row = 0; ((row < height)  &&  (!found));  row++)
    {
      for  (col = 0; ((col < width)  &&  (!found)); col++)
      {
        if  (ForegroundPixel (green[row][col]))
        {
          found = true;
          startRow = row;
          startCol = col;
        }
      }
    }

    if  (!found)
    {
      return;
    }
  }

  kkint32  curRow = startRow;
  kkint32  curCol = startCol;

  bool  nextPixelFound = false;

  kkint32  nextDir;

  do  
  {
    edgeLen++;

    fromDir = lastDir + 4;
    if  (fromDir > 7)
      fromDir = fromDir - 8;

    nextPixelFound = false;

    nextDir = fromDir + 2;
    while  (!nextPixelFound)
    {
      if  (nextDir > 7)
        nextDir = nextDir - 8;

      nextRow = curRow + movements[nextDir].row;
      nextCol = curCol + movements[nextDir].col;

      if  ((nextRow <  0)       ||  
           (nextRow >= height)  ||
           (nextCol <  0)       ||
           (nextCol >= width) 
          )
      {
        nextDir++;
      }
      else if  (ForegroundPixel (green[nextRow][nextCol]))
      {
        nextPixelFound = true;
      }
      else
      {
        nextDir++;
      }
    }

    if  (numOfAngles >= maxNumOfAngles)
    {
      kkint32  newMaxNumOfAngles = maxNumOfAngles * 2;

      #if  defined(FFTW_AVAILABLE)
        fftw_complex*  newSrc = (fftw_complex*)fftw_malloc (sizeof (fftw_complex) * newMaxNumOfAngles);
      #else
        KK_DFT1D_Float::DftComplexType*  newSrc = new KK_DFT1D_Float::DftComplexType[newMaxNumOfAngles];
      #endif

      kkint32  x;
      for  (x = 0; x < maxNumOfAngles; x++)
      {
        #if  defined(FFTW_AVAILABLE)
          newSrc[x][0] = src[x][0];
          newSrc[x][1] = src[x][1];
        #else
          newSrc[x].real (src[x].real ());
          newSrc[x].imag (src[x].imag ());
        #endif
      }
        
      #ifdef  FFTW3_H
        fftw_free (src);
      #else
        delete src;
      #endif

      src = newSrc;
      maxNumOfAngles = newMaxNumOfAngles;
    }
  
    #if  defined(FFTW_AVAILABLE)
      src[numOfAngles][0] = nextRow; 
      src[numOfAngles][1] = nextCol;
    #else
      src[x].real ((float)nextRow);
      src[x].imag ((float)nextCol);
    #endif


    // sqrt ((float)(nextRow * nextRow + nextCol * nextCol));
    numOfAngles++;
 
    lastDir = nextDir;
    curRow = nextRow;
    curCol = nextCol;
  }  while  ((curRow != startRow)  ||  (curCol != startCol));


  #if  defined(FFTW_AVAILABLE)
    fftw_complex*   dest = (fftw_complex*)fftw_malloc (sizeof (fftw_complex) * maxNumOfAngles);
    fftw_plan       plan;
    plan = fftw_plan_dft_1d (numOfAngles, src, dest, FFTW_FORWARD, FFTW_ESTIMATE);
    fftw_execute (plan);
    fftw_destroy_plan(plan);  
  #else
    KK_DFT1D_Float  plan(numOfAngles, true);
    KK_DFT1D_Float::DftComplexType*  dest = new KK_DFT1D_Float::DftComplexType[maxNumOfAngles];
    plan.Transform(src, dest);
  #endif


  float  middle = (float)(numOfAngles / 2.0);
  float  r1 = (float)(middle / 2.0);
  float  r2 = (float)(middle * ( 3.0  /   4.0));
  float  r3 = (float)(middle * ( 7.0  /   8.0));
  float  r4 = (float)(middle * (15.0  /  16.0));

  float  deltaX;
  float  mag;

  for  (x = 0; x < numOfAngles; x++)
  {
    #if  defined(FFTW_AVAILABLE)
      mag = (float)log (sqrt (dest[x][0] * dest[x][0] + dest[x][1] * dest[x][1]));
    #else
      mag = (float)log (sqrt (dest[x].real () * dest[x].real () + dest[x].imag () * dest[x].imag ()));
    #endif

    deltaX = (float)fabs ((float)x - middle);

    if  (deltaX < r1)
    {
      countourFreq[0] = countourFreq[0] + mag;
      count[0]++;
    }

    else if  (deltaX < r2)
    {
      countourFreq[1] = countourFreq[1] + mag;
      count[1]++;
    }

    else if  (deltaX < r3)
    {
      countourFreq[2] = countourFreq[2] + mag;
      count[2]++;
    }

    else if  (deltaX < r4)
    {
      countourFreq[3] = countourFreq[3] + mag;
      count[3]++;
    }

    else
    {
      countourFreq[4] = countourFreq[4] + mag;
      count[4]++;
    }
  }


  for  (x = 0; x < 5; x++)
    countourFreq[x] = countourFreq[x] / (float)count[x];

  #if  defined(FFTW_AVAILABLE)
    fftw_free (src);
    fftw_free (dest);
  #else
    delete[]  src;
    delete[]  dest;
  #endif
}  /* FollowContour */

bool Raster::ForegroundPixel	(	kkint32	row,
		kkint32	col
	)		const

Definition at line 1054 of file Raster.cpp.

References green.

Referenced by AreThereEdgePixels().

{
  return (ForegroundPixel (green[row][col]));
}  /* ForegroundPixel */

kkint32 KKB::Raster::ForegroundPixelCount ( ) const

inline

Definition at line 317 of file Raster.h.

References foregroundPixelCount.

Referenced by KKMLL::GrayScaleImagesFVProducer::ComputeFeatureVector(), Dilation(), Erosion(), KKB::MorphOpDilation::PerformOperation(), and Raster().

{return foregroundPixelCount;}

void KKB::Raster::ForegroundPixelCount ( kkint32  _foregroundPixelCount )

inline

Definition at line 344 of file Raster.h.

References foregroundPixelCount.

Referenced by KKB::MorphOpBinarize::PerformOperation(), KKB::MorphOpDilation::PerformOperation(), KKB::MorphOpErosion::PerformOperation(), and ReduceByEvenMultiple().

{foregroundPixelCount = _foregroundPixelCount;}

uchar KKB::Raster::ForegroundPixelValue ( ) const

inline

Definition at line 337 of file Raster.h.

References foregroundPixelValue.

Referenced by ExtractUsingMask(), KKB::MorphOpStretcher::PerformOperation(), and ToColor().

{return foregroundPixelValue;}

void KKB::Raster::ForegroundPixelValue ( uchar  _foregroundPixelValue )

inline

Definition at line 345 of file Raster.h.

References foregroundPixelValue.

Referenced by ExtractUsingMask(), KKB::MorphOpStretcher::PerformOperation(), and SegmentImage().

{foregroundPixelValue = _foregroundPixelValue;}

void Raster::FourierExtractFeatures

(

float

fourierFeatures[5]

)

const

Definition at line 5216 of file Raster.cpp.

References fourierMag, fourierMagArea, height, KKB::osWaitForEnter(), and width.

{
  if  (!fourierMagArea)
  {
     cerr << std::endl
          << "*** ERROR ***    This Raster image is not the result of a fast Fourier" << std::endl
          << std::endl;
     osWaitForEnter ();
     exit (-1);
  }

  float  cr = height / (float)2.0;
  float  cw = width  / (float)2.0;

  float  crSqr = cr * cr;
  float  cwSqr = cw * cw;

  //float  diagLen = crSqr + cwSqr;
  float  r1Len = crSqr / (float)4.0 + cwSqr / (float)4.0;

  float  r2Len = (float)((9.0   /  16.0) * crSqr + (9.0   /  16.0) * cwSqr);  //  3/ 4 ths Len

  float  r3Len = (float)((81.0  / 100.0) * crSqr + (81.0  / 100.0) * cwSqr);  //  9/10 ths Len

  float  r4Len = (float)((361.0 / 400.0) * crSqr + (361.0 / 400.0) * cwSqr);  // 19/20 ths Len

  fourierFeatures[0] = (float)0.0;
  fourierFeatures[1] = (float)0.0;
  fourierFeatures[2] = (float)0.0;
  fourierFeatures[3] = (float)0.0;
  fourierFeatures[4] = (float)0.0;

  kkint32  count[5];

  count[0] = 0;
  count[1] = 0;
  count[2] = 0;
  count[3] = 0;
  count[4] = 0;

  kkint32  row;
  kkint32  col;

  float  deltaRow;
  float  deltaRowSqr = (float)0.0;

  float  deltaCol;
  float  deltaColSqr = (float)0.0;

  float  distFromCent;

  for  (row = 0 ; row < height; row++)
  {
    deltaRow = cr - (float)row;
    deltaRowSqr = deltaRow * deltaRow;

    for  (col = 0; col < (kkint32)cw; col++)
    {
      deltaCol = cw - (float)col;
      deltaColSqr = deltaCol * deltaCol;
      
      distFromCent = deltaRowSqr + deltaColSqr;

      if  (distFromCent < r1Len)
      {
        fourierFeatures[0] = fourierFeatures[0] + fourierMag[row][col];
        count[0]++;
      }

      else if  (distFromCent < r2Len)
      {
        fourierFeatures[1] = fourierFeatures[1] + fourierMag[row][col];
        count[1]++;
      }
   
      else if  (distFromCent < r3Len)
      {
        fourierFeatures[2] = fourierFeatures[2] + fourierMag[row][col];
        count[2]++;
      }
   
      else if  (distFromCent < r4Len)
      {
        fourierFeatures[3] = fourierFeatures[3] + fourierMag[row][col];
        count[3]++;
      }
      else
      {
        fourierFeatures[4] = fourierFeatures[4] + fourierMag[row][col];
        count[4]++;
      }
    }
  }

  kkint32  x;

  for  (x = 0; x < 5; x++)
  {
    fourierFeatures[x] = fourierFeatures[x] / count[x];
  }
}  /* ExtractFourierFeatures */

float* KKB::Raster::FourierMagArea ( ) const

inline

Definition at line 333 of file Raster.h.

References fourierMagArea.

{return fourierMagArea;}

RasterPtr Raster::FromCompressor ( const uchar *  compressedBuff, kkuint32  compressedBuffLen  )

static

Creates a new instance of Raster object from zLib compressed data.

Performs the inverse operation of Raster::ToCompressor.

Parameters

[in]	compressedBuff	Pointer to buffer area containing compressed data originally created by 'ToCompressor'.
[in]	compressedBuffLen	Length in bytes of 'compressedBuff'.

Returns

If successful a pointer to a new instance of 'Raster'; if there is an error will return NULL.

See also

ToCompressor

Definition at line 9228 of file Raster.cpp.

References BlueArea(), KKB::Compressor::Decompress(), GreenArea(), Raster(), and RedArea().

{
  kkuint32  unCompressedBuffLen = 0;
  uchar*  unCompressedBuff = (uchar*)Compressor::Decompress (compressedBuff, compressedBuffLen, unCompressedBuffLen);
  if  (!unCompressedBuff)
    return NULL;

  if  (unCompressedBuffLen < 10)
  {
    cerr << std::endl << std::endl << "Raster::FromCompressor  Compressor did not return any data."  << std::endl;
    return NULL;
  }

  // 0 - 3:    Height:  high order to low order
  // 4 - 7:    Width:   high order to low order
  // 8 - 8:    Color    0 = Gray--                                     scale,  1 = Color
  // 9 - 8 + (Height * Width) Green Channel
  // xxxxx                    Red  Channel
  // xxxxx                    Blue Channel

  kkuint32  height = 0;
  kkuint32  width  = 0;
  height = unCompressedBuff[0] + unCompressedBuff[1] * 256 + unCompressedBuff[2] * 256 * 256 + unCompressedBuff[3] * 256 * 256 * 256;
  width  = unCompressedBuff[4] + unCompressedBuff[5] * 256 + unCompressedBuff[6] * 256 * 256 + unCompressedBuff[7] * 256 * 256 * 256;

  bool color = (unCompressedBuff[8] == 1);

  kkuint32  totalPixels = height * width;
  if  ((totalPixels > (100 * 1024 * 1024))  ||  (height < 1)  ||  (width < 1))
  {
    cerr << std::endl << std::endl << "Raster::FromCompressor  Height[" << height << "]  Width[" << width << "]  is not valid." << std::endl << std::endl;
    delete  unCompressedBuff;
    unCompressedBuff = NULL;
    return NULL;
  }

  kkuint32  totalDataNeeded = totalPixels + (color ? (2 * totalPixels) : 0) + 9;
  if  (totalDataNeeded > unCompressedBuffLen)
  {
    cerr << std::endl << std::endl 
         << "Raster::FromCompressor  Height[" << height << "]  Width[" << width << "]  Color[" << (color ? "Yes" : "No") << "]" << std::endl
         << "              requires TotalDataNeeded[" << totalDataNeeded << "]  but UnCompressedBuffLen[" << unCompressedBuffLen << "]" << std::endl
         << std::endl;
    delete  unCompressedBuff;
    unCompressedBuff = NULL;
    return NULL;
  }


  RasterPtr  r = new Raster ((kkint32)height, (kkint32)width, color);

  kkuint32 nextIdx = 9;
  kkuint32 x;

  uchar*  greenArea = r->GreenArea ();
  for  (x = 0;  x < totalPixels;  x++, nextIdx++)
    greenArea[x] = unCompressedBuff[nextIdx];

  if  (color)
  {
    uchar*  redArea = r->RedArea ();
    for  (x = 0;  x < totalPixels;  x++, nextIdx++)
      redArea[x] = unCompressedBuff[nextIdx];

    uchar*  blueArea = r->BlueArea ();
    for  (x = 0;  x < totalPixels;  x++, nextIdx++)
      blueArea[x] = unCompressedBuff[nextIdx];
  }
 
  delete  unCompressedBuff;
  unCompressedBuff = NULL;

  return  r;
}  /* FromCompressor */

RasterPtr Raster::FromSimpleCompression ( const uchar *  compressedBuff, kkuint32  compressedBuffLen  )

static

Creates a raster from a compressedBuff created by 'SimpleCompression'.

Definition at line 9035 of file Raster.cpp.

References KKB::SimpleCompressor::Decompress(), GreenArea(), and Raster().

{
  // I expect simple run length compressed data to be passed in.  The data was  originally 
  // compressed by SimpleCompressor and we will use the same class to decompress.

  // The format of the uncompressed data is very simple.
  //  Bytes    Description
  //  0 thru 1:    Height   2 byte integer.
  //  2 thru 3:    Width    2 byte integer.
  //
  //  4 thru (Hight * Width) - 1:   Raster Data
  //          Row 0          : (consists of 'Width' bytes.)
  //          Row 1          : (    ""    ""    ""   ""   )
  //                   --     ---     ---     ----   
  //          Row Height - 1 : (Last row of image) 
  //
  //          Each byte in the raster represents one pixel 0 - 255 gray-scale;  where 0=background.

  kkuint32  unCompressedSize = 0;

  if  (compressedBuff == NULL)
  {
    ofstream f ("c:\\Temp\\Raster_FromSimpleCompression.txt", ios_base::app);

    f << std::endl
      << "DateTime"                 << "\t"  <<  osGetLocalDateTime () << "\t"
      << "(compressedBuff==NULL)"
      << std::endl;

    f.flush ();
    f.close ();
    return new Raster (20, 20, false);
  }

  uchar*  uncompressedBuff = SimpleCompressor::Decompress (compressedBuff, compressedBuffLen, unCompressedSize);
  if  (uncompressedBuff == NULL)
  {
    ofstream f ("c:\\Temp\\Raster_FromSimpleCompression.txt", ios_base::app);

    f << std::endl
      << "DateTime"                 << "\t"  <<  osGetLocalDateTime () << "\t"
      << "(uncompressedBuff==NULL)" << "\t" 
      << "unCompressedSize"         << "\t" << unCompressedSize
      << std::endl;
      f.flush ();
      f.close ();
    return new Raster (20, 20, false);
  }

  // The first Four Bytes have the image Height, and Width.

  kkint32  height = uncompressedBuff[0] * 256 +  uncompressedBuff[1];
  kkint32  width  = uncompressedBuff[2] * 256 +  uncompressedBuff[3];

  if  ((height < 1)  ||  (height > 1000)  ||  (width < 1)  ||  (width > 1000))
  {
    ofstream f ("c:\\Temp\\Raster_FromSimpleCompression.txt", ios_base::app);

    f << std::endl
      << "DateTime"         << "\t"  << osGetLocalDateTime () << "\t"
      << "unCompressedSize" << "\t"  << unCompressedSize      << "\t"
      << "Height"           << "\t"  << height                << "\t" 
      << "Width"            << "\t"  << width
      << std::endl;

    f <<  (kkint32)compressedBuff [0] << "\t"
      <<  (kkint32)compressedBuff [1] << "\t"
      <<  (kkint32)compressedBuff [2] << "\t"
      <<  (kkint32)compressedBuff [3] << "\t"
      <<  (kkint32)compressedBuff [4] << "\t"
      <<  (kkint32)compressedBuff [5] << "\t"
      <<  (kkint32)compressedBuff [6] << "\t"
      <<  (kkint32)compressedBuff [7] << "\t"
      <<  (kkint32)compressedBuff [8] << "\t"
      <<  (kkint32)compressedBuff [9] << "\t"
      <<  (kkint32)compressedBuff[10] 
      << std::endl;

      f.flush ();
      f.close ();
    return new Raster (20, 20, false);
  }

  kkuint32  totalPixels = height * width;
  if  (unCompressedSize > (totalPixels + 4))
  {
    ofstream f ("c:\\Temp\\Raster_FromSimpleCompression.txt", ios_base::app);

    f << std::endl
      << "DateTime"         << "\t"  << osGetLocalDateTime () << "\t"
      << "unCompressedSize" << "\t"  << unCompressedSize      << "\t"
      << "totalPixels"      << "\t"  << totalPixels           << "\t"
      << "Height"           << "\t"  << height                << "\t" 
      << "Width"            << "\t"  << width
      << std::endl;

    f <<  (kkint32)compressedBuff [0] << "\t"
      <<  (kkint32)compressedBuff [1] << "\t"
      <<  (kkint32)compressedBuff [2] << "\t"
      <<  (kkint32)compressedBuff [3] << "\t"
      <<  (kkint32)compressedBuff [4] << "\t"
      <<  (kkint32)compressedBuff [5] << "\t"
      <<  (kkint32)compressedBuff [6] << "\t"
      <<  (kkint32)compressedBuff [7] << "\t"
      <<  (kkint32)compressedBuff [8] << "\t"
      <<  (kkint32)compressedBuff [9] << "\t"
      <<  (kkint32)compressedBuff[10] 
      << std::endl;

    f.flush ();
    f.close ();
  }


  RasterPtr  result = new Raster (height, width, false);
  uchar* greenArea = result->GreenArea ();

  kkuint32  nextIdx = 4;
  kkuint32  greanAreaIdx = 0;

  while  ((nextIdx < (kkuint32)unCompressedSize)  &&  (greanAreaIdx < totalPixels))
  {
    greenArea[greanAreaIdx] = uncompressedBuff[nextIdx];
    nextIdx++;
    greanAreaIdx++;
  }

  delete  uncompressedBuff;
  uncompressedBuff = NULL;

  return  result;
}  /* FromSimpleCompression */

uchar Raster::GetPixelValue	(	kkint32	row,
		kkint32	col
	)		const

Definition at line 1289 of file Raster.cpp.

References green, height, and width.

Referenced by Padded(), Rotate(), and SegmentImage().

{
  if  ((row <  0)      ||  
       (row >= height) ||
       (col <  0)      ||
       (col >= width))
  {
    cerr << "Raster::GetPixelValue   *** ERROR ***,  Raster Dimensions Exceeded."       << std::endl;
    cerr << "                        Height[" << height << "]  Width[" << width << "]." << std::endl;
    cerr << "                        Row["    << row    << "]  Col["   << col   << "]." << std::endl;
    exit (-1);
  }

  return  green[row][col];
}  /* GetPixelValue */

void Raster::GetPixelValue	(	kkint32	row,
		kkint32	col,
		uchar &	r,
		uchar &	g,
		uchar &	b
	)		const

Definition at line 1308 of file Raster.cpp.

References blue, color, green, height, red, and width.

Referenced by GetPixelValue().

{
  if  ((row <  0)      ||  
       (row >= height) ||
       (col <  0)      ||
       (col >= width))
  {
    cerr << "Raster::GetPixelValue   *** ERROR ***,  Raster Dimensions Exceeded."       << std::endl;
    cerr << "                        Height[" << height << "]  Width[" << width << "]." << std::endl;
    cerr << "                        Row["    << row    << "]  Col["   << col   << "]." << std::endl;
    exit (-1);
  }

  g = green [row][col];

  if  (color)
  {
    r = red   [row][col];
    b = blue  [row][col];
  }
  else
  {
    r = 0;
    b = 0;
  }
}  /* GetPixelValue */

void Raster::GetPixelValue	(	kkint32	row,
		kkint32	col,
		PixelValue &	p
	)		const

Definition at line 1343 of file Raster.cpp.

References KKB::PixelValue::b, KKB::PixelValue::g, GetPixelValue(), and KKB::PixelValue::r.

Referenced by CreateFromOrginalImageWithSpecifidBlobsOnly(), and ThresholdInHSI().

{
  GetPixelValue (row, col, p.r, p.g, p.b);
}  /* GetPixelValue */

uchar Raster::GetPixelValue	(	ColorChannels	channel,
		kkint32	row,
		kkint32	col
	)		const

Definition at line 1356 of file Raster.cpp.

References blue, color, KKB::Green, green, height, KKB::Red, red, and width.

{
  if  ((row <  0)      ||  
       (row >= height) ||
       (col <  0)      ||
       (col >= width))
  {
    cerr << "Raster::GetPixelValue   *** ERROR ***,  Raster Dimensions Exceeded."       << std::endl;
    cerr << "                        Height[" << height << "]  Width[" << width << "]." << std::endl;
    cerr << "                        Row["    << row    << "]  Col["   << col   << "]." << std::endl;
    exit (-1);
  }

  if  (channel == ColorChannels::Green)
    return  green [row][col];

  if  (!color)
  {
    cerr << "***ERROR*** Raster::GetPixelValue   *** ERROR ***,  Not a Color Raster."  << std::endl;
    exit (-1);
  }

  if  (channel == ColorChannels::Red)
    return red [row][col];
  else
    return blue[row][col];
}  /* GetPixelValue */

uchar ** Raster::GetSubSet	(	uchar **	_src,
		kkint32	_row,
		kkint32	_col,
		kkint32	_height,
		kkint32	_width
	)		const

Returns back a two dimension array that is a copy of the specified region in the image.

The caller will take ownership of the two dimensional array created.

Definition at line 4703 of file Raster.cpp.

References height, and width.

Referenced by Raster().

{
  kkint32  endR = _row + _height - 1;
  kkint32  endC = _col + _width - 1;

  if  ((_row < 0)  ||  (endR >= height) ||
       (_col < 0)  ||  (endC >= width))
  {
    cerr << "***ERROR***, Raster::Raster  *** ERROR ***,  Index's Exceed Raster Bounds" << std::endl;
    cerr << "       Raster Dimensions["       << width    << ", "  << height << "]."     << std::endl;
    cerr << "       Requested Coordinates [" << _row     << ", "  << _col      << "], "
         << "       Height["  << _height << "],  Width[" << _width << "]."
         << std::endl;
    //WaitForEnter ();
    exit (-1);
  }

  kkint32  row = 0;
  kkint32  col = 0;

  kkint32  totalPixelArea = _height * _width;
  uchar* subSetArea = new uchar[totalPixelArea];

  uchar** subSet = new uchar*[_height];
  
  for  (row = 0; row < _height; row++)
  {
    subSet[row] = subSetArea;
    for  (col = 0; col < _width; col++)
    {
      subSet[row][col] = _src[_row + row][_col + col];
    }
    subSetArea = subSetArea + _width;
  }

  return  subSet;
}  /* GetSubSet */

uchar** KKB::Raster::Green ( ) const

inline

returns a pointer to two dimensional array for 'Green' color channel; note this is the same as 'Rows'.

Definition at line 327 of file Raster.h.

References green.

Referenced by CreateErodedImage(), CreateSmoothedMediumImage(), CreateSmoothImage(), DeriveImageLength(), Dilation(), Edge(), Erosion(), ErosionBoundary(), ErosionChanged(), ErosionChanged1(), ExtractUsingMask(), FillHole(), FindMagnitudeDifferences(), KKB::MorphOpBinarize::PerformOperation(), KKB::MorphOpDilation::PerformOperation(), KKB::MorphOpErosion::PerformOperation(), KKB::MorphOpStretcher::PerformOperation(), Raster(), ReduceByEvenMultiple(), KKB::SaveImageInverted(), KKB::MorphOp::SetSrcRaster(), ThinContour(), TightlyBounded(), and Transpose().

uchar* KKB::Raster::GreenArea ( ) const

inline

Definition at line 330 of file Raster.h.

References greenArea.

Referenced by CalcAreaAndIntensityFeatures(), KKB::SegmentorOTSU::ClassAverageRGB(), CreateColorImageFromLabels(), CreateGrayScale(), CreateGrayScaleKLT(), CreateGrayScaleKLTOnMaskedArea(), KKB::RasterList::CreateSmoothedFrame(), Dilation(), Edge(), Erosion(), ExtractChannel(), FillHole(), FromCompressor(), FromSimpleCompression(), KKB::SegmentorOTSU::GetClassClosestToTargetColor(), KKB::MorphOpMaskExclude::PerformOperation(), ReduceByFactor(), KKB::SaveImagePGM(), KKB::SaveImagePNG(), KKB::SaveImagePPM(), KKB::SegmentorOTSU::SegmentImage(), KKB::SegmentorOTSU::SegmentMaskedImage(), KKB::MorphOp::SetSrcRaster(), and ToColor().

{return  greenArea;}

RasterPtr Raster::HalfSize

(

)

Definition at line 7326 of file Raster.cpp.

References AllocateARasterInstance(), KKB::Blue, blue, color, green, height, KKB::Red, red, SetPixelValue(), and width.

{
  kkint32  hHeight = kkint32 (height / 2);
  kkint32  hWidth  = kkint32 (width  / 2);

  RasterPtr  halfSize = AllocateARasterInstance (hHeight, hWidth, color);

  kkint32  row = 0;
  kkint32  col = 0;
  kkint32  hRow, hCol;
  for  (hRow = 0;  hRow < hHeight;  hRow++)
  {
    col = 0;
    for  (hCol = 0;  hCol < hWidth;  hCol++)
    {
      halfSize->SetPixelValue (hRow, hCol, green[row][col]);
      if  (color)
      {
        halfSize->SetPixelValue (ColorChannels::Red,  hRow, hCol, red [row][col]);
        halfSize->SetPixelValue (ColorChannels::Blue, hRow, hCol, blue[row][col]);
      }

      col += 2;
    }

    row += 2;
  }

  return  halfSize;
}  /* HalfSize */

kkint32 KKB::Raster::Height ( ) const

inline

Definition at line 319 of file Raster.h.

References height.

Referenced by KKB::BmpImage::BmpImage(), KKMLL::GrayScaleImagesFVProducer::ComputeFeatureVector(), KKB::ContourFollower::ContourFollower(), CreateGrayScaleKLT(), CreateGrayScaleKLTOnMaskedArea(), KKB::RasterList::CreateSmoothedFrame(), Dilation(), KKB::DisplayImage(), Edge(), Erosion(), FillBlob(), FillHole(), KKB::ConvexHull::Filter(), KKB::MorphOpBinarize::PerformOperation(), Raster(), Rotate(), KKB::SaveImageInverted(), KKB::SaveImagePGM(), KKB::SaveImagePNG(), KKB::SaveImagePPM(), KKB::SegmentorOTSU::SegmentImage(), SegmentImage(), KKB::SegmentorOTSU::SegmentMaskedImage(), KKB::MorphOp::SetSrcRaster(), and KKB::ConvexHull::Store().

{return  height;}

HistogramPtr Raster::Histogram

(

ColorChannels

channel

)

const

Definition at line 6110 of file Raster.cpp.

References KKB::Blue, blueArea, color, KKB::ColorChannelToKKStr(), KKB::KKStr::Concat(), KKB::Green, greenArea, KKB::Histogram::Histogram(), KKB::Histogram::Increment(), KKB::KKException::KKException(), KKB::KKStr::KKStr(), KKB::Red, redArea, and totPixels.

Referenced by HistogramImage().

{
  uchar*  data = NULL;
  if  (color)
  {
    switch  (channel)
    {
    case  ColorChannels::Red:   data = redArea;    break;
    case  ColorChannels::Green: data = greenArea;  break;
    case  ColorChannels::Blue:  data = blueArea;   break;
    }
  }

  if  (!data)
  {
    KKStr  errMsg (128);
    errMsg << "Raster::Histogram   ***ERROR***    channel: " << ColorChannelToKKStr (channel) << "  Is not defined.";
    cerr << endl << errMsg << endl << endl;
    throw KKException (errMsg);
  }

  HistogramPtr histogram = new KKB::Histogram (0, 256, 1.0, false);
  for  (kkint32 x = 0;  x < totPixels;  x++)
  {
    histogram->Increment (*data);
    ++data;
  }

  return  histogram;
}  /* Histogram */

RasterPtr Raster::HistogramEqualizedImage

(

)

const

Definition at line 6143 of file Raster.cpp.

References KKB::Histogram::Equalized(), HistogramEqualizedImage(), and HistogramGrayscale().

{
  HistogramPtr  grayScaleHistogram = HistogramGrayscale ();
  HistogramPtr  equalizedHistogram = grayScaleHistogram->Equalized ();
  delete  grayScaleHistogram;
  grayScaleHistogram = NULL;
  RasterPtr equalizedImage = HistogramEqualizedImage (equalizedHistogram);
  delete  equalizedHistogram;

  return  equalizedImage;
}  /* HistogramEqualizedImage */

RasterPtr Raster::HistogramEqualizedImage

(

HistogramPtr

equalizedHistogram

)

const

Definition at line 6159 of file Raster.cpp.

References AllocateARasterInstance(), KKB::Histogram::EqualizedMapTable(), green, height, KKB::Histogram::NumOfBuckets(), KKB::osWaitForEnter(), Rows(), and width.

Referenced by HistogramEqualizedImage().

{
  if  (equalizedHistogram->NumOfBuckets () != 256)
  {
    cerr << std::endl
         << "**** ERROR ****    Histogram Does not have 256 Buckets[" 
         << equalizedHistogram->NumOfBuckets () << "]"  << std::endl
         << std::endl;
    osWaitForEnter ();
    exit (-1);
  }


  kkint32*  equalizedMapTable = equalizedHistogram->EqualizedMapTable ();

  if  (!equalizedMapTable)
  {
    cerr << std::endl
         << "**** ERROR ****    Histogram Does not have EqualizeMapTable."  << std::endl
         << std::endl;
    osWaitForEnter ();
    exit (-1);
  }

  RasterPtr  equalizedImage = AllocateARasterInstance (height, width, false);

  uchar**  dest = equalizedImage->Rows ();

  kkint32  row, col;

  for  (row = 0;  row < height;  row++) 
  {
    for  (col = 0;  col < width;  col++)
    {
      dest[row][col] = (uchar)(equalizedMapTable[green[row][col]]);
    }
  }

  return  equalizedImage;
}  /* HistogramEqualizedImage */

HistogramPtr Raster::HistogramGrayscale

(

)

const

Definition at line 6091 of file Raster.cpp.

References green, height, KKB::Histogram::Histogram(), KKB::Histogram::Increment(), and width.

Referenced by HistogramEqualizedImage(), HistogramGrayscaleImage(), and SegmentImage().

{
  HistogramPtr histogram = new KKB::Histogram (0, 256, 1.0, false);

  kkint32  row, col;
 
  for  (row = 0;  row < height;  row++)
  {
    for  (col = 0;  col < width;  col++)
    {
      histogram->Increment (green[row][col]);
    }
  }

  return  histogram;
}  /* HistogramGrayscale */

RasterPtr Raster::HistogramGrayscaleImage

(

)

const

Definition at line 6203 of file Raster.cpp.

References color, KKB::Histogram::CreateGraph(), CreateGrayScale(), and HistogramGrayscale().

{
  HistogramPtr histogram = NULL;

  if  (color)
  {
    RasterPtr  gsImage = this->CreateGrayScale ();
    histogram = gsImage->HistogramGrayscale ();
    delete  gsImage;
    gsImage = NULL;
  }
  else
  {
    histogram = HistogramGrayscale ();
  }

  RasterPtr histogramImage = histogram->CreateGraph ();
  delete histogram;
  histogram = NULL;
  return  histogramImage;
}  /* HistogramGrayscaleImage */

RasterPtr Raster::HistogramImage

(

ColorChannels

channel

)

const

Definition at line 6227 of file Raster.cpp.

References KKB::Histogram::CreateGraph(), and Histogram().

{
  HistogramPtr histogram = Histogram (channel);
  RasterPtr histogramImage = histogram->CreateGraph ();
  delete histogram;
  histogram = NULL;
  return  histogramImage;
}  /* HistogramImage */

void Raster::Initialize	(	kkint32	_height,
		kkint32	_width,
		uchar *	_Data,
		uchar **	_Rows,
		bool	_takeOwnership
	)

Sets an existing instance to specific Raster Data of a image.

This instance of 'Raster' can take ownership of '_Data' and '_Rows' depending on '_takeOwnership'.

Parameters

[in]	_height	Image Height.
[in]	_width	Image Width.
[in]	_Data	The raster data that is to be used by this instance of 'Raster'; it should be continuous data, Row Major, of length (_height * _width).
[in]	_Rows	Two dimensional assessors to '_Data'; each entry will point to the respective row in '_Data' that contains that row.
[in]	_takeOwnership	Indicates whether this instance of 'Raster' will own the memory pointed to by '_Data' and '_Rows'; if set to true will delete them in the destructor.

Definition at line 917 of file Raster.cpp.

References color, green, greenArea, height, KKB::KKException::KKException(), totPixels, weOwnRasterData, and width.

{
  CleanUpMemory ();
  height = _height;
  width  = _width;
  totPixels = height * width;
  color = false;

  if  (_grayScaleData == NULL)
    throw KKException ("Raster::Initialize    _grayScaleData == NULL");

  if  (_grayScaleRows == NULL)
    throw KKException ("Raster::Initialize    _grayScaleRows == NULL");

  greenArea = _grayScaleData;
  green = _grayScaleRows;

  weOwnRasterData = _takeOwnership;
}

void Raster::Initialize	(	kkint32	_height,
		kkint32	_width,
		uchar *	_redArea,
		uchar **	_red,
		uchar *	_greenArea,
		uchar **	_green,
		uchar *	_blueArea,
		uchar **	_blue,
		bool	_takeOwnership
	)

Sets an existing instance to specific Raster Data of a image.

This instance of 'Raster' can take ownership of '_Data' and '_Rows' depending on '_takeOwnership'. The parameters '_redArea', '_greenArea', and '_blueArea' will point to raster data that represents their respective color channels. This data will be 'Row-Major' and of length '(_height * _width) bytes. For each color channel there will be a corresponding 2d accessors matrix '_red', '_green', and '_blue' where each entry in these 2d arrays will point to their respective rows in the color channel. The '_takeOwnership' parameters indicates whether this instance of 'Raster' will own these memory locations. '

Parameters

[in]	_height	Image Height.
[in]	_width	Image Width.
[in]	_redArea	The raster data representing the red channel.
[in]	_red	Two dimensional accessor to '_redArea'.
[in]	_greenArea	The raster data representing the green channel.
[in]	_green	Two dimensional accessor to '_greenArea'.
[in]	_blueArea	The raster data representing the blue channel.
[in]	_blue	Two dimensional accessor to '_blueArea'.
[in]	_takeOwnership	Indicates whether this instance of 'Raster' will own the supplied raster data.

Definition at line 944 of file Raster.cpp.

References blue, blueArea, color, green, greenArea, height, KKB::KKException::KKException(), red, redArea, totPixels, weOwnRasterData, and width.

{
  CleanUpMemory ();
  height = _height;
  width  = _width;
  color  = true;

  totPixels = height * width;

  if  ((_red   == NULL)  ||  (_redArea   == NULL)  ||
       (_green == NULL)  ||  (_greenArea == NULL)  ||
       (_blue  == NULL)  ||  (_blueArea  == NULL)
      )
    throw KKException ("Raster::Initialize    One or more of the Color channels == NULL");

  redArea   = _redArea;     red    = _red;
  greenArea = _greenArea;   green  = _green;
  blueArea  = _blueArea;    blue   = _blue;
 
  weOwnRasterData = _takeOwnership;
}

void Raster::Initialize ( )

staticprotected

Definition at line 79 of file Raster.cpp.

References KKB::GoalKeeper::Create(), KKB::GoalKeeper::EndBlock(), goalKeeper, rasterInitialized, and KKB::GoalKeeper::StartBlock().

{
  GoalKeeper::Create ("Raster", goalKeeper);

  goalKeeper->StartBlock ();
  if  (!rasterInitialized)
  {
    rasterInitialized = true;
    atexit (Raster::FinalCleanUp);
  }
  goalKeeper->EndBlock ();
}

uchar KKB::Raster::MaxPixVal ( ) const

inline

The maximum pixel value encountered in the image.

Definition at line 320 of file Raster.h.

References maxPixVal.

Referenced by Raster().

void KKB::Raster::MaxPixVal ( uchar  _maxPixVal )

inline

Definition at line 347 of file Raster.h.

References maxPixVal.

Referenced by ReduceByEvenMultiple().

{maxPixVal            = _maxPixVal;}

kkint32 Raster::MemoryConsumedEstimated

(

)

const

Definition at line 864 of file Raster.cpp.

References blobIds, color, fileName, fourierMagArea, height, KKB::KKStr::MemoryConsumedEstimated(), and totPixels.

Referenced by KKB::RasterBuffer::AddRaster().

{
  kkint32  blobIdsMem = 0;
  if  (blobIds)
    blobIdsMem = sizeof(kkint32) * totPixels + sizeof (kkint32*) * height;

  kkint32  fourierMem = 0;
  if  (fourierMagArea)
    fourierMem = sizeof (float) * totPixels + sizeof (float*) * height;

  kkint32  pixelMem = totPixels + sizeof (uchar*) * height;
  if  (color)
    pixelMem = pixelMem * 3;

  kkint32  memoryConsumedEstimated =
    sizeof (uchar)     * 4   +
    sizeof (float)     * 2   +
    sizeof (bool)      * 2   +
    sizeof (kkint32)   * 4   +
    sizeof (kkint32**) * 1   +
    sizeof (uchar*)    * 3   + 
    sizeof (uchar**)   * 3   +
    sizeof (float*)    * 1   +
    sizeof (float**)   * 1   +
    fileName.MemoryConsumedEstimated () +
    blobIdsMem                          +
    fourierMem                          +
    pixelMem;

  return  memoryConsumedEstimated;
}

void Raster::Opening

(

)

Definition at line 2944 of file Raster.cpp.

References Dilation(), and Erosion().

{
  Erosion ();
  Dilation ();
}  /* Opening */

void Raster::Opening

(

MaskTypes

mask

)

Definition at line 2952 of file Raster.cpp.

References Dilation(), and Erosion().

Referenced by KKB::MorphOpMaskExclude::PerformOperation().

{
  Erosion (mask);
  Dilation (mask);
}  /* Open */

RasterPtr Raster::Padded

(

kkint32

padding

)

Definition at line 9308 of file Raster.cpp.

References AllocateARasterInstance(), GetPixelValue(), height, SetPixelValue(), and width.

{
  kkint32  newHeight = height + padding * 2;
  kkint32  newWidth  = width  + padding * 2;

  kkint32  r, c;

  RasterPtr  paddedRaster = AllocateARasterInstance (newHeight, newWidth, false);

  for  (r = 0;  r < height;  r++)
  {
    for  (c = 0;  c < width; c++)
    {
      paddedRaster->SetPixelValue (r + padding, c + padding, this->GetPixelValue (r, c));
    }
  }

  return  paddedRaster;
}  /* Padded */

void Raster::PaintFatPoint	(	kkint32	row,
		kkint32	col,
		const PixelValue	pv,
		float	alpha
	)

Definition at line 6453 of file Raster.cpp.

References PaintPoint().

Referenced by DrawFatLine().

{
  PaintPoint (row - 2, col,     pv, alpha);

  PaintPoint (row - 1, col - 1, pv, alpha);
  PaintPoint (row - 1, col,     pv, alpha);
  PaintPoint (row - 1, col + 1, pv, alpha);

  PaintPoint (row,     col - 2, pv, alpha);
  PaintPoint (row,     col - 1, pv, alpha);
  PaintPoint (row,     col,     pv, alpha);
  PaintPoint (row,     col + 1, pv, alpha);
  PaintPoint (row,     col + 2, pv, alpha);

  PaintPoint (row + 1, col - 1, pv, alpha);
  PaintPoint (row + 1, col,     pv, alpha);
  PaintPoint (row + 1, col + 1, pv, alpha);

  PaintPoint (row + 2, col,     pv, alpha);
}

void Raster::PaintPoint	(	kkint32	row,
		kkint32	col,
		const PixelValue &	pv,
		float	alpha
	)

Definition at line 6432 of file Raster.cpp.

References color, height, and width.

Referenced by PaintFatPoint().

{
  if  ((row < 0)  ||  (row >= height)  ||  (col < 0)  ||  (col >= width))
    return;

  float beta = 1.0f - alpha;

  green[row][col] = Min (255, (int)(0.5f + alpha * (float)pv.g  + beta  * (float)green[row][col]));
  if  (color)
  {
    red [row][col] = Min (255, (int)(0.5f + alpha * (float)pv.r  + beta  * (float)red [row][col]));
    blue[row][col] = Min (255, (int)(0.5f + alpha * (float)pv.b  + beta  * (float)blue[row][col]));
  }
}

void Raster::PrintOutListOfAllocatedrasterInstances ( )

static

Definition at line 153 of file Raster.cpp.

{
  map<RasterPtr, RasterPtr>::iterator  idx;
  for  (idx = allocatedRasterInstances.begin ();  idx != allocatedRasterInstances.end ();  ++idx)
  {
    RasterPtr  r = idx->first;
    cout << r << "\t"
             << r->Height () << "\t"
             << r->Width  () << "\t"
             << r->FileName ()
             << std::endl;
  }
}  /* PrintOutListOfAllocatedrasterInstances */

uchar** KKB::Raster::Red ( ) const

inline

returns a pointer to two dimensional array for 'Red' color channel.

Definition at line 326 of file Raster.h.

References red.

Referenced by KKB::BmpImage::BmpImage(), CreateSmoothedMediumImage(), CreateSmoothImage(), ExtractUsingMask(), FindMagnitudeDifferences(), KKB::MorphOpStretcher::PerformOperation(), Raster(), KKB::SaveImageInverted(), KKB::MorphOp::SetSrcRaster(), TightlyBounded(), and Transpose().

uchar* KKB::Raster::RedArea ( ) const

inline

Definition at line 329 of file Raster.h.

References redArea.

Referenced by KKB::SegmentorOTSU::ClassAverageRGB(), CreateColorImageFromLabels(), KKB::RasterList::CreateSmoothedFrame(), ExtractChannel(), FromCompressor(), KKB::SegmentorOTSU::GetClassClosestToTargetColor(), KKB::MorphOpMaskExclude::PerformOperation(), KKB::ReadImagePPM(), ReduceByFactor(), KKB::SaveImagePNG(), KKB::SaveImagePPM(), KKB::MorphOp::SetSrcRaster(), and ToColor().

{return  redArea;}

RasterPtr Raster::ReduceByEvenMultiple

(

kkint32

multiple

)

const

Definition at line 7361 of file Raster.cpp.

References AllocateARasterInstance(), ForegroundPixelCount(), Green(), green, height, MaxPixVal(), and width.

{
  // We will pad one extra pixel top, bot, left, and right.
  // This is necessary because some feature calculations assume that there edge rows are empty.

  kkint32  nHeight = kkint32 (height / multiple) + 2;
  kkint32  nWidth  = kkint32 (width  / multiple) + 2; 

  kkint32  row = 0;
  kkint32  col = 0;
  kkint32  nRow, nCol;

  kkuint32**  workRaster  = new kkuint32*[nHeight];
  uchar**     workDivisor = new uchar*[nHeight];
  kkuint32*   workRow     = NULL;

  uchar*  workDivisorRow = NULL;

  for  (nRow = 0;  nRow < nHeight;  nRow++)
  {
    workRow = new kkuint32[nWidth];
    workRaster[nRow] = workRow;

    workDivisorRow = new uchar[nWidth];
    workDivisor[nRow] = workDivisorRow;

    for  (nCol = 0;  nCol < nWidth;  nCol++)
    {
      workRow[nCol] = 0;
      workDivisorRow[nCol] = 0;
    }
  }

  nRow = 1;
  kkint32  intermediateRow = 0;
  kkint32  intermediateCol = 0;
  uchar*  srcRow = NULL;

  for  (row = 0;  row < height;  row++)
  {
    srcRow = green[row];
    intermediateCol = 0;
    nCol = 1;
    workRow = workRaster[nRow];
    workDivisorRow = workDivisor[nRow];

    for  (col = 0;  col < width;  col++)
    {
      workRow[nCol] += srcRow[col];
      workDivisorRow[nCol]++;

      intermediateCol++;
      if  (intermediateCol >= multiple)
      {
        intermediateCol = 0;
        nCol++;
      }
    }

    intermediateRow++;
    if  (intermediateRow >= multiple)
    {
      intermediateRow = 0;
      nRow++;
    }
  }

  RasterPtr  reducedRaster = AllocateARasterInstance (nHeight, nWidth, false);

  uchar*  destRow = NULL;

  kkint32  newPixelVal           = 0;
  kkint32  nMaxPixVal            = 0;
  kkint32  nForegroundPixelCount = 0;

  for  (nRow = 0;  nRow < nHeight;  nRow++)
  {
    destRow = (reducedRaster->Green ())[nRow];
    workRow = workRaster[nRow];
    workDivisorRow = workDivisor[nRow];

    for  (nCol = 0;  nCol < nWidth;  nCol++)
    {
      newPixelVal = workRow[nCol];
      if  (newPixelVal > 0)  
      {
        nForegroundPixelCount++;
        newPixelVal = (kkint32)(0.5f + (float)(newPixelVal) / (float)(workDivisorRow[nCol]));
        destRow[nCol] = (uchar)(newPixelVal);
        if  (newPixelVal > nMaxPixVal)
          nMaxPixVal = newPixelVal;
      }
    }

    delete  workRaster[nRow];  
    delete  workDivisor[nRow];
    workRaster[nRow]  = NULL;
    workDivisor[nRow] = NULL;
  }
  delete[]  workRaster;
  workRaster = NULL;
  delete[]  workDivisor;
  workDivisor = NULL;

  reducedRaster->ForegroundPixelCount (nForegroundPixelCount);
  reducedRaster->MaxPixVal ((uchar)nMaxPixVal);

  return  reducedRaster;
}  /* ReduceByEvenMultiple */

RasterPtr Raster::ReduceByFactor

(

float

factor

)

const

Definition at line 7473 of file Raster.cpp.

References AllocateARasterInstance(), blue, BlueArea(), color, green, GreenArea(), height, red, RedArea(), and width.

{
  if  (factor <= 0.0f)  
    factor = 0.1f;
  
  else if  (factor > 1.0f)
    factor = 1.0f;

  kkint32  c, r;

  kkint32  newR;

  kkint32  newHeight = (kkint32)(height * factor + 0.5f);
  kkint32  newWidth  = (kkint32)(width  * factor + 0.5f);
  if  (newHeight < 2)
    newHeight = 2;

  if  (newWidth < 2)
    newWidth = 2;

  kkint32  newTotal  = newHeight * newWidth;

  float*  accumulatorAreaGreen = new float[newTotal];
  float*  accumulatorAreaRed   = NULL;
  float*  accumulatorAreaBlue  = NULL;
  if  (color)
  {
    accumulatorAreaRed   = new float[newTotal];
    accumulatorAreaBlue  = new float[newTotal];
    memset (accumulatorAreaRed,  0, newTotal * sizeof (float));
    memset (accumulatorAreaBlue, 0, newTotal * sizeof (float));
  }

  float*  divisorArea          = new float[newTotal];

  memset (accumulatorAreaGreen, 0, newTotal * sizeof (float));
  memset (divisorArea,          0, newTotal * sizeof (float));

  float** accumulatorRed   = NULL;
  float** accumulatorGreen = new float*[newHeight];
  float** accumulatorBlue  = NULL;

  if  (color)
  {
    accumulatorRed  = new float*[newHeight];
    accumulatorBlue = new float*[newHeight];
  }


  float** divisor   = new float*[newHeight];

  float*  rowFactor = new float[height + 1];
  float*  colFactor = new float[width  + 1];

  for  (r = 0;  r < height;  r++)
    rowFactor[r] = r * factor;
  rowFactor[height] = (float)newHeight;

  for  (c = 0;  c < width;  c++)
    colFactor[c] = c * factor;
  colFactor[width] = (float)newWidth;

  float*  arPtr = accumulatorAreaRed;
  float*  agPtr = accumulatorAreaGreen;
  float*  abPtr = accumulatorAreaBlue;
  float*  daPtr = divisorArea;
  for  (newR = 0;  newR < newHeight;  newR++)
  {
    accumulatorGreen [newR] = agPtr;
    divisor          [newR] = daPtr;
    agPtr += newWidth;
    daPtr += newWidth;

    if  (color)
    {
      accumulatorRed [newR] = arPtr;
      accumulatorBlue[newR] = abPtr;
      arPtr += newWidth;
      abPtr += newWidth;
    }
  }

  uchar  rValue = 0, gValue = 0, bValue = 0;

  for  (r = 0;  r < height;  r++)
  {
    kkint32  thisRow = (kkint32)rowFactor[r];
    if  (thisRow >= newHeight)
      thisRow = newHeight - 1;

    kkint32  nextRow = (kkint32)rowFactor[r + 1];
    if  (nextRow >= newHeight)
      nextRow = newHeight - 1;

    float  amtThisRow = 1.0f;
    float  amtNextRow = 0.0f;

    if  (nextRow > thisRow)
    {
      amtThisRow = (float)nextRow - rowFactor[r];
      amtNextRow = 1.0f - amtThisRow;
    }

    for  (c = 0;  c < width;  c++)
    {
      gValue = green[r][c];
      if  (color)
      {
        rValue = red [r][c];
        bValue = blue[r][c];
      }

      kkint32  thisCol = (kkint32)colFactor[c];
      if  (thisCol >= newWidth)
        thisCol = newWidth - 1;

      kkint32  nextCol = (kkint32)colFactor[c + 1];
      if  (nextCol >= newWidth)
        nextCol = newWidth - 1;

      float  amtThisCol = 1.0f;
      float  amtNextCol = 0.0f;

      if  (nextCol > thisCol)
      {
        amtThisCol = (float)nextCol - colFactor[c];
        amtNextCol = 1.0f - amtThisCol;
      }

      accumulatorGreen[thisRow][thisCol] += gValue * amtThisRow * amtThisCol;
      if  (color)
      {
        accumulatorRed [thisRow][thisCol] += rValue * amtThisRow * amtThisCol;
        accumulatorBlue[thisRow][thisCol] += bValue * amtThisRow * amtThisCol;
      }

      divisor   [thisRow][thisCol] += amtThisRow * amtThisCol;

      if  (nextRow > thisRow)
      {
        accumulatorGreen[nextRow][thisCol] += gValue * amtNextRow * amtThisCol;
        if  (color)
        {
          accumulatorRed [nextRow][thisCol] += rValue * amtNextRow * amtThisCol;
          accumulatorBlue[nextRow][thisCol] += bValue * amtNextRow * amtThisCol;
        }
        divisor   [nextRow][thisCol] += amtNextRow * amtThisCol;

        if  (nextCol > thisCol)
        {
          accumulatorGreen[nextRow][nextCol] += gValue * amtNextRow * amtNextCol;
          if  (color)
          {
            accumulatorRed [nextRow][nextCol] += rValue * amtNextRow * amtNextCol;
            accumulatorBlue[nextRow][nextCol] += bValue * amtNextRow * amtNextCol;
          }
          divisor   [nextRow][nextCol] += amtNextRow * amtNextCol;
        }
      }
      else
      {
        if  (nextCol > thisCol)
        {
          accumulatorGreen[thisRow][nextCol] += gValue * amtThisRow * amtNextCol;
          if  (color)
          {
            accumulatorRed [thisRow][nextCol] += rValue * amtThisRow * amtNextCol;
            accumulatorBlue[thisRow][nextCol] += bValue * amtThisRow * amtNextCol;
          }
          divisor   [thisRow][nextCol] += amtThisRow * amtNextCol;
        }
      }
    }  /*  for (c)  */
  }  /*  for (r)  */

  kkint32  x;
  RasterPtr  reducedRaster = AllocateARasterInstance (newHeight, newWidth, color);
  uchar*  newRedArea   = reducedRaster->RedArea   ();
  uchar*  newGreenArea = reducedRaster->GreenArea ();
  uchar*  newBlueArea  = reducedRaster->BlueArea  ();
  for  (x = 0;  x < newTotal;  x++)
  {
    if  (divisorArea[x] == 0.0f)
    {
      newGreenArea[x] = 0;
      if  (color)
      {
        newRedArea [x] = 0;
        newBlueArea[x] = 0;
      }
    }
    else
    {
      newGreenArea[x] = (uchar)(accumulatorAreaGreen[x] / divisorArea[x] + 0.5f);
      if  (color)
      {
        newRedArea [x] = (uchar)(accumulatorAreaRed [x] / divisorArea[x] + 0.5f);
        newBlueArea[x] = (uchar)(accumulatorAreaBlue[x] / divisorArea[x] + 0.5f);
      }
    }
     
  }

  delete[]  accumulatorAreaRed;    accumulatorAreaRed   = NULL;
  delete[]  accumulatorAreaGreen;  accumulatorAreaGreen = NULL;
  delete[]  accumulatorAreaBlue;   accumulatorAreaBlue  = NULL;

  delete[]  divisorArea;       divisorArea    = NULL;

  delete[]  accumulatorRed;    accumulatorRed    = NULL;
  delete[]  accumulatorGreen;  accumulatorGreen  = NULL;
  delete[]  accumulatorBlue;   accumulatorBlue   = NULL;
  delete[]  divisor;           divisor           = NULL;

  delete[]  rowFactor;       rowFactor      = NULL;
  delete[]  colFactor;       colFactor      = NULL;

  return  reducedRaster;
}  /* ReduceByFactor */

void Raster::ReduceToMostCompleteBlob

(

uchar

connectedComponentDist

)

Locates most complete blob; that is the one with the largest (Height x Width); and removes all other images from the blob.

Definition at line 3522 of file Raster.cpp.

References blobIds, ExtractBlobs(), green, greenArea, height, KKB::Blob::Id(), KKB::BlobList::LocateMostComplete(), totPixels, and width.

{
  if  (connectedComponentDist < 1)
    connectedComponentDist = 3;

  kkint32  row = 0, col = 0;

  BlobListPtr  blobs = ExtractBlobs (connectedComponentDist);

  BlobPtr largestBlob = blobs->LocateMostComplete ();
  if  (largestBlob)
  {
    kkint32  blobId = largestBlob->Id ();
     
    uchar*   newImageArea = new uchar[totPixels];
    memset (newImageArea, 0, totPixels);
    uchar*   newImageAreaPtr = newImageArea;

    uchar**  newRows = new uchar*[height];

    for  (row = 0; row < height; row++)
    {
      newRows[row] = newImageAreaPtr;
      
      for  (col = 0; col < width; col++)
      {
        if  (blobIds[row][col] == blobId)
        {
          newRows[row][col] = green[row][col];
        }
      }

      newImageAreaPtr = newImageAreaPtr + width;
    }

    delete  green;
    delete  greenArea;

    greenArea = newImageArea;
    green = newRows;
  }

  for  (row = 0; row < height; row++)
    delete  blobIds[row];
  delete  blobIds;
  blobIds = NULL;

  delete  blobs;  blobs = NULL;

  return;
}  /* ReduceToMostCompleteBlob */

void Raster::RemoveRasterInstance ( const RasterPtr  r )

staticprotected

Definition at line 129 of file Raster.cpp.

Referenced by ~Raster().

{
  /*
  if  (!rasterInitialized)
    Initialize ();

  goalKeeper->StartBlock ();

  map<RasterPtr, RasterPtr>::iterator  idx;
  idx = allocatedRasterInstances.find (r);
  if  (idx == allocatedRasterInstances.end ())
  {
    cerr << std::endl << "Raster::RemoveRasterInstance   ***ERROR***   Raster Instance[" << r << "] Not Found." << std::endl << std::endl;
  }
  else
  {
    allocatedRasterInstances.erase (idx);
  }
  goalKeeper->EndBlock ();
  */
}  /* RemoveRasterInstance */

void Raster::ReSize	(	kkint32	_height,
		kkint32	_width,
		bool	_color
	)

Lets you resize the raster dimensions; old image data will be lost.

Definition at line 898 of file Raster.cpp.

References color, height, and width.

Referenced by Dilation(), Edge(), Erosion(), FillHole(), and KKB::ConvexHull::Filter().

{
  CleanUpMemory ();
  height = _height;
  width  = _width;
  color  = _color;
  AllocateImageArea ();
}

RasterPtr Raster::ReversedImage

(

)

Definition at line 1177 of file Raster.cpp.

References AllocateARasterInstance(), and ReverseImage().

{
  RasterPtr  result = AllocateARasterInstance (*this);
  result->ReverseImage ();
  return  result;
}  /* ReversedImage */

void Raster::ReverseImage

(

)

Definition at line 1198 of file Raster.cpp.

References backgroundPixelTH, backgroundPixelValue, blueArea, color, foregroundPixelValue, greenArea, redArea, and totPixels.

Referenced by KKB::Histogram::CreateGraph(), KKB::ReadImage(), and ReversedImage().

{
  kkint32 x = 0;

  for  (x = 0;  x < totPixels;  x++)
  {
    greenArea[x] = 255 - greenArea[x];
    if  (color)
    {
      redArea[x]  = 255 - redArea[x];
      blueArea[x] = 255 - blueArea[x];
    }
  }

  uchar  temp = backgroundPixelValue;
  backgroundPixelValue = foregroundPixelValue;
  foregroundPixelValue = temp;
  backgroundPixelTH = 255 - backgroundPixelTH;
}  /* ReversedImage */

RasterPtr Raster::Rotate

(

float

turnAngle

)

Definition at line 5732 of file Raster.cpp.

References AllocateARasterInstance(), GetPixelValue(), Height(), height, SetPixelValue(), Width(), and width.

Referenced by DeriveImageLength().

{

  kkint32  diag = (kkint32)sqrt ((float)(Height () * Height () + Width () * Width ())) + 10;
  kkint32  halfDiag = (diag + 1) / 2;

  //  J( x+width(J)/2, y+height(J)/2 )= I( A11x+A12y+b1, A21x+A22y+b2 ),
  //  C:\Program Files\OpenCV\docs\ref\OpenCVRef_ImageProcessing.htm
  //      Example. Using cvGetQuadrangeSubPix for image rotation


  RasterPtr  rotatedImage = AllocateARasterInstance (diag, diag, false);

  float  a11 = (float)(cos (-turnAngle));
  float  a12 = (float)(sin (-turnAngle));
  float  b1  = width  * 0.5f;

  float  a21 = -a12;
  float  a22 = a11;
  float  b2  = height * 0.5f;

  kkint32  centDestCol = 0;
  kkint32  centDestRow = 0;

  kkint32  srcCol;
  kkint32  srcRow;

  kkint32  destX;
  kkint32  destY;


  for  (centDestRow = -halfDiag; centDestRow <  halfDiag; centDestRow++)
  {
    for  (centDestCol = -halfDiag; centDestCol <  halfDiag; centDestCol++)
    {
      srcRow = (kkint32)((float)(a21 * centDestCol) + (float)(a22 * centDestRow) + b2 + 0.5);
      if  ((srcRow >= 0)  &&  (srcRow < height))
      {
        srcCol = (kkint32)((float)(a11 * centDestCol) + (float)(a12 * centDestRow) + b1 + 0.5);
   
        if  ((srcCol >= 0)  &&  (srcCol < width))
        {
          uchar  pixVal = GetPixelValue (srcRow, srcCol);
          if  (pixVal > 0)
          {
            destY = centDestRow + halfDiag;
            destX = centDestCol + halfDiag;
            rotatedImage->SetPixelValue (destY, destX, pixVal);
          }
        }
      }
    }
  }

  return  rotatedImage;
}  /* Rotate */

Point Raster::RotateDerivePreRotatedPoint	(	kkint32	height,
		kkint32	width,
		Point &	rotatedPoint,
		float	turnAngle
	)		const

Definition at line 5792 of file Raster.cpp.

References KKB::Point::Col(), KKB::Point::Point(), and KKB::Point::Row().

Referenced by DeriveImageLength().

{
  kkint32  diag = (kkint32)sqrt ((float)(height * height + width * width)) + 10;

  float  a11 = (float)(cos (-turnAngle));
  float  a12 = (float)(sin (-turnAngle));
  float  b1  = width  * 0.5f;

  float  a21 = -a12;
  float  a22 = a11;
  float  b2  = height * 0.5f;

  kkint32  halfDiag = (diag + 1) / 2;

  kkint32  centDestRow = rotatedPoint.Row () - halfDiag;
  kkint32  centDestCol = rotatedPoint.Col () - halfDiag;

  kkint32  srcY = (kkint32)((float)(a21 * centDestCol) + (float)(a22 * centDestRow) + b2 + 0.5);
  kkint32  srcX = (kkint32)((float)(a11 * centDestCol) + (float)(a12 * centDestRow) + b1 + 0.5);

  return  Point (srcY, srcX);
}  /* RotateDerivePreRotatedPoint */

uchar** KKB::Raster::Rows ( ) const

inline

returns a pointer to a 2D array that allows the caller to access the raster data by row and column.

Definition at line 321 of file Raster.h.

References green.

Referenced by KKB::BmpImage::BmpImage(), KKB::ContourFollower::ContourFollower(), HistogramEqualizedImage(), SegmentImage(), and KKB::ConvexHull::Store().

RasterPtr Raster::SegmentImage

(

bool

save = false

)

Definition at line 7824 of file Raster.cpp.

References AllocateARasterInstance(), KKB::Histogram::AverageOfMaxBucketInRange(), BackgroundPixelValue(), KKB::Blue, Color(), KKB::KKStr::Concat(), CreateGrayScale(), CreateSmoothImage(), ExtractChannel(), fileName, ForegroundPixelValue(), GetPixelValue(), KKB::Green, Height(), HistogramGrayscale(), KKB::KKStr::operator+(), KKB::operator+(), KKB::osAddLastSlash(), KKB::osCreateDirectoryPath(), KKB::osGetRootName(), KKB::Red, Rows(), KKB::Histogram::Save(), KKB::Histogram::SaveGraphImage(), KKB::SaveImage(), SetPixelValue(), KKB::Histogram::Smooth(), KKB::StrFormatInt(), and Width().

{
  KKStr  rootName  = osGetRootName (fileName);
  KKStr  dirName = "c:\\Temp\\PolutionImages\\" + rootName;
  if  (save)
    osCreateDirectoryPath (dirName);
  osAddLastSlash (dirName);

  KKStr  baseName = dirName + rootName;

  if  (save)
    SaveImage (*this, baseName + "_Orig.bmp");

  bool  imageIsWhiteOnBlack = false;

  kkint32  r, c;

  float  threshold;

  float  backgroundValue;
  float  forgroundValue;

  RasterPtr  gsImage = NULL;

  if  (Color ())
  {
    gsImage = CreateGrayScale ();

    RasterPtr  redPart    = ExtractChannel (ColorChannels::Red);
    RasterPtr  greenPart  = ExtractChannel (ColorChannels::Green);
    RasterPtr  bluePart   = ExtractChannel (ColorChannels::Blue);

    delete  redPart;
    delete  greenPart;
    delete  bluePart;
  }
  else
  {
    gsImage = AllocateARasterInstance (*this);
  }

  RasterPtr  mask = NULL;

  RasterPtr  smoothedImage = gsImage->CreateSmoothImage ();
  {
    // Now lets determine if white or black background
 
    uchar**  g = smoothedImage->Rows ();

    kkint32  totalOfPixelVals = 0;
    kkint32  count = 0;
 
    kkint32  lastRow = Height () - 1;
    kkint32  lastCol = Width () - 1;

    for  (c = 0;  c < Width ();  c++)
    {
      totalOfPixelVals += g[0][c];
      totalOfPixelVals += g[lastRow][c];
      count += 2;
    }

    for  (r = 0;  r < Height ();  r++)
    {
      totalOfPixelVals += g[r][0];
      totalOfPixelVals += g[r][lastCol];
      count += 2;
    }

    threshold = (float)totalOfPixelVals / (float)count;

    imageIsWhiteOnBlack = (threshold < (float)175.0);
  }

  imageIsWhiteOnBlack = false;

  if  (imageIsWhiteOnBlack)
  {
    gsImage->BackgroundPixelValue (0);
    gsImage->ForegroundPixelValue (255);
  }
  else
  {
    gsImage->BackgroundPixelValue (255);
    gsImage->ForegroundPixelValue (0);
  }

  if  (save)
  {
    SaveImage (*gsImage, baseName + "_GrayScale.bmp");
    SaveImage (*smoothedImage, baseName + "_Smoothed.bmp");
  }


  {
    HistogramPtr  grayScaleHistogram = smoothedImage->HistogramGrayscale ();

    if  (save)
    {
      grayScaleHistogram->Save           (baseName + "_Histogram.txt");
      grayScaleHistogram->SaveGraphImage (baseName + "_Histogram.bmp");
    }

    HistogramPtr  grayScaleHistogramSmoothed = grayScaleHistogram->Smooth (4);

    if  (save)
    {
      grayScaleHistogramSmoothed->Save           (baseName + "_HistogramSmoothed.txt");
      grayScaleHistogramSmoothed->SaveGraphImage (baseName + "_HistogramSmoothed.bmp");
    }

    uchar**  g = smoothedImage->Rows ();

    if  (imageIsWhiteOnBlack)
    {
      backgroundValue = grayScaleHistogramSmoothed->AverageOfMaxBucketInRange (0, 120);
      forgroundValue  = grayScaleHistogramSmoothed->AverageOfMaxBucketInRange (130, 255);
      //threshold = grayScaleHistogramSmoothed->AverageOfMinBucketInRange (backgroundValue, forgroundValue);
      //threshold = backgroundValue + 10;
      threshold = (float)(backgroundValue + forgroundValue) / 2.0f;
    }
    else
    {
      backgroundValue = grayScaleHistogramSmoothed->AverageOfMaxBucketInRange (130, 255);
      forgroundValue  = grayScaleHistogramSmoothed->AverageOfMaxBucketInRange (0, 120);
      //threshold = grayScaleHistogramSmoothed->AverageOfMinBucketInRange (forgroundValue, backgroundValue);
      //threshold = backgroundValue - 10; 
      threshold = (float)(backgroundValue + forgroundValue) / 2.0f;
    }

    //threshold = (backgroundValue + forgroundValue) / (float)2.0;

    mask = AllocateARasterInstance (Height (), Width (), false);
    mask->BackgroundPixelValue (0);
    mask->ForegroundPixelValue (255);

    for  (r = 0;  r < Height ();  r++)
    {
      for  (c = 0;  c < Width ();  c++)
      {
        if  (imageIsWhiteOnBlack)
        {
          if  (g[r][c] > threshold)
            mask->SetPixelValue (r, c, 255);
          else
            mask->SetPixelValue (r, c, 0);
        }
        else
        {
          // Image is Black on White
          if  (g[r][c] < threshold)
            mask->SetPixelValue (r, c, 255);
          else
            mask->SetPixelValue (r, c, 0);
        }  
      }
    }

    delete  grayScaleHistogramSmoothed;
    delete  grayScaleHistogram;
  }

  if  (save)
    SaveImage (*mask, baseName + "_Mask_" + StrFormatInt ((kkint32)threshold, "zz0") + ".bmp");

  RasterPtr  destRaster = AllocateARasterInstance (Height (), Width (), false);
  destRaster->BackgroundPixelValue (255);
  destRaster->ForegroundPixelValue (0);

  for  (r = 0;  r < Height ();  r++)
  {
    for  (c = 0;  c < Width ();  c++)
    {
      if  (mask->GetPixelValue (r, c) >= 150)
      {
        if  (imageIsWhiteOnBlack)
          destRaster->SetPixelValue (r, c, gsImage->GetPixelValue (r, c));
        else
          destRaster->SetPixelValue (r, c, 255 - gsImage->GetPixelValue (r, c));
      }
      else
      {
        destRaster->SetPixelValue (r, c, 255);
      }
    }
  }


  delete  gsImage;
  delete  mask;

  
  if  (save)
    SaveImage (*destRaster, baseName + "_Segmented.bmp");

  return  destRaster;
}  /* SegmentImage */

void Raster::SetPixelValue	(	const Point &	point,
		const PixelValue &	pixVal
	)

Definition at line 1440 of file Raster.cpp.

References KKB::Point::Col(), KKB::Point::Row(), and SetPixelValue().

Referenced by DrawDot().

{
  SetPixelValue (point.Row (), point.Col (), pixVal);
} /* SetPixelValue */

void Raster::SetPixelValue	(	kkint32	row,
		kkint32	col,
		uchar	pixVal
	)

Definition at line 1390 of file Raster.cpp.

References green, height, and width.

Referenced by KKB::Histogram::CreateGraph(), KKB::ConvexHull::Draw(), HalfSize(), Padded(), KKB::ReadImagePGM(), Rotate(), and SegmentImage().

{
  if  ((row <  0)      ||  
       (row >= height) ||
       (col <  0)      ||
       (col >= width))
  {
    cerr << "***ERROR*** Raster::SetPixelValue   *** ERROR ***,  Raster Dimensions Exceeded."       << std::endl;
    cerr << "                        Height[" << height << "]  Width[" << width << "]." << std::endl;
    cerr << "                        Row["    << row    << "]  Col["   << col   << "]." << std::endl;
    return;
  }

  green[row][col] = pixVal;
}  /* SetPixelValue */

void Raster::SetPixelValue	(	kkint32	row,
		kkint32	col,
		const PixelValue &	pixVal
	)

Definition at line 1413 of file Raster.cpp.

References KKB::PixelValue::b, blue, color, KKB::PixelValue::g, green, height, KKB::PixelValue::r, red, and width.

Referenced by CreateColor(), CreateColorWithBlobsLabeldByColor(), CreateFromOrginalImageWithSpecifidBlobsOnly(), DrawCircle(), DrawDot(), FillBlob(), SetPixelValue(), and ThresholdInHSI().

{
  if  ((row <  0)      ||  
       (row >= height) ||
       (col <  0)      ||
       (col >= width))
  {
    cerr << "***ERROR*** Raster::SetPixelValue   *** ERROR ***,  Raster Dimensions Exceeded."       << std::endl;
    cerr << "                        Height[" << height << "]  Width[" << width << "]." << std::endl;
    cerr << "                        Row["    << row    << "]  Col["   << col   << "]." << std::endl;
    return;
  }

  green[row][col] = pixVal.g;
  if  (color)
  {
    red  [row][col] = pixVal.r;
    blue [row][col] = pixVal.b;
  }
}  /* SetPixelValue  */

void Raster::SetPixelValue	(	kkint32	row,
		kkint32	col,
		uchar	r,
		uchar	g,
		uchar	b
	)

Definition at line 1450 of file Raster.cpp.

References blue, color, green, height, red, and width.

{
  if  ((row <  0)      ||  
       (row >= height) ||
       (col <  0)      ||
       (col >= width))
  {
    cerr << "***ERROR*** Raster::SetPixelValue   *** ERROR ***,  Raster Dimensions Exceeded."       << std::endl;
    cerr << "                        Height[" << height << "]  Width[" << width << "]." << std::endl;
    cerr << "                        Row["    << row    << "]  Col["   << col   << "]." << std::endl;
    return;
  }

  green[row][col] = g;
  if  (color)
  {
    red  [row][col] = r;
    blue [row][col] = b;
  }
}  /* SetPixelValue  */

void Raster::SetPixelValue	(	ColorChannels	channel,
		kkint32	row,
		kkint32	col,
		uchar	pixVal
	)

Definition at line 1479 of file Raster.cpp.

References blue, color, KKB::Green, green, height, KKB::Red, red, and width.

Referenced by HalfSize().

{
  if  ((row <  0)      ||  
       (row >= height) ||
       (col <  0)      ||
       (col >= width))
  {
    cerr << "***ERROR*** Raster::SetPixelValue   *** ERROR ***,  Raster Dimensions Exceeded."       << std::endl;
    cerr << "                        Height[" << height << "]  Width[" << width << "]." << std::endl;
    cerr << "                        Row["    << row    << "]  Col["   << col   << "]." << std::endl;
    return;
  }

  if  (channel == ColorChannels::Green)
  {
    green[row][col] = pixVal;
    return;
  }

  if  (!color)
  {
    cerr << "***ERROR*** Raster::SetPixelValue   *** ERROR ***,  Not a Color Raster."  << std::endl;
  }

  if  (channel == ColorChannels::Red)
    red  [row][col]  = pixVal;
  else
    blue [row][col] = pixVal;

}  /* SetPixelValue  */

uchar * Raster::SimpleCompression

(

kkuint32 &

buffLen

)

const

Compresses the image in Raster using a simple Run length algorithm and returns a pointer to compressed data.

Using a simple run length compression algorithm compress the data in Raster and return a pointer to the resultant buffer. The caller will take ownership of the compressed data and be responsible for deleting it. The function 'FromCompressor' can take the compressed data with its length and recreate the original Raster object.

Parameters

buffLen

[in,out] Length of the compressed buffer returned.

Returns

pointer to compressed data; null if it fails, else an uchar*.

Definition at line 9016 of file Raster.cpp.

References KKB::SimpleCompressor::Add16BitInt(), KKB::SimpleCompressor::AddByte(), KKB::SimpleCompressor::CreateCompressedBuffer(), greenArea, height, KKB::SimpleCompressor::SimpleCompressor(), and width.

{
  kkint32  totalPixs = height * width;

  SimpleCompressor  compressor (totalPixs);

  compressor.Add16BitInt (height);
  compressor.Add16BitInt (width);

  kkint32  x;
  for  (x = 0;  x < totalPixs;  x++)
    compressor.AddByte (greenArea[x]);

  return  compressor.CreateCompressedBuffer (buffLen);
}  /* SimpleCompression */

RasterPtr Raster::SobelEdgeDetector

(

)

const

Definition at line 7696 of file Raster.cpp.

References KKB::MorphOpSobel::PerformOperation().

{
  MorphOpSobel  sobel;
  return sobel.PerformOperation (this);
}  /* SobelEdgeDetector */

RasterListPtr Raster::SplitImageIntoEqualParts	(	kkint32	numColSplits,
		kkint32	numRowSplits
	)		const

Definition at line 8025 of file Raster.cpp.

References height, Raster(), KKB::RasterList::RasterList(), and width.

{
  if  ((numColSplits < 1)  ||  (numColSplits >= width))
    return NULL;

  if  ((numRowSplits < 1)  ||  (numRowSplits >= height))  
    return NULL;

  RasterListPtr  parts = new RasterList (true);

  kkint32  partStartingCol = 0;
  kkint32  partStartingRow = 0;
 
  // because the image might not divide evenly we may have to do some
  // adjusting,  possibly loosing some rows and columns off the edges.
  kkint32  partWidth  = (kkint32)((float)(width  / numColSplits) + 0.5);
  kkint32  colsNeeded = numColSplits * partWidth;
  if  (colsNeeded > width)
  {
    partWidth--;
    partStartingCol = (width - (partWidth * numColSplits)) / 2;
  }

  kkint32  partHeight = (kkint32)((float)(height  / numRowSplits) + 0.5);
  kkint32  rowsNeeded = numRowSplits * partHeight;
  if  (rowsNeeded > height)
  {
    partWidth--;
    rowsNeeded = numRowSplits * partHeight;
    partStartingRow = (height -rowsNeeded) / 2;
  }

  kkint32  splitRow;
  kkint32  splitCol;

  kkint32  partStartRow = partStartingRow;

  for  (splitRow = 0;  splitRow < numRowSplits;  splitRow++)
  {
    kkint32  partEndRow = partStartRow + partHeight - 1;

    kkint32  partStartCol = partStartingCol;

    for  (splitCol = 0;  splitCol < numColSplits;  splitCol++)
    {
      kkint32  partEndCol = partStartCol + partWidth - 1;

      RasterPtr  part = new Raster (*this, partStartRow, partStartCol, partHeight, partWidth);

      parts->PushOnBack (part);

      partStartCol = partEndCol + 1;
    }

    partStartRow = partEndRow + 1;
  }

  return  parts;
}  /* SplitImageIntoEqualParts */

RasterPtr Raster::StreatchImage	(	float	rowFactor,
		float	colFactor
	)		const

Definition at line 1187 of file Raster.cpp.

References KKB::MorphOpStretcher::MorphOpStretcher(), and KKB::MorphOpStretcher::PerformOperation().

{
  MorphOpStretcher  streatcher (rowFactor, colFactor);
  return  streatcher.PerformOperation (this);
}

RasterPtr Raster::SwapQuadrants

(

)

const

summary> Thresholds image in HSI space.

remarks> Returns an image with only the pixels that are within a specified distance in HSI space to the supplied HSI parameters. All pixels that are not within the specified distance will be set to flagValue . /remarks> param name='thresholdH'> Hue in radians(0.0 thru 2Pie).

param name='thresholdS'> Saturation (0.0 thru 1.0).

param name='thresholdI'> Intensity (0.0 thru 1.0).

param name='distance'> Euclidean Distance (0.0 thru 1.0) that a pixel must be within in HSI space to be included.

param name='flagValue'> PixelValue to set for pixels that are NOT within 'distance' of threshold.

returns> A image where pixels that are within the threshold will retain their original pixel values and the ones that are not will be set to 'flagValue'.

Definition at line 5165 of file Raster.cpp.

References AllocateARasterInstance(), blue, fourierMag, green, height, red, and width.

{
  RasterPtr  result = AllocateARasterInstance (*this);

  kkint32  leftStart   = (kkint32)(width  / 2);
  kkint32  bottomStart = (kkint32)(height / 2);

  kkint32  r1, c1;
  kkint32  r2, c2;

  for  (r1 = 0, r2 = bottomStart;  (r1 < bottomStart)  &&  (r2 < height);  r1++, r2++)
  {
    for  (c1 = 0,  c2 = leftStart;  (c1 < leftStart)   &&  (c2 < width);   c1++, c2++)
    {
      result->green[r1][c1] = green[r2][c2];
      result->green[r2][c2] = green[r1][c1];
      result->green[r1][c2] = green[r2][c1];
      result->green[r2][c1] = green[r1][c2];

      if  (result->red)
      {
        result->red[r1][c1] = red[r2][c2];
        result->red[r2][c2] = red[r1][c1];
        result->red[r1][c2] = red[r2][c1];
        result->red[r2][c1] = red[r1][c2];
      }

      if  (result->blue)
      {
        result->blue[r1][c1] = blue[r2][c2];
        result->blue[r2][c2] = blue[r1][c1];
        result->blue[r1][c2] = blue[r2][c1];
        result->blue[r2][c1] = blue[r1][c2];
      }

      if  (result->fourierMag)
      {
        result->fourierMag[r1][c1] = fourierMag[r2][c2];
        result->fourierMag[r2][c2] = fourierMag[r1][c1];
        result->fourierMag[r1][c2] = fourierMag[r2][c1];
        result->fourierMag[r2][c1] = fourierMag[r1][c2];
      }
    }
  }

  return  result;
}  /* SwapQuadrants  */

void Raster::TakeOwnershipOfAnotherRastersData

(

Raster &

otherRaster

)

Will take ownership of 'otherRaster' raster dynamically allocated data and copy its non dynamically allocated data.

Dynamic structures for Fourier Transform and BlobId's will be set to NULL on the 'otherRaster' instance.

Definition at line 978 of file Raster.cpp.

References backgroundPixelTH, backgroundPixelValue, blobIds, blue, blueArea, centroidCol, centroidRow, color, divisor, fileName, foregroundPixelCount, foregroundPixelValue, fourierMag, fourierMagArea, green, greenArea, height, maxPixVal, KKB::KKStr::operator=(), red, redArea, title, totPixels, weOwnRasterData, and width.

{
  CleanUpMemory ();
  backgroundPixelValue    = otherRaster.backgroundPixelValue;
  backgroundPixelTH       = otherRaster.backgroundPixelTH;
  blobIds                 = otherRaster.blobIds;
  centroidCol             = otherRaster.centroidCol;
  centroidRow             = otherRaster.centroidRow;
  color                   = otherRaster.color;
  divisor                 = otherRaster.divisor;
  fileName                = otherRaster.fileName;
  foregroundPixelCount    = otherRaster.foregroundPixelCount;
  foregroundPixelValue    = otherRaster.foregroundPixelValue;
  fourierMag              = otherRaster.fourierMag;
  fourierMagArea          = otherRaster.fourierMagArea;
  height                  = otherRaster.height;
  maxPixVal               = otherRaster.maxPixVal;
  title                   = otherRaster.title;
  totPixels               = otherRaster.totPixels;
  weOwnRasterData         = otherRaster.weOwnRasterData;
  width                   = otherRaster.width;
  redArea                 = otherRaster.redArea;
  greenArea               = otherRaster.greenArea;
  blueArea                = otherRaster.blueArea;
  red                     = otherRaster.red;
  green                   = otherRaster.green;
  blue                    = otherRaster.blue;
  otherRaster.weOwnRasterData = false;
  otherRaster.fourierMagArea = NULL;
  otherRaster.fourierMag     = NULL;
  otherRaster.blobIds        = NULL;
}  /* TakeOwnershipOfAnotherRastersData */

RasterPtr Raster::ThinContour

(

)

const

Definition at line 8187 of file Raster.cpp.

References AllocateARasterInstance(), backgroundPixelValue, KKB::Point::Col(), ConnectedComponent(), ErodeSpurs(), FindBoundingBox(), Green(), k_ThinningCheckTransitions(), k_ThinningStep1cdTests(), k_ThinningStep2cdTests(), KKB::Point::Point(), KKB::PointList::PointList(), KKB::Point::Row(), and width.

Referenced by KKMLL::GrayScaleImagesFVProducer::ComputeFeatureVector().

{
  #if  defined(DEBUG_ThinContour)
  cout << std::endl << std::endl 
       << "Raster::ThinContour" << std::endl
       << std::endl;

    rasterGlobalHeight = height;
    rasterGlobalWidth  = width;
  #endif


  bool   PointsRemoved = false;
  uchar  m_Matrix22[3][3];

  kkint32  Iter = 0;
  kkint32  prem1;
  kkint32  prem2;
  kkint32  iCountX, iCountY;
  kkint32  pntinpic=0;

  
  PointList  pointList  (true);
  PointList  removeList (true);

  //ContourFollower contourFollwer (*this);
  //PointListPtr  borderPixs = contourFollower.GenerateContourList (blob);

  RasterPtr workRaster = AllocateARasterInstance (*this);
  workRaster->ConnectedComponent (3);

  uchar**   workGreen  = workRaster->Green ();
  workRaster->ErodeSpurs ();
  // workRaster->Dilation ();

  //   k_SetBorder(1,1,pImg);
  PointsRemoved = false;
  Iter++;


  /* step 1 Collecting the Black point in a list */
  prem1 = prem2 = 0;


  kkint32  minCol, maxCol, minRow, maxRow;

  workRaster->FindBoundingBox (minRow,
                               minCol,
                               maxRow,
                               maxCol
                              );

  if  ((minRow > maxRow)  ||  (minRow < 0)  ||  (minCol < 0))
  {
    #if  defined(DEBUG_ThinContour)
      cout << std::endl << std::endl 
           << "Raster::ThinContour    'FindBoundingBox'" << std::endl
           << "                        minRow[" << minRow << "]  maxRow[" << maxRow << "]" << std::endl
           << std::endl;
      cout.flush ();
    #endif
    // We must have a empty raster.  In this case there is nothing else we can do.
    return  workRaster;
  }

  for  (iCountY = minRow;  iCountY <= maxRow;  iCountY++)
  {
    minCol = 999999;
    maxCol = -1;

    for  (kkint32 x = 0; x < width; x++)
    {
      if  (ForegroundPixel (workGreen[iCountY][x]))
      {
        maxCol = Max (maxCol, x);
        minCol = Min (minCol, x);
      }
    }

    for  (iCountX = minCol;  iCountX <= maxCol;  iCountX++)
    {
      if  (ForegroundPixel (workGreen[iCountY][iCountX]))
      {
        PointPtr tempPoint = new Point (iCountY, iCountX);
        pntinpic++;

        if (ThinningSearchNeighbors  (iCountX, iCountY, workGreen, &m_Matrix22[0])  &&
            k_ThinningCheckTransitions (&m_Matrix22[0])                             &&
            k_ThinningStep1cdTests     (&m_Matrix22[0])
           )
        {
          prem1++;
          PointsRemoved = true;
          removeList.PushOnBack (tempPoint);
        }
        else
        {
          pointList.PushOnBack (tempPoint);
        }
      }
    }
  }

  #if  defined(DEBUG_ThinContour)
    cout << "Total black points:" << pntinpic << "\n";
    cout.flush ();
  #endif


  /* Set all pixels positions in RemoveList in image to white */
  {
    PointPtr  pixel = removeList.PopFromFront ();
    while  (pixel)
    {
      workGreen[pixel->Row ()][pixel->Col ()] = backgroundPixelValue;
      delete pixel;
      pixel = removeList.PopFromFront ();
    }
  }
  
  removeList.DeleteContents ();


  /* step 2 after step 1 which inserted points in list */
  if  (PointsRemoved)
  {
    #if  defined(DEBUG_ThinContour)
      cout << "PointsRemoved = true" << pntinpic << "\n";
      cout.flush ();
    #endif

    PointPtr  tempPoint = NULL;

    for  (iCountX = 0; iCountX < pointList.QueueSize ();  iCountX++)
    {
      tempPoint = pointList.IdxToPtr (iCountX);
      if  (tempPoint == NULL)
        continue;

      if  (ThinningSearchNeighbors  (tempPoint->Col (), tempPoint->Row (),  workGreen, &m_Matrix22[0])  &&
           k_ThinningCheckTransitions (&m_Matrix22[0])                                                    &&
           k_ThinningStep2cdTests     (&m_Matrix22[0])
          )
      {
        prem2++;
        PointsRemoved = true;
       
        //pointList.DeleteEntry (iCountX);
        pointList.SetIdxToPtr (iCountX, NULL); 
        removeList.PushOnBack (tempPoint);
        //iCountX--; /* Must decrease iCountX when a point has been removed */
      }
    }
  }

  /* Set all pixels positions in RemoveList in image to white */
  {
    PointPtr  pixel = removeList.PopFromFront ();
    while  (pixel)
    {
      workGreen[pixel->Row ()][pixel->Col ()] = backgroundPixelValue;
      delete pixel;
      pixel = removeList.PopFromFront ();
    }
  }

  removeList.DeleteContents ();
  #if  defined(DEBUG_ThinContour)
    cout  << "Iteration " << Iter << ": Points removed: " << prem1 << " + " << prem2 << " = " << prem1+prem2 << "\n";
    cout.flush ();
  #endif

  #if  defined(DEBUG_ThinContour)
    cout << std::endl << "ThinContour  Starting Step 1    PointsRemoved[" << (PointsRemoved?"True":"False") << "]" << "\n";
    cout.flush ();
  #endif
  /* step 1 */
  while  (PointsRemoved)
  {
    PointPtr  tempPoint = NULL;

    prem1 = prem2 = 0;

    Iter++;
    PointsRemoved = false;

    for  (iCountX = 0; iCountX < pointList.QueueSize (); iCountX++)
    {
      tempPoint = pointList.IdxToPtr (iCountX);
      if  (tempPoint == NULL)
        continue;
      
      if  ((ThinningSearchNeighbors  (tempPoint->Col (), tempPoint->Row (),  workGreen, &m_Matrix22[0]))  &&
           (k_ThinningCheckTransitions (&m_Matrix22[0]))                                                    &&
           (k_ThinningStep1cdTests     (&m_Matrix22[0]))
          )
      {
        prem1++;
        PointsRemoved = true;
        
        /*k_RemovePosFromGroupSlow(iCountX,&PointList);*/

        //pointList.DeleteEntry (iCountX);
        pointList.SetIdxToPtr (iCountX, NULL);
        removeList.PushOnBack (tempPoint);
        //iCountX--;  /* Must decrease iCountX when a point has been removed */
      }
    }
    
    /* Set all pixels positions in Remove List in image to white */
    #if  defined(DEBUG_ThinContour)
      cout << "Set all pixels positions in Remove List in image to white.   removeList.size()=[" << removeList.size () << "]" << "\n";
      cout.flush ();
    #endif

    {
      PointPtr  pixel = removeList.PopFromFront ();
      while  (pixel)
      {
        workGreen[pixel->Row ()][pixel->Col ()] = backgroundPixelValue;
        delete pixel;
        pixel = removeList.PopFromFront ();
      }

      removeList.DeleteContents ();
    }


    #if  defined(DEBUG_ThinContour)
      cout << "ThinContour  Starting Step 2" << "\n";
      cout.flush ();
    #endif
    /* step 2 */
    for  (iCountX = 0; iCountX < pointList.QueueSize (); iCountX++)
    {
       tempPoint = pointList.IdxToPtr (iCountX);
       if  (tempPoint == NULL)
         continue;

       if  (ThinningSearchNeighbors  (tempPoint->Col (), tempPoint->Row (), workGreen, &m_Matrix22[0])   &&
            k_ThinningCheckTransitions (&m_Matrix22[0]) &&
            k_ThinningStep2cdTests     (&m_Matrix22[0])
           )
       {
         prem2++;
         PointsRemoved = true;

         /*k_RemovePosFromGroupSlow(iCountX,&PointList);*/
         //pointList.DeleteEntry (iCountX);
         pointList.SetIdxToPtr (iCountX, NULL);
         removeList.PushOnBack (tempPoint);
         //iCountX--; /* Must decrease iCountX when a point has been removed */
       }
    }


    #if  defined(DEBUG_ThinContour)
      cout << "ThinContour  LastStep in loop" << "\n";
      cout.flush ();
    #endif

    /* Set all pixels positions in RemoveList in image to white */
    {
      PointPtr  pixel = removeList.PopFromFront ();
      while  (pixel)
      {
        workGreen[pixel->Row ()][pixel->Col ()] = backgroundPixelValue;
        delete pixel;
        pixel = removeList.PopFromFront ();
      }

      removeList.DeleteContents ();
    }

    #if  defined(DEBUG_ThinContour)
      cout << "Iteration " << Iter << ": Points removed: " << prem1 << " + " << prem2 << " = " << prem1 + prem2 << "\n";
      cout.flush ();
    #endif

  }

  #if  defined(DEBUG_ThinContour)
    cout << "ThinContour   Ready to Exit;  going to DeleteContents of 'pointList' and 'removeList'." << "\n";
    cout.flush ();
  #endif


  pointList.DeleteContents ();
  removeList.DeleteContents ();

  #if  defined(DEBUG_ThinContour)
    cout << "ThinContour   Exiting'." << "\n";
    cout.flush ();
  #endif

    return  workRaster;
}  /* ThinContour */

RasterPtr Raster::ThresholdInHSI	(	float	thresholdH,
		float	thresholdS,
		float	thresholdI,
		float	distance,
		const PixelValue &	flagValue
	)

Definition at line 9455 of file Raster.cpp.

References AllocateARasterInstance(), GetPixelValue(), height, KKB::PixelValue::PixelValue(), SetPixelValue(), KKB::PixelValue::ToHSI(), and width.

{
  PixelValue color (0, 0, 0);
  //Vec<float,3> white(255,255,255);
  float tempH, tempS, tempI;
  float y, x, r, xOriginalPoint, yOriginalPoint;

  // converts from polar coordinates to Cartesian coordinates. Hue is an angle and Saturation is a distance from an origin.
  // xOriginalPoint and yOriginalPoint are the threshold point coordinates (origin)
  xOriginalPoint = thresholdS * cos (thresholdH);
  yOriginalPoint = thresholdS * sin (thresholdH);

  RasterPtr  resultingImage = AllocateARasterInstance (*this);

  for  (kkint32 m = 0;  m < height;  m++)
  {
    for  (kkint32 n = 0;  n < width;  n++)
    {
      GetPixelValue (m, n, color);
      color.ToHSI (tempH, tempS, tempI);

      // Convert from Cartesian polar coordinates to Cartesian coordinates. These are the Cartesian coordinates of the
      // current pixel
      x = tempS * cos (tempH);
      y = tempS * sin (tempH);

      // Calculate the distance from the threshold initial point to the current pixel color using 
      // the euclidean distance
      r = (float)(sqrt (pow (xOriginalPoint - x, 2) + pow (yOriginalPoint - y, 2) + pow (thresholdI - tempI, 2)));

      if  (r <= distance)
         resultingImage->SetPixelValue (m, n, color);
      else
        resultingImage->SetPixelValue (m, n, flagValue);
    }
  }

  return  resultingImage;
}  /* ThresholdingHSI */

RasterPtr Raster::TightlyBounded

(

kkuint32

borderPixels

)

const

Returns the smallest image that contains all the foreground pixels plus column and row padding specified by 'borderPixels'.

Definition at line 8619 of file Raster.cpp.

References AllocateARasterInstance(), Blue(), blue, color, FindBoundingBox(), Green(), green, Red(), and red.

{
  kkint32  tlRow = 0;
  kkint32  tlCol = 0;
  kkint32  brRow = 0;
  kkint32  brCol = 0;

  FindBoundingBox (tlRow, tlCol, brRow, brCol);
  if  ((tlRow > brRow)  ||  (tlCol > brCol))
  {
    if  (borderPixels < 1)
      borderPixels = 1;
    return AllocateARasterInstance (borderPixels * 2, borderPixels * 2, color);
  }

  kkint32  newHeight = (brRow - tlRow) + borderPixels * 2 +  + 1;
  kkint32  newWidth  = (brCol - tlCol) + borderPixels * 2 +  + 1;

  RasterPtr  result = AllocateARasterInstance (newHeight, newWidth, color);

  uchar**  newRed   = result->Red   ();
  uchar**  newGreen = result->Green ();
  uchar**  newBlue  = result->Blue  ();

  kkint32  oldR, oldC;

  kkint32  newR = borderPixels;
  for  (oldR = tlRow;  oldR <= brRow;  oldR++)
  {
    kkint32  newC = borderPixels;
    for  (oldC = tlCol;  oldC < brCol;  oldC++)
    {
      newGreen[newR][newC] = green[oldR][oldC];
      if  (color)
      {
        newRed [newR][newC] = red [oldR][oldC];
        newBlue[newR][newC] = blue[oldR][oldC];
      }
      
      newC++;
    }
    newR++;
  }

  return  result;
}  /* TightlyBounded */

const KKStr& KKB::Raster::Title ( ) const

inline

Definition at line 322 of file Raster.h.

References title.

{return  title;}

void KKB::Raster::Title ( const KKStr &  _title )

inline

Definition at line 348 of file Raster.h.

References KKB::KKStr::operator=(), and title.

{title                = _title;}

RasterPtr Raster::ToColor

(

)

const

Definition at line 8696 of file Raster.cpp.

References AllocateARasterInstance(), BlueArea(), color, ForegroundPixelValue(), GreenArea(), greenArea, height, RedArea(), totPixels, and width.

{
  if  (color)
    return AllocateARasterInstance (*this);

  RasterPtr  r = AllocateARasterInstance (height, width, true);

  if  (this->ForegroundPixelValue () < 100)
  {
    // 
    memcpy (r->RedArea   (), greenArea, totPixels);
    memcpy (r->GreenArea (), greenArea, totPixels);
    memcpy (r->BlueArea  (), greenArea, totPixels);
  }
  else
  {
    uchar* srcGreen    = greenArea;
    uchar* targetRed   = r->RedArea   ();
    uchar* targetGreen = r->GreenArea ();
    uchar* targetBlue  = r->BlueArea  ();
    for  (kkint32 x = 0;  x < this->totPixels;  ++x)
    {
      uchar  pc = (255 - *srcGreen);
      *targetRed   = pc;
      *targetGreen = pc;
      *targetBlue  = pc;

      ++srcGreen;
      ++targetRed;
      ++targetGreen;
      ++targetBlue;
    }
  }

  return r;
}  /* ToColor */

uchar * Raster::ToCompressor

(

kkuint32 &

compressedBuffLen

)

const

Compresses the image in Raster using zlib library and returns a pointer to compressed data.

Will first write Rater data to a buffer that will be compressed by the Compressor class using the zlib library.

Buffer Contents:
   0 - 3: Height:  high order to low order
   4 - 7:    Width:   high order to low order
   8 - 8:    Color    0 = ,  1 = Color
   9 -  :   Green Channel  (Height * Width bytes)
   xxxxx:   Red  Channel, if color image.
   xxxxx:   Blue Channel, if color image.

Parameters

[out]

compressedBuffLen

Length of the compressed buffer returned.

Returns

pointer to compressed data.

Definition at line 9172 of file Raster.cpp.

References blueArea, color, KKB::Compressor::CreateCompressedBuffer(), greenArea, height, redArea, totPixels, and width.

{
  // Will first write Rater data to a buffer that will be compressed by zlib by the Compressor class.
  // 0 - 3:    Height:  high order to low order
  // 4 - 7:    Width:   high order to low order
  // 8 - 8:    Color    0 = Gray-scale,  1 = Color
  // 9 - 8 + (Height * Width) Green Channel
  // xxxxx                    Red  Channel
  // xxxxx                    Blue Channel
  kkuint32  totalDataNeeded = totPixels + (color ? (2 * totPixels) : 0) + 9;
  uchar*  buff = new uchar[totalDataNeeded];
  if  (!buff)
    return  NULL;

  memset (buff, 0, totalDataNeeded);

  kkuint32  h = (kkuint32)height;
  buff[0] = h % 256;  h = h / 256;
  buff[1] = h % 256;  h = h / 256;
  buff[2] = h % 256;  h = h / 256;
  buff[3] = h % 256;  h = h / 256;


  kkuint32  w = (kkuint32)width;
  
  buff[4] = w % 256;  w = w / 256;
  buff[5] = w % 256;  w = w / 256;
  buff[6] = w % 256;  w = w / 256;
  buff[7] = w % 256;  w = w / 256;

  buff[8] = (color ? 1 : 0);

  kkint32  buffIdx = 9;
  kkint32  x = 0;
  for  (x = 0;  x < totPixels;  x++, buffIdx++)
    buff[buffIdx] = greenArea[x];

  if  (color)
  {
    for  (x = 0;  x < totPixels;  x++, buffIdx++)
      buff[buffIdx] = redArea[x];

    for  (x = 0;  x < totPixels;  x++, buffIdx++)
      buff[buffIdx] = blueArea[x];
  }

  compressedBuffLen = 0;
  uchar*  compressedBuff = (uchar*)Compressor::CreateCompressedBuffer (buff, totalDataNeeded, compressedBuffLen);
  delete[]  buff;  buff = NULL;
  return  compressedBuff;
}  /* ToCompressor */

kkint32 Raster::TotalBackgroundPixels

(

)

const

Definition at line 1086 of file Raster.cpp.

References backgroundPixelTH, greenArea, and totPixels.

Referenced by CreateGrayScaleKLTOnMaskedArea(), and KKB::SegmentorOTSU::SegmentMaskedImage().

{
  kkint32  totalBackgroundPixels = 0;
  for  (kkint32 x = 0;  x < totPixels;  ++x)
  {
    if  (greenArea[x] > backgroundPixelTH)
      ++totalBackgroundPixels;
  }
  return  totalBackgroundPixels;
}  /* TotalBackgroundPixels */

kkint32 KKB::Raster::TotPixels ( ) const

inline

The total number of pixels (Height * Width).

Definition at line 323 of file Raster.h.

References totPixels.

Referenced by KKB::SegmentorOTSU::ClassAverageRGB(), Erosion(), KKB::SegmentorOTSU::GetClassClosestToTargetColor(), KKB::SegmentorOTSU::SegmentImage(), and KKB::SegmentorOTSU::SegmentMaskedImage().

RasterPtr Raster::Transpose

(

)

const

Definition at line 8669 of file Raster.cpp.

References Blue(), blue, color, Green(), green, height, Raster(), Red(), red, and width.

{
  RasterPtr  result = new Raster (width, height, color);

  uchar**  resultRed   = result->Red   ();
  uchar**  resultGreen = result->Green ();
  uchar**  resultBlue  = result->Blue  ();

  for  (kkint32  row = 0;  row < height;  ++row)
  {
    for  (kkint32  col = 0;  col < width;  ++col)
    {
      resultGreen[col][row] = green[row][col];
      if  (color)
      {
        resultRed [col][row] = red [row][col];
        resultBlue[col][row] = blue[row][col];
      }
    }
  }

  return  result;
}

void KKB::Raster::WeOwnRasterData ( bool  _weOwnRasterData )

inline

Definition at line 349 of file Raster.h.

References weOwnRasterData.

{weOwnRasterData      = _weOwnRasterData;}

void Raster::WhiteOutBackground

(

)

Sets all pixels that are in the Background Range ov values to BackgroundPixelValue.

Definition at line 9814 of file Raster.cpp.

References BackgroundPixel(), backgroundPixelValue, blue, color, green, height, red, and width.

{
  for  (kkint32 r = 0;  r < height;  ++r)
  {
    for  (kkint32 c = 0;  c < width;  ++c)
    {
      if  (BackgroundPixel (r, c))
      {
        green[r][c] = backgroundPixelValue;
        if  (color)
        {
          red[r][c] = backgroundPixelValue;
          blue[r][c] = backgroundPixelValue;
        }
      }
    }
  }
}  /* WhiteOutBackground */

kkint32 KKB::Raster::Width ( ) const

inline

Definition at line 324 of file Raster.h.

References width.

Referenced by KKB::BmpImage::BmpImage(), KKMLL::GrayScaleImagesFVProducer::ComputeFeatureVector(), KKB::ContourFollower::ContourFollower(), CreateGrayScaleKLT(), CreateGrayScaleKLTOnMaskedArea(), KKB::RasterList::CreateSmoothedFrame(), Dilation(), KKB::DisplayImage(), Edge(), Erosion(), FillBlob(), FillHole(), KKB::ConvexHull::Filter(), KKB::MorphOpBinarize::PerformOperation(), Raster(), Rotate(), KKB::SaveImageInverted(), KKB::SaveImagePGM(), KKB::SaveImagePNG(), KKB::SaveImagePPM(), KKB::SegmentorOTSU::SegmentImage(), SegmentImage(), KKB::SegmentorOTSU::SegmentMaskedImage(), KKB::MorphOp::SetSrcRaster(), and KKB::ConvexHull::Store().

{return  width;}

Member Data Documentation

map< RasterPtr, RasterPtr > Raster::allocatedRasterInstances

staticprotected

Supports the tracking down of memory leaks in Raster; it will be called every time a new instance of a 'Raster' object is created.

Definition at line 1358 of file Raster.h.

uchar KKB::Raster::backgroundPixelTH

protected

Threshold used to split Background and foreground pixel/

Definition at line 1325 of file Raster.h.

Referenced by BackgroundPixel(), BackgroundPixelTH(), CentralMoments(), CentralMomentsWeighted(), ComputeCentralMoments(), CreateGrayScaleKLTOnMaskedArea(), Dilation(), Erosion(), FillHole(), Raster(), ReverseImage(), TakeOwnershipOfAnotherRastersData(), and TotalBackgroundPixels().

uchar KKB::Raster::backgroundPixelValue

protected

Definition at line 1324 of file Raster.h.

Referenced by BackgroundPixel(), BackgroundPixelValue(), BandPass(), CreateErodedImage(), Edge(), ErodeSpurs(), Erosion(), ErosionBoundary(), ErosionChanged(), ErosionChanged1(), Raster(), ReverseImage(), TakeOwnershipOfAnotherRastersData(), ThinContour(), and WhiteOutBackground().

kkint32** KKB::Raster::blobIds

protected

Used when searching for connected components

Definition at line 1326 of file Raster.h.

Referenced by BlobId(), ConnectedComponent(), ConnectedComponent8Conected(), CreateColorWithBlobsLabeldByColor(), CreateFromOrginalImageWithSpecifidBlobsOnly(), ExtractABlob(), ExtractABlobTightly(), ExtractBlobs(), FillBlob(), MemoryConsumedEstimated(), Raster(), ReduceToMostCompleteBlob(), and TakeOwnershipOfAnotherRastersData().

uchar** KKB::Raster::blue

protected

Definition at line 1354 of file Raster.h.

Referenced by Blue(), CreateGaussianSmoothedImage(), CreateSmoothImage(), DrawConnectedPointList(), DrawLine(), DrawPointList(), ExtractABlob(), ExtractABlobTightly(), ExtractUsingMask(), FillRectangle(), FindMagnitudeDifferences(), GetPixelValue(), HalfSize(), Initialize(), Raster(), ReduceByFactor(), SetPixelValue(), SwapQuadrants(), TakeOwnershipOfAnotherRastersData(), TightlyBounded(), Transpose(), and WhiteOutBackground().

uchar* KKB::Raster::blueArea

protected

Definition at line 1345 of file Raster.h.

Referenced by BlueArea(), CreateGrayScale(), CreateGrayScaleKLT(), CreateGrayScaleKLTOnMaskedArea(), Histogram(), Initialize(), Raster(), ReverseImage(), TakeOwnershipOfAnotherRastersData(), and ToCompressor().

float KKB::Raster::centroidCol

mutableprotected

Definition at line 1327 of file Raster.h.

Referenced by CalcCentroid(), CalcOrientationAndEigerRatio(), CentralMoments(), CentroidCol(), CentroidRow(), ComputeCentralMoments(), Raster(), and TakeOwnershipOfAnotherRastersData().

float KKB::Raster::centroidRow

mutableprotected

Definition at line 1328 of file Raster.h.

Referenced by CalcCentroid(), CalcOrientationAndEigerRatio(), CentralMoments(), CentroidCol(), CentroidRow(), ComputeCentralMoments(), Raster(), and TakeOwnershipOfAnotherRastersData().

bool KKB::Raster::color

protected

Definition at line 1329 of file Raster.h.

Referenced by BandPass(), Color(), CreateColor(), CreateGaussianSmoothedImage(), CreateGrayScale(), CreateGrayScaleKLT(), CreateGrayScaleKLTOnMaskedArea(), CreateSmoothedMediumImage(), Dilation(), DrawConnectedPointList(), DrawLine(), DrawPointList(), ExtractABlob(), ExtractABlobTightly(), ExtractChannel(), ExtractUsingMask(), FillRectangle(), FindMagnitudeDifferences(), GetPixelValue(), HalfSize(), Histogram(), HistogramGrayscaleImage(), Initialize(), MemoryConsumedEstimated(), PaintPoint(), Raster(), ReduceByFactor(), ReSize(), ReverseImage(), SetPixelValue(), TakeOwnershipOfAnotherRastersData(), TightlyBounded(), ToColor(), ToCompressor(), Transpose(), and WhiteOutBackground().

kkint32 KKB::Raster::divisor

protected

Definition at line 1330 of file Raster.h.

Referenced by Divisor(), Raster(), and TakeOwnershipOfAnotherRastersData().

KKStr KKB::Raster::fileName

protected

Definition at line 1331 of file Raster.h.

Referenced by FileName(), MemoryConsumedEstimated(), Raster(), SegmentImage(), and TakeOwnershipOfAnotherRastersData().

kkint32 KKB::Raster::foregroundPixelCount

mutableprotected

Definition at line 1332 of file Raster.h.

Referenced by CalcArea(), CalcAreaAndIntensityFeatures(), CalcAreaAndIntensityFeatures16(), CalcAreaAndIntensityHistogram(), CentralMoments(), CreateDilatedRaster(), CreateErodedImage(), CreatePaddedRaster(), Dilation(), Edge(), Erosion(), ErosionBoundary(), ErosionChanged(), ErosionChanged1(), FillHole(), ForegroundPixelCount(), Raster(), and TakeOwnershipOfAnotherRastersData().

uchar KKB::Raster::foregroundPixelValue

protected

Definition at line 1333 of file Raster.h.

Referenced by Edge(), FillHole(), ForegroundPixelValue(), Raster(), ReverseImage(), and TakeOwnershipOfAnotherRastersData().

float** KKB::Raster::fourierMag

protected

Only used if image is result of a Fourier Transform

Definition at line 1334 of file Raster.h.

Referenced by FourierExtractFeatures(), Raster(), SwapQuadrants(), and TakeOwnershipOfAnotherRastersData().

float* KKB::Raster::fourierMagArea

protected

Only used if image is result of a Fourier Transform

Definition at line 1335 of file Raster.h.

Referenced by FastFourier(), FastFourierKK(), FourierExtractFeatures(), FourierMagArea(), MemoryConsumedEstimated(), Raster(), and TakeOwnershipOfAnotherRastersData().

volatile GoalKeeperPtr Raster::goalKeeper = NULL

staticprotected

Definition at line 1359 of file Raster.h.

Referenced by FinalCleanUp(), and Initialize().

uchar** KKB::Raster::green

protected

Definition at line 1353 of file Raster.h.

Referenced by BackgroundPixel(), BandPass(), CalcArea(), CalcAreaAndIntensityHistogram(), CalcAreaAndIntensityHistogramWhite(), CalcCentroid(), CalcOrientationAndEigerRatio(), CalcWeightedArea(), CentralMoments(), CentralMomentsWeighted(), ComputeCentralMoments(), ConnectedComponent(), ConnectedComponent8Conected(), CreateColor(), CreateDilatedRaster(), CreateErodedImage(), CreateGaussianSmoothedImage(), CreatePaddedRaster(), CreateSmoothedMediumImage(), CreateSmoothImage(), Dilation(), DrawConnectedPointList(), DrawLine(), DrawPointList(), ErodeSpurs(), Erosion(), ErosionBoundary(), ErosionChanged(), ErosionChanged1(), ExtractABlob(), ExtractABlobTightly(), ExtractBlobs(), ExtractUsingMask(), FillHole(), FillRectangle(), FindBoundingBox(), FindMagnitudeDifferences(), FollowContour(), ForegroundPixel(), GetPixelValue(), Green(), HalfSize(), HistogramEqualizedImage(), HistogramGrayscale(), Initialize(), Raster(), ReduceByEvenMultiple(), ReduceByFactor(), ReduceToMostCompleteBlob(), Rows(), SetPixelValue(), SwapQuadrants(), TakeOwnershipOfAnotherRastersData(), TightlyBounded(), Transpose(), and WhiteOutBackground().

uchar* KKB::Raster::greenArea

protected

Definition at line 1344 of file Raster.h.

Referenced by BandPass(), CalcAreaAndIntensityFeatures(), CalcAreaAndIntensityFeatures16(), ConnectedComponent(), ConnectedComponent8Conected(), CreateColorImageFromLabels(), CreateGrayScale(), CreateGrayScaleKLT(), CreateGrayScaleKLTOnMaskedArea(), Dilation(), Erosion(), FastFourier(), FastFourierKK(), GreenArea(), Histogram(), Initialize(), Raster(), ReduceToMostCompleteBlob(), ReverseImage(), SimpleCompression(), TakeOwnershipOfAnotherRastersData(), ToColor(), ToCompressor(), and TotalBackgroundPixels().

kkint32 KKB::Raster::height

protected

Definition at line 1336 of file Raster.h.

Referenced by AreThereEdgePixels(), BandPass(), BlobId(), CalcArea(), CalcAreaAndIntensityHistogram(), CalcAreaAndIntensityHistogramWhite(), CalcCentroid(), CalcOrientationAndEigerRatio(), CalcWeightedArea(), CentralMoments(), CentralMomentsWeighted(), ComputeCentralMoments(), ConnectedComponent(), ConnectedComponent8Conected(), CreateColor(), CreateColorImageFromLabels(), CreateColorWithBlobsLabeldByColor(), CreateDilatedRaster(), CreateErodedImage(), CreateFromOrginalImageWithSpecifidBlobsOnly(), CreateGrayScale(), CreateGrayScaleKLTOnMaskedArea(), CreateSmoothedMediumImage(), DeriveImageLength(), Dilation(), DrawCircle(), DrawConnectedPointList(), DrawFatLine(), DrawGrid(), DrawLine(), DrawPointList(), Edge(), ErodeSpurs(), Erosion(), ErosionBoundary(), ExtractABlob(), ExtractBlobs(), ExtractChannel(), ExtractUsingMask(), FastFourier(), FastFourierKK(), FillBlob(), FillHole(), FindBoundingBox(), FollowContour(), FourierExtractFeatures(), GetPixelValue(), GetSubSet(), HalfSize(), Height(), HistogramEqualizedImage(), HistogramGrayscale(), Initialize(), MemoryConsumedEstimated(), Padded(), PaintPoint(), Raster(), ReduceByEvenMultiple(), ReduceByFactor(), ReduceToMostCompleteBlob(), ReSize(), Rotate(), SetPixelValue(), SimpleCompression(), SplitImageIntoEqualParts(), SwapQuadrants(), TakeOwnershipOfAnotherRastersData(), ThresholdInHSI(), ToColor(), ToCompressor(), Transpose(), and WhiteOutBackground().

uchar KKB::Raster::maxPixVal

mutableprotected

Definition at line 1337 of file Raster.h.

Referenced by CalcArea(), CalcAreaAndIntensityFeatures(), CalcAreaAndIntensityFeatures16(), CalcAreaAndIntensityHistogram(), CalcAreaAndIntensityHistogramWhite(), MaxPixVal(), Raster(), and TakeOwnershipOfAnotherRastersData().

volatile bool Raster::rasterInitialized = false

staticprotected

Definition at line 1360 of file Raster.h.

Referenced by Initialize().

uchar** KKB::Raster::red

protected

Definition at line 1352 of file Raster.h.

Referenced by CreateGaussianSmoothedImage(), CreateSmoothImage(), DrawConnectedPointList(), DrawLine(), DrawPointList(), ExtractABlob(), ExtractABlobTightly(), ExtractUsingMask(), FillRectangle(), FindMagnitudeDifferences(), GetPixelValue(), HalfSize(), Initialize(), Raster(), Red(), ReduceByFactor(), SetPixelValue(), SwapQuadrants(), TakeOwnershipOfAnotherRastersData(), TightlyBounded(), Transpose(), and WhiteOutBackground().

uchar* KKB::Raster::redArea

protected

Definition at line 1343 of file Raster.h.

Referenced by CreateGrayScale(), CreateGrayScaleKLT(), CreateGrayScaleKLTOnMaskedArea(), Histogram(), Initialize(), Raster(), RedArea(), ReverseImage(), TakeOwnershipOfAnotherRastersData(), and ToCompressor().

KKStr KKB::Raster::title

protected

Title such as 'Class" that can be assigned to an image.

Definition at line 1338 of file Raster.h.

Referenced by Raster(), TakeOwnershipOfAnotherRastersData(), and Title().

kkint32 KKB::Raster::totPixels

mutableprotected

Definition at line 1339 of file Raster.h.

Referenced by BandPass(), CalcAreaAndIntensityFeatures(), CalcAreaAndIntensityFeatures16(), CentroidCol(), CentroidRow(), ConnectedComponent(), ConnectedComponent8Conected(), CreateColorImageFromLabels(), CreateGrayScale(), CreateGrayScaleKLT(), CreateGrayScaleKLTOnMaskedArea(), FastFourier(), FastFourierKK(), FillHole(), Histogram(), Initialize(), MemoryConsumedEstimated(), Raster(), ReduceToMostCompleteBlob(), ReverseImage(), TakeOwnershipOfAnotherRastersData(), ToColor(), ToCompressor(), TotalBackgroundPixels(), and TotPixels().

bool KKB::Raster::weOwnRasterData

protected

Definition at line 1340 of file Raster.h.

Referenced by Initialize(), Raster(), TakeOwnershipOfAnotherRastersData(), and WeOwnRasterData().

kkint32 KKB::Raster::width

protected

Definition at line 1341 of file Raster.h.

Referenced by AreThereEdgePixels(), BandPass(), BlobId(), CalcArea(), CalcAreaAndIntensityHistogram(), CalcAreaAndIntensityHistogramWhite(), CalcCentroid(), CalcOrientationAndEigerRatio(), CalcWeightedArea(), CentralMoments(), CentralMomentsWeighted(), ComputeCentralMoments(), ConnectedComponent(), ConnectedComponent8Conected(), CreateColor(), CreateColorImageFromLabels(), CreateColorWithBlobsLabeldByColor(), CreateDilatedRaster(), CreateErodedImage(), CreateFromOrginalImageWithSpecifidBlobsOnly(), CreateGrayScale(), CreateGrayScaleKLTOnMaskedArea(), CreateSmoothedMediumImage(), DeriveImageLength(), Dilation(), DrawCircle(), DrawConnectedPointList(), DrawFatLine(), DrawGrid(), DrawLine(), DrawPointList(), Edge(), ErodeSpurs(), Erosion(), ErosionBoundary(), ExtractABlob(), ExtractBlobs(), ExtractChannel(), ExtractUsingMask(), FastFourier(), FastFourierKK(), FillBlob(), FillHole(), FindBoundingBox(), FollowContour(), FourierExtractFeatures(), GetPixelValue(), GetSubSet(), HalfSize(), HistogramEqualizedImage(), HistogramGrayscale(), Initialize(), Padded(), PaintPoint(), Raster(), ReduceByEvenMultiple(), ReduceByFactor(), ReduceToMostCompleteBlob(), ReSize(), Rotate(), SetPixelValue(), SimpleCompression(), SplitImageIntoEqualParts(), SwapQuadrants(), TakeOwnershipOfAnotherRastersData(), ThinContour(), ThresholdInHSI(), ToColor(), ToCompressor(), Transpose(), WhiteOutBackground(), and Width().

---

The documentation for this class was generated from the following files:

• C:/Users/Kurt/GitHub/KSquareLibraries/KKBase/Raster.h
• C:/Users/Kurt/GitHub/KSquareLibraries/KKBase/Raster.cpp