KKB Namespace Reference

KKB The namespace for KKBase Library supporting general functionality needed by almost any application. More...

Classes
class	Application
	The base class for all standalone application. More...
class	Atom
	Base class of all other classes that are meant to be managed by 'KKBase'. More...
class	BitString
	Allows you to manage very long bit strings. More...
class	Blob
	Used by the Raster object to identify a distinct blob; where it is in the raster and its unique id. More...
class	BlobList
	Maintains a list of blobs. More...
class	BmpImage
	Used to encode and decode BMP Images. More...
class	Chart
	Used to Create chart's from defined series of data. More...
class	CmdLineExpander
	Expands command line parameters, by parsing for special parameters and expanding them to their full value. More...
class	Compressor
	Simple class that will compress and decompress specified buffers using the routines provided in zlib. More...
class	Configuration
	General purpose Configuration File manager class. More...
class	ContourFollower
class	ConvexHull
	Operator that will create a Convex Hull of a supplied image. More...
class	DateTime
class	DateType
	Represents a calendar date consisting of three fields, Year, Month, and Day. More...
class	GlobalGoalKeeper
	Maintains one instance of a GoalKeeper object that can be used anywhere in the application. More...
class	GoalKeeper
class	GoalKeeperList
class	GoalKeeperSimple
	A simple/ light-weight implementation of critical section blocking. More...
class	GoalKeeperSimpleList
class	HashTable
class	Histogram
	Used to manage the construction of a Histogram. More...
class	HTMLReport
class	ImageDirTree
	Creates a index of all images in a specified directory structure. More...
class	Iterator
class	KK_DFT1D
class	KK_DFT2D
class	KKException
class	KKObservable
	The base class to be used by Observer classes. More...
class	KKObserver
	The base class to be used by Observer classes. More...
class	KKQueue
	A typed container class/template that keeps track of entries via pointers only. More...
class	KKStr
class	KKStrList
class	KKStrListIndexed
class	KKStrMatrix
	A two dimensional matrix of Strings. More...
class	KKStrParser
	Class that manages the extraction of tokens from a String without being destructive to the original string. More...
class	KKThread
	The base class to be used any thread. More...
class	KKThreadList
class	KKThreadManager
class	Matrix
	Supports two dimensional matrices. More...
class	MorphOp
	Base class for all Morphological operations. More...
class	MorphOpBinarize
class	MorphOpBmiFiltering
class	MorphOpDilation
class	MorphOpErosion
class	MorphOpMaskExclude
class	MorphOpSobel
class	MorphOpStretcher
class	MorphOpStruct
struct	MovDir
class	MsgQueue
	Will manage a buffer that will allow multiple threads to add and remove messages to a queue. More...
class	PixelValue
	Used by the Raster Class to represent the contents of one pixel. More...
class	Point
	Used by Raster class and MorphOp derived classes to denote a single pixel location in Raster image. More...
class	PointList
	Container object used to maintaining a list of pixel locations. More...
class	RandomNumGenerator
	Represents one single random number generator. More...
class	Raster
	A class that is used by to represent a single image in memory. More...
class	RasterBuffer
	Will manage a buffer that will allow multiple threads to add and remove instances of 'Raster' objects. More...
class	RasterList
class	RBnode
class	RBTree
class	Row
class	RunLog
	Used for logging messages. More...
class	SegmentorOTSU
class	SimpleCompressor
class	TimeType
	Represents a Time, consisting of three fields, Hour, Minute, and Second. summary>Represents Date and Time, consists of two member classes DateType and TimeType. More...
class	TokenBuffer
class	TokenBufferStr
class	TokenBufferStream
class	Tokenizer
	Class is meant to break down a stream into a set of logical tokens. More...
class	VectorKKStr
union	WordFormat32Bits
	Structure used to break 32 bit word into different formats;. More...
class	XmlAttribute
class	XmlAttributeList
class	XmlContent
class	XmlElement
class	XmlElementArrayDouble
class	XmlElementArrayFloat
class	XmlElementArrayFloat2D
class	XmlElementArrayFloat2DVarying
class	XmlElementArrayInt32
class	XmlElementArrayUint16
class	XmlElementBool
class	XmlElementDateTime
class	XmlElementDouble
class	XmlElementFloat
class	XmlElementInt32
class	XmlElementInt64
class	XmlElementKeyValuePairs
class	XmlElementKKStr
class	XmlElementTemplate
class	XmlElementUnKnown
	XmlElement derived class that will be used when there is no Factory defined for the element. More...
class	XmlElementVectorFloat
class	XmlElementVectorInt32
class	XmlFactory
class	XmlFactoryManager
class	XmlStream
	Manages the reading and writing of objects in a simple XML format. For a class to be supported by XmlStream it must implement: More...
class	XmlTag
class	XmlToken
class	XmlTokenizer
	Manages the break down a stream into a set of logical tokens compatible with the XML format. More...

Typedefs
typedef BitString *	BitStringPtr
typedef BlobList *	BlobListPtr
typedef Blob *	BlobPtr
typedef BmpImage *	BmpImagePtr
typedef CmdLineExpander *	CmdLineExpanderPtr
typedef std::complex< double >	ComplexDouble
typedef Configuration *	ConfigurationPtr
typedef char const *const *const	ConstCharStarArray
typedef ConvexHull *	ConvexHullPtr
typedef GoalKeeperList *	GoalKeeperListPtr
typedef GoalKeeper *	GoalKeeperPtr
typedef GoalKeeperSimpleList *	GoalKeeperSimpleListPtr
typedef GoalKeeperSimple::GoalKeeperSimplePtr	GoalKeeperSimplePtr
typedef HashEntry *	HashEntryPtr
typedef Histogram *	HistogramPtr
typedef HTMLReport::HTMLReportPtr	HTMLReportPtr
typedef KK_DFT1D< double >	KK_DFT1D_Double
typedef KK_DFT1D< float >	KK_DFT1D_Float
typedef KK_DFT2D< double >	KK_DFT2D_Double
typedef KK_DFT2D< float >	KK_DFT2D_Float
typedef __int16	kkint16
	16 bit signed integer. More...
typedef __int32	kkint32
typedef __int64	kkint64
typedef __int8	kkint8
typedef KKObservable *	KKObservablePtr
typedef KKObserver::KKObserverPtr	KKObserverPtr
typedef KKStr const	KKStrConst
typedef KKStr::KKStrConstPtr	KKStrConstPtr
typedef KKStrList::KKStrListPtr	KKStrListPtr
typedef KKStrMatrix::KKStrMatrixPtr	KKStrMatrixPtr
typedef std::pair< KKStr, KKStr >	KKStrPair
typedef KKStr::KKStrPtr	KKStrPtr
typedef KKThreadList *	KKThreadListPtr
typedef KKThreadManager *	KKThreadManagerPtr
typedef KKTHread *	KKTHreadPtr
typedef KKThread::KKThreadPtr	KKThreadPtr
typedef unsigned __int16	kkuint16
	16 bit unsigned integer. More...
typedef unsigned __int32	kkuint32
typedef unsigned __int64	kkuint64
typedef unsigned __int8	kkuint8
typedef MorphOp::MaskTypes	MaskTypes
typedef Matrix *	MatrixPtr
typedef MorphOpBmiFiltering *	MorphBmiFilteringPtr
typedef KKQueue< MorphOp >	MorphologicalOperatorList
typedef MorphologicalOperatorList *	MorphologicalOperatorListPtr
typedef MorphOpMaskExclude *	MorphologicalOperatorMastPtr
typedef MorphOpBinarize *	MorphOpBinarizePtr
typedef MorphOpDilation *	MorphOpDialationPtr
typedef MorphOpErosion *	MorphOpErosionPtr
typedef MorphOp *	MorphOpPtr
typedef MorphOpStretcher *	MorphOpStretcherPtr
typedef MorphOpStruct *	MorphOpStructPtr
typedef MsgQueue *	MsgQueuePtr
typedef long long	osFilePos
typedef PixelValue *	PixelValuePtr
typedef PointList::PointListPtr	PointListPtr
typedef Point *	PointPtr
typedef RasterBuffer::RasterBufferPtr	RasterBufferPtr
typedef Raster::RasterConstPtr	RasterConstPtr
typedef RasterList *	RasterListPtr
typedef Raster *	RasterPtr
typedef Row *	RowPtr
typedef RunLog *	RunLogPtr
typedef vector< SeriesPtr >	SeriesList
typedef Chart::SeriesPtr	SeriesPtr
typedef KKStrList::KKStrListPtr	StringListPtr
	summary> Maintains a list of ordered KKStr instances that can be recalled by either string of index. More...
typedef MorphOp::StructureType	StructureType
typedef TokenBuffer *	TokenBufferPtr
typedef TokenBufferStream *	TokenBufferStreamPtr
typedef Tokenizer *	TokenizerPtr
typedef unsigned char	uchar
	Unsigned character. More...
typedef unsigned int	uint
	Unsigned integer. More...
typedef unsigned long	ulong
	Unsigned long. More...
typedef unsigned short	ushort
	Unsigned short. More...
typedef std::vector< bool >	VectorBool
typedef std::vector< char >	VectorChar
typedef VectorChar *	VectorCharPtr
typedef std::vector< double >	VectorDouble
	Vector of doubles. More...
typedef VectorDouble *	VectorDoubletPtr
typedef std::vector< float >	VectorFloat
typedef VectorFloat *	VectorFloatPtr
typedef std::vector< int >	VectorInt
typedef std::vector< kkint16 >	VectorInt16
	Vector of signed 16 bit integers. More...
typedef std::vector< kkint32 >	VectorInt32
	Vector of signed 32 bit integers. More...
typedef VectorInt32 *	VectorInt32Ptr
typedef std::vector< kkint64 >	VectorInt64
typedef VectorInt64 *	VectorInt64Ptr
typedef VectorInt *	VectorIntPtr
typedef std::vector< Point >	VectorPoint
typedef std::vector< short >	VectorShort
typedef VectorShort *	VectorShortPtr
typedef std::vector< uchar >	VectorUchar
typedef VectorUchar *	VectorUcharPtr
typedef std::vector< uint >	VectorUint
typedef std::vector< kkuint16 >	VectorUint16
	Vector of unsigned 16 bit integers. More...
typedef std::vector< kkuint32 >	VectorUint32
	Vector of unsigned 32 bit integers. More...
typedef std::vector< kkuint64 >	VectorUint64
typedef std::vector< ulong >	VectorUlong
typedef VectorUlong *	VectorUlongPtr
typedef volatile const bool	VolConstBool
typedef XmlAttribute const	XmlAttributeConst
typedef XmlAttributeConst *	XmlAttributeConstPtr
typedef XmlAttributeList *	XmlAttributeListPtr
typedef XmlAttribute *	XmlAttributePtr
typedef XmlContent *	XmlContentPtr
typedef XmlElementArrayDouble *	XmlElementArrayDoublePtr
typedef XmlElementArrayFloat2D *	XmlElementArrayFloat2DPtr
typedef XmlElementArrayFloat2DVarying *	XmlElementArrayFloat2DVaryingPtr
typedef XmlElementArrayFloat *	XmlElementArrayFloatPtr
typedef XmlElementArrayInt32 *	XmlElementArrayInt32Ptr
typedef XmlElementArrayUint16 *	XmlElementArrayUint16Ptr
typedef XmlElementTemplate< BitString >	XmlElementBitString
typedef XmlElementBool *	XmlElementBoolPtr
typedef XmlElementDateTime *	XmlElementDateTimePtr
typedef XmlElementDouble *	XmlElementDoublePtr
typedef XmlElementFloat *	XmlElementFloatPtr
typedef XmlElementInt32 *	XmlElementInt32Ptr
typedef XmlElementInt64 *	XmlElementInt64Ptr
typedef XmlElementKeyValuePairs *	XmlElementKeyValuePairsPtr
typedef XmlElementTemplate< KKStrList >	XmlElementKKStrList
typedef XmlElementTemplate< KKStrListIndexed >	XmlElementKKStrListIndexed
typedef XmlElementKKStrListIndexed *	XmlElementKKStrListIndexedPtr
typedef XmlElementKKStrList *	XmlElementKKStrListPtr
typedef XmlElementKKStr *	XmlElementKKStrPtr
typedef XmlElement *	XmlElementPtr
typedef XmlElementUnKnown *	XmlElementUnKnownPtr
typedef XmlElementVectorFloat *	XmlElementVectorFloatPtr
typedef XmlElementVectorInt32 *	XmlElementVectorInt32Ptr
typedef XmlElementTemplate< VectorKKStr >	XmlElementVectorKKStr
typedef XmlElementVectorKKStr *	XmlElementVectorKKStrPtr
typedef XmlFactory const *	XmlFactoryConstPtr
	summary>To be used for classes that implement default constructor, ReadXML, and WriteXML. More...
typedef XmlFactoryManager *	XmlFactoryManagerPtr
typedef XmlFactory *	XmlFactoryPtr
typedef XmlStream *	XmlStreamPtr
typedef XmlTag const	XmlTagConst
typedef XmlTag const *	XmlTagConstPtr
typedef XmlTag *	XmlTagPtr
typedef XmlTokenizer *	XmlTokenizerPtr
typedef XmlToken *	XmlTokenPtr

Enumerations
enum	ColorChannels { ColorChannels::Red, ColorChannels::Green, ColorChannels::Blue }
enum	RBcolor { RBcolor::Red, RBcolor::Black }

Functions
template<typename T >
T	Calc3TTLQC (const vector< T > &v, kkint32 b)
template<typename T >
T	CalcBQV (const vector< T > &v, kkint32 blockSize)
template<typename T >
void	CalcMeanAndStdDev (const vector< T > &v, T &mean, T &stdDev)
template<typename T >
T	CalcPQV (const vector< T > &v, kkint32 distance)
template<typename T >
T	CalcTTLQC (const vector< T > &v, kkint32 b)
template<typename T >
void	CalcVectorStats (const vector< T > &v, T &total, T &mean, T &stdDev, T &min, T &max)
ColorChannels	ColorChannelFromKKStr (const KKStr &s)
KKStr	ColorChannelToKKStr (ColorChannels c)
void	DefineImageIoAtExit ()
void	DisplayImage (const Raster &raster, const KKStr &title)
void	DisplayImage (const Raster &image)
HTMLReport &__cdecl	endl (HTMLReport &htmlReport)
void	FFT (float data[], kkuint32 number_of_complex_samples, kkint32 isign)
float	FloatAbs (float f)
void	ImageIoFinaleCleanUp ()
bool	IsFinite (const float &f)
bool	IsFinite (const double &f)
bool	IsNaN (const float &f)
bool	IsNaN (const double &d)
template<typename T >
T *	kkReallocateArray (T *oldA, kkint32 oldSize, kkint32 newSize)
float	LLoydsIndexOfPatchiness (const KKB::VectorInt &bins)
float	Log2 (float x)
kkint32	LRand48 ()
	A implementations of the Unix version of rand48 returning a 32 bit integer. More...
template<class T >
T	Max (T a, T b)
	generic Max function, Both parameters must be of the same type. More...
template<class T >
T	Max (T a, T b, T c)
	Generic Max function, that takes three parameters. All three parameters must be of the same type. More...
template<class T >
T	Max (T a, T b, T c, T d)
	Generic Max function, that takes four parameters. All four parameters must be of the same type. More...
template<class T >
T	Max (T x0, T x1, T x2, T x3, T x4)
	Generic Max function, that takes five parameters of the same type. More...
template<class T >
T	Max (T x0, T x1, T x2, T x3, T x4, T x5)
	Generic Max function, that takes six parameters of the same type. More...
template<class T >
T	Max (T x0, T x1, T x2, T x3, T x4, T x5, T x6)
	Generic Max function, that takes seven parameters of the same type. More...
template<class T >
T	Max (T x0, T x1, T x2, T x3, T x4, T x5, T x6, T x7)
	Generic Max function, that takes eight parameters of the same type. More...
float	McNemarsTest (kkint32 size, const bool *classedCorrectly1, const bool *classedCorrectly2)
template<class T >
T	Min (T a, T b)
	Generic Min function, Both parameters must be of the same type. More...
KKStr	operator+ (const char left, const KKStr &right)
KKStr	operator+ (const char *left, const KKStr &right)
Matrix	operator- (double left, const Matrix &right)
HTMLReport &__cdecl	operator<< (HTMLReport &htmlReport, HTMLReport &(__cdecl *mf)(HTMLReport &))
HTMLReport &	operator<< (HTMLReport &htmlReport, kkint32 right)
HTMLReport &	operator<< (HTMLReport &htmlReport, kkuint32 right)
HTMLReport &	operator<< (HTMLReport &htmlReport, kkint64 right)
HTMLReport &	operator<< (HTMLReport &htmlReport, kkuint64 right)
HTMLReport &	operator<< (HTMLReport &htmlReport, double right)
HTMLReport &	operator<< (HTMLReport &htmlReport, char right)
HTMLReport &	operator<< (HTMLReport &htmlReport, const char *right)
KKStr &	operator<< (KKStr &left, const Point &right)
HTMLReport &	operator<< (HTMLReport &htmlReport, const KKStr &right)
std::ostream &	operator<< (std::ostream &left, const Point &right)
HTMLReport &	operator<< (HTMLReport &htmlReport, KKStrConstPtr right)
HTMLReport &	operator<< (HTMLReport &htmlReport, const DateTime &right)
KKStr &	operator<< (KKB::KKStr &left, const DateType &right)
KKStr &	operator<< (KKB::KKStr &left, const TimeType &right)
KKStr &	operator<< (KKB::KKStr &left, const DateTime &right)
std::ostream &	operator<< (std::ostream &os, const DateType &right)
std::ostream &	operator<< (std::ostream &os, const TimeType &right)
std::ostream &	operator<< (std::ostream &os, const DateTime &right)
std::ostream &__cdecl	operator<< (std::ostream &os, const KKStr &str)
std::istream &__cdecl	operator>> (std::istream &is, KKStr &str)
void	osAddLastSlash (KKStr &fileSpec)
	Will add the appropriate Directory separator character to the end of fileSpec if one is not there already. More...
KKB::KKStr	osAddSlash (const KKStr &fileSpec)
void	osChangeDir (const KKStr &dirName, bool &successful)
bool	osCopyFile (const KKStr &srcFileName, const KKStr &destFileName)
bool	osCopyFileBetweenDirectories (const KKStr &_fileName, const KKStr &_srcDir, const KKStr &_destDir)
bool	osCreateDirectory (const KKStr &dirName)
bool	osCreateDirectoryPath (KKStr _pathName)
	Will create the whole Directory Path not just the final part of the path. More...
KKStr	osCreateUniqueFileName (KKStr fileName)
	Get a unique file name based off file spec 'fileName'. More...
bool	osDeleteFile (KKStr _fileName)
void	osDisplayWarning (KKStr _message)
bool	osFileExists (const KKStr &_fileName)
FILE *	osFOPEN (const char *fileName, const char *mode)
int	osFSEEK (FILE *f, kkint64 offset, int origin)
kkint64	osFTELL (FILE *f)
	Calls the appropriate 64 bit function for operating system. More...
KKStr	osGetCurrentDirectory ()
KKStr	osGetDirNameFromPath (KKStr dirPath)
	Extracts the final sub-directory name of the fill directory specification. More...
char	osGetDriveLetter (const KKStr &pathName)
	Given a full drive with path and name return the drive letter specified. More...
KKStrPtr	osGetEnvVariable (const KKStr &_varName)
KKStr	osGetErrorNoDesc (kkint32 errorNo)
KKB::DateTime	osGetFileDateTime (const KKStr &fileName)
KKStr	osGetFileExtension (KKStr fullFileName)
KKStr	osGetFileNamePartOfFile (KKStr fullFileName)
	osGetFileNamePartOfFile, retrieves the file name part of the file spec. More...
kkint64	osGetFileSize (const KKStr &fileName)
KKStr	osGetFullPathOfApplication ()
	returns the name and path of the current running application. More...
KKStr	osGetHostName ()
double	osGetKernalTimeUsed ()
KKStrListPtr	osGetListOfDirectories (KKStr fileSpec)
KKStrListPtr	osGetListOfFiles (const KKStr &fileSpec)
	Returns a list of files that match the provided file specification. More...
void	osGetListOfFilesInDirectoryTree (const KKStr &rootDir, KKStr fileSpec, VectorKKStr &fileNames)
KKStrListPtr	osGetListOfImageFiles (KKStr fileSpec)
KKB::DateTime	osGetLocalDateTime ()
	Returned the current local date and time. More...
kkint32	osGetNumberOfProcessors ()
	returns the number of CPU's or number of simultaneous threads that you can have. More...
KKStr	osGetParentDirectoryOfDirPath (KKStr path)
KKStr	osGetParentDirPath (KKStr dirPath)
	Returns the Parent directory path to 'dirPath'. More...
KKStr	osGetPathPartOfFile (KKStr fullFileName)
	Get the path part of a full file name specification. More...
kkint32	osGetProcessId ()
KKStr	osGetProgName ()
KKStr	osGetRootName (const KKStr &fullFileName)
KKStr	osGetRootNameOfDirectory (KKStr fullDirName)
KKStr	osGetRootNameWithExtension (const KKStr &fullFileName)
kkuint64	osGetSystemTimeInMiliSecs ()
	Returns mili-secs that system (Windows = has been started, Linux time in epoch). More...
double	osGetSystemTimeUsed ()
	Returns the number of CPU seconds used by current process. More...
kkint32	osGetThreadId ()
KKStr	osGetUserName ()
double	osGetUserTimeUsed ()
template<class T >
T *	osGrowAllocation (T *src, kkint32 origSize, kkint32 newSize)
bool	osIsBackGroundProcess ()
kkint32	osLocateFirstSlashChar (const KKStr &fileSpec)
kkint32	osLocateLastSlashChar (const KKStr &fileSpec)
KKStr	osLookForFile (const KKStr &fileName, const KKStr &srcDir)
	Look for a specified file in a sub-directory structure. More...
KKStr	osMakeFullFileName (const KKStr &_dirName, const KKStr &_fileName)
bool	osMoveFileBetweenDirectories (const KKStr &_fileName, const KKStr &_srcDir, const KKStr &_destDir)
void	osParseFileName (KKStr _fileName, KKStr &_dirPath, KKStr &_rootName, KKStr &_extension)
void	osParseFileSpec (KKStr fullFileName, KKStr &driveLetter, KKStr &path, KKStr &root, KKStr &extension)
KKStrPtr	osReadNextLine (FILE *in)
	Read the next line from the file and return a c-String(NULL terminated). More...
KKB::KKStr	osReadNextQuotedStr (FILE *in, const char *whiteSpaceCharacters, bool &eof)
	Read the next Quoted String from the file. More...
KKB::KKStr	osReadNextToken (FILE *in, const char *delimiters, bool &eof, bool &eol)
	Read the next logical token from a file using characters in 'delimiters' to separate tokens. More...
KKStr	osReadNextToken (FILE *in, const char *delimiters, bool &eof)
	Read the next logical token from a file using characters in 'delimiters' to separate tokens where ' '(end of line) is just another whitespace character. More...
KKB::KKStr	osReadNextToken (std::istream &in, const char *delimiters, bool &eof, bool &eol)
	Read the next logical token from a file using characters in 'delimiters' to separate tokens. More...
KKB::KKStrPtr	osReadRestOfLine (std::istream &in, bool &eof)
	Extracts text up to and including the next end-of-line character and returns pointer to dynamical allocated str that caller will own. More...
KKB::KKStrPtr	osReadRestOfLine (FILE *in, bool &eof)
KKB::KKStr	osReadRestOfLine2 (std::istream &in, bool &eof)
KKB::KKStr	osReadRestOfLine2 (FILE *in, bool &eof)
KKStr	osRemoveExtension (const KKStr &_fullFileName)
bool	osRenameFile (const KKStr &oldName, const KKStr &newName)
void	osRunAsABackGroundProcess ()
void	osSkipRestOfLine (FILE *in, bool &eof)
	Skips rest of the characters in the current line in the file. More...
void	osSkipRestOfLine (std::istream &in, bool &eof)
	Skips rest of the characters in the current line in the input stream. More...
void	osSleep (float numOfSecs)
void	osSleepMiliSecs (kkuint32 numMiliSecs)
VectorKKStr	osSplitDirectoryPathIntoParts (const KKStr &path)
KKB::KKStr	osSubstituteInEnvironmentVariables (const KKStr &src)
	Substitute in the value of the environment variables into 'src'. More...
bool	osValidDirectory (KKStrConstPtr _name)
bool	osValidDirectory (const KKStr &_name)
bool	osValidFileName (const KKStr &_name)
KKStrListPtr	osValidFileNameErrors (const KKStr &_name)
	Returns list of errors in '_name' with respect to it being a valid file name for the O/S. More...
void	osWaitForEnter ()
float	PairedTTest (const KKB::VectorFloat &set1, const KKB::VectorFloat &set2)
RasterPtr	ReadImage (const KKStr &imageFileName)
RasterPtr	ReadImagePGM (const KKStr &imageFileName)
RasterPtr	ReadImagePPM (const KKStr &imageFileName)
KKStr	ReadImagePpmField (FILE *in, bool &eof)
RasterPtr	ReadImageUsingGDI (const KKStr &imageFileName)
void	SaveImage (const Raster &image, const KKStr &imageFileName)
void	SaveImageGrayscaleInverted4Bit (const Raster &image, const KKStr &_fileName)
	Saves image as BMP file using 4 bit compressed gray-scale where Background = 255 and foreground = 0. More...
void	SaveImageGrayscaleInverted8Bit (const Raster &image, const KKStr &_fileName)
	Saves image as BMP using compressed gray-scale where Background = 255 and foreground = 0. More...
void	SaveImageInverted (Raster &raster, const KKStr &imageFileName)
void	SaveImagePGM (const Raster &image, const KKStr &imageFileName)
void	SaveImagePNG (const Raster &image, const KKStr &imageFileName)
void	SaveImagePPM (const Raster &image, const KKStr &imageFileName)
kkint32	SPRINTF (char *buff, kkint32 buffSize, const char *formatSpec, kkint16 right)
kkint32	SPRINTF (char *buff, kkint32 buffSize, const char *formatSpec, kkuint16 right)
kkint32	SPRINTF (char *buff, kkint32 buffSize, const char *formatSpec, kkint32 right)
kkint32	SPRINTF (char *buff, kkint32 buffSize, const char *formatSpec, kkuint32 right)
kkint32	SPRINTF (char *buff, kkint32 buffSize, const char *formatSpec, kkint64 right)
kkint32	SPRINTF (char *buff, kkint32 buffSize, const char *formatSpec, kkuint64 right)
kkint32	SPRINTF (char *buff, kkint32 buffSize, const char *formatSpec, kkint32 precision, double d)
kkint32	SPRINTF (char *buff, kkint32 buffSize, char const *formatSpec, double d)
void	SRand48 (kkint64 _seed)
	Seeds the Lrand48 functions with the parameters passed to it. More...
