apps/FastDeploy
1
0
Fork 0
mirror of https://github.com/PaddlePaddle/FastDeploy.git synced 2025-10-27 10:30:34 +08:00
Code Issues Actions 5 Packages Projects Releases Wiki Activity

[C API] add ppseg c api (#1384)

Browse Source 
* add ppseg c api

* fix bug

* fix interface
This commit is contained in:
chenjian
2023-02-27 11:07:56 +08:00
committed by GitHub
parent 017f305632
commit b6e8773b2f
21 changed files with 779 additions and 344 deletions
Download Patch File Download Diff File Expand all files Collapse all files

22
c_api/fastdeploy_capi/config.h
View File

@@ -1,22 +0,0 @@
// Copyright (c) 2023 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.
#pragma once
#ifndef ENABLE_VISION
#define ENABLE_VISION
#endif
#ifndef ENABLE_TEXT
/* #undef ENABLE_TEXT */
#endif

9
c_api/fastdeploy_capi/types_internal.cc
View File

@@ -31,6 +31,9 @@ DECL_AND_IMPLEMENT_RESULT_FUNC_FOR_GET_PTR_FROM_WRAPPER(
DECL_AND_IMPLEMENT_RESULT_FUNC_FOR_GET_PTR_FROM_WRAPPER(OCRResult,
fd_ocr_result_wrapper,
ocr_result)
// SegmentationResult
DECL_AND_IMPLEMENT_RESULT_FUNC_FOR_GET_PTR_FROM_WRAPPER(
SegmentationResult, fd_segmentation_result_wrapper, segmentation_result)
// Models:
@@ -147,6 +150,12 @@ DECL_AND_IMPLEMENT_PIPELINE_MODEL_FUNC_FOR_GET_PTR_FROM_WRAPPER(
DECL_AND_IMPLEMENT_PIPELINE_MODEL_FUNC_FOR_GET_PTR_FROM_WRAPPER(
PPOCRv3, fd_ppocrv3_wrapper, ppocrv3_model);
// Segmentation models
// PaddleSegModel
DECL_AND_IMPLEMENT_SEGMENTATION_MODEL_FUNC_FOR_GET_PTR_FROM_WRAPPER(
PaddleSegModel, fd_paddleseg_model_wrapper, segmentation_model);
#endif
std::unique_ptr<fastdeploy::RuntimeOption>&

33
c_api/fastdeploy_capi/types_internal.h
View File

@@ -27,6 +27,7 @@
#include "fastdeploy/vision/ocr/ppocr/recognizer.h"
#include "fastdeploy/vision/ocr/ppocr/ppocr_v2.h"
#include "fastdeploy/vision/ocr/ppocr/ppocr_v3.h"
#include "fastdeploy/vision/segmentation/ppseg/model.h"
#define DEFINE_RESULT_WRAPPER_STRUCT(typename, varname) typedef struct FD_C_##typename##Wrapper { \
std::unique_ptr<fastdeploy::vision::typename> varname; \
@@ -49,6 +50,10 @@
std::unique_ptr<fastdeploy::pipeline::typename> varname; \
} FD_C_##typename##Wrapper
#define DEFINE_SEGMENTATION_MODEL_WRAPPER_STRUCT(typename, varname) typedef struct FD_C_##typename##Wrapper { \
std::unique_ptr<fastdeploy::vision::segmentation::typename> varname; \
} FD_C_##typename##Wrapper
// ------------- belows are wrapper struct define --------------------- //
// Results:
@@ -63,6 +68,8 @@ DEFINE_RESULT_WRAPPER_STRUCT(DetectionResult, detection_result);
// OCRResult
DEFINE_RESULT_WRAPPER_STRUCT(OCRResult, ocr_result);
// Segmentation Result
DEFINE_RESULT_WRAPPER_STRUCT(SegmentationResult, segmentation_result);
// Models:
@@ -153,6 +160,10 @@ DEFINE_PIPELINE_MODEL_WRAPPER_STRUCT(PPOCRv2, ppocrv2_model);
// PPOCRv3
DEFINE_PIPELINE_MODEL_WRAPPER_STRUCT(PPOCRv3, ppocrv3_model);
// Segmentation models
// PaddleSegModel
DEFINE_SEGMENTATION_MODEL_WRAPPER_STRUCT(PaddleSegModel, segmentation_model);
// ------------- belows are function declaration for get ptr from wrapper --------------------- //
@@ -177,6 +188,10 @@ FD_C_CheckAndConvert##typename##Wrapper( \
FD_C_CheckAndConvert##typename##Wrapper( \
FD_C_##typename##Wrapper* varname)
#define DECLARE_SEGMENTATION_MODEL_FUNC_FOR_GET_PTR_FROM_WRAPPER(typename, varname) std::unique_ptr<fastdeploy::vision::segmentation::typename>& \
FD_C_CheckAndConvert##typename##Wrapper( \
FD_C_##typename##Wrapper* varname)
namespace fastdeploy {
@@ -194,6 +209,10 @@ DECLARE_RESULT_FUNC_FOR_GET_PTR_FROM_WRAPPER(DetectionResult,
DECLARE_RESULT_FUNC_FOR_GET_PTR_FROM_WRAPPER(OCRResult,
fd_ocr_result_wrapper);
// SegementationResult
DECLARE_RESULT_FUNC_FOR_GET_PTR_FROM_WRAPPER(SegmentationResult,
fd_segmentation_result_wrapper);
// Models:
@@ -324,6 +343,12 @@ DECLARE_PIPELINE_MODEL_FUNC_FOR_GET_PTR_FROM_WRAPPER(PPOCRv2, fd_ppocrv2_wrapper
// PPOCRv3
DECLARE_PIPELINE_MODEL_FUNC_FOR_GET_PTR_FROM_WRAPPER(PPOCRv3, fd_ppocrv3_wrapper);
// Segmentation models
// PaddleSegModel
DECLARE_SEGMENTATION_MODEL_FUNC_FOR_GET_PTR_FROM_WRAPPER(
PaddleSegModel, fd_paddleseg_model_wrapper);
} // namespace fastdeploy
#endif
@@ -383,3 +408,11 @@ FD_C_CheckAndConvert##typename##Wrapper( \
"The pointer of " #var_wrapper_name " shouldn't be nullptr."); \
return var_wrapper_name->var_ptr_name; \
}
#define DECL_AND_IMPLEMENT_SEGMENTATION_MODEL_FUNC_FOR_GET_PTR_FROM_WRAPPER(typename, var_wrapper_name, var_ptr_name) std::unique_ptr<fastdeploy::vision::segmentation::typename>& \
FD_C_CheckAndConvert##typename##Wrapper( \
FD_C_##typename##Wrapper* var_wrapper_name) { \
FDASSERT(var_wrapper_name != nullptr, \
"The pointer of " #var_wrapper_name " shouldn't be nullptr."); \
return var_wrapper_name->var_ptr_name; \
}

1
c_api/fastdeploy_capi/vision.h
View File

@@ -19,6 +19,7 @@
#include "fastdeploy_capi/vision/classification/ppcls/model.h"
#include "fastdeploy_capi/vision/detection/ppdet/model.h"
#include "fastdeploy_capi/vision/ocr/ppocr/model.h"
#include "fastdeploy_capi/vision/segmentation/ppseg/model.h"
#include "fastdeploy_capi/vision/result.h"
#include "fastdeploy_capi/vision/visualize.h"
#endif

42
c_api/fastdeploy_capi/vision/classification/ppcls/model.cc
View File

@@ -55,10 +55,10 @@ FD_C_Bool FD_C_PaddleClasModelWrapperPredict(
bool successful = paddleclas_model->Predict(im, classify_result.get());
if (successful) {
FD_C_ClassifyResult* res =
FD_C_ClassifyResultWrapperGetData(fd_c_classify_result_wrapper);
*fd_c_classify_result = *res;
FD_C_ClassifyResultWrapperToCResult(fd_c_classify_result_wrapper,
fd_c_classify_result);
}
FD_C_DestroyClassifyResultWrapper(fd_c_classify_result_wrapper);
return successful;
}
@@ -69,36 +69,17 @@ FD_C_Bool FD_C_PaddleClasModelWrapperInitialized(
return paddleclas_model->Initialized();
}
FD_C_ClassifyResult* FD_C_ClassifyResultToC(
fastdeploy::vision::ClassifyResult* classify_result) {
// Internal use, transfer fastdeploy::vision::ClassifyResult to
// FD_C_ClassifyResult
FD_C_ClassifyResult* fd_c_classify_result_data = new FD_C_ClassifyResult();
// copy label_ids
fd_c_classify_result_data->label_ids.size = classify_result->label_ids.size();
fd_c_classify_result_data->label_ids.data =
new int32_t[fd_c_classify_result_data->label_ids.size];
memcpy(fd_c_classify_result_data->label_ids.data,
classify_result->label_ids.data(),
sizeof(int32_t) * fd_c_classify_result_data->label_ids.size);
// copy scores
fd_c_classify_result_data->scores.size = classify_result->scores.size();
fd_c_classify_result_data->scores.data =
new float[fd_c_classify_result_data->scores.size];
memcpy(fd_c_classify_result_data->scores.data, classify_result->scores.data(),
sizeof(float) * fd_c_classify_result_data->scores.size);
fd_c_classify_result_data->type =
static_cast<FD_C_ResultType>(classify_result->type);
return fd_c_classify_result_data;
}
FD_C_Bool FD_C_PaddleClasModelWrapperBatchPredict(
FD_C_PaddleClasModelWrapper* fd_c_paddleclas_model_wrapper,
FD_C_OneDimMat imgs, FD_C_OneDimClassifyResult* results) {
std::vector<cv::Mat> imgs_vec;
std::vector<FD_C_ClassifyResultWrapper*> results_wrapper_out;
std::vector<fastdeploy::vision::ClassifyResult> results_out;
for (int i = 0; i < imgs.size; i++) {
imgs_vec.push_back(*(reinterpret_cast<cv::Mat*>(imgs.data[i])));
FD_C_ClassifyResultWrapper* fd_classify_result_wrapper =
FD_C_CreateClassifyResultWrapper();
results_wrapper_out.push_back(fd_classify_result_wrapper);
}
auto& paddleclas_model = CHECK_AND_CONVERT_FD_TYPE(
PaddleClasModelWrapper, fd_c_paddleclas_model_wrapper);
@@ -108,9 +89,16 @@ FD_C_Bool FD_C_PaddleClasModelWrapperBatchPredict(
results->size = results_out.size();
results->data = new FD_C_ClassifyResult[results->size];
for (int i = 0; i < results_out.size(); i++) {
results->data[i] = *FD_C_ClassifyResultToC(&results_out[i]);
(*CHECK_AND_CONVERT_FD_TYPE(ClassifyResultWrapper,
results_wrapper_out[i])) =
std::move(results_out[i]);
FD_C_ClassifyResultWrapperToCResult(results_wrapper_out[i],
&results->data[i]);
}
}
for (int i = 0; i < results_out.size(); i++) {
FD_C_DestroyClassifyResultWrapper(results_wrapper_out[i]);
}
return successful;
}

19
c_api/fastdeploy_capi/vision/detection/ppdet/base_define.h
View File

@@ -61,11 +61,10 @@ FD_C_Destroy##model_type##Wrapper(__fd_take FD_C_##model_type##Wrapper* wrapper_
DetectionResultWrapper, fd_c_detection_result_wrapper); \
bool successful = model->Predict(im, detection_result.get()); \
if (successful) { \
FD_C_DetectionResult* res = \
FD_C_DetectionResultWrapperGetData(fd_c_detection_result_wrapper); \
*fd_c_detection_result = *res; \
} \
return successful
FD_C_DetectionResultWrapperToCResult(fd_c_detection_result_wrapper, fd_c_detection_result); \
} \
FD_C_DestroyDetectionResultWrapper(fd_c_detection_result_wrapper); \
return successful
#define IMPLEMENT_INITIALIZED_FUNCTION(model_type, wrapper_var_name) auto& model = \
CHECK_AND_CONVERT_FD_TYPE(model_type##Wrapper, wrapper_var_name); \
@@ -73,8 +72,11 @@ return model->Initialized();
#define IMPLEMENT_BATCH_PREDICT_FUNCTION(model_type, wrapper_var_name) std::vector<cv::Mat> imgs_vec; \
std::vector<fastdeploy::vision::DetectionResult> results_out; \
std::vector<FD_C_DetectionResultWrapper*> results_wrapper_out; \
for (int i = 0; i < imgs.size; i++) { \
imgs_vec.push_back(*(reinterpret_cast<cv::Mat*>(imgs.data[i]))); \
FD_C_DetectionResultWrapper* fd_detection_result_wrapper = FD_C_CreateDetectionResultWrapper(); \
results_wrapper_out.push_back(fd_detection_result_wrapper); \
} \
auto& model = \
CHECK_AND_CONVERT_FD_TYPE(model_type##Wrapper, wrapper_var_name); \
@@ -83,9 +85,14 @@ return model->Initialized();
results->size = results_out.size(); \
results->data = new FD_C_DetectionResult[results->size]; \
for (int i = 0; i < results_out.size(); i++) { \
results->data[i] = *FD_C_DetectionResultToC(&results_out[i]); \
(*CHECK_AND_CONVERT_FD_TYPE(DetectionResultWrapper, \
results_wrapper_out[i])) = std::move(results_out[i]); \
FD_C_DetectionResultWrapperToCResult(results_wrapper_out[i], &results->data[i]); \
} \
} \
for (int i = 0; i < results_out.size(); i++) { \
FD_C_DestroyDetectionResultWrapper(results_wrapper_out[i]); \
}\
return successful;
#define DECLARE_AND_IMPLEMENT_CREATE_WRAPPER_FUNCTION(model_type, var_name) FD_C_##model_type##Wrapper* FD_C_Create##model_type##Wrapper(\

61
c_api/fastdeploy_capi/vision/detection/ppdet/model.cc
View File

@@ -46,67 +46,6 @@ FD_C_Bool FD_C_PPYOLOEWrapperInitialized(
IMPLEMENT_INITIALIZED_FUNCTION(PPYOLOE, fd_ppyoloe_wrapper);
}
FD_C_DetectionResult* FD_C_DetectionResultToC(
fastdeploy::vision::DetectionResult* detection_result) {
// Internal use, transfer fastdeploy::vision::DetectionResult to
// FD_C_DetectionResult
FD_C_DetectionResult* fd_c_detection_result = new FD_C_DetectionResult();
// copy boxes
const int boxes_coordinate_dim = 4;
fd_c_detection_result->boxes.size = detection_result->boxes.size();
fd_c_detection_result->boxes.data =
new FD_C_OneDimArrayFloat[fd_c_detection_result->boxes.size];
for (size_t i = 0; i < detection_result->boxes.size(); i++) {
fd_c_detection_result->boxes.data[i].size = boxes_coordinate_dim;
fd_c_detection_result->boxes.data[i].data = new float[boxes_coordinate_dim];
for (size_t j = 0; j < boxes_coordinate_dim; j++) {
fd_c_detection_result->boxes.data[i].data[j] =
detection_result->boxes[i][j];
}
}
// copy scores
fd_c_detection_result->scores.size = detection_result->scores.size();
fd_c_detection_result->scores.data =
new float[fd_c_detection_result->scores.size];
memcpy(fd_c_detection_result->scores.data, detection_result->scores.data(),
sizeof(float) * fd_c_detection_result->scores.size);
// copy label_ids
fd_c_detection_result->label_ids.size = detection_result->label_ids.size();
fd_c_detection_result->label_ids.data =
new int32_t[fd_c_detection_result->label_ids.size];
memcpy(fd_c_detection_result->label_ids.data,
detection_result->label_ids.data(),
sizeof(int32_t) * fd_c_detection_result->label_ids.size);
// copy masks
fd_c_detection_result->masks.size = detection_result->masks.size();
fd_c_detection_result->masks.data =
new FD_C_Mask[fd_c_detection_result->masks.size];
for (size_t i = 0; i < detection_result->masks.size(); i++) {
// copy data in mask
fd_c_detection_result->masks.data[i].data.size =
detection_result->masks[i].data.size();
fd_c_detection_result->masks.data[i].data.data =
new uint8_t[detection_result->masks[i].data.size()];
memcpy(fd_c_detection_result->masks.data[i].data.data,
detection_result->masks[i].data.data(),
sizeof(uint8_t) * detection_result->masks[i].data.size());
// copy shape in mask
fd_c_detection_result->masks.data[i].shape.size =
detection_result->masks[i].shape.size();
fd_c_detection_result->masks.data[i].shape.data =
new int64_t[detection_result->masks[i].shape.size()];
memcpy(fd_c_detection_result->masks.data[i].shape.data,
detection_result->masks[i].shape.data(),
sizeof(int64_t) * detection_result->masks[i].shape.size());
fd_c_detection_result->masks.data[i].type =
static_cast<FD_C_ResultType>(detection_result->masks[i].type);
}
fd_c_detection_result->contain_masks = detection_result->contain_masks;
fd_c_detection_result->type =
static_cast<FD_C_ResultType>(detection_result->type);
return fd_c_detection_result;
}
FD_C_Bool FD_C_PPYOLOEWrapperBatchPredict(
FD_C_PPYOLOEWrapper* fd_ppyoloe_wrapper, FD_C_OneDimMat imgs,
FD_C_OneDimDetectionResult* results) {

80
c_api/fastdeploy_capi/vision/ocr/ppocr/model.cc
View File

@@ -353,72 +353,26 @@ FD_C_Bool FD_C_PPOCRv2WrapperPredict(FD_C_PPOCRv2Wrapper* fd_c_ppocrv2_wrapper,
bool successful = model->Predict(im, ocr_result.get());
if (successful) {
FD_C_OCRResult* res = FD_C_OCRResultWrapperGetData(fd_c_ocr_result_wrapper);
*fd_c_ocr_result = *res;
FD_C_OCRResultWrapperToCResult(fd_c_ocr_result_wrapper, fd_c_ocr_result);
}
FD_C_DestroyOCRResultWrapper(fd_c_ocr_result_wrapper);
return successful;
}
PIPELINE_DECLARE_AND_IMPLEMENT_INITIALIZED_FUNCTION(PPOCRv2,
fd_c_ppocrv2_wrapper)
FD_C_OCRResult* FD_C_OCRResultToC(fastdeploy::vision::OCRResult* ocr_result) {
// Internal use, transfer fastdeploy::vision::OCRResult to
// FD_C_OCRResult
FD_C_OCRResult* fd_c_ocr_result = new FD_C_OCRResult();
// copy boxes
const int boxes_coordinate_dim = 8;
fd_c_ocr_result->boxes.size = ocr_result->boxes.size();
fd_c_ocr_result->boxes.data =
new FD_C_OneDimArrayInt32[fd_c_ocr_result->boxes.size];
for (size_t i = 0; i < ocr_result->boxes.size(); i++) {
fd_c_ocr_result->boxes.data[i].size = boxes_coordinate_dim;
fd_c_ocr_result->boxes.data[i].data = new int[boxes_coordinate_dim];
for (size_t j = 0; j < boxes_coordinate_dim; j++) {
fd_c_ocr_result->boxes.data[i].data[j] = ocr_result->boxes[i][j];
}
}
// copy text
fd_c_ocr_result->text.size = ocr_result->text.size();
fd_c_ocr_result->text.data = new FD_C_Cstr[fd_c_ocr_result->text.size];
for (size_t i = 0; i < ocr_result->text.size(); i++) {
fd_c_ocr_result->text.data[i].size = ocr_result->text[i].length();
fd_c_ocr_result->text.data[i].data =
new char[ocr_result->text[i].length() + 1];
strncpy(fd_c_ocr_result->text.data[i].data, ocr_result->text[i].c_str(),
ocr_result->text[i].length());
}
// copy rec_scores
fd_c_ocr_result->rec_scores.size = ocr_result->rec_scores.size();
fd_c_ocr_result->rec_scores.data =
new float[fd_c_ocr_result->rec_scores.size];
memcpy(fd_c_ocr_result->rec_scores.data, ocr_result->rec_scores.data(),
sizeof(float) * fd_c_ocr_result->rec_scores.size);
// copy cls_scores
fd_c_ocr_result->cls_scores.size = ocr_result->cls_scores.size();
fd_c_ocr_result->cls_scores.data =
new float[fd_c_ocr_result->cls_scores.size];
memcpy(fd_c_ocr_result->cls_scores.data, ocr_result->cls_scores.data(),
sizeof(float) * fd_c_ocr_result->cls_scores.size);
// copy cls_labels
fd_c_ocr_result->cls_labels.size = ocr_result->cls_labels.size();
fd_c_ocr_result->cls_labels.data =
new int32_t[fd_c_ocr_result->cls_labels.size];
memcpy(fd_c_ocr_result->cls_labels.data, ocr_result->cls_labels.data(),
sizeof(int32_t) * fd_c_ocr_result->cls_labels.size);
// copy type
fd_c_ocr_result->type = static_cast<FD_C_ResultType>(ocr_result->type);
return fd_c_ocr_result;
}
FD_C_Bool FD_C_PPOCRv2WrapperBatchPredict(
FD_C_PPOCRv2Wrapper* fd_c_ppocrv2_wrapper, FD_C_OneDimMat imgs,
FD_C_OneDimOCRResult* results) {
std::vector<cv::Mat> imgs_vec;
std::vector<FD_C_OCRResultWrapper*> results_wrapper_out;
std::vector<fastdeploy::vision::OCRResult> results_out;
for (int i = 0; i < imgs.size; i++) {
imgs_vec.push_back(*(reinterpret_cast<cv::Mat*>(imgs.data[i])));
FD_C_OCRResultWrapper* fd_ocr_result_wrapper =
FD_C_CreateOCRResultWrapper();
results_wrapper_out.push_back(fd_ocr_result_wrapper);
}
auto& model = CHECK_AND_CONVERT_FD_TYPE(PPOCRv2Wrapper, fd_c_ppocrv2_wrapper);
bool successful = model->BatchPredict(imgs_vec, &results_out);
@@ -427,9 +381,14 @@ FD_C_Bool FD_C_PPOCRv2WrapperBatchPredict(
results->size = results_out.size();
results->data = new FD_C_OCRResult[results->size];
for (int i = 0; i < results_out.size(); i++) {
results->data[i] = *FD_C_OCRResultToC(&results_out[i]);
(*CHECK_AND_CONVERT_FD_TYPE(OCRResultWrapper, results_wrapper_out[i])) =
std::move(results_out[i]);
FD_C_OCRResultWrapperToCResult(results_wrapper_out[i], &results->data[i]);
}
}
for (int i = 0; i < results_out.size(); i++) {
FD_C_DestroyOCRResultWrapper(results_wrapper_out[i]);
}
return successful;
}
@@ -468,9 +427,9 @@ FD_C_Bool FD_C_PPOCRv3WrapperPredict(FD_C_PPOCRv3Wrapper* fd_c_ppocrv3_wrapper,
bool successful = model->Predict(im, ocr_result.get());
if (successful) {
FD_C_OCRResult* res = FD_C_OCRResultWrapperGetData(fd_c_ocr_result_wrapper);
*fd_c_ocr_result = *res;
FD_C_OCRResultWrapperToCResult(fd_c_ocr_result_wrapper, fd_c_ocr_result);
}
FD_C_DestroyOCRResultWrapper(fd_c_ocr_result_wrapper);
return successful;
}
@@ -481,9 +440,13 @@ FD_C_Bool FD_C_PPOCRv3WrapperBatchPredict(
FD_C_PPOCRv3Wrapper* fd_c_ppocrv3_wrapper, FD_C_OneDimMat imgs,
FD_C_OneDimOCRResult* results) {
std::vector<cv::Mat> imgs_vec;
std::vector<FD_C_OCRResultWrapper*> results_wrapper_out;
std::vector<fastdeploy::vision::OCRResult> results_out;
for (int i = 0; i < imgs.size; i++) {
imgs_vec.push_back(*(reinterpret_cast<cv::Mat*>(imgs.data[i])));
FD_C_OCRResultWrapper* fd_ocr_result_wrapper =
FD_C_CreateOCRResultWrapper();
results_wrapper_out.push_back(fd_ocr_result_wrapper);
}
auto& model = CHECK_AND_CONVERT_FD_TYPE(PPOCRv3Wrapper, fd_c_ppocrv3_wrapper);
bool successful = model->BatchPredict(imgs_vec, &results_out);
@@ -492,9 +455,14 @@ FD_C_Bool FD_C_PPOCRv3WrapperBatchPredict(
results->size = results_out.size();
results->data = new FD_C_OCRResult[results->size];
for (int i = 0; i < results_out.size(); i++) {
results->data[i] = *FD_C_OCRResultToC(&results_out[i]);
(*CHECK_AND_CONVERT_FD_TYPE(OCRResultWrapper, results_wrapper_out[i])) =
std::move(results_out[i]);
FD_C_OCRResultWrapperToCResult(results_wrapper_out[i], &results->data[i]);
}
}
for (int i = 0; i < results_out.size(); i++) {
FD_C_DestroyOCRResultWrapper(results_wrapper_out[i]);
}
return successful;
}

180
c_api/fastdeploy_capi/vision/result.cc
View File

@@ -47,11 +47,11 @@ void FD_C_DestroyClassifyResult(
delete fd_c_classify_result;
}
FD_C_ClassifyResult* FD_C_ClassifyResultWrapperGetData(
__fd_keep FD_C_ClassifyResultWrapper* fd_c_classify_result_wrapper) {
void FD_C_ClassifyResultWrapperToCResult(
__fd_keep FD_C_ClassifyResultWrapper* fd_c_classify_result_wrapper,
__fd_keep FD_C_ClassifyResult* fd_c_classify_result_data) {
auto& classify_result = CHECK_AND_CONVERT_FD_TYPE(
ClassifyResultWrapper, fd_c_classify_result_wrapper);
FD_C_ClassifyResult* fd_c_classify_result_data = new FD_C_ClassifyResult();
// copy label_ids
fd_c_classify_result_data->label_ids.size = classify_result->label_ids.size();
fd_c_classify_result_data->label_ids.data =
@@ -67,10 +67,10 @@ FD_C_ClassifyResult* FD_C_ClassifyResultWrapperGetData(
sizeof(float) * fd_c_classify_result_data->scores.size);
fd_c_classify_result_data->type =
static_cast<FD_C_ResultType>(classify_result->type);
return fd_c_classify_result_data;
return;
}
FD_C_ClassifyResultWrapper* FD_C_CreateClassifyResultWrapperFromData(
FD_C_ClassifyResultWrapper* FD_C_CreateClassifyResultWrapperFromCResult(
__fd_keep FD_C_ClassifyResult* fd_c_classify_result) {
FD_C_ClassifyResultWrapper* fd_c_classify_result_wrapper =
FD_C_CreateClassifyResultWrapper();
@@ -90,14 +90,16 @@ FD_C_ClassifyResultWrapper* FD_C_CreateClassifyResultWrapperFromData(
return fd_c_classify_result_wrapper;
}
char* FD_C_ClassifyResultWrapperStr(
FD_C_ClassifyResultWrapper* fd_c_classify_result_wrapper) {
void FD_C_ClassifyResultStr(FD_C_ClassifyResult* fd_c_classify_result,
char* str_buffer) {
FD_C_ClassifyResultWrapper* fd_c_classify_result_wrapper =
FD_C_CreateClassifyResultWrapperFromCResult(fd_c_classify_result);
auto& classify_result = CHECK_AND_CONVERT_FD_TYPE(
ClassifyResultWrapper, fd_c_classify_result_wrapper);
std::string information = classify_result->Str();
char* cstr = new char[information.length() + 1];
std::strcpy(cstr, information.c_str());
return cstr;
std::strcpy(str_buffer, information.c_str());
FD_C_DestroyClassifyResultWrapper(fd_c_classify_result_wrapper);
return;
}
// Detection Results
@@ -136,11 +138,11 @@ void FD_C_DestroyDetectionResult(
delete fd_c_detection_result;
}
FD_C_DetectionResult* FD_C_DetectionResultWrapperGetData(
__fd_keep FD_C_DetectionResultWrapper* fd_c_detection_result_wrapper) {
void FD_C_DetectionResultWrapperToCResult(
__fd_keep FD_C_DetectionResultWrapper* fd_c_detection_result_wrapper,
__fd_keep FD_C_DetectionResult* fd_c_detection_result) {
auto& detection_result = CHECK_AND_CONVERT_FD_TYPE(
DetectionResultWrapper, fd_c_detection_result_wrapper);
FD_C_DetectionResult* fd_c_detection_result = new FD_C_DetectionResult();
// copy boxes
const int boxes_coordinate_dim = 4;
fd_c_detection_result->boxes.size = detection_result->boxes.size();
@@ -194,10 +196,10 @@ FD_C_DetectionResult* FD_C_DetectionResultWrapperGetData(
fd_c_detection_result->contain_masks = detection_result->contain_masks;
fd_c_detection_result->type =
static_cast<FD_C_ResultType>(detection_result->type);
return fd_c_detection_result;
return;
}
FD_C_DetectionResultWrapper* FD_C_CreateDetectionResultWrapperFromData(
FD_C_DetectionResultWrapper* FD_C_CreateDetectionResultWrapperFromCResult(
__fd_keep FD_C_DetectionResult* fd_c_detection_result) {
FD_C_DetectionResultWrapper* fd_c_detection_result_wrapper =
FD_C_CreateDetectionResultWrapper();
@@ -248,14 +250,16 @@ FD_C_DetectionResultWrapper* FD_C_CreateDetectionResultWrapperFromData(
return fd_c_detection_result_wrapper;
}
char* FD_C_DetectionResultWrapperStr(
FD_C_DetectionResultWrapper* fd_c_detection_result_wrapper) {
void FD_C_DetectionResultStr(FD_C_DetectionResult* fd_c_detection_result,
char* str_buffer) {
FD_C_DetectionResultWrapper* fd_c_detection_result_wrapper =
FD_C_CreateDetectionResultWrapperFromCResult(fd_c_detection_result);
auto& detection_result = CHECK_AND_CONVERT_FD_TYPE(
DetectionResultWrapper, fd_c_detection_result_wrapper);
std::string information = detection_result->Str();
char* cstr = new char[information.length() + 1];
std::strcpy(cstr, information.c_str());
return cstr;
std::strcpy(str_buffer, information.c_str());
FD_C_DestroyDetectionResultWrapper(fd_c_detection_result_wrapper);
return;
}
// OCR Results
@@ -294,11 +298,11 @@ void FD_C_DestroyOCRResult(__fd_take FD_C_OCRResult* fd_c_ocr_result) {
delete fd_c_ocr_result;
}
FD_C_OCRResult* FD_C_OCRResultWrapperGetData(
__fd_keep FD_C_OCRResultWrapper* fd_c_ocr_result_wrapper) {
void FD_C_OCRResultWrapperToCResult(
__fd_keep FD_C_OCRResultWrapper* fd_c_ocr_result_wrapper,
__fd_keep FD_C_OCRResult* fd_c_ocr_result) {
auto& ocr_result =
CHECK_AND_CONVERT_FD_TYPE(OCRResultWrapper, fd_c_ocr_result_wrapper);
FD_C_OCRResult* fd_c_ocr_result = new FD_C_OCRResult();
// copy boxes
const int boxes_coordinate_dim = 8;
fd_c_ocr_result->boxes.size = ocr_result->boxes.size();
@@ -342,10 +346,10 @@ FD_C_OCRResult* FD_C_OCRResultWrapperGetData(
sizeof(int32_t) * fd_c_ocr_result->cls_labels.size);
// copy type
fd_c_ocr_result->type = static_cast<FD_C_ResultType>(ocr_result->type);
return fd_c_ocr_result;
return;
}
FD_C_OCRResultWrapper* FD_C_CreateOCRResultWrapperFromData(
FD_C_OCRResultWrapper* FD_C_CreateOCRResultWrapperFromCResult(
__fd_keep FD_C_OCRResult* fd_c_ocr_result) {
FD_C_OCRResultWrapper* fd_c_ocr_result_wrapper =
FD_C_CreateOCRResultWrapper();
@@ -389,13 +393,131 @@ FD_C_OCRResultWrapper* FD_C_CreateOCRResultWrapperFromData(
return fd_c_ocr_result_wrapper;
}
char* FD_C_OCRResultWrapperStr(FD_C_OCRResultWrapper* fd_c_ocr_result_wrapper) {
void FD_C_OCRResultStr(FD_C_OCRResult* fd_c_ocr_result, char* str_buffer) {
FD_C_OCRResultWrapper* fd_c_ocr_result_wrapper =
FD_C_CreateOCRResultWrapperFromCResult(fd_c_ocr_result);
auto& ocr_result =
CHECK_AND_CONVERT_FD_TYPE(OCRResultWrapper, fd_c_ocr_result_wrapper);
std::string information = ocr_result->Str();
char* cstr = new char[information.length() + 1];
std::strcpy(cstr, information.c_str());
return cstr;
std::strcpy(str_buffer, information.c_str());
FD_C_DestroyOCRResultWrapper(fd_c_ocr_result_wrapper);
return;
}
// Segmentation Results
FD_C_SegmentationResultWrapper* FD_C_CreateSegmentationResultWrapper() {
FD_C_SegmentationResultWrapper* fd_c_segmentation_result_wrapper =
new FD_C_SegmentationResultWrapper();
fd_c_segmentation_result_wrapper->segmentation_result =
std::unique_ptr<fastdeploy::vision::SegmentationResult>(
new fastdeploy::vision::SegmentationResult());
return fd_c_segmentation_result_wrapper;
}
void FD_C_DestroySegmentationResultWrapper(
__fd_take FD_C_SegmentationResultWrapper*
fd_c_segmentation_result_wrapper) {
delete fd_c_segmentation_result_wrapper;
}
void FD_C_DestroySegmentationResult(
__fd_take FD_C_SegmentationResult* fd_c_segmentation_result) {
if (fd_c_segmentation_result == nullptr) return;
// delete label_map
delete[] fd_c_segmentation_result->label_map.data;
// delete score_map
delete[] fd_c_segmentation_result->score_map.data;
// delete shape
delete[] fd_c_segmentation_result->shape.data;
delete fd_c_segmentation_result;
}
void FD_C_SegmentationResultWrapperToCResult(
__fd_keep FD_C_SegmentationResultWrapper* fd_c_segmentation_result_wrapper,
__fd_keep FD_C_SegmentationResult* fd_c_segmentation_result) {
auto& segmentation_result = CHECK_AND_CONVERT_FD_TYPE(
SegmentationResultWrapper, fd_c_segmentation_result_wrapper);
// copy label_map
fd_c_segmentation_result->label_map.size =
segmentation_result->label_map.size();
fd_c_segmentation_result->label_map.data =
new uint8_t[fd_c_segmentation_result->label_map.size];
memcpy(fd_c_segmentation_result->label_map.data,
segmentation_result->label_map.data(),
sizeof(uint8_t) * fd_c_segmentation_result->label_map.size);
// copy score_map
fd_c_segmentation_result->score_map.size =
segmentation_result->score_map.size();
fd_c_segmentation_result->score_map.data =
new float[fd_c_segmentation_result->score_map.size];
memcpy(fd_c_segmentation_result->score_map.data,
segmentation_result->score_map.data(),
sizeof(float) * fd_c_segmentation_result->score_map.size);
// copy shape
fd_c_segmentation_result->shape.size = segmentation_result->shape.size();
fd_c_segmentation_result->shape.data =
new int64_t[fd_c_segmentation_result->shape.size];
memcpy(fd_c_segmentation_result->shape.data,
segmentation_result->shape.data(),
sizeof(int64_t) * fd_c_segmentation_result->shape.size);
// copy contain_score_map
fd_c_segmentation_result->contain_score_map =
segmentation_result->contain_score_map;
// copy type
fd_c_segmentation_result->type =
static_cast<FD_C_ResultType>(segmentation_result->type);
return;
}
FD_C_SegmentationResultWrapper* FD_C_CreateSegmentationResultWrapperFromCResult(
__fd_keep FD_C_SegmentationResult* fd_c_segmentation_result) {
FD_C_SegmentationResultWrapper* fd_c_segmentation_result_wrapper =
FD_C_CreateSegmentationResultWrapper();
auto& segmentation_result = CHECK_AND_CONVERT_FD_TYPE(
SegmentationResultWrapper, fd_c_segmentation_result_wrapper);
// copy label_map
segmentation_result->label_map.resize(
fd_c_segmentation_result->label_map.size);
memcpy(segmentation_result->label_map.data(),
fd_c_segmentation_result->label_map.data,
sizeof(uint8_t) * fd_c_segmentation_result->label_map.size);
// copy score_map
segmentation_result->score_map.resize(
fd_c_segmentation_result->score_map.size);
memcpy(segmentation_result->score_map.data(),
fd_c_segmentation_result->score_map.data,
sizeof(float) * fd_c_segmentation_result->score_map.size);
// copy shape
segmentation_result->shape.resize(fd_c_segmentation_result->shape.size);
memcpy(segmentation_result->shape.data(),
fd_c_segmentation_result->shape.data,
sizeof(int64_t) * fd_c_segmentation_result->shape.size);
// copy contain_score_map
segmentation_result->contain_score_map =
fd_c_segmentation_result->contain_score_map;
// copy type
segmentation_result->type = static_cast<fastdeploy::vision::ResultType>(
fd_c_segmentation_result->type);
return fd_c_segmentation_result_wrapper;
}
void FD_C_SegmentationResultStr(
FD_C_SegmentationResult* fd_c_segmentation_result, char* str_buffer) {
FD_C_SegmentationResultWrapper* fd_c_segmentation_result_wrapper =
FD_C_CreateSegmentationResultWrapperFromCResult(fd_c_segmentation_result);
auto& segmentation_result = CHECK_AND_CONVERT_FD_TYPE(
SegmentationResultWrapper, fd_c_segmentation_result_wrapper);
std::string information = segmentation_result->Str();
std::strcpy(str_buffer, information.c_str());
FD_C_DestroySegmentationResultWrapper(fd_c_segmentation_result_wrapper);
return;
}
#ifdef __cplusplus

139
c_api/fastdeploy_capi/vision/result.h
View File

@@ -20,6 +20,7 @@
typedef struct FD_C_ClassifyResultWrapper FD_C_ClassifyResultWrapper;
typedef struct FD_C_DetectionResultWrapper FD_C_DetectionResultWrapper;
typedef struct FD_C_OCRResultWrapper FD_C_OCRResultWrapper;
typedef struct FD_C_SegmentationResultWrapper FD_C_SegmentationResultWrapper;
#ifdef __cplusplus
extern "C" {
@@ -76,6 +77,20 @@ typedef struct FD_C_OneDimOCRResult {
FD_C_OCRResult* data;
} FD_C_OneDimOCRResult;
typedef struct FD_C_SegmentationResult {
FD_C_OneDimArrayUint8 label_map;
FD_C_OneDimArrayFloat score_map;
FD_C_OneDimArrayInt64 shape;
FD_C_Bool contain_score_map;
FD_C_ResultType type;
} FD_C_SegmentationResult;
typedef struct FD_C_OneDimSegmentationResult {
size_t size;
FD_C_SegmentationResult* data;
} FD_C_OneDimSegmentationResult;
// Classification Results
/** \brief Create a new FD_C_ClassifyResultWrapper object
@@ -105,11 +120,13 @@ FD_C_DestroyClassifyResult(__fd_take FD_C_ClassifyResult* fd_c_classify_result);
/** \brief Get a FD_C_ClassifyResult object from FD_C_ClassifyResultWrapper object
*
* \param[in] fd_c_classify_result_wrapper pointer to FD_C_ClassifyResultWrapper object
* \return Return a pointer to FD_C_ClassifyResult object
* \param[out] fd_c_classify_result pointer to FD_C_ClassifyResult object used to store data
*/
FASTDEPLOY_CAPI_EXPORT extern __fd_give FD_C_ClassifyResult*
FD_C_ClassifyResultWrapperGetData(
__fd_keep FD_C_ClassifyResultWrapper* fd_c_classify_result_wrapper);
FASTDEPLOY_CAPI_EXPORT extern __fd_give void
FD_C_ClassifyResultWrapperToCResult(
__fd_keep FD_C_ClassifyResultWrapper* fd_c_classify_result_wrapper,
__fd_keep FD_C_ClassifyResult* fd_c_classify_result);
/** \brief Create a new FD_C_ClassifyResultWrapper object from FD_C_ClassifyResult object
*
@@ -118,18 +135,19 @@ FD_C_ClassifyResultWrapperGetData(
*/
FASTDEPLOY_CAPI_EXPORT extern __fd_give FD_C_ClassifyResultWrapper*
FD_C_CreateClassifyResultWrapperFromData(
FD_C_CreateClassifyResultWrapperFromCResult(
__fd_keep FD_C_ClassifyResult* fd_c_classify_result);
/** \brief Print ClassifyResult formated information
*
* \param[in] fd_c_classify_result_wrapper pointer to FD_C_ClassifyResultWrapper object
* \return Return a string pointer
* \param[in] fd_c_classify_result pointer to FD_C_ClassifyResult object
* \param[out] str_buffer used to store string
*/
FASTDEPLOY_CAPI_EXPORT extern __fd_give char*
FD_C_ClassifyResultWrapperStr(
__fd_keep FD_C_ClassifyResultWrapper* fd_c_classify_result_wrapper);
FASTDEPLOY_CAPI_EXPORT extern __fd_give void
FD_C_ClassifyResultStr(
__fd_keep FD_C_ClassifyResult* fd_c_classify_result, char* str_buffer);
// Detection Results
@@ -160,11 +178,12 @@ FASTDEPLOY_CAPI_EXPORT extern void FD_C_DestroyDetectionResult(
/** \brief Get a FD_C_DetectionResult object from FD_C_DetectionResultWrapper object
*
* \param[in] fd_c_detection_result_wrapper pointer to FD_C_DetectionResultWrapper object
* \return Return a pointer to FD_C_DetectionResult object
* \param[out] fd_c_detection_result pointer to FD_C_DetectionResult object used to store data
*/
FASTDEPLOY_CAPI_EXPORT extern __fd_give FD_C_DetectionResult*
FD_C_DetectionResultWrapperGetData(
__fd_keep FD_C_DetectionResultWrapper* fd_c_detection_result_wrapper);
FASTDEPLOY_CAPI_EXPORT extern __fd_give void
FD_C_DetectionResultWrapperToCResult(
__fd_keep FD_C_DetectionResultWrapper* fd_c_detection_result_wrapper,
__fd_keep FD_C_DetectionResult* fd_c_detection_result);
/** \brief Create a new FD_C_DetectionResultWrapper object from FD_C_DetectionResult object
*
@@ -173,18 +192,19 @@ FD_C_DetectionResultWrapperGetData(
*/
FASTDEPLOY_CAPI_EXPORT extern __fd_give FD_C_DetectionResultWrapper*
FD_C_CreateDetectionResultWrapperFromData(
FD_C_CreateDetectionResultWrapperFromCResult(
__fd_keep FD_C_DetectionResult* fd_c_detection_result);
/** \brief Print DetectionResult formated information
*
* \param[in] fd_c_detection_result_wrapper pointer to FD_C_DetectionResultWrapper object
* \return Return a string pointer
* \param[in] fd_c_detection_result pointer to FD_C_DetectionResult object
* \param[out] str_buffer used to store string
*/
FASTDEPLOY_CAPI_EXPORT extern __fd_give char*
FD_C_DetectionResultWrapperStr(
__fd_keep FD_C_DetectionResultWrapper* fd_c_detection_result_wrapper);
FASTDEPLOY_CAPI_EXPORT extern void
FD_C_DetectionResultStr(
__fd_keep FD_C_DetectionResult* fd_c_detection_result, char* str_buffer);
// OCR Results
@@ -216,11 +236,12 @@ FASTDEPLOY_CAPI_EXPORT extern void FD_C_DestroyOCRResult(
/** \brief Get a FD_C_OCRResult object from FD_C_OCRResultWrapper object
*
* \param[in] fd_c_ocr_result_wrapper pointer to FD_C_OCRResultWrapper object
* \return Return a pointer to FD_C_OCRResult object
* \param[out] fd_c_ocr_result pointer to FD_C_OCRResult object used to store data
*/
FASTDEPLOY_CAPI_EXPORT extern __fd_give FD_C_OCRResult*
FD_C_OCRResultWrapperGetData(
__fd_keep FD_C_OCRResultWrapper* fd_c_ocr_result_wrapper);
FASTDEPLOY_CAPI_EXPORT extern __fd_give void
FD_C_OCRResultWrapperToCResult(
__fd_keep FD_C_OCRResultWrapper* fd_c_ocr_result_wrapper,
__fd_keep FD_C_OCRResult* fd_c_ocr_result);
/** \brief Create a new FD_C_OCRResultWrapper object from FD_C_OCRResult object
*
@@ -229,18 +250,76 @@ FD_C_OCRResultWrapperGetData(
*/
FASTDEPLOY_CAPI_EXPORT extern __fd_give FD_C_OCRResultWrapper*
FD_C_CreateOCRResultWrapperFromData(
FD_C_CreateOCRResultWrapperFromCResult(
__fd_keep FD_C_OCRResult* fd_c_ocr_result);
/** \brief Print OCRResult formated information
*
* \param[in] fd_c_ocr_result_wrapper pointer to FD_C_OCRResultWrapper object
* \return Return a string pointer
* \param[in] fd_c_ocr_result pointer to FD_C_OCRResult object
* \param[out] str_buffer used to store string
*/
FASTDEPLOY_CAPI_EXPORT extern __fd_give char*
FD_C_OCRResultWrapperStr(
__fd_keep FD_C_OCRResultWrapper* fd_c_ocr_result_wrapper);
FASTDEPLOY_CAPI_EXPORT extern void
FD_C_OCRResultStr(
__fd_keep FD_C_OCRResult* fd_c_ocr_result, char* str_buffer);
// Segmentation Results
/** \brief Create a new FD_C_SegmentationResultWrapper object
*
* \return Return a pointer to FD_C_SegmentationResultWrapper object
*/
FASTDEPLOY_CAPI_EXPORT extern __fd_give FD_C_SegmentationResultWrapper*
FD_C_CreateSegmentationResultWrapper();
/** \brief Destroy a FD_C_SegmentationResultWrapper object
*
* \param[in] fd_c_segmentation_result_wrapper pointer to FD_C_SegmentationResultWrapper object
*/
FASTDEPLOY_CAPI_EXPORT extern void FD_C_DestroySegmentationResultWrapper(
__fd_take FD_C_SegmentationResultWrapper* fd_c_segmentation_result_wrapper);
/** \brief Destroy a FD_C_SegmentationResult object
*
* \param[in] fd_c_segmentation_result pointer to FD_C_SegmentationResult object
*/
FASTDEPLOY_CAPI_EXPORT extern void FD_C_DestroySegmentationResult(
__fd_take FD_C_SegmentationResult* fd_c_segmentation_result);
/** \brief Get a FD_C_SegmentationResult object from FD_C_SegmentationResultWrapper object
*
* \param[in] fd_c_segmentation_result_wrapper pointer to FD_C_SegmentationResultWrapper object
* \param[out] fd_c_segmentation_result pointer to FD_C_SegmentationResult object used to store data
*/
FASTDEPLOY_CAPI_EXPORT extern __fd_give void
FD_C_SegmentationResultWrapperToCResult(
__fd_keep FD_C_SegmentationResultWrapper* fd_c_segmentation_result_wrapper,
__fd_keep FD_C_SegmentationResult* fd_c_segmentation_result);
/** \brief Create a new FD_C_SegmentationResultWrapper object from FD_C_SegmentationResult object
*
* \param[in] fd_c_segmentation_result pointer to FD_C_SegmentationResult object
* \return Return a pointer to FD_C_SegmentationResultWrapper object
*/
FASTDEPLOY_CAPI_EXPORT extern __fd_give FD_C_SegmentationResultWrapper*
FD_C_CreateSegmentationResultWrapperFromCResult(
__fd_keep FD_C_SegmentationResult* fd_c_segmentation_result);
/** \brief Print SegmentationResult formated information
*
* \param[in] fd_c_segmentation_result pointer to FD_C_SegmentationResult object
* \param[out] str_buffer used to store string
*/
FASTDEPLOY_CAPI_EXPORT extern __fd_give void
FD_C_SegmentationResultStr(
__fd_keep FD_C_SegmentationResult* fd_c_segmentation_result, char* str_buffer);
#ifdef __cplusplus

107
c_api/fastdeploy_capi/vision/segmentation/ppseg/model.cc Normal file
View File

@@ -0,0 +1,107 @@
// Copyright (c) 2023 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 "fastdeploy_capi/vision/segmentation/ppseg/model.h"
#include "fastdeploy_capi/types_internal.h"
#ifdef __cplusplus
extern "C" {
#endif
FD_C_PaddleSegModelWrapper* FD_C_CreatePaddleSegModelWrapper(
const char* model_file, const char* params_file, const char* config_file,
FD_C_RuntimeOptionWrapper* fd_c_runtime_option_wrapper,
const FD_C_ModelFormat model_format) {
auto& runtime_option = CHECK_AND_CONVERT_FD_TYPE(RuntimeOptionWrapper,
fd_c_runtime_option_wrapper);
FD_C_PaddleSegModelWrapper* fd_c_paddleseg_model_wrapper =
new FD_C_PaddleSegModelWrapper();
fd_c_paddleseg_model_wrapper->segmentation_model =
std::unique_ptr<fastdeploy::vision::segmentation::PaddleSegModel>(
new fastdeploy::vision::segmentation::PaddleSegModel(
std::string(model_file), std::string(params_file),
std::string(config_file), *runtime_option,
static_cast<fastdeploy::ModelFormat>(model_format)));
return fd_c_paddleseg_model_wrapper;
}
void FD_C_DestroyPaddleSegModelWrapper(
FD_C_PaddleSegModelWrapper* fd_c_paddleseg_model_wrapper) {
delete fd_c_paddleseg_model_wrapper;
}
FD_C_Bool FD_C_PaddleSegModelWrapperPredict(
FD_C_PaddleSegModelWrapper* fd_c_paddleseg_model_wrapper, FD_C_Mat img,
FD_C_SegmentationResult* fd_c_segmentation_result) {
cv::Mat* im = reinterpret_cast<cv::Mat*>(img);
auto& paddleseg_model = CHECK_AND_CONVERT_FD_TYPE(
PaddleSegModelWrapper, fd_c_paddleseg_model_wrapper);
FD_C_SegmentationResultWrapper* fd_c_segmentation_result_wrapper =
FD_C_CreateSegmentationResultWrapper();
auto& segmentation_result = CHECK_AND_CONVERT_FD_TYPE(
SegmentationResultWrapper, fd_c_segmentation_result_wrapper);
bool successful = paddleseg_model->Predict(im, segmentation_result.get());
if (successful) {
FD_C_SegmentationResultWrapperToCResult(fd_c_segmentation_result_wrapper,
fd_c_segmentation_result);
}
FD_C_DestroySegmentationResultWrapper(fd_c_segmentation_result_wrapper);
return successful;
}
FD_C_Bool FD_C_PaddleSegModelWrapperInitialized(
FD_C_PaddleSegModelWrapper* fd_c_paddleseg_model_wrapper) {
auto& paddleseg_model = CHECK_AND_CONVERT_FD_TYPE(
PaddleSegModelWrapper, fd_c_paddleseg_model_wrapper);
return paddleseg_model->Initialized();
}
FD_C_Bool FD_C_PaddleSegModelWrapperBatchPredict(
FD_C_PaddleSegModelWrapper* fd_c_paddleseg_model_wrapper,
FD_C_OneDimMat imgs, FD_C_OneDimSegmentationResult* results) {
std::vector<cv::Mat> imgs_vec;
std::vector<FD_C_SegmentationResultWrapper*> results_wrapper_out;
std::vector<fastdeploy::vision::SegmentationResult> results_out;
for (int i = 0; i < imgs.size; i++) {
imgs_vec.push_back(*(reinterpret_cast<cv::Mat*>(imgs.data[i])));
FD_C_SegmentationResultWrapper* fd_segmentation_result_wrapper =
FD_C_CreateSegmentationResultWrapper();
results_wrapper_out.push_back(fd_segmentation_result_wrapper);
}
auto& paddleseg_model = CHECK_AND_CONVERT_FD_TYPE(
PaddleSegModelWrapper, fd_c_paddleseg_model_wrapper);
bool successful = paddleseg_model->BatchPredict(imgs_vec, &results_out);
if (successful) {
// copy results back to FD_C_OneDimSegmentationResult
results->size = results_out.size();
results->data = new FD_C_SegmentationResult[results->size];
for (int i = 0; i < results_out.size(); i++) {
(*CHECK_AND_CONVERT_FD_TYPE(SegmentationResultWrapper,
results_wrapper_out[i])) =
std::move(results_out[i]);
FD_C_SegmentationResultWrapperToCResult(results_wrapper_out[i],
&results->data[i]);
}
}
for (int i = 0; i < results_out.size(); i++) {
FD_C_DestroySegmentationResultWrapper(results_wrapper_out[i]);
}
return successful;
}
#ifdef __cplusplus
}
#endif

90
c_api/fastdeploy_capi/vision/segmentation/ppseg/model.h Normal file
View File

@@ -0,0 +1,90 @@
// Copyright (c) 2023 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.
#pragma once
#include "fastdeploy_capi/fd_common.h"
#include "fastdeploy_capi/fd_type.h"
#include "fastdeploy_capi/runtime_option.h"
#include "fastdeploy_capi/vision/result.h"
typedef struct FD_C_PaddleSegModelWrapper FD_C_PaddleSegModelWrapper;
#ifdef __cplusplus
extern "C" {
#endif
/** \brief Create a new FD_C_PaddleSegModelWrapper object
*
* \param[in] model_file Path of model file, e.g net/model.pdmodel
* \param[in] params_file Path of parameter file, e.g unet/model.pdiparams, if the model format is ONNX, this parameter will be ignored
* \param[in] config_file Path of configuration file for deployment, e.g unet/deploy.yml
* \param[in] fd_c_runtime_option_wrapper RuntimeOption for inference, the default will use cpu, and choose the backend defined in `valid_cpu_backends`
* \param[in] model_format Model format of the loaded model, default is Paddle format
*
* \return Return a pointer to FD_C_PaddleSegModelWrapper object
*/
FASTDEPLOY_CAPI_EXPORT extern __fd_give FD_C_PaddleSegModelWrapper*
FD_C_CreatePaddleSegModelWrapper(
const char* model_file, const char* params_file, const char* config_file,
FD_C_RuntimeOptionWrapper* fd_c_runtime_option_wrapper,
const FD_C_ModelFormat model_format);
/** \brief Destroy a FD_C_PaddleSegModelWrapper object
*
* \param[in] fd_c_paddleseg_model_wrapper pointer to FD_C_PaddleSegModelWrapper object
*/
FASTDEPLOY_CAPI_EXPORT extern void FD_C_DestroyPaddleSegModelWrapper(
__fd_take FD_C_PaddleSegModelWrapper* fd_c_paddleseg_model_wrapper);
/** \brief Predict the segmentation result for an input image
*
* \param[in] fd_c_paddleseg_model_wrapper pointer to FD_C_PaddleSegModelWrapper object
* \param[in] img pointer to cv::Mat image
* \param[in] fd_c_segmentation_result pointer to FD_C_SegmentationResult object, which stores the result.
*/
FASTDEPLOY_CAPI_EXPORT extern FD_C_Bool FD_C_PaddleSegModelWrapperPredict(
__fd_keep FD_C_PaddleSegModelWrapper* fd_c_paddleseg_model_wrapper,
FD_C_Mat img, FD_C_SegmentationResult* fd_c_segmentation_result);
/** \brief Check if the model is initialized successfully
*
* \param[in] fd_c_paddleseg_model_wrapper pointer to FD_C_PaddleSegModelWrapper object
*
* \return Return a bool of value true if initialized successfully
*/
FASTDEPLOY_CAPI_EXPORT extern FD_C_Bool FD_C_PaddleSegModelWrapperInitialized(
__fd_keep FD_C_PaddleSegModelWrapper* fd_c_paddleseg_model_wrapper);
/** \brief Predict the segmentation results for a batch of input images
*
* \param[in] fd_c_paddleseg_model_wrapper pointer to FD_C_PaddleSegModelWrapper object
* \param[in] imgs The input image list, each element comes from cv::imread()
* \param[in] results The output segmentation result list
* \return true if the prediction successed, otherwise false
*/
FASTDEPLOY_CAPI_EXPORT extern FD_C_Bool FD_C_PaddleSegModelWrapperBatchPredict(
__fd_keep FD_C_PaddleSegModelWrapper* fd_c_paddleseg_model_wrapper,
FD_C_OneDimMat imgs,
FD_C_OneDimSegmentationResult* results);
#ifdef __cplusplus
} // extern "C"
#endif

28
c_api/fastdeploy_capi/vision/visualize.cc
View File

@@ -26,12 +26,13 @@ FD_C_Mat FD_C_VisDetection(FD_C_Mat im,
float score_threshold, int line_size,
float font_size) {
FD_C_DetectionResultWrapper* fd_c_detection_result_wrapper =
FD_C_CreateDetectionResultWrapperFromData(fd_c_detection_result);
FD_C_CreateDetectionResultWrapperFromCResult(fd_c_detection_result);
auto& detection_result = CHECK_AND_CONVERT_FD_TYPE(
DetectionResultWrapper, fd_c_detection_result_wrapper);
cv::Mat result = fastdeploy::vision::VisDetection(
*(reinterpret_cast<cv::Mat*>(im)), *detection_result, score_threshold,
line_size, font_size);
FD_C_DestroyDetectionResultWrapper(fd_c_detection_result_wrapper);
return new cv::Mat(result);
}
@@ -45,12 +46,13 @@ FD_C_Mat FD_C_VisDetectionWithLabel(FD_C_Mat im,
labels_in.emplace_back(labels->data[i].data);
}
FD_C_DetectionResultWrapper* fd_c_detection_result_wrapper =
FD_C_CreateDetectionResultWrapperFromData(fd_c_detection_result);
FD_C_CreateDetectionResultWrapperFromCResult(fd_c_detection_result);
auto& detection_result = CHECK_AND_CONVERT_FD_TYPE(
DetectionResultWrapper, fd_c_detection_result_wrapper);
cv::Mat result = fastdeploy::vision::VisDetection(
*(reinterpret_cast<cv::Mat*>(im)), *detection_result, labels_in,
score_threshold, line_size, font_size);
FD_C_DestroyDetectionResultWrapper(fd_c_detection_result_wrapper);
return new cv::Mat(result);
}
@@ -59,12 +61,13 @@ FD_C_Mat FD_C_VisClassification(FD_C_Mat im,
int top_k, float score_threshold,
float font_size) {
FD_C_ClassifyResultWrapper* fd_c_classify_result_wrapper =
FD_C_CreateClassifyResultWrapperFromData(fd_c_classify_result);
FD_C_CreateClassifyResultWrapperFromCResult(fd_c_classify_result);
auto& classify_result = CHECK_AND_CONVERT_FD_TYPE(
ClassifyResultWrapper, fd_c_classify_result_wrapper);
cv::Mat result = fastdeploy::vision::VisClassification(
*(reinterpret_cast<cv::Mat*>(im)), *classify_result, top_k,
score_threshold, font_size);
FD_C_DestroyClassifyResultWrapper(fd_c_classify_result_wrapper);
return new cv::Mat(result);
}
@@ -77,22 +80,37 @@ FD_C_Mat FD_C_VisClassificationWithLabel(
labels_in.emplace_back(labels->data[i].data);
}
FD_C_ClassifyResultWrapper* fd_c_classify_result_wrapper =
FD_C_CreateClassifyResultWrapperFromData(fd_c_classify_result);
FD_C_CreateClassifyResultWrapperFromCResult(fd_c_classify_result);
auto& classify_result = CHECK_AND_CONVERT_FD_TYPE(
ClassifyResultWrapper, fd_c_classify_result_wrapper);
cv::Mat result = fastdeploy::vision::VisClassification(
*(reinterpret_cast<cv::Mat*>(im)), *classify_result, labels_in, top_k,
score_threshold, font_size);
FD_C_DestroyClassifyResultWrapper(fd_c_classify_result_wrapper);
return new cv::Mat(result);
}
FD_C_Mat FD_C_VisOcr(FD_C_Mat im, FD_C_OCRResult* fd_c_ocr_result) {
FD_C_OCRResultWrapper* fd_c_ocr_result_wrapper =
FD_C_CreateOCRResultWrapperFromData(fd_c_ocr_result);
FD_C_CreateOCRResultWrapperFromCResult(fd_c_ocr_result);
auto& ocr_result =
CHECK_AND_CONVERT_FD_TYPE(OCRResultWrapper, fd_c_ocr_result_wrapper);
cv::Mat result = fastdeploy::vision::VisOcr(*(reinterpret_cast<cv::Mat*>(im)),
*ocr_result);
FD_C_DestroyOCRResultWrapper(fd_c_ocr_result_wrapper);
return new cv::Mat(result);
}
FD_C_Mat FD_C_VisSegmentation(FD_C_Mat im,
FD_C_SegmentationResult* fd_c_segmenation_result,
float weight) {
FD_C_SegmentationResultWrapper* fd_c_segmentation_result_wrapper =
FD_C_CreateSegmentationResultWrapperFromCResult(fd_c_segmenation_result);
auto& segmentation_result = CHECK_AND_CONVERT_FD_TYPE(
SegmentationResultWrapper, fd_c_segmentation_result_wrapper);
cv::Mat result = fastdeploy::vision::VisSegmentation(
*(reinterpret_cast<cv::Mat*>(im)), *segmentation_result, weight);
FD_C_DestroySegmentationResultWrapper(fd_c_segmentation_result_wrapper);
return new cv::Mat(result);
}

11
c_api/fastdeploy_capi/vision/visualize.h
View File

@@ -89,6 +89,17 @@ FASTDEPLOY_CAPI_EXPORT extern __fd_give FD_C_Mat FD_C_VisClassificationWithLabel
*/
FASTDEPLOY_CAPI_EXPORT extern __fd_give FD_C_Mat FD_C_VisOcr(FD_C_Mat im, FD_C_OCRResult* ocr_result);
/** \brief Show the visualized results for segmentation models
*
* \param[in] im the input image data, comes from cv::imread(), is a 3-D array with layout HWC, BGR format
* \param[in] result the result produced by model
* \param[in] weight transparent weight of visualized result image
* \return cv::Mat type stores the visualized results
*/
FASTDEPLOY_CAPI_EXPORT extern __fd_give FD_C_Mat FD_C_VisSegmentation(FD_C_Mat im,
FD_C_SegmentationResult* result,
float weight);
#ifdef __cplusplus
} // extern "C"