ANSCENTER/ANSCORE
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
b735931c55211c945fb73234c9fb87ad3bdc84cc
ANSCORE/modules/ANSOCR/ANSOCRBase.cpp

869 lines
30 KiB
C++
Raw Blame History

#include "ANSOCRBase.h"
#include "Utility.h"
#include <opencv2/highgui.hpp>
#include <omp.h>
#include <json.hpp>
#include "ANSLibsLoader.h"
static bool ansocrLicenceValid = false;
// Global once_flag to protect license checking
static std::once_flag ansocrLicenseOnceFlag;
template <typename T>
T GetData(const boost::property_tree::ptree& pt, const std::string& key)
{
T ret;
if (boost::optional<T> data = pt.get_optional<T>(key))
{
ret = data.get();
}
return ret;
}
namespace ANSCENTER {
/// <summary>
/// Base class
/// </summary>
///
///
static void VerifyGlobalANSOCRLicense(const std::string& licenseKey) {
try {
ansocrLicenceValid = ANSCENTER::ANSLicenseHelper::LicenseVerification(licenseKey, 1005, "ANSOCR");//Default productId=1006
if (!ansocrLicenceValid) { // we also support ANSTS license
ansocrLicenceValid = ANSCENTER::ANSLicenseHelper::LicenseVerification(licenseKey, 1003, "ANSVIS");//Default productId=1003 (ANSVIS)
}
}
catch (std::exception& e) {
ansocrLicenceValid = false;
}
}
void ANSOCRBase::CheckLicense() {
try {
// Check once globally
std::call_once(ansocrLicenseOnceFlag, [this]() {
VerifyGlobalANSOCRLicense(_licenseKey);
});
// Update this instance's local license flag
_licenseValid = ansocrLicenceValid;
}
catch (const std::exception& e) {
this->_logger.LogFatal("ANSOCRBase::CheckLicense. Error:", e.what(), __FILE__, __LINE__);
}
}
bool ANSOCRBase::Init(const std::string& licenseKey, OCRModelConfig modelConfig, const std::string& modelZipFilePath, const std::string& modelZipPassword, int engineMode) {
try {
ANSCENTER::ANSLibsLoader::Initialize();
_licenseKey = licenseKey;
_engineMode = engineMode;
_licenseValid = false;
_modelFolder = "";
_modelConfigFile = "";
_modelConfig = modelConfig;
_modelFolder.clear();
_modelConfigFile.clear();
CheckLicense();
if (!_licenseValid) {
this->_logger.LogError("ANSOCRBase::Initialize", "Invalid License", __FILE__, __LINE__);
return false;
}
_licenseValid = true;
// 0. Check if the modelZipFilePath exist?
if (!FileExist(modelZipFilePath)) {
this->_logger.LogFatal("ANSOCRBase::Initialize", "Model zip file is not exist", __FILE__, __LINE__);
return false;
}
// 1. Unzip model zip file to a special location with folder name as model file (and version)
std::string outputFolder;
std::vector<std::string> passwordArray;
if (!modelZipPassword.empty()) passwordArray.push_back(modelZipPassword);
passwordArray.push_back("AnsDemoModels20@!");
passwordArray.push_back("Sh7O7nUe7vJ/417W0gWX+dSdfcP9hUqtf/fEqJGqxYL3PedvHubJag==");
passwordArray.push_back("3LHxGrjQ7kKDJBD9MX86H96mtKLJaZcTYXrYRdQgW8BKGt7enZHYMg==");
std::string modelName = GetFileNameWithoutExtension(modelZipFilePath);
//this->_logger.LogDebug("ANSOCRBase::Initialize. Model name", modelName, __FILE__, __LINE__);
size_t vectorSize = passwordArray.size();
for (size_t i = 0; i < vectorSize; i++) {
if (ExtractPasswordProtectedZip(modelZipFilePath, passwordArray[i], modelName, _modelFolder, false))
break; // Break the loop when the condition is met.
}
// 2. Check if the outputFolder exist
if (!std::filesystem::exists(_modelFolder)) {
this->_logger.LogError("ANSOCRBase::Initialize. Output model folder is not exist", modelName, __FILE__, __LINE__);
return false; // That means the model file is not exist or the password is not correct
}
return true;
}
catch (std::exception& e) {
this->_logger.LogFatal("ANSOCRBase::Initialize", e.what(), __FILE__, __LINE__);
return false;
}
}
bool ANSOCRBase::Initialize(const std::string& licenseKey, OCRModelConfig modelConfig, const std::string& modelZipFilePath, const std::string& modelZipPassword, int engineMode) {
try {
_licenseKey = licenseKey;
_engineMode = engineMode;
_licenseValid = false;
_modelFolder = "";
_modelConfigFile = "";
_modelConfig = modelConfig;
_modelFolder.clear();
_modelConfigFile.clear();
CheckLicense();
if (!_licenseValid) {
this->_logger.LogError("ANSOCRBase::Initialize", "Invalid License", __FILE__, __LINE__);
return false;
}
_licenseValid = true;
// 0. Check if the modelZipFilePath exist?
if (!FileExist(modelZipFilePath)) {
this->_logger.LogFatal("ANSOCRBase::Initialize", "Model zip file is not exist", __FILE__, __LINE__);
return false;
}
// 1. Unzip model zip file to a special location with folder name as model file (and version)
std::string outputFolder;
std::vector<std::string> passwordArray;
if (!modelZipPassword.empty()) passwordArray.push_back(modelZipPassword);
passwordArray.push_back("AnsDemoModels20@!");
passwordArray.push_back("Sh7O7nUe7vJ/417W0gWX+dSdfcP9hUqtf/fEqJGqxYL3PedvHubJag==");
passwordArray.push_back("3LHxGrjQ7kKDJBD9MX86H96mtKLJaZcTYXrYRdQgW8BKGt7enZHYMg==");
std::string modelName = GetFileNameWithoutExtension(modelZipFilePath);
//this->_logger.LogDebug("ANSOCRBase::Initialize. Model name", modelName, __FILE__, __LINE__);
size_t vectorSize = passwordArray.size();
for (size_t i = 0; i < vectorSize; i++) {
if (ExtractPasswordProtectedZip(modelZipFilePath, passwordArray[i], modelName, _modelFolder, false))
break; // Break the loop when the condition is met.
}
// 2. Check if the outputFolder exist
if (!std::filesystem::exists(_modelFolder)) {
this->_logger.LogError("ANSOCRBase::Initialize. Output model folder is not exist", modelName, __FILE__, __LINE__);
return false; // That means the model file is not exist or the password is not correct
}
// 3. Check if the model has the configuration file
std::string modelConfigName = "model_config.json";
_modelConfigFile = CreateFilePath(_modelFolder, modelConfigName);
//4. For now we do have the model folder so we will assign paths to OCR models
_modelConfig.detectionModelDir = _modelFolder;
_modelConfig.recognizerModelDir = _modelFolder;
_modelConfig.clsModelDir = _modelFolder;
_modelConfig.layoutModelDir = _modelFolder;
_modelConfig.layourDictionaryPath = _modelFolder;
_modelConfig.tableModelDir = _modelFolder;
_modelConfig.tableCharDictionaryPath = _modelFolder;
_modelConfig.recogizerCharDictionaryPath = CreateFilePath(_modelFolder, "dict_ch.txt");
_modelConfig.detectionModelFile = CreateFilePath(_modelFolder, "ansocrdec.onnx");
_modelConfig.detectionModelParam = CreateFilePath(_modelFolder, "ansocrdec.onnx");
_modelConfig.clsModelFile = CreateFilePath(_modelFolder, "ansocrcls.onnx");
_modelConfig.clsModelParam = CreateFilePath(_modelFolder, "ansocrcls.onnx");
_modelConfig.recognizerModelFile = CreateFilePath(_modelFolder, "ansocrrec.onnx");
_modelConfig.recognizerModelParam = CreateFilePath(_modelFolder, "ansocrrec.onnx");
// For now we do have _modelConfig and _modelFolder
return true;
}
catch (std::exception& e) {
this->_logger.LogFatal("ANSOCRBase::Initialize", e.what(), __FILE__, __LINE__);
return false;
}
}
std::string ANSCENTER::ANSOCRUtility::OCRDetectionToJsonString(const std::vector<OCRObject>& dets)
{
if (dets.empty()) {
return R"({"results":[]})";
}
try {
nlohmann::json root;
auto& results = root["results"] = nlohmann::json::array();
for (const auto& det : dets) {
results.push_back({
{"class_id", std::to_string(det.classId)},
{"track_id", std::to_string(det.trackId)},
{"class_name", det.className},
{"prob", std::to_string(det.confidence)},
{"x", std::to_string(det.box.x)},
{"y", std::to_string(det.box.y)},
{"width", std::to_string(det.box.width)},
{"height", std::to_string(det.box.height)},
{"mask", ""}, // TODO: convert masks to comma separated string
{"extra_info", det.extraInfo},
{"camera_id", det.cameraId},
{"polygon", PolygonToString(det.polygon)},
{"kps", KeypointsToString(det.kps)}
});
}
return root.dump();
}
catch (const std::exception& e) {
// Add your error logging here if needed
return R"({"results":[],"error":"Serialization failed"})";
}
}
std::vector<cv::Rect> ANSCENTER::ANSOCRUtility::GetBoundingBoxes(const std::string& strBBoxes) {
std::vector<cv::Rect> bBoxes;
bBoxes.clear();
std::stringstream ss;
ss << strBBoxes;
boost::property_tree::ptree pt;
boost::property_tree::read_json(ss, pt);
BOOST_FOREACH(const boost::property_tree::ptree::value_type & child, pt.get_child("results"))
{
const boost::property_tree::ptree& result = child.second;
const auto x = GetData<float>(result, "x");
const auto y = GetData<float>(result, "y");
const auto width = GetData<float>(result, "width");
const auto height = GetData<float>(result, "height");
cv::Rect rectTemp;
rectTemp.x = x;
rectTemp.y = y;
rectTemp.width = width;
rectTemp.height = height;
bBoxes.push_back(rectTemp);
}
return bBoxes;
}
std::string ANSCENTER::ANSOCRUtility::PolygonToString(const std::vector<cv::Point2f>& polygon) {
if (polygon.empty()) {
return "";
}
std::string result;
result.reserve(polygon.size() * 20);
char buffer[64];
for (size_t i = 0; i < polygon.size(); ++i) {
if (i > 0) {
snprintf(buffer, sizeof(buffer), ";%.3f;%.3f", polygon[i].x, polygon[i].y);
}
else {
snprintf(buffer, sizeof(buffer), "%.3f;%.3f", polygon[i].x, polygon[i].y);
}
result += buffer;
}
return result;
}
std::string ANSCENTER::ANSOCRUtility::KeypointsToString(const std::vector<float>& kps) {
if (kps.empty()) {
return "";
}
std::string result;
result.reserve(kps.size() * 10);
char buffer[32];
for (size_t i = 0; i < kps.size(); ++i) {
if (i > 0) result += ';';
snprintf(buffer, sizeof(buffer), "%.3f", kps[i]);
result += buffer;
}
return result;
}
std::vector<cv::Point2f> ANSCENTER::ANSOCRUtility::RectToNormalizedPolygon(const cv::Rect& rect, float imageWidth, float imageHeight) {
// Ensure imageWidth and imageHeight are non-zero to avoid division by zero
if (imageWidth <= 0 || imageHeight <= 0) {
std::vector<cv::Point2f> emptyPolygon;
return emptyPolygon;
}
// Calculate normalized points for each corner of the rectangle
std::vector<cv::Point2f> polygon = {
{ rect.x / imageWidth, rect.y / imageHeight }, // Top-left
{ (rect.x + rect.width) / imageWidth, rect.y / imageHeight }, // Top-right
{ (rect.x + rect.width) / imageWidth, (rect.y + rect.height) / imageHeight }, // Bottom-right
{ rect.x / imageWidth, (rect.y + rect.height) / imageHeight } // Bottom-left
};
return polygon;
}
// ── ALPR Configuration Methods ──────────────────────────────────────
void ANSOCRBase::SetOCRMode(OCRMode mode) { _ocrMode = mode; }
OCRMode ANSOCRBase::GetOCRMode() const { return _ocrMode; }
void ANSOCRBase::SetALPRCountry(ALPRCountry country) {
_alprCountry = country;
LoadDefaultFormats(country);
}
ALPRCountry ANSOCRBase::GetALPRCountry() const { return _alprCountry; }
void ANSOCRBase::SetALPRFormat(const ALPRPlateFormat& format) {
_alprFormats.clear();
_alprFormats.push_back(format);
}
void ANSOCRBase::AddALPRFormat(const ALPRPlateFormat& format) {
_alprFormats.push_back(format);
}
void ANSOCRBase::ClearALPRFormats() { _alprFormats.clear(); }
const std::vector<ALPRPlateFormat>& ANSOCRBase::GetALPRFormats() const { return _alprFormats; }
void ANSOCRBase::LoadDefaultFormats(ALPRCountry country) {
_alprFormats.clear();
if (country == ALPR_JAPAN) {
ALPRPlateFormat fmt;
fmt.name = "JAPAN_STANDARD";
fmt.country = ALPR_JAPAN;
fmt.numRows = 2;
fmt.rowSplitThreshold = 0.3f;
ALPRZone region;
region.name = "region";
region.row = 0; region.col = 0;
region.charClass = CHAR_KANJI;
region.minLength = 1; region.maxLength = 4;
region.corrections = { {"#", "\xe4\xba\x95"} }; // # -> 井
ALPRZone classification;
classification.name = "classification";
classification.row = 0; classification.col = 1;
classification.charClass = CHAR_DIGIT;
classification.minLength = 1; classification.maxLength = 3;
classification.validationRegex = R"(^\d{1,3}$)";
ALPRZone kana;
kana.name = "kana";
kana.row = 1; kana.col = 0;
kana.charClass = CHAR_HIRAGANA;
kana.minLength = 1; kana.maxLength = 1;
ALPRZone designation;
designation.name = "designation";
designation.row = 1; designation.col = 1;
designation.charClass = CHAR_DIGIT;
designation.minLength = 2; designation.maxLength = 5;
designation.validationRegex = R"(^\d{2}-\d{2}$)";
// On Japanese plates, ・ (middle dot) represents 0
designation.corrections = {
{"\xe3\x83\xbb", "0"}, // ・ (U+30FB fullwidth middle dot)
{"\xc2\xb7", "0"}, // · (U+00B7 middle dot)
{".", "0"} // ASCII dot
};
fmt.zones = { region, classification, kana, designation };
_alprFormats.push_back(fmt);
}
}
// ── UTF-8 Helpers ───────────────────────────────────────────────────
uint32_t ANSOCRUtility::NextUTF8Codepoint(const std::string& str, size_t& pos) {
if (pos >= str.size()) return 0;
uint32_t cp = 0;
unsigned char c = static_cast<unsigned char>(str[pos]);
if (c < 0x80) {
cp = c; pos += 1;
} else if ((c & 0xE0) == 0xC0) {
cp = c & 0x1F;
if (pos + 1 < str.size()) cp = (cp << 6) | (static_cast<unsigned char>(str[pos + 1]) & 0x3F);
pos += 2;
} else if ((c & 0xF0) == 0xE0) {
cp = c & 0x0F;
if (pos + 1 < str.size()) cp = (cp << 6) | (static_cast<unsigned char>(str[pos + 1]) & 0x3F);
if (pos + 2 < str.size()) cp = (cp << 6) | (static_cast<unsigned char>(str[pos + 2]) & 0x3F);
pos += 3;
} else if ((c & 0xF8) == 0xF0) {
cp = c & 0x07;
if (pos + 1 < str.size()) cp = (cp << 6) | (static_cast<unsigned char>(str[pos + 1]) & 0x3F);
if (pos + 2 < str.size()) cp = (cp << 6) | (static_cast<unsigned char>(str[pos + 2]) & 0x3F);
if (pos + 3 < str.size()) cp = (cp << 6) | (static_cast<unsigned char>(str[pos + 3]) & 0x3F);
pos += 4;
} else {
pos += 1; // skip invalid byte
}
return cp;
}
bool ANSOCRUtility::IsCharClass(uint32_t cp, ALPRCharClass charClass) {
switch (charClass) {
case CHAR_DIGIT:
return (cp >= 0x30 && cp <= 0x39);
case CHAR_LATIN_ALPHA:
return (cp >= 0x41 && cp <= 0x5A) || (cp >= 0x61 && cp <= 0x7A);
case CHAR_ALPHANUMERIC:
return (cp >= 0x30 && cp <= 0x39) || (cp >= 0x41 && cp <= 0x5A) || (cp >= 0x61 && cp <= 0x7A);
case CHAR_HIRAGANA:
return (cp >= 0x3040 && cp <= 0x309F);
case CHAR_KATAKANA:
return (cp >= 0x30A0 && cp <= 0x30FF);
case CHAR_KANJI:
return (cp >= 0x4E00 && cp <= 0x9FFF) || (cp >= 0x3400 && cp <= 0x4DBF);
case CHAR_CJK_ANY:
return (cp >= 0x3040 && cp <= 0x30FF) || (cp >= 0x4E00 && cp <= 0x9FFF) || (cp >= 0x3400 && cp <= 0x4DBF);
case CHAR_ANY:
return true;
default:
return false;
}
}
// Helper: encode a single codepoint back to UTF-8
static std::string CodepointToUTF8(uint32_t cp) {
std::string result;
if (cp < 0x80) {
result += static_cast<char>(cp);
} else if (cp < 0x800) {
result += static_cast<char>(0xC0 | (cp >> 6));
result += static_cast<char>(0x80 | (cp & 0x3F));
} else if (cp < 0x10000) {
result += static_cast<char>(0xE0 | (cp >> 12));
result += static_cast<char>(0x80 | ((cp >> 6) & 0x3F));
result += static_cast<char>(0x80 | (cp & 0x3F));
} else {
result += static_cast<char>(0xF0 | (cp >> 18));
result += static_cast<char>(0x80 | ((cp >> 12) & 0x3F));
result += static_cast<char>(0x80 | ((cp >> 6) & 0x3F));
result += static_cast<char>(0x80 | (cp & 0x3F));
}
return result;
}
// Helper: check if a codepoint is a separator/punctuation that should stay with digits
static bool IsDigitSeparator(uint32_t cp) {
return cp == '-' || cp == '.' || cp == 0xB7 || cp == 0x30FB; // hyphen, dot, middle dot (U+00B7, U+30FB)
}
// Helper: split a UTF-8 string by character class, returning parts matching and not matching
// For CHAR_DIGIT, hyphens and dots are kept with digits (common in plate numbers like "20-46")
static void SplitByCharClass(const std::string& text, ALPRCharClass targetClass,
std::string& matched, std::string& remainder) {
matched.clear();
remainder.clear();
size_t pos = 0;
while (pos < text.size()) {
size_t startPos = pos;
uint32_t cp = ANSOCRUtility::NextUTF8Codepoint(text, pos);
if (cp == 0) break;
std::string ch = text.substr(startPos, pos - startPos);
bool belongs = ANSOCRUtility::IsCharClass(cp, targetClass);
// Keep separators with digits
if (!belongs && targetClass == CHAR_DIGIT && IsDigitSeparator(cp)) {
belongs = true;
}
if (belongs) {
matched += ch;
} else {
remainder += ch;
}
}
}
// ── ALPR Post-Processing ────────────────────────────────────────────
std::vector<ALPRResult> ANSOCRUtility::ALPRPostProcessing(
const std::vector<OCRObject>& ocrResults,
const std::vector<ALPRPlateFormat>& formats,
int imageWidth, int imageHeight,
ANSOCRBase* engine,
const cv::Mat& originalImage)
{
std::vector<ALPRResult> results;
if (ocrResults.empty() || formats.empty()) return results;
// Use the first format for now (extensible to try multiple)
const ALPRPlateFormat& fmt = formats[0];
// Step 1: Compute the bounding box encompassing all detections
// Then expand it by 20% on each side to account for tight detection crops
// that may cut off kana characters or edge digits
cv::Rect plateBox = ocrResults[0].box;
for (size_t i = 1; i < ocrResults.size(); i++) {
plateBox |= ocrResults[i].box;
}
{
int expandX = (int)(plateBox.width * 0.20f);
int expandY = (int)(plateBox.height * 0.05f);
plateBox.x = std::max(0, plateBox.x - expandX);
plateBox.y = std::max(0, plateBox.y - expandY);
plateBox.width = std::min(imageWidth - plateBox.x, plateBox.width + expandX * 2);
plateBox.height = std::min(imageHeight - plateBox.y, plateBox.height + expandY * 2);
}
// Step 2: Split OCR results into rows based on vertical center
float plateCenterY = plateBox.y + plateBox.height * 0.5f;
// For 2-row plates, use the midpoint of the plate as the row boundary
float rowBoundary = plateBox.y + plateBox.height * fmt.rowSplitThreshold +
(plateBox.height * (1.0f - fmt.rowSplitThreshold)) * 0.5f;
// Find the actual gap: sort by Y center, find largest gap
std::vector<std::pair<float, int>> yCenters; // (y_center, index)
for (int i = 0; i < (int)ocrResults.size(); i++) {
float yc = ocrResults[i].box.y + ocrResults[i].box.height * 0.5f;
yCenters.push_back({ yc, i });
}
std::sort(yCenters.begin(), yCenters.end());
if (yCenters.size() >= 2) {
float maxGap = 0;
float bestBoundary = rowBoundary;
for (size_t i = 1; i < yCenters.size(); i++) {
float gap = yCenters[i].first - yCenters[i - 1].first;
if (gap > maxGap) {
maxGap = gap;
bestBoundary = (yCenters[i].first + yCenters[i - 1].first) * 0.5f;
}
}
rowBoundary = bestBoundary;
}
// Step 3: Assign each OCR result to a row and collect text per row
struct RowItem {
int ocrIndex;
float xCenter;
std::string text;
float confidence;
cv::Rect box;
};
std::vector<RowItem> topRow, bottomRow;
for (int i = 0; i < (int)ocrResults.size(); i++) {
float yc = ocrResults[i].box.y + ocrResults[i].box.height * 0.5f;
RowItem item;
item.ocrIndex = i;
item.xCenter = ocrResults[i].box.x + ocrResults[i].box.width * 0.5f;
item.text = ocrResults[i].className;
item.confidence = ocrResults[i].confidence;
item.box = ocrResults[i].box;
if (yc < rowBoundary) {
topRow.push_back(item);
} else {
bottomRow.push_back(item);
}
}
// Sort each row left-to-right
auto sortByX = [](const RowItem& a, const RowItem& b) { return a.xCenter < b.xCenter; };
std::sort(topRow.begin(), topRow.end(), sortByX);
std::sort(bottomRow.begin(), bottomRow.end(), sortByX);
// Step 4: Concatenate text per row
std::string topText, bottomText;
float minConfidence = 1.0f;
for (auto& item : topRow) {
topText += item.text;
minConfidence = std::min(minConfidence, item.confidence);
}
for (auto& item : bottomRow) {
bottomText += item.text;
minConfidence = std::min(minConfidence, item.confidence);
}
// Step 5: For each zone, extract text using character class splitting
ALPRResult alprResult;
alprResult.formatName = fmt.name;
alprResult.plateBox = plateBox;
alprResult.confidence = minConfidence;
alprResult.valid = true;
// Process top row zones
std::string topRemaining = topText;
std::vector<const ALPRZone*> topZones, bottomZones;
for (const auto& zone : fmt.zones) {
if (zone.row == 0) topZones.push_back(&zone);
else bottomZones.push_back(&zone);
}
std::sort(topZones.begin(), topZones.end(), [](const ALPRZone* a, const ALPRZone* b) { return a->col < b->col; });
std::sort(bottomZones.begin(), bottomZones.end(), [](const ALPRZone* a, const ALPRZone* b) { return a->col < b->col; });
// Split top row text by character class
for (const auto* zone : topZones) {
std::string matched, remainder;
SplitByCharClass(topRemaining, zone->charClass, matched, remainder);
// Apply corrections
for (const auto& corr : zone->corrections) {
size_t pos = 0;
while ((pos = matched.find(corr.first, pos)) != std::string::npos) {
matched.replace(pos, corr.first.length(), corr.second);
pos += corr.second.length();
}
}
alprResult.parts[zone->name] = matched;
topRemaining = remainder;
}
// Split bottom row text by character class
std::string bottomRemaining = bottomText;
for (const auto* zone : bottomZones) {
std::string matched, remainder;
SplitByCharClass(bottomRemaining, zone->charClass, matched, remainder);
// Apply corrections
for (const auto& corr : zone->corrections) {
size_t pos = 0;
while ((pos = matched.find(corr.first, pos)) != std::string::npos) {
matched.replace(pos, corr.first.length(), corr.second);
pos += corr.second.length();
}
}
alprResult.parts[zone->name] = matched;
bottomRemaining = remainder;
}
// Step 5b: Kana re-crop — if kana zone is empty and we have the original image,
// crop the left portion of the bottom row and run recognizer-only (no detection)
if (engine && !originalImage.empty()) {
const ALPRZone* kanaZone = nullptr;
for (const auto* zone : bottomZones) {
if (zone->charClass == CHAR_HIRAGANA || zone->charClass == CHAR_KATAKANA) {
kanaZone = zone;
break;
}
}
if (kanaZone && alprResult.parts[kanaZone->name].empty() && !bottomRow.empty()) {
cv::Rect bottomBox = bottomRow[0].box;
for (const auto& item : bottomRow) {
bottomBox |= item.box;
}
// Crop the kana area: left ~20% of the expanded plate box, square crop.
int cropW = (int)(plateBox.width * 0.20f);
int cropH = cropW; // Square crop — kana is a square character
int cropX = std::max(0, plateBox.x);
if (cropW < 30) cropW = 30;
// Try vertical offsets: 50% (center), 30%, 15% from top of bottom row
const float yOffsets[] = { 0.50f, 0.30f, 0.15f };
bool kanaFound = false;
for (float yOff : yOffsets) {
if (kanaFound) break;
int centerY = bottomBox.y + (int)(bottomBox.height * yOff);
int cy = centerY - cropH / 2;
int cw = cropW, ch = cropH;
// Clamp to image bounds
if (cy < 0) cy = 0;
if (cropX + cw > originalImage.cols) cw = originalImage.cols - cropX;
if (cy + ch > originalImage.rows) ch = originalImage.rows - cy;
if (cw <= 0 || ch <= 0) continue;
cv::Mat kanaCrop = originalImage(cv::Rect(cropX, cy, cw, ch)).clone();
// Resize to recognizer format: height=48, min width=160
int recH = 48;
double scale = (double)recH / kanaCrop.rows;
cv::Mat resized;
cv::resize(kanaCrop, resized, cv::Size(), scale, scale, cv::INTER_CUBIC);
int minWidth = 160;
if (resized.cols < minWidth) {
int padLeft = (minWidth - resized.cols) / 2;
int padRight = minWidth - resized.cols - padLeft;
cv::copyMakeBorder(resized, resized, 0, 0, padLeft, padRight,
cv::BORDER_CONSTANT, cv::Scalar(255, 255, 255));
}
auto [recText, recConf] = engine->RecognizeText(resized);
if (!recText.empty()) {
std::string kanaText;
size_t pos = 0;
while (pos < recText.size()) {
size_t startPos = pos;
uint32_t cp = NextUTF8Codepoint(recText, pos);
if (cp == 0) break;
if (IsCharClass(cp, kanaZone->charClass)) {
kanaText += recText.substr(startPos, pos - startPos);
}
}
if (!kanaText.empty()) {
alprResult.parts[kanaZone->name] = kanaText;
kanaFound = true;
}
}
}
}
}
// Step 5c: Designation re-crop — if designation has too few digits,
// crop the right portion of the bottom row and run recognizer directly
if (engine && !originalImage.empty()) {
const ALPRZone* desigZone = nullptr;
for (const auto* zone : bottomZones) {
if (zone->name == "designation") {
desigZone = zone;
break;
}
}
if (desigZone && !desigZone->validationRegex.empty()) {
std::string& desigVal = alprResult.parts[desigZone->name];
try {
std::regex re(desigZone->validationRegex);
if (!std::regex_match(desigVal, re)) {
// Crop the right ~75% of the plate's bottom row
cv::Rect bottomBox = bottomRow[0].box;
for (const auto& item : bottomRow) bottomBox |= item.box;
int cropX = plateBox.x + (int)(plateBox.width * 0.25f);
int cropY = bottomBox.y;
int cropW = plateBox.x + plateBox.width - cropX;
int cropH = bottomBox.height;
// Clamp
if (cropX + cropW > originalImage.cols) cropW = originalImage.cols - cropX;
if (cropY + cropH > originalImage.rows) cropH = originalImage.rows - cropY;
if (cropW > 0 && cropH > 0) {
cv::Mat desigCrop = originalImage(cv::Rect(cropX, cropY, cropW, cropH)).clone();
// Resize to recognizer format
int recH = 48;
double scale = (double)recH / desigCrop.rows;
cv::Mat resized;
cv::resize(desigCrop, resized, cv::Size(), scale, scale, cv::INTER_CUBIC);
int minWidth = 320;
if (resized.cols < minWidth) {
cv::copyMakeBorder(resized, resized, 0, 0, 0, minWidth - resized.cols,
cv::BORDER_CONSTANT, cv::Scalar(255, 255, 255));
}
auto [recText, recConf] = engine->RecognizeText(resized);
if (!recText.empty()) {
// Apply corrections (dots to zeros)
for (const auto& corr : desigZone->corrections) {
size_t pos = 0;
while ((pos = recText.find(corr.first, pos)) != std::string::npos) {
recText.replace(pos, corr.first.length(), corr.second);
pos += corr.second.length();
}
}
// Extract digits and separators
std::string desigText;
size_t pos = 0;
while (pos < recText.size()) {
size_t startPos = pos;
uint32_t cp = NextUTF8Codepoint(recText, pos);
if (cp == 0) break;
if (IsCharClass(cp, CHAR_DIGIT) || IsDigitSeparator(cp)) {
desigText += recText.substr(startPos, pos - startPos);
}
}
if (!desigText.empty() && desigText.size() > desigVal.size()) {
desigVal = desigText;
}
}
}
}
} catch (...) {}
}
}
// Step 6: Validate and auto-fix zones that fail regex
for (const auto& zone : fmt.zones) {
if (zone.validationRegex.empty() || alprResult.parts[zone.name].empty()) continue;
try {
std::regex re(zone.validationRegex);
std::string& val = alprResult.parts[zone.name];
if (!std::regex_match(val, re)) {
bool fixed = false;
// For designation: try trimming leading digits (leaked from classification row)
if (zone.row == 1 && zone.charClass == CHAR_DIGIT) {
for (size_t trim = 1; trim < val.size() && !fixed; trim++) {
size_t pos = 0;
for (size_t t = 0; t < trim; t++) {
NextUTF8Codepoint(val, pos);
}
std::string trimmed = val.substr(pos);
if (std::regex_match(trimmed, re)) {
val = trimmed;
fixed = true;
}
}
}
// For designation: if too few digits, pad with leading zeros
// Japanese plates use ・ for zero, so "12" means "00-12"
if (!fixed && zone.name == "designation") {
// Extract only digits from val
std::string digitsOnly;
for (char c : val) {
if (c >= '0' && c <= '9') digitsOnly += c;
}
if (digitsOnly.size() >= 1 && digitsOnly.size() <= 3) {
// Pad to 4 digits and insert hyphen
while (digitsOnly.size() < 4) digitsOnly = "0" + digitsOnly;
std::string padded = digitsOnly.substr(0, 2) + "-" + digitsOnly.substr(2, 2);
if (std::regex_match(padded, re)) {
val = padded;
fixed = true;
}
}
}
if (!fixed) {
alprResult.valid = false;
}
}
} catch (...) {}
}
// Step 7: Build full plate text (after validation/fix so values are corrected)
alprResult.fullPlateText.clear();
for (const auto* zone : topZones) {
if (!alprResult.fullPlateText.empty()) alprResult.fullPlateText += " ";
alprResult.fullPlateText += alprResult.parts[zone->name];
}
alprResult.fullPlateText += " ";
for (const auto* zone : bottomZones) {
if (zone != bottomZones[0]) alprResult.fullPlateText += " ";
alprResult.fullPlateText += alprResult.parts[zone->name];
}
results.push_back(alprResult);
return results;
}
// ── ALPR JSON Serialization ─────────────────────────────────────────
std::string ANSOCRUtility::ALPRResultToJsonString(const std::vector<ALPRResult>& results) {
if (results.empty()) {
return R"({"results":[]})";
}
try {
nlohmann::json root;
auto& jsonResults = root["results"] = nlohmann::json::array();
for (const auto& res : results) {
nlohmann::json alprInfo;
alprInfo["valid"] = res.valid;
alprInfo["format"] = res.formatName;
for (const auto& part : res.parts) {
alprInfo[part.first] = part.second;
}
jsonResults.push_back({
{"class_id", "0"},
{"track_id", "0"},
{"class_name", res.fullPlateText},
{"prob", std::to_string(res.confidence)},
{"x", std::to_string(res.plateBox.x)},
{"y", std::to_string(res.plateBox.y)},
{"width", std::to_string(res.plateBox.width)},
{"height", std::to_string(res.plateBox.height)},
{"mask", ""},
{"extra_info", ""},
{"camera_id", ""},
{"polygon", ""},
{"kps", ""},
{"alpr_info", alprInfo}
});
}
return root.dump();
} catch (const std::exception&) {
return R"({"results":[],"error":"ALPR serialization failed"})";
}
}
};
Reference in New Issue View Git Blame Copy Permalink