char *	STRCAT (char *dest, kkint32 destSize, const char *src)
char *	STRCOPY (char *dest, kkint32 destSize, const char *src)
char *	STRCOPY (char *dest, kkuint16 destSize, const char *src)
char *	STRDUP (const char *src)
KKStr	StrFormatDouble (double val, const char *mask)
KKStr	StrFormatInt (kkint32 val, const char *mask)
KKStr	StrFormatInt64 (kkint64 val, const char *mask)
KKStr	StrFromDouble (double d)
KKStr	StrFromFloat (float f)
KKStr	StrFromInt16 (kkint16 i)
KKStr	StrFromInt32 (kkint32 i)
KKStr	StrFromInt64 (kkint64 i)
KKStr	StrFromUint16 (kkuint16 ui)
KKStr	StrFromUint32 (kkuint32 ui)
KKStr	StrFromUint64 (kkuint64 ui)
kkint32	STRICMP (const char *left, const char *right)
kkint32	STRNICMP (const char *left, const char *right, kkint32 len)
bool	SupportedImageFileFormat (const KKStr &imageFileName)
template<class T >
T	Swap (T &x, T &y)
unsigned int	ThreadStartCallBack (void *param)
void	tqli (kkint32 n, double *d, double *e, double z[2][2])
void	Tred2 (kkint32 n, double a[2][2], double *d, double *e)
XmlFactoryPtr	XmlElementKKStrFactoryInstance ()
XmlFactoryPtr	XmlElementUnKnownFactoryInstance ()

Variables
double	DoubleMax = DBL_MAX
double	DoubleMin = DBL_MIN
float	FloatMax = FLT_MAX
float	FloatMin = FLT_MIN
bool	imageIoAtExitDefined = false

Detailed Description

KKB The namespace for KKBase Library supporting general functionality needed by almost any application.

Kurt Kramer Utilities This namespace is intended to gather BaseBibrary Classes together.

Author

Kurt Kramer.
( mail : kurtkramer@gmail.com )

Introduction

The KKBase Librery is my tool box of handy objects that I have been building since 1994. It contains classes for string management(KKStr), Floating point Matrix operations, Image Processing Routines, common operating system routines, Statistics, Histogramming, etc. These classes are meant to be Operating System(OS) neutral in that from the outside of the library they perform identically no matter what OS you are on.

Platform Independence

All classes are meant to be Platform independent. That is from the outside there should be no need to worry about which O/S platform you are building for. All O/S specific code will be internal to KKBaseLibrery (KKB) classes. For the most part all functions that require O/S specific knowledge are implemented in OSServices.h. There are a couple of exceptions such as GoalKeeper and ImageIO.h.

Outside Libraries FFTW and ZLIB.

To use all the classes in this Library you will need the libraries fftw and zlib123. "fftw" stands for "Fastest Fourier Transform in The West". It can be downloaded from http://www.fftw.org/. "zlib123" is a library that is used to compress and uncompress data. can be found at http://www.zlib.net/. It is used by the Compressor class.

Macros that should be defined. 'FFTW_AVAILABLE' - Indicates that you want to utilize the FFTW library. otherwise a simple Fourier transform will be utilized. 'ZLIB_AVAILABLE' - Indicates that 'zlib' library is available. If not defined the class Compressor will not do anything.

KKQueue

I have a container template called KKQueue that is derived from the std::vector<> template. It is specifically meant to work with pointers to its contents and understands the concept of ownership. That is a instance of a KKQueue template either owns its contents or it does not. If it owns them it will call the individual destructors for each item that it contains when its destructor is called. Many classes that I have written use this template so it would be worth reading its documentation.

Image Processing

There are several classes that aid in Image Processing. The primary class is Raster which can handle both Grayscale and Color images. It supports various morphological operations as well as Connected Component Analysis, Fourier transform, etc. Other classes that work with Raster are Blob, BMPheader, BMPheader.h, ContourFollower, Histogram, ImageIO.h, PixelValue, Point, and Sobel.

Base class for applications.

Contains basic support for applications such as command-line processing and logging. There is logic to process specified text files for additional parameters. A RunLog instance will be created and inherited by all derived classes; the command line will process and -Log parameter specified. Derived classes can intercept command line parameters simple y implementing the virtual method ProcessCmdLineParameter

Typedef Documentation

typedef BitString* KKB::BitStringPtr

Definition at line 187 of file BitString.h.

typedef BlobList * KKB::BlobListPtr

Definition at line 130 of file Blob.h.

typedef Blob * KKB::BlobPtr

Definition at line 70 of file Blob.h.

typedef BmpImage * KKB::BmpImagePtr

Definition at line 290 of file BMPImage.h.

typedef CmdLineExpander* KKB::CmdLineExpanderPtr

Definition at line 85 of file CmdLineExpander.h.

typedef std::complex<double> KKB::ComplexDouble

Definition at line 29 of file ContourFollower.h.

typedef Configuration* KKB::ConfigurationPtr

Definition at line 167 of file Configuration.h.

typedef char const* const* const KKB::ConstCharStarArray

Definition at line 161 of file KKBaseTypes.h.

typedef ConvexHull* KKB::ConvexHullPtr

Definition at line 123 of file ConvexHull.h.

typedef GoalKeeperList* KKB::GoalKeeperListPtr

summary> Used to deal with issues related to thread synchronization issues when sharing the same variables.

remarks> Use the GoalKeeper::Create method to create an instance of this class. The Create method will ensure that two different threads don't accidentally create two different instances of the same GoalKeeper object.

GoalKeeper has a concept of levels of depth. That is a particular thread may call StartBlock more than once, each time doing so it would be one level deeper. In this case it would have to call EndBlock an equal number of times to actually release the block. Imagine that you have a function that Starts and Ends a Block but can be called from the middle of another function that also Starts and Ends a block on the same GoalKeeper object.

This class is meant to function the same under Windows or Linux /remarks>

Definition at line 23 of file GoalKeeper.h.

typedef GoalKeeper::GoalKeeperPtr KKB::GoalKeeperPtr

Definition at line 14 of file GlobalGoalKeeper.h.

typedef GoalKeeperSimpleList* KKB::GoalKeeperSimpleListPtr

Definition at line 23 of file GoalKeeperSimple.h.

typedef GoalKeeperSimple::GoalKeeperSimplePtr KKB::GoalKeeperSimplePtr

Definition at line 165 of file GoalKeeperSimple.h.

typedef HashEntry* KKB::HashEntryPtr

Definition at line 15 of file HashTable.h.

typedef Histogram * KKB::HistogramPtr

Definition at line 83 of file Raster.h.

typedef HTMLReport::HTMLReportPtr KKB::HTMLReportPtr

Definition at line 64 of file HTMLReport.h.

typedef KK_DFT1D<double> KKB::KK_DFT1D_Double

Definition at line 173 of file kku_fftw.h.

typedef KK_DFT1D<float> KKB::KK_DFT1D_Float

Definition at line 172 of file kku_fftw.h.

typedef KK_DFT2D<double> KKB::KK_DFT2D_Double

Definition at line 225 of file kku_fftw.h.

typedef KK_DFT2D<float> KKB::KK_DFT2D_Float

Definition at line 224 of file kku_fftw.h.

typedef __int16 KKB::kkint16

16 bit signed integer.

Definition at line 85 of file KKBaseTypes.h.

typedef __int32 KKB::kkint32

Definition at line 88 of file KKBaseTypes.h.

typedef __int64 KKB::kkint64

Definition at line 90 of file KKBaseTypes.h.

typedef __int8 KKB::kkint8

Definition at line 83 of file KKBaseTypes.h.

typedef KKObservable::KKObservablePtr KKB::KKObservablePtr

Definition at line 16 of file KKObserver.h.

typedef KKObserver * KKB::KKObserverPtr

Definition at line 57 of file KKObserver.h.

typedef KKStr const KKB::KKStrConst

Definition at line 19 of file Atom.h.

typedef KKStrConst * KKB::KKStrConstPtr

Definition at line 718 of file KKStr.h.

typedef KKStrList::KKStrListPtr KKB::KKStrListPtr

Definition at line 827 of file KKStr.h.

typedef KKStrMatrix::KKStrMatrixPtr KKB::KKStrMatrixPtr

Definition at line 92 of file KKStrMatrix.h.

typedef std::pair< KKStr, KKStr > KKB::KKStrPair

Definition at line 719 of file KKStr.h.

typedef KKStr * KKB::KKStrPtr

Definition at line 717 of file KKStr.h.

typedef KKThreadList * KKB::KKThreadListPtr

Definition at line 19 of file KKThread.h.

typedef KKThreadManager * KKB::KKThreadManagerPtr

Definition at line 15 of file KKThread.h.

typedef KKTHread* KKB::KKTHreadPtr

Definition at line 20 of file KKThreadManager.h.

typedef KKThread::KKThreadPtr KKB::KKThreadPtr

Definition at line 209 of file KKThread.h.

typedef unsigned __int16 KKB::kkuint16

16 bit unsigned integer.

Definition at line 86 of file KKBaseTypes.h.

typedef unsigned __int32 KKB::kkuint32

Definition at line 89 of file KKBaseTypes.h.

typedef unsigned __int64 KKB::kkuint64

Definition at line 91 of file KKBaseTypes.h.

typedef unsigned __int8 KKB::kkuint8

Definition at line 84 of file KKBaseTypes.h.

typedef MorphOp::MaskTypes KKB::MaskTypes

Definition at line 60 of file Raster.h.

typedef Matrix::MatrixPtr KKB::MatrixPtr

Definition at line 50 of file Raster.h.

typedef MorphOpBmiFiltering* KKB::MorphBmiFilteringPtr

Definition at line 75 of file MorphOpBmiFiltering.h.

typedef KKQueue<MorphOp> KKB::MorphologicalOperatorList

Definition at line 136 of file MorphOp.h.

typedef MorphologicalOperatorList* KKB::MorphologicalOperatorListPtr

Definition at line 138 of file MorphOp.h.

typedef MorphOpMaskExclude* KKB::MorphologicalOperatorMastPtr

Definition at line 52 of file MorphOpMaskExclude.h.

typedef MorphOpBinarize* KKB::MorphOpBinarizePtr

Definition at line 48 of file MorphOpBinarize.h.

typedef MorphOpDilation* KKB::MorphOpDialationPtr

Definition at line 43 of file MorphOpDilation.h.

typedef MorphOpErosion* KKB::MorphOpErosionPtr

Definition at line 42 of file MorphOpErosion.h.

typedef MorphOp* KKB::MorphOpPtr

Definition at line 134 of file MorphOp.h.

typedef MorphOpStretcher* KKB::MorphOpStretcherPtr

Definition at line 67 of file MorphOpStretcher.h.

typedef MorphOpStruct* KKB::MorphOpStructPtr

Definition at line 62 of file MorphOpStruct.h.

typedef MsgQueue::MsgQueuePtr KKB::MsgQueuePtr

Definition at line 45 of file RunLog.h.

typedef long long KKB::osFilePos

Definition at line 21 of file OSservices.h.

typedef PixelValue* KKB::PixelValuePtr

Definition at line 28 of file BMPImage.h.

typedef PointList * KKB::PointListPtr

Definition at line 107 of file Point.h.

typedef Point * KKB::PointPtr

Definition at line 66 of file Point.h.

typedef RasterBuffer::RasterBufferPtr KKB::RasterBufferPtr

Definition at line 104 of file RasterBuffer.h.

typedef Raster const * KKB::RasterConstPtr

Definition at line 1373 of file Raster.h.

typedef RasterList * KKB::RasterListPtr

Definition at line 75 of file Raster.h.

typedef Raster * KKB::RasterPtr

Definition at line 25 of file BMPImage.h.

typedef Row* KKB::RowPtr

Definition at line 33 of file Matrix.h.

typedef RunLog* KKB::RunLogPtr

Definition at line 198 of file RunLog.h.

typedef vector<SeriesPtr> KKB::SeriesList

Definition at line 85 of file Chart.cpp.

typedef Chart::SeriesPtr KKB::SeriesPtr

Definition at line 83 of file Chart.cpp.

typedef KKStrList::KKStrListPtr KKB::StringListPtr

summary> Maintains a list of ordered KKStr instances that can be recalled by either string of index.

For comparability with previous version.

Definition at line 828 of file KKStr.h.

typedef MorphOp::StructureType KKB::StructureType

Definition at line 61 of file Raster.h.

typedef TokenBuffer* KKB::TokenBufferPtr

Definition at line 31 of file TokenBuffer.h.

typedef TokenBufferStream* KKB::TokenBufferStreamPtr

Definition at line 85 of file TokenBuffer.h.

typedef Tokenizer* KKB::TokenizerPtr

Definition at line 89 of file Tokenizer.h.

typedef unsigned char KKB::uchar

Unsigned character.

Definition at line 77 of file KKBaseTypes.h.

typedef unsigned int KKB::uint

Unsigned integer.

Definition at line 78 of file KKBaseTypes.h.

typedef unsigned long KKB::ulong

Unsigned long.

Definition at line 80 of file KKBaseTypes.h.

typedef unsigned short KKB::ushort

Unsigned short.

Definition at line 79 of file KKBaseTypes.h.

typedef std::vector<bool> KKB::VectorBool

Definition at line 135 of file KKBaseTypes.h.

typedef std::vector<char> KKB::VectorChar

Definition at line 136 of file KKBaseTypes.h.

typedef VectorChar* KKB::VectorCharPtr

Definition at line 151 of file KKBaseTypes.h.

typedef std::vector<double> KKB::VectorDouble

Vector of doubles.

Definition at line 148 of file KKBaseTypes.h.

typedef VectorDouble* KKB::VectorDoubletPtr

Definition at line 158 of file KKBaseTypes.h.

typedef std::vector<float> KKB::VectorFloat

Definition at line 149 of file KKBaseTypes.h.

typedef VectorFloat* KKB::VectorFloatPtr

Definition at line 157 of file KKBaseTypes.h.

typedef std::vector<int> KKB::VectorInt

Definition at line 138 of file KKBaseTypes.h.

typedef std::vector<kkint16> KKB::VectorInt16

Vector of signed 16 bit integers.

Definition at line 140 of file KKBaseTypes.h.

typedef std::vector<kkint32> KKB::VectorInt32

Vector of signed 32 bit integers.

Definition at line 144 of file KKBaseTypes.h.

typedef VectorInt32* KKB::VectorInt32Ptr

Definition at line 154 of file KKBaseTypes.h.

typedef std::vector<kkint64> KKB::VectorInt64

Definition at line 146 of file KKBaseTypes.h.

typedef VectorInt64* KKB::VectorInt64Ptr

Definition at line 155 of file KKBaseTypes.h.

typedef VectorInt* KKB::VectorIntPtr

Definition at line 153 of file KKBaseTypes.h.

typedef std::vector<Point> KKB::VectorPoint

Definition at line 68 of file Point.h.

typedef std::vector<short> KKB::VectorShort

Definition at line 142 of file KKBaseTypes.h.

typedef VectorShort* KKB::VectorShortPtr

Definition at line 159 of file KKBaseTypes.h.

typedef std::vector<uchar> KKB::VectorUchar

Definition at line 137 of file KKBaseTypes.h.

typedef VectorUchar* KKB::VectorUcharPtr

Definition at line 152 of file KKBaseTypes.h.

typedef std::vector<uint> KKB::VectorUint

Definition at line 139 of file KKBaseTypes.h.

typedef std::vector<kkuint16> KKB::VectorUint16

Vector of unsigned 16 bit integers.

Definition at line 141 of file KKBaseTypes.h.

typedef std::vector<kkuint32> KKB::VectorUint32

Vector of unsigned 32 bit integers.

Definition at line 145 of file KKBaseTypes.h.

typedef std::vector<kkuint64> KKB::VectorUint64

Definition at line 147 of file KKBaseTypes.h.

typedef std::vector<ulong> KKB::VectorUlong

Definition at line 143 of file KKBaseTypes.h.

typedef VectorUlong* KKB::VectorUlongPtr

Definition at line 156 of file KKBaseTypes.h.

typedef volatile const bool KKB::VolConstBool

Commonly used for passing Cancel Flag in multi threaded environment.

Definition at line 163 of file KKBaseTypes.h.

typedef XmlAttribute const KKB::XmlAttributeConst

Definition at line 131 of file XmlStream.h.

typedef XmlAttributeConst* KKB::XmlAttributeConstPtr

Definition at line 132 of file XmlStream.h.

typedef XmlAttributeList* KKB::XmlAttributeListPtr

Definition at line 170 of file XmlStream.h.

typedef XmlAttribute* KKB::XmlAttributePtr

Definition at line 130 of file XmlStream.h.

typedef XmlContent * KKB::XmlContentPtr

Definition at line 24 of file XmlStream.h.

typedef XmlElementArrayDouble* KKB::XmlElementArrayDoublePtr

Definition at line 917 of file XmlStream.h.

typedef XmlElementArrayFloat2D* KKB::XmlElementArrayFloat2DPtr

Definition at line 922 of file XmlStream.h.

typedef XmlElementArrayFloat2DVarying* KKB::XmlElementArrayFloat2DVaryingPtr

Definition at line 647 of file XmlStream.h.

typedef XmlElementArrayFloat* KKB::XmlElementArrayFloatPtr

Definition at line 919 of file XmlStream.h.

typedef XmlElementArrayInt32* KKB::XmlElementArrayInt32Ptr

Definition at line 915 of file XmlStream.h.

typedef XmlElementArrayUint16* KKB::XmlElementArrayUint16Ptr

Definition at line 913 of file XmlStream.h.

typedef XmlElementTemplate<BitString> KKB::XmlElementBitString

Definition at line 189 of file BitString.h.

typedef XmlElementBool* KKB::XmlElementBoolPtr

Definition at line 524 of file XmlStream.h.

typedef XmlElementDateTime* KKB::XmlElementDateTimePtr

Definition at line 560 of file XmlStream.h.

typedef XmlElementDouble* KKB::XmlElementDoublePtr

Definition at line 909 of file XmlStream.h.

typedef XmlElementFloat* KKB::XmlElementFloatPtr

Definition at line 908 of file XmlStream.h.

typedef XmlElementInt32* KKB::XmlElementInt32Ptr

Definition at line 906 of file XmlStream.h.

typedef XmlElementInt64* KKB::XmlElementInt64Ptr

Definition at line 907 of file XmlStream.h.

typedef XmlElementKeyValuePairs* KKB::XmlElementKeyValuePairsPtr

Definition at line 605 of file XmlStream.h.

typedef XmlElementTemplate<KKStrList> KKB::XmlElementKKStrList

Definition at line 678 of file XmlStream.h.

typedef XmlElementTemplate<KKStrListIndexed> KKB::XmlElementKKStrListIndexed

Definition at line 682 of file XmlStream.h.

typedef XmlElementKKStrListIndexed* KKB::XmlElementKKStrListIndexedPtr

Definition at line 683 of file XmlStream.h.

typedef XmlElementKKStrList* KKB::XmlElementKKStrListPtr

Definition at line 679 of file XmlStream.h.

typedef XmlElementKKStr* KKB::XmlElementKKStrPtr

Definition at line 670 of file XmlStream.h.

typedef XmlElement::XmlElementPtr KKB::XmlElementPtr

Definition at line 21 of file XmlStream.h.

typedef XmlElementUnKnown* KKB::XmlElementUnKnownPtr

Definition at line 490 of file XmlStream.h.

typedef XmlElementVectorFloat* KKB::XmlElementVectorFloatPtr

Definition at line 927 of file XmlStream.h.

typedef XmlElementVectorInt32* KKB::XmlElementVectorInt32Ptr

Definition at line 926 of file XmlStream.h.

typedef XmlElementTemplate<VectorKKStr> KKB::XmlElementVectorKKStr

Definition at line 674 of file XmlStream.h.

typedef XmlElementVectorKKStr* KKB::XmlElementVectorKKStrPtr

Definition at line 675 of file XmlStream.h.

typedef XmlFactory const* KKB::XmlFactoryConstPtr

summary>To be used for classes that implement default constructor, ReadXML, and WriteXML.

Definition at line 411 of file XmlStream.h.

typedef XmlFactoryManager * KKB::XmlFactoryManagerPtr

Definition at line 30 of file XmlStream.h.

typedef XmlFactory * KKB::XmlFactoryPtr

Definition at line 27 of file XmlStream.h.

typedef XmlStream::XmlStreamPtr KKB::XmlStreamPtr

Definition at line 29 of file Atom.h.

typedef XmlTag const KKB::XmlTagConst

Definition at line 33 of file Atom.h.

typedef XmlTagConst * KKB::XmlTagConstPtr

Definition at line 45 of file KKStr.h.

typedef XmlTag::XmlTagPtr KKB::XmlTagPtr

Definition at line 31 of file Atom.h.

typedef XmlTokenizer* KKB::XmlTokenizerPtr

Definition at line 117 of file XmlTokenizer.h.

typedef XmlToken::XmlTokenPtr KKB::XmlTokenPtr

Summary>Parent class to all XmlElements

remarks> When XmlStream encounters the start of a element it looks up the appropriate ElementFactory that will construct an instance of a XmlElement derived class. The constructor of that class will be provided the XmlTag that starts the element plus a pointer to the XmlStream instance that is reading the XML file. The XmlElement derived classes constructor will the be responsible for creating an instance of the class that the XmnlElement wraps.

Definition at line 18 of file XmlStream.h.

Enumeration Type Documentation

enum KKB::ColorChannels

strong

Enumerator
Red
Green
Blue

Definition at line 64 of file Raster.h.

  {
    Red,
    Green,
    Blue
  };

enum KKB::RBcolor

strong

Enumerator
Red
Black

Definition at line 30 of file RBTree.h.

{Red, Black};

Function Documentation

template<typename T >

T KKB::Calc3TTLQC	(	const vector< T > &	v,
		kkint32	b
	)

Definition at line 235 of file StatisticalFunctions.h.

  {
    kkint32  i = 0;
    kkint32  n = (kkint32)v.size ();
    
    double  squareSun = 0.0;

    vector<T>  sumArray (v.size (), (T)0.0);
    sumArray[0] = v[0];
    for  (i = 1;  i < n;  i++)
      sumArray[i] = sumArray[i - 1] + v[i];

    kkint32  end = n + 1 - (3 * b);

    for  (i = 0;  i < end;  i++)
    {
      T plusSide  = sumArray[i + b - 1];
      T minusSide = 2 * sumArray[i + b + b - 1];
      T plusSide2 = sumArray[i + 2 * b];

      T delta = plusSide - minusSide + plusSide2;
      double  deltaSquared = delta * delta;
      squareSun += deltaSquared;
    }

    double  divisor = 8.0 * (double)b * ((double)n + 1.0 - 3.0 * (double)b);

    double  result = squareSun / divisor;

    return  (T)result;
  }  /* Calc3TTLQC */

template<typename T >

T KKB::CalcBQV	(	const vector< T > &	v,
		kkint32	blockSize
	)

Definition at line 114 of file StatisticalFunctions.h.

  {
    //typedef long double  uld;

    kkint32 zed = 0;
    kkint32 x   = 0;

    double  totalSquare = (T)0.0;

    double  divisorFactor = 1.0 / pow(2.0, blockSize);

    while  (zed < (kkint32)(v.size () - 2 * blockSize))
    {
      T  plusSide  = (T)0.0;
      T  minusSide = (T)0.0;

      double  delta = 0.0;

      for  (x = 0;  x < blockSize;  x++)
      {
        delta += v[zed];
        zed++;
      }
     
      for  (x = 0;  x < blockSize;  x++)
      {
        delta -= v[zed];
        zed++;
      }

      double  deltaSquared = delta * delta;


      totalSquare += divisorFactor * deltaSquared;
    }


    double  result  = pow (2.0, blockSize) * totalSquare / zed;

    return  (T)result;
  }  /* CalcBQV */

template<typename T >

void KKB::CalcMeanAndStdDev	(	const vector< T > &	v,
		T &	mean,
		T &	stdDev
	)

Definition at line 14 of file StatisticalFunctions.h.

  {
    typedef long double  uld;

    if  (v.size () < 1)
    {
      mean   = T (0);
      stdDev = T (0);
      return;
    }

    kkuint32  idx;
    T  total = T(0);

    for  (idx = 0;  idx < v.size ();  idx++)
      total = total + v[idx];

    mean = total / T (v.size ());

    uld   deltaSqrTotal = 0.0;
    uld   deltaSquared  = 0.0;
    uld   delta         = 0.0;
    
    
    for  (idx = 0;  idx < v.size ();  idx++)
    {
      delta = (uld)fabs (mean - v[idx]);
      deltaSquared = delta * delta;
      deltaSqrTotal += deltaSquared;
    }

    uld  varience = deltaSqrTotal / (uld)(v.size ());

    stdDev = (T)sqrt (varience);

    return;
  }  /* CalcMeanAndStdDev */

template<typename T >

T KKB::CalcPQV	(	const vector< T > &	v,
		kkint32	distance
	)

Definition at line 164 of file StatisticalFunctions.h.

  {
    //typedef long double  uld;

    kkint32 x = 0;
    kkint32 y = x + distance;

    double  totalDeltaSquared = 0.0;

    while  (y < (kkint32)v.size ())
    {
      T delta = v[x] - v[y];
      double deltaSquared = delta * delta;
      totalDeltaSquared += deltaSquared;

      x++;
      y++;
    }

    double result = totalDeltaSquared / (2 * (v.size () - distance));

    return  (T)result;
  }  /* CalcPQV */

template<typename T >

T KKB::CalcTTLQC	(	const vector< T > &	v,
		kkint32	b
	)

Definition at line 196 of file StatisticalFunctions.h.

  {
    kkint32  i = 0;
    kkint32  n = (kkint32)v.size ();
    
    double  squareSun = 0.0;

    vector<T>  sumArray (v.size (), (T)0.0);
    sumArray[0] = v[0];
    for  (i = 1;  i < n;  i++)
      sumArray[i] = sumArray[i - 1] + v[i];

    kkint32  end = n + 1 - (2 * b);

    for  (i = 0;  i < end;  i++)
    {
      T plusSide  = sumArray[i + b - 1];
      T minusSide = sumArray[i + b + b - 1] - sumArray[i + b - 1];
      T delta = plusSide - minusSide;
      double  deltaSquared = delta * delta;
      squareSun += deltaSquared;
    }

    double  divisor = 2.0 * (double)b * ((double)n + 1.0 - 2.0 * (double)b);

    double  result = squareSun / divisor;

    return  (T)result;
  }  /* CalcTTLQC */

template<typename T >

void KKB::CalcVectorStats	(	const vector< T > &	v,
		T &	total,
		T &	mean,
		T &	stdDev,
		T &	min,
		T &	max
	)

