mirror of
https://github.com/PaddlePaddle/PaddleOCR.git
synced 2025-11-03 19:29:18 +00:00
116 lines
3.7 KiB
C++
116 lines
3.7 KiB
C++
// Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
#include "crnn_process.h" //NOLINT
|
|
#include <algorithm>
|
|
#include <memory>
|
|
#include <string>
|
|
|
|
const std::vector<int> rec_image_shape{3, 32, 320};
|
|
|
|
cv::Mat CrnnResizeImg(cv::Mat img, float wh_ratio) {
|
|
int imgC, imgH, imgW;
|
|
imgC = rec_image_shape[0];
|
|
imgW = rec_image_shape[2];
|
|
imgH = rec_image_shape[1];
|
|
|
|
imgW = int(32 * wh_ratio);
|
|
|
|
float ratio = static_cast<float>(img.cols) / static_cast<float>(img.rows);
|
|
int resize_w, resize_h;
|
|
if (ceilf(imgH * ratio) > imgW)
|
|
resize_w = imgW;
|
|
else
|
|
resize_w = static_cast<int>(ceilf(imgH * ratio));
|
|
cv::Mat resize_img;
|
|
cv::resize(img, resize_img, cv::Size(resize_w, imgH), 0.f, 0.f,
|
|
cv::INTER_LINEAR);
|
|
|
|
return resize_img;
|
|
}
|
|
|
|
std::vector<std::string> ReadDict(std::string path) {
|
|
std::ifstream in(path);
|
|
std::string filename;
|
|
std::string line;
|
|
std::vector<std::string> m_vec;
|
|
if (in) {
|
|
while (getline(in, line)) {
|
|
m_vec.push_back(line);
|
|
}
|
|
} else {
|
|
std::cout << "no such file" << std::endl;
|
|
}
|
|
return m_vec;
|
|
}
|
|
|
|
cv::Mat GetRotateCropImage(cv::Mat srcimage,
|
|
std::vector<std::vector<int>> box) {
|
|
cv::Mat image;
|
|
srcimage.copyTo(image);
|
|
std::vector<std::vector<int>> points = box;
|
|
|
|
int x_collect[4] = {box[0][0], box[1][0], box[2][0], box[3][0]};
|
|
int y_collect[4] = {box[0][1], box[1][1], box[2][1], box[3][1]};
|
|
int left = int(*std::min_element(x_collect, x_collect + 4));
|
|
int right = int(*std::max_element(x_collect, x_collect + 4));
|
|
int top = int(*std::min_element(y_collect, y_collect + 4));
|
|
int bottom = int(*std::max_element(y_collect, y_collect + 4));
|
|
|
|
cv::Mat img_crop;
|
|
image(cv::Rect(left, top, right - left, bottom - top)).copyTo(img_crop);
|
|
|
|
for (int i = 0; i < points.size(); i++) {
|
|
points[i][0] -= left;
|
|
points[i][1] -= top;
|
|
}
|
|
|
|
int img_crop_width =
|
|
static_cast<int>(sqrt(pow(points[0][0] - points[1][0], 2) +
|
|
pow(points[0][1] - points[1][1], 2)));
|
|
int img_crop_height =
|
|
static_cast<int>(sqrt(pow(points[0][0] - points[3][0], 2) +
|
|
pow(points[0][1] - points[3][1], 2)));
|
|
|
|
cv::Point2f pts_std[4];
|
|
pts_std[0] = cv::Point2f(0., 0.);
|
|
pts_std[1] = cv::Point2f(img_crop_width, 0.);
|
|
pts_std[2] = cv::Point2f(img_crop_width, img_crop_height);
|
|
pts_std[3] = cv::Point2f(0.f, img_crop_height);
|
|
|
|
cv::Point2f pointsf[4];
|
|
pointsf[0] = cv::Point2f(points[0][0], points[0][1]);
|
|
pointsf[1] = cv::Point2f(points[1][0], points[1][1]);
|
|
pointsf[2] = cv::Point2f(points[2][0], points[2][1]);
|
|
pointsf[3] = cv::Point2f(points[3][0], points[3][1]);
|
|
|
|
cv::Mat M = cv::getPerspectiveTransform(pointsf, pts_std);
|
|
|
|
cv::Mat dst_img;
|
|
cv::warpPerspective(img_crop, dst_img, M,
|
|
cv::Size(img_crop_width, img_crop_height),
|
|
cv::BORDER_REPLICATE);
|
|
|
|
const float ratio = 1.5;
|
|
if (static_cast<float>(dst_img.rows) >=
|
|
static_cast<float>(dst_img.cols) * ratio) {
|
|
cv::Mat srcCopy = cv::Mat(dst_img.rows, dst_img.cols, dst_img.depth());
|
|
cv::transpose(dst_img, srcCopy);
|
|
cv::flip(srcCopy, srcCopy, 0);
|
|
return srcCopy;
|
|
} else {
|
|
return dst_img;
|
|
}
|
|
}
|