Add PPMatting Support

.gitignore

@@ -18,4 +18,4 @@ fastdeploy/ThirdPartyNotices*
 *.so*
 fastdeploy/libs/third_libs
 csrc/fastdeploy/core/config.h
-csrc/fastdeploy/pybind/main.cc
+csrc/fastdeploy/pybind/main.cc

csrc/fastdeploy/vision.h

@@ -35,6 +35,7 @@
 #include "fastdeploy/vision/faceid/contrib/partial_fc.h"
 #include "fastdeploy/vision/faceid/contrib/vpl.h"
 #include "fastdeploy/vision/matting/contrib/modnet.h"
+#include "fastdeploy/vision/matting/ppmatting/ppmatting.h"
 #include "fastdeploy/vision/segmentation/ppseg/model.h"
 #endif
 

csrc/fastdeploy/vision/common/processors/limit_short.cc

@@ -0,0 +1,70 @@
+// 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/limit_short.h"
+
+namespace fastdeploy {
+namespace vision {
+
+bool LimitShort::CpuRun(Mat* mat) {
+  cv::Mat* im = mat->GetCpuMat();
+  int origin_w = im->cols;
+  int origin_h = im->rows;
+  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_;
+  }
+  if (target != im_size_min) {
+    double scale =
+        static_cast<double>(target) / static_cast<double>(im_size_min);
+    cv::resize(*im, *im, cv::Size(), scale, scale, interp_);
+    mat->SetWidth(im->cols);
+    mat->SetHeight(im->rows);
+  }
+  return true;
+}
+
+#ifdef ENABLE_OPENCV_CUDA
+bool LimitShort::GpuRun(Mat* mat) {
+  cv::cuda::GpuMat* im = mat->GetGpuMat();
+  int origin_w = im->cols;
+  int origin_h = im->rows;
+  im->convertTo(*im, CV_32FC(im->channels()));
+  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_;
+  }
+  if (target != im_size_min) {
+    double scale =
+        static_cast<double>(target) / static_cast<double>(im_size_min);
+    cv::cuda::resize(*im, *im, cv::Size(), scale, scale, interp_);
+    mat->SetWidth(im->cols);
+    mat->SetHeight(im->rows);
+  }
+  return true;
+}
+#endif
+
+bool LimitShort::Run(Mat* mat, int max_short, int min_short, ProcLib lib) {
+  auto r = LimitShort(max_short, min_short);
+  return r(mat, lib);
+}
+}  // namespace vision
+}  // namespace fastdeploy

csrc/fastdeploy/vision/common/processors/limit_short.h

@@ -0,0 +1,44 @@
+// 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 LimitShort : public Processor {
+ public:
+  explicit LimitShort(int max_short = -1, int min_short = -1, int interp = 1) {
+    max_short_ = max_short;
+    min_short_ = min_short;
+    interp_ = interp;
+  }
+  bool CpuRun(Mat* mat);
+#ifdef ENABLE_OPENCV_CUDA
+  bool GpuRun(Mat* mat);
+#endif
+  std::string Name() { return "LimitShort"; }
+
+  static bool Run(Mat* mat, int max_short = -1, int min_short = -1,
+                  ProcLib lib = ProcLib::OPENCV_CPU);
+
+ private:
+  int max_short_;
+  int min_short_;
+  int interp_;
+};
+}  // namespace vision
+}  // namespace fastdeploy

csrc/fastdeploy/vision/common/processors/resize_to_int_mult.cc

@@ -0,0 +1,56 @@
+// 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/resize_to_int_mult.h"
+
+namespace fastdeploy {
+namespace vision {
+
+bool ResizeToIntMult::CpuRun(Mat* mat) {
+  cv::Mat* im = mat->GetCpuMat();
+  int origin_w = im->cols;
+  int origin_h = im->rows;
+  int rw = origin_w - origin_w % mult_int_;
+  int rh = origin_h - origin_h % mult_int_;
+  if (rw != origin_w || rh != origin_w) {
+    cv::resize(*im, *im, cv::Size(rw, rh), 0, 0, interp_);
+    mat->SetWidth(im->cols);
+    mat->SetHeight(im->rows);
+  }
+  return true;
+}
+
+#ifdef ENABLE_OPENCV_CUDA
+bool ResizeToIntMult::GpuRun(Mat* mat) {
+  cv::cuda::GpuMat* im = mat->GetGpuMat();
+  int origin_w = im->cols;
+  int origin_h = im->rows;
+  im->convertTo(*im, CV_32FC(im->channels()));
+  int rw = origin_w - origin_w % mult_int_;
+  int rh = origin_h - origin_h % mult_int_;
+  if (rw != origin_w || rh != origin_w) {
+    cv::cuda::resize(*im, *im, cv::Size(rw, rh), 0, 0, interp_);
+    mat->SetWidth(im->cols);
+    mat->SetHeight(im->rows);
+  }
+  return true;
+}
+#endif
+
+bool ResizeToIntMult::Run(Mat* mat, int mult_int, int interp, ProcLib lib) {
+  auto r = ResizeToIntMult(mult_int, interp);
+  return r(mat, lib);
+}
+}  // namespace vision
+}  // namespace fastdeploy

csrc/fastdeploy/vision/common/processors/resize_to_int_mult.h

@@ -0,0 +1,42 @@
+// 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 ResizeToIntMult : public Processor {
+ public:
+  explicit ResizeToIntMult(int mult_int = 32, int interp = 1) {
+    mult_int_ = mult_int;
+    interp_ = interp;
+  }
+  bool CpuRun(Mat* mat);
+#ifdef ENABLE_OPENCV_CUDA
+  bool GpuRun(Mat* mat);
+#endif
+  std::string Name() { return "ResizeToIntMult"; }
+
+  static bool Run(Mat* mat, int mult_int = 32, int interp = 1,
+                  ProcLib lib = ProcLib::OPENCV_CPU);
+
+ private:
+  int interp_;
+  int mult_int_;
+};
+}  // namespace vision
+}  // namespace fastdeploy

csrc/fastdeploy/vision/common/processors/transform.h

@@ -19,9 +19,11 @@
 #include "fastdeploy/vision/common/processors/color_space_convert.h"
 #include "fastdeploy/vision/common/processors/convert.h"
 #include "fastdeploy/vision/common/processors/hwc2chw.h"
+#include "fastdeploy/vision/common/processors/limit_short.h"
 #include "fastdeploy/vision/common/processors/normalize.h"
 #include "fastdeploy/vision/common/processors/pad.h"
 #include "fastdeploy/vision/common/processors/pad_to_size.h"
 #include "fastdeploy/vision/common/processors/resize.h"
 #include "fastdeploy/vision/common/processors/resize_by_short.h"
+#include "fastdeploy/vision/common/processors/resize_to_int_mult.h"
 #include "fastdeploy/vision/common/processors/stride_pad.h"

csrc/fastdeploy/vision/matting/matting_pybind.cc

@@ -17,10 +17,12 @@
 namespace fastdeploy {
 
 void BindMODNet(pybind11::module& m);
+void BindPPMatting(pybind11::module& m);
 
 void BindMatting(pybind11::module& m) {
   auto matting_module =
       m.def_submodule("matting", "Image object matting models.");
   BindMODNet(matting_module);
+  BindPPMatting(matting_module);
 }
 }  // namespace fastdeploy