Merge pull request #1447 from Siddharthk:master

modules/photo/doc/cloning.rst

+Seamless Cloning
+================
+
+.. highlight:: cpp
+
+seamlessClone
+-------------
+Image editing tasks concern either global changes (color/intensity corrections, filters, deformations) or local changes concerned to a selection.
+Here we are interested in achieving local changes, ones that are restricted to a region manually selected (ROI), in a seamless and effortless manner.
+The extent of the changes ranges from slight distortions to complete replacement by novel content.
+
+.. ocv:function:: void seamlessClone( InputArray src, InputArray dst, InputArray mask, Point p, OutputArray blend, int flags)
+
+    :param src: Input 8-bit 3-channel image.
+
+    :param dst: Input 8-bit 3-channel image.
+
+    :param mask: Input 8-bit 1 or 3-channel image.
+
+    :param p: Point in dst image where object is placed.
+
+    :param result: Output image with the same size and type as ``dst``.
+
+    :param flags: Cloning method that could be one of the following:
+
+            * **NORMAL_CLONE**     The power of the method is fully expressed when inserting objects with complex outlines into a new background
+
+            * **MIXED_CLONE**    The classic method, color-based selection and alpha
+                                 masking might be time consuming and often leaves an undesirable halo. Seamless
+                                 cloning, even averaged with the original image, is not effective. Mixed seamless
+                                 cloning based on a loose selection proves effective.
+
+            * **FEATURE_EXCHANGE**     Feature exchange allows the user to replace easily certain
+                                       features of one object by alternative features.
+
+
+
+colorChange
+-----------
+Given an original color image, two differently colored versions of this image can be mixed seamlessly.
+
+.. ocv:function:: void colorChange( InputArray src, InputArray mask, OutputArray dst, float red_mul = 1.0, float green_mul = 1.0, float blue_mul = 1.0)
+
+    :param src: Input 8-bit 3-channel image.
+
+    :param mask: Input 8-bit 1 or 3-channel image.
+
+    :param dst: Output image with the same size and type as  ``src`` .
+
+    :param red_mul: R-channel multiply factor.
+
+    :param green_mul: G-channel multiply factor.
+
+    :param blue_mul: B-channel multiply factor.
+
+Multiplication factor is between .5 to 2.5.
+
+
+illuminationChange
+------------------
+Applying an appropriate non-linear transformation to the gradient field inside the selection and then integrating back with a Poisson
+solver, modifies locally the apparent illumination of an image.
+
+.. ocv:function:: void illuminationChange(InputArray src, InputArray mask, OutputArray dst, float alpha = 0.2, float beta = 0.4)
+
+    :param src: Input 8-bit 3-channel image.
+
+    :param mask: Input 8-bit 1 or 3-channel image.
+
+    :param dst: Output image with the same size and type as  ``src``.
+
+    :param alpha: Value ranges between 0-2.
+
+    :param beta: Value ranges between 0-2.
+
+This is useful to highlight under-exposed foreground objects or to reduce specular reflections.
+
+textureFlattening
+-----------------
+By retaining only the gradients at edge locations, before integrating with the Poisson solver, one washes out the texture of the selected
+region, giving its contents a flat aspect. Here Canny Edge Detector is used.
+
+.. ocv:function:: void textureFlattening(InputArray src, InputArray mask, OutputArray dst, double low_threshold=30 , double high_threshold=45, int kernel_size=3)
+
+    :param src: Input 8-bit 3-channel image.
+
+    :param mask: Input 8-bit 1 or 3-channel image.
+
+    :param dst: Output image with the same size and type as  ``src``.
+
+    :param low_threshold: Range from 0 to 100.
+
+    :param high_threshold: Value > 100.
+
+    :param kernel_size: The size of the Sobel kernel to be used.
+
+**NOTE:**
+
+The algorithm assumes that the color of the source image is close to that of the destination. This assumption means that when the colors don't match, the source image color gets tinted toward the color of the destination image.

modules/photo/doc/decolor.rst

+Decolorization
+==============
+
+.. highlight:: cpp
+
+decolor
+-------
+
+Transforms a color image to a grayscale image. It is a basic tool in digital printing, stylized black-and-white photograph rendering, and in many single channel image processing applications.
+
+.. ocv:function:: void decolor( InputArray src, OutputArray grayscale, OutputArray color_boost )
+
+    :param src: Input 8-bit 3-channel image.
+
+    :param grayscale: Output 8-bit 1-channel image.
+
+    :param color_boost: Output 8-bit 3-channel image.
+
+This function is to be applied on color images.

modules/photo/doc/npr.rst

+Non-Photorealistic Rendering
+============================
+
+.. highlight:: cpp
+
+edgePreservingFilter
+--------------------
+
+Filtering is the fundamental operation in image and video processing. Edge-preserving smoothing filters are used in many different applications.
+
+.. ocv:function:: void edgePreservingFilter(InputArray src, OutputArray dst, int flags = 1, float sigma_s = 60, float sigma_r = 0.4)
+
+    :param src: Input 8-bit 3-channel image.
+
+    :param dst: Output 8-bit 3-channel image.
+
+    :param flags: Edge preserving filters:
+
+            * **RECURS_FILTER**
+
+            * **NORMCONV_FILTER**
+
+    :param sigma_s: Range between 0 to 200.
+
+    :param sigma_r: Range between 0 to 1.
+
+
+detailEnhance
+-------------
+This filter enhances the details of a particular image.
+
+.. ocv:function:: void detailEnhance(InputArray src, OutputArray dst, float sigma_s = 10, float sigma_r = 0.15)
+
+    :param src: Input 8-bit 3-channel image.
+
+    :param dst: Output image with the same size and type as  ``src``.
+
+    :param sigma_s: Range between 0 to 200.
+
+    :param sigma_r: Range between 0 to 1.
+
+
+pencilSketch
+------------
+Pencil-like non-photorealistic line drawing
+
+.. ocv:function:: void pencilSketch(InputArray src, OutputArray dst1, OutputArray dst2, float sigma_s = 60, float sigma_r = 0.07, float shade_factor = 0.02)
+
+    :param src: Input 8-bit 3-channel image.
+
+    :param dst1: Output 8-bit 1-channel image.
+
+    :param dst2: Output image with the same size and type as  ``src``.
+
+    :param sigma_s: Range between 0 to 200.
+
+    :param sigma_r: Range between 0 to 1.
+
+    :param shade_factor: Range between 0 to 0.1.
+
+
+stylization
+-----------
+Stylization aims to produce digital imagery with a wide variety of effects not focused on photorealism. Edge-aware filters are ideal for stylization, as they can abstract regions of low contrast while preserving, or enhancing, high-contrast features.
+
+.. ocv:function:: void stylization(InputArray src, OutputArray dst, float sigma_s = 60, float sigma_r = 0.45)
+
+    :param src: Input 8-bit 3-channel image.
+
+    :param dst: Output image with the same size and type as  ``src``.
+
+    :param sigma_s: Range between 0 to 200.
+
+    :param sigma_r: Range between 0 to 1.

