[Model] Integrate FlyCV image processing library (#375)

* Add falcon cmake

* Update CMakeLists.txt

* Add implementation for more preprocessors

* Add more implementation

* Add more implementations by flycv

* Fix some name

* fix some bug

* ready to test

* add fuse

* fix fuse problem

* add debug code

* add debug

* [Android] integrate flycv to Android (#459)

* [Android] integrate flycv into Andorid

* Falconcv (#27)

* [Bug Fix ]Update ppseg visualize python api && demo (#454)

Update ppseg visualize python api && demo

* [Model] update pptracking letterboxresize and add some comment (#438)

* add override mark

* delete some

* recovery

* recovery

* add tracking

* add tracking py_bind and example

* add pptracking

* add pptracking

* iomanip head file

* add opencv_video lib

* add python libs package

Signed-off-by: ChaoII <849453582@qq.com>

* complete comments

Signed-off-by: ChaoII <849453582@qq.com>

* add jdeTracker_ member variable

Signed-off-by: ChaoII <849453582@qq.com>

* add 'FASTDEPLOY_DECL' macro

Signed-off-by: ChaoII <849453582@qq.com>

* remove kwargs params

Signed-off-by: ChaoII <849453582@qq.com>

* [Doc]update pptracking docs

* delete 'ENABLE_PADDLE_FRONTEND' switch

* add pptracking unit test

* update pptracking unit test

Signed-off-by: ChaoII <849453582@qq.com>

* modify test video file path and remove trt test

* update unit test model url

* remove 'FASTDEPLOY_DECL' macro

Signed-off-by: ChaoII <849453582@qq.com>

* fix build python packages about pptracking on win32

Signed-off-by: ChaoII <849453582@qq.com>

* update comment

Signed-off-by: ChaoII <849453582@qq.com>

* add pptracking model explain

Signed-off-by: ChaoII <849453582@qq.com>

Signed-off-by: ChaoII <849453582@qq.com>
Co-authored-by: Jason <jiangjiajun@baidu.com>

Signed-off-by: ChaoII <849453582@qq.com>
Co-authored-by: huangjianhui <852142024@qq.com>
Co-authored-by: ChaoII <849453582@qq.com>
Co-authored-by: Jason <jiangjiajun@baidu.com>

* [cmake] optimize examples CMakeLists.txt

Signed-off-by: ChaoII <849453582@qq.com>
Co-authored-by: huangjianhui <852142024@qq.com>
Co-authored-by: ChaoII <849453582@qq.com>
Co-authored-by: Jason <jiangjiajun@baidu.com>

* remove debug log

* remove function

* remove function

Signed-off-by: ChaoII <849453582@qq.com>
Co-authored-by: DefTruth <31974251+DefTruth@users.noreply.github.com>
Co-authored-by: huangjianhui <852142024@qq.com>
Co-authored-by: ChaoII <849453582@qq.com>
This commit is contained in:
Jason
2022-11-01 10:42:52 +08:00
committed by GitHub
parent c76992c906
commit bb00e0757e
68 changed files with 2571 additions and 106 deletions

View File

@@ -60,8 +60,8 @@ option(ENABLE_POROS_BACKEND "Whether to enable poros backend." OFF)
option(ENABLE_OPENVINO_BACKEND "Whether to enable openvino backend." OFF) option(ENABLE_OPENVINO_BACKEND "Whether to enable openvino backend." OFF)
option(ENABLE_LITE_BACKEND "Whether to enable paddle lite backend." OFF) option(ENABLE_LITE_BACKEND "Whether to enable paddle lite backend." OFF)
option(ENABLE_VISION "Whether to enable vision models usage." OFF) option(ENABLE_VISION "Whether to enable vision models usage." OFF)
option(ENABLE_VISION_VISUALIZE "Whether to enable visualize vision model result toolbox." ON)
option(ENABLE_TEXT "Whether to enable text models usage." OFF) option(ENABLE_TEXT "Whether to enable text models usage." OFF)
option(ENABLE_FLYCV "Whether to enable flycv to boost image preprocess." OFF)
option(WITH_TESTING "Whether to compile with unittest." OFF) option(WITH_TESTING "Whether to compile with unittest." OFF)
############################# Options for Android cross compiling ######################### ############################# Options for Android cross compiling #########################
option(WITH_OPENCV_STATIC "Use OpenCV static lib for Android." OFF) option(WITH_OPENCV_STATIC "Use OpenCV static lib for Android." OFF)
@@ -136,16 +136,6 @@ set(HEAD_DIR "${PROJECT_SOURCE_DIR}/${CSRCS_DIR_NAME}")
include_directories(${HEAD_DIR}) include_directories(${HEAD_DIR})
include_directories(${CMAKE_CURRENT_BINARY_DIR}) include_directories(${CMAKE_CURRENT_BINARY_DIR})
if(BUILD_EXAMPLES AND EXISTS ${PROJECT_SOURCE_DIR}/examples)
if(ENABLE_VISION)
# ENABLE_VISION_VISUALIZE must be ON if enable vision examples.
message(STATUS "Found BUILD_EXAMPLES and ENABLE_VISION ON, so, force ENABLE_VISION_VISUALIZE ON")
set(ENABLE_VISION_VISUALIZE ON CACHE BOOL "force to enable visualize vision model result toolbox" FORCE)
else()
message(WARNING "BUILD_EXAMPLES is ON, but found ENABLE_VISION OFF, will skip vision examples.")
endif()
endif()
if(ANDROID OR IOS) if(ANDROID OR IOS)
if(ENABLE_ORT_BACKEND) if(ENABLE_ORT_BACKEND)
message(FATAL_ERROR "Not support ONNXRuntime backend for Andorid/IOS now. Please set ENABLE_ORT_BACKEND=OFF.") message(FATAL_ERROR "Not support ONNXRuntime backend for Andorid/IOS now. Please set ENABLE_ORT_BACKEND=OFF.")
@@ -382,6 +372,8 @@ endif()
if(ENABLE_VISION) if(ENABLE_VISION)
add_definitions(-DENABLE_VISION) add_definitions(-DENABLE_VISION)
# set(ENABLE_VISION_VISUALIZE ON)
add_definitions(-DENABLE_VISION_VISUALIZE)
if(ENABLE_OPENCV_CUDA) if(ENABLE_OPENCV_CUDA)
if(NOT WITH_GPU) if(NOT WITH_GPU)
message(FATAL_ERROR "ENABLE_OPENCV_CUDA is available on Linux and WITH_GPU=ON, but now WITH_GPU=OFF.") message(FATAL_ERROR "ENABLE_OPENCV_CUDA is available on Linux and WITH_GPU=ON, but now WITH_GPU=OFF.")
@@ -402,13 +394,10 @@ if(ENABLE_VISION)
include_directories(${PROJECT_SOURCE_DIR}/third_party/yaml-cpp/include) include_directories(${PROJECT_SOURCE_DIR}/third_party/yaml-cpp/include)
include(${PROJECT_SOURCE_DIR}/cmake/opencv.cmake) include(${PROJECT_SOURCE_DIR}/cmake/opencv.cmake)
if(ENABLE_VISION_VISUALIZE) if(ENABLE_FLYCV)
add_definitions(-DENABLE_VISION_VISUALIZE) add_definitions(-DENABLE_FLYCV)
endif() include(${PROJECT_SOURCE_DIR}/cmake/flycv.cmake)
else() list(APPEND DEPEND_LIBS external_flycv)
if(ENABLE_VISION_VISUALIZE)
message("While ENABLE_VISION=OFF, will force ENABLE_VISION_VISUALIZE=OFF.")
set(ENABLE_VISION_VISUALIZE OFF)
endif() endif()
endif() endif()

View File

@@ -10,6 +10,7 @@ set(POROS_VERSION @POROS_VERSION@)
set(ENABLE_TRT_BACKEND @ENABLE_TRT_BACKEND@) set(ENABLE_TRT_BACKEND @ENABLE_TRT_BACKEND@)
set(ENABLE_PADDLE_FRONTEND @ENABLE_PADDLE_FRONTEND@) set(ENABLE_PADDLE_FRONTEND @ENABLE_PADDLE_FRONTEND@)
set(ENABLE_VISION @ENABLE_VISION@) set(ENABLE_VISION @ENABLE_VISION@)
set(ENABLE_FLYCV @ENABLE_FLYCV@)
set(ENABLE_TEXT @ENABLE_TEXT@) set(ENABLE_TEXT @ENABLE_TEXT@)
set(BUILD_ON_JETSON @BUILD_ON_JETSON@) set(BUILD_ON_JETSON @BUILD_ON_JETSON@)
set(PADDLEINFERENCE_VERSION @PADDLEINFERENCE_VERSION@) set(PADDLEINFERENCE_VERSION @PADDLEINFERENCE_VERSION@)
@@ -185,6 +186,20 @@ if(ENABLE_VISION)
list(APPEND FASTDEPLOY_INCS ${OpenCV_INCLUDE_DIRS}) list(APPEND FASTDEPLOY_INCS ${OpenCV_INCLUDE_DIRS})
list(APPEND FASTDEPLOY_LIBS ${OpenCV_LIBS}) list(APPEND FASTDEPLOY_LIBS ${OpenCV_LIBS})
endif() endif()
if(ENABLE_FLYCV)
include_directories(${CMAKE_CURRENT_LIST_DIR}/third_libs/install/flycv/include)
set(FLYCV_LIB_DIR ${CMAKE_CURRENT_LIST_DIR}/third_libs/install/flycv/lib)
if(ANDROID)
add_library(flycv_shared STATIC IMPORTED GLOBAL)
set_property(TARGET flycv_shared PROPERTY IMPORTED_LOCATION ${FLYCV_LIB_DIR}/${ANDROID_ABI}/libflycv_shared.so)
list(APPEND FASTDEPLOY_LIBS flycv_shared)
else()
find_library(FLYCV_LIB flycv_shared ${FLYCV_LIB_DIR} NO_DEFAULT_PATH)
list(APPEND FASTDEPLOY_LIBS ${FLYCV_LIB})
endif()
endif()
endif() endif()
if (ENABLE_TEXT) if (ENABLE_TEXT)

130
cmake/flycv.cmake Normal file
View File

@@ -0,0 +1,130 @@
# Copyright (c) 2022 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(ExternalProject)
set(FLYCV_PROJECT "extern_flycv")
set(FLYCV_PREFIX_DIR ${THIRD_PARTY_PATH}/flycv)
set(FLYCV_SOURCE_DIR
${THIRD_PARTY_PATH}/flycv/src/${FLYCV_PROJECT})
set(FLYCV_INSTALL_DIR ${THIRD_PARTY_PATH}/install/flycv)
set(FLYCV_INC_DIR
"${FLYCV_INSTALL_DIR}/include"
CACHE PATH "flycv include directory." FORCE)
if(ANDROID)
set(FLYCV_LIB_DIR
"${FLYCV_INSTALL_DIR}/lib/${ANDROID_ABI}"
CACHE PATH "flycv lib directory." FORCE)
else()
set(FLYCV_LIB_DIR
"${FLYCV_INSTALL_DIR}/lib/"
CACHE PATH "flycv lib directory." FORCE)
endif()
set(CMAKE_BUILD_RPATH "${CMAKE_BUILD_RPATH}"
"${FLYCV_LIB_DIR}")
include_directories(${FLYCV_INC_DIR})
# ABI check
if(ANDROID)
if((NOT ANDROID_ABI MATCHES "armeabi-v7a") AND (NOT ANDROID_ABI MATCHES "arm64-v8a"))
message(FATAL_ERROR "FastDeploy with FlyCV only support armeabi-v7a, arm64-v8a now.")
endif()
if(NOT ANDROID_TOOLCHAIN MATCHES "clang")
message(FATAL_ERROR "Currently, only support clang toolchain while cross compiling FastDeploy for Android with FlyCV, but found ${ANDROID_TOOLCHAIN}.")
endif()
endif()
if(WIN32)
set(FLYCV_COMPILE_LIB
"${FLYCV_INSTALL_DIR}/lib/flycv.lib"
CACHE FILEPATH "flycv compile library." FORCE)
elseif(APPLE)
set(FLYCV_COMPILE_LIB
"${FLYCV_INSTALL_DIR}/lib/libflycv.dylib"
CACHE FILEPATH "flycv compile library." FORCE)
elseif(ANDROID)
set(FLYCV_COMPILE_LIB
"${FLYCV_INSTALL_DIR}/lib/${ANDROID_ABI}/libflycv_shared.so"
CACHE FILEPATH "flycv compile library." FORCE)
else()
set(FLYCV_COMPILE_LIB
"${FLYCV_INSTALL_DIR}/lib/libflycv_shared.so"
CACHE FILEPATH "flycv compile library." FORCE)
endif(WIN32)
set(FLYCV_URL_BASE "https://bj.bcebos.com/fastdeploy/third_libs/")
set(FLYCV_VERSION "1.0.1025")
if(WIN32)
message(FATAL_ERROR "FlyCV is not supported on Windows now.")
set(FLYCV_FILE "flycv-win-x64-${FLYCV_VERSION}.zip")
elseif(APPLE)
message(FATAL_ERROR "FlyCV is not supported on Mac OSX now.")
if(CMAKE_HOST_SYSTEM_PROCESSOR MATCHES "arm64")
set(FLYCV_FILE "flycv-osx-arm64-${FLYCV_VERSION}.tgz")
else()
set(FLYCV_FILE "flycv-osx-x86_64-${FLYCV_VERSION}.tgz")
endif()
elseif(ANDROID)
set(FLYCV_FILE "flycv-android-${FLYCV_VERSION}.tgz")
else()
if(CMAKE_HOST_SYSTEM_PROCESSOR MATCHES "aarch64")
set(FLYCV_FILE "flycv-linux-aarch64-${FLYCV_VERSION}.tgz")
else()
message(FATAL_ERROR "FlyCV is not supported on Linux x64 now.")
set(FLYCV_FILE "flycv-linux-x64-${FLYCV_VERSION}.tgz")
endif()
endif()
set(FLYCV_URL "${FLYCV_URL_BASE}${FLYCV_FILE}")
if(ANDROID)
ExternalProject_Add(
${FLYCV_PROJECT}
${EXTERNAL_PROJECT_LOG_ARGS}
URL ${FLYCV_URL}
PREFIX ${FLYCV_PREFIX_DIR}
DOWNLOAD_NO_PROGRESS 1
CONFIGURE_COMMAND ""
BUILD_COMMAND ""
UPDATE_COMMAND ""
INSTALL_COMMAND
${CMAKE_COMMAND} -E remove_directory ${FLYCV_INSTALL_DIR} &&
${CMAKE_COMMAND} -E make_directory ${FLYCV_INSTALL_DIR} &&
${CMAKE_COMMAND} -E make_directory ${FLYCV_INSTALL_DIR}/lib &&
${CMAKE_COMMAND} -E rename ${FLYCV_SOURCE_DIR}/lib/${ANDROID_ABI}
${FLYCV_LIB_DIR} && ${CMAKE_COMMAND} -E copy_directory
${FLYCV_SOURCE_DIR}/include ${FLYCV_INC_DIR}
BUILD_BYPRODUCTS ${FLYCV_COMPILE_LIB})
else()
ExternalProject_Add(
${FLYCV_PROJECT}
${EXTERNAL_PROJECT_LOG_ARGS}
URL ${FLYCV_URL}
PREFIX ${FLYCV_PREFIX_DIR}
DOWNLOAD_NO_PROGRESS 1
CONFIGURE_COMMAND ""
BUILD_COMMAND ""
UPDATE_COMMAND ""
INSTALL_COMMAND
${CMAKE_COMMAND} -E remove_directory ${FLYCV_INSTALL_DIR} &&
${CMAKE_COMMAND} -E make_directory ${FLYCV_INSTALL_DIR} &&
${CMAKE_COMMAND} -E rename ${FLYCV_SOURCE_DIR}/lib/
${FLYCV_LIB_DIR} && ${CMAKE_COMMAND} -E copy_directory
${FLYCV_SOURCE_DIR}/include ${FLYCV_INC_DIR}
BUILD_BYPRODUCTS ${FLYCV_COMPILE_LIB})
endif()
add_library(external_flycv STATIC IMPORTED GLOBAL)
set_property(TARGET external_flycv PROPERTY IMPORTED_LOCATION
${FLYCV_COMPILE_LIB})
add_dependencies(external_flycv ${FLYCV_PROJECT})

View File

@@ -184,7 +184,7 @@ else()
if (WIN32) if (WIN32)
set(OpenCV_DIR ${OpenCV_DIR}/build) set(OpenCV_DIR ${OpenCV_DIR}/build)
endif() endif()
find_package(OpenCV REQUIRED PATHS ${OpenCV_DIR}) find_package(OpenCV REQUIRED PATHS ${OpenCV_DIR} NO_DEFAULT_PATH)
include_directories(${OpenCV_INCLUDE_DIRS}) include_directories(${OpenCV_INCLUDE_DIRS})
list(APPEND DEPEND_LIBS opencv_core opencv_video opencv_highgui opencv_imgproc opencv_imgcodecs) list(APPEND DEPEND_LIBS opencv_core opencv_video opencv_highgui opencv_imgproc opencv_imgcodecs)
endif() endif()

View File

@@ -23,9 +23,15 @@ set(PADDLELITE_INSTALL_DIR ${THIRD_PARTY_PATH}/install/${PADDLELITE_FILENAME})
set(PADDLELITE_INC_DIR set(PADDLELITE_INC_DIR
"${PADDLELITE_INSTALL_DIR}/include" "${PADDLELITE_INSTALL_DIR}/include"
CACHE PATH "paddlelite include directory." FORCE) CACHE PATH "paddlelite include directory." FORCE)
if(ANDROID)
set(PADDLELITE_LIB_DIR set(PADDLELITE_LIB_DIR
"${PADDLELITE_INSTALL_DIR}/lib/${ANDROID_ABI}" "${PADDLELITE_INSTALL_DIR}/lib/${ANDROID_ABI}"
CACHE PATH "paddlelite lib directory." FORCE) CACHE PATH "paddlelite lib directory." FORCE)
else()
set(PADDLELITE_LIB_DIR
"${PADDLELITE_INSTALL_DIR}/lib/"
CACHE PATH "paddlelite lib directory." FORCE)
endif()
set(CMAKE_BUILD_RPATH "${CMAKE_BUILD_RPATH}" "${PADDLELITE_LIB_DIR}") set(CMAKE_BUILD_RPATH "${CMAKE_BUILD_RPATH}" "${PADDLELITE_LIB_DIR}")
set(PADDLELITE_URL_PREFIX "https://bj.bcebos.com/fastdeploy/third_libs") set(PADDLELITE_URL_PREFIX "https://bj.bcebos.com/fastdeploy/third_libs")

View File

@@ -37,6 +37,12 @@ function(config_fastdeploy_executable_link_flags TARGET_NAME)
endif() endif()
endfunction() endfunction()
# Usage: add_fastdeploy_executable_cc_files(xxx_var vision detection)
function(add_fastdeploy_executable_cc_files CC_FILES_VAR FIELD SUB_FIELD)
file(GLOB_RECURSE _EXAMPLE_SRCS ${PROJECT_SOURCE_DIR}/examples/${FIELD}/${SUB_FIELD}/*/cpp/*.cc)
set(${CC_FILES_VAR} ${_EXAMPLE_SRCS} PARENT_SCOPE)
endfunction()
set(EXAMPLES_NUM 0) set(EXAMPLES_NUM 0)
function(add_fastdeploy_executable FIELD CC_FILE) function(add_fastdeploy_executable FIELD CC_FILE)
# temp target name/file var in function scope # temp target name/file var in function scope
@@ -66,16 +72,26 @@ endfunction()
# vision examples # vision examples
if(BUILD_EXAMPLES AND ENABLE_VISION) if(BUILD_EXAMPLES AND ENABLE_VISION)
if(NOT ENABLE_VISION_VISUALIZE)
message(FATAL_ERROR "ENABLE_VISION_VISUALIZE must be ON while BUILD_EXAMPLES and ENABLE_VISION both ON.")
endif()
if(EXISTS ${PROJECT_SOURCE_DIR}/examples/vision) if(EXISTS ${PROJECT_SOURCE_DIR}/examples/vision)
message(STATUS "") message(STATUS "")
message(STATUS "*************FastDeploy Vision Examples Summary**********") message(STATUS "*************FastDeploy Vision Examples Summary**********")
file(GLOB_RECURSE ALL_VISION_EXAMPLE_SRCS ${PROJECT_SOURCE_DIR}/examples/vision/*/*/cpp/*.cc) set(ALL_VISION_SUD_FIELDS classification
foreach(_CC_FILE ${ALL_VISION_EXAMPLE_SRCS}) detection
facedet
faceid
keypointdetection
matting
ocr
segmentation)
if(NOT ANDROID)
list(APPEND ALL_VISION_SUD_FIELDS tracking)
endif()
foreach(_SUB_FIELD ${ALL_VISION_SUD_FIELDS})
add_fastdeploy_executable_cc_files(_SUB_CC_FILES vision ${_SUB_FIELD})
foreach(_CC_FILE ${_SUB_CC_FILES})
add_fastdeploy_executable(vision ${_CC_FILE}) add_fastdeploy_executable(vision ${_CC_FILE})
endforeach() endforeach()
endforeach()
message(STATUS " [FastDeploy Executable Path] : ${EXECUTABLE_OUTPUT_PATH}") message(STATUS " [FastDeploy Executable Path] : ${EXECUTABLE_OUTPUT_PATH}")
endif() endif()
endif() endif()

View File

@@ -49,8 +49,8 @@
#cmakedefine ENABLE_VISION #cmakedefine ENABLE_VISION
#endif #endif
#ifndef ENABLE_FALCONCV #ifndef ENABLE_FLYCV
#cmakedefine ENABLE_FALCONCV #cmakedefine ENABLE_FLYCV
#endif #endif
#ifndef ENABLE_TEXT #ifndef ENABLE_TEXT
@@ -61,8 +61,10 @@
#cmakedefine ENABLE_OPENCV_CUDA #cmakedefine ENABLE_OPENCV_CUDA
#endif #endif
#ifdef ENABLE_VISION
#ifndef ENABLE_VISION_VISUALIZE #ifndef ENABLE_VISION_VISUALIZE
#cmakedefine ENABLE_VISION_VISUALIZE #define ENABLE_VISION_VISUALIZE
#endif
#endif #endif
#ifndef ENABLE_FDTENSOR_FUNC #ifndef ENABLE_FDTENSOR_FUNC

View File

@@ -28,8 +28,39 @@ bool Processor::operator()(Mat* mat, ProcLib lib) {
target = default_lib; target = default_lib;
} }
bool ret = ImplByOpenCV(mat); if (target == ProcLib::FLYCV) {
return ret; #ifdef ENABLE_FLYCV
if (mat->mat_type != ProcLib::FLYCV) {
if (mat->layout != Layout::HWC) {
FDERROR << "Cannot convert cv::Mat to fcv::Mat while layout is not HWC." << std::endl;
}
fcv::Mat fcv_mat = ConvertOpenCVMatToFalconCV(*(mat->GetOpenCVMat()));
mat->SetMat(fcv_mat);
}
return ImplByFalconCV(mat);
#else
FDASSERT(false, "FastDeploy didn't compile with FalconCV.");
#endif
}
return ImplByOpenCV(mat);
}
void EnableFlyCV() {
#ifdef ENABLE_FLYCV
Processor::default_lib = ProcLib::FLYCV;
FDINFO << "Will change to use image processing library "
<< Processor::default_lib << std::endl;
#else
FDWARNING << "FastDeploy didn't compile with FlyCV, "
"will fallback to use OpenCV instead."
<< std::endl;
#endif
}
void DisableFlyCV() {
Processor::default_lib = ProcLib::OPENCV;
FDINFO << "Will change to use image processing library "
<< Processor::default_lib << std::endl;
} }
} // namespace vision } // namespace vision

View File

@@ -22,7 +22,14 @@
namespace fastdeploy { namespace fastdeploy {
namespace vision { namespace vision {
class Processor { /*! @brief Enable using FlyCV to process image while deploy vision models. Currently, FlyCV in only available on ARM(Linux aarch64/Android), so will fallback to using OpenCV in other platform
*/
FASTDEPLOY_DECL void EnableFlyCV();
/// Disable using FlyCV to process image while deploy vision models.
FASTDEPLOY_DECL void DisableFlyCV();
class FASTDEPLOY_DECL Processor {
public: public:
// default_lib has the highest priority // default_lib has the highest priority
// all the function in `processor` will force to use // all the function in `processor` will force to use

View File

@@ -35,6 +35,39 @@ bool Cast::ImplByOpenCV(Mat* mat) {
return true; return true;
} }
#ifdef ENABLE_FLYCV
bool Cast::ImplByFalconCV(Mat* mat) {
fcv::Mat* im = mat->GetFalconCVMat();
if (dtype_ == "float" && mat->Type() == FDDataType::FP32) {
return true;
}
if (dtype_ == "double" && mat->Type() == FDDataType::FP64) {
return true;
}
if (mat->layout != Layout::HWC) {
FDERROR
<< "While using Falcon to cast image, the image must be layout of HWC."
<< std::endl;
return false;
}
if (dtype_ == "float") {
fcv::Mat new_im;
auto fcv_type = CreateFalconCVDataType(FDDataType::FP32, im->channels());
im->convert_to(new_im, fcv_type);
mat->SetMat(new_im);
} else if (dtype_ == "double") {
fcv::Mat new_im;
auto fcv_type = CreateFalconCVDataType(FDDataType::FP64, im->channels());
im->convert_to(new_im, fcv_type);
mat->SetMat(new_im);
} else {
FDWARNING << "Cast not support for " << dtype_
<< " now! will skip this operation." << std::endl;
}
return true;
}
#endif
bool Cast::Run(Mat* mat, const std::string& dtype, ProcLib lib) { bool Cast::Run(Mat* mat, const std::string& dtype, ProcLib lib) {
auto c = Cast(dtype); auto c = Cast(dtype);
return c(mat, lib); return c(mat, lib);

View File

@@ -19,14 +19,21 @@
namespace fastdeploy { namespace fastdeploy {
namespace vision { namespace vision {
class Cast : public Processor { class FASTDEPLOY_DECL Cast : public Processor {
public: public:
explicit Cast(const std::string& dtype = "float") : dtype_(dtype) {} explicit Cast(const std::string& dtype = "float") : dtype_(dtype) {}
bool ImplByOpenCV(Mat* mat); bool ImplByOpenCV(Mat* mat);
#ifdef ENABLE_FLYCV
bool ImplByFalconCV(Mat* mat);
#endif
std::string Name() { return "Cast"; } std::string Name() { return "Cast"; }
static bool Run(Mat* mat, const std::string& dtype, static bool Run(Mat* mat, const std::string& dtype,
ProcLib lib = ProcLib::OPENCV); ProcLib lib = ProcLib::OPENCV);
std::string GetDtype() const {
return dtype_;
}
private: private:
std::string dtype_; std::string dtype_;
}; };

View File

@@ -28,12 +28,34 @@ bool CenterCrop::ImplByOpenCV(Mat* mat) {
int offset_x = static_cast<int>((width - width_) / 2); int offset_x = static_cast<int>((width - width_) / 2);
int offset_y = static_cast<int>((height - height_) / 2); int offset_y = static_cast<int>((height - height_) / 2);
cv::Rect crop_roi(offset_x, offset_y, width_, height_); cv::Rect crop_roi(offset_x, offset_y, width_, height_);
*im = (*im)(crop_roi); cv::Mat new_im = (*im)(crop_roi).clone();
mat->SetMat(new_im);
mat->SetWidth(width_); mat->SetWidth(width_);
mat->SetHeight(height_); mat->SetHeight(height_);
return true; return true;
} }
#ifdef ENABLE_FLYCV
bool CenterCrop::ImplByFalconCV(Mat* mat) {
fcv::Mat* im = mat->GetFalconCVMat();
int height = static_cast<int>(im->height());
int width = static_cast<int>(im->width());
if (height < height_ || width < width_) {
FDERROR << "[CenterCrop] Image size less than crop size" << std::endl;
return false;
}
int offset_x = static_cast<int>((width - width_) / 2);
int offset_y = static_cast<int>((height - height_) / 2);
fcv::Rect crop_roi(offset_x, offset_y, width_, height_);
fcv::Mat new_im;
fcv::crop(*im, new_im, crop_roi);
mat->SetMat(new_im);
mat->SetWidth(width_);
mat->SetHeight(height_);
return true;
}
#endif
bool CenterCrop::Run(Mat* mat, const int& width, const int& height, bool CenterCrop::Run(Mat* mat, const int& width, const int& height,
ProcLib lib) { ProcLib lib) {
auto c = CenterCrop(width, height); auto c = CenterCrop(width, height);

View File

@@ -19,10 +19,13 @@
namespace fastdeploy { namespace fastdeploy {
namespace vision { namespace vision {
class CenterCrop : public Processor { class FASTDEPLOY_DECL CenterCrop : public Processor {
public: public:
CenterCrop(int width, int height) : height_(height), width_(width) {} CenterCrop(int width, int height) : height_(height), width_(width) {}
bool ImplByOpenCV(Mat* mat); bool ImplByOpenCV(Mat* mat);
#ifdef ENABLE_FLYCV
bool ImplByFalconCV(Mat* mat);
#endif
std::string Name() { return "CenterCrop"; } std::string Name() { return "CenterCrop"; }
static bool Run(Mat* mat, const int& width, const int& height, static bool Run(Mat* mat, const int& width, const int& height,

View File

@@ -24,6 +24,20 @@ bool BGR2RGB::ImplByOpenCV(Mat* mat) {
return true; return true;
} }
#ifdef ENABLE_FLYCV
bool BGR2RGB::ImplByFalconCV(Mat* mat) {
fcv::Mat* im = mat->GetFalconCVMat();
if (im->channels() != 3) {
FDERROR << "[BGR2RGB] The channel of input image must be 3, but not it's " << im->channels() << "." << std::endl;
return false;
}
fcv::Mat new_im;
fcv::cvt_color(*im, new_im, fcv::ColorConvertType::CVT_PA_BGR2PA_RGB);
mat->SetMat(new_im);
return true;
}
#endif
bool RGB2BGR::ImplByOpenCV(Mat* mat) { bool RGB2BGR::ImplByOpenCV(Mat* mat) {
cv::Mat* im = mat->GetOpenCVMat(); cv::Mat* im = mat->GetOpenCVMat();
cv::Mat new_im; cv::Mat new_im;
@@ -32,6 +46,20 @@ bool RGB2BGR::ImplByOpenCV(Mat* mat) {
return true; return true;
} }
#ifdef ENABLE_FLYCV
bool RGB2BGR::ImplByFalconCV(Mat* mat) {
fcv::Mat* im = mat->GetFalconCVMat();
if (im->channels() != 3) {
FDERROR << "[RGB2BGR] The channel of input image must be 3, but not it's " << im->channels() << "." << std::endl;
return false;
}
fcv::Mat new_im;
fcv::cvt_color(*im, new_im, fcv::ColorConvertType::CVT_PA_RGB2PA_BGR);
mat->SetMat(new_im);
return true;
}
#endif
bool BGR2RGB::Run(Mat* mat, ProcLib lib) { bool BGR2RGB::Run(Mat* mat, ProcLib lib) {
auto b = BGR2RGB(); auto b = BGR2RGB();
return b(mat, lib); return b(mat, lib);

View File

@@ -19,17 +19,23 @@
namespace fastdeploy { namespace fastdeploy {
namespace vision { namespace vision {
class BGR2RGB : public Processor { class FASTDEPLOY_DECL BGR2RGB : public Processor {
public: public:
bool ImplByOpenCV(Mat* mat); bool ImplByOpenCV(Mat* mat);
#ifdef ENABLE_FLYCV
bool ImplByFalconCV(Mat* mat);
#endif
virtual std::string Name() { return "BGR2RGB"; } virtual std::string Name() { return "BGR2RGB"; }
static bool Run(Mat* mat, ProcLib lib = ProcLib::OPENCV); static bool Run(Mat* mat, ProcLib lib = ProcLib::OPENCV);
}; };
class RGB2BGR : public Processor { class FASTDEPLOY_DECL RGB2BGR : public Processor {
public: public:
bool ImplByOpenCV(Mat* mat); bool ImplByOpenCV(Mat* mat);
#ifdef ENABLE_FLYCV
bool ImplByFalconCV(Mat* mat);
#endif
std::string Name() { return "RGB2BGR"; } std::string Name() { return "RGB2BGR"; }
static bool Run(Mat* mat, ProcLib lib = ProcLib::OPENCV); static bool Run(Mat* mat, ProcLib lib = ProcLib::OPENCV);

View File

@@ -39,6 +39,23 @@ bool Convert::ImplByOpenCV(Mat* mat) {
return true; return true;
} }
#ifdef ENABLE_FLYCV
bool Convert::ImplByFalconCV(Mat* mat) {
fcv::Mat* im = mat->GetFalconCVMat();
FDASSERT(im->channels() == 3, "Only support 3-channels image in FalconCV.");
std::vector<float> mean(3, 0);
std::vector<float> std(3, 0);
for (size_t i = 0; i < 3; ++i) {
std[i] = 1.0 / alpha_[i];
mean[i] = -1 * beta_[i] * std[i];
}
fcv::Mat new_im;
fcv::normalize_to_submean_to_reorder(*im, mean, std, std::vector<uint32_t>(), new_im, true);
mat->SetMat(new_im);
return true;
}
#endif
bool Convert::Run(Mat* mat, const std::vector<float>& alpha, bool Convert::Run(Mat* mat, const std::vector<float>& alpha,
const std::vector<float>& beta, ProcLib lib) { const std::vector<float>& beta, ProcLib lib) {
auto c = Convert(alpha, beta); auto c = Convert(alpha, beta);

View File

@@ -18,11 +18,14 @@
namespace fastdeploy { namespace fastdeploy {
namespace vision { namespace vision {
class Convert : public Processor { class FASTDEPLOY_DECL Convert : public Processor {
public: public:
Convert(const std::vector<float>& alpha, const std::vector<float>& beta); Convert(const std::vector<float>& alpha, const std::vector<float>& beta);
bool ImplByOpenCV(Mat* mat); bool ImplByOpenCV(Mat* mat);
#ifdef ENABLE_FLYCV
bool ImplByFalconCV(Mat* mat);
#endif
std::string Name() { return "Convert"; } std::string Name() { return "Convert"; }
// Compute `result = mat * alpha + beta` directly by channel. // Compute `result = mat * alpha + beta` directly by channel.

View File

@@ -29,12 +29,35 @@ bool Crop::ImplByOpenCV(Mat* mat) {
return false; return false;
} }
cv::Rect crop_roi(offset_w_, offset_h_, width_, height_); cv::Rect crop_roi(offset_w_, offset_h_, width_, height_);
*im = (*im)(crop_roi); cv::Mat new_im = (*im)(crop_roi).clone();
mat->SetMat(new_im);
mat->SetWidth(width_); mat->SetWidth(width_);
mat->SetHeight(height_); mat->SetHeight(height_);
return true; return true;
} }
#ifdef ENABLE_FLYCV
bool Crop::ImplByFalconCV(Mat* mat) {
fcv::Mat* im = mat->GetFalconCVMat();
int height = static_cast<int>(im->height());
int width = static_cast<int>(im->width());
if (height < height_ + offset_h_ || width < width_ + offset_w_) {
FDERROR << "[Crop] Cannot crop [" << height_ << ", " << width_
<< "] from the input image [" << height << ", " << width
<< "], with offset [" << offset_h_ << ", " << offset_w_ << "]."
<< std::endl;
return false;
}
fcv::Rect crop_roi(offset_w_, offset_h_, width_, height_);
fcv::Mat new_im;
fcv::crop(*im, new_im, crop_roi);
mat->SetMat(new_im);
mat->SetWidth(width_);
mat->SetHeight(height_);
return true;
}
#endif
bool Crop::Run(Mat* mat, int offset_w, int offset_h, int width, int height, bool Crop::Run(Mat* mat, int offset_w, int offset_h, int width, int height,
ProcLib lib) { ProcLib lib) {
auto c = Crop(offset_w, offset_h, width, height); auto c = Crop(offset_w, offset_h, width, height);

View File

@@ -19,7 +19,7 @@
namespace fastdeploy { namespace fastdeploy {
namespace vision { namespace vision {
class Crop : public Processor { class FASTDEPLOY_DECL Crop : public Processor {
public: public:
Crop(int offset_w, int offset_h, int width, int height) { Crop(int offset_w, int offset_h, int width, int height) {
offset_w_ = offset_w; offset_w_ = offset_w;
@@ -29,6 +29,10 @@ class Crop : public Processor {
} }
bool ImplByOpenCV(Mat* mat); bool ImplByOpenCV(Mat* mat);
#ifdef ENABLE_FLYCV
bool ImplByFalconCV(Mat* mat);
#endif
std::string Name() { return "Crop"; } std::string Name() { return "Crop"; }
static bool Run(Mat* mat, int offset_w, int offset_h, int width, int height, static bool Run(Mat* mat, int offset_w, int offset_h, int width, int height,

View File

@@ -13,6 +13,7 @@
// limitations under the License. // limitations under the License.
#include "fastdeploy/vision/common/processors/hwc2chw.h" #include "fastdeploy/vision/common/processors/hwc2chw.h"
#include "fastdeploy/function/transpose.h"
namespace fastdeploy { namespace fastdeploy {
namespace vision { namespace vision {
@@ -28,11 +29,7 @@ bool HWC2CHW::ImplByOpenCV(Mat* mat) {
int rw = im->cols; int rw = im->cols;
int rc = im->channels(); int rc = im->channels();
// float* data = reinterpret_cast<float*>(im->data);
for (int i = 0; i < rc; ++i) { for (int i = 0; i < rc; ++i) {
// cv::extractChannel(im_clone, cv::Mat(rh, rw, im->type() % 8, data + i
// * rh * rw),
// i);
cv::extractChannel( cv::extractChannel(
im_clone, im_clone,
cv::Mat(rh, rw, im->type() % 8, cv::Mat(rh, rw, im->type() % 8,
@@ -43,6 +40,25 @@ bool HWC2CHW::ImplByOpenCV(Mat* mat) {
return true; return true;
} }
#ifdef ENABLE_FLYCV
bool HWC2CHW::ImplByFalconCV(Mat* mat) {
if (mat->layout != Layout::HWC) {
FDERROR << "HWC2CHW: The input data is not Layout::HWC format!" << std::endl;
return false;
}
if (mat->Type() != FDDataType::FP32) {
FDERROR << "HWC2CHW: Only support float data while use FalconCV, but now it's " << mat->Type() << "." << std::endl;
return false;
}
fcv::Mat* im = mat->GetFalconCVMat();
fcv::Mat new_im;
fcv::normalize_to_submean_to_reorder(*im, {0.0, 0.0, 0.0}, {1.0, 1.0, 1.0}, std::vector<uint32_t>(), new_im, false);
mat->SetMat(new_im);
mat->layout = Layout::CHW;
return true;
}
#endif
bool HWC2CHW::Run(Mat* mat, ProcLib lib) { bool HWC2CHW::Run(Mat* mat, ProcLib lib) {
auto h = HWC2CHW(); auto h = HWC2CHW();
return h(mat, lib); return h(mat, lib);

View File

@@ -19,9 +19,12 @@
namespace fastdeploy { namespace fastdeploy {
namespace vision { namespace vision {
class HWC2CHW : public Processor { class FASTDEPLOY_DECL HWC2CHW : public Processor {
public: public:
bool ImplByOpenCV(Mat* mat); bool ImplByOpenCV(Mat* mat);
#ifdef ENABLE_FLYCV
bool ImplByFalconCV(Mat* mat);
#endif
std::string Name() { return "HWC2CHW"; } std::string Name() { return "HWC2CHW"; }
static bool Run(Mat* mat, ProcLib lib = ProcLib::OPENCV); static bool Run(Mat* mat, ProcLib lib = ProcLib::OPENCV);

View File

@@ -23,6 +23,12 @@ bool LimitByStride::ImplByOpenCV(Mat* mat) {
int origin_h = im->rows; int origin_h = im->rows;
int rw = origin_w - origin_w % stride_; int rw = origin_w - origin_w % stride_;
int rh = origin_h - origin_h % stride_; int rh = origin_h - origin_h % stride_;
if (rw == 0) {
rw = stride_;
}
if (rh == 0) {
rh = stride_;
}
if (rw != origin_w || rh != origin_w) { if (rw != origin_w || rh != origin_w) {
cv::resize(*im, *im, cv::Size(rw, rh), 0, 0, interp_); cv::resize(*im, *im, cv::Size(rw, rh), 0, 0, interp_);
mat->SetWidth(im->cols); mat->SetWidth(im->cols);
@@ -31,6 +37,46 @@ bool LimitByStride::ImplByOpenCV(Mat* mat) {
return true; return true;
} }
#ifdef ENABLE_FLYCV
bool LimitByStride::ImplByFalconCV(Mat* mat) {
fcv::Mat* im = mat->GetFalconCVMat();
int origin_w = im->width();
int origin_h = im->height();
int rw = origin_w - origin_w % stride_;
int rh = origin_h - origin_h % stride_;
if (rw == 0) {
rw = stride_;
}
if (rh == 0) {
rh = stride_;
}
if (rw != origin_w || rh != origin_h) {
auto interp_method = fcv::InterpolationType::INTER_LINEAR;
if (interp_ == 0) {
interp_method = fcv::InterpolationType::INTER_NEAREST;
} else if (interp_ == 1) {
interp_method = fcv::InterpolationType::INTER_LINEAR;
} else if (interp_ == 2) {
interp_method = fcv::InterpolationType::INTER_CUBIC;
} else {
FDERROR << "LimitByStride: Only support interp_ be 0/1/2 with FalconCV, but "
"now it's "
<< interp_ << "." << std::endl;
return false;
}
fcv::Mat new_im;
FDERROR << "Before " << im->width() << " " << im->height() << std::endl;
fcv::resize(*im, new_im, fcv::Size(rw, rh), 0, 0, interp_method);
FDERROR << "After " << new_im.width() << " " << new_im.height() << std::endl;
mat->SetMat(new_im);
mat->SetWidth(new_im.width());
mat->SetHeight(new_im.height());
}
return true;
}
#endif
bool LimitByStride::Run(Mat* mat, int stride, int interp, ProcLib lib) { bool LimitByStride::Run(Mat* mat, int stride, int interp, ProcLib lib) {
auto r = LimitByStride(stride, interp); auto r = LimitByStride(stride, interp);
return r(mat, lib); return r(mat, lib);

View File

@@ -19,7 +19,7 @@
namespace fastdeploy { namespace fastdeploy {
namespace vision { namespace vision {
class LimitByStride : public Processor { class FASTDEPLOY_DECL LimitByStride : public Processor {
public: public:
explicit LimitByStride(int stride = 32, int interp = 1) { explicit LimitByStride(int stride = 32, int interp = 1) {
stride_ = stride; stride_ = stride;
@@ -27,8 +27,10 @@ class LimitByStride : public Processor {
} }
// Resize Mat* mat to make the size divisible by stride_. // Resize Mat* mat to make the size divisible by stride_.
bool ImplByOpenCV(Mat* mat); bool ImplByOpenCV(Mat* mat);
#ifdef ENABLE_FLYCV
bool ImplByFalconCV(Mat* mat);
#endif
std::string Name() { return "LimitByStride"; } std::string Name() { return "LimitByStride"; }
static bool Run(Mat* mat, int stride = 32, int interp = 1, static bool Run(Mat* mat, int stride = 32, int interp = 1,

View File

@@ -38,6 +38,50 @@ bool LimitLong::ImplByOpenCV(Mat* mat) {
return true; return true;
} }
#ifdef ENABLE_FLYCV
bool LimitLong::ImplByFalconCV(Mat* mat) {
fcv::Mat* im = mat->GetFalconCVMat();
int origin_w = im->width();
int origin_h = im->height();
int im_size_max = std::max(origin_w, origin_h);
int target = im_size_max;
if (max_long_ > 0 && im_size_max > max_long_) {
target = max_long_;
} else if (min_long_ > 0 && im_size_max < min_long_) {
target = min_long_;
}
if (target != im_size_max) {
double scale =
static_cast<double>(target) / static_cast<double>(im_size_max);
if (fabs(scale - 1.0) < 1e-06) {
return true;
}
auto interp_method = fcv::InterpolationType::INTER_LINEAR;
if (interp_ == 0) {
interp_method = fcv::InterpolationType::INTER_NEAREST;
} else if (interp_ == 1) {
interp_method = fcv::InterpolationType::INTER_LINEAR;
} else if (interp_ == 2) {
interp_method = fcv::InterpolationType::INTER_CUBIC;
} else {
FDERROR << "LimitLong: Only support interp_ be 0/1/2 with FalconCV, but "
"now it's "
<< interp_ << "." << std::endl;
return false;
}
fcv::Mat new_im;
FDERROR << "origin " << im->width() << " " << im->height() << std::endl;
FDERROR << "scale " << scale << std::endl;
fcv::resize(*im, new_im, fcv::Size(), scale, scale, interp_method);
FDERROR << "after " << new_im.width() << " " << new_im.height() << std::endl;
mat->SetMat(new_im);
mat->SetWidth(new_im.width());
mat->SetHeight(new_im.height());
}
return true;
}
#endif
bool LimitLong::Run(Mat* mat, int max_long, int min_long, int interp, ProcLib lib) { bool LimitLong::Run(Mat* mat, int max_long, int min_long, int interp, ProcLib lib) {
auto l = LimitLong(max_long, min_long, interp); auto l = LimitLong(max_long, min_long, interp);
return l(mat, lib); return l(mat, lib);

View File

@@ -19,7 +19,7 @@
namespace fastdeploy { namespace fastdeploy {
namespace vision { namespace vision {
class LimitLong : public Processor { class FASTDEPLOY_DECL LimitLong : public Processor {
public: public:
explicit LimitLong(int max_long = -1, int min_long = -1, int interp = 1) { explicit LimitLong(int max_long = -1, int min_long = -1, int interp = 1) {
max_long_ = max_long; max_long_ = max_long;
@@ -33,6 +33,9 @@ class LimitLong : public Processor {
// If the long edge is smaller than min_long_, resize the long edge // If the long edge is smaller than min_long_, resize the long edge
// to min_long_, while scale the short edge proportionally. // to min_long_, while scale the short edge proportionally.
bool ImplByOpenCV(Mat* mat); bool ImplByOpenCV(Mat* mat);
#ifdef ENABLE_FLYCV
bool ImplByFalconCV(Mat* mat);
#endif
std::string Name() { return "LimitLong"; } std::string Name() { return "LimitLong"; }
static bool Run(Mat* mat, int max_long = -1, int min_long = -1, static bool Run(Mat* mat, int max_long = -1, int min_long = -1,

View File

@@ -32,7 +32,7 @@ bool LimitShort::ImplByOpenCV(Mat* mat) {
if (target != im_size_min) { if (target != im_size_min) {
scale = static_cast<double>(target) / static_cast<double>(im_size_min); scale = static_cast<double>(target) / static_cast<double>(im_size_min);
} }
if (scale > 0) { if (fabs(scale - 1.0) > 1e-06) {
cv::resize(*im, *im, cv::Size(), scale, scale, interp_); cv::resize(*im, *im, cv::Size(), scale, scale, interp_);
mat->SetWidth(im->cols); mat->SetWidth(im->cols);
mat->SetHeight(im->rows); mat->SetHeight(im->rows);
@@ -40,6 +40,47 @@ bool LimitShort::ImplByOpenCV(Mat* mat) {
return true; return true;
} }
#ifdef ENABLE_FLYCV
bool LimitShort::ImplByFalconCV(Mat* mat) {
fcv::Mat* im = mat->GetFalconCVMat();
int origin_w = im->width();
int origin_h = im->height();
int im_size_min = std::min(origin_w, origin_h);
int target = im_size_min;
if (max_short_ > 0 && im_size_min > max_short_) {
target = max_short_;
} else if (min_short_ > 0 && im_size_min < min_short_) {
target = min_short_;
}
double scale = -1.f;
if (target != im_size_min) {
scale = static_cast<double>(target) / static_cast<double>(im_size_min);
}
if (fabs(scale - 1.0) > 1e-06) {
auto interp_method = fcv::InterpolationType::INTER_LINEAR;
if (interp_ == 0) {
interp_method = fcv::InterpolationType::INTER_NEAREST;
} else if (interp_ == 1) {
interp_method = fcv::InterpolationType::INTER_LINEAR;
} else if (interp_ == 2) {
interp_method = fcv::InterpolationType::INTER_CUBIC;
} else {
FDERROR << "LimitLong: Only support interp_ be 0/1/2 with FalconCV, but "
"now it's "
<< interp_ << "." << std::endl;
return false;
}
fcv::Mat new_im;
fcv::resize(*im, new_im, fcv::Size(), scale, scale, interp_method);
mat->SetMat(new_im);
mat->SetWidth(new_im.width());
mat->SetHeight(new_im.height());
}
return true;
}
#endif
bool LimitShort::Run(Mat* mat, int max_short, int min_short, int interp, ProcLib lib) { bool LimitShort::Run(Mat* mat, int max_short, int min_short, int interp, ProcLib lib) {
auto l = LimitShort(max_short, min_short, interp); auto l = LimitShort(max_short, min_short, interp);
return l(mat, lib); return l(mat, lib);

View File

@@ -33,6 +33,9 @@ class LimitShort : public Processor {
// If the short edge is smaller than min_short_, resize the short edge // If the short edge is smaller than min_short_, resize the short edge
// to min_short_, while scale the long edge proportionally. // to min_short_, while scale the long edge proportionally.
bool ImplByOpenCV(Mat* mat); bool ImplByOpenCV(Mat* mat);
#ifdef ENABLE_FLYCV
bool ImplByFalconCV(Mat* mat);
#endif
std::string Name() { return "LimitShort"; } std::string Name() { return "LimitShort"; }
static bool Run(Mat* mat, int max_short = -1, int min_short = -1, static bool Run(Mat* mat, int max_short = -1, int min_short = -1,

View File

@@ -19,8 +19,8 @@ namespace fastdeploy {
namespace vision { namespace vision {
void* Mat::Data() { void* Mat::Data() {
if (mat_type == ProcLib::FALCONCV) { if (mat_type == ProcLib::FLYCV) {
#ifdef ENABLE_FALCONCV #ifdef ENABLE_FLYCV
return fcv_mat.data(); return fcv_mat.data();
#else #else
FDASSERT(false, "FastDeploy didn't compile with FalconCV, but met data type with fcv::Mat."); FDASSERT(false, "FastDeploy didn't compile with FalconCV, but met data type with fcv::Mat.");
@@ -52,8 +52,8 @@ bool Mat::CopyToTensor(FDTensor* tensor) {
} }
void Mat::PrintInfo(const std::string& flag) { void Mat::PrintInfo(const std::string& flag) {
if (mat_type == ProcLib::FALCONCV) { if (mat_type == ProcLib::FLYCV) {
#ifdef ENABLE_FALCONCV #ifdef ENABLE_FLYCV
fcv::Scalar mean = fcv::mean(fcv_mat); fcv::Scalar mean = fcv::mean(fcv_mat);
std::cout << flag << ": " std::cout << flag << ": "
<< "DataType=" << Type() << ", " << "DataType=" << Type() << ", "
@@ -85,8 +85,8 @@ void Mat::PrintInfo(const std::string& flag) {
FDDataType Mat::Type() { FDDataType Mat::Type() {
int type = -1; int type = -1;
if (mat_type == ProcLib::FALCONCV) { if (mat_type == ProcLib::FLYCV) {
#ifdef ENABLE_FALCONCV #ifdef ENABLE_FLYCV
return FalconCVDataTypeToFD(fcv_mat.type()); return FalconCVDataTypeToFD(fcv_mat.type());
#else #else
FDASSERT(false, "FastDeploy didn't compile with FalconCV, but met data type with fcv::Mat."); FDASSERT(false, "FastDeploy didn't compile with FalconCV, but met data type with fcv::Mat.");
@@ -146,6 +146,25 @@ Mat CreateFromTensor(const FDTensor& tensor) {
return mat; return mat;
} }
std::ostream& operator<<(std::ostream& out,const ProcLib& p) {
switch (p) {
case ProcLib::DEFAULT:
out << "ProcLib::DEFAULT";
break;
case ProcLib::OPENCV:
out << "ProcLib::OPENCV";
break;
case ProcLib::FLYCV:
out << "ProcLib::FLYCV";
break;
default:
FDASSERT(false, "Unknow type of ProcLib.");
}
return out;
}
} // namespace vision } // namespace vision
} // namespace fastdeploy } // namespace fastdeploy

View File

@@ -14,24 +14,16 @@
#pragma once #pragma once
#include "fastdeploy/core/fd_tensor.h" #include "fastdeploy/core/fd_tensor.h"
#include "opencv2/core/core.hpp" #include "opencv2/core/core.hpp"
#include "fastdeploy/vision/common/processors/utils.h"
#ifdef ENABLE_OPENCV_CUDA
#include "opencv2/core/cuda.hpp"
#include "opencv2/cudaarithm.hpp"
#include "opencv2/cudaimgproc.hpp"
#include "opencv2/cudawarping.hpp"
#endif
namespace fcv {
class Mat;
} // namespace fcv
namespace fastdeploy { namespace fastdeploy {
namespace vision { namespace vision {
enum ProcLib { DEFAULT, OPENCV, FALCONCV}; enum class FASTDEPLOY_DECL ProcLib { DEFAULT, OPENCV, FLYCV};
enum Layout { HWC, CHW }; enum Layout { HWC, CHW };
FASTDEPLOY_DECL std::ostream& operator<<(std::ostream& out, const ProcLib& p);
struct FASTDEPLOY_DECL Mat { struct FASTDEPLOY_DECL Mat {
explicit Mat(cv::Mat& mat) { explicit Mat(cv::Mat& mat) {
cpu_mat = mat; cpu_mat = mat;
@@ -56,19 +48,20 @@ struct FASTDEPLOY_DECL Mat {
return &cpu_mat; return &cpu_mat;
} }
inline const cv::Mat* GetOpenCVMat() const { inline const cv::Mat* GetOpenCVMat() const {
FDASSERT(mat_type == ProcLib::OPENCV, "Met non cv::Mat data structure."); FDASSERT(mat_type == ProcLib::OPENCV, "Met non cv::Mat data structure.");
return &cpu_mat; return &cpu_mat;
} }
#ifdef ENABLE_FALCONCV #ifdef ENABLE_FLYCV
void SetMat(const fcv::Mat& mat) { void SetMat(const fcv::Mat& mat) {
fcv_mat = mat; fcv_mat = mat;
mat_type = Proclib::FALCONCV; mat_type = ProcLib::FLYCV;
} }
inline fcv::Mat* GetFalconCVMat() { inline fcv::Mat* GetFalconCVMat() {
FDASSERT(mat_type == ProcLib::FALCONCV, "Met non fcv::Mat data strucure."); FDASSERT(mat_type == ProcLib::FLYCV, "Met non fcv::Mat data strucure.");
return &fcv_mat; return &fcv_mat;
} }
#endif #endif
@@ -81,7 +74,7 @@ struct FASTDEPLOY_DECL Mat {
int width; int width;
cv::Mat cpu_mat; cv::Mat cpu_mat;
#ifdef ENABLE_FALCONCV #ifdef ENABLE_FLYCV
fcv::Mat fcv_mat; fcv::Mat fcv_mat;
#endif #endif

View File

@@ -54,6 +54,7 @@ Normalize::Normalize(const std::vector<float>& mean,
bool Normalize::ImplByOpenCV(Mat* mat) { bool Normalize::ImplByOpenCV(Mat* mat) {
cv::Mat* im = mat->GetOpenCVMat(); cv::Mat* im = mat->GetOpenCVMat();
std::vector<cv::Mat> split_im; std::vector<cv::Mat> split_im;
cv::split(*im, split_im); cv::split(*im, split_im);
for (int c = 0; c < im->channels(); c++) { for (int c = 0; c < im->channels(); c++) {
@@ -63,6 +64,28 @@ bool Normalize::ImplByOpenCV(Mat* mat) {
return true; return true;
} }
#ifdef ENABLE_FLYCV
bool Normalize::ImplByFalconCV(Mat* mat) {
fcv::Mat* im = mat->GetFalconCVMat();
if (im->channels() != 3) {
FDERROR << "Only supports 3-channels image in FalconCV, but now it's " << im->channels() << "." << std::endl;
return false;
}
std::vector<float> mean(3, 0);
std::vector<float> std(3, 0);
for (size_t i = 0; i < 3; ++i) {
std[i] = 1.0 / alpha_[i];
mean[i] = -1 * beta_[i] * std[i];
}
fcv::Mat new_im(im->width(), im->height(), fcv::FCVImageType::PACKAGE_BGR_F32);
fcv::normalize_to_submean_to_reorder(*im, mean, std, std::vector<uint32_t>(), new_im, true);
mat->SetMat(new_im);
return true;
}
#endif
bool Normalize::Run(Mat* mat, const std::vector<float>& mean, bool Normalize::Run(Mat* mat, const std::vector<float>& mean,
const std::vector<float>& std, bool is_scale, const std::vector<float>& std, bool is_scale,
const std::vector<float>& min, const std::vector<float>& min,

View File

@@ -18,13 +18,16 @@
namespace fastdeploy { namespace fastdeploy {
namespace vision { namespace vision {
class Normalize : public Processor { class FASTDEPLOY_DECL Normalize : public Processor {
public: public:
Normalize(const std::vector<float>& mean, const std::vector<float>& std, Normalize(const std::vector<float>& mean, const std::vector<float>& std,
bool is_scale = true, bool is_scale = true,
const std::vector<float>& min = std::vector<float>(), const std::vector<float>& min = std::vector<float>(),
const std::vector<float>& max = std::vector<float>()); const std::vector<float>& max = std::vector<float>());
bool ImplByOpenCV(Mat* mat); bool ImplByOpenCV(Mat* mat);
#ifdef ENABLE_FLYCV
bool ImplByFalconCV(Mat* mat);
#endif
std::string Name() { return "Normalize"; } std::string Name() { return "Normalize"; }
// While use normalize, it is more recommend not use this function // While use normalize, it is more recommend not use this function
@@ -42,6 +45,14 @@ class Normalize : public Processor {
const std::vector<float>& min = std::vector<float>(), const std::vector<float>& min = std::vector<float>(),
const std::vector<float>& max = std::vector<float>(), const std::vector<float>& max = std::vector<float>(),
ProcLib lib = ProcLib::OPENCV); ProcLib lib = ProcLib::OPENCV);
std::vector<float> GetAlpha() const {
return alpha_;
}
std::vector<float> GetBeta() const {
return beta_;
}
private: private:
std::vector<float> alpha_; std::vector<float> alpha_;
std::vector<float> beta_; std::vector<float> beta_;

View File

@@ -0,0 +1,111 @@
// Copyright (c) 2022 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/vision/common/processors/normalize_and_permute.h"
namespace fastdeploy {
namespace vision {
NormalizeAndPermute::NormalizeAndPermute(const std::vector<float>& mean,
const std::vector<float>& std, bool is_scale,
const std::vector<float>& min,
const std::vector<float>& max) {
FDASSERT(mean.size() == std.size(),
"Normalize: requires the size of mean equal to the size of std.");
std::vector<double> mean_(mean.begin(), mean.end());
std::vector<double> std_(std.begin(), std.end());
std::vector<double> min_(mean.size(), 0.0);
std::vector<double> max_(mean.size(), 255.0);
if (min.size() != 0) {
FDASSERT(
min.size() == mean.size(),
"Normalize: while min is defined, requires the size of min equal to "
"the size of mean.");
min_.assign(min.begin(), min.end());
}
if (max.size() != 0) {
FDASSERT(
min.size() == mean.size(),
"Normalize: while max is defined, requires the size of max equal to "
"the size of mean.");
max_.assign(max.begin(), max.end());
}
for (auto c = 0; c < mean_.size(); ++c) {
double alpha = 1.0;
if (is_scale) {
alpha /= (max_[c] - min_[c]);
}
double beta = -1.0 * (mean_[c] + min_[c] * alpha) / std_[c];
alpha /= std_[c];
alpha_.push_back(alpha);
beta_.push_back(beta);
}
}
bool NormalizeAndPermute::ImplByOpenCV(Mat* mat) {
cv::Mat* im = mat->GetOpenCVMat();
int origin_w = im->cols;
int origin_h = im->rows;
std::vector<cv::Mat> split_im;
cv::split(*im, split_im);
for (int c = 0; c < im->channels(); c++) {
split_im[c].convertTo(split_im[c], CV_32FC1, alpha_[c], beta_[c]);
}
cv::Mat res(origin_h, origin_w, CV_32FC(im->channels()));
for (int i = 0; i < im->channels(); ++i) {
cv::extractChannel(split_im[i], cv::Mat(origin_h, origin_w, CV_32FC1, res.ptr() + i * origin_h * origin_w * 4), 0);
}
mat->SetMat(res);
mat->layout = Layout::CHW;
return true;
}
#ifdef ENABLE_FLYCV
bool NormalizeAndPermute::ImplByFalconCV(Mat* mat) {
if (mat->layout != Layout::HWC) {
FDERROR << "Only supports input with HWC layout." << std::endl;
return false;
}
fcv::Mat* im = mat->GetFalconCVMat();
if (im->channels() != 3) {
FDERROR << "Only supports 3-channels image in FalconCV, but now it's " << im->channels() << "." << std::endl;
return false;
}
std::vector<float> mean(3, 0);
std::vector<float> std(3, 0);
for (size_t i = 0; i < 3; ++i) {
std[i] = 1.0 / alpha_[i];
mean[i] = -1 * beta_[i] * std[i];
}
fcv::Mat new_im;
fcv::normalize_to_submean_to_reorder(*im, mean, std, std::vector<uint32_t>(), new_im, false);
mat->SetMat(new_im);
mat->layout = Layout::CHW;
return true;
}
#endif
bool NormalizeAndPermute::Run(Mat* mat, const std::vector<float>& mean,
const std::vector<float>& std, bool is_scale,
const std::vector<float>& min,
const std::vector<float>& max, ProcLib lib) {
auto n = NormalizeAndPermute(mean, std, is_scale, min, max);
return n(mat, lib);
}
} // namespace vision
} // namespace fastdeploy

View File

@@ -0,0 +1,67 @@
// Copyright (c) 2022 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/vision/common/processors/base.h"
namespace fastdeploy {
namespace vision {
class FASTDEPLOY_DECL NormalizeAndPermute : public Processor {
public:
NormalizeAndPermute(const std::vector<float>& mean,
const std::vector<float>& std,
bool is_scale = true,
const std::vector<float>& min = std::vector<float>(),
const std::vector<float>& max = std::vector<float>());
bool ImplByOpenCV(Mat* mat);
#ifdef ENABLE_FLYCV
bool ImplByFalconCV(Mat* mat);
#endif
std::string Name() { return "NormalizeAndPermute"; }
// While use normalize, it is more recommend not use this function
// this function will need to compute result = ((mat / 255) - mean) / std
// if we use the following method
// ```
// auto norm = Normalize(...)
// norm(mat)
// ```
// There will be some precomputation in contruct function
// and the `norm(mat)` only need to compute result = mat * alpha + beta
// which will reduce lots of time
static bool Run(Mat* mat, const std::vector<float>& mean,
const std::vector<float>& std, bool is_scale = true,
const std::vector<float>& min = std::vector<float>(),
const std::vector<float>& max = std::vector<float>(),
ProcLib lib = ProcLib::OPENCV);
void SetAlpha(const std::vector<float>& alpha) {
alpha_.clear();
std::vector<float>().swap(alpha_);
alpha_.assign(alpha.begin(), alpha.end());
}
void SetBeta(const std::vector<float>& beta) {
beta_.clear();
std::vector<float>().swap(beta_);
beta_.assign(beta.begin(), beta.end());
}
private:
std::vector<float> alpha_;
std::vector<float> beta_;
};
} // namespace vision
} // namespace fastdeploy

View File

@@ -52,6 +52,45 @@ bool Pad::ImplByOpenCV(Mat* mat) {
return true; return true;
} }
#ifdef ENABLE_FLYCV
bool Pad::ImplByFalconCV(Mat* mat) {
if (mat->layout != Layout::HWC) {
FDERROR << "Pad: The input data must be Layout::HWC format!" << std::endl;
return false;
}
if (mat->Channels() > 4) {
FDERROR << "Pad: Only support channels <= 4." << std::endl;
return false;
}
if (mat->Channels() != value_.size()) {
FDERROR << "Pad: Require input channels equals to size of padding value, "
"but now channels = "
<< mat->Channels()
<< ", the size of padding values = " << value_.size() << "."
<< std::endl;
return false;
}
fcv::Mat* im = mat->GetFalconCVMat();
fcv::Scalar value;
if (value_.size() == 1) {
value = fcv::Scalar(value_[0]);
} else if (value_.size() == 2) {
value = fcv::Scalar(value_[0], value_[1]);
} else if (value_.size() == 3) {
value = fcv::Scalar(value_[0], value_[1], value_[2]);
} else {
value = fcv::Scalar(value_[0], value_[1], value_[2], value_[3]);
}
fcv::Mat new_im;
fcv::copy_make_border(*im, new_im, top_, bottom_, left_, right_,
fcv::BorderTypes::BORDER_CONSTANT, value);
mat->SetMat(new_im);
mat->SetHeight(new_im.height());
mat->SetWidth(new_im.width());
return true;
}
#endif
bool Pad::Run(Mat* mat, const int& top, const int& bottom, const int& left, bool Pad::Run(Mat* mat, const int& top, const int& bottom, const int& left,
const int& right, const std::vector<float>& value, const int& right, const std::vector<float>& value,
ProcLib lib) { ProcLib lib) {

View File

@@ -19,7 +19,7 @@
namespace fastdeploy { namespace fastdeploy {
namespace vision { namespace vision {
class Pad : public Processor { class FASTDEPLOY_DECL Pad : public Processor {
public: public:
Pad(int top, int bottom, int left, int right, Pad(int top, int bottom, int left, int right,
const std::vector<float>& value) { const std::vector<float>& value) {
@@ -30,6 +30,9 @@ class Pad : public Processor {
value_ = value; value_ = value;
} }
bool ImplByOpenCV(Mat* mat); bool ImplByOpenCV(Mat* mat);
#ifdef ENABLE_FLYCV
bool ImplByFalconCV(Mat* mat);
#endif
std::string Name() { return "Pad"; } std::string Name() { return "Pad"; }
static bool Run(Mat* mat, const int& top, const int& bottom, const int& left, static bool Run(Mat* mat, const int& top, const int& bottom, const int& left,

View File

@@ -75,6 +75,68 @@ bool PadToSize::ImplByOpenCV(Mat* mat) {
return true; return true;
} }
#ifdef ENABLE_FLYCV
bool PadToSize::ImplByFalconCV(Mat* mat) {
if (width_ == -1 || height_ == -1) {
return true;
}
if (mat->layout != Layout::HWC) {
FDERROR << "PadToSize: The input data must be Layout::HWC format!"
<< std::endl;
return false;
}
if (mat->Channels() > 4) {
FDERROR << "PadToSize: Only support channels <= 4." << std::endl;
return false;
}
if (mat->Channels() != value_.size()) {
FDERROR
<< "PadToSize: Require input channels equals to size of padding value, "
"but now channels = "
<< mat->Channels() << ", the size of padding values = " << value_.size()
<< "." << std::endl;
return false;
}
int origin_w = mat->Width();
int origin_h = mat->Height();
if (origin_w > width_) {
FDERROR << "PadToSize: the input width:" << origin_w
<< " is greater than the target width: " << width_ << "."
<< std::endl;
return false;
}
if (origin_h > height_) {
FDERROR << "PadToSize: the input height:" << origin_h
<< " is greater than the target height: " << height_ << "."
<< std::endl;
return false;
}
if (origin_w == width_ && origin_h == height_) {
return true;
}
fcv::Mat* im = mat->GetFalconCVMat();
fcv::Scalar value;
if (value_.size() == 1) {
value = fcv::Scalar(value_[0]);
} else if (value_.size() == 2) {
value = fcv::Scalar(value_[0], value_[1]);
} else if (value_.size() == 3) {
value = fcv::Scalar(value_[0], value_[1], value_[2]);
} else {
value = fcv::Scalar(value_[0], value_[1], value_[2], value_[3]);
}
fcv::Mat new_im;
// top, bottom, left, right
fcv::copy_make_border(*im, new_im, 0, height_ - origin_h, 0, width_ - origin_w,
fcv::BorderTypes::BORDER_CONSTANT, value);
mat->SetMat(new_im);
mat->SetHeight(height_);
mat->SetWidth(width_);
return true;
}
#endif
bool PadToSize::Run(Mat* mat, int width, int height, bool PadToSize::Run(Mat* mat, int width, int height,
const std::vector<float>& value, ProcLib lib) { const std::vector<float>& value, ProcLib lib) {
auto p = PadToSize(width, height, value); auto p = PadToSize(width, height, value);

View File

@@ -19,7 +19,7 @@
namespace fastdeploy { namespace fastdeploy {
namespace vision { namespace vision {
class PadToSize : public Processor { class FASTDEPLOY_DECL PadToSize : public Processor {
public: public:
// only support pad with right-bottom padding mode // only support pad with right-bottom padding mode
PadToSize(int width, int height, const std::vector<float>& value) { PadToSize(int width, int height, const std::vector<float>& value) {
@@ -28,6 +28,9 @@ class PadToSize : public Processor {
value_ = value; value_ = value;
} }
bool ImplByOpenCV(Mat* mat); bool ImplByOpenCV(Mat* mat);
#ifdef ENABLE_FLYCV
bool ImplByFalconCV(Mat* mat);
#endif
std::string Name() { return "PadToSize"; } std::string Name() { return "PadToSize"; }
static bool Run(Mat* mat, int width, int height, static bool Run(Mat* mat, int width, int height,

View File

@@ -25,6 +25,14 @@ bool Resize::ImplByOpenCV(Mat* mat) {
cv::Mat* im = mat->GetOpenCVMat(); cv::Mat* im = mat->GetOpenCVMat();
int origin_w = im->cols; int origin_w = im->cols;
int origin_h = im->rows; int origin_h = im->rows;
if (width_ == origin_w && height_ == origin_h) {
return true;
}
if (fabs(scale_w_ - 1.0) < 1e-06 && fabs(scale_h_ - 1.0) < 1e-06) {
return true;
}
if (width_ > 0 && height_ > 0) { if (width_ > 0 && height_ > 0) {
if (use_scale_) { if (use_scale_) {
float scale_w = width_ * 1.0 / origin_w; float scale_w = width_ * 1.0 / origin_w;
@@ -46,6 +54,65 @@ bool Resize::ImplByOpenCV(Mat* mat) {
return true; return true;
} }
#ifdef ENABLE_FLYCV
bool Resize::ImplByFalconCV(Mat* mat) {
if (mat->layout != Layout::HWC) {
FDERROR << "Resize: The format of input is not HWC." << std::endl;
return false;
}
fcv::Mat* im = mat->GetFalconCVMat();
int origin_w = im->width();
int origin_h = im->height();
if (width_ == origin_w && height_ == origin_h) {
return true;
}
if (fabs(scale_w_ - 1.0) < 1e-06 && fabs(scale_h_ - 1.0) < 1e-06) {
return true;
}
auto interp_method = fcv::InterpolationType::INTER_LINEAR;
if (interp_ == 0) {
interp_method = fcv::InterpolationType::INTER_NEAREST;
} else if (interp_ == 1) {
interp_method = fcv::InterpolationType::INTER_LINEAR;
} else if (interp_ == 2) {
interp_method = fcv::InterpolationType::INTER_CUBIC;
} else {
FDERROR << "LimitLong: Only support interp_ be 0/1/2 with FalconCV, but "
"now it's "
<< interp_ << "." << std::endl;
return false;
}
if (width_ > 0 && height_ > 0) {
fcv::Mat new_im;
if (use_scale_) {
float scale_w = width_ * 1.0 / origin_w;
float scale_h = height_ * 1.0 / origin_h;
fcv::resize(*im, new_im, fcv::Size(), scale_w, scale_h, interp_method);
} else {
fcv::resize(*im, new_im, fcv::Size(width_, height_), 0, 0, interp_method);
}
mat->SetMat(new_im);
mat->SetWidth(new_im.width());
mat->SetHeight(new_im.height());
} else if (scale_w_ > 0 && scale_h_ > 0) {
fcv::Mat new_im;
fcv::resize(*im, new_im, fcv::Size(0, 0), scale_w_, scale_h_, interp_method);
mat->SetMat(new_im);
mat->SetWidth(new_im.width());
mat->SetHeight(new_im.height());
} else {
FDERROR << "Resize: the parameters must satisfy (width > 0 && height > 0) "
"or (scale_w > 0 && scale_h > 0)."
<< std::endl;
return false;
}
return true;
}
#endif
bool Resize::Run(Mat* mat, int width, int height, float scale_w, float scale_h, bool Resize::Run(Mat* mat, int width, int height, float scale_w, float scale_h,
int interp, bool use_scale, ProcLib lib) { int interp, bool use_scale, ProcLib lib) {
if (mat->Height() == height && mat->Width() == width) { if (mat->Height() == height && mat->Width() == width) {

View File

@@ -19,7 +19,7 @@
namespace fastdeploy { namespace fastdeploy {
namespace vision { namespace vision {
class Resize : public Processor { class FASTDEPLOY_DECL Resize : public Processor {
public: public:
Resize(int width, int height, float scale_w = -1.0, float scale_h = -1.0, Resize(int width, int height, float scale_w = -1.0, float scale_h = -1.0,
int interp = 1, bool use_scale = false) { int interp = 1, bool use_scale = false) {
@@ -32,6 +32,9 @@ class Resize : public Processor {
} }
bool ImplByOpenCV(Mat* mat); bool ImplByOpenCV(Mat* mat);
#ifdef ENABLE_FLYCV
bool ImplByFalconCV(Mat* mat);
#endif
std::string Name() { return "Resize"; } std::string Name() { return "Resize"; }
static bool Run(Mat* mat, int width, int height, float scale_w = -1.0, static bool Run(Mat* mat, int width, int height, float scale_w = -1.0,

View File

@@ -36,6 +36,48 @@ bool ResizeByShort::ImplByOpenCV(Mat* mat) {
return true; return true;
} }
#ifdef ENABLE_FLYCV
bool ResizeByShort::ImplByFalconCV(Mat* mat) {
fcv::Mat* im = mat->GetFalconCVMat();
int origin_w = im->width();
int origin_h = im->height();
double scale = GenerateScale(origin_w, origin_h);
auto interp_method = fcv::InterpolationType::INTER_LINEAR;
if (interp_ == 0) {
interp_method = fcv::InterpolationType::INTER_NEAREST;
} else if (interp_ == 1) {
interp_method = fcv::InterpolationType::INTER_LINEAR;
} else if (interp_ == 2) {
interp_method = fcv::InterpolationType::INTER_CUBIC;
} else {
FDERROR << "LimitLong: Only support interp_ be 0/1/2 with FalconCV, but "
"now it's "
<< interp_ << "." << std::endl;
return false;
}
if (use_scale_ && fabs(scale - 1.0) >= 1e-06) {
fcv::Mat new_im;
fcv::resize(*im, new_im, fcv::Size(), scale, scale, interp_method);
mat->SetMat(new_im);
mat->SetHeight(new_im.height());
mat->SetWidth(new_im.width());
} else {
int width = static_cast<int>(round(scale * im->width()));
int height = static_cast<int>(round(scale * im->height()));
if (width != origin_w || height != origin_h) {
fcv::Mat new_im;
fcv::resize(*im, new_im, fcv::Size(width, height), 0, 0, interp_method);
mat->SetMat(new_im);
mat->SetHeight(new_im.height());
mat->SetWidth(new_im.width());
}
}
return true;
}
#endif
double ResizeByShort::GenerateScale(const int origin_w, const int origin_h) { double ResizeByShort::GenerateScale(const int origin_w, const int origin_h) {
int im_size_max = std::max(origin_w, origin_h); int im_size_max = std::max(origin_w, origin_h);
int im_size_min = std::min(origin_w, origin_h); int im_size_min = std::min(origin_w, origin_h);

View File

@@ -19,7 +19,7 @@
namespace fastdeploy { namespace fastdeploy {
namespace vision { namespace vision {
class ResizeByShort : public Processor { class FASTDEPLOY_DECL ResizeByShort : public Processor {
public: public:
ResizeByShort(int target_size, int interp = 1, bool use_scale = true, ResizeByShort(int target_size, int interp = 1, bool use_scale = true,
const std::vector<int>& max_hw = std::vector<int>()) { const std::vector<int>& max_hw = std::vector<int>()) {
@@ -29,6 +29,9 @@ class ResizeByShort : public Processor {
use_scale_ = use_scale; use_scale_ = use_scale;
} }
bool ImplByOpenCV(Mat* mat); bool ImplByOpenCV(Mat* mat);
#ifdef ENABLE_FLYCV
bool ImplByFalconCV(Mat* mat);
#endif
std::string Name() { return "ResizeByShort"; } std::string Name() { return "ResizeByShort"; }
static bool Run(Mat* mat, int target_size, int interp = 1, static bool Run(Mat* mat, int target_size, int interp = 1,

View File

@@ -63,6 +63,56 @@ bool StridePad::ImplByOpenCV(Mat* mat) {
return true; return true;
} }
#ifdef ENABLE_FLYCV
bool StridePad::ImplByFalconCV(Mat* mat) {
if (mat->layout != Layout::HWC) {
FDERROR << "StridePad: The input data must be Layout::HWC format!"
<< std::endl;
return false;
}
if (mat->Channels() > 4) {
FDERROR << "StridePad: Only support channels <= 4." << std::endl;
return false;
}
if (mat->Channels() != value_.size()) {
FDERROR
<< "StridePad: Require input channels equals to size of padding value, "
"but now channels = "
<< mat->Channels() << ", the size of padding values = " << value_.size()
<< "." << std::endl;
return false;
}
int origin_w = mat->Width();
int origin_h = mat->Height();
int pad_h = (mat->Height() / stride_) * stride_ +
(mat->Height() % stride_ != 0) * stride_ - mat->Height();
int pad_w = (mat->Width() / stride_) * stride_ +
(mat->Width() % stride_ != 0) * stride_ - mat->Width();
if (pad_h == 0 && pad_w == 0) {
return true;
}
fcv::Mat* im = mat->GetFalconCVMat();
fcv::Scalar value;
if (value_.size() == 1) {
value = fcv::Scalar(value_[0]);
} else if (value_.size() == 2) {
value = fcv::Scalar(value_[0], value_[1]);
} else if (value_.size() == 3) {
value = fcv::Scalar(value_[0], value_[1], value_[2]);
} else {
value = fcv::Scalar(value_[0], value_[1], value_[2], value_[3]);
}
fcv::Mat new_im;
// top, bottom, left, right
fcv::copy_make_border(*im, new_im, 0, pad_h, 0, pad_w, fcv::BorderTypes::BORDER_CONSTANT, value);
mat->SetMat(new_im);
mat->SetHeight(new_im.height());
mat->SetWidth(new_im.width());
return true;
}
#endif
bool StridePad::Run(Mat* mat, int stride, const std::vector<float>& value, bool StridePad::Run(Mat* mat, int stride, const std::vector<float>& value,
ProcLib lib) { ProcLib lib) {
auto p = StridePad(stride, value); auto p = StridePad(stride, value);

View File

@@ -19,7 +19,7 @@
namespace fastdeploy { namespace fastdeploy {
namespace vision { namespace vision {
class StridePad : public Processor { class FASTDEPLOY_DECL StridePad : public Processor {
public: public:
// only support pad with left-top padding mode // only support pad with left-top padding mode
StridePad(int stride, const std::vector<float>& value) { StridePad(int stride, const std::vector<float>& value) {
@@ -27,6 +27,9 @@ class StridePad : public Processor {
value_ = value; value_ = value;
} }
bool ImplByOpenCV(Mat* mat); bool ImplByOpenCV(Mat* mat);
#ifdef ENABLE_FLYCV
bool ImplByFalconCV(Mat* mat);
#endif
std::string Name() { return "StridePad"; } std::string Name() { return "StridePad"; }
static bool Run(Mat* mat, int stride, static bool Run(Mat* mat, int stride,

View File

@@ -30,5 +30,88 @@
#include "fastdeploy/vision/common/processors/resize_by_long.h" #include "fastdeploy/vision/common/processors/resize_by_long.h"
#include "fastdeploy/vision/common/processors/resize_by_short.h" #include "fastdeploy/vision/common/processors/resize_by_short.h"
#include "fastdeploy/vision/common/processors/stride_pad.h" #include "fastdeploy/vision/common/processors/stride_pad.h"
#include "fastdeploy/vision/common/processors/normalize_and_permute.h"
#include "fastdeploy/vision/common/processors/warp_affine.h" #include "fastdeploy/vision/common/processors/warp_affine.h"
#include "fastdeploy/vision/common/processors/letter_box.h" #include "fastdeploy/vision/common/processors/letter_box.h"
namespace fastdeploy {
namespace vision {
inline void FuseNormalizeCast(std::vector<std::shared_ptr<Processor>>* processors) {
// Fuse Normalize and Cast<Float>
int cast_index = -1;
for (size_t i = 0; i < processors->size(); ++i) {
if ((*processors)[i]->Name() == "Cast") {
if (i == 0) {
continue;
}
if ((*processors)[i - 1]->Name() != "Normalize" && (*processors)[i - 1]->Name() != "NormalizeAndPermute") {
continue;
}
cast_index = i;
}
}
if (cast_index < 0) {
return;
}
std::cout << dynamic_cast<Cast*>((*processors)[cast_index].get())->GetDtype() << "-----" << std::endl;
if (dynamic_cast<Cast*>((*processors)[cast_index].get())->GetDtype() != "float") {
return;
}
processors->erase(processors->begin() + cast_index);
FDINFO << (*processors)[cast_index - 1]->Name() << " and Cast are fused to " << (*processors)[cast_index - 1]->Name() << " in preprocessing pipeline." << std::endl;
}
inline void FuseNormalizeHWC2CHW(std::vector<std::shared_ptr<Processor>>* processors) {
// Fuse Normalize and HWC2CHW to NormalizeAndPermute
int hwc2chw_index = -1;
for (size_t i = 0; i < processors->size(); ++i) {
if ((*processors)[i]->Name() == "HWC2CHW") {
if (i == 0) {
continue;
}
if ((*processors)[i - 1]->Name() != "Normalize") {
continue;
}
hwc2chw_index = i;
}
}
if (hwc2chw_index < 0) {
return;
}
// Get alpha and beta of Normalize
std::vector<float> alpha = dynamic_cast<Normalize*>(
(*processors)[hwc2chw_index - 1].get())->GetAlpha();
std::vector<float> beta = dynamic_cast<Normalize*>(
(*processors)[hwc2chw_index - 1].get())->GetBeta();
// Delete Normalize and HWC2CHW
processors->erase(processors->begin() + hwc2chw_index);
processors->erase(processors->begin() + hwc2chw_index - 1);
// Add NormalizeAndPermute
std::vector<float> mean({0.0, 0.0, 0.0});
std::vector<float> std({1.0, 1.0, 1.0});
processors->push_back(std::make_shared<NormalizeAndPermute>(mean, std));
// Set alpha and beta
auto processor = dynamic_cast<NormalizeAndPermute*>(
(*processors)[hwc2chw_index - 1].get());
processor->SetAlpha(alpha);
processor->SetBeta(beta);
FDINFO << "Normalize and HWC2CHW are fused to NormalizeAndPermute "
" in preprocessing pipeline." << std::endl;
}
inline void FuseTransforms(
std::vector<std::shared_ptr<Processor>>* processors) {
FuseNormalizeCast(processors);
FuseNormalizeHWC2CHW(processors);
}
} // namespace vision
} // namespace fastdeploy

View File

@@ -12,6 +12,7 @@
// See the License for the specific language governing permissions and // See the License for the specific language governing permissions and
// limitations under the License. // limitations under the License.
#include "fastdeploy/utils/utils.h"
#include "fastdeploy/vision/common/processors/utils.h" #include "fastdeploy/vision/common/processors/utils.h"
namespace fastdeploy { namespace fastdeploy {
@@ -40,7 +41,7 @@ FDDataType OpenCVDataTypeToFD(int type) {
} }
} }
#ifdef ENABLE_FALCONCV #ifdef ENABLE_FLYCV
FDDataType FalconCVDataTypeToFD(fcv::FCVImageType type) { FDDataType FalconCVDataTypeToFD(fcv::FCVImageType type) {
if (type == fcv::FCVImageType::GRAY_U8) { if (type == fcv::FCVImageType::GRAY_U8) {
return FDDataType::UINT8; return FDDataType::UINT8;
@@ -103,11 +104,11 @@ FDDataType FalconCVDataTypeToFD(fcv::FCVImageType type) {
} else if (type == fcv::FCVImageType::GRAY_F64) { } else if (type == fcv::FCVImageType::GRAY_F64) {
return FDDataType::FP64; return FDDataType::FP64;
} }
FDASSERT(false, "While calling FalconDataTypeToFD(), get unexpected type:" + std::to_string(int(type)) + "."); FDASSERT(false, "While calling FalconDataTypeToFD(), get unexpected type:%d.", int(type));
return FDDataType::UNKNOWN; return FDDataType::UNKNOWN1;
} }
fcv::FCVImageType CreateFalconDataCVType(FDDataType type, int channel) { fcv::FCVImageType CreateFalconCVDataType(FDDataType type, int channel) {
FDASSERT(channel == 1 || channel == 3 || channel == 4, FDASSERT(channel == 1 || channel == 3 || channel == 4,
"Only support channel be 1/3/4 in Falcon."); "Only support channel be 1/3/4 in Falcon.");
if (type == FDDataType::UINT8) { if (type == FDDataType::UINT8) {
@@ -127,9 +128,19 @@ fcv::FCVImageType CreateFalconDataCVType(FDDataType type, int channel) {
return fcv::FCVImageType::PACKAGE_BGRA_F32; return fcv::FCVImageType::PACKAGE_BGRA_F32;
} }
} }
FDASSERT(false, "Data type of " + Str(type) + " is not supported."); FDASSERT(false, "Data type of %s is not supported.", Str(type).c_str());
return fcv::FCVImageType::PACKAGE_BGR_F32; return fcv::FCVImageType::PACKAGE_BGR_F32;
} }
fcv::Mat ConvertOpenCVMatToFalconCV(cv::Mat& im) {
int type = im.type() % 8;
// 0: uint8; 5: float32; 6: float64
if (type != 0 && type != 5 && type != 6) {
FDASSERT(false, "Only support type of uint8/float/double, but now it's %d.", im.type());
}
auto fcv_type = CreateFalconCVDataType(OpenCVDataTypeToFD(im.type()), im.channels());
return fcv::Mat(im.cols, im.rows, fcv_type, im.ptr());
}
#endif #endif

View File

@@ -15,19 +15,26 @@
#pragma once #pragma once
#include "fastdeploy/utils/utils.h" #include "fastdeploy/utils/utils.h"
#include "opencv2/core/core.hpp"
#include "fastdeploy/core/fd_tensor.h" #include "fastdeploy/core/fd_tensor.h"
#ifdef ENABLE_FLYCV
#include "flycv.h" // NOLINT
#endif
namespace fastdeploy { namespace fastdeploy {
namespace vision { namespace vision {
// Convert data type of opencv to FDDataType // Convert data type of opencv to FDDataType
FDDataType OpenCVDataTypeToFD(int type); FDDataType OpenCVDataTypeToFD(int type);
#ifdef ENABLE_FALCONCV #ifdef ENABLE_FLYCV
// Convert data type of falconcv to FDDataType // Convert data type of flycv to FDDataType
FDDataType FalconCVDataTypeToFD(fcv::FCVImageType type); FDDataType FalconCVDataTypeToFD(fcv::FCVImageType type);
// Create data type of falconcv by FDDataType // Create data type of flycv by FDDataType
fcv::FCVImageType CreateFalconCVDataType(FDDataType type, int channel = 1); fcv::FCVImageType CreateFalconCVDataType(FDDataType type, int channel = 1);
// Convert cv::Mat to fcv::Mat
fcv::Mat ConvertOpenCVMatToFalconCV(cv::Mat& im);
#endif #endif
} // namespace vision } // namespace vision

View File

@@ -160,6 +160,9 @@ bool PPYOLOE::BuildPreprocessPipelineFromConfig() {
processors_.push_back(std::make_shared<HWC2CHW>()); processors_.push_back(std::make_shared<HWC2CHW>());
} }
// Fusion will improve performance
FuseTransforms(&processors_);
return true; return true;
} }
@@ -259,6 +262,7 @@ bool PPYOLOE::Postprocess(std::vector<FDTensor>& infer_result,
bool PPYOLOE::Predict(cv::Mat* im, DetectionResult* result) { bool PPYOLOE::Predict(cv::Mat* im, DetectionResult* result) {
Mat mat(*im); Mat mat(*im);
std::vector<FDTensor> processed_data; std::vector<FDTensor> processed_data;
if (!Preprocess(&mat, &processed_data)) { if (!Preprocess(&mat, &processed_data)) {
FDERROR << "Failed to preprocess input data while using model:" FDERROR << "Failed to preprocess input data while using model:"

View File

@@ -14,7 +14,6 @@
#include "fastdeploy/vision/tracking/pptracking/model.h" #include "fastdeploy/vision/tracking/pptracking/model.h"
#include "yaml-cpp/yaml.h" #include "yaml-cpp/yaml.h"
#include "paddle2onnx/converter.h"
namespace fastdeploy { namespace fastdeploy {
namespace vision { namespace vision {

View File

@@ -115,6 +115,9 @@ void BindVision(pybind11::module& m) {
.def("__repr__", &vision::KeyPointDetectionResult::Str) .def("__repr__", &vision::KeyPointDetectionResult::Str)
.def("__str__", &vision::KeyPointDetectionResult::Str); .def("__str__", &vision::KeyPointDetectionResult::Str);
m.def("enable_flycv", &vision::EnableFlyCV, "Enable image preprocessing by FlyCV.");
m.def("disable_flycv", &vision::DisableFlyCV, "Disable image preprocessing by FlyCV, change to use OpenCV.");
BindDetection(m); BindDetection(m);
BindClassification(m); BindClassification(m);
BindSegmentation(m); BindSegmentation(m);

View File

@@ -25,3 +25,12 @@ from . import ocr
from . import evaluation from . import evaluation
from .utils import fd_result_to_json from .utils import fd_result_to_json
from .visualize import * from .visualize import *
from .. import C
def enable_flycv():
return C.vision.enable_flycv()
def disable_flycv():
return C.vision.disable_flycv()

View File

@@ -56,6 +56,7 @@ setup_configs["ENABLE_PADDLE_BACKEND"] = os.getenv("ENABLE_PADDLE_BACKEND",
setup_configs["ENABLE_POROS_BACKEND"] = os.getenv("ENABLE_POROS_BACKEND", setup_configs["ENABLE_POROS_BACKEND"] = os.getenv("ENABLE_POROS_BACKEND",
"OFF") "OFF")
setup_configs["ENABLE_VISION"] = os.getenv("ENABLE_VISION", "OFF") setup_configs["ENABLE_VISION"] = os.getenv("ENABLE_VISION", "OFF")
setup_configs["ENABLE_FLYCV"] = os.getenv("ENABLE_FLYCV", "OFF")
setup_configs["ENABLE_TEXT"] = os.getenv("ENABLE_TEXT", "OFF") setup_configs["ENABLE_TEXT"] = os.getenv("ENABLE_TEXT", "OFF")
setup_configs["ENABLE_TRT_BACKEND"] = os.getenv("ENABLE_TRT_BACKEND", "OFF") setup_configs["ENABLE_TRT_BACKEND"] = os.getenv("ENABLE_TRT_BACKEND", "OFF")
setup_configs["WITH_GPU"] = os.getenv("WITH_GPU", "OFF") setup_configs["WITH_GPU"] = os.getenv("WITH_GPU", "OFF")

View File

@@ -50,4 +50,15 @@ if [ -d ${INSTALLED_PREBUILT_FASTDEPLOY_DIR}/third_libs/install/paddle_inference
echo "MKLML Lib: ${INSTALLED_PREBUILT_FASTDEPLOY_DIR}/third_libs/install/paddle_inference/third_party/install/mklml/lib" echo "MKLML Lib: ${INSTALLED_PREBUILT_FASTDEPLOY_DIR}/third_libs/install/paddle_inference/third_party/install/mklml/lib"
fi fi
if [ -d ${INSTALLED_PREBUILT_FASTDEPLOY_DIR}/third_libs/install/flycv ]; then
export LD_LIBRARY_PATH=${INSTALLED_PREBUILT_FASTDEPLOY_DIR}/third_libs/install/flycv/lib:${LD_LIBRARY_PATH}
echo "Fly Lib: ${INSTALLED_PREBUILT_FASTDEPLOY_DIR}/third_libs/install/flycv/lib"
fi
if [ -d ${INSTALLED_PREBUILT_FASTDEPLOY_DIR}/third_libs/install/paddlelite ]; then
export LD_LIBRARY_PATH=${INSTALLED_PREBUILT_FASTDEPLOY_DIR}/third_libs/install/paddlelite/lib:${LD_LIBRARY_PATH}
echo "Paddle Lite Lib: ${INSTALLED_PREBUILT_FASTDEPLOY_DIR}/third_libs/install/paddlelite/lib"
fi
cd ${CURRENT_EXE_DIR} cd ${CURRENT_EXE_DIR}

View File

@@ -14,6 +14,7 @@
#pragma once #pragma once
#include <vector> #include <vector>
#include <cmath>
#include "gtest/gtest.h" #include "gtest/gtest.h"
namespace fastdeploy { namespace fastdeploy {
@@ -30,16 +31,35 @@ struct CheckShape {
struct CheckData { struct CheckData {
template <typename T> template <typename T>
void operator()(const T* lhs_ptr, const T* rhs_ptr, int num) { void operator()(const T* lhs_ptr, const T* rhs_ptr, int num, int atol = 0) {
for (int i = 0; i < num; ++i) { for (int i = 0; i < num; ++i) {
ASSERT_EQ(lhs_ptr[i], rhs_ptr[i]); // ASSERT_FLOAT_EQ(lhs_ptr[i], rhs_ptr[i]);
int abs_diff = abs(lhs_ptr[i] - rhs_ptr[i]);
if (abs_diff > atol) {
std::cout << "lhs_ptr: " << static_cast<int64_t>(lhs_ptr[i])
<< " rhs_ptr: " << static_cast<int64_t>(rhs_ptr[i])
<< " abs_diff: " << abs_diff << std::endl;
ASSERT_EQ(1, 0);
}
ASSERT_EQ(1, 1);
} }
} }
void operator()(const float* lhs_ptr, const float* rhs_ptr, int num) { void operator()(const float* lhs_ptr, const float* rhs_ptr,
int num, float atol = 1e-06, float rtol = 1e-06) {
for (int i = 0; i < num; ++i) { for (int i = 0; i < num; ++i) {
ASSERT_FLOAT_EQ(lhs_ptr[i], rhs_ptr[i]); float abs_diff = fabs(lhs_ptr[i] - rhs_ptr[i]);
float rel_diff = abs_diff / (std::max(fabs(lhs_ptr[i]),
fabs(rhs_ptr[i])) + 1e-06);
if (abs_diff > atol && rel_diff > rtol) {
std::cout << "lhs_ptr: " << lhs_ptr[i] << " rhs_ptr: "
<< rhs_ptr[i] << " abs_diff: " << abs_diff
<< " rel_diff: " << rel_diff << std::endl;
ASSERT_EQ(1, 0);
}
ASSERT_EQ(1, 1);
} }
} }
void operator()(const double* lhs_ptr, const double* rhs_ptr, int num) { void operator()(const double* lhs_ptr, const double* rhs_ptr, int num) {
for (int i = 0; i < num; ++i) { for (int i = 0; i < num; ++i) {
ASSERT_DOUBLE_EQ(lhs_ptr[i], rhs_ptr[i]); ASSERT_DOUBLE_EQ(lhs_ptr[i], rhs_ptr[i]);
@@ -47,4 +67,10 @@ struct CheckData {
} }
}; };
struct CheckType {
void operator()(FDDataType type1, FDDataType type2) {
ASSERT_EQ(type1, type2);
}
};
} // namespace fastdeploy } // namespace fastdeploy

View File

@@ -0,0 +1,51 @@
// Copyright (c) 2022 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 <array>
#include <vector>
#include "fastdeploy/vision.h"
#include "glog/logging.h"
#include "gtest/gtest.h"
#include "gtest_utils.h"
namespace fastdeploy {
#ifdef ENABLE_FLYCV
TEST(fastdeploy, flycv_cast) {
CheckShape check_shape;
CheckData check_data;
CheckType check_type;
cv::Mat mat(64, 64, CV_8UC3);
cv::randu(mat, cv::Scalar::all(0), cv::Scalar::all(255));
cv::Mat mat1 = mat.clone();
vision::Mat mat_opencv(mat);
vision::Mat mat_flycv(mat1);
vision::Cast::Run(&mat_opencv, "float", vision::ProcLib::OPENCV);
vision::Cast::Run(&mat_flycv, "float", vision::ProcLib::FLYCV);
FDTensor opencv;
FDTensor flycv;
mat_opencv.ShareWithTensor(&opencv);
mat_flycv.ShareWithTensor(&flycv);
check_shape(opencv.shape, flycv.shape);
check_data(reinterpret_cast<const float*>(opencv.Data()), reinterpret_cast<const float*>(flycv.Data()), opencv.Numel());
check_type(opencv.dtype, flycv.dtype);
}
#endif
} // namespace fastdeploy

View File

@@ -0,0 +1,79 @@
// Copyright (c) 2022 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 <array>
#include <vector>
#include "fastdeploy/vision.h"
#include "glog/logging.h"
#include "gtest/gtest.h"
#include "gtest_utils.h"
namespace fastdeploy {
#ifdef ENABLE_FLYCV
TEST(fastdeploy, flycv_center_crop1) {
CheckShape check_shape;
CheckData check_data;
CheckType check_type;
cv::Mat mat(64, 64, CV_8UC3);
cv::randu(mat, cv::Scalar::all(0), cv::Scalar::all(255));
cv::Mat mat1 = mat.clone();
vision::Mat mat_opencv(mat);
vision::Mat mat_flycv(mat1);
vision::Cast::Run(&mat_opencv, "float", vision::ProcLib::OPENCV);
vision::Cast::Run(&mat_flycv, "float", vision::ProcLib::FLYCV);
vision::CenterCrop::Run(&mat_opencv, 20, 20, vision::ProcLib::OPENCV);
vision::CenterCrop::Run(&mat_flycv, 20, 20, vision::ProcLib::FLYCV);
FDTensor opencv;
FDTensor flycv;
mat_opencv.ShareWithTensor(&opencv);
mat_flycv.ShareWithTensor(&flycv);
check_shape(opencv.shape, flycv.shape);
check_data(reinterpret_cast<const float*>(opencv.Data()), reinterpret_cast<const float*>(flycv.Data()), opencv.Numel());
check_type(opencv.dtype, flycv.dtype);
}
TEST(fastdeploy, flycv_center_crop2) {
CheckShape check_shape;
CheckData check_data;
CheckType check_type;
cv::Mat mat(64, 64, CV_8UC3);
cv::randu(mat, cv::Scalar::all(0), cv::Scalar::all(255));
cv::Mat mat1 = mat.clone();
vision::Mat mat_opencv(mat);
vision::Mat mat_flycv(mat1);
vision::CenterCrop::Run(&mat_opencv, 20, 20, vision::ProcLib::OPENCV);
vision::CenterCrop::Run(&mat_flycv, 20, 20, vision::ProcLib::FLYCV);
FDTensor opencv;
FDTensor flycv;
mat_opencv.ShareWithTensor(&opencv);
mat_flycv.ShareWithTensor(&flycv);
check_shape(opencv.shape, flycv.shape);
check_data(reinterpret_cast<const uint8_t*>(opencv.Data()), reinterpret_cast<const uint8_t*>(flycv.Data()), opencv.Numel());
check_type(opencv.dtype, flycv.dtype);
}
#endif
} // namespace fastdeploy

View File

@@ -0,0 +1,76 @@
// Copyright (c) 2022 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 <array>
#include <vector>
#include "fastdeploy/vision.h"
#include "glog/logging.h"
#include "gtest/gtest.h"
#include "gtest_utils.h"
namespace fastdeploy {
#ifdef ENABLE_FLYCV
TEST(fastdeploy, flycv_bgr2rgb) {
CheckShape check_shape;
CheckData check_data;
CheckType check_type;
cv::Mat mat(64, 64, CV_8UC3);
cv::randu(mat, cv::Scalar::all(0), cv::Scalar::all(255));
cv::Mat mat1 = mat.clone();
vision::Mat mat_opencv(mat);
vision::Mat mat_flycv(mat1);
vision::BGR2RGB::Run(&mat_opencv, vision::ProcLib::OPENCV);
vision::BGR2RGB::Run(&mat_flycv, vision::ProcLib::FLYCV);
FDTensor opencv;
FDTensor flycv;
mat_opencv.ShareWithTensor(&opencv);
mat_flycv.ShareWithTensor(&flycv);
check_shape(opencv.shape, flycv.shape);
check_data(reinterpret_cast<const uint8_t*>(opencv.Data()), reinterpret_cast<const uint8_t*>(flycv.Data()), opencv.Numel());
check_type(opencv.dtype, flycv.dtype);
}
TEST(fastdeploy, flycv_rgb2bgr) {
CheckShape check_shape;
CheckData check_data;
CheckType check_type;
cv::Mat mat(64, 64, CV_8UC3);
cv::randu(mat, cv::Scalar::all(0), cv::Scalar::all(255));
cv::Mat mat1 = mat.clone();
vision::Mat mat_opencv(mat);
vision::Mat mat_flycv(mat1);
vision::RGB2BGR::Run(&mat_opencv, vision::ProcLib::OPENCV);
vision::RGB2BGR::Run(&mat_flycv, vision::ProcLib::FLYCV);
FDTensor opencv;
FDTensor flycv;
mat_opencv.ShareWithTensor(&opencv);
mat_flycv.ShareWithTensor(&flycv);
check_shape(opencv.shape, flycv.shape);
check_data(reinterpret_cast<const uint8_t*>(opencv.Data()), reinterpret_cast<const uint8_t*>(flycv.Data()), opencv.Numel());
check_type(opencv.dtype, flycv.dtype);
}
#endif
} // namespace fastdeploy

View File

@@ -0,0 +1,85 @@
// Copyright (c) 2022 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 <array>
#include <vector>
#include "fastdeploy/vision.h"
#include "glog/logging.h"
#include "gtest/gtest.h"
#include "gtest_utils.h"
namespace fastdeploy {
#ifdef ENABLE_FLYCV
TEST(fastdeploy, flycv_convert1) {
CheckShape check_shape;
CheckData check_data;
CheckType check_type;
cv::Mat mat(64, 64, CV_8UC3);
cv::randu(mat, cv::Scalar::all(0), cv::Scalar::all(255));
cv::Mat mat1 = mat.clone();
vision::Mat mat_opencv(mat);
vision::Mat mat_flycv(mat1);
std::vector<float> alpha({0.1, 0.2, 0.3});
std::vector<float> beta({0.24, 0.77, 0.32});
vision::Convert::Run(&mat_opencv, alpha, beta, vision::ProcLib::OPENCV);
vision::Convert::Run(&mat_flycv, alpha, beta, vision::ProcLib::FLYCV);
FDTensor opencv;
FDTensor flycv;
mat_opencv.ShareWithTensor(&opencv);
mat_flycv.ShareWithTensor(&flycv);
check_shape(opencv.shape, flycv.shape);
check_data(reinterpret_cast<const float*>(opencv.Data()), reinterpret_cast<const float*>(flycv.Data()), opencv.Numel());
check_type(opencv.dtype, flycv.dtype);
}
TEST(fastdeploy, flycv_convert2) {
CheckShape check_shape;
CheckData check_data;
CheckType check_type;
cv::Mat mat(64, 64, CV_8UC3);
cv::randu(mat, cv::Scalar::all(0), cv::Scalar::all(255));
cv::Mat mat1 = mat.clone();
vision::Mat mat_opencv(mat);
vision::Mat mat_flycv(mat1);
std::vector<float> alpha({0.1, 0.2, 0.3});
std::vector<float> beta({0.24, 0.77, 0.32});
vision::Cast::Run(&mat_opencv, "float", vision::ProcLib::OPENCV);
vision::Cast::Run(&mat_flycv, "float", vision::ProcLib::FLYCV);
vision::Convert::Run(&mat_opencv, alpha, beta, vision::ProcLib::OPENCV);
vision::Convert::Run(&mat_flycv, alpha, beta, vision::ProcLib::FLYCV);
FDTensor opencv;
FDTensor flycv;
mat_opencv.ShareWithTensor(&opencv);
mat_flycv.ShareWithTensor(&flycv);
check_shape(opencv.shape, flycv.shape);
check_data(reinterpret_cast<const float*>(opencv.Data()), reinterpret_cast<const float*>(flycv.Data()), opencv.Numel());
check_type(opencv.dtype, flycv.dtype);
}
#endif
} // namespace fastdeploy

View File

@@ -0,0 +1,79 @@
// Copyright (c) 2022 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 <array>
#include <vector>
#include "fastdeploy/vision.h"
#include "glog/logging.h"
#include "gtest/gtest.h"
#include "gtest_utils.h"
namespace fastdeploy {
#ifdef ENABLE_FLYCV
TEST(fastdeploy, flycv_crop1) {
CheckShape check_shape;
CheckData check_data;
CheckType check_type;
cv::Mat mat(64, 64, CV_8UC3);
cv::randu(mat, cv::Scalar::all(0), cv::Scalar::all(255));
cv::Mat mat1 = mat.clone();
vision::Mat mat_opencv(mat);
vision::Mat mat_flycv(mat1);
vision::Cast::Run(&mat_opencv, "float", vision::ProcLib::OPENCV);
vision::Cast::Run(&mat_flycv, "float", vision::ProcLib::FLYCV);
vision::Crop::Run(&mat_opencv, 4, 8, 20, 20, vision::ProcLib::OPENCV);
vision::Crop::Run(&mat_flycv, 4, 8, 20, 20, vision::ProcLib::FLYCV);
FDTensor opencv;
FDTensor flycv;
mat_opencv.ShareWithTensor(&opencv);
mat_flycv.ShareWithTensor(&flycv);
check_shape(opencv.shape, flycv.shape);
check_data(reinterpret_cast<const float*>(opencv.Data()), reinterpret_cast<const float*>(flycv.Data()), opencv.Numel());
check_type(opencv.dtype, flycv.dtype);
}
TEST(fastdeploy, flycv_center_crop2) {
CheckShape check_shape;
CheckData check_data;
CheckType check_type;
cv::Mat mat(70, 60, CV_8UC3);
cv::randu(mat, cv::Scalar::all(0), cv::Scalar::all(255));
cv::Mat mat1 = mat.clone();
vision::Mat mat_opencv(mat);
vision::Mat mat_flycv(mat1);
vision::Crop::Run(&mat_opencv, 9, 16, 13, 23, vision::ProcLib::OPENCV);
vision::Crop::Run(&mat_flycv, 9, 16, 13, 23, vision::ProcLib::FLYCV);
FDTensor opencv;
FDTensor flycv;
mat_opencv.ShareWithTensor(&opencv);
mat_flycv.ShareWithTensor(&flycv);
check_shape(opencv.shape, flycv.shape);
check_data(reinterpret_cast<const uint8_t*>(opencv.Data()), reinterpret_cast<const uint8_t*>(flycv.Data()), opencv.Numel());
check_type(opencv.dtype, flycv.dtype);
}
#endif
} // namespace fastdeploy

View File

@@ -0,0 +1,78 @@
// Copyright (c) 2022 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 <array>
#include <vector>
#include "fastdeploy/vision.h"
#include "glog/logging.h"
#include "gtest/gtest.h"
#include "gtest_utils.h"
namespace fastdeploy {
#ifdef ENABLE_FLYCV
TEST(fastdeploy, flycv_hwc2chw1) {
CheckShape check_shape;
CheckData check_data;
CheckType check_type;
cv::Mat mat(64, 64, CV_8UC3);
cv::randu(mat, cv::Scalar::all(0), cv::Scalar::all(255));
cv::Mat mat1 = mat.clone();
vision::Mat mat_opencv(mat);
vision::Mat mat_flycv(mat1);
vision::Cast::Run(&mat_opencv, "float", vision::ProcLib::OPENCV);
vision::Cast::Run(&mat_flycv, "float", vision::ProcLib::FLYCV);
vision::HWC2CHW::Run(&mat_opencv, vision::ProcLib::OPENCV);
vision::HWC2CHW::Run(&mat_flycv, vision::ProcLib::FLYCV);
FDTensor opencv;
FDTensor flycv;
mat_opencv.ShareWithTensor(&opencv);
mat_flycv.ShareWithTensor(&flycv);
check_shape(opencv.shape, flycv.shape);
check_data(reinterpret_cast<const float*>(opencv.Data()), reinterpret_cast<const float*>(flycv.Data()), opencv.Numel());
check_type(opencv.dtype, flycv.dtype);
}
//TEST(fastdeploy, flycv_hwc2chw2) {
// CheckShape check_shape;
// CheckData check_data;
// CheckType check_type;
//
// cv::Mat mat(64, 64, CV_8UC3);
// cv::randu(mat, cv::Scalar::all(0), cv::Scalar::all(255));
// cv::Mat mat1 = mat.clone();
//
// vision::Mat mat_opencv(mat);
// vision::Mat mat_flycv(mat1);
// vision::HWC2CHW::Run(&mat_opencv, vision::ProcLib::OPENCV);
// vision::HWC2CHW::Run(&mat_flycv, vision::ProcLib::FLYCV);
//
// FDTensor opencv;
// FDTensor flycv;
//
// mat_opencv.ShareWithTensor(&opencv);
// mat_flycv.ShareWithTensor(&flycv);
//
// check_shape(opencv.shape, flycv.shape);
// check_data(reinterpret_cast<const uint8_t*>(opencv.Data()), reinterpret_cast<const uint8_t*>(flycv.Data()), opencv.Numel());
// check_type(opencv.dtype, flycv.dtype);
//}
#endif
} // namespace fastdeploy

View File

@@ -0,0 +1,108 @@
// Copyright (c) 2022 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 <array>
#include <vector>
#include "fastdeploy/vision.h"
#include "glog/logging.h"
#include "gtest/gtest.h"
#include "gtest_utils.h"
namespace fastdeploy {
#ifdef ENABLE_FLYCV
TEST(fastdeploy, flycv_limit_long1) {
CheckShape check_shape;
CheckData check_data;
CheckType check_type;
cv::Mat mat(35, 69, CV_8UC3);
cv::randu(mat, cv::Scalar::all(0), cv::Scalar::all(255));
cv::Mat mat1 = mat.clone();
vision::Mat mat_opencv(mat);
vision::Mat mat_flycv(mat1);
vision::LimitLong::Run(&mat_opencv, 38, -1, vision::ProcLib::OPENCV);
vision::LimitLong::Run(&mat_flycv, 38, -1, vision::ProcLib::FLYCV);
std::cout << "opencv " << mat_opencv.GetOpenCVMat()->cols << " " << mat_opencv.GetOpenCVMat()->rows << std::endl;
std::cout << "flycv " << mat_flycv.GetFalconCVMat()->width() << " " << mat_flycv.GetFalconCVMat()->height() << std::endl;
FDTensor opencv;
FDTensor flycv;
mat_opencv.ShareWithTensor(&opencv);
mat_flycv.ShareWithTensor(&flycv);
check_shape(opencv.shape, flycv.shape);
check_type(opencv.dtype, flycv.dtype);
check_data(reinterpret_cast<const uint8_t*>(opencv.Data()), reinterpret_cast<const uint8_t*>(flycv.Data()), opencv.Numel(), 20);
}
//TEST(fastdeploy, flycv_limit_long2) {
// CheckShape check_shape;
// CheckData check_data;
// CheckType check_type;
//
// cv::Mat mat(35, 69, CV_8UC3);
// cv::randu(mat, cv::Scalar::all(0), cv::Scalar::all(255));
// cv::Mat mat1 = mat.clone();
//
// vision::Mat mat_opencv(mat);
// vision::Mat mat_flycv(mat1);
// vision::Cast::Run(&mat_opencv, "float", vision::ProcLib::OPENCV);
// vision::Cast::Run(&mat_flycv, "float", vision::ProcLib::FLYCV);
// vision::LimitByStride::Run(&mat_opencv, 38, -1, vision::ProcLib::OPENCV);
// vision::LimitByStride::Run(&mat_flycv, 38, -1, vision::ProcLib::FLYCV);
//
// FDTensor opencv;
// FDTensor flycv;
//
// mat_opencv.ShareWithTensor(&opencv);
// mat_flycv.ShareWithTensor(&flycv);
//
// check_shape(opencv.shape, flycv.shape);
// check_type(opencv.dtype, flycv.dtype);
// check_data(reinterpret_cast<const float*>(opencv.Data()), reinterpret_cast<const float*>(flycv.Data()), opencv.Numel(), 0, 0);
//}
//
//TEST(fastdeploy, flycv_limit_long3) {
// CheckShape check_shape;
// CheckData check_data;
// CheckType check_type;
//
// cv::Mat mat(35, 69, CV_8UC3);
// cv::randu(mat, cv::Scalar::all(0), cv::Scalar::all(255));
// cv::Mat mat1 = mat.clone();
//
// vision::Mat mat_opencv(mat);
// vision::Mat mat_flycv(mat1);
// vision::Cast::Run(&mat_opencv, "float", vision::ProcLib::OPENCV);
// vision::Cast::Run(&mat_flycv, "float", vision::ProcLib::FLYCV);
// vision::LimitByStride::Run(&mat_opencv, 108, 50, vision::ProcLib::OPENCV);
// vision::LimitByStride::Run(&mat_flycv, 108, 50, vision::ProcLib::FLYCV);
//
// FDTensor opencv;
// FDTensor flycv;
//
// mat_opencv.ShareWithTensor(&opencv);
// mat_flycv.ShareWithTensor(&flycv);
//
// check_shape(opencv.shape, flycv.shape);
// check_type(opencv.dtype, flycv.dtype);
// check_data(reinterpret_cast<const float*>(opencv.Data()), reinterpret_cast<const float*>(flycv.Data()), opencv.Numel(), 0, 0);
//}
#endif
} // namespace fastdeploy

View File

@@ -0,0 +1,133 @@
// Copyright (c) 2022 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 <array>
#include <vector>
#include "fastdeploy/vision.h"
#include "glog/logging.h"
#include "gtest/gtest.h"
#include "gtest_utils.h"
namespace fastdeploy {
#ifdef ENABLE_FLYCV
TEST(fastdeploy, flycv_limit_stride1) {
CheckShape check_shape;
CheckData check_data;
CheckType check_type;
cv::Mat mat(35, 69, CV_8UC3);
cv::randu(mat, cv::Scalar::all(0), cv::Scalar::all(255));
cv::Mat mat1 = mat.clone();
vision::Mat mat_opencv(mat);
vision::Mat mat_flycv(mat1);
vision::LimitByStride::Run(&mat_opencv, 38, 1, vision::ProcLib::OPENCV);
vision::LimitByStride::Run(&mat_flycv, 38, 1, vision::ProcLib::FLYCV);
FDTensor opencv;
FDTensor flycv;
mat_opencv.ShareWithTensor(&opencv);
mat_flycv.ShareWithTensor(&flycv);
check_shape(opencv.shape, flycv.shape);
check_type(opencv.dtype, flycv.dtype);
check_data(reinterpret_cast<const uint8_t*>(opencv.Data()), reinterpret_cast<const uint8_t*>(flycv.Data()), opencv.Numel(), 1);
}
TEST(fastdeploy, flycv_limit_stride2) {
CheckShape check_shape;
CheckData check_data;
CheckType check_type;
cv::Mat mat(35, 69, CV_8UC3);
cv::randu(mat, cv::Scalar::all(0), cv::Scalar::all(255));
cv::Mat mat1 = mat.clone();
vision::Mat mat_opencv(mat);
vision::Mat mat_flycv(mat1);
vision::Cast::Run(&mat_opencv, "float", vision::ProcLib::OPENCV);
vision::Cast::Run(&mat_flycv, "float", vision::ProcLib::FLYCV);
vision::LimitByStride::Run(&mat_opencv, 32, 1, vision::ProcLib::OPENCV);
vision::LimitByStride::Run(&mat_flycv, 32, 1, vision::ProcLib::FLYCV);
FDTensor opencv;
FDTensor flycv;
mat_opencv.ShareWithTensor(&opencv);
mat_flycv.ShareWithTensor(&flycv);
check_shape(opencv.shape, flycv.shape);
check_type(opencv.dtype, flycv.dtype);
check_data(reinterpret_cast<const float*>(opencv.Data()), reinterpret_cast<const float*>(flycv.Data()), opencv.Numel(), 0, 0);
}
//TEST(fastdeploy, flycv_limit_stride3) {
// CheckShape check_shape;
// CheckData check_data;
// CheckType check_type;
//
// cv::Mat mat(35, 69, CV_8UC3);
// cv::randu(mat, cv::Scalar::all(0), cv::Scalar::all(255));
// cv::Mat mat1 = mat.clone();
//
// vision::Mat mat_opencv(mat);
// vision::Mat mat_flycv(mat1);
//// vision::Cast::Run(&mat_opencv, "float", vision::ProcLib::OPENCV);
//// vision::Cast::Run(&mat_flycv, "float", vision::ProcLib::FLYCV);
// vision::LimitByStride::Run(&mat_opencv, 32, 0, vision::ProcLib::OPENCV);
// vision::LimitByStride::Run(&mat_flycv, 32, 0, vision::ProcLib::FLYCV);
//
// FDTensor opencv;
// FDTensor flycv;
//
// mat_opencv.ShareWithTensor(&opencv);
// mat_flycv.ShareWithTensor(&flycv);
//
// check_shape(opencv.shape, flycv.shape);
// check_type(opencv.dtype, flycv.dtype);
// check_data(reinterpret_cast<const uint8_t*>(opencv.Data()), reinterpret_cast<const uint8_t*>(flycv.Data()), opencv.Numel(), 1);
//}
//TEST(fastdeploy, flycv_limit_stride4) {
// CheckShape check_shape;
// CheckData check_data;
// CheckType check_type;
//
// cv::Mat mat(35, 69, CV_8UC3);
// cv::randu(mat, cv::Scalar::all(0), cv::Scalar::all(255));
// cv::Mat mat1 = mat.clone();
//
// vision::Mat mat_opencv(mat);
// vision::Mat mat_flycv(mat1);
// vision::Cast::Run(&mat_opencv, "float", vision::ProcLib::OPENCV);
// vision::Cast::Run(&mat_flycv, "float", vision::ProcLib::FLYCV);
// vision::LimitByStride::Run(&mat_opencv, 32, 2, vision::ProcLib::OPENCV);
// vision::LimitByStride::Run(&mat_flycv, 32, 2, vision::ProcLib::FLYCV);
//
// FDTensor opencv;
// FDTensor flycv;
//
// mat_opencv.ShareWithTensor(&opencv);
// mat_flycv.ShareWithTensor(&flycv);
//
// check_shape(opencv.shape, flycv.shape);
// check_type(opencv.dtype, flycv.dtype);
// check_data(reinterpret_cast<const float*>(opencv.Data()), reinterpret_cast<const float*>(flycv.Data()), opencv.Numel(), 0, 0);
//}
#endif
} // namespace fastdeploy

View File

@@ -0,0 +1,116 @@
// Copyright (c) 2022 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 <array>
#include <vector>
#include "fastdeploy/vision.h"
#include "glog/logging.h"
#include "gtest/gtest.h"
#include "gtest_utils.h"
namespace fastdeploy {
#ifdef ENABLE_FLYCV
TEST(fastdeploy, flycv_norm1) {
CheckShape check_shape;
CheckData check_data;
CheckType check_type;
cv::Mat mat(64, 64, CV_8UC3);
cv::randu(mat, cv::Scalar::all(0), cv::Scalar::all(255));
cv::Mat mat1 = mat.clone();
vision::Mat mat_opencv(mat);
vision::Mat mat_flycv(mat1);
std::vector<float> mean({0.25, 0.35, 0.45});
std::vector<float> std({0.33, 0.22, 0.54});
std::vector<float> min;
std::vector<float> max;
vision::Normalize::Run(&mat_opencv, mean, std, true, min, max, vision::ProcLib::OPENCV);
vision::Normalize::Run(&mat_flycv, mean, std, true, min, max, vision::ProcLib::FLYCV);
FDTensor opencv;
FDTensor flycv;
mat_opencv.ShareWithTensor(&opencv);
mat_flycv.ShareWithTensor(&flycv);
check_shape(opencv.shape, flycv.shape);
check_data(reinterpret_cast<const float*>(opencv.Data()), reinterpret_cast<const float*>(flycv.Data()), opencv.Numel());
check_type(opencv.dtype, flycv.dtype);
}
TEST(fastdeploy, flycv_norm2) {
CheckShape check_shape;
CheckData check_data;
CheckType check_type;
cv::Mat mat(64, 64, CV_8UC3);
cv::randu(mat, cv::Scalar::all(0), cv::Scalar::all(255));
cv::Mat mat1 = mat.clone();
vision::Mat mat_opencv(mat);
vision::Mat mat_flycv(mat1);
std::vector<float> mean({0.25, 0.35, 0.45});
std::vector<float> std({0.33, 0.22, 0.54});
std::vector<float> min({1, 2, 3});
std::vector<float> max({300, 400, 500});
vision::Normalize::Run(&mat_opencv, mean, std, true, min, max, vision::ProcLib::OPENCV);
vision::Normalize::Run(&mat_flycv, mean, std, true, min, max, vision::ProcLib::FLYCV);
FDTensor opencv;
FDTensor flycv;
mat_opencv.ShareWithTensor(&opencv);
mat_flycv.ShareWithTensor(&flycv);
check_shape(opencv.shape, flycv.shape);
check_data(reinterpret_cast<const float*>(opencv.Data()), reinterpret_cast<const float*>(flycv.Data()), opencv.Numel());
check_type(opencv.dtype, flycv.dtype);
}
TEST(fastdeploy, flycv_norm3) {
CheckShape check_shape;
CheckData check_data;
CheckType check_type;
cv::Mat mat(64, 64, CV_8UC3);
cv::randu(mat, cv::Scalar::all(0), cv::Scalar::all(255));
cv::Mat mat1 = mat.clone();
vision::Mat mat_opencv(mat);
vision::Mat mat_flycv(mat1);
std::vector<float> mean({0.25, 0.35, 0.45});
std::vector<float> std({0.33, 0.22, 0.54});
std::vector<float> min({1, 2, 3});
std::vector<float> max({300, 400, 500});
vision::Normalize::Run(&mat_opencv, mean, std, true, min, max, vision::ProcLib::OPENCV);
vision::Normalize::Run(&mat_flycv, mean, std, true, min, max, vision::ProcLib::FLYCV);
FDTensor opencv;
FDTensor flycv;
mat_opencv.ShareWithTensor(&opencv);
mat_flycv.ShareWithTensor(&flycv);
check_shape(opencv.shape, flycv.shape);
check_data(reinterpret_cast<const float*>(opencv.Data()), reinterpret_cast<const float*>(flycv.Data()), opencv.Numel());
check_type(opencv.dtype, flycv.dtype);
}
#endif
} // namespace fastdeploy

View File

@@ -0,0 +1,65 @@
// Copyright (c) 2022 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 <array>
#include <vector>
#include "fastdeploy/vision.h"
#include "glog/logging.h"
#include "gtest/gtest.h"
#include "gtest_utils.h"
namespace fastdeploy {
#ifdef ENABLE_FLYCV
TEST(fastdeploy, flycv_norm_and_perm0) {
CheckShape check_shape;
CheckData check_data;
CheckType check_type;
cv::Mat mat(64, 64, CV_8UC3);
cv::randu(mat, cv::Scalar::all(0), cv::Scalar::all(255));
cv::Mat mat1 = mat.clone();
cv::Mat mat2 = mat.clone();
std::vector<float> mean({0.25, 0.35, 0.45});
std::vector<float> std({0.33, 0.22, 0.54});
std::vector<float> min;
std::vector<float> max;
vision::Mat mat_opencv(mat);
vision::Mat mat_opencv1(mat);
vision::Mat mat_flycv(mat1);
vision::Normalize::Run(&mat_opencv, mean, std, true, min, max, vision::ProcLib::OPENCV);
vision::HWC2CHW::Run(&mat_opencv, vision::ProcLib::OPENCV);
vision::NormalizeAndPermute::Run(&mat_opencv1, mean, std, true, min, max, vision::ProcLib::OPENCV);
vision::NormalizeAndPermute::Run(&mat_flycv, mean, std, true, min, max, vision::ProcLib::FLYCV);
FDTensor opencv;
FDTensor opencv1;
FDTensor flycv;
mat_opencv.ShareWithTensor(&opencv);
mat_opencv1.ShareWithTensor(&opencv1);
mat_flycv.ShareWithTensor(&flycv);
check_shape(opencv.shape, flycv.shape);
check_data(reinterpret_cast<const float*>(opencv.Data()), reinterpret_cast<const float*>(flycv.Data()), opencv.Numel());
check_data(reinterpret_cast<const float*>(opencv1.Data()), reinterpret_cast<const float*>(flycv.Data()), opencv1.Numel());
check_type(opencv.dtype, flycv.dtype);
}
#endif
} // namespace fastdeploy

View File

@@ -0,0 +1,78 @@
// Copyright (c) 2022 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 <array>
#include <vector>
#include "fastdeploy/vision.h"
#include "glog/logging.h"
#include "gtest/gtest.h"
#include "gtest_utils.h"
namespace fastdeploy {
#ifdef ENABLE_FLYCV
TEST(fastdeploy, flycv_pad1) {
CheckShape check_shape;
CheckData check_data;
CheckType check_type;
cv::Mat mat(64, 64, CV_8UC3);
cv::randu(mat, cv::Scalar::all(0), cv::Scalar::all(255));
cv::Mat mat1 = mat.clone();
vision::Mat mat_opencv(mat);
vision::Mat mat_flycv(mat1);
vision::Cast::Run(&mat_opencv, "float", vision::ProcLib::OPENCV);
vision::Cast::Run(&mat_flycv, "float", vision::ProcLib::FLYCV);
vision::Pad::Run(&mat_opencv, 1, 2, 3, 4, {1, 2, 3}, vision::ProcLib::OPENCV);
vision::Pad::Run(&mat_flycv, 1, 2, 3, 4, {1, 2, 3}, vision::ProcLib::FLYCV);
FDTensor opencv;
FDTensor flycv;
mat_opencv.ShareWithTensor(&opencv);
mat_flycv.ShareWithTensor(&flycv);
check_shape(opencv.shape, flycv.shape);
check_data(reinterpret_cast<const float*>(opencv.Data()), reinterpret_cast<const float*>(flycv.Data()), opencv.Numel());
check_type(opencv.dtype, flycv.dtype);
}
TEST(fastdeploy, flycv_pad2) {
CheckShape check_shape;
CheckData check_data;
CheckType check_type;
cv::Mat mat(64, 64, CV_8UC3);
cv::randu(mat, cv::Scalar::all(0), cv::Scalar::all(255));
cv::Mat mat1 = mat.clone();
vision::Mat mat_opencv(mat);
vision::Mat mat_flycv(mat1);
vision::Pad::Run(&mat_opencv, 1, 2, 3, 4, {1, 2, 3}, vision::ProcLib::OPENCV);
vision::Pad::Run(&mat_flycv, 1, 2, 3, 4, {1, 2, 3}, vision::ProcLib::FLYCV);
FDTensor opencv;
FDTensor flycv;
mat_opencv.ShareWithTensor(&opencv);
mat_flycv.ShareWithTensor(&flycv);
check_shape(opencv.shape, flycv.shape);
check_data(reinterpret_cast<const uint8_t*>(opencv.Data()), reinterpret_cast<const uint8_t*>(flycv.Data()), opencv.Numel());
check_type(opencv.dtype, flycv.dtype);
}
#endif
} // namespace fastdeploy

View File

@@ -0,0 +1,78 @@
// Copyright (c) 2022 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 <array>
#include <vector>
#include "fastdeploy/vision.h"
#include "glog/logging.h"
#include "gtest/gtest.h"
#include "gtest_utils.h"
namespace fastdeploy {
#ifdef ENABLE_FLYCV
TEST(fastdeploy, flycv_pad_to_size_1) {
CheckShape check_shape;
CheckData check_data;
CheckType check_type;
cv::Mat mat(64, 21, CV_8UC3);
cv::randu(mat, cv::Scalar::all(0), cv::Scalar::all(255));
cv::Mat mat1 = mat.clone();
vision::Mat mat_opencv(mat);
vision::Mat mat_flycv(mat1);
vision::Cast::Run(&mat_opencv, "float", vision::ProcLib::OPENCV);
vision::Cast::Run(&mat_flycv, "float", vision::ProcLib::FLYCV);
vision::PadToSize::Run(&mat_opencv, 102, 77, {1, 12, 13}, vision::ProcLib::OPENCV);
vision::PadToSize::Run(&mat_flycv, 102, 77, {1, 12, 13}, vision::ProcLib::FLYCV);
FDTensor opencv;
FDTensor flycv;
mat_opencv.ShareWithTensor(&opencv);
mat_flycv.ShareWithTensor(&flycv);
check_shape(opencv.shape, flycv.shape);
check_data(reinterpret_cast<const float*>(opencv.Data()), reinterpret_cast<const float*>(flycv.Data()), opencv.Numel());
check_type(opencv.dtype, flycv.dtype);
}
TEST(fastdeploy, flycv_pad_to_size_2) {
CheckShape check_shape;
CheckData check_data;
CheckType check_type;
cv::Mat mat(64, 21, CV_8UC3);
cv::randu(mat, cv::Scalar::all(0), cv::Scalar::all(255));
cv::Mat mat1 = mat.clone();
vision::Mat mat_opencv(mat);
vision::Mat mat_flycv(mat1);
vision::PadToSize::Run(&mat_opencv, 102, 77, {0.5, 12, 13}, vision::ProcLib::OPENCV);
vision::PadToSize::Run(&mat_flycv, 102, 77, {0.5, 12, 13}, vision::ProcLib::FLYCV);
FDTensor opencv;
FDTensor flycv;
mat_opencv.ShareWithTensor(&opencv);
mat_flycv.ShareWithTensor(&flycv);
check_shape(opencv.shape, flycv.shape);
check_data(reinterpret_cast<const uint8_t*>(opencv.Data()), reinterpret_cast<const uint8_t*>(flycv.Data()), opencv.Numel());
check_type(opencv.dtype, flycv.dtype);
}
#endif
} // namespace fastdeploy

View File

@@ -0,0 +1,104 @@
// Copyright (c) 2022 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 <array>
#include <vector>
#include "fastdeploy/vision.h"
#include "glog/logging.h"
#include "gtest/gtest.h"
#include "gtest_utils.h"
namespace fastdeploy {
#ifdef ENABLE_FLYCV
TEST(fastdeploy, flycv_limit_resize1) {
CheckShape check_shape;
CheckData check_data;
CheckType check_type;
cv::Mat mat(35, 69, CV_8UC3);
cv::randu(mat, cv::Scalar::all(0), cv::Scalar::all(255));
cv::Mat mat1 = mat.clone();
vision::Mat mat_opencv(mat);
vision::Mat mat_flycv(mat1);
vision::Resize::Run(&mat_opencv, 38, 19, -1, -1, 1, false, vision::ProcLib::OPENCV);
vision::Resize::Run(&mat_flycv, 38, 19, -1, -1, 1, false, vision::ProcLib::FLYCV);
FDTensor opencv;
FDTensor flycv;
mat_opencv.ShareWithTensor(&opencv);
mat_flycv.ShareWithTensor(&flycv);
check_shape(opencv.shape, flycv.shape);
check_type(opencv.dtype, flycv.dtype);
check_data(reinterpret_cast<const uint8_t*>(opencv.Data()), reinterpret_cast<const uint8_t*>(flycv.Data()), opencv.Numel(), 1);
}
TEST(fastdeploy, flycv_limit_resize2) {
CheckShape check_shape;
CheckData check_data;
CheckType check_type;
cv::Mat mat(35, 69, CV_8UC3);
cv::randu(mat, cv::Scalar::all(0), cv::Scalar::all(255));
cv::Mat mat1 = mat.clone();
vision::Mat mat_opencv(mat);
vision::Mat mat_flycv(mat1);
vision::Cast::Run(&mat_opencv, "float", vision::ProcLib::OPENCV);
vision::Cast::Run(&mat_flycv, "float", vision::ProcLib::FLYCV);
vision::Resize::Run(&mat_opencv, 38, 19, -1, -1, 1, false, vision::ProcLib::OPENCV);
vision::Resize::Run(&mat_flycv, 38, 19, -1, -1, 1, false, vision::ProcLib::FLYCV);
FDTensor opencv;
FDTensor flycv;
mat_opencv.ShareWithTensor(&opencv);
mat_flycv.ShareWithTensor(&flycv);
check_shape(opencv.shape, flycv.shape);
check_type(opencv.dtype, flycv.dtype);
check_data(reinterpret_cast<const float*>(opencv.Data()), reinterpret_cast<const float*>(flycv.Data()), opencv.Numel(), 1);
}
TEST(fastdeploy, flycv_limit_resize3) {
CheckShape check_shape;
CheckData check_data;
CheckType check_type;
cv::Mat mat(35, 69, CV_8UC3);
cv::randu(mat, cv::Scalar::all(0), cv::Scalar::all(255));
cv::Mat mat1 = mat.clone();
vision::Mat mat_opencv(mat);
vision::Mat mat_flycv(mat1);
vision::Resize::Run(&mat_opencv, 38, 19, -1, -1, 0, false, vision::ProcLib::OPENCV);
vision::Resize::Run(&mat_flycv, 38, 19, -1, -1, 0, false, vision::ProcLib::FLYCV);
FDTensor opencv;
FDTensor flycv;
mat_opencv.ShareWithTensor(&opencv);
mat_flycv.ShareWithTensor(&flycv);
check_shape(opencv.shape, flycv.shape);
check_type(opencv.dtype, flycv.dtype);
check_data(reinterpret_cast<const uint8_t*>(opencv.Data()), reinterpret_cast<const uint8_t*>(flycv.Data()), opencv.Numel(), 1);
}
#endif
} // namespace fastdeploy

View File

@@ -0,0 +1,104 @@
// Copyright (c) 2022 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 <array>
#include <vector>
#include "fastdeploy/vision.h"
#include "glog/logging.h"
#include "gtest/gtest.h"
#include "gtest_utils.h"
namespace fastdeploy {
#ifdef ENABLE_FLYCV
TEST(fastdeploy, flycv_limit_resize_by_short1) {
CheckShape check_shape;
CheckData check_data;
CheckType check_type;
cv::Mat mat(35, 69, CV_8UC3);
cv::randu(mat, cv::Scalar::all(0), cv::Scalar::all(255));
cv::Mat mat1 = mat.clone();
vision::Mat mat_opencv(mat);
vision::Mat mat_flycv(mat1);
vision::ResizeByShort::Run(&mat_opencv, 104, 1, false, {}, vision::ProcLib::OPENCV);
vision::ResizeByShort::Run(&mat_flycv, 104, 1, false, {}, vision::ProcLib::FLYCV);
FDTensor opencv;
FDTensor flycv;
mat_opencv.ShareWithTensor(&opencv);
mat_flycv.ShareWithTensor(&flycv);
check_shape(opencv.shape, flycv.shape);
check_type(opencv.dtype, flycv.dtype);
check_data(reinterpret_cast<const uint8_t*>(opencv.Data()), reinterpret_cast<const uint8_t*>(flycv.Data()), opencv.Numel(), 1);
}
//TEST(fastdeploy, flycv_limit_resize_by_short2) {
// CheckShape check_shape;
// CheckData check_data;
// CheckType check_type;
//
// cv::Mat mat(35, 69, CV_8UC3);
// cv::randu(mat, cv::Scalar::all(0), cv::Scalar::all(255));
// cv::Mat mat1 = mat.clone();
//
// vision::Mat mat_opencv(mat);
// vision::Mat mat_flycv(mat1);
// vision::Cast::Run(&mat_opencv, "float", vision::ProcLib::OPENCV);
// vision::Cast::Run(&mat_flycv, "float", vision::ProcLib::FLYCV);
// vision::Resize::Run(&mat_opencv, 38, 19, -1, -1, 1, false, vision::ProcLib::OPENCV);
// vision::Resize::Run(&mat_flycv, 38, 19, -1, -1, 1, false, vision::ProcLib::FLYCV);
//
// FDTensor opencv;
// FDTensor flycv;
//
// mat_opencv.ShareWithTensor(&opencv);
// mat_flycv.ShareWithTensor(&flycv);
//
// check_shape(opencv.shape, flycv.shape);
// check_type(opencv.dtype, flycv.dtype);
// check_data(reinterpret_cast<const float*>(opencv.Data()), reinterpret_cast<const float*>(flycv.Data()), opencv.Numel(), 1);
//}
//
//TEST(fastdeploy, flycv_limit_resize_by_stride3) {
// CheckShape check_shape;
// CheckData check_data;
// CheckType check_type;
//
// cv::Mat mat(35, 69, CV_8UC3);
// cv::randu(mat, cv::Scalar::all(0), cv::Scalar::all(255));
// cv::Mat mat1 = mat.clone();
//
// vision::Mat mat_opencv(mat);
// vision::Mat mat_flycv(mat1);
// vision::Resize::Run(&mat_opencv, 38, 19, -1, -1, 0, false, vision::ProcLib::OPENCV);
// vision::Resize::Run(&mat_flycv, 38, 19, -1, -1, 0, false, vision::ProcLib::FLYCV);
//
// FDTensor opencv;
// FDTensor flycv;
//
// mat_opencv.ShareWithTensor(&opencv);
// mat_flycv.ShareWithTensor(&flycv);
//
// check_shape(opencv.shape, flycv.shape);
// check_type(opencv.dtype, flycv.dtype);
// check_data(reinterpret_cast<const uint8_t*>(opencv.Data()), reinterpret_cast<const uint8_t*>(flycv.Data()), opencv.Numel(), 1);
//}
#endif
} // namespace fastdeploy

View File

@@ -0,0 +1,78 @@
// Copyright (c) 2022 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 <array>
#include <vector>
#include "fastdeploy/vision.h"
#include "glog/logging.h"
#include "gtest/gtest.h"
#include "gtest_utils.h"
namespace fastdeploy {
#ifdef ENABLE_FLYCV
TEST(fastdeploy, flycv_stride_pad_1) {
CheckShape check_shape;
CheckData check_data;
CheckType check_type;
cv::Mat mat(65, 21, CV_8UC3);
cv::randu(mat, cv::Scalar::all(0), cv::Scalar::all(255));
cv::Mat mat1 = mat.clone();
vision::Mat mat_opencv(mat);
vision::Mat mat_flycv(mat1);
vision::Cast::Run(&mat_opencv, "float", vision::ProcLib::OPENCV);
vision::Cast::Run(&mat_flycv, "float", vision::ProcLib::FLYCV);
vision::StridePad::Run(&mat_opencv, 64, {0.5, 12, 13}, vision::ProcLib::OPENCV);
vision::StridePad::Run(&mat_flycv, 64, {0.5, 12, 13}, vision::ProcLib::FLYCV);
FDTensor opencv;
FDTensor flycv;
mat_opencv.ShareWithTensor(&opencv);
mat_flycv.ShareWithTensor(&flycv);
check_shape(opencv.shape, flycv.shape);
check_data(reinterpret_cast<const float*>(opencv.Data()), reinterpret_cast<const float*>(flycv.Data()), opencv.Numel());
check_type(opencv.dtype, flycv.dtype);
}
TEST(fastdeploy, flycv_stride_pad_2) {
CheckShape check_shape;
CheckData check_data;
CheckType check_type;
cv::Mat mat(65, 21, CV_8UC3);
cv::randu(mat, cv::Scalar::all(0), cv::Scalar::all(255));
cv::Mat mat1 = mat.clone();
vision::Mat mat_opencv(mat);
vision::Mat mat_flycv(mat1);
vision::StridePad::Run(&mat_opencv, 64, {0.5, 12, 13}, vision::ProcLib::OPENCV);
vision::StridePad::Run(&mat_flycv, 64, {0.5, 12, 13}, vision::ProcLib::FLYCV);
FDTensor opencv;
FDTensor flycv;
mat_opencv.ShareWithTensor(&opencv);
mat_flycv.ShareWithTensor(&flycv);
check_shape(opencv.shape, flycv.shape);
check_data(reinterpret_cast<const uint8_t*>(opencv.Data()), reinterpret_cast<const uint8_t*>(flycv.Data()), opencv.Numel());
check_type(opencv.dtype, flycv.dtype);
}
#endif
} // namespace fastdeploy