Definition at line 58 of file StatisticalFunctions.h.

  {
    typedef long double  uld;

    total = 0;

    if  (v.size () < 1)
    {
      mean   = T (0);
      stdDev = T (0);
      min = 0.0;
      max = 0.0;
      return;
    }

    kkuint32  idx;
    total = T(0);

    min = max = v[0];

    for  (idx = 0;  idx < v.size ();  idx++)
    {
      total = total + v[idx];
      if  (v[idx] < min)  min = v[idx];
      if  (v[idx] > max)  max = v[idx];
    }

    mean = total / T (v.size ());

    uld   deltaSqrTotal = 0.0;
    uld   deltaSquared  = 0.0;
    uld   delta         = 0.0;
    
    for  (idx = 0;  idx < v.size ();  idx++)
    {
      delta = (uld)fabs (mean - v[idx]);
      deltaSquared = delta * delta;
      deltaSqrTotal += deltaSquared;
    }

    uld  varience = deltaSqrTotal / (uld)(v.size ());

    stdDev = (T)sqrt (varience);

    return;
  }  /* CalcMeanAndStdDev */

ColorChannels KKB::ColorChannelFromKKStr

(

const KKStr &

s

)

Definition at line 68 of file Raster.cpp.

References Blue, Green, and Red.

{
  char  c = tolower(s.FirstChar());
  if  (c == 'r')  return ColorChannels::Red;
  if  (c == 'g')  return ColorChannels::Green;
  if  (c == 'b')  return ColorChannels::Blue;
  return ColorChannels::Green;
}

KKStr KKB::ColorChannelToKKStr

(

ColorChannels

c

)

Definition at line 56 of file Raster.cpp.

References Blue, Green, and Red.

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

{
  switch  (c)  {
  case  ColorChannels::Red:   return "Red";
  case  ColorChannels::Green: return "Green";
  case  ColorChannels::Blue:  return "Blue";
  default:
    return "";
  }
}

void KKB::DefineImageIoAtExit

(

)

Definition at line 70 of file ImageIO.cpp.

References imageIoAtExitDefined.

Referenced by ReadImageUsingGDI().

{
  if  (!imageIoAtExitDefined)
  {
    atexit (ImageIoFinaleCleanUp);
    imageIoAtExitDefined = true;
  }
}

void KKB::DisplayImage	(	const Raster &	raster,
		const KKStr &	title
	)

Definition at line 99 of file ImageIO.cpp.

References DisplayImage().

{
  DisplayImage (raster);
}

void KKB::DisplayImage

(

const Raster &

image

)

Definition at line 81 of file ImageIO.cpp.

References KKB::Raster::Height(), and KKB::Raster::Width().

Referenced by DisplayImage().

{
  kkint32  col, row;

  for  (row = 0;  row < image.Height (); row++)
  {
    for  (col = 0;  col < image.Width ();  col++)
    {
      cout  <<  image.GetPixelValue ( row, col) << " ";
    }

    cout << std::endl;
  }
}  /* DisplayImage */

HTMLReport &__cdecl KKB::endl

(

HTMLReport &

htmlReport

)

Definition at line 240 of file HTMLReport.cpp.

References KKB::HTMLReport::Append().

{
  htmlReport.Append ("\n");
  return htmlReport;
}

void KKB::FFT	(	float	data[],
		kkuint32	number_of_complex_samples,
		kkint32	isign
	)

Definition at line 143 of file kku_fftw.cpp.

References SWAP().

{
  //variables for trigonometric recurrences
  kkuint32  n = 0;
  kkuint32  mmax = 0;
  kkuint32  m = 0;
  kkuint32  j = 0;
  kkuint32  istep = 0; 
  kkuint32  i = 0;

  float  wtemp  = 0.0;
  float  wr     = 0.0;
  float  wpr    = 0.0;
  float  wpi    = 0.0;
  float  wi     = 0.0;
  float  theta  = 0.0;
  float  tempr  = 0.0;
  float  tempi  = 0.0;

  /*
   * The Bit-Reversal Method
   *
   * First, the original array must be transformed in order to perform the Danielson-Lanzcos 
   * algorithm. For example, the complex[index] will swap places with the 
   * complex[bit-reverse-order-index]. If the index (in binary) is 0b00001, the 
   * bit-reverse-order-index will be 0b10000. In figure 1, you can see what happens to the 
   * data array after the transformation.
   *
   * The implementation of this method according to Numerical Recipes In C goes like this:
   */

  //the complex array is real+complex so the array 
  //as a size n = 2* number of complex samples
  // real part is the data[index] and 
  //the complex part is the data[index+1]
  n = number_of_complex_samples * 2; 

  //binary inversion (note that the indexes 
  //start from 0 witch means that the
  //real part of the complex is on the even-indexes 
  //and the complex part is on the odd-indexes
  j = 0;
  for  (i = 0;  i < n / 2;  i += 2)
  {
    if  (j > i) 
    {
      //swap the real part
      SWAP (data[j],  data[i]);

      //swap the complex part
      SWAP (data[j + 1],data[i + 1]);

      // checks if the changes occurs in the first half
      // and use the mirrored effect on the second half
      if  ((j / 2) < (n / 4))
      {
        //swap the real part
        SWAP (data[(n - (i + 2))], data[(n - (j + 2))]);
        //swap the complex part
        SWAP (data[(n - (i + 2)) + 1], data[(n - (j + 2)) + 1]);
      }
    }
    m = n / 2;
    while  (m >= 2 && j >= m) 
    {
      j -= m;
      m = m / 2;
    }
    j += m;
  }

  //Danielson-Lanzcos routine 
  mmax = 2;
  //external loop
  while  (n > mmax)
  {
    istep = mmax <<  1;
    theta = isign * (2 * (float)PIE / mmax);
    wtemp = sin (0.5f * theta);
    wpr = -2.0f * wtemp * wtemp;
    wpi = sin (theta);
    wr = 1.0f;
    wi = 0.0f;
    //internal loops
    for (m = 1;  m < mmax;  m += 2)
    {
      for (i = m;  i <= n;  i += istep)
      {
        j = i + mmax;
        tempr = wr * data[j - 1] - wi * data[j];
        tempi = wr * data[j]     + wi * data[j - 1];
        data[j - 1] = data[i - 1] - tempr;
        data[j]     = data[i]     - tempi;
        data[i - 1] += tempr;
        data[i]     += tempi;
      }
      wr = (wtemp = wr) * wpr - wi * wpi + wr;
      wi = wi * wpr + wtemp * wpi + wi;
    }
    mmax = istep;
  } 
}  /* FFT */

float KKB::FloatAbs

(

float

f

)

Definition at line 25 of file KKBaseTypes.cpp.

{
  return (float)abs (f);
}

void KKB::ImageIoFinaleCleanUp

(

)

Definition at line 963 of file ImageIO.cpp.

References gdiStarted.

{
  if  (gdiStarted)
  {
    GdiplusShutdown(gdiplusToken);
    gdiStarted = false;
  }
}

bool KKB::IsFinite

(

const float &

f

)

Definition at line 100 of file KKBaseTypes.cpp.

{
  return (std::isfinite(f) != 0);
}

bool KKB::IsFinite

(

const double &

f

)

Definition at line 106 of file KKBaseTypes.cpp.

{
  return (std::isfinite(f) != 0);
}

bool KKB::IsNaN

(

const float &

f

)

Definition at line 86 of file KKBaseTypes.cpp.

{
  bool  notANum = std::isnan (f) != 0;
  return  notANum;
}

bool KKB::IsNaN

(

const double &

d

)

Definition at line 93 of file KKBaseTypes.cpp.

{
  bool  notANum = std::isnan (d) != 0;
  return  notANum;
}

template<typename T >

T* KKB::kkReallocateArray	(	T *	oldA,
		kkint32	oldSize,
		kkint32	newSize
	)

Definition at line 306 of file KKBaseTypes.h.

  {
    T*  newA = new T[newSize];
    kkint32 x = 0;
    while (x < Min(oldSize, newSize))  {
      newA[x] = oldA[x];
      ++x;
    }
    while  (x < Max(oldSize, newSize))  {
      newA[x] = NULL;
      ++x;
    }
    delete[]  oldA;
    oldA = NULL;
    return newA;
  }  /* namespace KKB */

float KKB::LLoydsIndexOfPatchiness

(

const KKB::VectorInt &

bins

)

Definition at line 166 of file StatisticalFunctions.cpp.

{
  // As defined by Andrew Remsen
  // also look at http://www.pmel.noaa.gov/pubs/outstand/stab1646/statistics.shtml

  if  (bins.size () < 1)
    return  0.0f;

  kkuint32  x;
  double  total = 0.0;
  double  mean  = 0.0;

  for  (x = 0;  x < bins.size ();  x++)
    total += bins[x];

  mean = total / double (bins.size ());

  double  totalDeltaSquared = 0.0;

  for  (x = 0;  x < bins.size ();  x++)
  {
    double  delta = double (bins[x]) - mean;
    totalDeltaSquared += delta * delta;
  }

  double  var = totalDeltaSquared / bins.size ();


  double  varDivMean = var / mean;
  double  oneDivMean = 1.0 / mean;

  float p =  float ((varDivMean - 1.0 + mean) * oneDivMean);

  return  p;
}  /* LLoydsIndexOfPatchiness */

float KKB::Log2

(

float

x

)

Definition at line 250 of file kku_fftw.cpp.

{
  return  log10 (x) / log10 (2.0f);
}

kkint32 KKB::LRand48

(

)

A implementations of the Unix version of rand48 returning a 32 bit integer.

Definition at line 36 of file KKBaseTypes.cpp.

References _lrand48_sequence.

Referenced by KKMLL::FeatureNumList::RandomlySelectFeatures().

{
  static const kkint64 a = 0x5DEECE66DLL;
  static const kkint64 c = 0xBLL;
  static const kkint64 m = 281474976710656LL;
  kkint64 mask = 281474976710655LL;

  _lrand48_sequence = ( ((a * _lrand48_sequence) & mask) + c ) % m;
  return (kkint32)(_lrand48_sequence >> 17);
}

template<class T >

T KKB::Max	(	T	a,
		T	b
	)

generic Max function, Both parameters must be of the same type.

Definition at line 181 of file KKBaseTypes.h.

  {
    if  (a >= b)
      return  a;
    else
      return  b;
  }

template<class T >

T KKB::Max	(	T	a,
		T	b,
		T	c
	)

Generic Max function, that takes three parameters. All three parameters must be of the same type.

Definition at line 195 of file KKBaseTypes.h.

  {
    if  ((a >= b)  &&  (a >= c))
      return  a;

    if  (b >= c)
      return b;
    else
      return c;
  }

template<class T >

T KKB::Max	(	T	a,
		T	b,
		T	c,
		T	d
	)

Generic Max function, that takes four parameters. All four parameters must be of the same type.

Definition at line 213 of file KKBaseTypes.h.

  {
    return  Max (Max (a, b), Max (c, d));
  }

template<class T >

T KKB::Max	(	T	x0,
		T	x1,
		T	x2,
		T	x3,
		T	x4
	)

Generic Max function, that takes five parameters of the same type.

Definition at line 225 of file KKBaseTypes.h.

  {
    return Max (Max(x0, x1, x2, x3), x4);
  }

template<class T >

T KKB::Max	(	T	x0,
		T	x1,
		T	x2,
		T	x3,
		T	x4,
		T	x5
	)

Generic Max function, that takes six parameters of the same type.

Definition at line 233 of file KKBaseTypes.h.

  {
    return Max (Max(x0, x1, x2), Max (x3, x4, x5));
  }

template<class T >

T KKB::Max	(	T	x0,
		T	x1,
		T	x2,
		T	x3,
		T	x4,
		T	x5,
		T	x6
	)

Generic Max function, that takes seven parameters of the same type.

Definition at line 240 of file KKBaseTypes.h.

  {
    return Max (Max(x0, x1, x2, x3), Max (x4, x5, x6));
  }

template<class T >

T KKB::Max	(	T	x0,
		T	x1,
		T	x2,
		T	x3,
		T	x4,
		T	x5,
		T	x6,
		T	x7
	)

Generic Max function, that takes eight parameters of the same type.

Definition at line 248 of file KKBaseTypes.h.

  {
    return Max (Max(x0, x1, x2, x3), Max (x4, x5, x6, x7));
  }

float KKB::McNemarsTest	(	kkint32	size,
		const bool *	classedCorrectly1,
		const bool *	classedCorrectly2
	)

Definition at line 109 of file StatisticalFunctions.cpp.

{
  kkint32  n00 = 0;
  kkint32  n01 = 0;
  kkint32  n10 = 0;
  kkint32  n11 = 0;

  kkint32  x;

  for  (x = 0;  x < size;  x++)
  {
    bool  ca = classedCorrectly1[x];
    bool  cb = classedCorrectly2[x];

    if  (!ca && !cb)
      n00++;   // true neg.

    else if  (!ca && cb)
      n01++;   // false pos.

    else if  (ca && !cb)
      n10++;   // false neg.

    else if  (ca && cb)
      n11++;   // true pos
  }

  float y = (float)fabs ((float)(n01 - n10)) - 1.0f;    // (false pos - false neg) - 1.0;

  float  mcNemars = 0.0;
  float  divisor = (float)n01 + (float)n10;

  if  (divisor != 0.0f)
    mcNemars =  y * y / divisor;

  return  mcNemars;
}  /* McNemarsTest */

template<class T >

T KKB::Min	(	T	a,
		T	b
	)

Generic Min function, Both parameters must be of the same type.

Definition at line 168 of file KKBaseTypes.h.

  {
    if  (a <= b)
      return  a;
    else
      return  b;
  }

KKStr KKB::operator+	(	const char	left,
		const KKStr &	right
	)

Definition at line 3964 of file KKStr.cpp.

References KKB::KKStr::Append(), KKB::KKStr::Concat(), KKB::KKStr::KKStr(), and KKB::KKStr::Len().

{
  KKStr  result (right.Len () + 3);
  result.Append (left);
  result.Append (right);
  return  result;
}

KKStr KKB::operator+	(	const char *	left,
		const KKStr &	right
	)

Definition at line 3976 of file KKStr.cpp.

References KKB::KKStr::Concat(), KKB::KKStr::KKStr(), and KKB::KKStr::operator+().

Referenced by KKB::KKStr::Append(), KKB::BmpImage::BlueRow(), KKMLL::GrayScaleImagesFVProducer::ComputeFeatureVector(), KKMLL::Model::CreateAModel(), KKLSC::ScannerFile::CreateGoalie(), KKMLL::ModelSvmBase::Description(), KKMLL::ModelOldSVM::Description(), KKMLL::ModelDual::Description(), KKB::GoalKeeperSimple::EndBlock(), KKB::GoalKeeper::EndBlock(), KKMLL::FeatureFileIOColumn::GetFileDesc(), KKMLL::FeatureFileIOUCI::GetFileDesc(), KKMLL::FeatureFileIOSparse::GetFileDesc(), KKB::BmpImage::ImageRow(), KKB::KKStr::KKStr(), KKB::MsgQueue::MsgQueue(), osSubstituteInEnvironmentVariables(), KKMLL::ClassProbList::PushOnBack(), KKMLL::ClassProbList::PushOnFront(), KKB::RasterBuffer::RasterBuffer(), KKB::BmpImage::RedRow(), KKB::KKStr::RightPad(), KKB::BmpImage::Save(), KKB::BmpImage::SaveGrayscaleInverted4Bit(), KKB::BmpImage::SaveGrayscaleInverted8Bit(), SaveImage(), SaveImageGrayscaleInverted4Bit(), SaveImageGrayscaleInverted8Bit(), SaveImagePNG(), SaveImagePPM(), KKB::Raster::SegmentImage(), KKB::KKStr::StrReplace(), KKMLL::ModelParam::ToCmdLineStr(), KKB::PixelValue::ToStr(), KKMLL::SVMparam::ToString(), tqli(), KKMLL::ModelSvmBase::TrainModel(), KKMLL::ModelDual::TrainModel(), Tred2(), KKB::KKStr::Wide(), KKMLL::SVMModel::WriteXML(), and KKB::XmlElementArrayFloat2DVarying::WriteXML().

{
  return  KKStr (left) + right;
}

Matrix KKB::operator-	(	double	left,
		const Matrix &	right
	)

Definition at line 456 of file Matrix.cpp.

References KKB::Matrix::Matrix(), KKB::Matrix::NumOfCols(), and KKB::Matrix::NumOfRows().

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

{
  kkint32  numOfRows = right.NumOfRows ();
  kkint32  numOfCols = right.NumOfCols ();
  kkint32  totNumCells = right.totNumCells;

  Matrix  result (numOfRows, numOfCols);
  double*  resultDataArea = result.dataArea;
  double*  rightDataArea  = right.dataArea;

  for  (kkint32 x = 0;   x < totNumCells;  ++x)
    resultDataArea[x] = left - rightDataArea[x];

  return  result;
}  /* operator- */

HTMLReport &__cdecl KKB::operator<<	(	KKB::HTMLReport &	htmlReport,
		KKB::HTMLReport &	__cdecl *mf)(HTMLReport &
	)

Definition at line 230 of file HTMLReport.cpp.

{
  mf (htmlReport);
  return  htmlReport;
}

HTMLReport & KKB::operator<<	(	HTMLReport &	htmlReport,
		kkint32	right
	)

Definition at line 106 of file HTMLReport.cpp.

References KKB::HTMLReport::Append(), KKB::KKStr::Concat(), KKB::KKStr::KKStr(), KKB::KKStr::operator=(), KKB::KKStr::Str(), and StrFormatInt().

{
  KKStr  s (30);
  s = StrFormatInt (right, "0");
  htmlReport.Append (s.Str ());
  return  htmlReport;
}

HTMLReport & KKB::operator<<	(	HTMLReport &	htmlReport,
		kkuint32	right
	)

Definition at line 118 of file HTMLReport.cpp.

References KKB::HTMLReport::Append(), KKB::KKStr::Concat(), KKB::KKStr::KKStr(), KKB::KKStr::operator=(), KKB::KKStr::Str(), and StrFormatInt().

{
  KKStr  s (30);
  s = StrFormatInt (right, "0");
  htmlReport.Append (s.Str ());
  return  htmlReport;
}

HTMLReport & KKB::operator<<	(	HTMLReport &	htmlReport,
		kkint64	right
	)

Definition at line 130 of file HTMLReport.cpp.

References KKB::HTMLReport::Append(), KKB::KKStr::Concat(), KKB::KKStr::KKStr(), KKB::KKStr::operator=(), KKB::KKStr::Str(), and StrFormatInt64().

{
  KKStr  s (30);
  s = StrFormatInt64 (right, "0");
  htmlReport.Append (s.Str ());
  return  htmlReport;
}

HTMLReport & KKB::operator<<	(	HTMLReport &	htmlReport,
		kkuint64	right
	)

Definition at line 142 of file HTMLReport.cpp.

References KKB::HTMLReport::Append(), KKB::KKStr::Concat(), KKB::KKStr::KKStr(), KKB::KKStr::operator=(), KKB::KKStr::Str(), and StrFormatInt64().

{
  KKStr  s (30);
  s = StrFormatInt64 (right, "0");
  htmlReport.Append (s.Str ());
  return  htmlReport;
}

HTMLReport & KKB::operator<<	(	HTMLReport &	htmlReport,
		double	right
	)

Definition at line 154 of file HTMLReport.cpp.

References KKB::HTMLReport::Append().

{
  char  buff[50];

# ifdef  USE_SECURE_FUNCS
    sprintf_s (buff, sizeof (buff), "%f", right);
# else
    sprintf (buff, "%f", right);
# endif

  htmlReport.Append (buff);
  return  htmlReport;
}

HTMLReport & KKB::operator<<	(	HTMLReport &	htmlReport,
		char	right
	)

Definition at line 172 of file HTMLReport.cpp.

References KKB::HTMLReport::Append().

{
  char  buff[20];
  buff[0] = right;
  buff[1] = 0;
  htmlReport.Append (buff);
  return  htmlReport;
}

HTMLReport & KKB::operator<<	(	HTMLReport &	htmlReport,
		const char *	right
	)

Definition at line 185 of file HTMLReport.cpp.

References KKB::HTMLReport::Append().

{
  htmlReport.Append (right);
  return  htmlReport;
}

KKStr & KKB::operator<<	(	KKStr &	left,
		const Point &	right
	)

Definition at line 265 of file Point.cpp.

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

{
  left << "[" << right.Row () << ", " <<  right.Col () << "]";
  return  left;
}

HTMLReport & KKB::operator<<	(	HTMLReport &	htmlReport,
		const KKStr &	right
	)

Definition at line 196 of file HTMLReport.cpp.

References KKB::HTMLReport::Append(), and KKB::KKStr::Str().

{
  htmlReport.Append (right.Str ());
  return  htmlReport;
}

ostream & KKB::operator<<	(	std::ostream &	left,
		const Point &	right
	)

Definition at line 275 of file Point.cpp.

References KKB::Point::Col(), operator<<(), and KKB::Point::Row().

{
  left << "[" << right.Row () << ", " <<  right.Col () << "]";
  return  left;
}

HTMLReport & KKB::operator<<	(	HTMLReport &	htmlReport,
		KKStrConstPtr	right
	)

Definition at line 207 of file HTMLReport.cpp.

References KKB::HTMLReport::Append(), and KKB::KKStr::Str().

{
  if  (right)
    htmlReport.Append (right->Str ());
  return  htmlReport;
}

HTMLReport & KKB::operator<<	(	HTMLReport &	htmlReport,
		const DateTime &	right
	)

Definition at line 218 of file HTMLReport.cpp.

References KKB::HTMLReport::Append(), KKB::KKStr::Concat(), KKB::DateTime::Date(), KKB::TimeType::HH_MM_SS(), KKB::KKStr::operator+(), KKB::KKStr::Str(), KKB::DateTime::Time(), and KKB::DateType::YYYY_MM_DD().

{
  KKStr s = right.Date ().YYYY_MM_DD () + "-" + right.Time ().HH_MM_SS ();
  htmlReport.Append (s.Str ());
  return  htmlReport;
}

KKStr & KKB::operator<<	(	KKB::KKStr &	left,
		const DateType &	right
	)

Definition at line 737 of file DateTime.cpp.

References KKB::DateType::YYYY_MMM_DD().

{
  left << right.YYYY_MMM_DD ();
  return  left;
}

KKStr & KKB::operator<<	(	KKB::KKStr &	left,
		const TimeType &	right
	)

Definition at line 969 of file DateTime.cpp.

References KKB::TimeType::Hour(), KKB::TimeType::Minute(), KKB::TimeType::Second(), and StrFormatInt().

{
  left << StrFormatInt (right.Hour   (), "00") << ":"
       << StrFormatInt (right.Minute (), "00") << ":"
       << StrFormatInt (right.Second (), "00");

  return  left;
}

KKStr & KKB::operator<<	(	KKB::KKStr &	left,
		const DateTime &	right
	)

Definition at line 1319 of file DateTime.cpp.

References KKB::DateTime::Date(), and KKB::DateTime::Time().

{
  left << right.Date () << "-" << right.Time ();
  return left;
}

std::ostream & KKB::operator<<	(	std::ostream &	os,
		const DateType &	right
	)

Definition at line 747 of file DateTime.cpp.

References operator<<(), and KKB::DateType::YYYY_MMM_DD().

{
  os << right.YYYY_MMM_DD ();
  return  os;
}

std::ostream & KKB::operator<<	(	std::ostream &	os,
		const TimeType &	right
	)

Definition at line 982 of file DateTime.cpp.

References KKB::TimeType::Hour(), KKB::TimeType::Minute(), operator<<(), KKB::TimeType::Second(), and StrFormatInt().

{
  os << StrFormatInt (right.Hour   (), "00") << ":"
     << StrFormatInt (right.Minute (), "00") << ":"
     << StrFormatInt (right.Second (), "00");

  return  os;
}

std::ostream & KKB::operator<<	(	std::ostream &	os,
		const DateTime &	right
	)

Definition at line 1330 of file DateTime.cpp.

References KKB::DateTime::Date(), operator<<(), and KKB::DateTime::Time().

{
  os << right.Date () << "-" << right.Time ();
  return  os;
}

std::ostream& __cdecl KKB::operator<<	(	std::ostream &	os,
		const KKStr &	str
	)

Referenced by KKB::RunLog::Append(), KKMLL::FileDesc::Cardinality(), operator<<(), KKMLL::operator<<(), operator<<(), KKB::BmpImage::Print(), KKMLL::ConfusionMatrix2::PrintConfusionMatrixNarrow(), KKMLL::SizeDistribution::ClassTotals::PrintFormatedLine(), KKB::Histogram::PrintTable(), KKMLL::FeatureVectorList::ReSyncSymbolicData(), KKMLL::FeatureFileIORoberts::SaveFile(), KKMLL::FeatureFileIOUCI::SaveFile(), KKMLL::FeatureFileIOC45::SaveFile(), KKMLL::FeatureFileIOSparse::SaveFile(), Test2(), SVM289_BFS::svm_model::Write(), KKB::VectorKKStr::WriteXML(), KKMLL::FeatureNumList::WriteXML(), KKB::XmlTag::WriteXML(), KKB::XmlContent::WriteXml(), KKB::XmlElementKeyValuePairs::WriteXML(), KKB::KKStrList::WriteXML(), and KKB::KKStrListIndexed::WriteXML().

std::istream &__cdecl KKB::operator>>	(	std::istream &	is,
		KKStr &	str
	)

Definition at line 4287 of file KKStr.cpp.

References KKB::KKStr::operator=(), KKB::KKStr::TrimLeft(), and KKB::KKStr::TrimRight().

{
  char  buff[10240];
  is >> buff;
  str = buff;
  str.TrimLeft ();
  str.TrimRight ();
  return  is;
}

void KKB::osAddLastSlash

(

KKStr &

fileSpec

)

Will add the appropriate Directory separator character to the end of fileSpec if one is not there already.

Definition at line 1045 of file OSservices.cpp.

References KKB::KKStr::LastChar().

Referenced by KKMLL::FeatureFileIO::LoadInSubDirectoryTree(), osCopyFileBetweenDirectories(), osMakeFullFileName(), KKMLL::GrayScaleImagesFVList::RecalcFeatureValuesFromImagesInDirTree(), and KKB::Raster::SegmentImage().

{
  char  c = fileSpec.LastChar ();

  if  ((c != '\\')  &&  (c != '/'))
    fileSpec << DS;
}  /* osAddLastSlash */

KKStr KKB::osAddSlash

(

const KKStr &

fileSpec

)

Definition at line 1055 of file OSservices.cpp.

References KKB::KKStr::Concat(), KKB::KKStr::KKStr(), and KKB::KKStr::LastChar().

Referenced by KKLSC::Variables::ConfigurationDir(), KKMLL::TrainingConfiguration2::CreateFromDirectoryStructure(), KKMLL::TrainingClass::ExpandedDirectory(), KKMLL::FeatureFileIO::FeatureDataReSink(), KKMLL::TrainingConfiguration2::GetEffectiveConfigFileName(), KKMLL::FeatureFileIO::LoadInSubDirectoryTree(), KKMLL::TrainingConfiguration2::LoadOtherClasssExamples(), osCreateUniqueFileName(), osGetListOfFilesInDirectoryTree(), osLookForFile(), KKLSC::Variables::ScannerFilesDefaultDir(), KKMLL::KKMLVariables::TempDir(), KKMLL::KKMLVariables::TrainingLibrariesDir(), and KKMLL::KKMLVariables::TrainingModelsDir().