modules/photo/doc/photo.rst

@@ -9,4 +9,7 @@ photo. Computational Photography
 
     inpainting
     denoising
-    hdr_imaging
+    hdr_imaging
\ No newline at end of file
+    decolor
+    cloning
+    npr

modules/photo/include/opencv2/photo.hpp

@@ -47,7 +47,7 @@
 #include "opencv2/imgproc.hpp"
 
 /*! \namespace cv
- Namespace where all the C++ OpenCV functionality resides
+  Namespace where all the C++ OpenCV functionality resides
  */
 namespace cv
 {
@@ -59,26 +59,39 @@ enum
     INPAINT_TELEA = 1 // A. Telea algorithm
 };
 
+enum
+{
+    NORMAL_CLONE = 1,
+    MIXED_CLONE  = 2,
+    MONOCHROME_TRANSFER = 3
+};
+
+enum
+{
+    RECURS_FILTER = 1,
+    NORMCONV_FILTER = 2
+};
+
 //! restores the damaged image areas using one of the available intpainting algorithms
 CV_EXPORTS_W void inpaint( InputArray src, InputArray inpaintMask,
-                           OutputArray dst, double inpaintRadius, int flags );
+        OutputArray dst, double inpaintRadius, int flags );
 
 
 CV_EXPORTS_W void fastNlMeansDenoising( InputArray src, OutputArray dst, float h = 3,
-                                        int templateWindowSize = 7, int searchWindowSize = 21);
+        int templateWindowSize = 7, int searchWindowSize = 21);
 
 CV_EXPORTS_W void fastNlMeansDenoisingColored( InputArray src, OutputArray dst,
-                                               float h = 3, float hColor = 3,
-                                               int templateWindowSize = 7, int searchWindowSize = 21);
+        float h = 3, float hColor = 3,
+        int templateWindowSize = 7, int searchWindowSize = 21);
 
 CV_EXPORTS_W void fastNlMeansDenoisingMulti( InputArrayOfArrays srcImgs, OutputArray dst,
-                                             int imgToDenoiseIndex, int temporalWindowSize,
-                                             float h = 3, int templateWindowSize = 7, int searchWindowSize = 21);
+        int imgToDenoiseIndex, int temporalWindowSize,
+        float h = 3, int templateWindowSize = 7, int searchWindowSize = 21);
 
 CV_EXPORTS_W void fastNlMeansDenoisingColoredMulti( InputArrayOfArrays srcImgs, OutputArray dst,
-                                                    int imgToDenoiseIndex, int temporalWindowSize,
-                                                    float h = 3, float hColor = 3,
-                                                    int templateWindowSize = 7, int searchWindowSize = 21);
+        int imgToDenoiseIndex, int temporalWindowSize,
+        float h = 3, float hColor = 3,
+        int templateWindowSize = 7, int searchWindowSize = 21);
 
 enum { LDR_SIZE = 256 };
 
@@ -288,6 +301,33 @@ public:
 
 CV_EXPORTS_W Ptr<MergeRobertson> createMergeRobertson();
 
+CV_EXPORTS_W void decolor( InputArray src, OutputArray grayscale, OutputArray color_boost);
+
+CV_EXPORTS_W void seamlessClone( InputArray src, InputArray dst, InputArray mask, Point p,
+        OutputArray blend, int flags);
+
+CV_EXPORTS_W void colorChange(InputArray src, InputArray mask, OutputArray dst, float red_mul = 1.0,
+        float green_mul = 1.0, float blue_mul = 1.0);
+
+CV_EXPORTS_W void illuminationChange(InputArray src, InputArray mask, OutputArray dst,
+        float alpha = 0.2, float beta = 0.4);
+
+CV_EXPORTS_W void textureFlattening(InputArray src, InputArray mask, OutputArray dst,
+        double low_threshold = 30, double high_threshold = 45,
+        int kernel_size = 3);
+
+CV_EXPORTS_W void edgePreservingFilter(InputArray src, OutputArray dst, int flags = 1,
+        float sigma_s = 60, float sigma_r = 0.4);
+
+CV_EXPORTS_W void detailEnhance(InputArray src, OutputArray dst, float sigma_s = 10,
+        float sigma_r = 0.15);
+
+CV_EXPORTS_W void pencilSketch(InputArray src, OutputArray dst1, OutputArray dst2,
+        float sigma_s = 60, float sigma_r = 0.07, float shade_factor = 0.02);
+
+CV_EXPORTS_W void stylization(InputArray src, OutputArray dst, float sigma_s = 60,
+        float sigma_r = 0.45);
+
 } // cv
 
 #endif

modules/photo/src/contrast_preserve.cpp

