c++ function call by value not work

Question

I have a problem with this code:

The problem is when I see the image original, is modified by "borrarFondo()" but this function is called from "segmentarHoja" and here entry img by value, but img modifies.

void borrarFondo(Mat& img){
   img = ~img;
   Mat background;
   medianBlur(img, background, 45);
   GaussianBlur(background, background, Size(203,203),101,101);
   img = img - background;
   img = ~img;
}

void segmentarHoja(Mat img, Mat& imsheet){
   Mat imgbw;
   borrarFondo(img); //borrarFondo is called from here where img is a copy
   cvtColor(img, imgbw, CV_BGR2GRAY);
   threshold(imgbw, imgbw, 0, 255, CV_THRESH_BINARY | CV_THRESH_OTSU);
   Mat element = getStructuringElement(MORPH_ELLIPSE, Size(21,21));
   erode(imgbw, imgbw, element);
   vector<vector<Point> > contoursSheet; 
   findContours(imgbw, contoursSheet, CV_RETR_CCOMP, CV_CHAIN_APPROX_SIMPLE);
   vector<Rect> boundSheet(contoursSheet.size());
   int largest_area=0;

   for( int i = 0; i< contoursSheet.size(); i++ )
   {
        double a= contourArea( contoursSheet[i],false);
        if(a>largest_area){
           largest_area=a; 
           boundSheet[i] = boundingRect(contoursSheet[i]);
           imsheet=img(boundSheet[i]).clone(); 
        }
    }
    borrarFondo(imsheet);
  }

int main()
{
    Mat imsheet;
    image= imread("c:/imagen.jpg");
    segmentarHoja(image, imsheet);

    imshow("imsheet",imsheet);
    imshow("imagen",image); //original image by amending borrarFondo 
    waitKey(0);
}

I don't want to change original image

Answer 1

if you're doing something like this:

Mat a;
Mat b = a;

or like this:

void func(Mat m) {...}

or :

vector<Mat> vm; 
vm.push_back(m);

all of it is a shallow copy. the Mat header will be a copy, the pointers inside, too.

so, e.g. in the 1st example, b and a share the same size and data members

this might explain, why passing a Mat by value still results in pixels manipulated from the 'shallow' copy.

to avoid that you will have to do a 'deep' copy instead:

Mat c = a.clone(); // c has its own pixels now.

and again, if you don't want your Mat to be manipulated, pass it as a const Mat & be very careful about how you use it, as illustrated below.

#include <opencv2/opencv.hpp>

void foo( cv::Mat const& image )
{
    cv::Mat result = image;
    cv::ellipse(
        result,                     // img
        cv::Point( 300, 300 ),        // center
        cv::Size( 50, 50 ),         // axes (bounding box size)
        0.0,                        // angle
        0.0,                        // startAngle
        360.0,                      // endAngle
        cv::Scalar_<int>( 0, 0, 255 ),  // color
        6                           // thickness
        );
}

auto main() -> int
{
    auto window_name = "Display";
    cv::Mat lenna = cv::imread( "lenna.png" );
    foo( lenna );
    imshow( window_name, lenna );
    cv::waitKey( 0 );
}

The Mat const& lied about mutability, and Lenna’s nose is correspondingly long, here marked by a big fat circle placed by the foo function above:

Answer 2

opencv Mat is a counted reference (i.e. like std::shared_ptr, except different syntax) where copy construction or assignment does not copy. use the clone method to copy. read the documentation, always a good idea.