Beispiel #1
0
void watershedWithErosion(Mat &in, Mat &dispImg1, Mat &out){ //in->adapThreshImg1
    Mat element1 = getStructuringElement( MORPH_ELLIPSE, Size( 2*1+1, 2*1+1 ), Point(1, 1));
    Mat element3 = getStructuringElement( MORPH_ELLIPSE, Size( 2*3+1, 2*3+1 ), Point(3, 3));
    Mat ero;
    erode(in, ero, element1);
    imshow("erosion", ero);
    Mat dil;
    dilate(in, dil, element3);
    Mat bg;
    threshold(dil, bg, 1, 128, 1);
    imshow("bg", bg);
    Mat markers;
    add(ero, bg, markers);
    WatershedSegmenter segmenter;
    segmenter.setMarkers(markers);
    Mat dispImg1Clone = dispImg1.clone();
    out = segmenter.process(dispImg1Clone);
    out.convertTo(out,CV_8UC3);
    imshow("final_result", out);
    /*
        for(int j = 0; j < height; j++){
            for(int i = 0; i < width; i++){
                if(markers.at<uchar>(j,i) == 0){
                    dispImg1.data[dispImg1.channels()*(dispImg1.cols*j + i)+0] = 81;
                    dispImg1.data[dispImg1.channels()*(dispImg1.cols*j + i)+1] = 172;
                    dispImg1.data[dispImg1.channels()*(dispImg1.cols*j + i)+2] = 251;
                }
            }
        }*/
}
bool Segmentation::watershed_segmentation(std::string image_name)//, PointCloudElement* pElement)
{
	cv::Mat src;
	cv::Mat median_image;
	cv::Mat binary;

	src = cv::imread(path + "/Results/" +image_name, 1);
	cv::medianBlur (src, median_image, 5);
    cv::cvtColor(median_image, binary, CV_BGR2GRAY);
	
	 cv::Scalar temp_mean;
	 cv::Scalar temp_std;
	 cv::Scalar temp_mode = cv_matrix_mode (binary); // on the test tile of the test point cloud is 109
	 cv::meanStdDev(binary, temp_mean, temp_std, cv::Mat());
	 double mean = temp_mean.val[0];
	 double std = temp_std.val[0];
	 double mode = temp_mode.val[0];
	 segmentation_msg += "Tile " + StringUtilities::toDisplayString(k_for_process_all_point_cloud) + "\n" + "MEAN \n" + StringUtilities::toDisplayString(mean) + "\n"+ "STD DEV \n"+StringUtilities::toDisplayString(std)+ "\n" + "MODE \n"+StringUtilities::toDisplayString(mode)+ "\n\n";

	cv::threshold(binary, binary, mode + std::max(9.0, 1.1*(mean - mode)), 255, cv::THRESH_BINARY_INV); 

	// Eliminate noise and smaller objects c++
     cv::Mat fg;
     cv::erode(binary, fg, cv::Mat(), cv::Point(-1,-1), 2);
	
    // Identify image pixels without objects
    cv::Mat bg;
    cv::dilate(binary, bg, cv::Mat(), cv::Point(-1,-1), 3);
    cv::threshold(bg, bg, 1, 128, cv::THRESH_BINARY_INV);

    // Create markers image
    cv::Mat markers(binary.size(),CV_8U,cv::Scalar(0));
    markers = fg + bg;

    // Create watershed segmentation object 
    WatershedSegmenter segmenter;
    segmenter.setMarkers(markers);

    cv::Mat result = segmenter.process(median_image);
    
	 ////////////////// DISABLED WARNINGS AS ERRORS ///////////////////////
	// these lines are needed to remove the tiles contours (watershed identifies as building countours also the tile contours, and I need to remove them otherwise there are problems with the connected component method)
	 result.col(1).copyTo(result.col(0)); // I disabled the warning treated as errors: to re-enable, add the enable warnings property sheet (see http://opticks.org/irclogs/%23opticks/%23opticks.2014-05-27-Tue.txt)
	 result.col(result.cols-2).copyTo(result.col(result.cols-1));//http://stackoverflow.com/questions/6670818/opencv-c-copying-a-row-column-in-a-mat-to-another
	 result.row(1).copyTo(result.row(0)); // I disabled the warning treated as errors: to re-enable, add the enable warnings property sheet
	 result.row(result.rows-2).copyTo(result.row(result.rows-1));

	// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
	 result_tiles_array[k_for_process_all_point_cloud] = result; // this line must be commented when using only one tile //
	// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
	
	result.convertTo(result, CV_8U);

	cv::waitKey(0);
	return true;
}
int main(int argc, char* argv[])
{
    cv::Mat image = cv::imread(argv[1]);
    resize(image,image,Size(image.rows/10,image.cols/10));

    int64_t st=getTickCount();
    cv::Mat binary;// = cv::imread(argv[2], 0);
    cv::cvtColor(image, binary, CV_BGR2GRAY);
    cv::threshold(binary, binary, 100, 255, THRESH_BINARY);

    imshow("originalimage", image);
    imshow("originalbinary", binary);

    // Eliminate noise and smaller objects
    cv::Mat fg;
    cv::erode(binary,fg,cv::Mat(),cv::Point(-1,-1),2);
    imshow("fg", fg);

    // Identify image pixels without objects
    cv::Mat bg;
    cv::dilate(binary,bg,cv::Mat(),cv::Point(-1,-1),3);
    cv::threshold(bg,bg,1, 128,cv::THRESH_BINARY_INV);
    imshow("bg", bg);

    // Create markers image
    cv::Mat markers(binary.size(),CV_8U,cv::Scalar(0));
    markers= fg+bg;
    imshow("markers", markers);

    // Create watershed segmentation object
    WatershedSegmenter segmenter;
    segmenter.setMarkers(markers);

    cv::Mat result = segmenter.process(image);
    result.convertTo(result,CV_8U);
    imshow("final_result", result);
    int64_t et=getTickCount();
    float cost_time=(et-st)*1000.0/getTickFrequency();
    std::cout<<"cost time="<<cost_time<<"ms"<<std::endl;

    cv::waitKey(0);

    return 0;
}
Beispiel #4
0
int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
    Mat binary = imread("/Users/Haoyang/Downloads/Pics/binary.bmp");
    if(binary.empty())
        qDebug() << "你妹";
    Mat fg;
    erode(binary,fg,cv::Mat(),Point(-1,-1),6);
    Mat bg;
    dilate(binary,bg,cv::Mat(),Point(-1,-1),6);
    threshold(bg,bg,1,128,cv::THRESH_BINARY_INV);
    cv::Mat marker(binary.size(),CV_8U,cv::Scalar(0));
    marker = bg + fg;

    WatershedSegmenter * ws = new WatershedSegmenter;
    ws->setMarkers(marker);
    Mat result = ws->process(binary);

    namedWindow("Result");
    imshow("Result",result);
    return a.exec();
}
int main (int argc, char* argv[]) {

    Mat image = imread(argv[1]);
    Mat binary;
    cvtColor(image, binary, CV_RGB2GRAY);
    threshold(binary, binary, 10, 255, THRESH_BINARY);

    imshow("originalimage", image);
    imshow("originalbinary", binary);

    // Eliminate noise and smaller objects
    Mat fg;
    erode(binary,fg,Mat(),Point(-1,-1),2);
    imshow("fg", fg);

    // Identify image pixels without objects
    Mat bg;
    dilate(binary,bg,Mat(),Point(-1,-1),3);
    threshold(bg,bg,1, 128,THRESH_BINARY_INV);
    imshow("bg", bg);

    // Create markers image
    Mat markers(binary.size(),CV_8U,Scalar(0));
    markers= fg+bg;
    imshow("markers", markers);

    // Create watershed segmentation object
    WatershedSegmenter segmenter;
    segmenter.setMarkers(markers);

    Mat result = segmenter.process(image);
    result.convertTo(result,CV_8U);
    imshow("final_result", result);

    waitKey(0);

    return 0;
}
cv::Mat PathDetect::WatershedImage(const cv::Mat& input) const
{
    // Create markers image
    cv::Mat markers(input.size(),CV_8U,cv::Scalar(0));
    for (int i = 0; i < input.rows; ++i)
    {
        for (int j = 0; j < input.cols; ++j)
        {
            unsigned char value = 0;
            double r = input.at<cv::Vec3b>(i,j)[2];
            double g = input.at<cv::Vec3b>(i,j)[1];
            double b = input.at<cv::Vec3b>(i,j)[0];
            if (r > g && r > b) value = PATH;
            if (g > r && g > b) value = NOT_PATH;

            markers.at<unsigned char>(i,j) = value;
        }
    }
    // Create watershed segmentation object
    WatershedSegmenter segmenter;
    segmenter.setMarkers(markers);

    return   segmenter.process(input);
}
/** @function main */
int main( int argc, char** argv )
{
			Mat image = imread("tiger1.jpeg",1);



			Mat image_gray;
			cvtColor(image,image_gray,CV_RGB2GRAY);
			GaussianBlur(image_gray,image_gray,Size(5,5),0,0);



			Mat image_t;
			threshold(image_gray,image_t,150,255,1);
			namedWindow("tre");
			imshow("tre",image_t);

			Mat image_cool;
			threshold(image,image_cool,150,255,2);
			namedWindow("cool");
			imshow("cool",image_cool);


			Mat fg;
			erode(image_t,fg,Mat(),Point(-1,-1),6);

			namedWindow("foreground");
			imshow("foreground",fg);

			Mat bg;
			dilate(image_t,bg,Mat(),Point(-1,-1),6);
			threshold(bg,bg,1,128,THRESH_BINARY_INV);
			namedWindow("bg");
			imshow("bg",bg);

			Mat markers(image_t.size(),CV_8U,Scalar(0));
			markers = fg+bg;

			Mat xy;
			xy = fg +  bg;




			WatershedSegmenter seg;
			seg.setMarkers(markers);
			seg.process(image);

			namedWindow("dilated");
			imshow("dilated",xy);













			waitKey(0);

	        return 0;
}
Beispiel #8
0
int main()
{
    //ocl::setUseOpenCL(true);
    
    VideoCapture video("/Users/sonhojun/Downloads/data/all.mp4");
    
    if(!video.isOpened())
    {
        cout<<"video open error"<<endl;
        return 0 ;
    }
    Mat pri;
    Mat aft;
    Mat binary;
    Mat frame1,frame2;
    
    while (1)
    {
        
        video.read(frame1);
        video.read(frame2);
        
//        Mat cropFrame1, cropFrame2;
//        Mat oriConv = frame1(Rect(10,340,700,200));
//        
////        cropFrame1 = frame1(Rect(10,340,700,200));
////        cropFrame2 = frame2(Rect(10,340,700,200));
//        
//        Mat grayImage1,grayImage2;
//        Mat differenceImage;
//        Mat thresholdImage;
//        Vec<double,4> totalDiff = 0.0;
//        
//        cropFrame1 = frame1(Rect(10,340,700,200));
//        cvtColor(cropFrame1, grayImage1, COLOR_BGR2GRAY);
//        
//        cropFrame2 =frame2(Rect(10,340,700,200));
//        
//        cvtColor(cropFrame2, grayImage2, COLOR_BGR2GRAY);
//        absdiff(grayImage1,grayImage2,differenceImage);
//        
//        totalDiff = sum(differenceImage) / (690 * 140);
//        cout << "sum diff: " <<totalDiff<<endl;
//        
//        if(totalDiff[0] > 14.0)
//            continue;
//        
//        threshold(differenceImage, thresholdImage, SENSITIVITY_VALUE, 255, THRESH_BINARY);
//        
//        blur(thresholdImage, thresholdImage , Size(BLUR_SIZE,BLUR_SIZE));
//        
//        threshold(thresholdImage,thresholdImage,SENSITIVITY_VALUE,255,THRESH_BINARY);
//        
//        
//        //if tracking enabled, search for contours in our thresholded image
//
//        //searchForMovement(thresholdImage, oriConv);
//        
//        
//        //show our captured frame
//        imshow("moving",thresholdImage);
        
      
       // imshow("ori",temp);
        Mat cropRGB = frame2(Rect(10,340,700,200));
        Mat cropG;
        cvtColor(cropRGB, cropG, CV_RGB2GRAY);
        GaussianBlur(cropG, cropG, Size(5,5), 0,0);
        threshold(cropG,binary,0,255,THRESH_OTSU|THRESH_BINARY);
      //  adaptiveThreshold(cropG, binary, 255, <#int adaptiveMethod#>, THRESH_OTSU|THRESH_BINARY, 3, 0.);
       // bitwise_xor(thresholdImage,binary,binary);
        imshow("bin",binary);
      
        Mat fg;
        
        erode(binary, fg, Mat(), Point(-1, -1), 6);

        namedWindow("Foreground Image");
        imshow("Foreground Image", fg);

        Mat bg;
        dilate(binary,bg,Mat(),Point(-1,-1),6);
        threshold(bg,bg,1,128,THRESH_BINARY_INV);

        namedWindow("Background Image");
        imshow("Background Image",bg);

//        Mat dist;
//        distanceTransform(binary, dist, CV_DIST_L2, 5);
//        normalize(dist, dist, 0, 1., NORM_MINMAX);
//        imshow("dist",dist);
//        
//        threshold(dist, dist, .4, 1., CV_THRESH_BINARY);
//                // Dilate a bit the dist image
//        Mat kernel1 = Mat::ones(3, 3, CV_8UC1);
//        dilate(dist, dist, kernel1);
//        imshow("Peaks", dist);
        
        Mat markers(binary.size(),CV_8U,Scalar(0));
        markers= fg+bg;

        namedWindow("Markers");
        imshow("Markers",markers);
        
        WatershedSegmenter segmenter;
        
        segmenter.setMarkers(markers);
        segmenter.process(cropRGB);

        namedWindow("Segmentation");
        imshow("Segmentation",segmenter.getSegmentation());
        
       // segmenter.getSegmentation()
//        namedWindow("Watersheds"); // 워터쉐드 띄워 보기
//        imshow("Watersheds",segmenter.getWatersheds());
        
        
        
        
//111        Mat kernel = Mat::ones(3,3,CV_8U);
//        
//        Mat morpho;
//        morphologyEx(binary,morpho,MORPH_OPEN,kernel);
//        
//        imshow("open",morpho);
//        
//        Mat sure_bg;
//        dilate(morpho,sure_bg,kernel);
//        
//        imshow("dilate",sure_bg);
//        
//        Mat dist;
//        distanceTransform(binary, dist, CV_DIST_L2, 5);
//        // Normalize the distance image for range = {0.0, 1.0}
//        // so we can visualize and threshold it
//        normalize(dist, dist, 0, 1., NORM_MINMAX);
//        imshow("Distance Transform Image", dist);
//        // Threshold to obtain the peaks
//        // This will be the markers for the foreground objects
//        threshold(dist, dist, .4, 1., CV_THRESH_BINARY);
//        // Dilate a bit the dist image
//        Mat kernel1 = Mat::ones(3, 3, CV_8UC1);
//        dilate(dist, dist, kernel1);
//        imshow("Peaks", dist);
//        // Create the CV_8U version of the distance image
//        // It is needed for findContours()
//        Mat dist_8u;
//        dist.convertTo(dist_8u, CV_8U);
//        // Find total markers
//        vector<vector<Point> > contours;
//        findContours(dist_8u, contours, CV_RETR_EXTERNAL, CV_CHAIN_APPROX_SIMPLE);
//        // Create the marker image for the watershed algorithm
//        Mat markers = Mat::zeros(dist.size(), CV_32SC1);
//        // Draw the foreground markers
//        for (size_t i = 0; i < contours.size(); i++)
//            drawContours(markers, contours, static_cast<int>(i), Scalar::all(static_cast<int>(i)+1), -1);
//        // Draw the background marker
//        circle(markers, Point(5,5), 3, CV_RGB(255,255,255), -1);
//        imshow("Markers", markers*10000);
//        // Perform the watershed algorithm
//        watershed(cropRGB, markers);
////        Mat mark = Mat::zeros(markers.size(), CV_8UC1);
////        markers.convertTo(mark, CV_8UC1);
////        bitwise_not(mark, mark);
////        imshow("Markers_v2", mark); // uncomment this if you want to see how the mark
//        // image looks like at that point
//        // Generate random colors
//        vector<Vec3b> colors;
//        for (size_t i = 0; i < contours.size(); i++)
//        {
//            int b = theRNG().uniform(0, 255);
//            int g = theRNG().uniform(0, 255);
//            int r = theRNG().uniform(0, 255);
//            colors.push_back(Vec3b((uchar)b, (uchar)g, (uchar)r));
//        }
//        // Create the result image
//        Mat dst = Mat::zeros(markers.size(), CV_8UC3);
//        // Fill labeled objects with random colors
//        for (int i = 0; i < markers.rows; i++)
//        {
//            for (int j = 0; j < markers.cols; j++)
//            {
//                int index = markers.at<int>(i,j);
//                if (index > 0 && index <= static_cast<int>(contours.size()))
//                    dst.at<Vec3b>(i,j) = colors[index-1];
//                else
//                    dst.at<Vec3b>(i,j) = Vec3b(0,0,0);
//            }
//        }
//        // Visualize the final image
//        imshow("Final Result", dst);
//        
//    
// 111       1

        cvWaitKey(10);
    }
    
    return 0;
}
int imageProcess(cv::Mat frame)
{

int countLabel = 0;

//ROS_INFO("Part 4");

    Mat grayFrame;
//ROS_INFO("Part 5");

    cvtColor(frame,grayFrame,CV_RGB2GRAY);
//ROS_INFO("Part 6");

    //Watershed Segmentation


        // Get the binary map
           cv::Mat binary;
           //binary = cv::imread("binary.bmp", 0); // prevent loading of pre-converted image
           cvtColor(frame, grayFrame, CV_BGR2GRAY); // instead convert original
           grayFrame = grayFrame < 60; // apply threshold

           // Display the binary image
           cv::namedWindow("Binary Image");
        //   cv::imshow("Binary Image", grayFrame);

           // Eliminate noise and smaller objects
           cv::Mat fg;
           cv::erode(grayFrame, fg, cv::Mat(), cv::Point(-1, -1), 6);

           // Display the foreground image
        //   cv::namedWindow("Foreground Image");
        //   cv::imshow("Foreground Image", fg);

           // Identify image pixels without objects
           cv::Mat bg;
           cv::dilate(grayFrame, bg, cv::Mat(), cv::Point(-1, -1), 6);
           cv::threshold(bg, bg, 1, 128, cv::THRESH_BINARY_INV);

           // Display the background image
          // cv::namedWindow("Background Image");
         //  cv::imshow("Background Image", bg);

           // Show markers image
           cv::Mat markers(grayFrame.size(), CV_8U, cv::Scalar(0));
           markers = fg + bg;
          // cv::namedWindow("Markers");
         //  cv::imshow("Markers", markers);

          // Create watershed segmentation object
           WatershedSegmenter segmenter;
           // Set markers and process
           segmenter.setMarkers(markers);
           segmenter.process(frame);
//ROS_INFO("Part 7");
   cv::Mat mutableImage;
   mutableImage = segmenter.getSegmentation();
   
   string name = "simpleWall";
   
   std::stringstream sstm;
   sstm << name << hallwayCenter;
   ++countLabel;
   
   imwrite(sstm.str()+".jpg", segmenter.getSegmentation());

   cv::namedWindow("testVision");
   cv::imshow("testVision",mutableImage);
  // cv::imwrite("imgForPoster", mutableImage);

//ROS_INFO("Part 8");

   //Set starting x,y values

           int y_ex= 260;
           int x_ex= 320;


//ROS_INFO("Part 9");

Scalar intensity; 

           for (int i=x_ex; i>0; i--) {
//ROS_INFO("Part 9.1");
        	   Scalar intensity = (int)mutableImage.at<uchar>(y_ex, i);
//ROS_INFO("Part 9.2");
        	   Scalar intensity1 = (int)mutableImage.at<uchar>(y_ex, i-10);
//ROS_INFO("Part 9.3");
        	   int floorVal= (int)*intensity.val;
//ROS_INFO("Part 9.4");
        	   int floorVal1= (int)*intensity1.val;

           if (floorVal==128 && floorVal1!= 128 ){
//ROS_INFO("Part 9.41");
        	           		   a1=i;

           }


           }

//ROS_INFO("Part 10");

           for (int i=x_ex; i<590; i++) {
        	   Scalar intensity = (int)mutableImage.at<uchar>(y_ex, i);
        	   Scalar intensity2 = (int)mutableImage.at<uchar>(y_ex, i+30);
        	   int floorVal= (int)*intensity.val;
        	   int floorVal2= (int)*intensity2.val;

        	   if(floorVal==128 && floorVal2 != 128) {
        		   a2=i;
        	   }
           }

//ROS_INFO("Part 11");

           hallwayCenter=(a1+a2)/2;
           int imageCenter= 300;
//ROS_INFO("Part 12");
           int error= hallwayCenter-imageCenter;

//ROS_INFO("Part 13");

     	   double tempYawValue= error*kValue;

	   double yawArray[10000];
   
           yawArray[countLabel] = tempYawValue;
           
           


           //MAIN Y Value for ROS implemenation. Should be teling me where the center is in relation to one of the walls.
//ROS_INFO("Part 14");

            putText(mutableImage, "X", cvPoint(hallwayCenter,y_ex), 0, 2.5, cvScalar(0,0,0,255), 3, CV_AA);
             cout<<"It is working "<<hallwayCenter;
//ROS_INFO("Part 15");
 

//ROS_INFO("Part 16");
ROS_INFO("Frame Error:  [%d]", error); 
ros::NodeHandle n; 
ros::Publisher tempYawValue_pub = n.advertise<geometry_msgs::Twist>("cmd_vel", 1000);
geometry_msgs::Twist yaw_access;


yaw_access.angular.z = tempYawValue;


tempYawValue_pub.publish(yaw_access);

for(int i = 0; i < 10000; i++)
{
   ROS_INFO("y[%f] ",yawArray[i]);
}

return tempYawValue;

}
int main()
{
	// Read input image
	cv::Mat image= cv::imread("../images/group.jpg");
	if (!image.data)
		return 0;

    // Display the image
	cv::namedWindow("Original Image");
	cv::imshow("Original Image",image);

	// Get the binary map
	cv::Mat binary;
	binary= cv::imread("../images/binary.bmp",0);

    // Display the binary image
	cv::namedWindow("Binary Image");
	cv::imshow("Binary Image",binary);

	// Eliminate noise and smaller objects
	cv::Mat fg;
	cv::erode(binary,fg,cv::Mat(),cv::Point(-1,-1),6);

    // Display the foreground image
	cv::namedWindow("Foreground Image");
	cv::imshow("Foreground Image",fg);

	// Identify image pixels without objects
	cv::Mat bg;
	cv::dilate(binary,bg,cv::Mat(),cv::Point(-1,-1),6);
	cv::threshold(bg,bg,1,128,cv::THRESH_BINARY_INV);

    // Display the background image
	cv::namedWindow("Background Image");
	cv::imshow("Background Image",bg);

	// Show markers image
	cv::Mat markers(binary.size(),CV_8U,cv::Scalar(0));
	markers= fg+bg;
	cv::namedWindow("Markers");
	cv::imshow("Markers",markers);

	// Create watershed segmentation object
	WatershedSegmenter segmenter;

	// Set markers and process
	segmenter.setMarkers(markers);
	segmenter.process(image);

	// Display segmentation result
	cv::namedWindow("Segmentation");
	cv::imshow("Segmentation",segmenter.getSegmentation());

	// Display watersheds
	cv::namedWindow("Watersheds");
	cv::imshow("Watersheds",segmenter.getWatersheds());

	// Open another image
	image= cv::imread("../images/tower.jpg");
    if (!image.data)
        return 0;

	// Identify background pixels
	cv::Mat imageMask(image.size(),CV_8U,cv::Scalar(0));
	cv::rectangle(imageMask,cv::Point(5,5),cv::Point(image.cols-5,image.rows-5),cv::Scalar(255),3);
	// Identify foreground pixels (in the middle of the image)
	cv::rectangle(imageMask,cv::Point(image.cols/2-10,image.rows/2-10),
						 cv::Point(image.cols/2+10,image.rows/2+10),cv::Scalar(1),10);

	// Set markers and process
	segmenter.setMarkers(imageMask);
	segmenter.process(image);

    // Display the image with markers
	cv::rectangle(image,cv::Point(5,5),cv::Point(image.cols-5,image.rows-5),cv::Scalar(255,255,255),3);
	cv::rectangle(image,cv::Point(image.cols/2-10,image.rows/2-10),
						 cv::Point(image.cols/2+10,image.rows/2+10),cv::Scalar(1,1,1),10);
	cv::namedWindow("Image with marker");
	cv::imshow("Image with marker",image);

	// Display watersheds
	cv::namedWindow("Watersheds of foreground object");
	cv::imshow("Watersheds of foreground object",segmenter.getWatersheds());

	// Open another image
	image= cv::imread("../images/tower.jpg");

	// define bounding rectangle
	cv::Rect rectangle(50,70,image.cols-150,image.rows-180);

	cv::Mat result; // segmentation result (4 possible values)
	cv::Mat bgModel,fgModel; // the models (internally used)
	// GrabCut segmentation
	cv::grabCut(image,    // input image
		        result,   // segmentation result
				rectangle,// rectangle containing foreground
				bgModel,fgModel, // models
				1,        // number of iterations
				cv::GC_INIT_WITH_RECT); // use rectangle

	// Get the pixels marked as likely foreground
	cv::compare(result,cv::GC_PR_FGD,result,cv::CMP_EQ);
	// Generate output image
	cv::Mat foreground(image.size(),CV_8UC3,cv::Scalar(255,255,255));
	image.copyTo(foreground,result); // bg pixels not copied

	// draw rectangle on original image
	cv::rectangle(image, rectangle, cv::Scalar(255,255,255),1);
	cv::namedWindow("Image");
	cv::imshow("Image",image);

	// display result
	cv::namedWindow("Segmented Image");
	cv::imshow("Segmented Image",foreground);

	// Open another image
	image= cv::imread("../images/group.jpg");

	// define bounding rectangle
    cv::Rect rectangle2(10,100,380,180);

	cv::Mat bkgModel,fgrModel; // the models (internally used)
	// GrabCut segmentation
	cv::grabCut(image,  // input image
		        result, // segmentation result
				rectangle2,bkgModel,fgrModel,5,cv::GC_INIT_WITH_RECT);
	// Get the pixels marked as likely foreground
//	cv::compare(result,cv::GC_PR_FGD,result,cv::CMP_EQ);
	result= result&1;
	foreground.create(image.size(),CV_8UC3);
    foreground.setTo(cv::Scalar(255,255,255));
	image.copyTo(foreground,result); // bg pixels not copied

	// draw rectangle on original image
	cv::rectangle(image, rectangle2, cv::Scalar(255,255,255),1);
	cv::namedWindow("Image 2");
	cv::imshow("Image 2",image);

	// display result
	cv::namedWindow("Foreground objects");
	cv::imshow("Foreground objects",foreground);

	cv::waitKey();
	return 0;
}