+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+
+#include "precomp.hpp"
+#include "opencv2/photo.hpp"
+#include "math.h"
+#include <vector>
+#include <limits>
+#include <iostream>
+#include "contrast_preserve.hpp"
+
+using namespace std;
+using namespace cv;
+
+void cv::decolor(InputArray _src, OutputArray _dst, OutputArray _color_boost)
+{
+    Mat I = _src.getMat();
+    _dst.create(I.size(), CV_8UC1);
+    Mat dst = _dst.getMat();
+
+    _color_boost.create(I.size(), CV_8UC3);
+    Mat color_boost = _color_boost.getMat();
+
+    if(!I.data )
+    {
+        cout <<  "Could not open or find the image" << endl ;
+        return;
+    }
+    if(I.channels() !=3)
+    {
+        cout << "Input Color Image" << endl;
+        return;
+    }
+
+    // Parameter Setting
+    int maxIter = 15;
+    int iterCount = 0;
+    double tol = .0001;
+    double E = 0;
+    double pre_E = std::numeric_limits<double>::infinity();
+
+    Decolor obj;
+
+    Mat img;
+
+    img = Mat(I.size(),CV_32FC3);
+    I.convertTo(img,CV_32FC3,1.0/255.0);
+
+    // Initialization
+    obj.init();
+
+    vector <double> Cg;
+    vector < vector <double> > polyGrad;
+    vector < vector < int > > comb;
+
+    vector <double> alf;
+
+    obj.grad_system(img,polyGrad,Cg,comb);
+    obj.weak_order(img,alf);
+
+    // Solver
+    Mat Mt = Mat(polyGrad.size(),polyGrad[0].size(), CV_32FC1);
+    obj.wei_update_matrix(polyGrad,Cg,Mt);
+
+    vector <double> wei;
+    obj.wei_inti(comb,wei);
+
+    //////////////////////////////// main loop starting ////////////////////////////////////////
+
+    while(sqrt(pow(E-pre_E,2)) > tol)
+    {
+        iterCount +=1;
+        pre_E = E;
+
+        vector <double> G_pos;
+        vector <double> G_neg;
+
+        vector <double> temp;
+        vector <double> temp1;
+
+        double val = 0.0;
+        for(unsigned int i=0;i< polyGrad[0].size();i++)
+        {
+            val = 0.0;
+            for(unsigned int j =0;j<polyGrad.size();j++)
+                val = val + (polyGrad[j][i] * wei[j]);
+            temp.push_back(val - Cg[i]);
+            temp1.push_back(val + Cg[i]);
+        }
+
+        double pos = 0.0;
+        double neg = 0.0;
+        for(unsigned int i =0;i<alf.size();i++)
+        {
+            pos = ((1 + alf[i])/2) * exp((-1.0 * 0.5 * pow(temp[i],2))/pow(obj.sigma,2));
+            neg = ((1 - alf[i])/2) * exp((-1.0 * 0.5 * pow(temp1[i],2))/pow(obj.sigma,2));
+            G_pos.push_back(pos);
+            G_neg.push_back(neg);
+        }
+
+        vector <double> EXPsum;
+        vector <double> EXPterm;
+
+        for(unsigned int i = 0;i<G_pos.size();i++)
+            EXPsum.push_back(G_pos[i]+G_neg[i]);
+
+        vector <double> temp2;
+
+        for(unsigned int i=0;i<EXPsum.size();i++)
+        {
+            if(EXPsum[i] == 0)
+                temp2.push_back(1.0);
+            else
+                temp2.push_back(0.0);
+        }
+
+        for(unsigned int i =0; i < G_pos.size();i++)
+            EXPterm.push_back((G_pos[i] - G_neg[i])/(EXPsum[i] + temp2[i]));
+
+        double val1 = 0.0;
+        vector <double> wei1;
+
+        for(unsigned int i=0;i< polyGrad.size();i++)
+        {
+            val1 = 0.0;
+            for(unsigned int j =0;j<polyGrad[0].size();j++)
+            {
+                val1 = val1 + (Mt.at<float>(i,j) * EXPterm[j]);
+            }
+            wei1.push_back(val1);
+        }
+
+        for(unsigned int i =0;i<wei.size();i++)
+            wei[i] = wei1[i];
+
+        E = obj.energyCalcu(Cg,polyGrad,wei);
+
+        if(iterCount > maxIter)
+            break;
+
+        G_pos.clear();
+        G_neg.clear();
+        temp.clear();
+        temp1.clear();
+        EXPsum.clear();
+        EXPterm.clear();
+        temp2.clear();
+        wei1.clear();
+    }
+
+    Mat Gray = Mat::zeros(img.size(),CV_32FC1);
+    obj.grayImContruct(wei, img, Gray);
+
+    Gray.convertTo(dst,CV_8UC1,255);
+
+    ///////////////////////////////////       Contrast Boosting   /////////////////////////////////
+
+    Mat lab = Mat(img.size(),CV_8UC3);
+    Mat color = Mat(img.size(),CV_8UC3);
+
+    cvtColor(I,lab,COLOR_BGR2Lab);
+
+    vector <Mat> lab_channel;
+    split(lab,lab_channel);
+
+    dst.copyTo(lab_channel[0]);
+
+    merge(lab_channel,lab);
+
+    cvtColor(lab,color_boost,COLOR_Lab2BGR);
+}

modules/photo/src/npr.cpp

