575 lines
21 KiB
C++
575 lines
21 KiB
C++
#include "ANSCpuOCR.h"
|
|
#include "Utility.h"
|
|
#include <opencv2/highgui.hpp>
|
|
#include <omp.h>
|
|
#include <include/paddleocr_utility.h>
|
|
|
|
|
|
namespace ANSCENTER {
|
|
|
|
bool ANSCPUOCR::Initialize(const std::string& licenseKey, OCRModelConfig modelConfig,
|
|
const std::string& modelZipFilePath, const std::string& modelZipPassword, int engineMode) {
|
|
try
|
|
{
|
|
bool result = ANSOCRBase::Initialize(licenseKey, modelConfig, modelZipFilePath, modelZipPassword, engineMode);
|
|
if (!result) return false;
|
|
|
|
//Override the paddleocrv3 for openvino only
|
|
switch (_modelConfig.ocrLanguage) {
|
|
case ANSCENTER::OCRLanguage::ENGLISH: {
|
|
_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_en.txt");
|
|
|
|
_modelConfig.detectionModelFile = CreateFilePath(_modelFolder, "EN_DET.pdmodel");
|
|
_modelConfig.detectionModelParam = CreateFilePath(_modelFolder, "EN_DET.pdiparams");
|
|
_modelConfig.clsModelFile = CreateFilePath(_modelFolder, "CH_CLS.pdmodel");
|
|
_modelConfig.clsModelParam = CreateFilePath(_modelFolder, "CH_CLS.pdiparams");
|
|
_modelConfig.recognizerModelFile = CreateFilePath(_modelFolder, "ENV4_REC.pdmodel");
|
|
_modelConfig.recognizerModelParam = CreateFilePath(_modelFolder, "ENV4_REC.pdiparams");
|
|
|
|
break;
|
|
}
|
|
case ANSCENTER::OCRLanguage::CHINESE: {
|
|
_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, "CHV4_DET.pdmodel");
|
|
_modelConfig.detectionModelParam = CreateFilePath(_modelFolder, "CHV4_DET.pdiparams");
|
|
_modelConfig.clsModelFile = CreateFilePath(_modelFolder, "CH_CLS.pdmodel");
|
|
_modelConfig.clsModelParam = CreateFilePath(_modelFolder, "CH_CLS.pdiparams");
|
|
_modelConfig.recognizerModelFile = CreateFilePath(_modelFolder, "CHV4_REC.pdmodel");
|
|
_modelConfig.recognizerModelParam = CreateFilePath(_modelFolder, "CHV4_REC.pdiparams");
|
|
break;
|
|
}
|
|
case ANSCENTER::OCRLanguage::FRENCH: {
|
|
_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_fr.txt");
|
|
|
|
_modelConfig.detectionModelFile = CreateFilePath(_modelFolder, "MPP_DET.pdmodel");
|
|
_modelConfig.detectionModelParam = CreateFilePath(_modelFolder, "MPP_DET.pdiparams");
|
|
_modelConfig.clsModelFile = CreateFilePath(_modelFolder, "CH_CLS.pdmodel");
|
|
_modelConfig.clsModelParam = CreateFilePath(_modelFolder, "CH_CLS.pdiparams");
|
|
_modelConfig.recognizerModelFile = CreateFilePath(_modelFolder, "FR_REC.pdmodel");
|
|
_modelConfig.recognizerModelParam = CreateFilePath(_modelFolder, "FR_REC.pdiparams");
|
|
break;
|
|
}
|
|
case ANSCENTER::OCRLanguage::GERMANY: {
|
|
_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_gr.txt");
|
|
|
|
_modelConfig.detectionModelFile = CreateFilePath(_modelFolder, "MPP_DET.pdmodel");
|
|
_modelConfig.detectionModelParam = CreateFilePath(_modelFolder, "MPP_DET.pdiparams");
|
|
_modelConfig.clsModelFile = CreateFilePath(_modelFolder, "CH_CLS.pdmodel");
|
|
_modelConfig.clsModelParam = CreateFilePath(_modelFolder, "CH_CLS.pdiparams");
|
|
_modelConfig.recognizerModelFile = CreateFilePath(_modelFolder, "GR_REC.pdmodel");
|
|
_modelConfig.recognizerModelParam = CreateFilePath(_modelFolder, "GR_REC.pdiparams");
|
|
break;
|
|
}
|
|
case ANSCENTER::OCRLanguage::JAPANESE: {
|
|
_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_jp.txt");
|
|
|
|
_modelConfig.detectionModelFile = CreateFilePath(_modelFolder, "MPP_DET.pdmodel");
|
|
_modelConfig.detectionModelParam = CreateFilePath(_modelFolder, "MPP_DET.pdiparams");
|
|
_modelConfig.clsModelFile = CreateFilePath(_modelFolder, "CH_CLS.pdmodel");
|
|
_modelConfig.clsModelParam = CreateFilePath(_modelFolder, "CH_CLS.pdiparams");
|
|
_modelConfig.recognizerModelFile = CreateFilePath(_modelFolder, "JP_REC.pdmodel");
|
|
_modelConfig.recognizerModelParam = CreateFilePath(_modelFolder, "JP_REC.pdiparams");
|
|
|
|
break;
|
|
}
|
|
case ANSCENTER::OCRLanguage::KOREAN: {
|
|
_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_kr.txt");
|
|
|
|
_modelConfig.detectionModelFile = CreateFilePath(_modelFolder, "MPP_DET.pdmodel");
|
|
_modelConfig.detectionModelParam = CreateFilePath(_modelFolder, "MPP_DET.pdiparams");
|
|
_modelConfig.clsModelFile = CreateFilePath(_modelFolder, "CH_CLS.pdmodel");
|
|
_modelConfig.clsModelParam = CreateFilePath(_modelFolder, "CH_CLS.pdiparams");
|
|
_modelConfig.recognizerModelFile = CreateFilePath(_modelFolder, "KR_REC.pdmodel");
|
|
_modelConfig.recognizerModelParam = CreateFilePath(_modelFolder, "KR_REC.pdiparams");
|
|
break;
|
|
}
|
|
case ANSCENTER::OCRLanguage::CUSTOM: {
|
|
_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_ct.txt");
|
|
|
|
_modelConfig.detectionModelFile = CreateFilePath(_modelFolder, "CT_DET.pdmodel");
|
|
_modelConfig.detectionModelParam = CreateFilePath(_modelFolder, "CT_DET.pdiparams");
|
|
_modelConfig.clsModelFile = CreateFilePath(_modelFolder, "CH_CLS.pdmodel");
|
|
_modelConfig.clsModelParam = CreateFilePath(_modelFolder, "CH_CLS.pdiparams");
|
|
_modelConfig.recognizerModelFile = CreateFilePath(_modelFolder, "CT_REC.pdmodel");
|
|
_modelConfig.recognizerModelParam = CreateFilePath(_modelFolder, "CT_REC.pdiparams");
|
|
break;
|
|
}
|
|
default: {
|
|
_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_ct.txt");
|
|
|
|
_modelConfig.detectionModelFile = CreateFilePath(_modelFolder, "CT_DET.pdmodel");
|
|
_modelConfig.detectionModelParam = CreateFilePath(_modelFolder, "CT_DET.pdiparams");
|
|
_modelConfig.clsModelFile = CreateFilePath(_modelFolder, "CH_CLS.pdmodel");
|
|
_modelConfig.clsModelParam = CreateFilePath(_modelFolder, "CH_CLS.pdiparams");
|
|
_modelConfig.recognizerModelFile = CreateFilePath(_modelFolder, "CT_REC.pdmodel");
|
|
_modelConfig.recognizerModelParam = CreateFilePath(_modelFolder, "CT_REC.pdiparams");
|
|
break;
|
|
}
|
|
}
|
|
// For now we do have _modelConfig and _modelFolder
|
|
if (!FileExist(_modelConfig.detectionModelFile)) {
|
|
this->_logger.LogFatal("ANSCPUOCR::Initialize", "Invalid detector model file", __FILE__, __LINE__);
|
|
_licenseValid = false;
|
|
return false;
|
|
}
|
|
|
|
if (!FileExist(_modelConfig.clsModelFile)) {
|
|
this->_logger.LogFatal("ANSCPUOCR::Initialize", "Invalid classifier model file", __FILE__, __LINE__);
|
|
_licenseValid = false;
|
|
return false;
|
|
}
|
|
|
|
if (!FileExist(_modelConfig.recognizerModelFile)) {
|
|
this->_logger.LogFatal("ANSCPUOCR::Initialize", "Invalid recognizer model file", __FILE__, __LINE__);
|
|
_licenseValid = false;
|
|
return false;
|
|
}
|
|
try {
|
|
|
|
_isInitialized = ppocr->Initialize(_modelConfig.detectionModelFile, _modelConfig.clsModelFile, _modelConfig.recognizerModelFile, _modelConfig.recogizerCharDictionaryPath);
|
|
return _isInitialized;
|
|
}
|
|
catch (const std::exception& e) {
|
|
_licenseValid = false;
|
|
this->_logger.LogFatal("ANSCPUOCR::Initialize", e.what(), __FILE__, __LINE__);
|
|
return false;
|
|
}
|
|
catch (...) {
|
|
_licenseValid = false;
|
|
this->_logger.LogFatal("ANSCPUOCR::Initialize", "Failed to create OCR objects", __FILE__, __LINE__);
|
|
return false;
|
|
}
|
|
}
|
|
catch (std::exception& e) {
|
|
// Handle any other exception that occurs during initialization
|
|
this->_logger.LogFatal("ANSCPUOCR::Initialize", e.what(), __FILE__, __LINE__);
|
|
_licenseValid = false;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
std::vector<ANSCENTER::OCRObject> ANSCPUOCR::RunInference(const cv::Mat& input) {
|
|
std::vector<ANSCENTER::OCRObject> output;
|
|
if (input.empty()) return output;
|
|
if ((input.cols < 10) || (input.rows < 10)) return output;
|
|
return RunInference(input, "OCRCPUCAM");
|
|
}
|
|
std::vector<ANSCENTER::OCRObject> ANSCPUOCR::RunInference(const cv::Mat& input, const std::string& cameraId) {
|
|
std::lock_guard<std::mutex> lock(_mutex);
|
|
|
|
// Early validation
|
|
if (!_licenseValid) {
|
|
this->_logger.LogError("ANSCPUOCR::RunInference", "Invalid License", __FILE__, __LINE__);
|
|
return {};
|
|
}
|
|
|
|
if (!_isInitialized) {
|
|
this->_logger.LogError("ANSCPUOCR::RunInference", "Model is not initialized", __FILE__, __LINE__);
|
|
return {};
|
|
}
|
|
|
|
if (input.empty() || input.cols < 10 || input.rows < 10) {
|
|
this->_logger.LogError("ANSCPUOCR::RunInference", "Input image is invalid or too small", __FILE__, __LINE__);
|
|
return {};
|
|
}
|
|
|
|
if (!ppocr) {
|
|
this->_logger.LogFatal("ANSCPUOCR::RunInference", "PPOCR instance is null", __FILE__, __LINE__);
|
|
return {};
|
|
}
|
|
|
|
try {
|
|
// Convert grayscale to BGR if necessary using reusable buffer
|
|
const cv::Mat* imPtr;
|
|
if (input.channels() == 1) {
|
|
cv::cvtColor(input, this->_frameBuffer, cv::COLOR_GRAY2BGR);
|
|
imPtr = &this->_frameBuffer;
|
|
}
|
|
else {
|
|
imPtr = &input;
|
|
}
|
|
const cv::Mat& im = *imPtr;
|
|
|
|
// Run OCR
|
|
std::vector<PaddleOCR::OCRPredictResult> res_ocr = ppocr->ocr(im);
|
|
|
|
// Build results
|
|
std::vector<ANSCENTER::OCRObject> OCRObjects;
|
|
OCRObjects.reserve(res_ocr.size());
|
|
|
|
const int imgWidth = im.cols;
|
|
const int imgHeight = im.rows;
|
|
|
|
for (const auto& ocr_result : res_ocr) {
|
|
if (ocr_result.box.size() != 4) {
|
|
this->_logger.LogError("ANSCPUOCR::RunInference", "Invalid OCR box size", __FILE__, __LINE__);
|
|
continue;
|
|
}
|
|
|
|
// Extract corner points
|
|
const int x0 = static_cast<int>(ocr_result.box[0][0]);
|
|
const int y0 = static_cast<int>(ocr_result.box[0][1]);
|
|
const int x1 = static_cast<int>(ocr_result.box[1][0]);
|
|
const int y2 = static_cast<int>(ocr_result.box[2][1]);
|
|
|
|
// Calculate bounding box
|
|
const int x = std::max(0, x0);
|
|
const int y = std::max(0, y0);
|
|
int width = x1 - x0;
|
|
int height = y2 - static_cast<int>(ocr_result.box[1][1]);
|
|
|
|
// Clamp to image bounds
|
|
width = std::max(1, std::min(imgWidth - x, width));
|
|
height = std::max(1, std::min(imgHeight - y, height));
|
|
|
|
// Skip invalid boxes
|
|
if (width <= 1 || height <= 1) {
|
|
this->_logger.LogError("ANSCPUOCR::RunInference", "Invalid bounding box dimension", __FILE__, __LINE__);
|
|
continue;
|
|
}
|
|
|
|
ANSCENTER::OCRObject ocrObject;
|
|
ocrObject.box = cv::Rect(x, y, width, height);
|
|
ocrObject.classId = ocr_result.cls_label;
|
|
ocrObject.confidence = ocr_result.score;
|
|
ocrObject.className = ocr_result.text;
|
|
ocrObject.extraInfo = "cls label: " + std::to_string(ocr_result.cls_label)
|
|
+ "; cls score: " + std::to_string(ocr_result.cls_score);
|
|
ocrObject.cameraId = cameraId;
|
|
|
|
OCRObjects.push_back(std::move(ocrObject));
|
|
}
|
|
|
|
return OCRObjects;
|
|
|
|
}
|
|
catch (const std::exception& e) {
|
|
this->_logger.LogFatal("ANSCPUOCR::RunInference", e.what(), __FILE__, __LINE__);
|
|
}
|
|
catch (...) {
|
|
this->_logger.LogFatal("ANSCPUOCR::RunInference", "Unknown exception occurred", __FILE__, __LINE__);
|
|
}
|
|
|
|
return {};
|
|
}
|
|
|
|
std::vector<ANSCENTER::OCRObject> ANSCPUOCR::RunInference(const cv::Mat& input, const std::vector<cv::Rect>& Bbox) {
|
|
std::lock_guard<std::mutex> lock(_mutex);
|
|
|
|
// Early validation
|
|
if (!_licenseValid) {
|
|
this->_logger.LogError("ANSCPUOCR::RunInference", "Invalid License", __FILE__, __LINE__);
|
|
return {};
|
|
}
|
|
|
|
if (!_isInitialized) {
|
|
this->_logger.LogError("ANSCPUOCR::RunInference", "Model is not initialized", __FILE__, __LINE__);
|
|
return {};
|
|
}
|
|
|
|
if (input.empty()) {
|
|
this->_logger.LogError("ANSCPUOCR::RunInference", "Input image is empty", __FILE__, __LINE__);
|
|
return {};
|
|
}
|
|
|
|
if (input.cols < 10 || input.rows < 10) {
|
|
return {};
|
|
}
|
|
|
|
try {
|
|
// Convert grayscale to BGR if necessary using reusable buffer
|
|
const cv::Mat* framePtr;
|
|
if (input.channels() == 1) {
|
|
cv::cvtColor(input, this->_frameBuffer, cv::COLOR_GRAY2BGR);
|
|
framePtr = &this->_frameBuffer;
|
|
}
|
|
else {
|
|
framePtr = &input; // No clone needed - we only read from it
|
|
}
|
|
const cv::Mat& frame = *framePtr;
|
|
|
|
const int fWidth = frame.cols;
|
|
const int fHeight = frame.rows;
|
|
|
|
std::vector<ANSCENTER::OCRObject> OCRObjects;
|
|
|
|
if (!Bbox.empty()) {
|
|
// Process each bounding box region
|
|
OCRObjects.reserve(Bbox.size());
|
|
|
|
for (const auto& bbox : Bbox) {
|
|
const int x1 = std::max(0, bbox.x);
|
|
const int y1 = std::max(0, bbox.y);
|
|
const int width = std::min(fWidth - x1, bbox.width);
|
|
const int height = std::min(fHeight - y1, bbox.height);
|
|
|
|
if (width < 5 || height < 5) {
|
|
continue;
|
|
}
|
|
|
|
// Get cropped region (no copy, just ROI)
|
|
cv::Mat croppedObject = frame(cv::Rect(x1, y1, width, height));
|
|
|
|
// Run inference on cropped region
|
|
std::vector<ANSCENTER::OCRObject> OCRTempObjects = RunInference(croppedObject);
|
|
|
|
for (auto& obj : OCRTempObjects) {
|
|
// Adjust coordinates to original image space
|
|
obj.box.x = std::max(0, std::min(fWidth - obj.box.width, obj.box.x + x1));
|
|
obj.box.y = std::max(0, std::min(fHeight - obj.box.height, obj.box.y + y1));
|
|
obj.box.width = std::min(fWidth - obj.box.x, obj.box.width);
|
|
obj.box.height = std::min(fHeight - obj.box.y, obj.box.height);
|
|
|
|
OCRObjects.push_back(std::move(obj));
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
// No bounding boxes - run OCR on full image
|
|
if (!ppocr) {
|
|
this->_logger.LogFatal("ANSCPUOCR::RunInference", "PPOCR instance is null", __FILE__, __LINE__);
|
|
return {};
|
|
}
|
|
|
|
std::vector<PaddleOCR::OCRPredictResult> res_ocr = ppocr->ocr(frame);
|
|
OCRObjects.reserve(res_ocr.size());
|
|
|
|
for (const auto& ocr_result : res_ocr) {
|
|
if (ocr_result.box.size() < 4) {
|
|
continue;
|
|
}
|
|
|
|
// Extract bounding box from corner points
|
|
const int x = static_cast<int>(ocr_result.box[0][0]);
|
|
const int y = static_cast<int>(ocr_result.box[0][1]);
|
|
int width = static_cast<int>(ocr_result.box[1][0]) - x;
|
|
int height = static_cast<int>(ocr_result.box[2][1]) - static_cast<int>(ocr_result.box[1][1]);
|
|
|
|
// Clamp to image bounds
|
|
const int clampedX = std::max(0, x);
|
|
const int clampedY = std::max(0, y);
|
|
width = std::min(fWidth - clampedX, width);
|
|
height = std::min(fHeight - clampedY, height);
|
|
|
|
ANSCENTER::OCRObject ocrObject;
|
|
ocrObject.box = cv::Rect(clampedX, clampedY, width, height);
|
|
ocrObject.classId = ocr_result.cls_label;
|
|
ocrObject.confidence = ocr_result.score;
|
|
ocrObject.className = ocr_result.text;
|
|
ocrObject.extraInfo = "cls label:" + std::to_string(ocr_result.cls_label) +
|
|
";cls score:" + std::to_string(ocr_result.cls_score);
|
|
|
|
OCRObjects.push_back(std::move(ocrObject));
|
|
}
|
|
}
|
|
|
|
return OCRObjects;
|
|
|
|
}
|
|
catch (const std::exception& e) {
|
|
this->_logger.LogFatal("ANSCPUOCR::RunInference", e.what(), __FILE__, __LINE__);
|
|
return {};
|
|
}
|
|
}
|
|
|
|
|
|
std::vector<ANSCENTER::OCRObject> ANSCPUOCR::RunInference(const cv::Mat& input,
|
|
const std::vector<cv::Rect>& Bbox,
|
|
const std::string& cameraId)
|
|
{
|
|
std::lock_guard<std::mutex> lock(_mutex);
|
|
|
|
// Early validation
|
|
if (!_licenseValid) {
|
|
this->_logger.LogError("ANSCPUOCR::RunInference", "Invalid License", __FILE__, __LINE__);
|
|
return {};
|
|
}
|
|
|
|
if (!_isInitialized) {
|
|
this->_logger.LogError("ANSCPUOCR::RunInference", "Model is not initialized", __FILE__, __LINE__);
|
|
return {};
|
|
}
|
|
|
|
if (input.empty()) {
|
|
this->_logger.LogError("ANSCPUOCR::RunInference", "Input image is empty", __FILE__, __LINE__);
|
|
return {};
|
|
}
|
|
|
|
if (input.cols < 10 || input.rows < 10) {
|
|
return {};
|
|
}
|
|
|
|
try {
|
|
// Convert grayscale to BGR if necessary using reusable buffer
|
|
const cv::Mat* framePtr;
|
|
if (input.channels() == 1) {
|
|
cv::cvtColor(input, this->_frameBuffer, cv::COLOR_GRAY2BGR);
|
|
framePtr = &this->_frameBuffer;
|
|
}
|
|
else {
|
|
framePtr = &input; // No clone needed - we only read from it
|
|
}
|
|
const cv::Mat& frame = *framePtr;
|
|
|
|
const int fWidth = frame.cols;
|
|
const int fHeight = frame.rows;
|
|
|
|
std::vector<ANSCENTER::OCRObject> OCRObjects;
|
|
|
|
if (!Bbox.empty()) {
|
|
// Process each bounding box region
|
|
OCRObjects.reserve(Bbox.size());
|
|
|
|
for (const auto& bbox : Bbox) {
|
|
const int x1 = std::max(0, bbox.x);
|
|
const int y1 = std::max(0, bbox.y);
|
|
const int width = std::min(fWidth - x1, bbox.width);
|
|
const int height = std::min(fHeight - y1, bbox.height);
|
|
|
|
if (width < 5 || height < 5) {
|
|
continue;
|
|
}
|
|
|
|
// Get cropped region (ROI, no copy)
|
|
cv::Mat croppedObject = frame(cv::Rect(x1, y1, width, height));
|
|
|
|
// Run inference on cropped region
|
|
std::vector<ANSCENTER::OCRObject> OCRTempObjects = RunInference(croppedObject);
|
|
|
|
for (auto& obj : OCRTempObjects) {
|
|
// Adjust coordinates to original image space
|
|
obj.box.x = std::max(0, std::min(fWidth - obj.box.width, obj.box.x + x1));
|
|
obj.box.y = std::max(0, std::min(fHeight - obj.box.height, obj.box.y + y1));
|
|
obj.box.width = std::min(fWidth - obj.box.x, obj.box.width);
|
|
obj.box.height = std::min(fHeight - obj.box.y, obj.box.height);
|
|
obj.cameraId = cameraId;
|
|
|
|
OCRObjects.push_back(std::move(obj));
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
// No bounding boxes - run OCR on full image
|
|
if (!ppocr) {
|
|
this->_logger.LogFatal("ANSCPUOCR::RunInference", "PPOCR instance is null", __FILE__, __LINE__);
|
|
return {};
|
|
}
|
|
|
|
std::vector<PaddleOCR::OCRPredictResult> res_ocr = ppocr->ocr(frame);
|
|
OCRObjects.reserve(res_ocr.size());
|
|
|
|
for (const auto& ocr_result : res_ocr) {
|
|
if (ocr_result.box.size() < 4) {
|
|
continue;
|
|
}
|
|
|
|
// Extract bounding box from corner points
|
|
const int x = static_cast<int>(ocr_result.box[0][0]);
|
|
const int y = static_cast<int>(ocr_result.box[0][1]);
|
|
int width = static_cast<int>(ocr_result.box[1][0]) - x;
|
|
int height = static_cast<int>(ocr_result.box[2][1]) - static_cast<int>(ocr_result.box[1][1]);
|
|
|
|
// Clamp to image bounds
|
|
const int clampedX = std::max(0, x);
|
|
const int clampedY = std::max(0, y);
|
|
width = std::min(fWidth - clampedX, width);
|
|
height = std::min(fHeight - clampedY, height);
|
|
|
|
ANSCENTER::OCRObject ocrObject;
|
|
ocrObject.box = cv::Rect(clampedX, clampedY, width, height);
|
|
ocrObject.classId = ocr_result.cls_label;
|
|
ocrObject.confidence = ocr_result.score;
|
|
ocrObject.className = ocr_result.text;
|
|
ocrObject.extraInfo = "cls label:" + std::to_string(ocr_result.cls_label) +
|
|
";cls score:" + std::to_string(ocr_result.cls_score);
|
|
ocrObject.cameraId = cameraId;
|
|
|
|
OCRObjects.push_back(std::move(ocrObject));
|
|
}
|
|
}
|
|
|
|
return OCRObjects;
|
|
|
|
}
|
|
catch (const std::exception& e) {
|
|
this->_logger.LogFatal("ANSCPUOCR::RunInference", e.what(), __FILE__, __LINE__);
|
|
return {};
|
|
}
|
|
}
|
|
ANSCPUOCR::~ANSCPUOCR() {
|
|
try {
|
|
Destroy();
|
|
}
|
|
catch (std::exception& e) {
|
|
this->_logger.LogFatal("ANSCPUOCR::~ANSCPUOCR()", e.what(), __FILE__, __LINE__);
|
|
}
|
|
this->ANSOCRBase::~ANSOCRBase();
|
|
}
|
|
bool ANSCPUOCR::Destroy() {
|
|
try {
|
|
if (ppocr) ppocr.reset();
|
|
return true;
|
|
}
|
|
catch (std::exception& e) {
|
|
this->_logger.LogFatal("ANSCPUOCR::Destroy", e.what(), __FILE__, __LINE__);
|
|
return false;
|
|
}
|
|
}
|
|
} |