Fix ALPR order issue

This commit is contained in:
2026-05-06 19:55:52 +10:00
parent 66c67dff26
commit a526aa6cdb
4 changed files with 146 additions and 250 deletions
Submodule .claude/worktrees/heuristic-lichterman-bda22b added at 66c67dff26
+133 -240
View File
@@ -356,6 +356,7 @@ namespace ANSCENTER {
constexpr float ROW_SPLIT_MIN_GAP_FACTOR = 0.2f; // maxGap < avgHeight * this => single row
constexpr float ROW_SPLIT_AVGY_FACTOR = 0.4f; // avgY diff must exceed avgHeight * this
constexpr size_t ROW_SPLIT_MIN_GROUP_SIZE = 2; // minimum chars per row
constexpr float Y_CLUSTER_STRONG_FACTOR = 0.7f; // maxYGap > avgHeight * this => Y-cluster reliable, else use PCA
constexpr float DUPLICATE_DIST_THRESHOLD = 5.0f; // pixels: chars closer than this are duplicates
constexpr int DUPLICATE_GRID_SIZE = 10; // spatial hash grid cell size in pixels
constexpr int ASYNC_TIMEOUT_SECONDS = 30; // timeout for async worker threads
@@ -1240,9 +1241,10 @@ namespace ANSCENTER {
return {};
}
std::string ANSALPR_OD::DetectLicensePlateString(const cv::Mat& lprROI, const std::string& cameraId) {
// No coarse _mutex — _ocrDetector has its own m_inferenceMutex
// No coarse _mutex — _ocrDetector has its own m_inferenceMutex.
// Single-frame and batch paths now share post-processing via
// ProcessSingleOCRResult (PCA-based; robust to plate tilt).
try {
// convert lprROI to greyscale if it is not already
if (lprROI.empty()) {
this->_logger.LogError("ANSALPR_OD::DetectLicensePlateString", "Input image is empty", __FILE__, __LINE__);
return "";
@@ -1256,174 +1258,9 @@ namespace ANSCENTER {
}
std::vector<Object> ocrOutput = _ocrDetector->RunInference(grayLprROI, cameraId);
std::string ocrText = "";
if (ocrOutput.empty()) return ocrText;
//std::cout << "=== OCR Detections ===" << std::endl;
//for (size_t i = 0; i < ocrOutput.size(); ++i) {
// << "' X=" << ocrOutput[i].box.x
// << " Y=" << ocrOutput[i].box.y << std::endl;
//}
// Remove duplicates
std::vector<Object> uniqueOutput;
for (const auto& obj : ocrOutput) {
bool isDuplicate = false;
for (const auto& unique : uniqueOutput) {
if (std::abs(obj.box.x - unique.box.x) < DUPLICATE_DIST_THRESHOLD &&
std::abs(obj.box.y - unique.box.y) < DUPLICATE_DIST_THRESHOLD) {
isDuplicate = true;
break;
}
}
if (!isDuplicate) {
uniqueOutput.push_back(obj);
}
}
//std::cout << "\nAfter removing duplicates: " << uniqueOutput.size() << " chars" << std::endl;
if (uniqueOutput.empty()) return ocrText;
if (uniqueOutput.size() == 1) return uniqueOutput[0].className;
// Calculate average character height for threshold
float avgHeight = 0;
for (const auto& obj : uniqueOutput) {
avgHeight += obj.box.height;
}
avgHeight /= uniqueOutput.size();
// Calculate linear regression Y = mX + b
float sumX = 0, sumY = 0, sumXY = 0, sumX2 = 0;
int n = uniqueOutput.size();
for (const auto& obj : uniqueOutput) {
float x = obj.box.x;
float y = obj.box.y;
sumX += x;
sumY += y;
sumXY += x * y;
sumX2 += x * x;
}
float denominator = n * sumX2 - sumX * sumX;
float slope = (std::abs(denominator) > 1e-6f) ? (n * sumXY - sumX * sumY) / denominator : 0.0f;
float intercept = (n > 0) ? (sumY - slope * sumX) / n : 0.0f;
//std::cout << "Linear regression: Y = " << slope << " * X + " << intercept << std::endl;
// Calculate perpendicular distance from each point to regression line
float a = slope;
float b = -1.0f;
float c = intercept;
float normFactor = std::sqrt(a * a + b * b);
std::vector<std::pair<float, size_t>> distances;
for (size_t i = 0; i < uniqueOutput.size(); ++i) {
float x = uniqueOutput[i].box.x;
float y = uniqueOutput[i].box.y;
float dist = (a * x + b * y + c) / normFactor;
distances.push_back({ dist, i });
}
// Sort by perpendicular distance
std::sort(distances.begin(), distances.end(),
[](const std::pair<float, size_t>& a, const std::pair<float, size_t>& b) {
return a.first < b.first;
});
// Find largest gap in perpendicular distances
float maxGap = 0;
size_t splitIdx = distances.size() / 2;
//std::cout << "\n=== Distance gaps ===" << std::endl;
for (size_t i = 1; i < distances.size(); ++i) {
float gap = distances[i].first - distances[i - 1].first;
//std::cout << "Gap " << i << ": " << gap << std::endl;
if (gap > maxGap) {
maxGap = gap;
splitIdx = i;
}
}
// Check if this is actually a single row
// If max gap is too small relative to character height, it's a single row
std::vector<std::vector<Object>> rows;
if (maxGap < avgHeight * ROW_SPLIT_MIN_GAP_FACTOR) {
// Single row - all characters on one line
rows.resize(1);
rows[0] = uniqueOutput;
}
else {
// Two rows
rows.resize(2);
// Split into two rows based on perpendicular distance
for (size_t i = 0; i < distances.size(); ++i) {
size_t objIdx = distances[i].second;
if (i < splitIdx) {
rows[0].push_back(uniqueOutput[objIdx]);
}
else {
rows[1].push_back(uniqueOutput[objIdx]);
}
}
// Determine which row is on top (lower average Y = top row)
float avgY0 = 0, avgY1 = 0;
for (const auto& obj : rows[0]) {
avgY0 += obj.box.y;
}
for (const auto& obj : rows[1]) {
avgY1 += obj.box.y;
}
avgY0 /= rows[0].size();
avgY1 /= rows[1].size();
//std::cout << "Average Y: Row0=" << avgY0 << " Row1=" << avgY1 << std::endl;
// Swap if needed (top row should be row 0)
if (avgY0 > avgY1) {
//std::cout << "Swapping rows (Row 0 should be on top)" << std::endl;
std::swap(rows[0], rows[1]);
}
}
//std::cout << "\n=== Rows before X-sorting ===" << std::endl;
//for (size_t r = 0; r < rows.size(); ++r) {
// std::cout << "Row " << r << " (" << rows[r].size() << " chars): ";
// for (const auto& obj : rows[r]) {
// }
// std::cout << std::endl;
//}
// Sort each row by X
for (auto& row : rows) {
std::sort(row.begin(), row.end(),
[](const Object& a, const Object& b) {
return a.box.x < b.box.x;
});
}
/*std::cout << "\n=== Rows after X-sorting ===" << std::endl;
for (size_t r = 0; r < rows.size(); ++r) {
std::cout << "Row " << r << ": ";
for (const auto& obj : rows[r]) {
}
std::cout << std::endl;
}*/
// Concatenate
for (const auto& row : rows) {
for (const auto& obj : row) {
ocrText += obj.className;
}
}
//std::cout << "\nFinal text: '" << ocrText << "'" << std::endl;
grayLprROI.release(); // Release the grayscale image to free memory
std::string processedOcrText = AnalyseLicensePlateText(ocrText);
return processedOcrText;
ANS_DBG("OCR_PostProc", "cam=%s entry path=single ocr_dets=%zu lpr=%dx%d",
cameraId.c_str(), ocrOutput.size(), grayLprROI.cols, grayLprROI.rows);
return ProcessSingleOCRResult(ocrOutput, cameraId);
}
catch (std::exception& e) {
this->_logger.LogFatal("ANSALPR_OD::DetectLicensePlateString", e.what(), __FILE__, __LINE__);
@@ -2917,7 +2754,7 @@ namespace ANSCENTER {
// Process OCR results — ProcessSingleOCRResult is pure CPU math
// on ~5-20 characters per plate, so thread overhead dominates.
for (size_t i = 0; i < batchSize; ++i) {
results[i] = ProcessSingleOCRResult(ocrBatchOutputs[i]);
results[i] = ProcessSingleOCRResult(ocrBatchOutputs[i], cameraId);
}
return results;
@@ -2931,8 +2768,9 @@ namespace ANSCENTER {
}
// New helper function - thread-safe, no shared state
std::string ANSALPR_OD::ProcessSingleOCRResult(const std::vector<Object>& ocrOutput) {
std::string ANSALPR_OD::ProcessSingleOCRResult(const std::vector<Object>& ocrOutput, const std::string& cameraId) {
if (ocrOutput.empty()) {
ANS_DBG("OCR_PostProc", "cam=%s empty raw OCR output", cameraId.c_str());
return "";
}
@@ -2978,10 +2816,12 @@ namespace ANSCENTER {
}
if (uniqueOutput.empty()) {
ANS_DBG("OCR_PostProc", "cam=%s all dets dropped as duplicates raw=%zu", cameraId.c_str(), ocrOutput.size());
return "";
}
if (uniqueOutput.size() == 1) {
ANS_DBG("OCR_PostProc", "cam=%s single-char plate cls=%s", cameraId.c_str(), uniqueOutput[0].className.c_str());
return AnalyseLicensePlateText(uniqueOutput[0].className);
}
@@ -2996,17 +2836,85 @@ namespace ANSCENTER {
}
avgHeight /= static_cast<float>(n);
// ---- Mean center ----
// Hybrid row-split strategy:
// - If chars cluster cleanly in Y (maxYGap > avgHeight*Y_CLUSTER_STRONG_FACTOR),
// trust Y-clustering. Handles flat plates with asymmetric layouts where PCA
// gets fooled by cov(x,y) from row-centroid mismatch.
// - Otherwise, the plate is either single-row or significantly tilted; fall
// back to PCA on character centers to find the true reading direction,
// then split rows by perpendicular projection. Handles tilts up to ~45°
// where rows interleave in raw Y.
//
// Failure precedents:
// "30E89916" (78x64, top "30E" centered over wider bottom "89916", flat):
// PCA invents theta≈33° from layout → "30E16899". Y-cluster works.
// "65L149702" (heavily tilted ~28°):
// Y-cluster splits rows mid-row at the largest Y gap → "654970L21".
// PCA correctly finds reading direction.
std::vector<std::pair<float, size_t>> ySorted;
ySorted.reserve(n);
for (int i = 0; i < n; ++i)
ySorted.push_back({ cys[i], static_cast<size_t>(i) });
std::sort(ySorted.begin(), ySorted.end());
float maxYGap = 0.0f;
size_t ySplitIdx = ySorted.size();
const size_t minGroupSize = ROW_SPLIT_MIN_GROUP_SIZE;
for (size_t i = 1; i < ySorted.size(); ++i) {
if (i < minGroupSize || (ySorted.size() - i) < minGroupSize)
continue;
float gap = ySorted[i].first - ySorted[i - 1].first;
if (gap > maxYGap) {
maxYGap = gap;
ySplitIdx = i;
}
}
const float gapThreshold = avgHeight * ROW_SPLIT_MIN_GAP_FACTOR;
const float strongYThreshold = avgHeight * Y_CLUSTER_STRONG_FACTOR;
const bool useYCluster = (maxYGap > strongYThreshold) && (ySplitIdx < ySorted.size());
auto sortByXAndConcat = [&](std::vector<size_t>& row, std::string& out) {
std::sort(row.begin(), row.end(), [&](size_t a, size_t b) {
return uniqueOutput[a].box.x < uniqueOutput[b].box.x;
});
for (size_t idx : row) out += uniqueOutput[idx].className;
};
// ============================================================
// Path A: Y-clustering (flat plates with reliable Y separation)
// ============================================================
if (useYCluster) {
std::vector<size_t> topRow, bottomRow;
topRow.reserve(ySplitIdx);
bottomRow.reserve(ySorted.size() - ySplitIdx);
for (size_t i = 0; i < ySplitIdx; ++i) topRow.push_back(ySorted[i].second);
for (size_t i = ySplitIdx; i < ySorted.size(); ++i) bottomRow.push_back(ySorted[i].second);
std::string ocrText;
ocrText.reserve(n);
sortByXAndConcat(topRow, ocrText);
sortByXAndConcat(bottomRow, ocrText);
std::string finalText = AnalyseLicensePlateText(ocrText);
float avgY0 = 0.0f, avgY1 = 0.0f;
for (size_t idx : topRow) avgY0 += cys[idx];
for (size_t idx : bottomRow) avgY1 += cys[idx];
avgY0 /= static_cast<float>(topRow.size());
avgY1 /= static_cast<float>(bottomRow.size());
ANS_DBG("OCR_PostProc", "cam=%s Y-cluster two-row n=%d split=%zu/%zu maxYGap=%.2f avgYsep=%.2f raw='%s' final='%s'",
cameraId.c_str(), n, topRow.size(), bottomRow.size(),
maxYGap, std::abs(avgY1 - avgY0), ocrText.c_str(), finalText.c_str());
return finalText;
}
// ============================================================
// Path B: PCA (single-row or tilted plates)
// ============================================================
float meanX = 0.0f, meanY = 0.0f;
for (int i = 0; i < n; ++i) {
meanX += cxs[i];
meanY += cys[i];
}
meanX /= n;
meanY /= n;
for (int i = 0; i < n; ++i) { meanX += cxs[i]; meanY += cys[i]; }
meanX /= n; meanY /= n;
// PCA to find the plate's reading direction.
// Robust to large tilt angles unlike OLS regression.
float cov_xx = 0.0f, cov_xy = 0.0f, cov_yy = 0.0f;
for (int i = 0; i < n; ++i) {
float dx = cxs[i] - meanX;
@@ -3017,14 +2925,10 @@ namespace ANSCENTER {
}
float theta = 0.5f * std::atan2(2.0f * cov_xy, cov_xx - cov_yy);
float dirX = std::cos(theta);
float dirY = std::sin(theta);
float dirX = std::cos(theta), dirY = std::sin(theta);
if (dirX < 0) { dirX = -dirX; dirY = -dirY; }
float perpX = -dirY, perpY = dirX;
float perpX = -dirY;
float perpY = dirX;
// Project centers onto both axes
std::vector<float> projAlong(n), projPerp(n);
for (int i = 0; i < n; ++i) {
float dx = cxs[i] - meanX;
@@ -3033,84 +2937,73 @@ namespace ANSCENTER {
projPerp[i] = dx * perpX + dy * perpY;
}
// Row splitting using perpendicular projections
std::vector<std::pair<float, size_t>> perpSorted;
perpSorted.reserve(n);
for (int i = 0; i < n; ++i)
perpSorted.push_back({ projPerp[i], static_cast<size_t>(i) });
std::sort(perpSorted.begin(), perpSorted.end());
// Find largest gap with validation:
// 1. Both groups must have >= 2 chars
// 2. Groups must be vertically separated (avgY check)
float maxGap = 0.0f;
size_t splitIdx = perpSorted.size() / 2;
const size_t minGroupSize = ROW_SPLIT_MIN_GROUP_SIZE;
float maxPerpGap = 0.0f;
size_t perpSplitIdx = perpSorted.size();
for (size_t i = 1; i < perpSorted.size(); ++i) {
float gap = perpSorted[i].first - perpSorted[i - 1].first;
if (i < minGroupSize || (perpSorted.size() - i) < minGroupSize)
continue;
if (gap > maxGap) {
float gap = perpSorted[i].first - perpSorted[i - 1].first;
if (gap > maxPerpGap) {
float avgY_g1 = 0.0f, avgY_g2 = 0.0f;
for (size_t j = 0; j < i; ++j)
avgY_g1 += cys[perpSorted[j].second];
for (size_t j = i; j < perpSorted.size(); ++j)
avgY_g2 += cys[perpSorted[j].second];
for (size_t j = 0; j < i; ++j) avgY_g1 += cys[perpSorted[j].second];
for (size_t j = i; j < perpSorted.size(); ++j) avgY_g2 += cys[perpSorted[j].second];
avgY_g1 /= static_cast<float>(i);
avgY_g2 /= static_cast<float>(perpSorted.size() - i);
if (std::abs(avgY_g2 - avgY_g1) > avgHeight * ROW_SPLIT_AVGY_FACTOR) {
maxGap = gap;
splitIdx = i;
maxPerpGap = gap;
perpSplitIdx = i;
}
}
}
if (maxGap < avgHeight * ROW_SPLIT_MIN_GAP_FACTOR) {
// Single row - sort by projection along reading direction
std::vector<std::pair<float, size_t>> allProj;
for (int i = 0; i < n; ++i)
allProj.push_back({ projAlong[i], static_cast<size_t>(i) });
std::sort(allProj.begin(), allProj.end());
auto sortByProjAlongAndConcat = [&](std::vector<size_t>& row, std::string& out) {
std::sort(row.begin(), row.end(), [&](size_t a, size_t b) {
return projAlong[a] < projAlong[b];
});
for (size_t idx : row) out += uniqueOutput[idx].className;
};
if (maxPerpGap < gapThreshold || perpSplitIdx == perpSorted.size()) {
// Single row along PCA axis
std::vector<size_t> all(n);
for (int i = 0; i < n; ++i) all[i] = static_cast<size_t>(i);
std::string ocrText;
ocrText.reserve(n);
for (const auto& p : allProj)
ocrText += uniqueOutput[p.second].className;
return AnalyseLicensePlateText(ocrText);
}
else {
// Two rows
std::vector<std::vector<size_t>> rowIndices(2);
for (size_t i = 0; i < perpSorted.size(); ++i) {
size_t objIdx = perpSorted[i].second;
if (i < splitIdx)
rowIndices[0].push_back(objIdx);
else
rowIndices[1].push_back(objIdx);
sortByProjAlongAndConcat(all, ocrText);
std::string finalText = AnalyseLicensePlateText(ocrText);
ANS_DBG("OCR_PostProc", "cam=%s PCA single-row n=%d theta=%.3f maxPerpGap=%.2f raw='%s' final='%s'",
cameraId.c_str(), n, theta, maxPerpGap, ocrText.c_str(), finalText.c_str());
return finalText;
}
// Ensure row 0 is top row (lower average center-Y)
std::vector<size_t> topRow, bottomRow;
topRow.reserve(perpSplitIdx);
bottomRow.reserve(perpSorted.size() - perpSplitIdx);
for (size_t i = 0; i < perpSplitIdx; ++i) topRow.push_back(perpSorted[i].second);
for (size_t i = perpSplitIdx; i < perpSorted.size(); ++i) bottomRow.push_back(perpSorted[i].second);
float avgY0 = 0.0f, avgY1 = 0.0f;
for (auto idx : rowIndices[0]) avgY0 += cys[idx];
for (auto idx : rowIndices[1]) avgY1 += cys[idx];
avgY0 /= static_cast<float>(rowIndices[0].size());
avgY1 /= static_cast<float>(rowIndices[1].size());
if (avgY0 > avgY1)
std::swap(rowIndices[0], rowIndices[1]);
for (size_t idx : topRow) avgY0 += cys[idx];
for (size_t idx : bottomRow) avgY1 += cys[idx];
avgY0 /= static_cast<float>(topRow.size());
avgY1 /= static_cast<float>(bottomRow.size());
if (avgY0 > avgY1) std::swap(topRow, bottomRow);
// Sort each row by projection along reading direction
std::string ocrText;
ocrText.reserve(n);
for (const auto& row : rowIndices) {
std::vector<std::pair<float, size_t>> rowProj;
for (auto idx : row)
rowProj.push_back({ projAlong[idx], idx });
std::sort(rowProj.begin(), rowProj.end());
for (const auto& p : rowProj)
ocrText += uniqueOutput[p.second].className;
}
return AnalyseLicensePlateText(ocrText);
}
sortByProjAlongAndConcat(topRow, ocrText);
sortByProjAlongAndConcat(bottomRow, ocrText);
std::string finalText = AnalyseLicensePlateText(ocrText);
ANS_DBG("OCR_PostProc", "cam=%s PCA two-row n=%d theta=%.3f split=%zu/%zu maxPerpGap=%.2f avgYsep=%.2f raw='%s' final='%s'",
cameraId.c_str(), n, theta, topRow.size(), bottomRow.size(),
maxPerpGap, std::abs(avgY1 - avgY0), ocrText.c_str(), finalText.c_str());
return finalText;
}
void ANSALPR_OD::ensureUniquePlateText(std::vector<Object>& results, const std::string& cameraId)
+1 -1
View File
@@ -249,7 +249,7 @@ namespace ANSCENTER
const std::string& cameraId) override;
[[nodiscard]] std::vector<std::string> DetectLicensePlateStringBatch(const std::vector<cv::Mat>& lprROIs, const std::string& cameraId);
[[nodiscard]] std::vector<std::string> DetectLPColourDetectorBatch(const std::vector<cv::Mat>& lprROIs, const std::string& cameraId);
[[nodiscard]] std::string ProcessSingleOCRResult(const std::vector<Object>& ocrOutput);
[[nodiscard]] std::string ProcessSingleOCRResult(const std::vector<Object>& ocrOutput, const std::string& cameraId);
[[nodiscard]] bool Destroy() override;
/// Propagate debug flag to all sub-detectors (LPD, OCR, colour)
+7 -5
View File
@@ -417,7 +417,7 @@ int ANSLPR_OD_VideoTest() {
std::string licenseKey = "";
std::string modelZipFile ="C:\\ProgramData\\ANSCENTER\\ANSVIS Server\\ANSALPR\\ANS_ALPR_v1.2.zip";// "C:\\Projects\\ANSVIS\\Models\\ANS_ALPR_v1.2.zip";// "C:\\ProgramData\\ANSCENTER\\ANSVIS Server\\ANSALPR\\ServerOptimised\\ANS_ALPR_v1.1_NVIDIAGeForceRTX4070LaptopGPU.zip";
std::string videoFilePath = "C:\\ProgramData\\ANSCENTER\\Shared\\day.mp4";//"E:\\Programs\\DemoAssets\\Videos\\ALRP\\PMH\\Day\\day.mp4";//
std::string videoFilePath = "E:\\Programs\\DemoAssets\\Videos\\ALRP\\PMH\\Day\\day.mp4";// "C:\\ProgramData\\ANSCENTER\\Shared\\day.mp4";//
std::string lpnResult;
int engineType = 1;
double detectionThreshold = 0.5;
@@ -701,8 +701,10 @@ int ANSLPR_OD_INDOInferences_FileTest() {
boost::property_tree::ptree pt;
ANSCENTER::ANSALPR* infHandle;
std::string licenseKey = "";
std::string modelZipFile = "E:\\Programs\\DemoAssets\\ModelsForANSVIS\\ANS_ALPR_IND_v1.1.zip";
std::string imageFilePath = "E:\\Programs\\TrainingWorkingStation\\IndoALPR\\Indonesian License Plate Dataset\\data\\train075.jpg";//20250912_213850.717.jpg; 20250912_213850.511.jpg;//20250912_213850.411.jpg;//20250912_213850.261.jpg(65H115912:0.73) cororect (20250912_213850.071.jpg: 65H115833)
std::string modelZipFile = "C:\\ProgramData\\ANSCENTER\\ANSVIS Server\\ANSALPR\\ServerOptimised\\ANS_ALPR_v1.4_NVIDIAGeForceRTX4070LaptopGPU.zip";//"E:\\Programs\\DemoAssets\\ModelsForANSVIS\\ANS_ALPR_IND_v1.1.zip";
std::string imageFilePath = "E:\\Programs\\DemoAssets\\Images\\ALPRTest\\alpr_loi\\702.jpg";//"E:\\Programs\\TrainingWorkingStation\\IndoALPR\\Indonesian License Plate Dataset\\data\\train075.jpg";//20250912_213850.717.jpg; 20250912_213850.511.jpg;//20250912_213850.411.jpg;//20250912_213850.261.jpg(65H115912:0.73) cororect (20250912_213850.071.jpg: 65H115833)
//"E:\\Programs\\DemoAssets\\Images\\ALPRTest\\WrongOrder\\4389.jpg";///
std::string lpnResult;
int engineType = 1;
double detectionThreshold = 0.3;
@@ -5206,7 +5208,7 @@ int main()
// doesn't exist on AMD/Intel machines. Re-enable after fixing the path
// at line 573 if you need the OD folder test.
//ANSLPR_OD_FolderInferences_Test();
//ANSLPR_OD_VideoTest();
ANSLPR_OD_VideoTest();
//ANSLPR_BigSize_VideoTest();
//ANSLPR_CPU_VideoTest();
//for (int i = 0; i < 100; i++) {
@@ -5220,7 +5222,7 @@ int main()
//ANSLPR_OD_CPU_VideoTest();
//ALPR_OCR_Test();
//ALPR_OCR_VideoTest();
ALPR_OCR_FolderInferences_Test();
//ALPR_OCR_FolderInferences_Test();
//ALPR_Helmet_Parallel_VideoTest(); // ANSVIS sim: ALPR + Helmet on same FilePlayer
return 0;