+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "precomp.hpp"
+#include "opencv2/photo.hpp"
+#include <iostream>
+#include <stdlib.h>
+
+#include "npr.hpp"
+
+using namespace std;
+using namespace cv;
+
+void cv::edgePreservingFilter(InputArray _src, OutputArray _dst, int flags, float sigma_s, float sigma_r)
+{
+    Mat I = _src.getMat();
+    _dst.create(I.size(), CV_8UC3);
+    Mat dst = _dst.getMat();
+
+    int h = I.size().height;
+    int w = I.size().width;
+
+    Mat res = Mat(h,w,CV_32FC3);
+    dst.convertTo(res,CV_32FC3,1.0/255.0);
+
+    Domain_Filter obj;
+
+    Mat img = Mat(I.size(),CV_32FC3);
+    I.convertTo(img,CV_32FC3,1.0/255.0);
+
+    obj.filter(img, res, sigma_s, sigma_r, flags);
+
+    convertScaleAbs(res, dst, 255,0);
+}
+
+void cv::detailEnhance(InputArray _src, OutputArray _dst, float sigma_s, float sigma_r)
+{
+    Mat I = _src.getMat();
+    _dst.create(I.size(), CV_8UC3);
+    Mat dst = _dst.getMat();
+
+    int h = I.size().height;
+    int w = I.size().width;
+    float factor = 3.0;
+
+    Mat img = Mat(I.size(),CV_32FC3);
+    I.convertTo(img,CV_32FC3,1.0/255.0);
+
+    Mat res = Mat(h,w,CV_32FC1);
+    dst.convertTo(res,CV_32FC3,1.0/255.0);
+
+    Mat result = Mat(img.size(),CV_32FC3);
+    Mat lab = Mat(img.size(),CV_32FC3);
+    vector <Mat> lab_channel;
+
+    cvtColor(img,lab,COLOR_BGR2Lab);
+    split(lab,lab_channel);
+
+    Mat L = Mat(img.size(),CV_32FC1);
+
+    lab_channel[0].convertTo(L,CV_32FC1,1.0/255.0);
+
+    Domain_Filter obj;
+
+    obj.filter(L, res, sigma_s, sigma_r, 1);
+
+    Mat detail = Mat(h,w,CV_32FC1);
+
+    detail = L - res;
+    multiply(detail,factor,detail);
+    L = res + detail;
+
+    L.convertTo(lab_channel[0],CV_32FC1,255);
+
+    merge(lab_channel,lab);
+
+    cvtColor(lab,result,COLOR_Lab2BGR);
+    result.convertTo(dst,CV_8UC3,255);
+}
+
+void cv::pencilSketch(InputArray _src, OutputArray _dst1, OutputArray _dst2, float sigma_s, float sigma_r, float shade_factor)
+{
+    Mat I = _src.getMat();
+    _dst1.create(I.size(), CV_8UC1);
+    Mat dst1 = _dst1.getMat();
+
+    _dst2.create(I.size(), CV_8UC3);
+    Mat dst2 = _dst2.getMat();
+
+    Mat img = Mat(I.size(),CV_32FC3);
+    I.convertTo(img,CV_32FC3,1.0/255.0);
+
+    Domain_Filter obj;
+
+    Mat sketch = Mat(I.size(),CV_32FC1);
+    Mat color_sketch = Mat(I.size(),CV_32FC3);
+
+    obj.pencil_sketch(img, sketch, color_sketch, sigma_s, sigma_r, shade_factor);
+
+    sketch.convertTo(dst1,CV_8UC1,255);
+    color_sketch.convertTo(dst2,CV_8UC3,255);
+
+}
+
+void cv::stylization(InputArray _src, OutputArray _dst, float sigma_s, float sigma_r)
+{
+    Mat I = _src.getMat();
+    _dst.create(I.size(), CV_8UC3);
+    Mat dst = _dst.getMat();
+
+    Mat img = Mat(I.size(),CV_32FC3);
+    I.convertTo(img,CV_32FC3,1.0/255.0);
+
+    int h = img.size().height;
+    int w = img.size().width;
+
+    Mat res = Mat(h,w,CV_32FC3);
+    Mat magnitude = Mat(h,w,CV_32FC1);
+
+    Domain_Filter obj;
+    obj.filter(img, res, sigma_s, sigma_r, NORMCONV_FILTER);
+
+    obj.find_magnitude(res,magnitude);
+
+    Mat stylized = Mat(h,w,CV_32FC3);
+
+    vector <Mat> temp;
+    split(res,temp);
+    multiply(temp[0],magnitude,temp[0]);
+    multiply(temp[1],magnitude,temp[1]);
+    multiply(temp[2],magnitude,temp[2]);
+    merge(temp,stylized);
+
+    stylized.convertTo(dst,CV_8UC3,255);
+}

modules/photo/src/seamless_cloning.cpp

+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "precomp.hpp"
+#include "opencv2/photo.hpp"
+#include <iostream>
+#include <stdlib.h>
+
+#include "seamless_cloning.hpp"
+
+using namespace std;
+using namespace cv;
+
+void cv::seamlessClone(InputArray _src, InputArray _dst, InputArray _mask, Point p, OutputArray _blend, int flags)
+{
+    Mat src  = _src.getMat();
+    Mat dest = _dst.getMat();
+    Mat mask = _mask.getMat();
+    _blend.create(dest.size(), CV_8UC3);
+    Mat blend = _blend.getMat();
+
+    int minx = INT_MAX, miny = INT_MAX, maxx = INT_MIN, maxy = INT_MIN;
+    int h = mask.size().height;
+    int w = mask.size().width;
+
+    Mat gray = Mat(mask.size(),CV_8UC1);
+    Mat dst_mask = Mat::zeros(dest.size(),CV_8UC1);
+    Mat cs_mask = Mat::zeros(src.size(),CV_8UC3);
+    Mat cd_mask = Mat::zeros(dest.size(),CV_8UC3);
+
+    if(mask.channels() == 3)
+        cvtColor(mask, gray, COLOR_BGR2GRAY );
+    else
+        gray = mask;
+
+    for(int i=0;i<h;i++)
+    {
+        for(int j=0;j<w;j++)
+        {
+            if(gray.at<uchar>(i,j) == 255)
+            {
+                minx = std::min(minx,i);
+                maxx = std::max(maxx,i);
+                miny = std::min(miny,j);
+                maxy = std::max(maxy,j);
+            }
+        }
+    }
+
+    int lenx = maxx - minx;
+    int leny = maxy - miny;
+
+    int minxd = p.y - lenx/2;
+    int maxxd = p.y + lenx/2;
+    int minyd = p.x - leny/2;
+    int maxyd = p.x + leny/2;
+
+    if(minxd < 0 || minyd < 0 || maxxd > dest.size().height || maxyd > dest.size().width)
+    {
+        cout << "Index out of range" << endl;
+        exit(0);
+    }
+
+    Rect roi_d(minyd,minxd,leny,lenx);
+    Rect roi_s(miny,minx,leny,lenx);
+
+    Mat destinationROI = dst_mask(roi_d);
+    Mat sourceROI = cs_mask(roi_s);
+
+    gray(roi_s).copyTo(destinationROI);
+    src(roi_s).copyTo(sourceROI,gray(roi_s));
+
+    destinationROI = cd_mask(roi_d);
+    cs_mask(roi_s).copyTo(destinationROI);
+
+    Cloning obj;
+    obj.normal_clone(dest,cd_mask,dst_mask,blend,flags);
+}
+
+void cv::colorChange(InputArray _src, InputArray _mask, OutputArray _dst, float r, float g, float b)
+{
+    Mat src  = _src.getMat();
+    Mat mask  = _mask.getMat();
+    _dst.create(src.size(), src.type());
+    Mat blend = _dst.getMat();
+
+    float red = r;
+    float green = g;
+    float blue = b;
+
+    Mat gray = Mat::zeros(mask.size(),CV_8UC1);
+
+    if(mask.channels() == 3)
+        cvtColor(mask, gray, COLOR_BGR2GRAY );
+    else
+        gray = mask;
+
+    Mat cs_mask = Mat::zeros(src.size(),CV_8UC3);
+
+    src.copyTo(cs_mask,gray);
+
+    Cloning obj;
+    obj.local_color_change(src,cs_mask,gray,blend,red,green,blue);
+}
+
+
+void cv::illuminationChange(InputArray _src, InputArray _mask, OutputArray _dst, float a, float b)
+{
+
+    Mat src  = _src.getMat();
+    Mat mask  = _mask.getMat();
+    _dst.create(src.size(), src.type());
+    Mat blend = _dst.getMat();
+    float alpha = a;
+    float beta = b;
+
+    Mat gray = Mat::zeros(mask.size(),CV_8UC1);
+
+    if(mask.channels() == 3)
+        cvtColor(mask, gray, COLOR_BGR2GRAY );
+    else
+        gray = mask;
+
+    Mat cs_mask = Mat::zeros(src.size(),CV_8UC3);
+
+    src.copyTo(cs_mask,gray);
+
+    Cloning obj;
+    obj.illum_change(src,cs_mask,gray,blend,alpha,beta);
+
+}
+
+void cv::textureFlattening(InputArray _src, InputArray _mask, OutputArray _dst,
+                           double low_threshold, double high_threshold, int kernel_size)
+{
+
+    Mat src  = _src.getMat();
+    Mat mask  = _mask.getMat();
+    _dst.create(src.size(), src.type());
+    Mat blend = _dst.getMat();
+
+    Mat gray = Mat::zeros(mask.size(),CV_8UC1);
+
+    if(mask.channels() == 3)
+        cvtColor(mask, gray, COLOR_BGR2GRAY );
+    else
+        gray = mask;
+
+    Mat cs_mask = Mat::zeros(src.size(),CV_8UC3);
+
+    src.copyTo(cs_mask,gray);
+
+    Cloning obj;
+    obj.texture_flatten(src,cs_mask,gray,low_threshold,high_threshold,kernel_size,blend);
+}

