} /* UpdateDetailProbabilityDisplay */
private void UpdateBinaryClassifierProbabilities(String className)
{
PicesClass leftClass = PicesClassList.GetUniqueClass(className, "");
BinaryClassName.Text = "";
BinaryProbabilities.Rows.Clear();
Prediction pred = GetPrediction(curSelImageFileName);
PicesPredictionList binaryPredictions = pred.trainModel.BinaryProbailitiesForClass(leftClass);
if (binaryPredictions == null)
{
return;
}
BinaryClassName.Text = leftClass.Name;
foreach (PicesPrediction p in binaryPredictions)
{
if (leftClass == p.MLClass)
{
continue;
}
Object[] data = new Object[2];
data[0] = p.ClassName;
double probForRightSide = 1.0 - p.Probability;
data[1] = probForRightSide;
BinaryProbabilities.Rows.Add(data);
}
} /* UpdateBinaryClassifierProbabilities */
} /* MakePredictions */
public static void MakePredictions(PicesFeatureVector featureVector,
ref PicesPredictionList model1Predictions,
ref PicesPredictionList model2Predictions,
PicesRunLog runLog
)
{
model1Predictions = null;
model2Predictions = null;
if ((!ModelsAreAvailable()) || (featureVector == null))
{
return;
}
if (model1 != null)
{
model1Predictions = model1.PredictProbabilities(featureVector);
}
if (model2 != null)
{
model2Predictions = model2.PredictProbabilities(featureVector);
}
return;
} /* MakePredictions */
} /* LoadImageGrid */
private void UpdateDetailProbabilityDisplay()
{
if ((trainingModel == null) || (trainingModel.ModelType != TrainingModel2.ModelTypes.Dual))
{
return;
}
PicesPredictionList class1Results = null;
PicesPredictionList class2Results = null;
String classifier1Desc = null;
String classifier2Desc = null;
PicesFeatureVector fvToUse = dbFeatureVector;
if (fvToUse == null)
{
fvToUse = featureVector;
}
trainingModel.ProbabilitiesByClassDual(fvToUse,
ref classifier1Desc,
ref classifier2Desc,
ref class1Results,
ref class2Results
);
this.Classifier1Name.Text = classifier1Desc;
this.Classifier2Name.Text = classifier2Desc;
if (class1Results != null)
{
Classifier1Probabilities.Rows.Clear();
foreach (PicesPrediction p in class1Results)
{
Object[] data = new Object[3];
data[0] = p.ClassName;
data[1] = p.Probability;
data[2] = p.Votes;
Classifier1Probabilities.Rows.Add(data);
}
}
if (class2Results != null)
{
Classifier2Probabilities.Rows.Clear();
foreach (PicesPrediction p in class2Results)
{
Object[] data = new Object[3];
data[0] = p.ClassName;
data[1] = p.Probability;
data[2] = p.Votes;
Classifier2Probabilities.Rows.Add(data);
}
}
} /* UpdateDetailProbabilityDisplay */
/// <summary>
/// Using supplied 'Raster' data it will call each currently active model and return there predictions.
/// </summary>
/// <param name="raster">Raster of image to predict. .</param>
/// <param name="instrumentData">Instrument data that was recorded with the 'raster' .</param>
/// <param name="imageFileName">Name of the image file.</param>
/// <param name="model1Predictions">The model1 predictions.</param>
/// <param name="model2Predictions">The model2 predictions.</param>
/// <param name="runLog">The run log.</param>
public static void MakePredictions(PicesRaster raster,
InstrumentData instrumentData,
String imageFileName,
ref PicesPredictionList model1Predictions,
ref PicesPredictionList model2Predictions,
PicesRunLog runLog
)
{
model1Predictions = null;
model2Predictions = null;
if (!ModelsAreAvailable())
{
return;
}
ParsedImageFileName pifn = PicesFeatureVector.ParseImageFileName(imageFileName);
String sipperFileName = pifn.sipperFileName;
uint scanLineNum = pifn.scanLineNum;
PicesFeatureVector fv = new PicesFeatureVector(raster, imageFileName, null, runLog);
if (instrumentData != null)
{
fv.AddInstrumentData(instrumentData.Depth(),
instrumentData.Salinity(),
instrumentData.Oxygen(),
instrumentData.Fluorescence()
);
}
else
{
PicesDataBase dbConn = PicesDataBase.GetGlobalDatabaseManagerNewInstance(runLog);
PicesInstrumentData pid = dbConn.InstrumentDataGetByScanLine(sipperFileName, scanLineNum);
if (pid != null)
{
fv.AddInstrumentData(pid);
}
pid = null;
dbConn.Close();
dbConn = null;
}
if (model1 != null)
{
model1Predictions = model1.PredictProbabilities(fv);
}
if (model2 != null)
{
model2Predictions = model2.PredictProbabilities(fv);
}
fv = null;
return;
} /* MakePredictions */
private PicesPredictionList PredictClasses(PicesFeatureVector fv,
PicesPrediction pred1,
PicesPrediction pred2,
String imageFileName,
String imageFileRootName
)
{
PicesFeatureVector fvToUse = fv;
PicesPredictionList probPredList = null;
if (fvToUse.FeatureDataMissing)
{
fvToUse = null;
// Feature data is missing. we need to compute from original image.
PicesDataBaseImage pdbi = DbConn().ImageLoad(imageFileRootName);
if (pdbi != null)
{
PicesRaster pr = DbConn().ImageFullSizeFind(imageFileRootName);
if (pr == null)
{
ErrorMsgsAdd("Failed to Load FullSize image [" + imageFileRootName + "]");
}
else
{
fvToUse = new PicesFeatureVector(pr, imageFileName, null, runLog);
// Since we had to compute the FeatureDatya from the raster image we now need to
// get the instrument data that matches it.
PicesInstrumentData id = DbConn().InstrumentDataGetByScanLine(pdbi.SipperFileName, pdbi.TopLeftRow);
if (id != null)
{
fvToUse.AddInstrumentData(id);
}
DbConn().FeatureDataInsertRow(pdbi.SipperFileName, fvToUse);
pr.Dispose();
}
pr = null;
}
}
if (fvToUse != null)
{
classifier.PredictClass(fvToUse, pred1, pred2);
probPredList = classifier.PredictProbabilities(fvToUse);
}
else
{
pred1.MLClass = PicesClassList.GetUnKnownClassStatic(); pred1.Probability = 1.0f;
pred2.MLClass = PicesClassList.GetUnKnownClassStatic(); pred2.Probability = 0.0f;
}
return(probPredList);
} /* PredictClasses */
public PredictionResult(String _imageRootName,
int _class1Id,
double _class1Prob,
int _class2Id,
double _class2Prob,
PicesPredictionList _probPredList
)
{
imageRootName = _imageRootName;
class1Id = _class1Id;
class1Prob = _class1Prob;
class2Id = _class2Id;
class2Prob = _class2Prob;
probPredList = _probPredList;
}
} /* LoadImageGrid */
private void UpdateDetailProbabilityDisplay()
{
if (trainingModel == null)
{
return;
}
PicesPredictionList guesses = trainingModel.PredictProbabilities(featureVector);
if (guesses == null)
{
return;
}
ClassificationProbabilities.Rows.Clear();
foreach (PicesPrediction p in guesses)
{
Object[] data = new Object[3];
data[0] = p.ClassName;
data[1] = p.Probability;
data[2] = p.Votes;
ClassificationProbabilities.Rows.Add(data);
}
FeatureCalcImages.Rows.Clear();
if (featureCalcImages == null)
{
return;
}
for (int x = 0; x < featureCalcImages.Count; x++)
{
Object[] data = new Object[2];
data[0] = featureCalcImages[x].BuildBitmap();
data[1] = featureCalcImages[x].FileName;
FeatureCalcImages.Rows.Add(data);
}
} /* UpdateDetailProbabilityDisplay */
} /* UpdateDetailProbabilityDisplay */
private void UpdateBinaryClassifierProbabilities(String className)
{
PicesClass leftClass = PicesClassList.GetUniqueClass(className, "");
BinaryClassName.Text = "";
BinaryProbabilities.Rows.Clear();
PicesPredictionList binaryPredictions = trainingModel.BinaryProbailitiesForClass(leftClass);
if (binaryPredictions == null)
{
return;
}
BinaryClassName.Text = leftClass.Name;
selectedTopClass = leftClass;
foreach (PicesPrediction p in binaryPredictions)
{
if (leftClass == p.MLClass)
{
continue;
}
Object[] data = new Object[2];
data[0] = p.ClassName;
double probForRightSide = 1.0 - p.Probability;
data[1] = probForRightSide;
BinaryProbabilities.Rows.Add(data);
}
BuildBinaryProbabilitiesGridViewConetextMenu();
} /* UpdateBinaryClassifierProbabilities */
} /* LoadImageGrid */
private void UpdateDetailProbabilityDisplay(String fileName)
{
if (fileName == null)
{
return;
}
curSelImageFileName = fileName;
String fullFileName = null;
if ((fileName.Length > 1) && (fileName[1] == ':'))
{
fullFileName = fileName;
}
else
{
fullFileName = OSservices.AddSlash(rootDir) + fileName;
}
if (!File.Exists(fullFileName))
{
String fn = OSservices.GetRootName(fileName) + ".bmp";
fullFileName = OSservices.LookForFile(fn, rootDir);
}
Prediction prediction = GetPrediction(fileName);
// We need to call 'PredictProbabilities' twice. Once to get the intermediate images and the
// second time to perform prediction using the FeatureVector that was used in the original
// prediction. It has to be done this way because the version of 'PredictProbabilities' that
// derives the FeatureVector from an image does not always have access of instrumentation data.
PicesRasterList featureCalcImages = new PicesRasterList();
PicesPredictionList guesses2 = prediction.trainModel.PredictProbabilities(fullFileName, featureCalcImages);
// Perform Prediction using original FeatureVector.
PicesPredictionList guesses = prediction.trainModel.PredictProbabilities(prediction.fv);
ImageFileName.Text = fileName;
if (guesses == null)
{
return;
}
ClassificationProbabilities.Rows.Clear();
foreach (PicesPrediction p in guesses)
{
Object[] data = new Object[3];
data[0] = p.ClassName;
data[1] = p.Probability;
data[2] = p.Votes;
ClassificationProbabilities.Rows.Add(data);
}
FeatureCalcImages.Rows.Clear();
if ((featureCalcImages == null) || (featureCalcImages.Count < 1))
{
return;
}
for (int x = 0; x < featureCalcImages.Count; x++)
{
Object[] data = new Object[2];
data[0] = featureCalcImages[x].BuildBitmap();
data[1] = featureCalcImages[x].FileName;
FeatureCalcImages.Rows.Add(data);
}
} /* UpdateDetailProbabilityDisplay */
} /* ThreadProcess */
private void ProcessOneFeatureVector(PicesFeatureVector fv)
{
int x = midPoint.CompareTo(fv.CtdDateTime);
PicesPredictionList probPredList = null;
bool downCast = (x > 0);
if (reClassify)
{
String imageFileName = fv.ExampleFileName;
String imageFileRootName = OSservices.GetRootName(imageFileName);
if ((fv.Validated) && (validatedTrumps))
{
PicesClass validatedClass = AssignVallidatedClassAsPredictedClass(fv);
probPredList = PredictClasses(fv, pred1, pred2, imageFileName, imageFileRootName);
if (validatedClass != null)
{
if (pred1.MLClass != validatedClass)
{
pred2.MLClass = pred1.MLClass;
}
pred2.Probability = 0.0f;
pred1.MLClass = validatedClass;
pred1.Probability = 1.0f;
}
}
else
{
probPredList = PredictClasses(fv, pred1, pred2, imageFileName, imageFileRootName);
}
String imageRootName = OSservices.GetRootName(fv.ExampleFileName);
lock (predictionUpdateQueue)
{
if (pred1.MLClass.ClassId < 0)
{
pred1.MLClass = UpdateClassId(pred1.MLClass);
}
if (pred2.MLClass.ClassId < 0)
{
pred2.MLClass = UpdateClassId(pred2.MLClass);
}
predictionUpdateQueue.Enqueue(new PredictionResult(imageRootName,
pred1.MLClass.ClassId,
pred1.Probability,
pred2.MLClass.ClassId,
pred2.Probability,
probPredList
)
);
}
}
else
{
if ((fv.Validated) && (validatedTrumps))
{
pred1.MLClass = fv.MLClass;
pred1.Probability = 1.0f;
}
else
{
pred1.MLClass = fv.MLClass;
pred1.Probability = fv.Probability;
}
}
String className = pred1.ClassName;
bool noiseClass = ((className.Length >= 5) &&
(className.Substring(0, 5).Equals("Noise", StringComparison.InvariantCultureIgnoreCase))
);
if (noiseClass)
{
}
else
{
lock (classCounts)
{
classCounts.AddOne(pred1.MLClass);
depthDistribution_1.Increment(pred1.MLClass, (int)fv.Depth);
if (downCast)
{
depthDistribution_1Down.Increment(pred1.MLClass, (int)fv.Depth);
sizeDistributionDown.Increment(pred1.MLClass, fv.AreaMMSquare);
}
else
{
depthDistribution_1Up.Increment(pred1.MLClass, (int)fv.Depth);
sizeDistributionUp.Increment(pred1.MLClass, fv.AreaMMSquare);
}
depthDistribution_10.Increment(pred1.MLClass, (int)fv.Depth);
numImagesClassified++;
}
}
} /* ProcessOneFeatureVector */
