[GSOC 2019] Global sampling matting

modules/ximgproc/CMakeLists.txt

@@ -1,2 +1,2 @@
 set(the_description "Extended image processing module. It includes edge-aware filters and etc.")
-ocv_define_module(ximgproc opencv_core opencv_imgproc opencv_calib3d opencv_imgcodecs WRAP python java)
+ocv_define_module(ximgproc opencv_core opencv_highgui opencv_imgproc opencv_calib3d opencv_imgcodecs WRAP python java)

modules/ximgproc/README.md

@@ -16,3 +16,4 @@ Extended Image Processing
 - Pei&Lin Normalization
 - Ridge Detection Filter
 - Binary morphology on run-length encoded images
+- Global sampling method for matting

modules/ximgproc/include/opencv2/ximgproc.hpp

@@ -59,6 +59,7 @@
 #include "ximgproc/run_length_morphology.hpp"
 #include "ximgproc/edgepreserving_filter.hpp"
 #include "ximgproc/color_match.hpp"
+#include "ximgproc/globalmatting.hpp"
 
 
 /** @defgroup ximgproc Extended Image Processing

modules/ximgproc/include/opencv2/ximgproc/globalmatting.hpp

@@ -0,0 +1,109 @@
+#ifndef GLOBAL_MATTING_H
+#define GLOBAL_MATTING_H
+
+#include <opencv2/highgui.hpp>
+#include <opencv2/imgproc.hpp>
+#include <opencv2/ximgproc/edge_filter.hpp>
+
+#include <string>
+#include <cstdlib>
+
+// for sorting the boundary pixels according to intensity
+struct IntensityComp
+{
+    IntensityComp(const cv::Mat_<cv::Vec3b> &img_temp) : img(img_temp)
+    {
+
+    }
+
+    bool operator()(const cv::Point &p0, const cv::Point &p1) const
+    {
+	const cv::Vec3b &c0 = img(p0.y, p0.x);
+	const cv::Vec3b &c1 = img(p1.y, p1.x);
+
+	return ((int)c0[0] + (int)c0[1] + (int)c0[2]) < ((int)c1[0] + (int)c1[1] + (int)c1[2]);
+    }
+
+    const cv::Mat_<cv::Vec3b> &img;
+};
+
+
+
+namespace cv
+{
+
+namespace ximgproc
+{
+class CV_EXPORTS GlobalMatting
+{
+      private:
+
+	template <typename T>
+        inline T sqr(T a)
+        {
+           return a * a;
+        }
+
+
+
+	std::vector<cv::Point> findBoundaryPixels(const cv::Mat_<uchar> &trimap, int a, int b);
+
+	// Eq. 2
+	float calculateAlpha(const cv::Vec3b &F, const cv::Vec3b &B, const cv::Vec3b &I);
+
+	// Eq. 3
+	float colorCost(const cv::Vec3b &F, const cv::Vec3b &B, const cv::Vec3b &I, float alpha);
+
+	// Eq. 4
+	float distCost(const cv::Point &p0, const cv::Point &p1, float minDist);
+
+	float colorDist(const cv::Vec3b &I0, const cv::Vec3b &I1);
+	float nearestDistance(const std::vector<cv::Point> &boundary, const cv::Point &p);
+
+
+
+
+	void expansionOfKnownRegions(const cv::Mat_<cv::Vec3b> &image,
+		                            cv::Mat_<uchar> &trimap,
+                               int r, float c);
+
+	// erode foreground and background regions to increase the size of unknown region
+	void erodeFB(cv::Mat_<uchar> &trimap, int r);
+
+
+
+	struct Sample
+	{
+	    int fi, bj;
+	    float df, db;
+	    float cost, alpha;
+	};
+
+	void calculateAlphaPatchMatch(const cv::Mat_<cv::Vec3b> &image,
+		const cv::Mat_<uchar> &trimap,
+		const std::vector<cv::Point> &foregroundBoundary,
+		const std::vector<cv::Point> &backgroundBoundary,
+		std::vector<std::vector<Sample> > &samples);
+
+	void expansionOfKnownRegionsHelper(const cv::Mat &_image,
+		                                  cv::Mat &_trimap,
+		                                  int r, float c);
+
+
+	// erode foreground and background regions to increase the size of unknown region
+	void erodeFB(cv::Mat &_trimap, int r);
+
+	void expansionOfKnownRegions(cv::InputArray _img, cv::InputOutputArray _trimap, int niter);
+	void globalMattingHelper(cv::Mat _image, cv::Mat _trimap, cv::Mat &_foreground, cv::Mat &_alpha, cv::Mat &_conf);
+        public:
+                GlobalMatting();
+
+		void globalMatting(cv::InputArray _image, cv::InputArray _trimap, cv::OutputArray _foreground, cv::OutputArray _alpha, cv::OutputArray _conf);
+
+                void getMat(cv::Mat image,cv::Mat trimap,cv::Mat &foreground,cv:: Mat &alpha,int niter=9);
+
+};
+
+}
+}
+#endif

modules/ximgproc/samples/globalmatting.cpp

@@ -0,0 +1,45 @@
+#include <opencv2/ximgproc.hpp>
+#include <iostream>
+#include <opencv2/core.hpp>
+#include <opencv2/highgui.hpp>
+
+using namespace std;
+using namespace cv;
+using namespace ximgproc;
+int main(int argc,char** argv)
+{
+    if(argc<3)
+    {
+      cout<<"arg1: Directory of Input image"<<endl;
+      cout<<"arg2: Directory of its trimap"<<endl;
+      cout<<"arg3(optional): Enter the number of iterations to run expansion of trimap"<<endl;
+      return -1;
+    }
+    string img_path = argv[1];
+    string tri_path = argv[2];
+    int niter = 9;
+    if(argc==4)
+    {
+      niter = atoi(argv[3]);
+    }
+    cv::Mat image = cv::imread(img_path, cv::IMREAD_COLOR);
+    cv::Mat trimap = cv::imread(tri_path, cv::IMREAD_GRAYSCALE);
+    if(image.empty() || trimap.empty())
+    {
+       cout<<"Could not load the inputs"<<endl;
+       return -2;
+    }
+    // (optional) exploit the affinity of neighboring pixels to reduce the
+    // size of the unknown region. please refer to the paper
+    // 'Shared Sampling for Real-Time Alpha Matting'.
+
+    cv::Mat foreground, alpha;
+
+    GlobalMatting gm;
+
+    gm.getMat(image,trimap,foreground,alpha,niter);
+
+    cv::imwrite("alpha-matte.png", alpha);
+
+    return 0;
+}