bool ImportFullSizeFromSqlBackUp::ProcessCmdLineParameter (
char parmSwitchCode,
KKStr parmSwitch,
KKStr parmValue
)
{
KKStr parmValueUpper (parmValue);
parmValueUpper.Upper ();
parmSwitch.Upper ();
if ((parmSwitch == "-S") ||
(parmSwitch == "-SRC") ||
(parmSwitch == "-SOURCE") ||
(parmSwitch.EqualIgnoreCase ("-SrcFile"))
)
{
srcFileName = parmValue;
if (!osFileExists (srcFileName))
{
log.Level (-1) << "ProcessCmdLineParameter ***ERROR*** Invalid '-SrcFile' [" << srcFileName << "] file." << endl;
Abort (true);
}
}
return !Abort ();
} /* ProcessCmdLineParameter */
bool DumpSipper3InstrumentData::ProcessCmdLineParameter (char parmSwitchCode,
KKStr parmSwitch,
KKStr parmValue
)
{
parmSwitch.Upper ();
if ((parmSwitch == "-REPORT") ||
(parmSwitch == "-REPORTFILE") ||
(parmSwitch == "-RF") ||
(parmSwitch == "-R")
)
{
reportFileName = parmValue;
}
else
if ((parmSwitch == "-S") ||
(parmSwitch == "-SIPPERFILE") ||
(parmSwitch == "-SF")
)
{
sipperFileName = parmValue;
}
return !Abort ();
} /* ProcessCmdLineParameter */
bool AbundanceCorrectionStatsBuilder::ProcessCmdLineParameter (char parmSwitchCode,
KKStr parmSwitch,
KKStr parmValue
)
{
KKStr parmValueUpper (parmValue);
parmValueUpper.Upper ();
if (parmSwitch.EqualIgnoreCase ("-c") || parmSwitch.EqualIgnoreCase ("-config"))
{
configFileName = parmValue;
configFileFullPath = TrainingConfiguration2::GetEffectiveConfigFileName (configFileName);
if (!osFileExists (configFileFullPath))
{
log.Level (-1) << "ProcessCmdLineParameter ***ERROR*** Invalid '-config' [" << configFileName << "] file." << endl;
Abort (true);
}
}
else if (parmSwitch.EqualIgnoreCase ("-folds") || parmSwitch.EqualIgnoreCase ("-numFolds") || parmSwitch.EqualIgnoreCase ("-numOfFolds"))
{
numOfFolds = parmValue.ToInt ();
if ((numOfFolds < 2) || (numOfFolds > 1000))
{
log.Level (-1) << "ProcessCmdLineParameter ***ERROR*** Invalid '-NumFolds' [" << numOfFolds << "] Invlaid; valid values (2 - 1000)." << endl;
Abort (true);
}
}
else if (parmSwitch.EqualIgnoreCase ("-r") || parmSwitch.EqualIgnoreCase ("-report") || parmSwitch.EqualIgnoreCase ("-ReportFileName"))
reportFileName = parmValue;
return !Abort ();
} /* ProcessCmdLineParameter */
void KKJob::ProcessStatusStr (const KKStr& statusStr)
{
log.Level (30) << "KKJob::ProcessStatusStr[" << statusStr << "]" << endl;
KKStr fieldName;
KKStr fieldValue;
VectorKKStr fields = statusStr.Split ('\t');
kkuint32 fieldNum = 0;
while (fieldNum < fields.size ())
{
fieldName = fields[fieldNum];
fieldNum++;
if (fieldNum < fields.size ())
{
fieldValue = fields[fieldNum];
fieldNum++;
}
else
{
fieldValue = "";
}
fieldName.Upper ();
fieldValue.TrimLeft ("\n\r\t ");
fieldValue.TrimRight ("\n\r\t ");
if (fieldName.CompareIgnoreCase ("JOBID") == 0)
jobId = atoi (fieldValue.Str ());
else if (fieldName.CompareIgnoreCase ("PARENTID") == 0)
parentId = atoi (fieldValue.Str ());
else if (fieldName.CompareIgnoreCase ("STATUS") == 0)
status = JobStatusFromStr (fieldValue);
else if (fieldName.CompareIgnoreCase ("NumProcessors") == 0)
numProcessors = fieldValue.ToInt ();
else if (fieldName.CompareIgnoreCase ("NumPorcessesAllowed") == 0)
numPorcessesAllowed = fieldValue.ToInt ();
else if (fieldName.CompareIgnoreCase ("Prerequisites") == 0)
PrerequisitesFromStr (fieldValue);
else
{
ProcessStatusField (fieldName, fieldValue);
}
}
} /* ProcessStatusStr */
ClassPairStatus BinaryClass::BinaryClassStatusFromStr (KKStr statusStr)
{
statusStr.Upper ();
if (statusStr == "NOTSTARTED")
return ClassPairStatus::NotStarted;
if (statusStr == "STARTED")
return ClassPairStatus::Started;
if (statusStr == "DONE")
return ClassPairStatus::Done;
return ClassPairStatus::Null;
} /* BinaryClassStatusFromStr */
rjJobStatus RandomSampleJob::JobStatusFromStr (KKStr statusStr)
{
statusStr.Upper ();
if (statusStr == "OPEN")
return rjOpen;
if (statusStr == "STARTED")
return rjStarted;
if (statusStr == "DONE")
return rjDone;
return rjNULL;
} /* JobStatusFromStr */
/******************************************************************************
* ProcessCmdLineParamters
* DESC: Extracts parameters from the command line
******************************************************************************/
bool GradeClassification::ProcessCmdLineParameter (char parmSwitchCode,
KKStr parmSwitch,
KKStr parmValue
)
{
parmSwitch.Upper ();
if ((parmSwitch == "-R") || (parmSwitch == "-REPORT"))
{
reportFileName = parmValue;
}
else if ((parmSwitch == "-C") || (parmSwitch == "-CONFIG") || (parmSwitch == "-CONFIGFILE"))
{
configFileName = parmValue;
}
else if ((parmSwitch == "-SOURCEDIR") ||
(parmSwitch == "-SOURCEDIRECTORY") ||
(parmSwitch == "-SD") ||
(parmSwitch == "-S")
)
{
sourceRootDirPath = parmValue;
}
else if ((parmSwitch == "-HTML") || (parmSwitch == "-H"))
{
htmlFileName = parmValue;
}
else if ((parmSwitch == "-GROUNDTRUTH") || (parmSwitch == "-GT"))
{
groundTruthDirName = parmValue;
}
else
{
log.Level (-1) << endl << endl
<< "Unrecognized parameter[" << parmSwitch << "]" << endl
<< endl;
Abort (true);
}
return !Abort ();
} /* ProcessCmdLineParameter */
// Will scan for fields that are specific to 'JobValidation'
void JobValidation::ProcessStatusStr (KKStrParser& statusStr)
{
log.Level (30) << "JobValidation::ProcessStatusStr[" << statusStr.Str () << "]" << endl;
KKStr fieldName;
KKStr fieldValue;
while (statusStr.MoreTokens ())
{
fieldName = statusStr.GetNextToken ("\t\n\r");
fieldName.Upper ();
fieldValue = statusStr.GetNextToken ("\t");
fieldValue.TrimLeft ("\n\r\t ");
fieldValue.TrimRight ("\n\r\t ");
ProcessStatusField (fieldName, fieldValue);
}
} /* ProcessStatusStr */
void InstrumentDataPitchAndRoll::ProcessData (const KKStr& txt)
{
VectorKKStr fields = txt.Split (" \t\n\r");
if (fields.size () < 4)
return;
float pitch = -999.99f;
float roll = -999.99f;
KKStr fieldName = "";
KKStr fieldValue = "";
kkuint32 fieldNum = 0;
while (fieldNum < fields.size ())
{
fieldName = fields[fieldNum];
fieldName.Upper ();
fieldNum++;
if (fieldNum < fields.size ())
{
fieldValue = fields[fieldNum];
fieldNum++;
}
else
{
fieldValue = "";
}
if (fieldName == "R")
{
roll = fieldValue.ToFloat ();
}
else if (fieldName == "P")
{
pitch = fieldValue.ToFloat ();
}
}
manager->PitchAndRollData (curTextLineStartScanLine, pitch, roll);
} /* ProcessData */
void RandomSampleJobList::Load (TrainingConfigurationPtr _config,
OrderingsPtr _orderings,
int _numExamplesToKeep
)
{
FILE* in = fopen (jobFileName.Str (), "r");
if (!in)
{
log.Level (-1) << endl
<< endl
<< "RandomSampleJobList::Load *** ERROR ***" << endl
<< endl
<< " Error Opening Status File[" << jobFileName << "]" << endl
<< endl;
exit (-1);
}
char buff[10240];
while (fgets (buff, sizeof (buff), in))
{
KKStr statusStr (buff);
if (statusStr.SubStrPart (0, 1) == "//")
{
// We have a comment line, we want to ignore.
}
else
{
KKStr field = statusStr.ExtractToken (" \t\n\r");
field.Upper ();
if (field == "JOB")
{
RandomSampleJobPtr j = new RandomSampleJob (_config, _orderings, _numExamplesToKeep, statusStr);
PushOnBack (j);
}
}
}
fclose (in);
} /* Load */
void LogicalFrame::PerformMorphOperations ()
{
KKStr ops = parms.MorphOperations ();
memcpy (origFrameArea, frameArea, frameTotalPixels);
while (!ops.Empty ())
{
KKStr nextOp = ops.ExtractToken (",\n\r\t");
nextOp.Upper ();
if (nextOp == "O")
PerformOpening ();
else if (nextOp == "C")
PerformClosing ();
else if (nextOp == "D")
PerformDialation ();
else if (nextOp == "E")
PerformErosion ();
}
} /* PerformMorphOperations */
void BinaryClass::ProcessStatusStr (KKStr statusStr,
MLClassListPtr mlClasses
)
{
KKStr fieldName;
class1 = NULL;
class2 = NULL;
fieldName = statusStr.ExtractToken2 ("\t");
while (!fieldName.Empty ())
{
fieldName.TrimLeft ("\n\r\t ");
fieldName.TrimRight ("\n\r\t ");
fieldName.Upper ();
if (fieldName == "ALLCLASSES")
{
class1 = NULL;
class2 = NULL;
}
else if (fieldName == "BINARYCLASSES")
{
class1 = mlClasses->GetMLClassPtr (statusStr.ExtractToken2 ("\t"));
class2 = mlClasses->GetMLClassPtr (statusStr.ExtractToken2 ("\t"));
if ((class1 == NULL) || (class2== NULL))
{
cout << "Class1 or Class2 == NULL" << endl;
}
else
{
if ((class1->Name ().Empty ()) || (class1->Name ().Empty ()))
{
cout << "Class1Name or Class2Name are empty" << endl;
}
}
}
else if (fieldName == "STATUS")
status = BinaryClassStatusFromStr (statusStr.ExtractToken2 ("\t"));
else if (fieldName == "NUMPROCESSORS")
numProcessors = statusStr.ExtractTokenInt ("\t");
else if (fieldName.CompareIgnoreCase ("FinalResultType") == 0)
resultType = FinalResultTypeFromStr (statusStr.ExtractToken2 ("\t"));
else if (fieldName.CompareIgnoreCase ("ResultsFileName") == 0)
finalResultsFileName = statusStr.ExtractToken2 ("\t");
else if (fieldName.CompareIgnoreCase ("SelectionMethod") == 0)
selectionMethod = SelectionMethodFromStr (statusStr.ExtractToken2 ("\t"));
else if (fieldName.CompareIgnoreCase ("configFileName") == 0)
configFileName = statusStr.ExtractToken2 ("\t");
fieldName = statusStr.ExtractToken2 ("\t");
}
} /* ProcessStatusStr */
void Configuration::LoadFile (RunLog& log)
{
log.Level (10) << "Configuration::LoadFile: " << fileName << endl;
kkint32 lastLineNum = 0;
if (fileName == "")
{
log.Level (-1) << endl
<< "Configuration::LoadFile ***ERROR*** File-Name is blank" << endl
<< endl;
FormatGood (false);
return;
}
FILE* inFile = osFOPEN (fileName.Str (), "r");
if (!inFile)
{
log.Level (-1) << endl
<< "Configuration::LoadFile ***ERROR*** Opening File: " << fileName << endl
<< endl;
FormatGood (false);
return;
}
char buff[10240];
kkint32 lineCount = 0;
curSectionName = "";
ConfSectionPtr curSection = NULL;
while (fgets (buff, sizeof (buff), inFile))
{
lastLineNum++;
KKStr line (buff);
line.TrimRight ();
line.TrimLeft ();
StripOutAnyComments (line);
log.Level (70) << line << endl;
StripOutAnyComments (line);
if (line.Empty ())
{
// If we have a blank line, we do nothing.
}
else if (line.FirstChar () == '[')
{
// Looks like definition of new section.
if (line.LastChar () == ']')
{
curSectionName = line.SubStrPart (1, line.Len () - 2);
curSectionName.TrimLeft ();
curSectionName.TrimRight ();
curSectionName.Upper ();
curSection = new ConfSection (curSectionName, lastLineNum);
sections->AddConfSection (curSection);
log.Level (30) << "LoadFile SectionName[" << curSectionName << "]." << endl;
}
else
{
log.Level (-1) << endl
<< "Configuration::LoadFile ***ERROR*** LineNumber[" << lastLineNum << "] Improper Section Name[" << line << "]." << endl
<< endl;
formatGood = false;
}
}
else
{
if (!curSection)
{
log.Level (-1) << endl
<< "Configuration::LoadFile ***ERROR*** Format Error LineNumber[" << lastLineNum << "]" << endl
<< " No Section Defined." << endl
<< endl;
formatGood = false;
curSectionName = "GLOBAL";
curSection = new ConfSection (curSectionName, lastLineNum);
sections->AddConfSection (curSection);
}
kkint32 equalIdx = line.LocateCharacter ('=');
if (equalIdx < 0)
{
// We have a improperly formated line.
log.Level (-1) << endl
<< "Configuration::LoadFile ***ERROR*** LineNumber[" << lastLineNum << "] Improperly Formated Line[" << line << "]."
<< endl;
formatGood = false;
}
else
{
KKStr settingName (line.SubStrPart (0, equalIdx - 1));
settingName.TrimLeft ();
settingName.TrimRight ();
settingName.Upper ();
KKStr settingValue (line.SubStrPart (equalIdx + 1));
settingValue.TrimLeft ();
settingValue.TrimRight ();
log.Level (30) << "LoadFile SectionName[" << curSectionName << "], "
<< "Setting[" << settingName << "], Value[" << settingValue << "]."
<< endl;
curSection->AddSetting (settingName, settingValue, lastLineNum);
}
lineCount++;
}
}
fclose (inFile);
} /* LoadFile */
void ActiveLearningReport::Load (KKStr fileName,
bool& validFormat
)
{
validFormat = false;
FILE* f = osFOPEN (fileName.Str (), "r");
if (!f)
{
log.Level (-1) << endl
<< "ActiveLearningReport::Load *** ERROR ***" << endl
<< endl
<< " Could noty open File[" << fileName << "]" << endl
<< endl;
return;
}
char buff[10240];
bool fileParmsLoaded = false;
{
// Get Frst Row wicj should be InitialTrainingImagesPerClass
if (!fgets (buff, sizeof (buff), f))
{
log.Level (-1) << endl
<< "ActiveLearningReport::Load *** ERROR ***" << endl
<< endl
<< " *** No Data ***" << endl
<< endl;
fclose (f);
return;
}
KKStr l (buff);
l.Upper ();
KKStr field = l.ExtractToken ("\n\t\r ");
if (field != "\\INITIALTRAININGIMAGESPERCLASS")
{
log.Level (-1) << endl
<< "ActiveLearningReport::Load *** ERROR ***" << endl
<< endl
<< " First Liine Not Valid[" << l << "]" << endl
<< endl;
fclose (f);
return;
}
initialImagesPerClass = l.ExtractTokenInt ("\n\t\r ");
}
{
// Get second Row wicj should be ImagesPerRetraining
if (!fgets (buff, sizeof (buff), f))
{
log.Level (-1) << endl
<< "ActiveLearningReport::Load *** ERROR ***" << endl
<< endl
<< " *** Missing Second Line ***" << endl
<< endl;
fclose (f);
return;
}
KKStr l (buff);
l.Upper ();
KKStr field = l.ExtractToken ("\n\t\r ");
if (field != "\\IMAGESPERRETRAINING")
{
log.Level (-1) << endl
<< "ActiveLearningReport::Load *** ERROR ***" << endl
<< endl
<< " Second Liine Not Valid[" << l << "]" << endl
<< endl;
fclose (f);
return;
}
imagesPerRetraining = l.ExtractTokenInt ("\n\t\r ");
}
SortOrderResultsPtr curSortOrderResults = NULL;
while (fgets (buff, sizeof (buff), f))
{
KKStr l (buff);
if (l.SubStrPart (0, 0) == "\\")
{
if (curSortOrderResults)
{
results.PushOnBack (curSortOrderResults);
curSortOrderResults = NULL;
}
SortOrderType nextSortOrder = NULL_SortOrder;
int numOfRetrainings = 0;
while (l.SubStrPart (0, 0) == "\\")
{
l = l.SubStrPart (1);
l.Upper ();
KKStr fieldName = l.ExtractToken ("\n\t\r ");
if (fieldName == "SORTORDER")
{
KKStr sortOrderDesc = l.ExtractToken ("\n\t\r ");
nextSortOrder = SortOrderTypeFromStr (sortOrderDesc);
}
else if (fieldName == "NUMOFRETRAININGS")
{
numOfRetrainings = l.ExtractTokenInt ("\n\t\r ");
}
if (fgets (buff, sizeof (buff), f))
l = buff;
else
l = "";
}
if (nextSortOrder == NULL_SortOrder)
{
log.Level (-1) << "ActiveLearningReport::Load *** ERROR ***" << endl
<< endl
<< " Invalid Sort Order Defined." << endl
<< endl;
fclose (f);
return;
}
curSortOrderResults = new SortOrderResults (nextSortOrder);
}
if (!curSortOrderResults)
{
log.Level (-1) << "ActiveLearningReport::Load *** ERROR ***" << endl
<< endl
<< " Invalid Sort Order Defined." << endl
<< endl;
fclose (f);
return;
}
float numOfTrainingImages = (float)l.ExtractTokenDouble ("\n\t\r ");
float accuracy = (float)l.ExtractTokenDouble ("\n\t\r ");
float numOfSupportVectors = (float)l.ExtractTokenDouble ("\n\t\r ");
RetrainingResultsPtr retrainingResults = new RetrainingResults (numOfTrainingImages,
accuracy,
numOfSupportVectors
);
curSortOrderResults->PushOnBack (retrainingResults);
}
if (curSortOrderResults)
{
results.PushOnBack (curSortOrderResults);
curSortOrderResults = NULL;
}
fclose (f);
validFormat = true;
return;
} /* Load */
void RandomSampleJob::ProcessStatusStr (KKStr statusStr)
{
log.Level (30) << "RandomSampleJob::ProcessStatusStr[" << statusStr << "]" << endl;
KKStr fieldName;
KKStr fieldValue;
compMethod = BRNull;
fieldName = statusStr.ExtractToken ("\t\n\r");
while (!fieldName.Empty ())
{
fieldName.Upper ();
fieldValue = statusStr.ExtractToken ("\t\n\r");
fieldValue.TrimLeft ("\n\r\t ");
fieldValue.TrimRight ("\n\r\t ");
if (fieldName == "JOBID")
jobId = atoi (fieldValue.Str ());
else if (fieldName == "STATUS")
status = JobStatusFromStr (fieldValue);
else if (fieldName == "KERNEL")
kernelType = KernalTypeFromStr (fieldValue);
else if (fieldName == "ENCODING")
encodingMethod = EncodingMethodFromStr (fieldValue);
else if (fieldName == "COMPMETHOD")
compMethod = CompressionMethodFromStr (fieldValue);
else if (fieldName == "C_PARAM")
c = atoi (fieldValue.Str ());
else if (fieldName == "GAMMA")
gamma = atof (fieldValue.Str ());
else if (fieldName == "ORDERINGNUM")
orderingNum = atoi (fieldValue.Str ());
else if (fieldName == "EXAMPLESTOKEEP")
numExamplesToKeep = atoi (fieldValue.Str ());
else if (fieldName == "ACCURACY")
accuracy = (float)atof (fieldValue.Str ());
else if (fieldName == "TRAINTIME")
{
trainTime = atof (fieldValue.Str ());
}
else if (fieldName == "PREDTIME")
testTime = (float)atof (fieldValue.Str ());
else if (fieldName == "SUPPORTVECTORS")
supportVectors = (float)atof (fieldValue.Str ());
else
{
log.Level (-1) << "RandomSampleJob::ProcessStatusStr Invalid Field Name[" << fieldName << "]." << endl;
}
fieldName = statusStr.ExtractToken ("\t\n\r");
}
} /* ProcessStatusStr */
/******************************************************************************
* ProcessCmdLineParamters
* DESC: Extracts parameters from the command line
******************************************************************************/
bool FeatureFileConverter::ProcessCmdLineParameter (char parmSwitchCode,
KKStr parmSwitch,
KKStr parmValue
)
{
KKStr parmValueUpper (parmValue);
parmValueUpper.Upper ();
parmSwitch.Upper ();
if ((parmSwitch == "-DEST") ||
(parmSwitch == "-D") ||
(parmSwitch == "-DESTFILE") ||
(parmSwitch == "-DF") ||
(parmSwitch == "-DESTFILENAME") ||
(parmSwitch == "-DFN")
)
destFileName = parmValue;
else if ((parmSwitch == "-OUTFORMAT") ||
(parmSwitch == "-OF") ||
(parmSwitch == "-OUTFILEFORMAT") ||
(parmSwitch == "-OFF") ||
(parmSwitch == "-DESTFILEFORMAT") ||
(parmSwitch == "-DESTFORMAT") ||
(parmSwitch == "-DFF")
)
{
destFileFormat = FeatureFileIO::FileFormatFromStr (parmValue,
false, // Don't care if valid read format
true // must be valid write format
);
if (destFileFormat == NULL)
{
log.Level (-1) << endl
<< endl
<< "Invalid Write File Format Specified[" << parmValue << endl
<< endl
<< "Valid Formats are <" << FeatureFileIO::FileFormatsWrittenOptionsStr () << ">" << endl
<< endl;
Abort (true);
}
}
else if ((parmSwitch == "-ENCODEFEATUREDATA") ||
(parmSwitch == "-ENCODEFEATURES") ||
(parmSwitch == "-EF")
)
{
encodingMethod = ModelParam::EncodingMethodFromStr (parmValue);
if (encodingMethod != Encoding_NULL)
{
encodeFeatureData = true;
}
else
{
if ((parmValue == "NO") ||
(parmValue == "OFF") ||
(parmValue == "N")
)
encodeFeatureData = false;
else
{
encodingMethod = ModelParam::BinaryEncoding;
encodeFeatureData = true;
}
}
}
else if ((parmSwitch == "-ENUMERATECLASSES") ||
(parmSwitch == "-ENUMERATECLASS") ||
(parmSwitch == "-EC")
)
{
if ((parmValue == "NO") ||
(parmValue == "OFF") ||
(parmValue == "N")
)
enumerateClasses = false;
else
enumerateClasses = true;
}
else if (parmSwitch == "-FEATURES")
{
featureStr = parmValue;
}
else if ((parmSwitch == "-IF") ||
(parmSwitch == "-INPUTFORMAT") ||
(parmSwitch == "-IFF") ||
(parmSwitch == "-INFILEFORMAT") ||
(parmSwitch == "-SFF") ||
(parmSwitch == "-SrcFileFormat")
)
{
srcFileFormat = FeatureFileIO::FileFormatFromStr (parmValue,
true, // Valid Read Format
false // Don't care if valid write format
);
if (srcFileFormat == NULL)
{
log.Level (-1) << endl
<< endl
<< "Invalid Source File Format Specified[" << parmValue << endl
<< endl
<< "Valid Formats are <" << FeatureFileIO::FileFormatsReadOptionsStr () << ">" << endl
<< endl;
Abort (true);
}
}
else if ((parmSwitch == "-NORM") || (parmSwitch == "-NORMALIZE"))
{
normalizeData = true;
parmValue.TrimLeft ();
parmValue.TrimRight ();
if (!parmValue.Empty ())
nornParmsFileName = parmValue;
}
else if ((parmSwitch == "-R") || (parmSwitch == "-REPORT"))
reportFileName = parmValue;
else if ((parmSwitch == "-S") ||
(parmSwitch == "-SRC") ||
(parmSwitch == "-SF") ||
(parmSwitch == "-SOURCFILE") ||
(parmSwitch == "-SFN") ||
(parmSwitch == "-SRCFILENAME") ||
(parmSwitch == "-SOURCFILENAME")
)
srcFileName = parmValue;
else if ((parmSwitch == "-STAT") ||
(parmSwitch == "-STATS") ||
(parmSwitch == "-STATISTICS")
)
statistics = true;
else
{
log.Level (-1) << endl
<< "ProcessCmdLineParameter Invalid Parameter[" << parmSwitch << "]" << endl
<< endl;
Abort (true);
}
return !Abort ();
} /* ProcessCmdLineParameter */
/******************************************************************************
* ProcessCmdLineParamters
* DESC: Extracts parameters from the command line
******************************************************************************/
bool RandomNND::ProcessCmdLineParameter (
char parmSwitchCode,
KKStr parmSwitch,
KKStr parmValue
)
{
KKStr parmValueUpper (parmValue);
parmValueUpper.Upper ();
parmSwitch.Upper ();
if ((parmSwitch == "-BUCKETS") || (parmSwitch == "-B"))
{
numOfBuckets = atoi (parmValue.Str ());
if (numOfBuckets < 3)
{
log.Level (-1) << endl
<< "ProcessCmdLineParameter *** ERROR ***" << endl
<< " NumOfBuckets[" << numOfBuckets << "] Must be breater than 2" << endl
<< endl;
Abort (true);
}
}
else if ((parmSwitch == "-BUCKETSIZE") || (parmSwitch == "-BS"))
{
bucketSize = atoi (parmValue.Str ());
if (bucketSize < 1)
{
log.Level (-1) << endl
<< "ProcessCmdLineParameter *** ERROR ***" << endl
<< " BucketSize[" << bucketSize << "] Must be breater than 0" << endl
<< endl;
Abort (true);
}
}
else if ((parmSwitch == "-MINSIZE") || (parmSwitch == "-MS"))
{
minSize = (double)atof (parmValue.Str ());
if (minSize < 1.0)
{
log.Level (-1) << endl
<< "ProcessCmdLineParameter *** ERROR ***" << endl
<< " MinSize[" << minSize << "] Must be breater than 1.0" << endl
<< endl;
Abort (true);
}
}
else if ((parmSwitch == "-PARTICLES") || (parmSwitch == "-P"))
{
numOfParticles = atoi (parmValue.Str ());
if (numOfParticles < 2)
{
log.Level (-1) << endl
<< "ProcessCmdLineParameter *** ERROR ***" << endl
<< " numOfParticles[" << numOfParticles << "] Must be breater than 1." << endl
<< endl;
Abort (true);
}
}
else if ((parmSwitch == "-ITERATIONS") || (parmSwitch == "-I"))
{
numIterations = atoi (parmValue.Str ());
if (numIterations < 1)
{
log.Level (-1) << endl
<< "ProcessCmdLineParameter *** ERROR ***" << endl
<< " NumIterations[" << numIterations << "] Must be breater than 0." << endl
<< endl;
Abort (true);
}
}
else if ((parmSwitch == "-R") || (parmSwitch == "-REPORT"))
reportFileName = parmValue;
else if ((parmSwitch == "-SCANLINES") || (parmSwitch == "-SL"))
{
scanLines = atoi (parmValue.Str ());
if (scanLines < 100)
{
log.Level (-1) << endl
<< "ProcessCmdLineParameter *** ERROR ***" << endl
<< " scanLines[" << scanLines << "] Must be breater than 100." << endl
<< endl;
Abort (true);
}
}
else
{
log.Level (-1) << endl
<< "ProcessCmdLineParameter Invalid Parameter[" << parmSwitch << "]" << endl
<< endl;
Abort (true);
}
return !Abort ();
} /* ProcessCmdLineParameter */
bool RandomSplits::ProcessCmdLineParameter (char parmSwitchCode,
KKStr parmSwitch,
KKStr parmValue
)
{
KKStr parmValueUpper (parmValue);
parmValueUpper.Upper ();
parmSwitch.Upper ();
if ((parmSwitch == "-CONFIGFILENAME") || (parmSwitch == "-C") || (parmSwitch == "-CONFIG"))
{
configFileName = parmValue;
}
else if ((parmSwitch == "-DATAFILE") || (parmSwitch == "-DF"))
{
dataFileName = parmValue;
}
else if ((parmSwitch == "-F") || (parmSwitch == "-FORMAT"))
{
format = FeatureFileIO::FileFormatFromStr (parmValue);
if (!format)
{
log.Level (-1) << endl << endl
<< "ProcessCmdLineParameter ***ERROR*** No such format as[" << parmValue<< "]." << endl
<< endl;
Abort (true);
}
}
else if (parmSwitch.EqualIgnoreCase ("-NumFolds") ||
parmSwitch.EqualIgnoreCase ("-NF") ||
parmSwitch.EqualIgnoreCase ("-NumOfFolds") ||
parmSwitch.EqualIgnoreCase ("-NOF")
)
{
numFolds = parmValue.ToInt ();
if ((numFolds != 0) && (numFolds < 2))
{
log.Level (-1) << endl
<< "ProcessCmdLineParameter ***ERROR*** Invalid NumFolds[" << parmValue<< "]." << endl
<< " Must be '0' or greter than '1'." << endl
<< endl;
Abort (true);
}
}
else if ((parmSwitch == "-NUMSPLITS") || (parmSwitch == "-NS") || (parmSwitch == "-SPLITS"))
{
numSplits = parmValue.ToInt ();
}
else if ((parmSwitch == "-SPLITPERCENTAGE") || (parmSwitch == "-SP"))
{
bool percentage = false;
if (parmValue.LastChar () == '%')
{
percentage = true;
parmValue.ChopLastChar ();
}
splitFraction = parmValue.ToFloat ();
if (percentage)
splitFraction = splitFraction / 100.0f;
else
{
if (splitFraction >= 1.0f)
{
log.Level (-1) << endl << endl
<< "ProcessCmdLineParameter ***ERROR*** Invalid Split Percentage[" << splitFraction << "]" << endl
<< endl
<< " If you want to enter as percentage include a '%' sign otherwise it is assumed to be a fraction." << endl
<< endl;
}
}
}
else if (parmSwitch.EqualIgnoreCase ("Restart"))
{
restart = true;
}
else
{
log.Level (-1) << endl << endl
<< "ProcessCmdLineParameter ***ERROR***" << endl
<< endl
<< " Invalid Parameter[" << parmSwitch << "]" << endl
<< endl;
Abort (true);
}
return !Abort ();
} /* ProcessCmdLineParameter */
