/*
* Description:
* Read the license plate
* Input:
* //Rectified license plate image containing six characters
* Int32Image labeledRectifiedPlateImage
* Output:
* //Result by the blob matcher
* ref LicensePlate result
* Return:
* //six characters found
* bool
*/
public static bool MatchPlate(Int32Image binaryCharacterImage, ref LicensePlate result)
{
try
{
VisionLab.SetInt32Image(cmdInt, "binaryCharacterImage", binaryCharacterImage);
String plateStr = StripTime(cmdInt.ExecRequest("icall MatchPlate binaryCharacterImage"));
if (plateStr.Substring(0, 5) != "false")
{
string[] plateResult = plateStr.Split(' ');
string plateResultChars = plateResult[0];
result.confidence = double.Parse(plateResult[1], CultureInfo.InvariantCulture);
for (int c = 0; c < 6; c++)
{
result.characters.Add(new LicenseCharacter(plateResultChars[c].ToString(), double.Parse(plateResult[2 + c], CultureInfo.InvariantCulture), result.confidence));
}
bool[] types = new bool[6];
for (int i = 0; i < 6; i++)
{
types[i] = '0' <= result.characters[i].character[0] && result.characters[i].character[0] <= '9';
}
if (types[0] && types[1] && !types[2] && !types[3] && !types[4] && !types[5])
{
return(true);
}
if (!types[0] && !types[1] && types[2] && types[3] && !types[4] && !types[5])
{
return(true);
}
if (!types[0] && !types[1] && !types[2] && !types[3] && types[4] && types[5])
{
return(true);
}
if (types[0] && !types[1] && !types[2] && !types[3] && types[4] && types[5])
{
return(true);
}
if (types[0] && types[1] && !types[2] && !types[3] && !types[4] && types[5])
{
return(true);
}
return(false);
}
else
{
return(false);
}
}
catch (System.Exception ex)
{
throw new Exception("MatchPlate: " + ex.Message);
}
}
private void MatchImage(String Filename, bool add)
{
ErrorTB.Text = "";
lblExpected.Text = Filename.Substring(0, 6);
//*************************************//
//** load and display original image **//
//*************************************//
Bitmap bm;
bm = new Bitmap(Filename);
RGB888Image plateImage = VisionLabEx.BitmapToJL(bm);
VisionLabEx.DisplayImage(plateImage, imgOrig);
//****************//
//** Find plate **//
//****************//
Int32Image binaryPlateImage = new Int32Image();
if (!LicensePlateMatcher.FindPlate(plateImage, ref binaryPlateImage))
{
VisionLabEx.DisplayImage(binaryPlateImage, imgPlateBin, true, true);
lblLexiconResult.Text = "";
if (add)
{
lstFindPlateErr.Items.Add(Filename);
lblFindPlateErrCount.Text = lstFindPlateErr.Items.Count.ToString();
}
ClearResultLabels();
return;
}
VisionLabEx.DisplayImage(binaryPlateImage, imgPlateBin, true, true);
//**
//** Enable this to display blob measurements to debug output
//**
DisplayBlobs(binaryPlateImage);
//*******************//
//** Rectify plate **//
//*******************//
Int32Image binaryCharacterImage = new Int32Image();
if (!LicensePlateMatcher.FindCharacters(plateImage, binaryPlateImage, ref binaryCharacterImage))
{
if (imgRectifiedPlate.Image != null)
{
imgRectifiedPlate.Image.Dispose();
}
imgRectifiedPlate.Image = null;
lblLexiconResult.Text = "";
if (add)
{
lstRectifyPlateErr.Items.Add(Filename);
lblRectfyPlateErrCount.Text = lstRectifyPlateErr.Items.Count.ToString();
}
ClearResultLabels();
return;
}
VisionLabEx.DisplayImage(binaryCharacterImage, imgRectifiedPlate, true, true);
//**
//** Enable this to display blob measurements to debug output
//**
DisplayBlobs(binaryCharacterImage);
//*****************//
//** Match Plate **//
//*****************//
LicensePlate result = new LicensePlate();
LicensePlate lexiconResult = new LicensePlate();
if (!LicensePlateMatcher.MatchPlate(binaryCharacterImage, blobMatcher, lexicon, ref result, ref lexiconResult))
{
lblLexiconResult.Text = "";
if (add)
{
lstMatchPlateErr.Items.Add(Filename);
lblMatchPlateErrCount.Text = lstMatchPlateErr.Items.Count.ToString();
}
ClearResultLabels();
return;
}
//*********************//
//** Process results **//
//*********************//
ProcessResults(result, lexiconResult, Filename, (double)nupConfidence.Value / 100, add);
bm.Dispose();
plateImage.Dispose();
binaryPlateImage.Dispose();
binaryCharacterImage.Dispose();
//Force a garbage collect to prevens malloc errors from unmanaged code.
GC.Collect();
}
public void ProcessResults(LicensePlate result, LicensePlate lexiconResult, string filename, double minConfidence, bool add)
{
string expected = filename.Substring(0, 6);
lblExpected.Text = expected;
lblResult.Text = result.getLicensePlateString();
lblConfidence.Text = Math.Round(result.confidence, 3).ToString();
if (lexiconResult != null)
{
lblLexiconResult.Text = lexiconResult.getLicensePlateString();
lblLexiconConfidence.Text = Math.Round(lexiconResult.confidence, 3).ToString();
}
else
{
lblLexiconResult.Text = "";
}
lblError1.Text = Math.Round(result.characters[0].error, 2).ToString();
lblError2.Text = Math.Round(result.characters[1].error, 2).ToString();
lblError3.Text = Math.Round(result.characters[2].error, 2).ToString();
lblError4.Text = Math.Round(result.characters[3].error, 2).ToString();
lblError5.Text = Math.Round(result.characters[4].error, 2).ToString();
lblError6.Text = Math.Round(result.characters[5].error, 2).ToString();
if (!chkUseLexicon.Checked)
{
lblLexiconResult.ForeColor = Color.Black;
if (result.confidence >= minConfidence && expected == result.getLicensePlateString()) //True Positive (Matched)
{
lblResult.ForeColor = Color.Green;
if (add)
{
lstMatched.Items.Add(filename);
lblMatchedCount.Text = lstMatched.Items.Count.ToString();
}
}
if (result.confidence >= minConfidence && expected != result.getLicensePlateString()) //False Positive (Error)
{
lblResult.ForeColor = Color.Red;
if (add)
{
lstErrors.Items.Add(filename);
lblErrorsCount.Text = lstErrors.Items.Count.ToString();
}
}
if ((result.confidence < minConfidence && expected == result.getLicensePlateString()) || //False Negative (Low confidence)
(result.confidence < minConfidence && expected != result.getLicensePlateString())) //True Negative (Low confidence)
{
lblResult.ForeColor = Color.Blue;
if (add)
{
lstLowConfidence.Items.Add(filename);
lblLowConfidenceCount.Text = lstLowConfidence.Items.Count.ToString();
}
}
}
else
{
lblResult.ForeColor = Color.Black;
if (lexiconResult.confidence >= minConfidence && expected == lexiconResult.getLicensePlateString()) //True Positive (Matched)
{
lblLexiconResult.ForeColor = Color.Green;
if (add)
{
if (lexiconResult.getLicensePlateString() != result.getLicensePlateString())
{
lstLexicon.Items.Add(filename);
lblLexiconCount.Text = lstMatched.Items.Count.ToString();
}
else
{
lstMatched.Items.Add(filename);
lblMatchedCount.Text = lstMatched.Items.Count.ToString();
}
}
}
if (lexiconResult.confidence >= minConfidence && expected != lexiconResult.getLicensePlateString()) //False Positive (Error)
{
lblLexiconResult.ForeColor = Color.Red;
if (add)
{
lstErrors.Items.Add(filename);
lblErrorsCount.Text = lstErrors.Items.Count.ToString();
}
}
if ((lexiconResult.confidence < minConfidence && expected == lexiconResult.getLicensePlateString()) || //False Negative (Low confidence)
(lexiconResult.confidence < minConfidence && expected != lexiconResult.getLicensePlateString())) //True Negative (Low confidence)
{
lblLexiconResult.ForeColor = Color.Blue;
if (add)
{
lstLowConfidence.Items.Add(filename);
lblLowConfidenceCount.Text = lstLowConfidence.Items.Count.ToString();
}
}
}
}
public void ProcessResults(LicensePlate result, string filename, double minConfidence, bool add)
{
ProcessResults(result, null, filename, minConfidence, add);
}
public void ProcessResults(LicensePlate result, LicensePlate lexiconResult, string filename, double minConfidence, bool add)
{
string expected = filename.Substring(0, 6);
lblExpected.Text = expected;
lblResult.Text = result.getLicensePlateString();
lblConfidence.Text = Math.Round(result.confidence, 3).ToString();
if (lexiconResult != null)
{
lblLexiconResult.Text = lexiconResult.getLicensePlateString();
lblLexiconConfidence.Text = Math.Round(lexiconResult.confidence, 3).ToString();
} else {
lblLexiconResult.Text = "";
}
lblError1.Text = Math.Round(result.characters[0].error, 2).ToString();
lblError2.Text = Math.Round(result.characters[1].error, 2).ToString();
lblError3.Text = Math.Round(result.characters[2].error, 2).ToString();
lblError4.Text = Math.Round(result.characters[3].error, 2).ToString();
lblError5.Text = Math.Round(result.characters[4].error, 2).ToString();
lblError6.Text = Math.Round(result.characters[5].error, 2).ToString();
if (!chkUseLexicon.Checked)
{
lblLexiconResult.ForeColor = Color.Black;
if (result.confidence >= minConfidence && expected == result.getLicensePlateString()) //True Positive (Matched)
{
lblResult.ForeColor = Color.Green;
if (add)
{
lstMatched.Items.Add(filename);
lblMatchedCount.Text = lstMatched.Items.Count.ToString();
}
}
if (result.confidence >= minConfidence && expected != result.getLicensePlateString()) //False Positive (Error)
{
lblResult.ForeColor = Color.Red;
if (add)
{
lstErrors.Items.Add(filename);
lblErrorsCount.Text = lstErrors.Items.Count.ToString();
}
}
if ((result.confidence < minConfidence && expected == result.getLicensePlateString()) || //False Negative (Low confidence)
(result.confidence < minConfidence && expected != result.getLicensePlateString())) //True Negative (Low confidence)
{
lblResult.ForeColor = Color.Blue;
if (add)
{
lstLowConfidence.Items.Add(filename);
lblLowConfidenceCount.Text = lstLowConfidence.Items.Count.ToString();
}
}
}
else
{
lblResult.ForeColor = Color.Black;
if (lexiconResult.confidence >= minConfidence && expected == lexiconResult.getLicensePlateString()) //True Positive (Matched)
{
lblLexiconResult.ForeColor = Color.Green;
if (add)
{
if (lexiconResult.getLicensePlateString() != result.getLicensePlateString())
{
lstLexicon.Items.Add(filename);
lblLexiconCount.Text = lstMatched.Items.Count.ToString();
}
else
{
lstMatched.Items.Add(filename);
lblMatchedCount.Text = lstMatched.Items.Count.ToString();
}
}
}
if (lexiconResult.confidence >= minConfidence && expected != lexiconResult.getLicensePlateString()) //False Positive (Error)
{
lblLexiconResult.ForeColor = Color.Red;
if (add)
{
lstErrors.Items.Add(filename);
lblErrorsCount.Text = lstErrors.Items.Count.ToString();
}
}
if ((lexiconResult.confidence < minConfidence && expected == lexiconResult.getLicensePlateString()) || //False Negative (Low confidence)
(lexiconResult.confidence < minConfidence && expected != lexiconResult.getLicensePlateString())) //True Negative (Low confidence)
{
lblLexiconResult.ForeColor = Color.Blue;
if (add)
{
lstLowConfidence.Items.Add(filename);
lblLowConfidenceCount.Text = lstLowConfidence.Items.Count.ToString();
}
}
}
}
public void ProcessResults(LicensePlate result, string filename, double minConfidence, bool add) { ProcessResults(result, null, filename, minConfidence, add); }
private void MatchImage(String Filename, bool add)
{
ErrorTB.Text = "";
lblExpected.Text = Filename.Substring(0, 6);
//*************************************//
//** load and display original image **//
//*************************************//
Bitmap bm;
bm = new Bitmap(Filename);
RGB888Image plateImage = VisionLabEx.BitmapToJL(bm);
DisplayImage(plateImage, imgOrig);
//****************//
//** Find plate **//
//****************//
Int16Image binaryPlateImage = new Int16Image();
if (!LicensePlateMatcher.FindPlate(plateImage, ref binaryPlateImage, TresholdConditions.NORMAAL)
&& !LicensePlateMatcher.FindPlate(plateImage, ref binaryPlateImage, TresholdConditions.OVERBELICHT)
&& !LicensePlateMatcher.FindPlate(plateImage, ref binaryPlateImage, TresholdConditions.ONDERBELICHT))
{
DisplayImage(binaryPlateImage, imgPlateBin, true, true);
lblLexiconResult.Text = "";
if (add)
{
lstFindPlateErr.Items.Add(Filename);
lblFindPlateErrCount.Text = lstFindPlateErr.Items.Count.ToString();
}
ClearResultLabels();
return;
}
DisplayImage(binaryPlateImage, imgPlateBin, true, true);
//*******************//
//** Rectify plate **//
//*******************//
Int16Image binaryRectifiedImage = new Int16Image();
do
{
// Check if we can find the plate
if (LicensePlateMatcher.FindCharacters(plateImage, binaryPlateImage, ref binaryRectifiedImage))
{
// if so we are done
break;
}
else
{
// ************************************
// ** Find the biggest blob in the **
// ** image and remove that one **
// ************************************
VisionLab.LabelBlobs(binaryPlateImage, Connected.EightConnected);
vector_BlobAnalyse ba_vec = new vector_BlobAnalyse();
ba_vec.Add(BlobAnalyse.BA_Area);
vector_Blob blobs = new vector_Blob();
VisionLab.BlobAnalysis(binaryPlateImage, VisionLab.VectorToSet_BlobAnalyse(ba_vec), VisionLab.MaxPixel(binaryPlateImage), blobs);
int biggestArea = 0;
foreach (Blob ba in blobs)
{
if (ba.Area() > biggestArea)
{
biggestArea = ba.Area();
}
}
VisionLab.RemoveBlobs(binaryPlateImage, Connected.EightConnected, BlobAnalyse.BA_Area, biggestArea - 1, biggestArea + 1);
}
} // Repeat this until there is nothing left
while (VisionLab.SumIntPixels(binaryPlateImage) > 0);
// If that is so it wasn't found
if (VisionLab.SumIntPixels(binaryPlateImage) == 0)
{
// So do all this
if (imgRectifiedPlate.Image != null)
imgRectifiedPlate.Image.Dispose();
imgRectifiedPlate.Image = null;
lblLexiconResult.Text = "";
if (add)
{
lstRectifyPlateErr.Items.Add(Filename);
lblRectfyPlateErrCount.Text = lstRectifyPlateErr.Items.Count.ToString();
}
ClearResultLabels();
return;
}
DisplayImage(binaryRectifiedImage, imgRectifiedPlate, true, true);
//*****************//
//** Match Plate **//
//*****************//
LicensePlate result = new LicensePlate();
LicensePlate lexiconResult = new LicensePlate();
if (!LicensePlateMatcher.MatchPlate(binaryRectifiedImage, blobMatcher, lexicon, ref result, ref lexiconResult, false))
{
lblLexiconResult.Text = "";
if (add)
{
lstMatchPlateErr.Items.Add(Filename);
lblMatchPlateErrCount.Text = lstMatchPlateErr.Items.Count.ToString();
}
ClearResultLabels();
return;
}
// Extra way to up confidence perhaps
if(result.characters != null && result.confidence < (double)nupConfidence.Value / 100)
{
LicensePlateMatcher.MatchPlate(binaryRectifiedImage, blobMatcher, lexicon, ref result, ref lexiconResult, true);
}
//*********************//
//** Process results **//
//*********************//
ProcessResults(result, lexiconResult, Filename, (double) nupConfidence.Value / 100, add);
bm.Dispose();
plateImage.Dispose();
binaryPlateImage.Dispose();
binaryRectifiedImage.Dispose();
//Force a garbage collect to prevens malloc errors from unmanaged code.
GC.Collect();
}
/*
* Description:
* Read the license plate
* Input:
* //Rectified license plate image containing six characters
* Int32Image labeledRectifiedPlateImage
* Output:
* //Result by the blob matcher
* ref LicensePlate result
* Return:
* //six characters found
* bool
*/
public static bool MatchPlate(Int32Image binaryCharacterImage, BlobMatcher_Int32 matcher, ClassLexicon lexicon, ref LicensePlate result, ref LicensePlate lexiconResult)
{
try
{
//Check if 6 characters/blobs have been found and label image.
if (VisionLab.LabelBlobs(binaryCharacterImage, Connected.EightConnected) != 6)
{
return(false);
}
//Calculate dimensions and locations of all characters/blobs.
vector_BlobAnalyse ba_vec = new vector_BlobAnalyse();
ba_vec.Add(BlobAnalyse.BA_TopLeft);
ba_vec.Add(BlobAnalyse.BA_Height);
ba_vec.Add(BlobAnalyse.BA_Width);
vector_Blob returnBlobs = new vector_Blob();
VisionLab.BlobAnalysis(binaryCharacterImage, VisionLab.VectorToSet_BlobAnalyse(ba_vec), VisionLab.MaxPixel(binaryCharacterImage), returnBlobs, SortOrder.SortDown, BlobAnalyse.BA_TopLeft, UseXOrY.UseX);
ba_vec.Dispose();
Int32Image binaryCharacter = new Int32Image();
//Create data structure for lexicon.
vector_vector_LetterMatch match = new vector_vector_LetterMatch();
//Process each character/blob.
foreach (Blob b in returnBlobs)
{
//Cut out character
VisionLab.ROI(binaryCharacterImage, binaryCharacter, b.TopLeft(), new HeightWidth(b.Height(), b.Width()));
//Convert ROI result to binary
VisionLab.ClipPixelValue(binaryCharacter, 0, 1);
//Calculate character's classification for all classes.
vector_PatternMatchResult returnMatches = new vector_PatternMatchResult();
float conf = matcher.AllMatches(binaryCharacter, (float)-0.5, (float)0.5, returnMatches);
float err = returnMatches[0].error;
int id = returnMatches[0].id;
string chr = matcher.PatternName(id);
//Fill datastructure for lexicon.
match.Add(VisionLabEx.PatternMatchResultToLetterMatch(returnMatches));
//Store best match in result
result.characters.Add(new LicenseCharacter(chr, err, conf));
}
//Validate match with lexicon.
vector_int bestWord = new vector_int();
lexiconResult.confidence = lexicon.FindBestWord(match, bestWord, Optimize.OptimizeForMinimum);
for (int i = 0; i < bestWord.Count; i++)
{
string character = matcher.PatternName(bestWord[i]);
//Store lexicon result
lexiconResult.characters.Add(new LicenseCharacter(character));
}
binaryCharacter.Dispose();
returnBlobs.Dispose();
match.Dispose();
bestWord.Dispose();
bool[] types = new bool[6];
for (int i = 0; i < 6; i++)
{
types[i] = '0' <= result.characters[i].character[0] && result.characters[i].character[0] <= '9';
}
if (types[0] && types[1] && !types[2] && !types[3] && !types[4] && !types[5])
{
return(true);
}
if (!types[0] && !types[1] && types[2] && types[3] && !types[4] && !types[5])
{
return(true);
}
if (!types[0] && !types[1] && !types[2] && !types[3] && types[4] && types[5])
{
return(true);
}
if (types[0] && !types[1] && !types[2] && !types[3] && types[4] && types[5])
{
return(true);
}
if (types[0] && types[1] && !types[2] && !types[3] && !types[4] && types[5])
{
return(true);
}
return(false);
}
catch (System.Exception ex)
{
throw new Exception("MatchPlate: " + ex.Message);
}
}
private void MatchImage(String Filename, bool add)
{
ErrorTB.Text = "";
lblExpected.Text = Filename.Substring(0, 6);
//*************************************//
//** load and display original image **//
//*************************************//
Bitmap bm;
bm = new Bitmap(Filename);
RGB888Image plateImage = VisionLabEx.BitmapToJL(bm);
DisplayImage(plateImage, imgOrig);
//****************//
//** Find plate **//
//****************//
Int16Image binaryPlateImage = new Int16Image();
if (!LicensePlateMatcher.FindPlate(plateImage, ref binaryPlateImage, TresholdConditions.NORMAAL) &&
!LicensePlateMatcher.FindPlate(plateImage, ref binaryPlateImage, TresholdConditions.OVERBELICHT) &&
!LicensePlateMatcher.FindPlate(plateImage, ref binaryPlateImage, TresholdConditions.ONDERBELICHT))
{
DisplayImage(binaryPlateImage, imgPlateBin, true, true);
lblLexiconResult.Text = "";
if (add)
{
lstFindPlateErr.Items.Add(Filename);
lblFindPlateErrCount.Text = lstFindPlateErr.Items.Count.ToString();
}
ClearResultLabels();
return;
}
DisplayImage(binaryPlateImage, imgPlateBin, true, true);
//*******************//
//** Rectify plate **//
//*******************//
Int16Image binaryRectifiedImage = new Int16Image();
do
{
// Check if we can find the plate
if (LicensePlateMatcher.FindCharacters(plateImage, binaryPlateImage, ref binaryRectifiedImage))
{
// if so we are done
break;
}
else
{
// ************************************
// ** Find the biggest blob in the **
// ** image and remove that one **
// ************************************
VisionLab.LabelBlobs(binaryPlateImage, Connected.EightConnected);
vector_BlobAnalyse ba_vec = new vector_BlobAnalyse();
ba_vec.Add(BlobAnalyse.BA_Area);
vector_Blob blobs = new vector_Blob();
VisionLab.BlobAnalysis(binaryPlateImage, VisionLab.VectorToSet_BlobAnalyse(ba_vec), VisionLab.MaxPixel(binaryPlateImage), blobs);
int biggestArea = 0;
foreach (Blob ba in blobs)
{
if (ba.Area() > biggestArea)
{
biggestArea = ba.Area();
}
}
VisionLab.RemoveBlobs(binaryPlateImage, Connected.EightConnected, BlobAnalyse.BA_Area, biggestArea - 1, biggestArea + 1);
}
} // Repeat this until there is nothing left
while (VisionLab.SumIntPixels(binaryPlateImage) > 0);
// If that is so it wasn't found
if (VisionLab.SumIntPixels(binaryPlateImage) == 0)
{
// So do all this
if (imgRectifiedPlate.Image != null)
{
imgRectifiedPlate.Image.Dispose();
}
imgRectifiedPlate.Image = null;
lblLexiconResult.Text = "";
if (add)
{
lstRectifyPlateErr.Items.Add(Filename);
lblRectfyPlateErrCount.Text = lstRectifyPlateErr.Items.Count.ToString();
}
ClearResultLabels();
return;
}
DisplayImage(binaryRectifiedImage, imgRectifiedPlate, true, true);
//*****************//
//** Match Plate **//
//*****************//
LicensePlate result = new LicensePlate();
LicensePlate lexiconResult = new LicensePlate();
if (!LicensePlateMatcher.MatchPlate(binaryRectifiedImage, blobMatcher, lexicon, ref result, ref lexiconResult, false))
{
lblLexiconResult.Text = "";
if (add)
{
lstMatchPlateErr.Items.Add(Filename);
lblMatchPlateErrCount.Text = lstMatchPlateErr.Items.Count.ToString();
}
ClearResultLabels();
return;
}
// Extra way to up confidence perhaps
if (result.characters != null && result.confidence < (double)nupConfidence.Value / 100)
{
LicensePlateMatcher.MatchPlate(binaryRectifiedImage, blobMatcher, lexicon, ref result, ref lexiconResult, true);
}
//*********************//
//** Process results **//
//*********************//
ProcessResults(result, lexiconResult, Filename, (double)nupConfidence.Value / 100, add);
bm.Dispose();
plateImage.Dispose();
binaryPlateImage.Dispose();
binaryRectifiedImage.Dispose();
//Force a garbage collect to prevens malloc errors from unmanaged code.
GC.Collect();
}
/*
Description:
Read the license plate
Input:
//Rectified license plate image containing six characters
Int16Image labeledRectifiedPlateImage
BlobMatcher_Int16 matcher //initialized blobmatcher
ClassLexicon lexicon //initialized lexicon
Output:
//Result by the blob matcher
ref LicensePlate result
//Result by the lexicon
ref LicensePlate lexiconResult
Return:
//six characters found
bool
*/
public static bool MatchPlate(Int16Image binaryCharacterImage, BlobMatcher_Int16 matcher,
ClassLexicon lexicon, ref LicensePlate result, ref LicensePlate lexiconResult, bool dilate)
{
// NIEUW
// 2de optie voor aanroep als eerste low confidence levert
if (dilate)
{
Int16Image temp = new Int16Image();
VisionLab.Dilation(binaryCharacterImage, temp, new Mask_Int32(3, 3, 1));
binaryCharacterImage = new Int16Image(temp);
temp.Dispose();
}
if (VisionLab.LabelBlobs(binaryCharacterImage, Connected.EightConnected) != 6)
return false;
//Calculate dimensions and locations of all characters/blobs.
vector_BlobAnalyse ba_vec = new vector_BlobAnalyse();
ba_vec.Add(BlobAnalyse.BA_TopLeft);
ba_vec.Add(BlobAnalyse.BA_Height);
ba_vec.Add(BlobAnalyse.BA_Width);
vector_Blob returnBlobs = new vector_Blob();
VisionLab.BlobAnalysis(binaryCharacterImage, VisionLab.VectorToSet_BlobAnalyse(ba_vec), VisionLab.MaxPixel(binaryCharacterImage), returnBlobs, SortOrder.SortDown, BlobAnalyse.BA_TopLeft, UseXOrY.UseX);
ba_vec.Dispose();
Int16Image binaryCharacter = new Int16Image();
//Create data structure for lexicon.
vector_vector_LetterMatch match = new vector_vector_LetterMatch();
// NIEUW
// Change the matcher params
matcher.ChangeParams(60, 10, 64, 0);
//Process each character/blob.
foreach (Blob b in returnBlobs)
{
//Cut out character
VisionLab.ROI(binaryCharacterImage, binaryCharacter, b.TopLeft(), new HeightWidth(b.Height(), b.Width()));
//Convert ROI result to binary
VisionLab.ClipPixelValue(binaryCharacter, 0, 1);
//Calculate character's classification for all classes.
vector_PatternMatchResult returnMatches = new vector_PatternMatchResult();
float conf = matcher.AllMatches(binaryCharacter, (float)-0.5, (float)0.5, returnMatches);
float err = returnMatches[0].error;
int id = returnMatches[0].id;
string chr = matcher.PatternName(id);
// NIEUW
// If error to big decrease the confidence
if(err > 0.20f)
conf -= 0.2f;
//Fill datastructure for lexicon.
match.Add(VisionLabEx.PatternMatchResultToLetterMatch(returnMatches));
//Store best match in result
result.characters.Add(
new LicenseCharacter(
chr,
err,
conf,
// NIEUW
// Extra param: The middle of a character
// (used for matching patterns)
b.TopLeft().x + ((b.TopRight().x - b.TopLeft().x)/2) ,
// NIEUW
// All other results that we're found
// So we can switch between em
returnMatches
));
}
//Validate match with lexicon.
vector_int bestWord = new vector_int();
lexiconResult.confidence = lexicon.FindBestWord(match, bestWord, Optimize.OptimizeForMinimum);
for (int i = 0; i < bestWord.Count; i++)
{
string character = matcher.PatternName(bestWord[i]);
//Store lexicon result
lexiconResult.characters.Add(new LicenseCharacter(character));
}
// NIEUW
// Create the best match with the aid of the pattern matcher
result.CalculateBestMatch(matcher);
binaryCharacter.Dispose();
returnBlobs.Dispose();
match.Dispose();
bestWord.Dispose();
GC.Collect();
return true;
}
/*
* Description:
* Read the license plate
* Input:
* //Rectified license plate image containing six characters
* Int16Image labeledRectifiedPlateImage
* BlobMatcher_Int16 matcher //initialized blobmatcher
* ClassLexicon lexicon //initialized lexicon
* Output:
* //Result by the blob matcher
* ref LicensePlate result
* //Result by the lexicon
* ref LicensePlate lexiconResult
* Return:
* //six characters found
* bool
*/
public static bool MatchPlate(Int16Image binaryCharacterImage, BlobMatcher_Int16 matcher,
ClassLexicon lexicon, ref LicensePlate result, ref LicensePlate lexiconResult, bool dilate)
{
// NIEUW
// 2de optie voor aanroep als eerste low confidence levert
if (dilate)
{
Int16Image temp = new Int16Image();
VisionLab.Dilation(binaryCharacterImage, temp, new Mask_Int32(3, 3, 1));
binaryCharacterImage = new Int16Image(temp);
temp.Dispose();
}
if (VisionLab.LabelBlobs(binaryCharacterImage, Connected.EightConnected) != 6)
{
return(false);
}
//Calculate dimensions and locations of all characters/blobs.
vector_BlobAnalyse ba_vec = new vector_BlobAnalyse();
ba_vec.Add(BlobAnalyse.BA_TopLeft);
ba_vec.Add(BlobAnalyse.BA_Height);
ba_vec.Add(BlobAnalyse.BA_Width);
vector_Blob returnBlobs = new vector_Blob();
VisionLab.BlobAnalysis(binaryCharacterImage, VisionLab.VectorToSet_BlobAnalyse(ba_vec), VisionLab.MaxPixel(binaryCharacterImage), returnBlobs, SortOrder.SortDown, BlobAnalyse.BA_TopLeft, UseXOrY.UseX);
ba_vec.Dispose();
Int16Image binaryCharacter = new Int16Image();
//Create data structure for lexicon.
vector_vector_LetterMatch match = new vector_vector_LetterMatch();
// NIEUW
// Change the matcher params
matcher.ChangeParams(60, 10, 64, 0);
//Process each character/blob.
foreach (Blob b in returnBlobs)
{
//Cut out character
VisionLab.ROI(binaryCharacterImage, binaryCharacter, b.TopLeft(), new HeightWidth(b.Height(), b.Width()));
//Convert ROI result to binary
VisionLab.ClipPixelValue(binaryCharacter, 0, 1);
//Calculate character's classification for all classes.
vector_PatternMatchResult returnMatches = new vector_PatternMatchResult();
float conf = matcher.AllMatches(binaryCharacter, (float)-0.5, (float)0.5, returnMatches);
float err = returnMatches[0].error;
int id = returnMatches[0].id;
string chr = matcher.PatternName(id);
// NIEUW
// If error to big decrease the confidence
if (err > 0.20f)
{
conf -= 0.2f;
}
//Fill datastructure for lexicon.
match.Add(VisionLabEx.PatternMatchResultToLetterMatch(returnMatches));
//Store best match in result
result.characters.Add(
new LicenseCharacter(
chr,
err,
conf,
// NIEUW
// Extra param: The middle of a character
// (used for matching patterns)
b.TopLeft().x + ((b.TopRight().x - b.TopLeft().x) / 2),
// NIEUW
// All other results that we're found
// So we can switch between em
returnMatches
));
}
//Validate match with lexicon.
vector_int bestWord = new vector_int();
lexiconResult.confidence = lexicon.FindBestWord(match, bestWord, Optimize.OptimizeForMinimum);
for (int i = 0; i < bestWord.Count; i++)
{
string character = matcher.PatternName(bestWord[i]);
//Store lexicon result
lexiconResult.characters.Add(new LicenseCharacter(character));
}
// NIEUW
// Create the best match with the aid of the pattern matcher
result.CalculateBestMatch(matcher);
binaryCharacter.Dispose();
returnBlobs.Dispose();
match.Dispose();
bestWord.Dispose();
GC.Collect();
return(true);
}