{
  KKStr  result (fileSpec);
  if  ((result.LastChar () != '\\')  &&  (result.LastChar () != '/'))
     result << DS;
  return  result;
}  /* OsAddLastSlash */

void KKB::osChangeDir	(	const KKStr &	dirName,
		bool &	successful
	)

Definition at line 793 of file OSservices.cpp.

{
#ifdef  WIN32


  BOOL  changeOk = SetCurrentDirectory(dirName.Str ());
  if  (changeOk)
    successful = true;
  else
    successful = false;

#else
  kkint32 errorCd = chdir (dirName.Str ());
  successful = (errorCd == 0);

  if  (!successful)
  {
    cerr << std::endl << std::endl << std::endl
         << "osChangeDir  *** ERROR ***   DirPath[" << dirName << "]" << std::endl
         << std::endl;
  }

#endif


  return;
}  /* osChangeDir */

bool KKB::osCopyFile	(	const KKStr &	srcFileName,
		const KKStr &	destFileName
	)

Definition at line 689 of file OSservices.cpp.

References KKB::KKStr::Concat().

{
  BOOL    fail = 1;
  
  bool  result = (CopyFile (srcFileName.Str (),
                            destFileName.Str (),
                            fail)  != 0);


  if  (result)
  {
    return true;
  }

  else 
  {
    DWORD lastError = GetLastError ();

    KKStr  errorMessage = StrFormatInt (lastError, "#,###,##0");

    cerr << std::endl
         << "osCopyFile    *** ERROR ***"                          << std::endl
         << "               srcFileName [" << srcFileName  << "]"  << std::endl
         << "               destFileName[" << destFileName << "]"  << std::endl
         << "               Error Code  [" << lastError    << "]"  << std::endl
         << "               Error Msg   [" << errorMessage << "]"  << std::endl;
    return false;
  }
}

bool KKB::osCopyFileBetweenDirectories	(	const KKStr &	_fileName,
		const KKStr &	_srcDir,
		const KKStr &	_destDir
	)

Definition at line 643 of file OSservices.cpp.

References KKB::KKStr::Concat(), KKB::KKStr::KKStr(), and osAddLastSlash().

{
  KKStr  existingFile (_srcDir);
  KKStr  destinationName (_destDir);
  BOOL    fail = 1;
  
  osAddLastSlash (existingFile);
  existingFile    <<  _fileName;

  osAddLastSlash (destinationName);
  destinationName << _fileName;
  
  bool  result = (CopyFile (existingFile.Str (),
                            destinationName.Str (),
                            fail)  != 0);

  if  (result)
    return true;
  else 
    return false;
}

bool KKB::osCreateDirectory

(

const KKStr &

dirName

)

Definition at line 875 of file OSservices.cpp.

Referenced by osCreateDirectoryPath().

{
  #ifdef  WIN32
    return  (CreateDirectory (_dirName.Str (), NULL) != 0);
  
  #else  
      
    kkint32  result;

    mode_t mode  = S_IRWXU + S_IRWXG;

    result = mkdir (_dirName.Str (), mode);
    return result == 0;

  #endif 
}

bool KKB::osCreateDirectoryPath

(

KKStr

_pathName

)

Will create the whole Directory Path not just the final part of the path.

For example if you need a directory path "C:\\Temp\\Temple\\DataFiles" created this function will create a directory in the specified path if they do not already exists.

Definition at line 825 of file OSservices.cpp.

References KKB::KKStr::Concat(), KKB::KKStr::Empty(), KKB::KKStr::ExtractToken(), KKB::KKStr::FirstChar(), KKB::KKStr::LastChar(), KKB::KKStr::operator=(), osCreateDirectory(), osValidDirectory(), and KKB::KKStr::SubStrPart().

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

{
  KKStr  nextPartOfPath;

  if  (_pathName.FirstChar () == DSchar)
  {
    nextPartOfPath = DS;
    _pathName = _pathName.SubStrPart (1);
    nextPartOfPath << _pathName.ExtractToken (DS);
  }
  else
  {
    nextPartOfPath = _pathName.ExtractToken (DS);
  }

  KKStr  pathNameSoFar;

  while  (!nextPartOfPath.Empty ())
  {
    if  (!pathNameSoFar.Empty ())
    {
      if  (pathNameSoFar.LastChar () != DSchar)
        pathNameSoFar << DS;
    }

    pathNameSoFar << nextPartOfPath;

    if  (!KKB::osValidDirectory (pathNameSoFar))
    {
      bool  createdSucessfully = osCreateDirectory (pathNameSoFar);
      if  (!createdSucessfully)
      {
        cerr << std::endl 
             << "osCreateDirectoryPath   Error Creating Directory[" << pathNameSoFar << "]"
             << std::endl;
        return  false;
      }
    }

    nextPartOfPath = _pathName.ExtractToken (DS);
  }


  return  true;
}  /* osCreateDirectoryPath */

KKStr KKB::osCreateUniqueFileName

(

KKStr

fileName

)

Get a unique file name based off file spec 'fileName'.

Make sure that fileName is unique, if file name already is used will add a sequence num to the root part of the name, starting with 0 and incrementing until file name is unique.

Definition at line 2226 of file OSservices.cpp.

References KKB::KKStr::Concat(), KKB::KKStr::Empty(), KKB::KKStr::operator+(), KKB::KKStr::operator=(), osAddSlash(), osFileExists(), osParseFileName(), and StrFormatInt().

{
  if  (fileName.Empty ())
    fileName = "Temp.txt";

  KKStr   dirPath, rootName, extension;

  osParseFileName (fileName, dirPath, rootName, extension);

  kkint32  seqNum = 0;
  bool  fileNameExists = osFileExists (fileName);
  while  (fileNameExists)
  {
    if  (dirPath.Empty ())
    {
      fileName = rootName + "_" + StrFormatInt (seqNum, "ZZ00") + "." + extension;
    }
    else
    {
      fileName = osAddSlash (dirPath) + 
                 rootName + "_" + StrFormatInt (seqNum, "ZZ00") + 
                 "." + extension;
    }

    fileNameExists = osFileExists (fileName);
    seqNum++;
  }

  return  fileName;
}  /* osCreateUniqueFileName */

bool KKB::osDeleteFile

(

KKStr

_fileName

)

Definition at line 523 of file OSservices.cpp.

References KKB::KKStr::Str().

{
  #ifdef  WIN32
 
  const char*  fileName = _fileName.Str ();

  if  (DeleteFile (fileName))
  {
    return  true;
  }
  else
  {
    DWORD fileAttributes = GetFileAttributes (fileName);
    fileAttributes = FILE_ATTRIBUTE_NORMAL;
    if  (!SetFileAttributes (fileName, fileAttributes))
    {
      return  false;
    }

    else
    {
      // At this point we can either delete this file or not.
      return  (DeleteFile (fileName) != 0);
    }
  }


  #else
  kkint32  returnCd;

  // We are in Unix Environment.
  returnCd = unlink (_fileName.Str ());
  return  (returnCd == 0);
  #endif  
}  /* DeleteFile */

void KKB::osDisplayWarning

(

KKStr

_message

)

Definition at line 2131 of file OSservices.cpp.

Referenced by KKMLL::FeatureVectorList::BinarySearchByName(), and KKMLL::FeatureVectorList::ExtractExamplesForAGivenClass().

{
  MessageBox (NULL,
              _message.Str (),
              "Warning",
              (MB_OK + MB_SETFOREGROUND)
             );
/*
  cerr << endl
       << "    *** WARNING ***" << endl
       << endl 
       << _message << endl
       << endl;
  osWaitForEnter ();
*/
}

bool KKB::osFileExists

(

const KKStr &

_fileName

)

Definition at line 568 of file OSservices.cpp.

References KKB::KKStr::Str().

Referenced by KKMLL::TrainingConfiguration2::ConfigFileExists(), KKMLL::TrainingConfiguration2::CreateFromDirectoryStructure(), KKLSC::ScannerFile::CreateScannerFileForOutput(), KKMLL::TrainingConfiguration2::GetEffectiveConfigFileName(), KKJobManagment::KKJobManager::InitilizeJobManager(), KKMLL::TrainingProcess2::LoadExistingTrainingProcess(), KKMLL::FeatureFileIOC45::LoadFeatureFile(), KKMLL::Orderings::Orderings(), and osCreateUniqueFileName().

{
  const char* fileName = _fileName.Str ();

  #define INVALID_FILE_ATTRIBUTES ((DWORD)-1)

  DWORD fileAttributes = GetFileAttributes (fileName);
  if  (fileAttributes == INVALID_FILE_ATTRIBUTES)
  {
    // Error getting Attributes.  File may not exist.
      DWORD  lastErrorNum = GetLastError ();
      if  ((lastErrorNum == ERROR_FILE_NOT_FOUND)  ||  (lastErrorNum == 3))
        return false;
  }

  return  true;
}

FILE * KKB::osFOPEN	(	const char *	fileName,
		const char *	mode
	)

Definition at line 74 of file OSservices.cpp.

Referenced by KKB::BmpImage::BmpImage(), KKLSC::ScannerFile::GuessFormatOfFile(), KKMLL::FeatureNumList::Load(), KKMLL::MLClassList::Load(), KKB::Configuration::LoadFile(), KKLSC::ScannerFile::LoadIndexFile(), KKLSC::ScannerFile::Open(), KKMLL::FeatureVectorList::OrderUsingNamesFromAFile(), ReadImagePGM(), ReadImagePPM(), KKB::BmpImage::Save(), KKB::BmpImage::SaveGrayscaleInverted4Bit(), KKB::BmpImage::SaveGrayscaleInverted8Bit(), SaveImagePGM(), SaveImagePNG(), and SaveImagePPM().

{
  FILE*  f = NULL;

# ifdef  USE_SECURE_FUNCS
    fopen_s (&f, fileName, mode);
# else
    f = fopen (fileName, mode);
# endif

  return  f;
}

int KKB::osFSEEK	(	FILE *	f,
		kkint64	offset,
		int	origin
	)

Definition at line 104 of file OSservices.cpp.

{
#if  defined(OS_WINDOWS)
  return  _fseeki64(f, offset, origin);
#else
  return  fseeko (f, offset, origin);
#endif
}

kkint64 KKB::osFTELL

(

FILE *

f

)

Calls the appropriate 64 bit function for operating system.

Definition at line 93 of file OSservices.cpp.

Referenced by KKLSC::ScannerFile::BuildFrameOffsets(), KKLSC::ScannerFile::InitiateWritting(), KKLSC::ScannerFileSimple::ReadBufferFrame(), KKLSC::ScannerFile2BitEncoded::ReadBufferFrame(), KKLSC::ScannerFile3BitEncoded::ReadBufferFrame(), KKLSC::ScannerFile4BitEncoded::ReadBufferFrame(), KKLSC::ScannerFile::Reset(), KKLSC::ScannerFile::ScannerFile(), KKLSC::ScannerFileSimple::SkipToNextFrame(), KKLSC::ScannerFileSimple::WriteBufferFrame(), KKLSC::ScannerFile2BitEncoded::WriteBufferFrame(), KKLSC::ScannerFile3BitEncoded::WriteBufferFrame(), KKLSC::ScannerFile4BitEncoded::WriteBufferFrame(), KKLSC::ScannerFileZLib3BitEncoded::WriteTextBlock(), KKLSC::ScannerFile2BitEncoded::WriteTextBlock(), KKLSC::ScannerFile3BitEncoded::WriteTextBlock(), and KKLSC::ScannerFile4BitEncoded::WriteTextBlock().

{
#if  defined(OS_WINDOWS)
  return  _ftelli64 (f);
#else
  return  ftello( f);
#endif
}

KKStr KKB::osGetCurrentDirectory

(

)

Definition at line 319 of file OSservices.cpp.

References KKB::KKStr::Concat(), and KKB::KKStr::KKStr().

Referenced by KKMLL::TrainingConfiguration2::GetEffectiveConfigFileName().

{
  DWORD    buffLen = 0;
  char*    buff = NULL;
  DWORD    reqLen = 1000;

  while  (reqLen > buffLen)
  {
    buffLen = reqLen;

    if  (buff)
      delete[] buff;

    buff = new char[buffLen];
 
    reqLen = GetCurrentDirectory (buffLen, buff);
  }

  KKStr  curDir (buff);

  delete[] buff;   

  return  curDir;
}  /* GetCurrentDirectory */

KKStr KKB::osGetDirNameFromPath

(

KKStr

dirPath

)

Extracts the final sub-directory name of the fill directory specification.

ex:Input                              Returns
   -----------------------            ----------------------
   c:\an\Example\FileSpec\Romeo       Romeo
   /usr/kkramer/Kinsey/Release_2      Release_2
   /usr/kkramer/Thesis/               Thesis
   /usr/kkramer/Thesis.dat/           Thesis.dat

Parameters

[in]

dirPath

Directory path to get dir name from .

Definition at line 1081 of file OSservices.cpp.

References KKB::KKStr::ChopLastChar(), KKB::KKStr::Concat(), KKB::KKStr::Empty(), KKB::KKStr::LastChar(), KKB::KKStr::operator+(), and osParseFileName().

{
  if  (dirPath.LastChar () == DSchar)
    dirPath.ChopLastChar ();

  KKStr  path, root, ext;
  osParseFileName (dirPath, path, root, ext);
  
  if  (ext.Empty ())
    return  root;
  else
    return  root + "." + ext;
}  /* osGetDirNameFromPath */

char KKB::osGetDriveLetter

(

const KKStr &

pathName

)

Given a full drive with path and name return the drive letter specified.

If not on a Windows system returns x'00'= char(0)

Parameters

[in]

pathName

File path to extract driver letter from.

Returns

Drive Letter ('A' - 'Z').

Definition at line 297 of file OSservices.cpp.

References KKB::KKStr::Len(), and KKB::KKStr::operator[]().

{
#ifndef  WIN32
  return 0;
#else
  if  (pathName.Len () < 3)
    return 0;

  if  (pathName[(kkint16)1] == ':')
    return  pathName[(kkint16)0];

  return 0;
#endif
}  /* osGetDriveLetter */

KKStrPtr KKB::osGetEnvVariable

(

const KKStr &

_varName

)

Definition at line 897 of file OSservices.cpp.

Referenced by KKLSC::Variables::HomeDir(), osGetNumberOfProcessors(), osSubstituteInEnvironmentVariables(), and KKLSC::Variables::SubstituteInEnvironmentVariables().

{
  char    buff[1024];
  DWORD   varLen;

  varLen = GetEnvironmentVariable (_varName.Str (), buff, sizeof (buff));

  if  (varLen == 0)
  {
    return NULL;
  }
  else
  {
    return  new KKStr (buff);
  }
} /* GetEnvVariable */

KKStr KKB::osGetErrorNoDesc

(

kkint32

errorNo

)

Definition at line 45 of file OSservices.cpp.

References KKB::KKStr::Concat(), and KKB::KKStr::operator=().

{
  KKStr  desc;

# ifdef WIN32
#   ifdef  USE_SECURE_FUNCS
      char buff[100];
      buff[0] = 0;
      strerror_s (buff, sizeof (buff), errorNo);
      desc = buff;
#   else
      const char* buff = _sys_errlist[errorNo];
      if  (buff)
        desc = buff;
#   endif
# else
   const char*  buff = strerror (errorNo);
   if  (buff)
     desc = buff;
# endif

  return  desc;
}  /* osGetErrorNoDesc */

DateTime KKB::osGetFileDateTime

(

const KKStr &

fileName

)

Definition at line 2037 of file OSservices.cpp.

Referenced by KKMLL::TrainingProcess2::CreateTrainingProcess(), and KKMLL::FeatureFileIO::FeatureDataReSink().

{
  WIN32_FIND_DATA   wfd;

  HANDLE  handle = FindFirstFile  (fileName.Str (), &wfd);
  if  (handle == INVALID_HANDLE_VALUE)
  {
    return  DateTime (0, 0, 0, 0 ,0 ,0);
  }


  SYSTEMTIME  fileTime;
  SYSTEMTIME  stLocal;


  FileTimeToSystemTime (&(wfd.ftLastWriteTime), &fileTime);
  SystemTimeToTzSpecificLocalTime(NULL, &fileTime, &stLocal);

  return  DateTime ((short)stLocal.wYear, 
                    (uchar)stLocal.wMonth, 
                    (uchar)stLocal.wDay,
                    (uchar)stLocal.wHour,
                    (uchar)stLocal.wMinute,
                    (uchar)stLocal.wSecond
                   );

}  /* osGetFileDateTime */

KKStr KKB::osGetFileExtension

(

KKStr

fullFileName

)

Definition at line 1323 of file OSservices.cpp.

References KKB::KKStr::Concat(), and osParseFileName().

Referenced by KKMLL::TrainingConfiguration2::GetEffectiveConfigFileName(), ReadImage(), SaveImage(), SaveImageGrayscaleInverted4Bit(), SaveImageGrayscaleInverted8Bit(), and SupportedImageFileFormat().

{
  KKStr   fileName, dirPath, rootName, extension;
  osParseFileName (fullFileName, dirPath, rootName, extension);
  return  extension;
}  /* osGetFileExtension */

KKStr KKB::osGetFileNamePartOfFile

(

KKStr

fullFileName

)

osGetFileNamePartOfFile, retrieves the file name part of the file spec.

ex:  Input (fullFileName)                 Returned
     --------------------------------_    ---------------
     c:\KurtUtilities\KKBase\KKStr.cpp    KKStr.cpp
     /bin/usr/KKramer/Dictionary.dat      Dictionary.dat
     dataFile.data                       dataFile.data

Parameters

[in]

fullFileName

Sting that contains the full file name specification.

Returns

File Name.

Definition at line 1471 of file OSservices.cpp.

References KKB::KKStr::Concat(), KKB::KKStr::KKStr(), KKB::KKStr::LastChar(), KKB::KKStr::LocateCharacter(), osLocateLastSlashChar(), and KKB::KKStr::SubStrPart().

{
  if  (fullFileName.LastChar () == DSchar)
    return  KKStr ("");

  kkint32  lastSlash =  osLocateLastSlashChar (fullFileName);
  if  (lastSlash < 0)
  {
   kkint32  colon = fullFileName.LocateCharacter (':');
   if  (colon < 0)
     return fullFileName;
   else
     return fullFileName.SubStrPart (colon + 1);
  }
  else
  {
    return  fullFileName.SubStrPart (lastSlash + 1);
  }
}  /* FileNamePartOfFile */

kkint64 KKB::osGetFileSize

(

const KKStr &

fileName

)

Definition at line 2096 of file OSservices.cpp.

Referenced by KKLSC::ScannerFile::Open().

{
  WIN32_FIND_DATA   wfd;

  HANDLE  handle = FindFirstFile  (fileName.Str (), &wfd);
  if  (handle == INVALID_HANDLE_VALUE)
  {
    return  -1;
  }

  return  (kkint64)(wfd.nFileSizeHigh) * (kkint64)MAXDWORD + (kkint64)(wfd.nFileSizeLow);
}

KKStr KKB::osGetFullPathOfApplication

(

)

returns the name and path of the current running application.

Definition at line 2843 of file OSservices.cpp.

{
#if  defined(WIN32)
  char  szAppPath[MAX_PATH] = "";
  DWORD  result = ::GetModuleFileName (0, szAppPath, MAX_PATH);
  return  szAppPath;
#else
  return  KKStr::EmptyStr ();
#endif
}

KKStr KKB::osGetHostName

(

)

Definition at line 1354 of file OSservices.cpp.

References KKB::KKStr::Concat().

{
#if  defined(OS_WINDOWS)
  char  buff[1024];
  DWORD buffSize = sizeof (buff) - 1;
  memset (buff, 0, sizeof(buff));
 
  KKStr  compName = "";

  //BOOL returnCd = GetComputerNameEx (ComputerNameDnsFullyQualified, buff, &buffSize);
  BOOL returnCd = GetComputerNameA (buff, &buffSize);
  if  (returnCd != 0)
  {
    compName = buff;
  } 
  else 
  {  
    KKStrPtr  compNameStr = osGetEnvVariable ("COMPUTERNAME");
    if  (compNameStr)
    {
      compName = *compNameStr;
      delete compNameStr;
      compNameStr = NULL;
    }
    else
    {
      compName = "";
    }
  }  

  return  compName;  


#else

  char  buff[1024];
  memset (buff, 0, sizeof (buff));
  kkint32  returnCd = gethostname (buff, sizeof (buff) - 2);
  if  (returnCd != 0)
    return "";
  else
    return buff;

#endif
}  /* osGetHostName */

double KKB::osGetKernalTimeUsed

(

)

Definition at line 1938 of file OSservices.cpp.

{
  HANDLE h = GetCurrentProcess ();

  FILETIME   creationTime, exitTime, kernelTime, userTime;

  BOOL  ok = GetProcessTimes (h, &creationTime, &exitTime, &kernelTime, &userTime);

  if  (!ok)
    return 0.0;

  SYSTEMTIME  st;

  FileTimeToSystemTime(&kernelTime, &st);
  double  kt =  st.wHour * 3600 + 
                st.wMinute * 60 + 
                st.wSecond      +
                st.wMilliseconds / 1000.0;


  return  kt;
}  /* osGetSystemTimeUsed */

KKStrListPtr KKB::osGetListOfDirectories

(

KKStr

fileSpec

)

Definition at line 1743 of file OSservices.cpp.

References KKB::KKStrList::KKStrList(), KKB::KKStr::LastChar(), KKB::KKStr::LocateCharacter(), and osValidDirectory().

Referenced by KKMLL::FeatureFileIO::LoadInSubDirectoryTree(), osGetListOfFilesInDirectoryTree(), and osLookForFile().

