apps/FastDeploy
1
0
Fork 0
mirror of https://github.com/PaddlePaddle/FastDeploy.git synced 2025-10-06 17:17:14 +08:00
Code Issues Actions 2 Packages Projects Releases Wiki Activity

[CVCUDA] PP-OCR Cls & Rec preprocessor support CV-CUDA (#1470)

Browse Source 
* ppocr cls preprocessor use manager

* hwc2chw cvcuda

* ppocr rec preproc use manager

* ocr rec preproc cvcuda

* fix rec preproc bug

* ppocr cls&rec preproc set normalize

* fix pybind

* address comment
This commit is contained in:
Wang Xinyu
2023-03-02 10:50:44 +08:00
committed by GitHub
parent fe2882a1ef
commit 044ab993d2
19 changed files with 424 additions and 306 deletions
Download Patch File Download Diff File Expand all files Collapse all files

46
fastdeploy/vision/ocr/ppocr/cls_preprocessor.h
View File

@@ -14,6 +14,7 @@
#pragma once
#include "fastdeploy/vision/common/processors/transform.h"
#include "fastdeploy/vision/common/processors/manager.h"
#include "fastdeploy/vision/common/result.h"
namespace fastdeploy {
@@ -22,32 +23,37 @@ namespace vision {
namespace ocr {
/*! @brief Preprocessor object for Classifier serials model.
*/
class FASTDEPLOY_DECL ClassifierPreprocessor {
class FASTDEPLOY_DECL ClassifierPreprocessor : public ProcessorManager {
public:
ClassifierPreprocessor();
using ProcessorManager::Run;
/** \brief Process the input image and prepare input tensors for runtime
*
* \param[in] images The input data list, all the elements are FDMat
* \param[in] outputs The output tensors which will be fed into runtime
* \return true if the preprocess successed, otherwise false
*/
bool Run(std::vector<FDMat>* images, std::vector<FDTensor>* outputs);
bool Run(std::vector<FDMat>* images, std::vector<FDTensor>* outputs,
size_t start_index, size_t end_index);
/// Set mean value for the image normalization in classification preprocess
void SetMean(const std::vector<float>& mean) { mean_ = mean; }
/// Get mean value of the image normalization in classification preprocess
std::vector<float> GetMean() const { return mean_; }
/** \brief Implement the virtual function of ProcessorManager, Apply() is the
* body of Run(). Apply() contains the main logic of preprocessing, Run() is
* called by users to execute preprocessing
*
* \param[in] image_batch The input image batch
* \param[in] outputs The output tensors which will feed in runtime
* \return true if the preprocess successed, otherwise false
*/
virtual bool Apply(FDMatBatch* image_batch, std::vector<FDTensor>* outputs);
/// Set scale value for the image normalization in classification preprocess
void SetScale(const std::vector<float>& scale) { scale_ = scale; }
/// Get scale value of the image normalization in classification preprocess
std::vector<float> GetScale() const { return scale_; }
/// Set is_scale for the image normalization in classification preprocess
void SetIsScale(bool is_scale) { is_scale_ = is_scale; }
/// Get is_scale of the image normalization in classification preprocess
bool GetIsScale() const { return is_scale_; }
/// Set preprocess normalize parameters, please call this API to customize
/// the normalize parameters, otherwise it will use the default normalize
/// parameters.
void SetNormalize(const std::vector<float>& mean,
const std::vector<float>& std,
bool is_scale) {
normalize_op_ = std::make_shared<Normalize>(mean, std, is_scale);
}
/// Set cls_image_shape for the classification preprocess
void SetClsImageShape(const std::vector<int>& cls_image_shape) {
@@ -62,14 +68,18 @@ class FASTDEPLOY_DECL ClassifierPreprocessor {
void DisablePermute() { disable_normalize_ = true; }
private:
void OcrClassifierResizeImage(FDMat* mat,
const std::vector<int>& cls_image_shape);
// for recording the switch of hwc2chw
bool disable_permute_ = false;
// for recording the switch of normalize
bool disable_normalize_ = false;
std::vector<float> mean_ = {0.5f, 0.5f, 0.5f};
std::vector<float> scale_ = {0.5f, 0.5f, 0.5f};
bool is_scale_ = true;
std::vector<int> cls_image_shape_ = {3, 48, 192};
std::shared_ptr<Resize> resize_op_;
std::shared_ptr<Pad> pad_op_;
std::shared_ptr<Normalize> normalize_op_;
std::shared_ptr<HWC2CHW> hwc2chw_op_;
};
} // namespace ocr