modules/photo/test/test_cloning.cpp

+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+
+#include "test_precomp.hpp"
+#include "opencv2/photo.hpp"
+#include <string>
+
+using namespace cv;
+using namespace std;
+
+
+TEST(Photo_SeamlessClone_normal, regression)
+{
+    string folder = string(cvtest::TS::ptr()->get_data_path()) + "cloning/Normal_Cloning/";
+    string original_path1 = folder + "source1.png";
+    string original_path2 = folder + "destination1.png";
+    string original_path3 = folder + "mask.png";
+
+    Mat source = imread(original_path1, IMREAD_COLOR);
+    Mat destination = imread(original_path2, IMREAD_COLOR);
+    Mat mask = imread(original_path3, IMREAD_COLOR);
+
+    ASSERT_FALSE(source.empty()) << "Could not load source image " << original_path1;
+    ASSERT_FALSE(destination.empty()) << "Could not load destination image " << original_path2;
+    ASSERT_FALSE(mask.empty()) << "Could not load mask image " << original_path3;
+
+    Mat result;
+    Point p;
+    p.x = destination.size().width/2;
+    p.y = destination.size().height/2;
+    seamlessClone(source, destination, mask, p, result, 1);
+
+    imwrite(folder + "cloned.png", result);
+
+}
+
+TEST(Photo_SeamlessClone_mixed, regression)
+{
+    string folder = string(cvtest::TS::ptr()->get_data_path()) + "cloning/Mixed_Cloning/";
+    string original_path1 = folder + "source1.png";
+    string original_path2 = folder + "destination1.png";
+    string original_path3 = folder + "mask.png";
+
+    Mat source = imread(original_path1, IMREAD_COLOR);
+    Mat destination = imread(original_path2, IMREAD_COLOR);
+    Mat mask = imread(original_path3, IMREAD_COLOR);
+
+    ASSERT_FALSE(source.empty()) << "Could not load source image " << original_path1;
+    ASSERT_FALSE(destination.empty()) << "Could not load destination image " << original_path2;
+    ASSERT_FALSE(mask.empty()) << "Could not load mask image " << original_path3;
+
+    Mat result;
+    Point p;
+    p.x = destination.size().width/2;
+    p.y = destination.size().height/2;
+    seamlessClone(source, destination, mask, p, result, 2);
+
+    imwrite(folder + "cloned.png", result);
+
+}
+
+TEST(Photo_SeamlessClone_featureExchange, regression)
+{
+    string folder = string(cvtest::TS::ptr()->get_data_path()) + "cloning/Monochrome_Transfer/";
+    string original_path1 = folder + "source1.png";
+    string original_path2 = folder + "destination1.png";
+    string original_path3 = folder + "mask.png";
+
+    Mat source = imread(original_path1, IMREAD_COLOR);
+    Mat destination = imread(original_path2, IMREAD_COLOR);
+    Mat mask = imread(original_path3, IMREAD_COLOR);
+
+    ASSERT_FALSE(source.empty()) << "Could not load source image " << original_path1;
+    ASSERT_FALSE(destination.empty()) << "Could not load destination image " << original_path2;
+    ASSERT_FALSE(mask.empty()) << "Could not load mask image " << original_path3;
+
+    Mat result;
+    Point p;
+    p.x = destination.size().width/2;
+    p.y = destination.size().height/2;
+    seamlessClone(source, destination, mask, p, result, 3);
+
+    imwrite(folder + "cloned.png", result);
+
+}
+
+TEST(Photo_SeamlessClone_colorChange, regression)
+{
+    string folder = string(cvtest::TS::ptr()->get_data_path()) + "cloning/color_change/";
+    string original_path1 = folder + "source1.png";
+    string original_path2 = folder + "mask.png";
+
+    Mat source = imread(original_path1, IMREAD_COLOR);
+    Mat mask = imread(original_path2, IMREAD_COLOR);
+
+    ASSERT_FALSE(source.empty()) << "Could not load source image " << original_path1;
+    ASSERT_FALSE(mask.empty()) << "Could not load mask image " << original_path2;
+
+    Mat result;
+    colorChange(source, mask, result, 1.5, .5, .5);
+
+    imwrite(folder + "cloned.png", result);
+
+}
+
+TEST(Photo_SeamlessClone_illuminationChange, regression)
+{
+    string folder = string(cvtest::TS::ptr()->get_data_path()) + "cloning/Illumination_Change/";
+    string original_path1 = folder + "source1.png";
+    string original_path2 = folder + "mask.png";
+
+    Mat source = imread(original_path1, IMREAD_COLOR);
+    Mat mask = imread(original_path2, IMREAD_COLOR);
+
+    ASSERT_FALSE(source.empty()) << "Could not load source image " << original_path1;
+    ASSERT_FALSE(mask.empty()) << "Could not load mask image " << original_path2;
+
+    Mat result;
+    illuminationChange(source, mask, result, .2, .4);
+
+    imwrite(folder + "cloned.png", result);
+
+}
+
+TEST(Photo_SeamlessClone_textureFlattening, regression)
+{
+    string folder = string(cvtest::TS::ptr()->get_data_path()) + "cloning/Texture_Flattening/";
+    string original_path1 = folder + "source1.png";
+    string original_path2 = folder + "mask.png";
+
+    Mat source = imread(original_path1, IMREAD_COLOR);
+    Mat mask = imread(original_path2, IMREAD_COLOR);
+
+    ASSERT_FALSE(source.empty()) << "Could not load source image " << original_path1;
+    ASSERT_FALSE(mask.empty()) << "Could not load mask image " << original_path2;
+
+    Mat result;
+    textureFlattening(source, mask, result, 30, 45, 3);
+
+    imwrite(folder + "cloned.png", result);
+
+}

