[feat] add DynamicThreshold(), Stretching(), Variance(), TwoLineIntersection()

Author: zzo30802

.gitignore

@@ -0,0 +1,49 @@
+# Prerequisites
+*.d
+
+# Compiled Object files
+*.slo
+*.lo
+*.o
+*.obj
+
+# Precompiled Headers
+*.gch
+*.pch
+
+# Compiled Dynamic libraries
+*.so
+*.dylib
+*.dll
+
+# Fortran module files
+*.mod
+*.smod
+
+# Compiled Static libraries
+*.lai
+*.la
+*.a
+*.lib
+
+# Executables
+*.exe
+*.out
+*.app
+
+#others
+build/CMakeCache.txt
+build/cmake_install.cmake
+build/Makefile
+build/CMakeFiles/*
+build/lib/*
+build/bin/*
+build/ALL_BUILD.vcxproj
+build/ALL_BUILD.vcxproj.filters
+build/ZERO_CHECK.vcxproj
+build/ZERO_CHECK.vcxproj.filters
+build/x64
+build/computervision.dir
+build/computervision.sln
+build/computervision.vcxproj
+build/computervision.vcxproj.filters

include/common.h

@@ -4,6 +4,7 @@
 #include <cmath>
 #include <experimental/filesystem>
 #include <iostream>
+#include <memory>
 #include <string>
 #include <vector>
 
@@ -23,4 +24,50 @@ static std::unique_ptr<T> make_unique(Args &&...args) {
   return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
 }
 
+inline int LoadFolderPath(const std::string &folder_path, std::vector<std::string> &img_path_vector, std::vector<std::string> &img_filename_vector) {
+  std::cout << "LoadFolderPath() start" << std::endl;
+  if (!folder_path.empty()) {
+    if (!boost::filesystem::exists(folder_path)) {
+      std::cout << "Folder : " << folder_path << " does not exist." << std::endl;
+      return -1;
+    }
+    // boost::regex pattern(folder_path + "/[0-9]*.png");
+    boost::filesystem::directory_iterator end_itr;
+    for (boost::filesystem::directory_iterator itr(folder_path); itr != end_itr; ++itr) {
+      if (boost::filesystem::is_directory(itr->status())) {
+      } else if ((itr->path().extension() == ".png") || (itr->path().extension() == ".bmp")) {
+        std::string imgpath = itr->path().string();
+        // std::cout << "imgpath : " << imgpath << std::endl;
+        img_path_vector.push_back(itr->path().string());
+        img_filename_vector.push_back(itr->path().filename().stem().string());
+      }
+      // else if (boost::regex_match(itr->path().string(), pattern)){
+      //   img_path_vector.push_back(itr->path().string());
+      // }
+    }
+  }
+  std::cout << "LoadFolderPath() end" << std::endl;
+  return 0;
+}
+
+inline int ConvertMatToGrayscale(const cv::Mat &src, cv::Mat &gray_dst) {
+  const int &&channel = src.channels();
+  switch (channel) {
+    case 1: {
+      gray_dst = cv::Mat::zeros(src.size(), CV_8UC1);
+      gray_dst = src.clone();
+      break;
+    }
+    case 3: {
+      gray_dst = cv::Mat::zeros(src.size(), CV_8UC1);
+      cv::cvtColor(src, gray_dst, cv::COLOR_BGR2GRAY, 1);
+      break;
+    }
+    default: {
+      std::cout << "  --> int ConvertMatToGrayscale (cv::Mat)src.channels != 1 || 3" << std::endl;
+      return -1;
+    }
+  }
+  return 0;
+}
 #endif  //_COMMON_H_

include/component/image_proc.h

@@ -0,0 +1,44 @@
+#ifndef _IMAGE_PROC_H_
+#define _IMAGE_PROC_H_
+
+#include "common.h"
+
+namespace ipo {
+
+enum class DynamicThresholdTypes {
+  DYNAMIC_THRES_LIGHT = 0,
+  DYNAMIC_THRES_DARK = 1,
+  DYNAMIC_THRES_LIGHT_AND_DARK_INRANGE = 2,
+  DYNAMIC_THRES_LIGHT_OR_DARK_OUTRANGE = 3,
+};
+
+/**
+ * @brief Calculate the diff value between subtraction of grayscale image and fuzzy image. If the value exceed the offset value, then it equal to 255, and vice versa.
+ * @param src input image.
+ * @param dst output image.
+ * @param blur_ksize blurring kernel size.
+ * @param offset diff value.
+ * @param mode dynamic threshold mode.
+**/
+int DynamicThreshold(const cv::Mat &src, cv::Mat &dst,
+                     const int &blur_ksize, const int &offset,
+                     const DynamicThresholdTypes &mode);
+/**
+ * @brief Refer to the B&C function of imageJ to stretch the pixel value
+ *  between low_value and high_value. If it exceeds high_value, it is 255, and it
+ *  is 0 if it is less than low_value.
+ * @param src input image.
+ * @param dst output image.
+ * @param low_value Low threshold.
+ * @param high_value High threshold.
+**/
+int Stretching(const cv::Mat &src, cv::Mat &dst,
+               const int &low_value, const int &high_value);
+/**
+ * 
+**/
+int Variance(const cv::Mat &src, cv::Mat &dst, const int &kernel_size);
+cv::Point TwoLineIntersection(const cv::Point &x1_start, const cv::Point &x1_end,
+                              const cv::Point &x2_start, const cv::Point &x2_end);
+}  // namespace ipo
+#endif  // _IMAGE_PROC_H_

include/error_code/error_code.h

@@ -0,0 +1,4 @@
+#ifndef _ERROR_CODE_H_
+#define _ERROR_CODE_H_
+// class
+#endif  // _ERROR_CODE_H_

main.cpp

@@ -0,0 +1,15 @@
+#include "component/image_proc.h"
+
+// cv::Mat ImgProcTestFunc(cv::)
+
+int main() {
+  // ---load image---
+  cv::Mat &&src = cv::imread("D:\\images\\Kenmec\\20210208\\13.png");
+  // cv::Mat &&dst = cv::Mat::zeros(src.size(), src.type());
+  cv::Mat dst;
+  // std::shared_ptr<ipo::ImageProc> obj = std::make_shared<ipo::ImageProc>();
+  ipo::DynamicThreshold(src, dst, 21, 10, ipo::DynamicThresholdTypes::DYNAMIC_THRES_LIGHT);
+  cv::imshow("dst", dst);
+  cv::waitKey(0);
+  return 0;
+}