Files
ANSCORE/modules/ANSOCR/ANSPaddleOCR/src/ocr_cls.cpp
T

115 lines
4.3 KiB
C++

#include "include/ocr_cls.h"
namespace PaddleOCR {
std::string Classifier::GetOpenVINODevice() {
ov::Core core;
std::vector<std::string> available_devices = core.get_available_devices();
// Prioritize devices: NPU > GPU > CPU
std::vector<std::string> priority_devices = { "GPU", "CPU" };
for (const auto& device : priority_devices) {
if (std::find(available_devices.begin(), available_devices.end(), device) != available_devices.end()) {
return device; // Return the first available device based on priority
}
}
return "CPU";
}
Classifier::Classifier(std::string model_path)
{
this->model_path = model_path;
ov::Core core;
this->model = core.read_model(this->model_path);
// dimension of batch size is dynamic
this->model->reshape({ {ov::Dimension(1, 6), cls_image_shape[0], cls_image_shape[1], cls_image_shape[2]} });
// preprocessing API
ov::preprocess::PrePostProcessor prep(this->model);
// declare section of desired application's input format
prep.input().tensor()
.set_layout("NHWC")
.set_color_format(ov::preprocess::ColorFormat::BGR);
// specify actual model layout
prep.input().model()
.set_layout("NCHW");
prep.input().preprocess()
.mean(this->mean_)
.scale(this->scale_);
std::string deviceName = GetOpenVINODevice();
this->model = prep.build();
//core.set_property(deviceName, ov::hint::performance_mode(ov::hint::PerformanceMode::THROUGHPUT));
this->compiled_model = core.compile_model(this->model, deviceName);
this->infer_request = compiled_model.create_infer_request();
}
void Classifier::SetParameters(int cls_batch_num, double cls_thresh) {
std::lock_guard<std::recursive_mutex> lock(_mutex);
this->cls_batch_num_ = cls_batch_num;
this->cls_thresh = cls_thresh;
}
void Classifier::GetParameters(int& cls_batch_num, double& cls_thresh) {
std::lock_guard<std::recursive_mutex> lock(_mutex);
cls_batch_num = this->cls_batch_num_;
cls_thresh = this->cls_thresh;
}
void Classifier::Run(std::vector<cv::Mat> img_list, std::vector<OCRPredictResult>& ocr_results)
{
try {
std::lock_guard<std::recursive_mutex> lock(_mutex);
std::vector<int> cls_labels(img_list.size(), 0);
std::vector<float> cls_scores(img_list.size(), 0);
std::vector<double> cls_times;
auto input_port = this->compiled_model.input();
int img_num = img_list.size();
for (int beg_img_no = 0; beg_img_no < img_num; beg_img_no += this->cls_batch_num_) {
int end_img_no = std::min(img_num, beg_img_no + this->cls_batch_num_);
size_t batch_num = end_img_no - beg_img_no;
std::vector<ov::Tensor> batch_tensors;
ov::Shape intput_shape = { batch_num, cls_image_shape[1], cls_image_shape[2],3 };
for (int ino = beg_img_no; ino < end_img_no; ino++) {
cv::Mat srcimg;
img_list[ino].copyTo(srcimg);
cv::Mat resize_img;
// preprocess
this->resize_op_.Run(srcimg, resize_img, this->cls_image_shape);
resize_img.convertTo(resize_img, CV_32FC3, e);
if (resize_img.cols < cls_image_shape[2]) {
cv::copyMakeBorder(resize_img, resize_img, 0, 0, 0,
cls_image_shape[2] - resize_img.cols,
cv::BORDER_CONSTANT, cv::Scalar(0, 0, 0));
}
// prepare input tensor
ov::Tensor input_tensor(input_port.get_element_type(), intput_shape, (float*)resize_img.data);
batch_tensors.push_back(input_tensor);
}
// set batched input tensors
this->infer_request.set_input_tensors(batch_tensors);
// start inference
//this->infer_request.start_async();
//this->infer_request.wait();
this->infer_request.infer();
// get output tensor
auto output = this->infer_request.get_output_tensor();
const float* out_data = output.data<const float>();
for (size_t batch_idx = 0; batch_idx < output.get_size() / 2; batch_idx++) {
int label = int(
Utility::argmax(&out_data[batch_idx * 2],
&out_data[(batch_idx + 1) * 2]));
float score = float(*std::max_element(
&out_data[batch_idx * 2],
&out_data[(batch_idx + 1) * 2]));
cls_labels[beg_img_no + batch_idx] = label;
cls_scores[beg_img_no + batch_idx] = score;
}
}
for (int i = 0; i < cls_labels.size(); i++) {
ocr_results[i].cls_label = cls_labels[i];
ocr_results[i].cls_score = cls_scores[i];
}
}
catch (const std::exception& e) {
std::cerr << e.what() << std::endl;
}
}
}