{
  WIN32_FIND_DATA     wfd;

  
  if  (fileSpec.LastChar () == DSchar)
  {
    fileSpec << "*.*";
  }

  else if  (fileSpec.LocateCharacter ('*') < 0)
  {
    if  (osValidDirectory (&fileSpec))
    {
      fileSpec << "\\*.*";
    }
  }

  KKStrListPtr  nameList = new KKStrList (true);

  HANDLE  handle = FindFirstFile  (fileSpec.Str (),  &wfd);

  if  (handle == INVALID_HANDLE_VALUE)
  {
    delete  nameList;
    return  NULL;
  }


  BOOL  moreFiles = true;
  while  (moreFiles)
  {
    if  ((wfd.dwFileAttributes & FILE_ATTRIBUTE_SYSTEM) == 0)  
    {
      if  ((wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0)
      {
        KKStrPtr dirName = new KKStr (wfd.cFileName);

        if  ((*dirName != ".")  &&  (*dirName != ".."))
          nameList->PushOnBack (dirName);
        else
          delete  dirName;
      }
    }

    moreFiles = FindNextFile (handle, &wfd);
  }

  FindClose (handle);

  return  nameList;
}  /* osGetListOfDirectories */

KKStrListPtr KKB::osGetListOfFiles

(

const KKStr &

fileSpec

)

Returns a list of files that match the provided file specification.

You can provide any file specification including a directory path. If there is a failure will return NULL. The caller will be responsible for deleting the returned list. The file names returned will not include any directory path.

Definition at line 1531 of file OSservices.cpp.

References KKB::KKStrList::KKStrList().

Referenced by KKMLL::FeatureFileIO::FeatureDataReSink(), osGetListOfFilesInDirectoryTree(), osGetListOfImageFiles(), and osLookForFile().

{
  WIN32_FIND_DATA     wfd;

  HANDLE  handle = FindFirstFile  (fileSpec.Str (),  &wfd);

  if  (handle == INVALID_HANDLE_VALUE)
  {
    return  NULL;
  }

  KKStrListPtr  nameList = new KKStrList (true);

  BOOL  moreFiles = true;
  while  (moreFiles)
  {
    if  ((wfd.dwFileAttributes & FILE_ATTRIBUTE_SYSTEM) == 0)  
    {
      if  ((wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == 0)
      {
        nameList->PushOnBack (new KKStr (wfd.cFileName));
      }
    }

    moreFiles = FindNextFile (handle, &wfd);
  }

  FindClose (handle);

  return  nameList;
}  /* osGetListOfFiles */

void KKB::osGetListOfFilesInDirectoryTree	(	const KKStr &	rootDir,
		KKStr	fileSpec,
		VectorKKStr &	fileNames
	)

Definition at line 1668 of file OSservices.cpp.

References KKB::KKStr::Concat(), KKB::KKStr::Empty(), KKB::KKStr::operator+(), KKB::KKStr::operator=(), KKB::KKStr::operator==(), osAddSlash(), osGetListOfDirectories(), osGetListOfFiles(), and osGetListOfFilesInDirectoryTree().

Referenced by osGetListOfFilesInDirectoryTree().

{ 
  if  (fileSpec.Empty ())
    fileSpec = "*.*";

  {
    KKStrListPtr  filesInThisDirectory = osGetListOfFiles (osAddSlash (rootDir) + fileSpec);
    if  (filesInThisDirectory)
    {
      KKStrList::iterator  idx;
      for  (idx = filesInThisDirectory->begin ();  idx != filesInThisDirectory->end ();  idx++)
      {
        KKStrPtr  fn = *idx;
        KKStr  fullName = osAddSlash (rootDir) + (*fn);
        fileNames.push_back (fullName);
      }
      delete  filesInThisDirectory;  filesInThisDirectory = NULL;
    }
  }

  // Lets now process all sub directories below 'rootDir'
  KKStrListPtr  subDirectories = osGetListOfDirectories (osAddSlash (rootDir) + "*.*");
  if  (subDirectories)
  {
    KKStrList::iterator  idx;
    for  (idx = subDirectories->begin ();  idx != subDirectories->end ();  idx++)
    {
      KKStr subDirName = **idx;
      if  ((subDirName == ".")  ||  (subDirName == ".."))
        continue;


      KKStr  dirToSearch = osAddSlash (rootDir) + subDirName;
      osGetListOfFilesInDirectoryTree (dirToSearch, fileSpec, fileNames);
    }

    delete  subDirectories;  subDirectories = NULL;
  }

  return;
}  /* osGetListOfFilesInDirectoryTree */

KKStrListPtr KKB::osGetListOfImageFiles

(

KKStr

fileSpec

)

Definition at line 1717 of file OSservices.cpp.

References KKB::KKStr::Concat(), KKB::KKStrList::KKStrList(), and osGetListOfFiles().

{
  KKStrListPtr  imageFileNames = new KKStrList (true);

  KKStrListPtr filesInDir = osGetListOfFiles (fileSpec);
  if  (filesInDir)
  {
    KKStrList::iterator  fnIDX;
    for  (fnIDX = filesInDir->begin ();  fnIDX != filesInDir->end ();  ++fnIDX)
    {
      KKStr  fileName (**fnIDX);
      if  (SupportedImageFileFormat (fileName))
        imageFileNames->PushOnBack (new KKStr (fileName));
    }

    delete  filesInDir;
    filesInDir = NULL;
  }

  return  imageFileNames;
}  /* osGetListOfImageFiles */

DateTime KKB::osGetLocalDateTime

(

)

Returned the current local date and time.

Definition at line 1993 of file OSservices.cpp.

Referenced by KKB::KKThread::AddMsg(), KKMLL::TrainingProcess2::CreateModelsFromTrainingData(), KKMLL::FeatureFileIO::FeatureDataReSink(), KKB::KKThread::WaitForThreadToStop(), and KKMLL::SVMModel::WriteXML().

{
  SYSTEMTIME  sysTime;

  GetLocalTime(&sysTime);

  DateTime  dateTime ((short)sysTime.wYear,
                      (uchar)sysTime.wMonth,
                      (uchar)sysTime.wDay,
                      (uchar)sysTime.wHour,
                      (uchar)sysTime.wMinute,
                      (uchar)sysTime.wSecond
                     );

  return  dateTime;
}  /* osGetCurrentDateTime */

kkint32 KKB::osGetNumberOfProcessors

(

)

returns the number of CPU's or number of simultaneous threads that you can have.

Definition at line 1449 of file OSservices.cpp.

References osGetEnvVariable(), and KKB::KKStr::ToInt32().

{
#if  defined(OS_WINDOWS)
  KKStrPtr numProcessorsStr = osGetEnvVariable ("NUMBER_OF_PROCESSORS");
  kkuint32  numOfProcessors = -1;
  if  (numProcessorsStr)
  {
    numOfProcessors = numProcessorsStr->ToInt32 ();
    delete  numProcessorsStr;
    numProcessorsStr = NULL;
  }

  return  numOfProcessors;
#else
  /** @todo  Need to implement 'osGetNumberOfProcessors' for linux. */
  return  1;
#endif
}  /* osGetNumberOfProcessors */

KKStr KKB::osGetParentDirectoryOfDirPath

(

KKStr

path

)

Definition at line 1202 of file OSservices.cpp.

References KKB::KKStr::ChopLastChar(), KKB::KKStr::Concat(), KKB::KKStr::EmptyStr(), KKB::KKStr::LastChar(), KKB::KKStr::LocateLastOccurrence(), and KKB::KKStr::SubStrPart().

{
  if  (path.LastChar () == DSchar) 
    path.ChopLastChar ();

  kkint32  x1 = path.LocateLastOccurrence (DSchar);
  kkint32  x2 = path.LocateLastOccurrence (':');

  kkint32  x = Max (x1, x2);
  if  (x < 1)
    return KKStr::EmptyStr ();

  return  path.SubStrPart (0, x);
}  /* osGetParentDirectoryOfDirPath */

KKStr KKB::osGetParentDirPath

(

KKStr

dirPath

)

Returns the Parent directory path to 'dirPath'.

ex:Input                              Returns
   -----------------------            ----------------------
   c:\an\Example\FileSpec\Romeo       c:\an\Example\FileSpec
   /usr/kkramer/Kinsey/Release_2      /usr/kkramer/Kinsey
   /usr/kkramer/Thesis/               /usr/kkramer
   /usr/kkramer/Thesis.dat/           /usr/kkramer

Definition at line 1333 of file OSservices.cpp.

References KKB::KKStr::ChopLastChar(), KKB::KKStr::Concat(), KKB::KKStr::EmptyStr(), KKB::KKStr::LastChar(), KKB::KKStr::LocateLastOccurrence(), and KKB::KKStr::SubStrPart().

{
  if  ((dirPath.LastChar () == '\\')  ||  (dirPath.LastChar () == '/'))
    dirPath.ChopLastChar ();
  
  int x = Max (dirPath.LocateLastOccurrence ('\\'), dirPath.LocateLastOccurrence ('/'));
  
  if  (x < 0)
  {
    x = dirPath.LocateLastOccurrence (':');
    if  (x >= 0)
      return  dirPath.SubStrPart (0, x - 1);
    else
      return  KKStr::EmptyStr ();
  }

  return  dirPath.SubStrPart (0, x - 1);
}

KKStr KKB::osGetPathPartOfFile

(

KKStr

fullFileName

)

Get the path part of a full file name specification.

ex:Input                              Returns
   -----------------------            ----------------------
   c:\an\Example\FileSpec\data.txt    c:\an\Example\FileSpec
   /usr/kkramer/Plankton/Relase_2     /usr/kkramer/Plankton
   /usr/kkramer/Thesis/               /usr/kkramer/Thesis

Parameters

[in]

fullFileName

The full file specification including directory path, root-name, and extension.

Returns

Path part of fullFileName.

Definition at line 1305 of file OSservices.cpp.

References KKB::KKStr::Concat(), KKB::KKStr::KKStr(), KKB::KKStr::LocateLastOccurrence(), osLocateLastSlashChar(), and KKB::KKStr::SubStrPart().

Referenced by KKMLL::TrainingConfiguration2::GetEffectiveConfigFileName().

{
  kkint32  lastSlash =  osLocateLastSlashChar (fullFileName);

  if  (lastSlash >= 0)
  {
    return  fullFileName.SubStrPart (0, lastSlash - 1);
  }

  kkint32  lastColon = fullFileName.LocateLastOccurrence (':');
  if  (lastColon >= 0)
    return  fullFileName.SubStrPart (0, lastColon);
  else
    return  KKStr ("");
}  /* GetPathPartOfFile */

kkint32 KKB::osGetProcessId

(

)

Definition at line 2736 of file OSservices.cpp.

Referenced by GetProcessId().

{
#ifdef  WIN32
  //DWORD WINAPI  processId = GetCurrentProcessId ();
  DWORD processId = GetCurrentProcessId();
  return  processId;

#else
  pid_t processID = getpid ();
  return  processID;

#endif
}

KKStr KKB::osGetProgName

(

)

Definition at line 1402 of file OSservices.cpp.

References KKB::KKStr::Concat().

{
#if  defined(OS_WINDOWS)
  KKStr  progName;

  char filename[ MAX_PATH ];
  DWORD size = GetModuleFileNameA (NULL, filename, MAX_PATH);
  if  (size)
    progName = filename;  
  else
    progName = "";

  return progName;

#else
  return  "NotImplemented";  
#endif
}

KKStr KKB::osGetRootName

(

const KKStr &

fullFileName

)

Definition at line 1154 of file OSservices.cpp.

References KKB::KKStr::Concat(), KKB::KKStr::LocateLastOccurrence(), KKB::KKStr::operator=(), osLocateLastSlashChar(), and KKB::KKStr::SubStrPart().

Referenced by KKLSC::ScannerFile::CreateGoalie(), KKMLL::TrainingProcess2::CreateModelsFromTrainingData(), KKMLL::ModelDual::Description(), KKMLL::DuplicateImage::ExampleWithSmallestScanLine(), KKB::Raster::ExtractChannel(), KKMLL::FeatureVectorList::ExtractDuplicatesByRootImageFileName(), KKMLL::ExtractExampleFileName::ExtractKey(), KKMLL::FeatureFileIO::FeatureDataReSink(), KKLSC::ScannerFileEntry::GetOrCreateScannerFileEntry(), KKMLL::TrainingConfiguration2::Load(), KKMLL::FeatureFileIODstWeb::LoadFile(), KKMLL::FeatureFileIOColumn::LoadFile(), KKMLL::FeatureFileIOUCI::LoadFile(), KKMLL::FeatureFileIOC45::LoadFile(), KKMLL::FeatureFileIOSparse::LoadFile(), KKMLL::TrainingConfiguration2List::LookUp(), KKMLL::FeatureVectorList::LookUpByRootName(), KKMLL::FeatureVectorList::RootNameComparrisonReversed::operator()(), KKLSC::ScannerFile::ScannerFile(), and KKB::Raster::SegmentImage().

{
  kkint32  lastSlashChar = osLocateLastSlashChar (fullFileName);
  kkint32  lastColon     = fullFileName.LocateLastOccurrence (':');

  kkint32  lastSlashOrColon = Max (lastSlashChar, lastColon);
 
  KKStr  lastPart;
  if  (lastSlashOrColon < 0)
  {
    lastPart = fullFileName;
  }
  else
  {
    lastPart = fullFileName.SubStrPart (lastSlashOrColon + 1);
  }

  kkint32  period = lastPart.LocateLastOccurrence ('.');

  if  (period < 0)
    return  lastPart;

  return  lastPart.SubStrPart (0, period - 1);
}  /*  osGetRootName */

KKStr KKB::osGetRootNameOfDirectory

(

KKStr

fullDirName

)

Definition at line 1181 of file OSservices.cpp.

References KKB::KKStr::ChopLastChar(), KKB::KKStr::Concat(), KKB::KKStr::LastChar(), KKB::KKStr::LocateLastOccurrence(), KKB::KKStr::operator=(), osLocateLastSlashChar(), and KKB::KKStr::SubStrPart().

Referenced by KKMLL::TrainingConfiguration2::CreateFromDirectoryStructure(), KKMLL::MLClass::GetClassNameFromDirName(), and KKMLL::FeatureFileIO::LoadInSubDirectoryTree().

{
  if  (fullDirName.LastChar () == DSchar)
    fullDirName.ChopLastChar ();

  kkint32  lastSlashChar = osLocateLastSlashChar (fullDirName);
  kkint32  lastColon     = fullDirName.LocateLastOccurrence (':');

  kkint32  lastSlashOrColon = Max (lastSlashChar, lastColon);
 
  KKStr  lastPart;
  if  (lastSlashOrColon < 0)
    lastPart = fullDirName;
  else
    lastPart = fullDirName.SubStrPart (lastSlashOrColon + 1);

  return  lastPart;
}  /*  osGetRootNameOfDirectory */

KKStr KKB::osGetRootNameWithExtension

(

const KKStr &

fullFileName

)

Definition at line 1219 of file OSservices.cpp.

References KKB::KKStr::Concat(), KKB::KKStr::LocateLastOccurrence(), KKB::KKStr::operator=(), osLocateLastSlashChar(), and KKB::KKStr::SubStrPart().

Referenced by KKMLL::TrainingConfiguration2::GetEffectiveConfigFileName(), and KKMLL::FeatureVectorList::RootNameComparrison::operator()().

{
  kkint32  lastSlashChar = osLocateLastSlashChar (fullFileName);
  kkint32  lastColon     = fullFileName.LocateLastOccurrence (':');

  kkint32  lastSlashOrColon = Max (lastSlashChar, lastColon);
 
  KKStr  lastPart;
  if  (lastSlashOrColon < 0)
  {
    lastPart = fullFileName;
  }
  else
  {
    lastPart = fullFileName.SubStrPart (lastSlashOrColon + 1);
  }

  return  lastPart;
}  /* osGetRootNameWithExtension */

kkuint64 KKB::osGetSystemTimeInMiliSecs

(

)

Returns mili-secs that system (Windows = has been started, Linux time in epoch).

Definition at line 1976 of file OSservices.cpp.

{
  return timeGetTime();
}  /* osGetSystemTimeInMiliSecs */

double KKB::osGetSystemTimeUsed

(

)

Returns the number of CPU seconds used by current process.

This consists of both User and Kernel Time. When used to get timing data of some function, Call this method before and after running the function and use the difference.

Definition at line 1855 of file OSservices.cpp.

Referenced by KKMLL::FeatureEncoder::CompressExamples(), KKJobManagment::KKJobManager::InitilizeJobManager(), KKMLL::Model::TrainingTimeEnd(), KKMLL::Model::TrainingTimeStart(), and KKMLL::Model::TrainModel().

{
  HANDLE h = GetCurrentProcess ();

  FILETIME   creationTime, exitTime, kernelTime, userTime;

  BOOL  ok = GetProcessTimes (h, &creationTime, &exitTime, &kernelTime, &userTime);

  if  (!ok)
    return 0;

  SYSTEMTIME  st;

  FileTimeToSystemTime(&kernelTime, &st);
  double  kt =  st.wHour * 3600 + st.wMinute * 60 + st.wSecond;
  kt += ((double)st.wMilliseconds / 1000.0);

  FileTimeToSystemTime(&userTime, &st);
  double  ut =  st.wHour * 3600 + st.wMinute * 60 + st.wSecond;
  ut += ((double)st.wMilliseconds / 1000.0);

  double  numOfSecs = kt + ut;
  
  // (kernelTime.dwLowDateTime + userTime.dwLowDateTime) / 10000000 + 0.5;
  return  numOfSecs;
}  /* osGetSystemTimeUsed */

kkint32 KKB::osGetThreadId

(

)

Definition at line 2752 of file OSservices.cpp.

Referenced by KKB::KKThread::AddMsg(), KKB::RunLog::Append(), KKB::GoalKeeperSimple::BlockedByAnotherThread(), KKB::GoalKeeper::BlockedByAnotherThread(), KKB::GoalKeeperSimple::EndBlock(), KKB::GoalKeeper::EndBlock(), KKB::GoalKeeperSimple::StartBlock(), and KKB::GoalKeeper::StartBlock().

{
#ifdef  WIN32
  //DWORD WINAPI threadId = GetCurrentThreadId ();
  DWORD threadId = GetCurrentThreadId();
  return  threadId;
#else
  return 0;
#endif
}

KKStr KKB::osGetUserName

(

)

Definition at line 1426 of file OSservices.cpp.

References KKB::KKStr::Concat().

{
#if  defined(OS_WINDOWS)
  TCHAR name [ UNLEN + 1 ];
  DWORD size = UNLEN + 1;

  KKStr  userName = "";
  if  (GetUserName ((TCHAR*)name, &size))
    userName = name;
  else
    userName = "***ERROR***";

  return  userName;
#else

  return "NoImplemented";
#endif
}  /* osGetUserName */

double KKB::osGetUserTimeUsed

(

)

Definition at line 1897 of file OSservices.cpp.

{
  HANDLE h = GetCurrentProcess ();

  FILETIME   creationTime, exitTime, kernelTime, userTime;

  BOOL  ok = GetProcessTimes (h, &creationTime, &exitTime, &kernelTime, &userTime);

  if  (!ok)
    return 0;


  SYSTEMTIME  st;

  FileTimeToSystemTime(&userTime, &st);
  double   ut =  st.wHour * 3600 + 
                 st.wMinute * 60 + 
                 st.wSecond      +
                 st.wMilliseconds / 1000.0;

  return  ut;
}  /* osGetSystemTimeUsed */

template<class T >

T* KKB::osGrowAllocation ( T *  src, kkint32  origSize, kkint32  newSize  )

inline

Definition at line 489 of file OSservices.h.

  {
    kkint32  zed = 0;
    T*  dest = new T[newSize];
    while  (zed < origSize)    {dest[zed] = src[zed];  zed++;}
    while  (zed < newSize)     {dest[zed] = (T)0;      zed++;}
    delete  src;
    return  dest;
  }  /* GrowAllocation */

bool KKB::osIsBackGroundProcess

(

)

Definition at line 1506 of file OSservices.cpp.

References backGroundProcess.

{
  return  backGroundProcess;
}

kkint32 KKB::osLocateFirstSlashChar

(

const KKStr &

fileSpec

)

Definition at line 1027 of file OSservices.cpp.

References KKB::KKStr::LocateCharacter().

{
  kkint32  firstForewardSlash  = fileSpec.LocateCharacter ('/');
  kkint32  firstBackSlash = fileSpec.LocateCharacter ('\\');

  if  (firstForewardSlash < 0)
    return firstBackSlash;

  else if  (firstBackSlash < 0)
    return firstForewardSlash;

  return  Min (firstForewardSlash, firstBackSlash);
}  /* LastSlashChar */

kkint32 KKB::osLocateLastSlashChar

(

const KKStr &

fileSpec

)

Definition at line 1017 of file OSservices.cpp.

References KKB::KKStr::LocateLastOccurrence().

Referenced by osGetFileNamePartOfFile(), osGetPathPartOfFile(), osGetRootName(), osGetRootNameOfDirectory(), osGetRootNameWithExtension(), osParseFileName(), osParseFileSpec(), and osRemoveExtension().

{
  kkint32  lastLeftSlash  = fileSpec.LocateLastOccurrence ('\\');
  kkint32  lastRightSlash = fileSpec.LocateLastOccurrence ('/');

  return  Max (lastLeftSlash, lastRightSlash);
}  /* LastSlashChar */

KKStr KKB::osLookForFile	(	const KKStr &	fileName,
		const KKStr &	srcDir
	)

Look for a specified file in a sub-directory structure.

Parameters

[in]	fileName	Name of file we are looking for.
[in]	srcDir	Sub Directory tree we want to search.

Returns

Full directory path to where first occurrence of fileName is located. If not found will return back an empty string.

Definition at line 2174 of file OSservices.cpp.

References KKB::KKStr::Concat(), KKB::KKStr::Empty(), KKB::KKStr::KKStr(), KKB::KKStr::operator+(), osAddSlash(), osGetListOfDirectories(), osGetListOfFiles(), osLookForFile(), KKB::KKStr::Str(), KKB::KKStr::StrEqualNoCase(), and KKB::KKStr::Upper().

Referenced by osLookForFile().

{
  KKStr  fileNameUpper (fileName);
  fileNameUpper.Upper ();

  KKStr  fileSpec = osAddSlash (srcDir) + fileName;
  //KKStr  fileSpec = osAddSlash (srcDir) + "*.*";

  // We will first look at contents of 'srcDir'  and if not there then look at sub directories
  KKStrListPtr files = osGetListOfFiles (fileSpec);
  if  (files)
  {
    for  (KKStrList::iterator nIDX = files->begin ();  nIDX != files->end ();  nIDX++)
    {
      KKStrPtr  fnPtr = *nIDX;
      if  (KKStr::StrEqualNoCase (fileName.Str (), fnPtr->Str ()))
      {
        delete  files;
        files = NULL;
        return srcDir;
      }
    }
    delete  files;
    files = NULL;
  }

  KKStrListPtr  subDirs = osGetListOfDirectories (srcDir);
  if  (subDirs)
  {
    for  (KKStrList::iterator sdIDX = subDirs->begin ();  sdIDX != subDirs->end ();  sdIDX++)
    {
      KKStr  subDirName = osAddSlash (srcDir) + **sdIDX;
      KKStr  resultDir = osLookForFile (fileName, subDirName);
      if  (!resultDir.Empty ())
      {
        delete  subDirs;
        subDirs = NULL;
        return resultDir;
      }
    }

    delete  subDirs;  subDirs = NULL;
  }

  return "";
}  /* osLookForFile */

KKStr KKB::osMakeFullFileName	(	const KKStr &	_dirName,
		const KKStr &	_fileName
	)

Definition at line 1066 of file OSservices.cpp.

References KKB::KKStr::Concat(), KKB::KKStr::KKStr(), and osAddLastSlash().

{
  KKStr  fullFileName (_dirName);

  osAddLastSlash (fullFileName);

  fullFileName << _fileName;

  return  fullFileName;
}

bool KKB::osMoveFileBetweenDirectories	(	const KKStr &	_fileName,
		const KKStr &	_srcDir,
		const KKStr &	_destDir
	)

Definition at line 609 of file OSservices.cpp.

References KKB::KKStr::Concat(), KKB::KKStr::KKStr(), and KKB::KKStr::LastChar().

{
  #ifdef  WIN32

    KKStr  srcName (_srcDir);
    KKStr  destName (_destDir);

    if  (srcName.LastChar () != '\\')
      srcName  << "\\";
    
    if  (destName.LastChar () != '\\')
      destName << "\\";

    srcName   << _fileName;
    destName  << _fileName;

    return  (MoveFile (srcName.Str (), destName.Str ()) != 0);

  #else
    cerr << std::endl;
    cerr << "*** osMoveFileBetweenDirectories ***" << std::endl;
    cerr << std::endl;
    cerr << "*** Not yet implemented ***" << std::endl;
    osWaitForEnter ();
    exit (-1);
  #endif
}

void KKB::osParseFileName	(	KKStr	_fileName,
		KKStr &	_dirPath,
		KKStr &	_rootName,
		KKStr &	_extension
	)

Definition at line 1097 of file OSservices.cpp.

References KKB::KKStr::LocateLastOccurrence(), KKB::KKStr::operator=(), osLocateLastSlashChar(), and KKB::KKStr::SubStrPart().

Referenced by osCreateUniqueFileName(), osGetDirNameFromPath(), and osGetFileExtension().

{
  kkint32  x;
  
  x = osLocateLastSlashChar (_fileName);

  if  (x < 0)
  {
    _dirPath = "";
  }

  else
  {
    _dirPath  = _fileName.SubStrPart (0, x - 1);
    _fileName = _fileName.SubStrPart (x + 1);
  }
  
      
  x = _fileName.LocateLastOccurrence ('.');
  if  (x < 0)
  {
    _rootName  = _fileName;
    _extension = "";
  }
  else
  {
    _rootName  = _fileName.SubStrPart (0, x - 1);
    _extension = _fileName.SubStrPart (x + 1);
  }

  return;
}  /* ParseFileName */

void KKB::osParseFileSpec	(	KKStr	fullFileName,
		KKStr &	driveLetter,
		KKStr &	path,
		KKStr &	root,
		KKStr &	extension
	)

Definition at line 1243 of file OSservices.cpp.

References KKB::KKStr::Concat(), KKB::KKStr::LastChar(), KKB::KKStr::LocateCharacter(), KKB::KKStr::LocateLastOccurrence(), KKB::KKStr::operator=(), osLocateLastSlashChar(), and KKB::KKStr::SubStrPart().

{
  path = "";
  root = "";
  extension = "";
  driveLetter = "";

  // Look for Drive Letter
  kkint32  driveLetterPos = fullFileName.LocateCharacter (':');
  if  (driveLetterPos >= 0)
  {
    driveLetter  = fullFileName.SubStrPart (0, driveLetterPos - 1);
    fullFileName = fullFileName.SubStrPart (driveLetterPos + 1);
  }

  KKStr  fileName;

  if  (fullFileName.LastChar () == DSchar)
  {
    // FileSpec must look like  'c:\xxx\xx\'
    path      = fullFileName;
    root      = "";
    extension = "";
    return;
  }

  kkint32  lastSlash =  osLocateLastSlashChar (fullFileName);
  if  (lastSlash < 0)
  {
    path = "";
    fileName = fullFileName;
  }
  else 
  {
    path     = fullFileName.SubStrPart (0, lastSlash - 1);
    fileName = fullFileName.SubStrPart (lastSlash + 1);
  }

  kkint32  period = fileName.LocateLastOccurrence ('.');
  if  (period <= 0)
  {
    root = fileName;
    extension = "";
  }
  else 
  {
    root      = fileName.SubStrPart (0, period - 1);
    extension = fileName.SubStrPart (period + 1);
  }

  return;
}  /* osParseFileSpec */

KKStrPtr KKB::osReadNextLine

(

FILE *

in

)

Read the next line from the file and return a c-String(NULL terminated).

Will read in characters from 'in' until a line feed character is read. The caller will own the string returned and be responsible for deleting it.

Parameters

[in]

in

File to read from.

Returns

A dynamically allocated c-string (NULL Terminated) containing the next line in the file. If end-of-file reached will return a NULL pointer.

Definition at line 2261 of file OSservices.cpp.

References KKB::KKStr::Append(), KKB::KKStr::Concat(), KKB::KKStr::KKStr(), and KKB::KKStr::Len().

{
  if  (feof (in))
    return NULL;

  KKStrPtr  buff = new KKStr (100);
  while  (true)
  {
    if  (feof (in))
      break;

    char  ch = fgetc (in);
    if  (ch == '\r')
    {
      if  (!feof (in))
      {
        char  nextCh = fgetc (in);
        if  (nextCh != '\n')
          ungetc (nextCh, in);
        break;
      }
    }
    else if  (ch == '\n')
    {
      break;
    }

    buff->Append (ch);
    if  (buff->Len () >= uint16_max)
      break;
  }

  return  buff;
}  /* osReadNextLine */

KKStr KKB::osReadNextQuotedStr	(	FILE *	in,
		const char *	whiteSpaceCharacters,
		bool &	eof
	)

Read the next Quoted String from the file.

If the first non whitespace character is a quote (") character will read in rest of string until the next occurrence of a Quote character. Otherwise it will read in characters until another whitespace character occurs.

Parameters

[in]	in	File to read from.
[in]	whiteSpaceCharacters	c-string (NULL Terminated) list of white space characters.
[out]	eof	Will be set to true if we are at the end of file when you make the call.

Returns

A String containing the next String in the file.

Definition at line 2598 of file OSservices.cpp.

References KKB::KKStr::Concat(), and KKB::KKStr::KKStr().

{
  if  (feof (in))
  {
    eof = true;
    return KKStr::EmptyStr ();
  }

  // Skip leading white space and find first character in Token
  kkint32  ch = fgetc (in);

  while  ((!feof (in))  &&  (strchr (whiteSpaceCharacters, ch) != NULL))
  {
    ch = fgetc (in); 
  }

  if  (feof (in))
  {
    eof = true;
    return  KKStr::EmptyStr ();
  }


  KKStr  result (10);

  bool  lookForTerminatingQuote = false;

  if  (ch == '"')
  {
    // We are going to read in a quoted string.  In this case we include all characters until 
    // we find the terminating quote
    lookForTerminatingQuote = true;
    ch = fgetc (in);
  }

  // Search for matching terminating Quote

  while  (!feof (in))
  {
    if  (lookForTerminatingQuote)
    {
      if  (ch == '"')
      {
        break;
      }
    }

    else 
    {
      if  (strchr (whiteSpaceCharacters, ch))
      {
        // We found the next terminating white space character.
        break;
      }
    }

    if  ((ch == '\\')  &&  (lookForTerminatingQuote))
    {
      if  (!feof (in))
      {
        ch = fgetc (in);
        switch  (ch)
        {
         case  '"': result.Append ('"');      break;
         case  't': result.Append ('\t');     break;
         case  'n': result.Append ('\n');     break;
         case  'r': result.Append ('\r');     break;
         case '\\': result.Append ('\\');     break;
         case  '0': result.Append (char (0)); break;
         case    0:                           break;
         default:   result.Append (ch); break;
        }
      }
    }
    else
    {
      result.Append (ch);
    }

    ch = fgetc (in);
  }

  // Eliminate all trailing white space
  if  (!feof (in))
  {
    ch = fgetc (in);
    while  ((!feof (in))  &&  (strchr (whiteSpaceCharacters, ch) != NULL))
    {
      ch = fgetc (in);
    }

    if  (!feof (in))
    {
      ungetc (ch, in);
    }
  }


  return  result;
}  /* osReadNextQuotedStr */

KKStr KKB::osReadNextToken	(	FILE *	in,
		const char *	delimiters,
		bool &	eof,
		bool &	eol
	)

Read the next logical token from a file using characters in 'delimiters' to separate tokens.

Use this function to read logical tokens from a file. It recognizes the concept of a line that is terminated by the line feed ('
') character. When end of line is reached it will return an empty string setting 'eol' to true; the very next call will return the first token on the next line. The leading whitespace characters ' ' and '\r' will be skipped before reading the next token. Tokens will be separated by any one of the characters specified in 'delimiters'. Two or more delimiters that occur consecutively will not be treated as one separator. You will need to call this method for each one.

ex: the string "Apple\tPeer\t\tGrape\t\n" with the delimiters = "\t" will generate the following tokens when "Apple", "Peer", "", "Grape", "", ""(eol = True)

Parameters

[in]	in	File handle to read from.
[in]	delimiters	c string listing delimiter characters.
[out]	eof	End of file flag. When this goes true so will eol, also no token will be returned.
[out]	eol	Will be set to true when the end-of-line is reached ('\n'). No token will be returned. The next call to this method will start at the next line.

Returns

The next token read from the file. You must also monitor the 'eol' and 'eof' variables. If either one is true the no token will be returned.

Definition at line 2374 of file OSservices.cpp.

{
  eof = false;
  eol = false;

  char  token[1024];
  kkint32  maxTokenLen = sizeof (token) - 1;

  kkint32  ch = fgetc (in);  eof = (feof (in) != 0);

  if  (eof)
  {
    eol = true;
    return "";
  }

  // lets skip leading white space
  while  ((!eof)  &&  ((ch == ' ') || (ch == '\r'))  &&  (ch != '\n'))
    {ch = fgetc (in); eof = (feof (in)!= 0);}

  if  (ch == '\n')
  {
    eol = true;
    return "";
  }

  kkint32 tokenLen = 0;

  // Read till first delimiter or eof
  while  ((!eof)  &&  (!strchr (delimiters, ch)))
  {
    if  (ch == '\n')
    {
      ungetc (ch, in);
      break;
    }
    else
    {
      token[tokenLen] = ch;
      tokenLen++;
      
      if  (tokenLen >= maxTokenLen)
        break;

      ch = fgetc (in); eof = (feof (in)!= 0);
    }
  }

  token[tokenLen] = 0;  // Terminating NULL character.


  // Remove Trailing whitespace
  while  (tokenLen > 0)
  {
    if  (strchr (" \r", token[tokenLen - 1]) == 0)
      break;
    tokenLen--;
    token[tokenLen] = 0;
  }

  return  token;
}  /* ReadNextToken */

KKStr KKB::osReadNextToken	(	FILE *	in,
		const char *	delimiters,
		bool &	eof
	)

Read the next logical token from a file using characters in 'delimiters' to separate tokens where '
'(end of line) is just another whitespace character.

Use this function to read logical tokens from a file. Leading whitespace characters ' ', '\n', and '\r' will be skipped before reading the next token. Tokens will be separated by any one of the characters specified in 'delimiters'. Two or more delimiters that occur consecutively will not be treated as one separator. You will need to call this method for each one. Note that whitespace characters are not treated as delimiters but characters that are to be ignored before and after the token.

ex: the string "Apple\tPeer\t\tGrape\t\n" with the delimiters = "\t" will generate the following tokens when "Apple", "Peer", "", "Grape", "", ""(eol = True)

Parameters

[in]	in	File handle to read from.
[in]	delimiters	c string listing delimiter characters.
[out]	eof	End of file flag. When this goes true so will eol, also no token will be returned.

Returns

The next token read from the file. You must also monitor the 'eol' and 'eof' variables. If either one is true the no token will be returned.

Definition at line 2444 of file OSservices.cpp.

Referenced by ReadImagePPM().

{
  eof = false;
  char  token[1024];
  kkint32  maxTokenLen = sizeof (token) - 1;

  kkint32  ch = fgetc (in);  eof = (feof (in) != 0);

  if  (eof)
    return "";

  // lets skip leading white space
  while  ((!eof)  &&  ((ch == ' ') || (ch == '\r'))  &&  (ch != '\n'))
    {ch = fgetc (in); eof = (feof (in)!= 0);}

  kkint32 tokenLen = 0;

  // Read till first delimiter or eof
  while  ((!eof)  &&  (!strchr (delimiters, ch)))
  {
    token[tokenLen] = ch;
    tokenLen++;
      
    if  (tokenLen >= maxTokenLen)
      break;

    ch = fgetc (in); eof = (feof (in)!= 0);
  }

  token[tokenLen] = 0;  // Terminating NULL character.


  // Remove Trailing whitespace
  while  (tokenLen > 0)
  {
    if  (strchr (" \n\r", token[tokenLen - 1]) == 0)
      break;
    tokenLen--;
    token[tokenLen] = 0;
  }

  return  token;
}  /* ReadNextToken */

KKStr KKB::osReadNextToken	(	std::istream &	in,
		const char *	delimiters,
		bool &	eof,
		bool &	eol
	)

Read the next logical token from a file using characters in 'delimiters' to separate tokens.

Use this function to read logical tokens from a input stream. It recognizes the concept of a line that is terminated by the line feed ('
') character. When end of line is reached it will return an empty string setting 'eol' to true; the very next call will return the first token on the next line. The leading whitespace characters ' ' and ']r' will be skipped before reading the next token. Tokens will be separated by any one of the characters specified in 'delimiters'. Two or more delimiters that occur consecutively will not be treated as one separator. You will need to call this method for each one.

ex: the string "Apple\tPeer\t\tGrape\t\n" with the delimiters = "\t" will generate the following tokens when "Apple", "Peer", "", "Grape", "", ""(eol = True)

Parameters

[in]	in	Input Stream to read from.
[in]	delimiters	c string listing delimiter characters.
[out]	eof	End of file flag. When this goes true so will eol, also no token will be returned.
[out]	eol	Will be set to true when the end-of-line is reached (' '). No token will be returned. The next call to this method will start at the next line.

Returns

The next token read from the file. You must also monitor the 'eol' and 'eof' variables. If either one is true the no token will be returned.

Definition at line 2301 of file OSservices.cpp.

{
  eof = false;
  eol = false;

  char  token[1024];
  kkint32  maxTokenLen = sizeof (token) - 1;

  //kkint32  ch = fgetc (in);  eof = (feof (in) != 0);
  kkint32  ch = in.get ();  
  eof = in.eof ();
  if  (eof)
  {
    eol = true;
    return "";
  }

  // lets skip leading white space
  while  ((!eof)  &&  ((ch == ' ') || (ch == '\r'))  &&  (ch != '\n'))
  {
    ch = in.get (); 
    eof = in.eof ();
  }

  if  (ch == '\n')
  {
    eol = true;
    return "";
  }

  kkint32 tokenLen = 0;

  // Read till first delimiter or eof
  while  ((!eof)  &&  (!strchr (delimiters, ch)))
  {
    if  (ch == '\n')
    {
      in.putback (ch);
      break;
    }
    else
    {
      token[tokenLen] = ch;
      tokenLen++;
      
      if  (tokenLen >= maxTokenLen)
        break;

      ch = in.get (); 
      eof = in.eof ();
    }
  }

  token[tokenLen] = 0;  // Terminating NULL character.

  // Remove Trailing whitespace
  while  (tokenLen > 0)
  {
    if  (strchr (" \r", token[tokenLen - 1]) == 0)
      break;
    tokenLen--;
    token[tokenLen] = 0;
  }

  return  token;
}  /* osReadNextToken */

KKStrPtr KKB::osReadRestOfLine	(	std::istream &	in,
		bool &	eof
	)

Extracts text up to and including the next end-of-line character and returns pointer to dynamical allocated str that caller will own.

The new-line character that terminated the nor any carriage-return will not be included. If stream [[in]] is already at end-of-file then will return NULL as well as eof being set to true.

Parameters

in	Stream to read text from.
eof	Set to true if end-of-file is reached while reading file.

Definition at line 2511 of file OSservices.cpp.

References KKB::KKStr::Append(), KKB::KKStr::Concat(), KKB::KKStr::KKStr(), KKB::KKStr::Len(), KKB::KKStr::MaxLenSupported(), and KKB::KKStr::Trim().

Referenced by osReadRestOfLine2().

{
  eof = false;

  kkint32  ch = in.get ();  
  eof = in.eof ();

  if  (eof)
    return NULL;

  KKStrPtr  result = new KKStr (1024);

  // Read till first delimiter or eof
  while  (!eof)
  {
    if  (ch == '\n')
    {
      break;
    }
    else
    {
      result->Append (ch);
      if  (result->Len () >= (result->MaxLenSupported ()))
        break;
      ch = in.get ();  eof = in.eof ();
    }
  }

  result->Trim (" \n\r");

  return  result;
}  /* osReadRestOfLine */

KKStrPtr KKB::osReadRestOfLine	(	FILE *	in,
		bool &	eof
	)

Definition at line 2549 of file OSservices.cpp.

References KKB::KKStr::Append(), KKB::KKStr::Concat(), KKB::KKStr::KKStr(), KKB::KKStr::Len(), KKB::KKStr::MaxLenSupported(), and KKB::KKStr::TrimRight().

Referenced by KKMLL::MLClassList::Load(), KKLSC::ScannerFile::LoadIndexFile(), and osReadRestOfLine2().

{
  eof = false;

  kkint32  ch = fgetc (in);  
  eof = (feof (in) != 0);
  if  (eof)  
    return NULL;

  KKStrPtr  result = new KKStr(1024);
  // Read till first delimiter or eof
  while  (!eof)
  {
    if  (ch == '\n')
    {
      break;
    }
    else
    {
      result->Append (ch);
      if  (result->Len () >= result->MaxLenSupported ())
        break;
      ch = fgetc (in);  eof = (feof (in) != 0);
    }
  }

  result->TrimRight (" \r\n");

  return  result;
}  /* osReadRestOfLine */

KKB::KKStr KKB::osReadRestOfLine2	(	std::istream &	in,
		bool &	eof
	)

Definition at line 2493 of file OSservices.cpp.

References KKB::KKStr::Concat(), KKB::KKStr::KKStr(), and osReadRestOfLine().

Referenced by KKMLL::ClassProbList::CreateFromXMLStream().

{
  KKStrPtr l = osReadRestOfLine (in, eof);
  if  (l) {
    KKStr  result(*l);
    delete l;
    l = NULL;
    return  result;
  }
  else {
    return "";
  }
}

KKB::KKStr KKB::osReadRestOfLine2	(	FILE *	in,
		bool &	eof
	)

Definition at line 2584 of file OSservices.cpp.

References KKB::KKStr::Concat(), KKB::KKStr::KKStr(), and osReadRestOfLine().

Referenced by ReadImagePGM().

{
  KKStrPtr l = osReadRestOfLine (in, eof);
  KKStr  result(*l);
  delete l;
  l = NULL;
  return  result;
}

KKStr KKB::osRemoveExtension

(

const KKStr &

_fullFileName

)

Definition at line 1136 of file OSservices.cpp.

References KKB::KKStr::Concat(), KKB::KKStr::KKStr(), KKB::KKStr::LocateLastOccurrence(), osLocateLastSlashChar(), and KKB::KKStr::SubStrPart().

Referenced by KKMLL::ClassificationBiasMatrix::ClassificationBiasMatrix(), KKMLL::Orderings::CreateOrderingsObjFromFileIfAvaliable(), KKMLL::TrainingConfiguration2::GetEffectiveConfigFileName(), KKMLL::TrainingProcess2::LoadExistingTrainingProcess(), KKLSC::ScannerFile::LoadIndexFile(), KKLSC::ScannerFile::Open(), KKMLL::Orderings::Orderings(), KKLSC::ScannerFile::SaveIndexFile(), and KKMLL::TrainingProcess2::SaveTrainingProcess().

{
  kkint32  lastSlashChar = osLocateLastSlashChar (_fullFileName);
    
  kkint32  lastPeriodChar = _fullFileName.LocateLastOccurrence ('.');

  if  (lastPeriodChar < lastSlashChar)
    return KKStr (_fullFileName);

  if  (lastPeriodChar <= 1)
    return KKStr (_fullFileName);

  return _fullFileName.SubStrPart (0, lastPeriodChar - 1);
}  /* osRemoveExtension */

bool KKB::osRenameFile	(	const KKStr &	oldName,
		const KKStr &	newName
	)

Definition at line 743 of file OSservices.cpp.

{
  bool  returnCd = (MoveFile (oldName.Str (), newName.Str ()) != 0);

  if  (!returnCd)
  {
     DWORD lastError = GetLastError ();

     cerr << std::endl
          << "osRenameFile   *** ERROR ***,   Rename Failed"                          << std::endl
          <<                                                                             std::endl
          << "               oldName[" << oldName << "]   NewName[" << newName << "]" << std::endl
          << "               LastError[" << lastError << "]"                          << std::endl
          << std::endl;
     
  }
 
  return  returnCd;

}  /* osRenameFile */

void KKB::osRunAsABackGroundProcess

(

)

Definition at line 1499 of file OSservices.cpp.

References backGroundProcess.

{
  backGroundProcess = true;
}

void KKB::osSkipRestOfLine	(	FILE *	in,
		bool &	eof
	)

Skips rest of the characters in the current line in the file.

Will skip all characters in 'in' until a '
' is read or the end of file has been reached. It is meant be be used in conjunction with 'osReadNextToken'.

Parameters

[in]	in	File being read.
[out]	eof	Will be set to true if end of file is encountered.

Definition at line 2705 of file OSservices.cpp.

{
  eof = false;
  kkint32  ch = fgetc (in);  eof = (feof (in) != 0);
  while  ((ch != '\n')  &&  (!eof))
  {
    ch = fgetc (in);  eof = (feof (in) != 0);
  }
}  /* osSkipRestOfLine */

void KKB::osSkipRestOfLine	(	std::istream &	in,
		bool &	eof
	)

Skips rest of the characters in the current line in the input stream.

Will skip all characters in 'in' until a '
' is read or the end of file has been reached. It is meant be be used in conjunction with 'osReadNextToken'.

Parameters

[in]	in	File being read.
[out]	eof	Will be set to true if end of file is encountered.

Definition at line 2720 of file OSservices.cpp.

{
  kkint32  ch = in.get ();  
  eof = in.eof ();

  while  ((ch != '\n')  &&  (!eof))
  {
    ch = in.get ();  
    eof = in.eof ();
  }
}  /* osSkipRestOfLine */

void KKB::osSleep

(

float

numOfSecs

)

Definition at line 2764 of file OSservices.cpp.

Referenced by KKJobManagment::KKJobManager::Block(), KKB::KKThreadManager::ManageThreads(), and KKB::KKThreadManager::ShutdownProcessing().

{
  #ifdef  WIN32
  kkint32  miliSecsToSleep = (kkint32)(1000.0f * secsToSleep + 0.5f);
  Sleep (miliSecsToSleep);
  #else
  kkint32  secsToSleepInt = (kkint32)(0.5f + secsToSleep);

  if  (secsToSleepInt < 1)
    secsToSleepInt = 1;
 
  else if  (secsToSleepInt > 3600)
    cout  << "osSleep  secsToSleep[" << secsToSleepInt << "]" << std::endl;

  sleep (secsToSleepInt);
  #endif
}

void KKB::osSleepMiliSecs

(

kkuint32

numMiliSecs

)

Definition at line 2785 of file OSservices.cpp.

Referenced by KKLSC::ScannerFile::AddStartStopEntryToIndexFile(), KKLSC::ScannerFile::BuildFrameOffsets(), KKB::GoalKeeper::StartBlock(), and KKB::KKThread::WaitForThreadToStop().

{
  #ifdef  WIN32
    Sleep (numMiliSecs);
  #else
    int  numSecsToSleep = (numMiliSecs / 1000);
    sleep (numSecsToSleep);
  #endif
}

VectorKKStr KKB::osSplitDirectoryPathIntoParts

(

const KKStr &

path

)

Definition at line 2797 of file OSservices.cpp.

References KKB::KKStr::Len(), and KKB::KKStr::operator[]().

{
  VectorKKStr  parts;

  if  (path.Len () == 0)
    return parts;

  kkuint32  zed = 0;

  if  (path[(kkuint16)1] == ':')
  {
    parts.push_back (path.SubStrPart (0, 1));
    zed += 2;
  }

  while  (zed < path.Len ())
  {
    if  (path[zed] == '\\')
    {
      parts.push_back ("\\");
      zed++;
    }
    else if  (path[zed] == '/')
    {
      parts.push_back ("/");
      zed++;
    }
    else
    {
      // Scan until we come up to another separator or end of string
      kkint32  startPos = zed;
      while  (zed < path.Len ())
      {
        if  ((path[zed] == '\\')  ||  (path[zed] == '/'))
          break;
        zed++;
      }

      parts.push_back (path.SubStrPart (startPos, zed - 1));
    }
  }

  return  parts;
}  /* osSplitDirectoryPathIntoParts */

KKStr KKB::osSubstituteInEnvironmentVariables

(

const KKStr &

src

)

Substitute in the value of the environment variables into 'src'.

Will scan the 'src' string for references to environment variables. The format would be $(env-var-name). These sub-strings in 'src' will be replaced by the the actual value of the environment variable. If no such environment variable exists the substring will be left as is besides parentheses '{}' or '[]' can be used, ex the string "${KinseyHomeDir}\\Reports" would be replaced by "c:\Kinsey\reports"

Parameters

[in]

src

String that you want to scan for environment variables.

Returns

'src' string with environment variables expanded.

Definition at line 977 of file OSservices.cpp.

References KKB::KKStr::Concat(), KKB::KKStr::KKStr(), KKB::KKStr::Len(), KKB::KKStr::LocateCharacter(), KKB::KKStr::operator+(), operator+(), KKB::KKStr::operator=(), KKB::KKStr::operator[](), osGetEnvVariable(), osLocateEnvStrStart(), and KKB::KKStr::SubStrPart().

Referenced by KKMLL::TrainingClass::ExpandedDirectory(), KKMLL::TrainingConfiguration2::LoadOtherClasssExamples(), KKMLL::TrainingConfiguration2::RootDir(), and KKMLL::TrainingClassList::WriteXML().

{
  kkint16  x = osLocateEnvStrStart (src, 0);
  if  (x < 0)  return  src;

  KKStr  str (src);

  while  (x >= 0)
  {
    char  startChar = src[(kkint16)(x + 1)];
    char  endChar = ')';

    if       (startChar == '(')   endChar = ')';
    else if  (startChar == '{')   endChar = '}';
    else if  (startChar == '[')   endChar = ']';

    KKStr  beforeEnvStr = str.SubStrPart (0, x - 1);
    str = str.SubStrPart (x + 2);
    x = str.LocateCharacter (endChar);
    if  (x < 0)  return  src;

    KKStr  envStrName   = str.SubStrPart (0, x - 1);
    KKStr  afterStrName = str.SubStrPart (x + 1);

    KKStrPtr envStrValue = osGetEnvVariable (envStrName);
    if  (envStrValue == NULL)
      envStrValue = new KKStr ("${" + envStrName + "}");

    kkuint32  idxToStartAtNextTime = beforeEnvStr.Len () + envStrValue->Len ();
    str = beforeEnvStr + (*envStrValue)  + afterStrName;
    delete  envStrValue;
    x = osLocateEnvStrStart (str, idxToStartAtNextTime);
  }

  return  str;
}  /* osSubstituteInEnvironmentVariables */

bool KKB::osValidDirectory

(

KKStrConstPtr

_name

)

Definition at line 382 of file OSservices.cpp.

Referenced by osGetListOfDirectories().

{
  DWORD  returnCd = GetFileAttributes (name->Str ());

  if  (returnCd == 0xFFFFFFFF)
  {
    return false;
  }

  if  ((FILE_ATTRIBUTE_DIRECTORY & returnCd)  != FILE_ATTRIBUTE_DIRECTORY)
    return false;
  else
    return true;
}

bool KKB::osValidDirectory

(

const KKStr &

_name

)

Definition at line 398 of file OSservices.cpp.

Referenced by osCreateDirectoryPath().

{
  #define INVALID_FILE_ATTRIBUTES ((DWORD)-1)
  DWORD  returnCd = GetFileAttributes (name.Str ());

  if  (returnCd == INVALID_FILE_ATTRIBUTES)
    return false;


  if  ((FILE_ATTRIBUTE_DIRECTORY & returnCd)  != FILE_ATTRIBUTE_DIRECTORY)
    return false;
  else
    return true;
}

bool KKB::osValidFileName

(

const KKStr &

_name

)

Definition at line 443 of file OSservices.cpp.

References osValidFileNameErrors().

{
  KKStrListPtr  errors = osValidFileNameErrors (_name);
  if  (errors == NULL)
    return true;
  else
  {
    delete errors;
    errors = NULL;
    return false;
  }
}

KKStrListPtr KKB::osValidFileNameErrors

(

const KKStr &

_name

)

Returns list of errors in '_name' with respect to it being a valid file name for the O/S.

Definition at line 458 of file OSservices.cpp.

References KKB::KKStr::Empty(), KKB::KKStrList::KKStrList(), KKB::KKStr::Len(), and KKB::KKStr::operator[]().

Referenced by osValidFileName().

{
  const char*  invalidChars = "\\\" :<>!?*";
  const char*  invalidNames[] = {"CON",  "PRN",  "AUX",  "NUL",  "COM1", "COM2", 
                                 "COM3", "COM4", "COM5", "COM6", "COM7", "COM8", 
                                 "COM9", "LPT1", "LPT2", "LPT3", "LPT4", "LPT5",
                                 "LPT6", "LPT7", "LPT8", "LPT9", 
                                 NULL
                                }; 

  KKStrListPtr  errors = new KKStrList (true);
  if  (_name.Empty ())
  {
    errors->PushOnBack (new KKStr ("Blank names are invalid!"));
  }

  else
  {
    // Check for invalid names.
    kkuint32  x = 0;
    while  (invalidNames[x] != NULL)
    {
      if  (_name.EqualIgnoreCase (invalidNames[x]))
        errors->PushOnBack (new KKStr ("Can not use \"" + _name + "\""));
      ++x;
    }

    // Check for invalid characters
    for  (x = 0;  x < _name.Len ();  ++x)
    {
      char c = _name[x];
      if  (c == 0)
        errors->PushOnBack (new KKStr ("Null character at position: " + StrFormatInt (x, "##0")));

      else if  (c == ' ')
        errors->PushOnBack (new KKStr ("No spaces allowed."));

      else if  (c < 32)
      {
        errors->PushOnBack (new KKStr ("Character at position: " + StrFormatInt (x, "##0") + " has ordinal value of: " + StrFormatInt (c, "##0")));
      }

      else if  (strchr (invalidChars, c) != NULL)
      {
        KKStr invalidStr (2);
        invalidStr.Append (c);
        errors->PushOnBack (new KKStr ("Invalid character: " + invalidStr + "  at position: " + StrFormatInt (x, "##0")));
      }
    }
  }

  if  (errors->QueueSize () < 1)
  {
    delete  errors;
    errors = NULL;
  }

  return errors;
}  /* osValidFileNameErrors */

void KKB::osWaitForEnter

(

)

Definition at line 1513 of file OSservices.cpp.

References backGroundProcess.

Referenced by KKB::Matrix::CalcCoFactorMatrix(), KKMLL::FeatureEncoder2::CreateEncodedFileDesc(), KKB::Raster::FourierExtractFeatures(), KKB::Raster::HistogramEqualizedImage(), KKMLL::NormalizationParms::NormalizeExamples(), KKB::Row::operator[](), KKMLL::Orderings::Save(), KKJobManagment::KKJobManager::StatusFileProcessLineJobStatusChange(), and KKMLL::SvmPredictRaw().

{
  if  (backGroundProcess)
    return;

  cout << std::endl
       << std::endl
       << "Press Enter To Continue"
       << std::endl;

  while  (getchar () != '\n');

} /* osWaitForEnter */

float KKB::PairedTTest	(	const KKB::VectorFloat &	set1,
		const KKB::VectorFloat &	set2
	)

Definition at line 24 of file StatisticalFunctions.cpp.

{
  // Formula was taken from MathWorld
  // http://mathworld.wolfram.com/Pairedt-Test.html

  //ofstream  out ("T-Test_Stats.txt", ios_base::app);
  double  numOfPairs = (double)set1.size ();

  if  (numOfPairs != set2.size ())
  {
    cerr << std::endl
         << std::endl
         << "PairedTTest     *** ERROR ***    The two sets are not the same length." << std::endl
         << std::endl
         << "                set1.size [" << set1.size () << "]   set2.size [" << set2.size () << "]" << std::endl
         << std::endl;
    osWaitForEnter ();
    exit (-1);
  }
                    

  double  xTotal = 0.0f;
  double yTotal = 0.0f;

  kkint32  foldNum = 0;


  //out << "X";
  //for  (foldNum = 0;  foldNum < numOfPairs;  foldNum++)
  //  out << "\t" << set1[foldNum];
  //out << endl;

  //out << "Y";
  //for  (foldNum = 0;  foldNum < numOfPairs;  foldNum++)
  //  out << "\t" << set2[foldNum];
  //out << endl;


  for  (foldNum = 0;  foldNum < numOfPairs;  foldNum++)
  {
    xTotal += set1[foldNum];
    yTotal += set2[foldNum];
  }

  double  xMean = xTotal / numOfPairs;
  double  yMean = yTotal / numOfPairs;

  //out  << endl
  //     << "X_Mean = " << xMean << endl
  //     << "Y_Mean = " << yMean << endl;

  double  totalDeltaSquared = 0.0f;

  for  (foldNum = 0;  foldNum < numOfPairs;  foldNum++)
  {
    double  xDelta = set1[foldNum] - xMean;
    double  yDelta = set2[foldNum] - yMean;

    double  deltaDelta = xDelta - yDelta;
    totalDeltaSquared += (deltaDelta * deltaDelta);
  }

  //out  << endl 
  //     << "totalDeltaSquared = " 
  //     << totalDeltaSquared << endl;


  double  tValue = 0.0f;
  if  (totalDeltaSquared != 0.0)
    tValue = fabs ((xMean - yMean) * sqrt ((numOfPairs * (numOfPairs - 1.0)) / totalDeltaSquared));

  //out  << endl 
  //     << "tValue = " << tValue << endl
  //     << endl;

  //out.close ();

  return  float (tValue);
}  /* PairedTTest */

RasterPtr KKB::ReadImage

(

const KKStr &

imageFileName

)

Definition at line 188 of file ImageIO.cpp.

References KKB::BmpImage::BmpImage(), KKB::Raster::Color(), KKB::KKStr::Concat(), KKB::KKStr::operator==(), osGetFileExtension(), KKB::Raster::Raster(), ReadImagePGM(), ReadImagePPM(), ReadImageUsingGDI(), KKB::Raster::ReverseImage(), and KKB::KKStr::ToLower().

Referenced by KKMLL::FeatureVectorProducer::ComputeFeatureVectorFromImage(), KKMLL::FeatureFileIO::FeatureDataReSink(), and KKB::Raster::Raster().

{
  bool  successful = false;
  RasterPtr  image = NULL;

  KKStr  extension = osGetFileExtension (imageFileName).ToLower ();
  if  (extension == "pgm")
  {
    image = ReadImagePGM (imageFileName);
  }

  else if  (extension == "bmp")
  {
    BmpImage  bmpImage (imageFileName, successful);
    if  (!successful)
      return  NULL;
    image = new Raster (bmpImage);
  }

  else if  (extension == "ppm")
  {
    image = ReadImagePPM (imageFileName);
  }

#if  defined(OS_WINDOWS)
  else if  ((extension == "jpg")  ||  (extension == "tif")  ||  (extension == "tiff"))
  {
    image = ReadImageUsingGDI (imageFileName);
    if  (image)
    {
      if  (!image->Color ())
        image->ReverseImage ();
    }
  }
#endif

  return  image;
}  /* ReadImage */

RasterPtr KKB::ReadImagePGM

(

const KKStr &

imageFileName

)

Definition at line 371 of file ImageIO.cpp.

References KKB::KKStr::Concat(), KKB::KKStr::ExtractTokenInt(), KKB::KKStr::operator=(), KKB::KKStr::operator[](), osFOPEN(), osReadRestOfLine2(), KKB::Raster::Raster(), KKB::Raster::SetPixelValue(), KKB::KKStr::Str(), and KKB::KKStr::ToInt().

Referenced by ReadImage().

{
  FILE* i = osFOPEN (imageFileName.Str (), "rb");
  if  (!i)
    return NULL;

  kkint32  height    = -1;
  kkint32  pixelSize = -1;
  kkint32  width     = -1;

  {
    // We are going to read in header part of file.
    KKStr  nextLine = "";
    bool  eof = false;
    nextLine = osReadRestOfLine2 (i, eof);
    if  (eof  ||  (nextLine[(kkint16)0] != 'P')  ||  (nextLine[(kkint16)1] != '5'))
    {
      fclose (i);
      return NULL;
    }

    kkint32  headerFieldsRead = 0;
    nextLine = osReadRestOfLine2 (i, eof);
    while  (!eof)
    {
      if  (nextLine[(kkint16)0] != '#')
      {
        if  (headerFieldsRead == 0)
        {
          width  = nextLine.ExtractTokenInt (" \t\n\r");
          height = nextLine.ExtractTokenInt (" \t\n\r");
        }
        if  (headerFieldsRead == 1)
        {
          pixelSize = nextLine.ToInt ();
          break;
        }
        headerFieldsRead++;
      }
      nextLine = osReadRestOfLine2 (i, eof);
    }
  }

  if  ((pixelSize < 0)  ||  (pixelSize > 255)  ||
       (width     < 1)  ||  (height < 1)
      )
  {
    fclose (i);
    cerr << endl << endl
      << "ReadImagePGM   ***ERROR***  ImageFile[" << imageFileName << "]  Invalid Header"
      << "  width[" << width << "]  height[" << height << "]  pixelSize[" << pixelSize << "]"
      << endl
      << endl;
    return  NULL;
  }

  RasterPtr  image = new Raster (height, width, false);

  kkint32  row, col;

  uchar* colBuff = new uchar[width + 10];

  for  (row = 0;  row < height;  row++)
  {
    fread (colBuff, 1, width, i);

    for  (col = 0;  col < width;  col++)
    {
      image->SetPixelValue (row, col, colBuff[col]);
    }
  }

  fclose (i);
     
  return  image;
}  /* ReadImagePGM */

RasterPtr KKB::ReadImagePPM

(

const KKStr &

imageFileName

)

Definition at line 515 of file ImageIO.cpp.

References KKB::KKStr::Concat(), KKB::KKStr::operator=(), osFOPEN(), osReadNextToken(), KKB::Raster::Raster(), ReadImagePpmField(), KKB::Raster::RedArea(), KKB::KKStr::Str(), and KKB::KKStr::ToInt32().

Referenced by ReadImage().

{
  FILE* i = osFOPEN (imageFileName.Str (), "rb");
  if  (!i)
    return NULL;

  kkint32  height     = -1;
  kkint32  pixelDepth = -1;
  kkint32  width      = -1;

  bool  eof = false;
  
  char  buff[10];
  kkint32  bytesRead = (kkint32)fread (buff, 1, 2, i);
  if  (bytesRead < 2)
  {
    fclose (i);
    return NULL;
  }

  bool  p3Format = ((buff[0] == 'P')  &&  (buff[1] == '3'));
  bool  p6Format = ((buff[0] == 'P')  &&  (buff[1] == '6'));

  if  (!p3Format  &&  !p6Format)
  {
    fclose (i);
    return NULL;
  }

  kkint32  fieldNum = 0;
  KKStr  field =  ReadImagePpmField (i, eof);
  while  ((fieldNum  < 3)  &&  (!eof))
  {
    switch  (fieldNum)
    {
    case  0: width      = field.ToInt32 ();   break;
    case  1: height     = field.ToInt32 ();   break;
    case  2: pixelDepth = field.ToInt32 ();   break;
    }
    ++fieldNum;
    field =  ReadImagePpmField (i, eof);
  }

  if  ((width < 1)  ||  (height < 1)  ||  (pixelDepth < 1)  ||  (pixelDepth > 65535))
  {
    cerr << endl << "ReadImagePPM   ***ERROR***    Invalid Header Fields:  "
      << "FileName[" << imageFileName << "]  "
      << "Width["  << width << "]  Height[" << height << "]  PixelDepth[" << pixelDepth << "]"
      << endl
      << endl;
    fclose (i);
    return NULL;
  }

  RasterPtr  image = new Raster (height, width, true);
  int  totalPixels = height * width;

  kkint32  pixelsRead = 0;

  uchar*  red   = image->RedArea ();
  uchar*  green = image->RedArea ();
  uchar*  blue  = image->RedArea ();
  if  (p3Format)
  {
    while  ((pixelsRead < totalPixels)  &&  (!eof))
    {
      KKStr  redField   = osReadNextToken (i, "\n\r\t ", eof);
      KKStr  greenField = osReadNextToken (i, "\n\r\t ", eof);
      KKStr  blueField  = osReadNextToken (i, "\n\r\t ", eof);

      kkint32  redValue    = Min (redField.ToInt32   (), pixelDepth);
      kkint32  greenValue  = Min (greenField.ToInt32 (), pixelDepth);
      kkint32  blueValue   = Min (blueField.ToInt32  (), pixelDepth);

      *red   = ((255 *  redValue)   / pixelDepth);   ++red;
      *green = ((255 *  greenValue) / pixelDepth);   ++green;
      *blue  = ((255 *  blueValue)  / pixelDepth);   ++blue;

      ++pixelsRead;
    }
  }
  else
  {
    char  rgbBuff[3];
    while  ((pixelsRead < totalPixels)  &&  (!eof))
    {
      fread (rgbBuff, 1, 3, i);  eof = (feof (i) != 0);
      *red   = rgbBuff[0];   ++red;
      *green = rgbBuff[1];   ++green;
      *blue  = rgbBuff[2];   ++blue;
      ++pixelsRead;
    }
  }

  fclose (i);
     
  return  image;
}  /* ReadImagePPM */

KKStr KKB::ReadImagePpmField	(	FILE *	in,
		bool &	eof
	)

Definition at line 451 of file ImageIO.cpp.

References KKB::KKStr::Concat(), and KKB::KKStr::EmptyStr().

Referenced by ReadImagePPM().

{
  eof = false;
  char  token[2048];
  kkint32  maxTokenLen = sizeof (token) - 1;

  kkint32  ch = 0;

  bool  startOfTokenFound = false;
  while  (!startOfTokenFound)
  {
    // Skip leading white space
    ch = fgetc (in);  eof = (feof (in) != 0);
    while  ((!eof)  &&  (strchr (" #\t\n\r", ch) != NULL)  &&  (ch != '\n')  &&  (ch != '#'))
      {ch = fgetc (in); eof = (feof (in)!= 0);}

    if  (eof)  
      return KKStr::EmptyStr ();

    else if  (ch == '#')
    {
      // Skip the rest of the line.
      while  ((!eof)  &&  (ch != '\n'))
        {ch = fgetc (in); eof = (feof (in)!= 0);}
    }

    else
    {
      startOfTokenFound = true;
    }
  }

  kkint32 tokenLen = 0;

  // Read till first delimiter or eof or eol
  while  ((!eof)  &&  (strchr (" #\t\n\r", ch) == 0))
  {
    token[tokenLen] = ch;
    tokenLen++;
    if  (tokenLen >= maxTokenLen)
      break;
    ch = fgetc (in); eof = (feof (in)!= 0);
  }
  token[tokenLen] = 0;  // Terminating NULL character.
  if  ((!eof)  &&  (ch == '#'))
  {
    // Skip the rest of the line.
    while  ((!eof)  &&  (ch != '\n'))
      {ch = fgetc (in); eof = (feof (in)!= 0);}
  }

  if  (eof  &  (tokenLen > 0))
  {
    eof = false;
    ungetc ('\n', in);
  }
  return  token;
}  /* ReadImagePpmField */

RasterPtr KKB::ReadImageUsingGDI

(

const KKStr &

imageFileName

)

Definition at line 237 of file ImageIO.cpp.

References DefineImageIoAtExit(), gdiStarted, and KKB::KKStr::ToWchar_t().

Referenced by ReadImage().

{
  if  (!gdiStarted)
  {
    GdiplusStartupInput gdiplusStartupInput;
    ULONG_PTR           gdiplusToken;
    // Initialize GDI+.
    GdiplusStartup(&gdiplusToken, &gdiplusStartupInput, NULL);

    //GdiplusShutdown(gdiplusToken);

    gdiStarted = true;
    DefineImageIoAtExit ();
  }

  RasterPtr  r = NULL;
  wchar_t*  imageFileNameWide = imageFileName.ToWchar_t ();

  Bitmap*  bm = Bitmap::FromFile (imageFileNameWide, false);
  if  (bm == NULL)
  {
    cerr << endl << "KKB::ReadImageUsingGDI   ***ERROR***  Reading file: " << imageFileName << endl;
  }
  else
  {
    kkuint32  height = bm->GetHeight ();
    kkuint32  width  = bm->GetWidth ();

    BitmapData* bitmapData = new BitmapData ();
    Gdiplus::Rect rect (0, 0, width, height);

    bm->LockBits(&rect, Gdiplus::ImageLockModeRead, bm->GetPixelFormat (), bitmapData);

    Gdiplus::PixelFormat  pixFormat = bitmapData->PixelFormat;
    kkint32  stride = bitmapData->Stride;
    void*  scan0 = bitmapData->Scan0;

    if  (pixFormat == PixelFormat24bppRGB)
    {
      r = new Raster (height, width, true);

      kkint32  nOffset = stride - width * 3;
      kkint32  bytesPerRow = width * 3 + nOffset;

      uchar  red   = 255;
      uchar  green = 255;
      uchar  blue  = 255;
      
      kkuint32  row, col;

      bool  grayScaleImage = true;

      uchar*  ptr = (uchar*)(void*)scan0;
      for  (row = 0;  row < height;  ++row)
      {
        for  (col = 0;  col < width;  ++col)
        {
          red   = *ptr;  ++ptr;
          green = *ptr;  ++ptr;
          blue  = *ptr;  ++ptr;
          r->SetPixelValue (row, col, red, green, blue);

          if  ((red != green)  ||  (red != blue))
            grayScaleImage= false;
        }
        ptr += nOffset;
      }

      if  (grayScaleImage)
      {
        RasterPtr  grayScaleR = r->CreateGrayScale ();
        delete  r;
        r = grayScaleR;
        grayScaleR = NULL;
      }
    }

    else if  (pixFormat == PixelFormat8bppIndexed)
    {
      kkint32  paletteSize = bm->GetPaletteSize ();

      ColorPalette* palette = (ColorPalette*)malloc (paletteSize);
      bm->GetPalette (palette, paletteSize);

      INT  paletteHasAlpha     = palette->Flags & PaletteFlagsHasAlpha;
      INT  paletteHasGrayScale = palette->Flags & PaletteFlagsGrayScale;
      INT  paletteHasHalftone  = palette->Flags & PaletteFlagsHalftone;

      r = new Raster (height, width, false);
      kkint32  nOffset = stride - width;
      kkint32  bytesPerRow = width + nOffset;

      uchar  index = 255;
      
      kkuint32  row, col;

      uchar*  ptr = (uchar*)(void*)scan0;

      for  (row = 0;  row < height;  ++row)
      {
        for  (col = 0;  col < width;  ++col)
        {
          index = *ptr;  ++ptr;

          ARGB argb = palette->Entries[index];

          kkint32  grayScaleValue = argb % 256;

          r->SetPixelValue (row, col, (uchar)grayScaleValue);
        }
        
        ptr += nOffset;
      }

      free (palette);
      palette = NULL;
    }

    bm->UnlockBits (bitmapData);

    delete  bitmapData;  bitmapData = NULL;
    delete  bm;          bm = NULL;
  }

  delete  imageFileNameWide;
  imageFileNameWide = NULL;
  return  r;
}

void KKB::SaveImage	(	const Raster &	image,
		const KKStr &	imageFileName
	)

Definition at line 617 of file ImageIO.cpp.

References KKB::BmpImage::BmpImage(), KKB::KKStr::Concat(), KKB::KKException::KKException(), KKB::KKStr::operator+(), operator+(), KKB::KKStr::operator==(), osGetFileExtension(), KKB::BmpImage::Save(), SaveImagePGM(), SaveImagePNG(), and KKB::KKStr::Upper().

Referenced by KKB::Chart::SaveAsImage(), KKB::Histogram::SaveGraphImage(), SaveImageInverted(), and KKB::Raster::SegmentImage().

{
  KKStr  extension = osGetFileExtension (imageFileName);
  extension.Upper ();

  if  (extension == "BMP")
  {
    try
    {
      BmpImage  bmpImage (image);
      bmpImage.Save (imageFileName);
    }
    catch  (const KKStr&  errMsg)
    {
      throw KKException (errMsg);
    }
    catch  (const KKException&  errMsg)
    {
      KKStr msg = "SaveImage  Exception  Saving image using 'BmpImage'";
      cerr << std::endl << msg << std::endl << std::endl;
      throw KKException (msg, errMsg);
    }
    catch (...)
    {
      KKStr  errMsg = "SaveImage   Exception occurred calling 'BmpImage::Save'  for file[" + imageFileName + "]";
      cerr << std::endl << errMsg << std::endl << std::endl;
      throw  KKException (errMsg);
    }
  }

  else if  (extension == "PGM")
  {
    SaveImagePGM (image, imageFileName);
  }

  else if  (extension == "PNG")
  {
    SaveImagePNG (image, imageFileName);
  }

  else
  {
    KKStr errMsg = "ImageIO::SaveImage    Extension[" + extension + "] is not supported.";

    cerr << std::endl << std::endl << std::endl
         << "SaveImage     *** ERROR ***    " << std::endl
         << errMsg << std::endl
         << std::endl;
    throw  KKException (errMsg);
  }

  return;
}  /* SaveImage */

void KKB::SaveImageGrayscaleInverted4Bit	(	const Raster &	image,
		const KKStr &	_fileName
	)

Saves image as BMP file using 4 bit compressed gray-scale where Background = 255 and foreground = 0.

If image is color will convert to gray-scale 1st. Palette will be set to 0 = 255, 1 = 238, 2 = 221, 3 = 204... 255 = 0.

Definition at line 874 of file ImageIO.cpp.

References KKB::BmpImage::BmpImage(), KKB::KKStr::Concat(), KKB::KKStr::EqualIgnoreCase(), KKB::KKException::KKException(), KKB::KKStr::operator+(), operator+(), osGetFileExtension(), and KKB::BmpImage::SaveGrayscaleInverted4Bit().

{
  KKStr  ext = osGetFileExtension (_fileName);
  if  (!ext.EqualIgnoreCase ("BMP"))
  {
    KKStr msg;
    msg << "KKB::SaveImageGrayscaleInverted4Bit   Only 'BMP' files are supported;  FileName[" << _fileName << "].";
    cerr << endl << "***ERROR***    " << msg << endl << endl;
    throw KKException (msg);
  }

  try
  {
    BmpImage  bmpImage (image);
    bmpImage.SaveGrayscaleInverted4Bit (_fileName);
  }
  catch  (const KKException&  errMsg)
  {
    KKStr msg = "SaveImageGrayscaleInverted4Bit  Exception  Saving image using 'BmpImage'  for file[" + _fileName + "]";
    cerr << std::endl << msg << std::endl << std::endl;
    throw KKException (msg, errMsg);
  }
  catch (...)
  {
    KKStr  errMsg = "SaveImageGrayscaleInverted4Bit   Exception occurred calling 'BmpImage::Save'  for file[" + _fileName + "]";
    cerr << std::endl << errMsg << std::endl << std::endl;
    throw  KKException (errMsg);
  }
}  /* SaveImageGrayscaleInverted4Bit */

void KKB::SaveImageGrayscaleInverted8Bit	(	const Raster &	image,
		const KKStr &	_fileName
	)

Saves image as BMP using compressed gray-scale where Background = 255 and foreground = 0.

Saves image as BMP using compressed GrayScale where Background = 255 and foreground = 0.

If image is color will convert to gray-scale 1st. Palette will be set to 0 = 255, 1 = 254, 2 = 253, ... 255 = 0.

If image is color will convert to GrayScale 1st. Palette will be set to 0 = 255, 1 = 254, 2 = 253, ... 255 = 0.

Definition at line 914 of file ImageIO.cpp.

References KKB::BmpImage::BmpImage(), KKB::KKStr::Concat(), KKB::KKStr::EqualIgnoreCase(), KKB::KKException::KKException(), KKB::KKStr::operator+(), operator+(), osGetFileExtension(), and KKB::BmpImage::SaveGrayscaleInverted8Bit().

{
  KKStr  ext = osGetFileExtension (_fileName);
  if  (!ext.EqualIgnoreCase ("BMP"))
  {
    KKStr msg;
    msg << "KKB::SaveImageGrayscaleInverted4Bit   Only 'BMP' files are supported;  FileName[" << _fileName << "].";
    cerr << endl << "***ERROR***    " << msg << endl << endl;
    throw KKException (msg);
  }

  try
  {
    BmpImage  bmpImage (image);
    bmpImage.SaveGrayscaleInverted8Bit (_fileName);
  }
  catch  (const KKException&  errMsg)
  {
    KKStr msg = "SaveImageGrayscaleInverted8Bit  Exception  Saving image using 'BmpImage'";
    cerr << std::endl << "***ERROR***    " << msg << std::endl << std::endl;
    throw KKException (msg, errMsg);
  }
  catch (...)
  {
    KKStr  errMsg = "SaveImageGrayscaleInverted8Bit   Exception occurred calling 'BmpImage::Save'  for file[" + _fileName + "]";
    cerr << std::endl << errMsg << std::endl << std::endl;
    throw  KKException (errMsg);
  }
}  /* SaveImageGrayscaleInverted4Bit */

void KKB::SaveImageInverted	(	Raster &	raster,
		const KKStr &	imageFileName
	)

Definition at line 841 of file ImageIO.cpp.

References KKB::Raster::Blue(), KKB::Raster::Color(), KKB::Raster::Green(), KKB::Raster::Height(), KKB::Raster::Raster(), KKB::Raster::Red(), SaveImage(), and KKB::Raster::Width().

{
  RasterPtr  invertedImage = new Raster (raster);

  kkint32  r, c;

  uchar**  g    = invertedImage->Green ();
  uchar**  red  = invertedImage->Red   ();
  uchar**  blue = invertedImage->Blue  ();

  for  (r = 0; r < invertedImage->Height ();  r++)
  {
    for  (c = 0;  c < invertedImage->Width ();  c++)
    {
      g[r][c] = 255 - g[r][c];
      if  (invertedImage->Color ())
      {
        red [r][c] = 255 - red [r][c];
        blue[r][c] = 255 - blue[r][c];
      }
    }
  }

  SaveImage (*invertedImage, imageFileName);
  delete  invertedImage;
  invertedImage = NULL;
}  /* SaveImageInverted */

void KKB::SaveImagePGM	(	const Raster &	image,
		const KKStr &	imageFileName
	)

Definition at line 675 of file ImageIO.cpp.

References KKB::Raster::Color(), KKB::KKStr::Concat(), KKB::Raster::CreateGrayScale(), KKB::Raster::GreenArea(), KKB::Raster::Height(), KKB::KKStr::KKStr(), osFOPEN(), KKB::KKStr::Str(), and KKB::Raster::Width().

Referenced by SaveImage().

{
  FILE* o = osFOPEN (imageFileName.Str (), "wb");

  {
    KKStr  headerStr (15);
    headerStr << "P5"            << endl
              << image.Width ()  << endl
              << image.Height () << endl
              << (kkint16)255    << endl;

    const char* h = headerStr.Str ();
    fwrite (h, 1, headerStr.Len (), o);
  }

  kkint32  totalPixels = image.Height () * image.Width ();

  if  (image.Color ())
  {
    RasterPtr  grayScaleImage = image.CreateGrayScale ();
    const uchar* g = grayScaleImage->GreenArea ();
    fwrite (g, 1, totalPixels, o);
    delete  grayScaleImage;
  }
  else
  {
    const uchar* g = image.GreenArea ();
    fwrite (g, 1, totalPixels, o);
  }
 
  fclose (o);
}  /* SaveImagePGM */

void KKB::SaveImagePNG	(	const Raster &	image,
		const KKStr &	imageFileName
	)

Definition at line 712 of file ImageIO.cpp.

References KKB::Raster::BlueArea(), KKB::Raster::Color(), KKB::KKStr::Concat(), KKB::Raster::GreenArea(), KKB::Raster::Height(), KKB::KKException::KKException(), KKB::KKStr::KKStr(), KKB::KKStr::operator+(), operator+(), osFOPEN(), KKB::Raster::RedArea(), KKB::KKStr::Str(), and KKB::Raster::Width().

Referenced by SaveImage().

{
  FILE* o = osFOPEN (imageFileName.Str (), "wb");
  if  (!o)
  {
    KKStr  errMsg = "SaveImagePNG   Error opening File[" + imageFileName + "]";
    cerr << std::endl << errMsg  << std::endl << std::endl;
    throw KKException (errMsg);
  }

  {
    KKStr  headerStr (15);
    headerStr << "P6"            << endl
              << image.Width ()  << endl
              << image.Height () << endl
              << (kkint16)255    << endl;

    const char* h = headerStr.Str ();
    fwrite (h, 1, headerStr.Len (), o);
  }

  kkint32  totalPixels = image.Height () * image.Width ();

  if  (image.Color ())
  {
    const uchar*  red   = image.RedArea   ();
    const uchar*  green = image.GreenArea ();
    const uchar*  blue  = image.BlueArea  ();

    for  (kkint32 x = 0;  x < totalPixels;  x++)
    {
      fwrite (red,   1, 1, o);  ++red;
      fwrite (green, 1, 1, o);  ++green;
      fwrite (blue,  1, 1, o);  ++blue;
    }
  }
  else
  {
    uchar*  green = image.GreenArea ();
    uchar  buff3[3];

    for  (kkint32 x = 0;  x < totalPixels;  x++)
    {
      uchar  intensity = 255 - (*green);
      buff3[0] = intensity;
      buff3[1] = intensity;
      buff3[2] = intensity;
      fwrite (buff3, 1, 3, o);
      ++green;
    }
  }

  fclose (o);
  o = NULL;

  return ;
}  /* SaveImagePNG */

void KKB::SaveImagePPM	(	const Raster &	image,
		const KKStr &	imageFileName
	)

Definition at line 774 of file ImageIO.cpp.

References KKB::Raster::BlueArea(), KKB::Raster::Color(), KKB::KKStr::Concat(), KKB::Raster::GreenArea(), KKB::Raster::Height(), KKB::KKException::KKException(), KKB::KKStr::KKStr(), KKB::KKStr::operator+(), operator+(), osFOPEN(), KKB::Raster::RedArea(), KKB::KKStr::Str(), and KKB::Raster::Width().

{
  FILE* o = osFOPEN (imageFileName.Str (), "wb");
  if  (!o)
  {
    KKStr  errMsg = "SaveImagePNG   Error opening File[" + imageFileName + "]";
    cerr << std::endl << errMsg  << std::endl << std::endl;
    throw KKException (errMsg);
  }

  {
    KKStr  headerStr (15);
    headerStr << "P6"            << endl
              << image.Width ()  << endl
              << image.Height () << endl
              << (kkint16)255    << endl;

    const char* h = headerStr.Str ();
    fwrite (h, 1, headerStr.Len (), o);
  }

  kkint32  totalPixels = image.Height () * image.Width ();

  if  (image.Color ())
  {
    const uchar*  red   = image.RedArea   ();
    const uchar*  green = image.GreenArea ();
    const uchar*  blue  = image.BlueArea  ();

    for  (kkint32 x = 0;  x < totalPixels;  x++)
    {
      fwrite (red,   1, 1, o);  ++red;
      fwrite (green, 1, 1, o);  ++green;
      fwrite (blue,  1, 1, o);  ++blue;
    }
  }
  else
  {
    uchar*  green = image.GreenArea ();
    uchar  buff3[3];

    for  (kkint32 x = 0;  x < totalPixels;  x++)
    {
      uchar  intensity = *green;
      buff3[0] = intensity;
      buff3[1] = intensity;
      buff3[2] = intensity;
      fwrite (buff3, 1, 3, o);
      ++green;
    }
  }

  fclose (o);
  o = NULL;

  return ;
}  /* SaveImagePPM */

kkint32 KKB::SPRINTF	(	char *	buff,
		kkint32	buffSize,
		const char *	formatSpec,
		kkint16	right
	)

Definition at line 162 of file KKStr.cpp.

Referenced by KKB::KKStr::operator+(), and StrFromInt16().

{
# ifdef  USE_SECURE_FUNCS
    return sprintf_s (buff, buffSize, formatSpec, right);
# else
    return sprintf (buff, formatSpec, right);
# endif
}

kkint32 KKB::SPRINTF	(	char *	buff,
		kkint32	buffSize,
		const char *	formatSpec,
		kkuint16	right
	)

Definition at line 177 of file KKStr.cpp.

Referenced by KKB::KKStr::operator+(), and StrFromUint16().

{
# ifdef  USE_SECURE_FUNCS
    return sprintf_s (buff, buffSize, formatSpec, right);
# else
    return sprintf (buff, formatSpec, right);
#endif
}

kkint32 KKB::SPRINTF	(	char *	buff,
		kkint32	buffSize,
		const char *	formatSpec,
		kkint32	right
	)

Definition at line 193 of file KKStr.cpp.

Referenced by KKB::KKStr::operator+(), KKB::KKStr::operator=(), and StrFromInt32().

{
# ifdef  USE_SECURE_FUNCS
    return sprintf_s (buff, buffSize, formatSpec, right);
# else
    return sprintf (buff, formatSpec, right);
# endif
}

kkint32 KKB::SPRINTF	(	char *	buff,
		kkint32	buffSize,
		const char *	formatSpec,
		kkuint32	right
	)

Definition at line 208 of file KKStr.cpp.

Referenced by KKB::KKStr::operator+(), and StrFromUint32().

{
# ifdef  USE_SECURE_FUNCS
    return sprintf_s (buff, buffSize, formatSpec, right);
# else
    return sprintf (buff, formatSpec, right);
#endif
}

kkint32 KKB::SPRINTF	(	char *	buff,
		kkint32	buffSize,
		const char *	formatSpec,
		kkint64	right
	)

Definition at line 223 of file KKStr.cpp.

Referenced by KKB::KKStr::operator+(), and StrFromInt64().

{
  
# ifdef  USE_SECURE_FUNCS
    return sprintf_s (buff, buffSize, formatSpec, right);
# else
    return sprintf (buff, formatSpec, right);
# endif
}

kkint32 KKB::SPRINTF	(	char *	buff,
		kkint32	buffSize,
		const char *	formatSpec,
		kkuint64	right
	)

Definition at line 239 of file KKStr.cpp.

Referenced by KKB::KKStr::operator+(), and StrFromUint64().

{

# ifdef  USE_SECURE_FUNCS
    return sprintf_s (buff, buffSize, formatSpec, right);
# else
    return sprintf (buff, formatSpec, right);
# endif
}

kkint32 KKB::SPRINTF	(	char *	buff,
		kkint32	buffSize,
		const char *	formatSpec,
		kkint32	precision,
		double	d
	)

Definition at line 255 of file KKStr.cpp.

Referenced by KKB::KKStr::KKStr().

{
#ifdef  USE_SECURE_FUNCS
  return  sprintf_s (buff, buffSize, formatSpec, precision, d);
#else
  return  sprintf (buff, formatSpec, precision, d);
#endif
}

kkint32 KKB::SPRINTF	(	char *	buff,
		kkint32	buffSize,
		char const *	formatSpec,
		double	d
	)

Definition at line 271 of file KKStr.cpp.

Referenced by KKB::KKStr::KKStr(), KKB::KKStr::operator+(), KKB::KKStr::operator<<(), StrFromDouble(), StrFromFloat(), and SVM289_MFS::Svm_Model::WriteXML().

{
  #ifdef  USE_SECURE_FUNCS
  return sprintf_s (buff, buffSize, formatSpec, d);
  #else
  return sprintf (buff, formatSpec, d);
  #endif
}

void KKB::SRand48

(

kkint64

_seed

)

Seeds the Lrand48 functions with the parameters passed to it.

Definition at line 49 of file KKBaseTypes.cpp.

References _lrand48_sequence.

{
  kkint64 seedMask = 65535;
  _lrand48_sequence &= seedMask;
  kkint64 upperBits = _seed;
  upperBits <<= 16;
  _lrand48_sequence |= upperBits;
}

char * KKB::STRCAT	(	char *	dest,
		kkint32	destSize,
		const char *	src
	)

Definition at line 74 of file KKStr.cpp.

{
# ifdef  USE_SECURE_FUNCS
    strcat_s  (dest, destSize, src);
# else
    strcat (dest, src);
# endif

  return  dest;
}  /* STRCAT */

char * KKB::STRCOPY	(	char *	dest,
		kkint32	destSize,
		const char *	src
	)

Definition at line 46 of file KKStr.cpp.

Referenced by KKB::KKStr::StrReplace().

{
# ifdef  USE_SECURE_FUNCS
    strcpy_s  (dest, destSize, src);
# else
    strcpy (dest, src);
# endif
  return  dest;
}  /* STRCOPY */

char * KKB::STRCOPY	(	char *	dest,
		kkuint16	destSize,
		const char *	src
	)

Definition at line 31 of file KKStr.cpp.

Referenced by KKB::KKStr::EnterStr(), KKB::KKStr::KKStr(), and KKB::KKStr::operator=().

{
# ifdef  USE_SECURE_FUNCS
    strcpy_s  (dest, destSize, src);
# else
    strcpy (dest, src);
# endif
  return  dest;
}  /* STRCOPY */

char * KKB::STRDUP

(

const char *

src

)

Definition at line 62 of file KKStr.cpp.

Referenced by KKB::Tokenizer::DefineOperatorChars(), KKB::KKStrParser::KKStrParser(), and KKB::KKStrParser::TrimWhiteSpace().

{
# ifdef  USE_SECURE_FUNCS
    return _strdup (src);
# else
    return  strdup (src);
# endif
}  /* STRDUP */

KKStr KKB::StrFormatDouble	(	double	val,
		const char *	mask
	)

Definition at line 4819 of file KKStr.cpp.

References KKB::KKStr::Concat(), KKB::KKStr::KKStr(), and LocateLastOccurrence().

Referenced by KKMLL::ConfusionMatrix2::AccuracyStr(), KKMLL::CrossValidationVoting::FoldAccuracysToStr(), KKLSC::ScannerFile::InitiateWritting(), KKMLL::ConfusionMatrix2::PrintAccuracyByProbByClassHTML(), and StrFormatInt().

{
  // Get number of decimal Places

  char  buff[512];
  char* bp = buff + 511;
  *bp = 0;

  bool  negativePrinted = true;

  if  (val < 0)
  {
    negativePrinted = false;
    val = fabs (val);
  }

  bool    printDecimalPoint = false;

  kkint32 numOfDecimalPlaces = 0;

  kkint32 maskLen = (kkint32)strlen (mask);
  
  kkint32 decimalPosition = LocateLastOccurrence (mask, '.');

  const char*  maskPtr = mask + maskLen - 1; 

  long  intPart = (long)floor (val);

  kkint32  nextDigit = 0;

  kkint32  x;

  if  (decimalPosition >= 0)
  {
    numOfDecimalPlaces = maskLen - decimalPosition - 1;
    printDecimalPoint = true;
    maskPtr = mask + decimalPosition - 1;
    maskLen = decimalPosition;
  }

  if  (printDecimalPoint)
  {
    double  power = pow ((double)10, (double)numOfDecimalPlaces);

    double  frac = val - floor (val);

    kkint32  fracInt = (kkint32)(frac * power + 0.5);

    for  (x = 0; x < numOfDecimalPlaces; x++)
    {
      nextDigit = fracInt % 10;
      fracInt   = fracInt / 10;
      bp--;
      *bp = (char)('0' + nextDigit);
    }

    if  (fracInt != 0)
    {
      // This can occur,  
      //  ex:  mask = "#0.000",  val = 1.9997
      //  fracInt will end up equaling 1.000. because of rounding.  
      intPart = intPart + fracInt;
    }

    bp--;
    *bp = '.';
  }

  char  formatChar = ' ';
  char  lastFormatChar = ' ';

  while  (maskLen > 0)
  {
    formatChar = (char)toupper (*maskPtr);

    switch (formatChar)
    {
      case  '0': 
      case  '@': 
           nextDigit = intPart % 10;
           intPart = intPart / 10;
           bp--;
           *bp = '0' + (uchar)nextDigit;
           break;


      case  '#':
      case  '9':
           if (intPart > 0)
           {
             nextDigit = intPart % 10;
             intPart = intPart / 10;
             bp--;
             *bp = '0' + (uchar)nextDigit;
           }
           else
           {
             bp--;
             *bp = ' ';
           }
           break;


      case  'Z':
           if (intPart > 0)
           {
             nextDigit = intPart % 10;
             intPart = intPart / 10;
             bp--;
             *bp = '0' + (uchar)nextDigit;
           }
           break;


      case  '-':
           if  (intPart > 0)
           {
             nextDigit = intPart % 10;
             intPart = intPart / 10;
             bp--;
             *bp = '0' + (uchar)nextDigit;
           }
           else
           {
             if  (!negativePrinted)
             {
               negativePrinted = true;
               bp--;
               *bp = '-';
             }
           }
           break;


      case  ',':
           if  (intPart > 0)
           {
             bp--;
             *bp = ',';
           }

           else if  (lastFormatChar != 'Z')
           {
             bp--;
             *bp = ' ';
           }
           break;
       

      default:
           bp--;
           *bp = formatChar;
           break;
    }  /* end of Switch (*maskPtr) */


    lastFormatChar = formatChar;

    maskPtr--;
    maskLen--;
  }
  
  // If the mask was not large enough to include all digits then lets do it now.
  while  (intPart > 0)
  {
    nextDigit = intPart % 10;
    intPart = intPart / 10;
    bp--;
    *bp = '0' + (uchar)nextDigit;
  }

  if  (!negativePrinted)
  {
    bp--;
    *bp = '-';
  }

  return  KKStr (bp);
}  /* StrFormatDouble */

KKStr KKB::StrFormatInt	(	kkint32	val,
		const char *	mask
	)

Definition at line 5004 of file KKStr.cpp.

References StrFormatDouble().

Referenced by KKMLL::GrayScaleImagesFVProducer::ComputeFeatureVector(), KKMLL::FeatureEncoder2::CreateEncodedFileDesc(), KKMLL::FeatureEncoder::CreateEncodedFileDesc(), KKMLL::FeatureFileIOColumn::GetFileDesc(), KKMLL::FeatureFileIOUCI::GetFileDesc(), KKMLL::FeatureFileIOSparse::GetFileDesc(), KKB::TimeType::HH_MM_SS(), KKB::DateTime::HH_MM_SS(), KKB::TimeType::HHMMSS(), KKLSC::ScannerFile::InitiateWritting(), KKMLL::FeatureFileIOColumn::LoadFile(), KKMLL::FeatureFileIOUCI::LoadFile(), KKMLL::FeatureFileIOC45::LoadFile(), KKB::DateType::MM_DD_YY(), KKB::DateType::MMM_DD_YYYY(), KKMLL::FileDesc::NewContinuousDataOnly(), KKB::RunLog::operator<<(), operator<<(), osCreateUniqueFileName(), KKB::Raster::SegmentImage(), KKB::KKStr::StrReplace(), KKMLL::ModelParamKnn::ToCmdLineStr(), KKB::PixelValue::ToStr(), KKMLL::SVMModel::WriteXML(), KKB::XmlElementArrayFloat2DVarying::WriteXML(), KKB::DateType::YY_MM_DD(), KKB::DateType::YYYY_MM_DD(), KKB::DateType::YYYY_MMM_DD(), and KKB::DateType::YYYYMMDD().

{
  return  KKB::StrFormatDouble ((double)val, mask);
}

KKStr KKB::StrFormatInt64	(	kkint64	val,
		const char *	mask
	)

Definition at line 5013 of file KKStr.cpp.

References KKB::KKStr::Concat(), and KKB::KKStr::KKStr().

Referenced by operator<<(), KKB::RunLog::operator<<(), and KKB::KKStr::operator<<().

{
  // Get number of decimal Places

  char  buff[128];
  char* bp = buff + 127;
  *bp = 0;

  bool  negativePrinted = true;

  if  (val < 0)
  {
    negativePrinted = false;
    val = 0 - val;
  }

  kkint32 maskLen = (kkint32)strlen (mask);
  const char*  maskPtr = mask + maskLen - 1; 

  kkint64  intPart = val;

  kkint32  nextDigit = 0;

  char  formatChar = ' ';
  char  lastFormatChar = ' ';

  while  (maskLen > 0)
  {
    formatChar = (uchar)toupper (*maskPtr);

    switch (formatChar)
    {
      case  '0': 
      case  '@': 
           nextDigit = intPart % 10;
           intPart = intPart / 10;
           bp--;
           *bp = '0' + (uchar)nextDigit;
           break;


      case  '#':
      case  '9':
           if (intPart > 0)
           {
             nextDigit = intPart % 10;
             intPart = intPart / 10;
             bp--;
             *bp = '0' + (uchar)nextDigit;
           }
           else
           {
             bp--;
             *bp = ' ';
           }
           break;


      case  'Z':
           if (intPart > 0)
           {
             nextDigit = intPart % 10;
             intPart = intPart / 10;
             bp--;
             *bp = '0' + (uchar)nextDigit;
           }
           break;


      case  '-':
           if  (intPart > 0)
           {
             nextDigit = intPart % 10;
             intPart = intPart / 10;
             bp--;
             *bp = '0' + (uchar)nextDigit;
           }
           else
           {
             if  (!negativePrinted)
             {
               negativePrinted = true;
               bp--;
               *bp = '-';
             }
           }
           break;


      case  ',':
           if  (intPart > 0)
           {
             bp--;
             *bp = ',';
           }

           else if  (lastFormatChar != 'Z')
           {
             bp--;
             *bp = ' ';
           }
           break;
       

      default:
           bp--;
           *bp = formatChar;
           break;
    }  /* end of Switch (*maskPtr) */


    lastFormatChar = formatChar;

    maskPtr--;
    maskLen--;
  }
  
  // If the mask was not large enough to include all digits then lets do it now.
  while  (intPart > 0)
  {
    nextDigit = intPart % 10;
    intPart = intPart / 10;
    bp--;
    *bp = '0' + (uchar)nextDigit;
  }

  if  (!negativePrinted)
  {
    bp--;
    *bp = '-';
  }

  return  KKStr (bp);
}  /* StrFormatInt */

KKStr KKB::StrFromDouble

(

double

d

)

Definition at line 5229 of file KKStr.cpp.

References KKB::KKStr::Concat(), KKB::KKStr::KKStr(), and SPRINTF().

Referenced by KKB::XmlElementKeyValuePairs::Add().

{
  char  buff[50];
  SPRINTF (buff, sizeof (buff), "%g", d);
  KKStr s (buff);
  return  s;
}  /* StrFromFloat */

KKStr KKB::StrFromFloat

(

float

f

)

Definition at line 5219 of file KKStr.cpp.

References KKB::KKStr::Concat(), KKB::KKStr::KKStr(), and SPRINTF().

Referenced by KKB::XmlElementKeyValuePairs::Add().

{
  char  buff[50];
  SPRINTF (buff, sizeof (buff), "%f", f);
  KKStr s (buff);
  return  s;
}  /* StrFromFloat */

KKStr KKB::StrFromInt16

(

kkint16

i

)

Definition at line 5152 of file KKStr.cpp.

References KKB::KKStr::Concat(), KKB::KKStr::KKStr(), and SPRINTF().

Referenced by KKMLL::Model::CreateAModel().

{
  char  buff[50];

  SPRINTF (buff, sizeof (buff), "%d", i);
  KKStr s (buff);
  return  s;
}  /* StrFromInt16 */

KKStr KKB::StrFromInt32

(

kkint32

i

)

Definition at line 5175 of file KKStr.cpp.

References KKB::KKStr::Concat(), KKB::KKStr::KKStr(), and SPRINTF().

Referenced by KKB::XmlElementKeyValuePairs::Add(), KKB::BmpImage::BlueRow(), KKB::BmpImage::ImageRow(), KKB::BmpImage::RedRow(), KKB::KKStr::RightPad(), tqli(), and Tred2().

{
  char  buff[50];
  
  SPRINTF (buff, sizeof (buff), "%ld", i);
  KKStr s (buff);
  return  s;
}  /* StrFromInt32 */

KKStr KKB::StrFromInt64

(

kkint64

i

)

Definition at line 5198 of file KKStr.cpp.

References KKB::KKStr::Concat(), KKB::KKStr::KKStr(), and SPRINTF().

{
  char  buff[50];
  
  SPRINTF (buff, sizeof (buff), "%lld", i64);
  KKStr s (buff);
  return  s;
}  /* StrFromInt64 */

KKStr KKB::StrFromUint16

(

kkuint16

ui

)

Definition at line 5164 of file KKStr.cpp.

References KKB::KKStr::Concat(), KKB::KKStr::KKStr(), and SPRINTF().

Referenced by KKB::KKStr::KKStr().

{
  char  buff[50];

  SPRINTF (buff, sizeof (buff), "%u", ui);
  KKStr s (buff);
  return  s;
}  /* StrFromUint16 */

KKStr KKB::StrFromUint32

(

kkuint32

ui

)

Definition at line 5187 of file KKStr.cpp.

References KKB::KKStr::Concat(), KKB::KKStr::KKStr(), and SPRINTF().

Referenced by KKB::KKStr::Append().

{
  char  buff[50];
  
  SPRINTF (buff, sizeof (buff), "%lu", ui);
  KKStr s (buff);
  return  s;
}  /* StrFromUint32 */

KKStr KKB::StrFromUint64

(

kkuint64

ui

)

Definition at line 5209 of file KKStr.cpp.

References KKB::KKStr::Concat(), KKB::KKStr::KKStr(), and SPRINTF().

{
  char  buff[50];
  SPRINTF (buff, sizeof (buff), "%llu", ul);
  KKStr s (buff);
  return  s;
}  /* StrFromUint64 */

kkint32 KKB::STRICMP	(	const char *	left,
		const char *	right
	)

Definition at line 92 of file KKStr.cpp.

Referenced by KKB::KKStr::ToBool().

{
  if  (left == NULL)
  {
    if  (right == NULL)
      return 0;
    else
      return -1;
  }
  else if  (!right)
    return 1;

  kkint32  zed = (toupper (*left)) - (toupper (*right));

  while  ((zed == 0)  &&  (*left != 0))
  {
    left++;    right++;
    zed = (toupper (*left)) - (toupper (*right));
  }

  if  (zed < 0)
    return -1;
  else if  (zed == 0)  
    return 0;
  else
    return 1;

}  /* STRICMP */

kkint32 KKB::STRNICMP	(	const char *	left,
		const char *	right,
		kkint32	len
	)

Definition at line 126 of file KKStr.cpp.

{
  if  (left == NULL)
  {
    if  (right == NULL)
      return 0;
    else
      return -1;
  }
  else if  (!right)
    return 1;

  if  (len < 1)
    return 0;

  kkint32  x = 0;
  kkint32  zed = (toupper (*left)) - (toupper (*right));
  while  ((zed == 0)  &&  (*left != 0)  &&  (x < len))
  {
    ++left;    ++right;     ++x;
    zed = (toupper (*left)) - (toupper (*right));
  }

  if  (zed < 0)
    return -1;
  else if  (zed == 0)  
    return 0;
  else
    return 1;
}  /* STRNICMP */

bool KKB::SupportedImageFileFormat

(

const KKStr &

imageFileName

)

Definition at line 948 of file ImageIO.cpp.

References KKB::KKStr::Concat(), KKB::KKStr::operator==(), osGetFileExtension(), and KKB::KKStr::Upper().

Referenced by KKMLL::FeatureFileIO::FeatureDataReSink().

{
  KKStr  ext = osGetFileExtension (imageFileName);
  ext.Upper ();

  return  (
           (ext == "BMP")  ||
           (ext == "PGM")  ||
           (ext == "PNG") 
          );
}

template<class T >

T KKB::Swap	(	T &	x,
		T &	y
	)

Definition at line 255 of file KKBaseTypes.h.

  {
    T z = x;
    x = y;
    y = z;
  }  /* Swap */

unsigned int KKB::ThreadStartCallBack

(

void *

param

)

Definition at line 280 of file KKThread.cpp.

References KKB::KKStr::Concat(), KKB::KKThread::Crashed(), KKB::KKThread::ExceptionText(), KKB::KKThread::Run(), KKB::KKThread::Starting, KKB::KKThread::Status(), KKB::KKThread::Stopped, and KKB::KKException::ToString().

  {
    KKThreadPtr  tp = (KKThreadPtr)param;
    tp->Status (KKThread::ThreadStatus::Starting);
    try  
    {
      tp->Run ();
    }
    catch  (const KKException&  e1)
    {
      tp->Crashed (true);
      tp->ExceptionText (e1.ToString ());
    }
    catch  (const std::exception e2)
    {
      tp->Crashed (true);
      const char* e2What = e2.what ();
      KKStr  msg (30 + strlen (e2What));
      msg << "std::exception: " << e2What;
      tp->ExceptionText (msg);
    }
    catch  (...)
    {
      tp->Crashed (true);
      tp->ExceptionText ("exception(...) trapped.");
    }

    tp->Status (KKThread::ThreadStatus::Stopped);
    return 0;
  }

void KKB::tqli	(	kkint32	n,
		double *	d,
		double *	e,
		double	z[2][2]
	)

Definition at line 195 of file EigenVector.cpp.

References KKB::KKException::KKException(), KKB::KKStr::operator+(), operator+(), pythag(), and StrFromInt32().

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

{
  if  ((n < 1)  ||  (n > 2))
    throw KKException ("KKB::tqli  n:" + StrFromInt32(n) + " out of range of 1 thru 2");

  kkint32  m, l, iter, i, k;
  double  s, r, p,g, f, dd, c, b;

  for  (i = 1;  i < n;  i++)
    e[i - 1] = e[i];

  e[n - 1] = 0.0;

  for  (l = 0;  l < n;  l++)
  {
    iter = 0;

    do 
    {
      for  (m = l;  m < n - 1;  m++)
      {
        // Looking for a single small sub-diagonal element
        // to split the matrix
        dd = fabs (d[m]) + fabs (d[m + 1]);
        if  (fabs (e[m]) + dd == dd)
          break;
      }

      if  (m != l)
      {
        if  (iter == 100)
        {
          cerr << std::endl << std::endl
               << "EigenVector::tqli    **** ERROR ****            To many iterations in tqli" << std::endl
               << std::endl;
          //osWaitForEnter ();
          //exit (-1);
          return;
        }
        iter++;

        g = (d[l + 1] - d[l]) / (2.0 * e[1]);
        r = pythag (g, 1.0);
        g = d[m] - d[l] + e[l] / (g + SIGN (r, g));
        s = c = 1.0;
        p = 0.0;

        for  (i = m - 1;  i >= l;  i--)
        {
          f = s * e[i];
          b = c * e[i];
          e[i + 1] = (r = pythag (f, g));
          if  (r == 0.0)
          {
            d[i + 1] -= p;
            e[m] = 0.0;
            break;
          }

          s = f / r;
          c = g / r;
          g = d[i + 1] - p;
          r = (d[i] - g) * s + 2.0 * c * b;
          d[i + 1] = g + (p = s * r);
          g = c * r - b;

          // Next loop can be omitted if eigen vectors not wanted

          for  (k = 0;  k < n;  k++)
          {
            f = z[k][i + 1];
            z[k][i + 1] = s * z[k][i] + c * f;
            z[k][i] = c * z[k][i] - s * f;
          }  /* for (k) */

        }  /* for (i) */

        if  ((r == 0.0)  &&  (i >= l))
          continue;

        d[l] -= p;
        e[l] = g;
        e[m] = 0.0;
      }
    } 
    while  (m != l);

  }  /* for (l) */

  return;
}  /* tqli */

void KKB::Tred2	(	kkint32	n,
		double	a[2][2],
		double *	d,
		double *	e
	)

Definition at line 31 of file EigenVector.cpp.

References KKB::KKException::KKException(), KKB::KKStr::operator+(), operator+(), and StrFromInt32().

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

{
  if ((n < 1) || (n > 2))
    throw KKException("KKB::Tred2  n:" + StrFromInt32(n) + " out of range of 1 thru 2");  kkint32  i, j, k, l;

  double  scale, hh, h, g, f;

  for (i = n - 1; i > 0;  i--)
  {
    l = i - 1;
    h = scale = 0.0;

    if  (l > 0)
    {
      for (k = 0;  k < l + 1;  k++)
        scale += fabs (a[i][k]);

      if  (scale == 0.0)
      {
        e[i] = a[i][l];
      }

      else
      {
        for (k = 0;  k < l + 1;  k++)
        {
          if  (scale == 0.0)
            a[i][k] = 0.0;
          else
            a[i][k] /= scale;     // Use scaled a's for transformation
          h+= a[i][k] * a[i][k];  // h = sigma
        }
        
        f = a[i][l];
        g = (f > 0 ? -sqrt(h) : sqrt(h));
        e[i] = scale * g;
        h -= f * g;
        a[i][l] = f - g;
        f = 0.0;

        for  (j = 0;  j < l + 1;  j++)
        {
          a[j][i] = a[i][j] / h;
          g = 0.0;
          for  (k = 0;  k < j + 1;  k++)
            g += a[j][k] * a[i][k];

          for  (k = j + 1;  k < l + 1;  k++)
            g += a[k][j] * a[i][k];

          e[j] = g / h;

          f += e[j] * a[i][j];
        } /* for  (j = 0; */

        hh = f / (h + h);

        for  (j = 0;  j < l + 1;  j++)
        {
          f = a[i][j];
          e[j] = g = e[j] - hh * f;
          for  (k = 0;  k < j + 1;  k++)
            a[j][k] -= (f * e[k] + g * a[i][k]);
        }
      }
    }  /* if  (l > 0) */
    else
    {
      e[i] = a[i][l];
    }

    d[i] = h;
  }

  // We can now calculate Eigen Vectors

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

  for  (i = 0;  i < n;  i++)
  {
    l = i;

    if  (d[i] != 0.0)
    {
      for  (j = 0;  j < l;  j++)
      {
        g = 0.0;
        for  (k = 0;  k < l;  k++)
          g += a[i][k] * a[k][j];

        for  (k = 0;  k < l;  k++)
          a[k][j] -= g * a[k][i];
      }
    }

    d[i] = a[i][i];

    // Reset row and column of 'a' to identity matrix;
    a[i][i] = 1.0;
    for  (j = 0;  j < l;  j++)
      a[j][i] = a[i][j] = 0.0;
  }  /* for (i) */

}  /* Tred2 */

XmlFactoryPtr KKB::XmlElementKKStrFactoryInstance

(

)

Definition at line 1415 of file XmlStream.cpp.

{
  return  XmlFactoryKKStr::FactoryInstance ();
}

XmlFactoryPtr KKB::XmlElementUnKnownFactoryInstance

(

)

Definition at line 1090 of file XmlStream.cpp.

Referenced by KKB::XmlStream::GetNextToken().

{
  return  XmlFactoryUnKnown::FactoryInstance ();
}

Variable Documentation

double KKB::DoubleMax = DBL_MAX

Definition at line 22 of file KKBaseTypes.cpp.

double KKB::DoubleMin = DBL_MIN

Definition at line 23 of file KKBaseTypes.cpp.

float KKB::FloatMax = FLT_MAX

Definition at line 20 of file KKBaseTypes.cpp.

Referenced by KKB::Chart::Chart(), KKMLL::FeatureVector::FeatureDataValid(), and KKB::ContourFollower::HistogramDistanceFromAPointOfEdge().

float KKB::FloatMin = FLT_MIN

Definition at line 21 of file KKBaseTypes.cpp.

Referenced by KKB::Chart::Chart(), KKMLL::FeatureVector::FeatureDataValid(), and KKB::ContourFollower::HistogramDistanceFromAPointOfEdge().

bool KKB::imageIoAtExitDefined = false

Definition at line 65 of file ImageIO.cpp.

Referenced by DefineImageIoAtExit().