modules/photo/test/test_decolor.cpp

+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+
+#include "test_precomp.hpp"
+#include "opencv2/photo.hpp"
+#include <string>
+
+using namespace cv;
+using namespace std;
+
+
+TEST(Photo_Decolor, regression)
+{
+        string folder = string(cvtest::TS::ptr()->get_data_path()) + "decolor/";
+        string original_path = folder + "color_image_1.png";
+
+        Mat original = imread(original_path, IMREAD_COLOR);
+
+        ASSERT_FALSE(original.empty()) << "Could not load input image " << original_path;
+        ASSERT_FALSE(original.channels()!=3) << "Load color input image " << original_path;
+
+        Mat grayscale, color_boost;
+        decolor(original, grayscale, color_boost);
+
+        imwrite(folder + "grayscale.png",grayscale);
+        imwrite(folder + "color_boost.png",color_boost);
+
+}

modules/photo/test/test_npr.cpp

+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+
+#include "test_precomp.hpp"
+#include "opencv2/photo.hpp"
+#include <string>
+
+using namespace cv;
+using namespace std;
+
+
+TEST(Photo_NPR_EdgePreserveSmoothing_RecursiveFilter, regression)
+{
+    string folder = string(cvtest::TS::ptr()->get_data_path()) + "npr/";
+    string original_path = folder + "test1.png";
+
+    Mat source = imread(original_path, IMREAD_COLOR);
+
+    ASSERT_FALSE(source.empty()) << "Could not load input image " << original_path;
+
+    Mat result;
+    edgePreservingFilter(source,result,1);
+
+    imwrite(folder + "smoothened_RF.png", result);
+
+}
+
+TEST(Photo_NPR_EdgePreserveSmoothing_NormConvFilter, regression)
+{
+    string folder = string(cvtest::TS::ptr()->get_data_path()) + "npr/";
+    string original_path = folder + "test1.png";
+
+    Mat source = imread(original_path, IMREAD_COLOR);
+
+    ASSERT_FALSE(source.empty()) << "Could not load input image " << original_path;
+
+    Mat result;
+    edgePreservingFilter(source,result,2);
+
+    imwrite(folder + "smoothened_NCF.png", result);
+
+}
+
+TEST(Photo_NPR_DetailEnhance, regression)
+{
+    string folder = string(cvtest::TS::ptr()->get_data_path()) + "npr/";
+    string original_path = folder + "test1.png";
+
+    Mat source = imread(original_path, IMREAD_COLOR);
+
+    ASSERT_FALSE(source.empty()) << "Could not load input image " << original_path;
+
+    Mat result;
+    detailEnhance(source,result);
+
+    imwrite(folder + "detail_enhanced.png", result);
+
+}
+
+TEST(Photo_NPR_PencilSketch, regression)
+{
+    string folder = string(cvtest::TS::ptr()->get_data_path()) + "npr/";
+    string original_path = folder + "test1.png";
+
+    Mat source = imread(original_path, IMREAD_COLOR);
+
+    ASSERT_FALSE(source.empty()) << "Could not load input image " << original_path;
+
+    Mat result,result1;
+    pencilSketch(source,result,result1,10,.1,.03);
+
+    imwrite(folder + "pencil_sketch.png", result);
+    imwrite(folder + "color_pencil_sketch.png", result1);
+
+}
+
+TEST(Photo_NPR_Stylization, regression)
+{
+    string folder = string(cvtest::TS::ptr()->get_data_path()) + "npr/";
+    string original_path = folder + "test1.png";
+
+    Mat source = imread(original_path, IMREAD_COLOR);
+
+    ASSERT_FALSE(source.empty()) << "Could not load input image " << original_path;
+
+    Mat result;
+    stylization(source,result);
+
+    imwrite(folder + "stylized.png", result);
+
+}

samples/cpp/cloning_demo.cpp

