the last commit to the program

Author: xin-xinhanggao

clone.cpp

@@ -93,7 +93,53 @@ void computeWeightedGradientVectorField(cv::InputArray background,
     cv::addWeighted(vyf, weightForeground, vyb, 1.f - weightForeground, 0, vy);
 }
 
-    
+void seamlessCloneNaive(cv::InputArray background,
+                 cv::InputArray foreground,
+                 cv::InputArray foregroundMask,
+                 int offsetX,
+                 int offsetY,
+                 cv::OutputArray destination,
+                 CloneType type)
+{
+  // Copy original background as we only solve for the overlapping area of the translated foreground mask.
+        background.getMat().copyTo(destination);
+        
+        // Find overlapping region. We will only perform on this region
+        cv::Rect rbg, rfg;
+        if (!findOverlap(background, foreground, offsetX, offsetY, rbg, rfg))
+            return;
+        
+        // Compute the guidance vector field
+        cv::Mat vx, vy;
+        computeWeightedGradientVectorField(background.getMat()(rbg),foreground.getMat()(rfg), vx, vy, 1.f);
+        
+        
+        // For the Poisson equation the divergence of the guidance field is necessary.
+        cv::Mat vxx, vyy;
+        cv::Mat kernelx = (cv::Mat_<float>(1, 3) << -0.5, 0, 0.5);
+        cv::Mat kernely = (cv::Mat_<float>(3, 1) << -0.5, 0, 0.5);
+        cv::filter2D(vx, vxx, CV_32F, kernelx);
+        cv::filter2D(vy, vyy, CV_32F, kernely);
+        
+        cv::Mat f = vxx + vyy;
+                
+        cv::Mat boundaryMask(rfg.size(), CV_8UC1);      
+        cv::threshold(foregroundMask.getMat()(rfg), boundaryMask, UNKNOWN, DIRICHLET_BD, cv::THRESH_BINARY_INV);
+        cv::rectangle(boundaryMask, cv::Rect(0, 0, boundaryMask.cols, boundaryMask.rows), DIRICHLET_BD, 1);
+
+        cv::Mat boundaryValues(rfg.size(), CV_MAKETYPE(CV_32F, background.channels()));
+        background.getMat()(rbg).convertTo(boundaryValues, CV_32F);
+        // Solve Poisson equation
+        cv::Mat result;
+        solvePoissonEquations(f,
+                              boundaryMask,
+                              boundaryValues,
+                              result);
+        
+        // Copy result to destination image.
+        result.convertTo(destination.getMat()(rbg), CV_8U);
+}
+
 void seamlessClone(cv::InputArray background,
                  cv::InputArray foreground,
                  cv::InputArray foregroundMask,
@@ -126,27 +172,6 @@ void seamlessClone(cv::InputArray background,
 
     cv::Mat foreValues(rfg.size(), CV_MAKETYPE(CV_32F, foreground.channels()));
     foreground.getMat()(rfg).convertTo(foreValues, CV_32F);
-    /*
-    cv::Mat image = boundaryMask;
-    int nr=image.rows;
-    int nc=image.cols;
-    if(image.isContinuous())
-    {
-        nr=1;
-        nc=nc*image.rows*image.channels();
-    }
-    for(int i=0;i<nr;i++)
-    {
-       const uchar* inData=image.ptr<uchar>(i);
-       for(int j=0;j<nc;j++)
-       {
-         std::cout<<int(*inData++)<<std::endl;
-
-       }
-    }
-    */
-
-
 
     // Solve Poisson equation
     cv::Mat result;

clone.h

@@ -67,5 +67,12 @@ void seamlessClone(cv::InputArray background,
                    cv::OutputArray destination,
                    CloneType type);
 
+void seamlessCloneNaive(cv::InputArray background,
+                   cv::InputArray foreground,
+                   cv::InputArray foregroundMask,
+                   int offsetX,
+                   int offsetY,
+                   cv::OutputArray destination,
+                   CloneType type);
 
 #endif