+/*
+* cloning_demo.cpp
+*
+* Author:
+* Siddharth Kherada <siddharthkherada27[at]gmail[dot]com>
+*
+* This tutorial demonstrates how to use OpenCV seamless cloning
+* module without GUI.
+*
+* 1- Normal Cloning
+* 2- Mixed Cloning
+* 3- Monochrome Transfer
+* 4- Color Change
+* 5- Illumination change
+* 6- Texture Flattening
+
+* The program takes as input a source and a destination image (for 1-3 methods)
+* and ouputs the cloned image.
+*
+* Download test images from opencv_extra folder @github.
+*
+*/
+
+#include "opencv2/photo.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/core.hpp"
+#include <iostream>
+#include <stdlib.h>
+
+using namespace std;
+using namespace cv;
+
+int main()
+{
+    cout << endl;
+    cout << "Cloning Module" << endl;
+    cout << "---------------" << endl;
+    cout << "Options: " << endl;
+    cout << endl;
+    cout << "1) Normal Cloning " << endl;
+    cout << "2) Mixed Cloning " << endl;
+    cout << "3) Monochrome Transfer " << endl;
+    cout << "4) Local Color Change " << endl;
+    cout << "5) Local Illumination Change " << endl;
+    cout << "6) Texture Flattening " << endl;
+    cout << endl;
+    cout << "Press number 1-6 to choose from above techniques: ";
+    int num = 1;
+    cin >> num;
+    cout << endl;
+
+    if(num == 1)
+    {
+        string folder =  "cloning/Normal_Cloning/";
+        string original_path1 = folder + "source1.png";
+        string original_path2 = folder + "destination1.png";
+        string original_path3 = folder + "mask.png";
+
+        Mat source = imread(original_path1, IMREAD_COLOR);
+        Mat destination = imread(original_path2, IMREAD_COLOR);
+        Mat mask = imread(original_path3, IMREAD_COLOR);
+
+        if(source.empty())
+        {
+            cout << "Could not load source image " << original_path1 << endl;
+            exit(0);
+        }
+        if(destination.empty())
+        {
+            cout << "Could not load destination image " << original_path2 << endl;
+            exit(0);
+        }
+        if(mask.empty())
+        {
+            cout << "Could not load mask image " << original_path3 << endl;
+            exit(0);
+        }
+
+        Mat result;
+        Point p;
+        p.x = 400;
+        p.y = 100;
+
+        seamlessClone(source, destination, mask, p, result, 1);
+
+        imshow("Output",result);
+        imwrite(folder + "cloned.png", result);
+    }
+    else if(num == 2)
+    {
+        string folder = "cloning/Mixed_Cloning/";
+        string original_path1 = folder + "source1.png";
+        string original_path2 = folder + "destination1.png";
+        string original_path3 = folder + "mask.png";
+
+        Mat source = imread(original_path1, IMREAD_COLOR);
+        Mat destination = imread(original_path2, IMREAD_COLOR);
+        Mat mask = imread(original_path3, IMREAD_COLOR);
+
+        if(source.empty())
+        {
+            cout << "Could not load source image " << original_path1 << endl;
+            exit(0);
+        }
+        if(destination.empty())
+        {
+            cout << "Could not load destination image " << original_path2 << endl;
+            exit(0);
+        }
+        if(mask.empty())
+        {
+            cout << "Could not load mask image " << original_path3 << endl;
+            exit(0);
+        }
+
+        Mat result;
+        Point p;
+        p.x = destination.size().width/2;
+        p.y = destination.size().height/2;
+
+        seamlessClone(source, destination, mask, p, result, 2);
+
+        imshow("Output",result);
+        imwrite(folder + "cloned.png", result);
+    }
+    else if(num == 3)
+    {
+        string folder = "cloning/Monochrome_Transfer/";
+        string original_path1 = folder + "source1.png";
+        string original_path2 = folder + "destination1.png";
+        string original_path3 = folder + "mask.png";
+
+        Mat source = imread(original_path1, IMREAD_COLOR);
+        Mat destination = imread(original_path2, IMREAD_COLOR);
+        Mat mask = imread(original_path3, IMREAD_COLOR);
+
+        if(source.empty())
+        {
+            cout << "Could not load source image " << original_path1 << endl;
+            exit(0);
+        }
+        if(destination.empty())
+        {
+            cout << "Could not load destination image " << original_path2 << endl;
+            exit(0);
+        }
+        if(mask.empty())
+        {
+            cout << "Could not load mask image " << original_path3 << endl;
+            exit(0);
+        }
+
+        Mat result;
+        Point p;
+        p.x = destination.size().width/2;
+        p.y = destination.size().height/2;
+
+        seamlessClone(source, destination, mask, p, result, 3);
+
+        imshow("Output",result);
+        imwrite(folder + "cloned.png", result);
+    }
+    else if(num == 4)
+    {
+        string folder = "cloning/Color_Change/";
+        string original_path1 = folder + "source1.png";
+        string original_path2 = folder + "mask.png";
+
+        Mat source = imread(original_path1, IMREAD_COLOR);
+        Mat mask = imread(original_path2, IMREAD_COLOR);
+
+        if(source.empty())
+        {
+            cout << "Could not load source image " << original_path1 << endl;
+            exit(0);
+        }
+        if(mask.empty())
+        {
+            cout << "Could not load mask image " << original_path2 << endl;
+            exit(0);
+        }
+
+        Mat result;
+
+        colorChange(source, mask, result, 1.5, .5, .5);
+
+        imshow("Output",result);
+        imwrite(folder + "cloned.png", result);
+    }
+    else if(num == 5)
+    {
+        string folder = "cloning/Illumination_Change/";
+        string original_path1 = folder + "source1.png";
+        string original_path2 = folder + "mask.png";
+
+        Mat source = imread(original_path1, IMREAD_COLOR);
+        Mat mask = imread(original_path2, IMREAD_COLOR);
+
+        if(source.empty())
+        {
+            cout << "Could not load source image " << original_path1 << endl;
+            exit(0);
+        }
+        if(mask.empty())
+        {
+            cout << "Could not load mask image " << original_path2 << endl;
+            exit(0);
+        }
+
+        Mat result;
+
+        illuminationChange(source, mask, result, .2, .4);
+
+        imshow("Output",result);
+        imwrite(folder + "cloned.png", result);
+    }
+    else if(num == 6)
+    {
+        string folder = "cloning/Texture_Flattening/";
+        string original_path1 = folder + "source1.png";
+        string original_path2 = folder + "mask.png";
+
+        Mat source = imread(original_path1, IMREAD_COLOR);
+        Mat mask = imread(original_path2, IMREAD_COLOR);
+
+        if(source.empty())
+        {
+            cout << "Could not load source image " << original_path1 << endl;
+            exit(0);
+        }
+        if(mask.empty())
+        {
+            cout << "Could not load mask image " << original_path2 << endl;
+            exit(0);
+        }
+
+        Mat result;
+
+        textureFlattening(source, mask, result, 30, 45, 3);
+
+        imshow("Output",result);
+        imwrite(folder + "cloned.png", result);
+    }
+    waitKey(0);
+}

samples/cpp/create_mask.cpp

+/*
+* create_mask.cpp
+*
+* Author:
+* Siddharth Kherada <siddharthkherada27[at]gmail[dot]com>
+*
+* This tutorial demonstrates how to make mask image (black and white).
+* The program takes as input a source image and ouputs its corresponding
+* mask image.
+*/
+
+#include "opencv2/imgproc.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/core.hpp"
+#include <iostream>
+#include <stdlib.h>
+
+using namespace std;
+using namespace cv;
+
+Mat img0, img1, res1, final;
+
+Point point;
+int drag = 0;
+
+int numpts = 100;
+Point* pts = new Point[100];
+
+int var = 0;
+int flag = 0;
+int flag1 = 0;
+
+int minx,miny,maxx,maxy,lenx,leny;
+
+int channel;
+
+void mouseHandler(int, int, int, int, void*);
+
+void mouseHandler(int event, int x, int y, int, void*)
+{
+
+    if (event == EVENT_LBUTTONDOWN && !drag)
+    {
+        if(flag1 == 0)
+        {
+            if(var==0)
+                img1 = img0.clone();
+            point = Point(x, y);
+            circle(img1,point,2,Scalar(0, 0, 255),-1, 8, 0);
+            pts[var] = point;
+            var++;
+            drag  = 1;
+            if(var>1)
+                line(img1,pts[var-2], point, Scalar(0, 0, 255), 2, 8, 0);
+
+            imshow("Source", img1);
+        }
+    }
+
+    if (event == EVENT_LBUTTONUP && drag)
+    {
+        imshow("Source", img1);
+
+        drag = 0;
+    }
+    if (event == EVENT_RBUTTONDOWN)
+    {
+        flag1 = 1;
+        img1 = img0.clone();
+        for(int i = var; i < numpts ; i++)
+            pts[i] = point;
+
+        if(var!=0)
+        {
+            const Point* pts3[1] = {&pts[0]};
+            polylines( img1, pts3, &numpts,1, 1, Scalar(0,0,0), 2, 8, 0);
+        }
+
+        for(int i=0;i<var;i++)
+        {
+            minx = min(minx,pts[i].x);
+            maxx = max(maxx,pts[i].x);
+            miny = min(miny,pts[i].y);
+            maxy = max(maxy,pts[i].y);
+        }
+        lenx = maxx - minx;
+        leny = maxy - miny;
+
+        imshow("Source", img1);
+    }
+
+    if (event == EVENT_RBUTTONUP)
+    {
+        flag = var;
+
+        final = Mat::zeros(img0.size(),CV_8UC3);
+        res1 = Mat::zeros(img0.size(),CV_8UC1);
+        const Point* pts4[1] = {&pts[0]};
+
+        fillPoly(res1, pts4,&numpts, 1, Scalar(255, 255, 255), 8, 0);
+        bitwise_and(img0, img0, final,res1);
+        imshow("mask",res1);
+        imwrite("mask.png",res1);
+
+        imshow("Source", img1);
+
+    }
+    if (event == EVENT_MBUTTONDOWN)
+    {
+        for(int i = 0; i < numpts ; i++)
+        {
+            pts[i].x=0;
+            pts[i].y=0;
+        }
+        var = 0;
+        flag1 = 0;
+        minx = INT_MAX; miny = INT_MAX; maxx = INT_MIN; maxy = INT_MIN;
+        imshow("Source", img0);
+        drag = 0;
+    }
+}
+
+int main(int argc, char **argv)
+{
+
+    if(argc != 2)
+    {
+        cout << "usage: " << argv[0] << " <input_image>" << endl;
+        exit(1);
+    }
+
+    Mat src = imread(argv[1]);
+
+    minx = INT_MAX; miny = INT_MAX; maxx = INT_MIN; maxy = INT_MIN;
+
+    img0 = src;
+
+    channel = img0.channels();
+
+    res1 = Mat::zeros(img0.size(),CV_8UC1);
+    final = Mat::zeros(img0.size(),CV_8UC3);
+    //////////// source image ///////////////////
+
+    namedWindow("Source", 1);
+    setMouseCallback("Source", mouseHandler, NULL);
+    imshow("Source", img0);
+    waitKey(0);
+
+    img0.release();
+    img1.release();
+}

samples/cpp/npr_demo.cpp

+/*
+* npr_demo.cpp
+*
+* Author:
+* Siddharth Kherada <siddharthkherada27[at]gmail[dot]com>
+*
+* This tutorial demonstrates how to use OpenCV Non-Photorealistic Rendering Module.
+* 1) Edge Preserve Smoothing
+*    -> Using Normalized convolution Filter
+*    -> Using Recursive Filter
+* 2) Detail Enhancement
+* 3) Pencil sketch/Color Pencil Drawing
+* 4) Stylization
+*
+*/
+
+#include <signal.h>
+#include "opencv2/photo.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/core.hpp"
+#include <iostream>
+#include <stdlib.h>
+
+using namespace std;
+using namespace cv;
+
+int main(int argc, char* argv[])
+{
+    if(argc < 2)
+    {
+        cout << "usage: " << argv[0] << " <Input image> "  << endl;
+        exit(0);
+    }
+
+    int num,type;
+
+    Mat I = imread(argv[1]);
+
+    if(!I.data)
+    {
+        cout <<  "Image not found" << endl;
+        exit(0);
+    }
+
+    cout << endl;
+    cout << " Edge Preserve Filter" << endl;
+    cout << "----------------------" << endl;
+
+    cout << "Options: " << endl;
+    cout << endl;
+
+    cout << "1) Edge Preserve Smoothing" << endl;
+    cout << "   -> Using Normalized convolution Filter" << endl;
+    cout << "   -> Using Recursive Filter" << endl;
+    cout << "2) Detail Enhancement" << endl;
+    cout << "3) Pencil sketch/Color Pencil Drawing" << endl;
+    cout << "4) Stylization" << endl;
+    cout << endl;
+
+    cout << "Press number 1-4 to choose from above techniques: ";
+
+    cin >> num;
+
+    Mat img;
+
+    if(num == 1)
+    {
+        cout << endl;
+        cout << "Press 1 for Normalized Convolution Filter and 2 for Recursive Filter: ";
+
+        cin >> type;
+
+        edgePreservingFilter(I,img,type);
+        imshow("Edge Preserve Smoothing",img);
+
+    }
+    else if(num == 2)
+    {
+        detailEnhance(I,img);
+        imshow("Detail Enhanced",img);
+    }
+    else if(num == 3)
+    {
+        Mat img1;
+        pencilSketch(I,img1, img, 10 ,.1,.03);
+        imshow("Pencil Sketch",img1);
+        imshow("Color Pencil Sketch",img);
+    }
+    else if(num == 4)
+    {
+        stylization(I,img);
+        imshow("Stylization",img);
+    }
+    waitKey(0);
+}