コード例 #1
0
ファイル: image.cpp プロジェクト: h005/2Dfeature3
void Image::setNumCorners()
{
    memset(numCorners,0,sizeof(double)*NUM);
    Mat *dst,*dstnorm;
    dst = new Mat();
    dstnorm = new Mat();
    int blockSize = 2;
    int apertureSize = 3;
    double k = 0.04;
    int thresh = 200;

    for(int t=0;t<NUM;t++)
    {
        readInGray(t);
        cornerHarris(*gray,*dst,blockSize,apertureSize,k,BORDER_DEFAULT);
//        normalizing
        normalize(*dst,*dstnorm,0,255,NORM_MINMAX,CV_32FC1,Mat());
//        count corners
        for(int i=0;i<dstnorm->rows;i++)
            for(int j=0;j<dstnorm->cols;j++)
                if((int) dstnorm->at<float>(i,j) >thresh)
                    numCorners[t]++;
        delete gray;
        //cout<<numCorners[t]<<endl;
    }
    delete dst;
    delete dstnorm;
    cout<<"corner...ok"<<endl;
}
コード例 #2
0
ファイル: image.cpp プロジェクト: momolenghun/disparity
// Harris points
vector<Point> harris(const Image<float>& I, double th,int n) {
	vector<Point> v;
	Image<float> H;
	cornerHarris(I,H,10,3,0.04);
	for (int y=n;y<I.height()-n;y++)
		for (int x=n;x<I.width()-n;x++)
			if (H(x,y) > th
				&& H(x,y)>H(x,y+1) && H(x,y)>H(x,y-1) && H(x,y)>H(x-1,y-1) && H(x,y)>H(x-1,y)
				&& H(x,y)>H(x-1,y+1) && H(x,y)>H(x+1,y-1) && H(x,y)>H(x+1,y) && H(x,y)>H(x+1,y+1))
				v.push_back(Point(x,y));
	return v;
}
コード例 #3
0
KDvoid CornerHarris ( KDint nIdx )
{
	Mat		tSrc;
	Mat		tGray;
	KDint   nThresh;

	nThresh = 205;

	// Load source image and convert it to gray
	tSrc = imread ( "/res/image/building.png" );
	cvtColor ( tSrc, tGray, CV_BGR2GRAY );

	//
	// Executes the corner detection and draw a circle around the possible corners
	//
	Mat			tCorner;
	Mat			tNorm;
	Mat			tNormScaled;

	// Detector parameters
	KDint		nBlockSize		= 2;
	KDint		nApertureSize	= 3;
	KDdouble	dK				= 0.04;

	tCorner = Mat::zeros ( tSrc.size ( ), CV_32FC1 );

	// Detecting corners
	cornerHarris ( tGray, tCorner, nBlockSize, nApertureSize, dK, BORDER_DEFAULT );

	// Normalizing
	normalize ( tCorner, tNorm, 0, 255, NORM_MINMAX, CV_32FC1, Mat ( ) );
	convertScaleAbs ( tNorm, tNormScaled ); 

	// Drawing a circle around corners
	for ( KDint j = 0; j < tNorm.rows ; j++ )
	{ 
		for ( KDint i = 0; i < tNorm.cols; i++ )
		{
			if( (KDint) tNorm.at<KDfloat> ( j, i ) > nThresh )
			{ 
				circle ( tNormScaled, Point ( i, j ), 5,  Scalar ( 0 ), 2, 8, 0 ); 
			}
		} 
	}    

	g_pController->setFrame ( 1, tSrc );
	g_pController->setFrame ( 2, tNormScaled );
}
コード例 #4
0
void harris(int thresh, Mat img, char *window_name, char *filename)
{
	cout << filename << endl;
	char *filename_cornerless = "harris_cornerless.jpg", *filename_final = "harris_final.jpg";
	Mat dst, dst_norm, dst_norm_scaled;
	Mat img_gray;
	cvtColor(img, img_gray, CV_BGR2GRAY);
	DWORD t1, t2, t;
	dst = Mat::zeros(img.size(), CV_32FC1);

	/// Detector parameters
	int blockSize = 2;
	int count = 0;
	int apertureSize = 3;
	double k = 0.04;

	/// Detecting corners
	t1 = ticks;
	cornerHarris(img_gray, dst, blockSize, apertureSize, k, BORDER_DEFAULT);
	t2 = ticks;
	t = t2 - t1;
	/// Normalizing
	normalize(dst, dst_norm, 0, 255, NORM_MINMAX, CV_32FC1, Mat());
	convertScaleAbs(dst_norm, dst_norm_scaled);
	imwrite(filename_cornerless, dst_norm_scaled);
	/// Drawing a circle around corners
	for(int j = 0; j < dst_norm.rows ; j++)
	{ for(int i = 0; i < dst_norm.cols; i++)
	{
		if((int) dst_norm.at<float>(j,i) > thresh)
		{
			circle(img, Point(i, j), 5,  Scalar(0, 0, 255), 1, 8, 0);
			count++;
		}
	}
	}
	/// Showing the result
	cout << "Harris features detected: " << count << endl << "Time to execute: " << t << endl;
	imwrite(filename, img);
	namedWindow(window_name, CV_WINDOW_AUTOSIZE);
	imshow(window_name, img);
}
コード例 #5
0
ToolsMenu::ToolsMenu(ImageViewer* iv, QWidget* parent) :
    QWidget(parent),
    ui(new Ui::ToolsMenu)
{
    ui->setupUi(this);
    setLayout(ui->verticalLayoutWidget->layout());

    m_viewer = (ImageViewer*) iv;
    m_tools = new Tools(m_viewer, this);

    // locking tools menu when performing transformation

    connect(m_viewer, SIGNAL(lockTools()), this, SLOT(disableAllTools()));
    connect(m_viewer, SIGNAL(unlockTools()), this, SLOT(enableAllTools()));

    /* -------------------------------------------------------
     * ROTATION
     * ------------------------------------------------------- */

    connect(ui->rotate90Button, SIGNAL(clicked()), m_tools, SLOT(rotate90()));
    connect(ui->rotate180Button, SIGNAL(clicked()), m_tools, SLOT(rotate180()));
    connect(ui->rotate270Button, SIGNAL(clicked()), m_tools, SLOT(rotate270()));

    /* -------------------------------------------------------
     * HISTOGRAM
     * ------------------------------------------------------- */

    QMenu* hMenu = new QMenu(ui->histogramButton);
    hMenu->addAction(
                QIcon(":/icons/icons/chart_curve_error.png"),
                QString("Equalize histograms"),
                m_tools,
                SLOT(histogramEqualize())
                );
    hMenu->addAction(
                QIcon(":/icons/icons/chart_curve_go.png"),
                QString("Stretch histograms"),
                m_tools,
                SLOT(histogramStretch())
                );

    ui->histogramButton->setMenu(hMenu);

    /* -------------------------------------------------------
     * FILTERS (convolution, blur)
     * ------------------------------------------------------- */

    QMenu* bMenu = new QMenu(ui->blurButton);
    bMenu->addAction(
                QIcon(":/icons/icons/draw_convolve.png"),
                QString("Gaussian blur"),
                m_tools,
                SLOT(blurGauss())
                );
    bMenu->addAction(
                QIcon(":/icons/icons/draw_convolve.png"),
                QString("Uniform blur"),
                m_tools,
                SLOT(blurUniform())
                );
    bMenu->addAction(
                QIcon(":/icons/icons/flag_airfield_vehicle_safety.png"),
                QString("Custom linear filter"),
                m_tools,
                SLOT(blurLinear())
                );

    ui->blurButton->setMenu(bMenu);

    /* -------------------------------------------------------
     * BINARIZATION
     * ------------------------------------------------------- */

    QMenu* binMenu = new QMenu(ui->binarizationButton);
    binMenu->addAction(
                QIcon(":/icons/icons/universal_binary.png"),
                QString("Manual"),
                m_tools,
                SLOT(binManual())
                );
    binMenu->addAction(
                QIcon(":/icons/icons/universal_binary.png"),
                QString("Gradient"),
                m_tools,
                SLOT(binGradient())
                );
    binMenu->addAction(
                QIcon(":/icons/icons/universal_binary.png"),
                QString("Iterative bimodal"),
                m_tools,
                SLOT(binIterBimodal())
                );
    binMenu->addAction(
                QIcon(":/icons/icons/universal_binary.png"),
                QString("Niblack"),
                m_tools,
                SLOT(binNiblack())
                );
    binMenu->addAction(
                QIcon(":/icons/icons/universal_binary.png"),
                QString("Otsu"),
                m_tools,
                SLOT(binOtsu())
                );

    ui->binarizationButton->setMenu(binMenu);

    /* -------------------------------------------------------
     * NOISE REDUCTION
     * ------------------------------------------------------- */

    QMenu* nMenu = new QMenu(ui->noiseButton);
    nMenu->addAction(
                QIcon(":/icons/icons/checkerboard.png"),
                QString("Median"),
                m_tools,
                SLOT(noiseMedian())
                );
    nMenu->addAction(
                QIcon(":/icons/icons/checkerboard.png"),
                QString("Bilateral"),
                m_tools,
                SLOT(noiseBilateral())
                );

    ui->noiseButton->setMenu(nMenu);

    /* -------------------------------------------------------
     * MORPHOLOGICAL
     * ------------------------------------------------------- */

    QMenu* morphMenu = new QMenu(ui->morphButton);
    morphMenu->addAction(
                QIcon(":/icons/icons/arrow_out.png"),
                QString("Dilate"),
                m_tools,
                SLOT(morphDilate())
                );
    morphMenu->addAction(
                QIcon(":/icons/icons/arrow_in.png"),
                QString("Erode"),
                m_tools,
                SLOT(morphErode())
                );
    morphMenu->addAction(
                QIcon(":/icons/icons/arrow_divide.png"),
                QString("Open"),
                m_tools,
                SLOT(morphOpen())
                );
    morphMenu->addAction(
                QIcon(":/icons/icons/arrow_join.png"),
                QString("Close"),
                m_tools,
                SLOT(morphClose())
                );

    ui->morphButton->setMenu(morphMenu);

    /* -------------------------------------------------------
     * EDGE DETECTION
     * ------------------------------------------------------- */

    QMenu* eMenu = new QMenu(ui->edgeButton);
    eMenu->addAction(
                QIcon(":/icons/icons/key_s.png"),
                QString("Sobel"),
                m_tools,
                SLOT(edgeSobel())
                );
    eMenu->addAction(
                QIcon(":/icons/icons/key_p.png"),
                QString("Prewitt"),
                m_tools,
                SLOT(edgePrewitt())
                );
    eMenu->addAction(
                QIcon(":/icons/icons/key_r.png"),
                QString("Roberts"),
                m_tools,
                SLOT(edgeRoberts())
                );
    eMenu->addAction(
                QIcon(":/icons/icons/edge_detection.png"),
                QString("Laplacian"),
                m_tools,
                SLOT(edgeLaplacian())
                );
    eMenu->addAction(
                QIcon(":/icons/icons/edge_detection.png"),
                QString("Zero-crossing (LoG)"),
                m_tools,
                SLOT(edgeZero())
                );

    eMenu->addAction(
                QIcon(":/icons/icons/edge_detection.png"),
                QString("Canny"),
                m_tools,
                SLOT(edgeCanny())
                );

    ui->edgeButton->setMenu(eMenu);

    /* -------------------------------------------------------
     * TEXTURES
     * ------------------------------------------------------- */

    QMenu* texMenu = new QMenu(ui->textureButton);
    texMenu->addAction(
                QIcon(":/icons/icons/flag_airfield_vehicle_safety.png"),
                QString("Height map"),
                m_tools,
                SLOT(mapHeight())
                );
    texMenu->addAction(
                QIcon(":/icons/icons/flag_airfield_vehicle_safety.png"),
                QString("Normal map"),
                m_tools,
                SLOT(mapNormal())
                );
    texMenu->addAction(
                QIcon(":/icons/icons/flag_airfield_vehicle_safety.png"),
                QString("Horizon map"),
                m_tools,
                SLOT(mapHorizon())
                );
    ui->textureButton->setMenu(texMenu);

    /* -------------------------------------------------------
     * TRANSFORMATIONS
     * ------------------------------------------------------- */

    QMenu* transMenu = new QMenu(ui->transformationsButton);
    transMenu->addAction(
                QIcon(":/icons/icons/videodisplay.png"),
                QString("Hough"),
                m_tools,
                SLOT(houghTransform())
                );
    transMenu->addAction(
                QIcon(":/icons/icons/videodisplay.png"),
                QString("Hough - lines"),
                m_tools,
                SLOT(houghLines())
                );
    transMenu->addAction(
                QIcon(":/icons/icons/videodisplay.png"),
                QString("Hough - rectangles"),
                m_tools,
                SLOT(houghRectangles())
                );
    transMenu->addAction(
                QIcon(":/icons/icons/videodisplay.png"),
                QString("Segmentation"),
                m_tools,
                SLOT(segmentation())
                );
    ui->transformationsButton->setMenu(transMenu);

    /* -------------------------------------------------------
     * CORNER DETECTION
     * ------------------------------------------------------- */

    QMenu* cornerMenu = new QMenu(ui->cornerButton);
    cornerMenu->addAction(
                QIcon(":/icons/icons/things_digital.png"),
                QString("Harris"),
                m_tools,
                SLOT(cornerHarris())
                );
    ui->cornerButton->setMenu(cornerMenu);

}
コード例 #6
0
ファイル: cvfeatureselect.cpp プロジェクト: lubyk/cv
void goodFeaturesToTrack( const Mat& image, vector<Point2f>& corners,
                          int maxCorners, double qualityLevel, double minDistance,
                          const Mat& mask, int blockSize,
                          bool useHarrisDetector, double harrisK )
{
    CV_Assert( qualityLevel > 0 && minDistance >= 0 && maxCorners >= 0 );

    if( mask.data )
        CV_Assert( mask.type() == CV_8UC1 && mask.size() == image.size() );

    Mat eig, tmp;
    if( useHarrisDetector )
        cornerHarris( image, eig, blockSize, 3, harrisK );
    else
        cornerMinEigenVal( image, eig, blockSize, 3 );

    double maxVal = 0;
    minMaxLoc( eig, 0, &maxVal, 0, 0, mask );
    threshold( eig, eig, maxVal*qualityLevel, 0, THRESH_TOZERO );
    dilate( eig, tmp, Mat());

    Size imgsize = image.size();

    vector<const float*> tmpCorners;

    // collect list of pointers to features - put them into temporary image
    for( int y = 1; y < imgsize.height - 1; y++ )
    {
        const float* eig_data = (const float*)eig.ptr(y);
        const float* tmp_data = (const float*)tmp.ptr(y);
        const uchar* mask_data = mask.data ? mask.ptr(y) : 0;

        for( int x = 1; x < imgsize.width - 1; x++ )
        {
            float val = eig_data[x];
            if( val != 0 && val == tmp_data[x] && (!mask_data || mask_data[x]) )
                tmpCorners.push_back(eig_data + x);
        }
    }

    sort( tmpCorners, greaterThanPtr<float>() );
    corners.clear();
    size_t i, j, total = tmpCorners.size(), ncorners = 0;

    if(minDistance >= 1)
    {
         // Partition the image into larger grids
        int w = image.cols;
        int h = image.rows;

        const int cell_size = (int)(minDistance);
        const int grid_width = (float)w / cell_size + 0.5; // round up
        const int grid_height = (float)h / cell_size + 0.5; // round up

        std::vector <  std::vector <Point2f> > grid(grid_width*grid_height);

        minDistance *= minDistance;

        for( i = 0; i < total; i++ )
        {
            int ofs = (int)((const uchar*)tmpCorners[i] - eig.data);
            int y = (int)(ofs / eig.step);
            int x = (int)((ofs - y*eig.step)/sizeof(float));

	        bool good = true;

            int x_cell = x / cell_size;
            int y_cell = y / cell_size;

            int x1 = x_cell - 1;
            int y1 = y_cell - 1;
            int x2 = x_cell + 1;
            int y2 = y_cell + 1;

            // boundary check
            x1 = std::max(0, x1);
            y1 = std::max(0, y1);
            x2 = std::min(grid_width-1, x2);
            y2 = std::min(grid_height-1, y2);

            for( int yy = y1; yy <= y2; yy++ )
            {
                for( int xx = x1; xx <= x2; xx++ )
                {   
                    vector <Point2f> &m = grid[yy*grid_width + xx];

                    if( m.size() )
                    {
                        for(j = 0; j < m.size(); j++)
                        {
                            float dx = x - m[j].x;
                            float dy = y - m[j].y;

                            if( dx*dx + dy*dy < minDistance )
                            {
                                good = false;
                                goto break_out;
                            }
                        }
                    }                
                }
            }

            break_out:

            if(good)
            {
                // printf("%d: %d %d -> %d %d, %d, %d -- %d %d %d %d, %d %d, c=%d\n",
                //    i,x, y, x_cell, y_cell, (int)minDistance, cell_size,x1,y1,x2,y2, grid_width,grid_height,c);
                grid[y_cell*grid_width + x_cell].push_back(Point2f((float)x, (float)y));

                corners.push_back(Point2f((float)x, (float)y));
                ++ncorners;

                if( maxCorners > 0 && (int)ncorners == maxCorners )
                    break;
            }
        }
    }
    else
    {
        for( i = 0; i < total; i++ )
        {
            int ofs = (int)((const uchar*)tmpCorners[i] - eig.data);
            int y = (int)(ofs / eig.step);
            int x = (int)((ofs - y*eig.step)/sizeof(float));

            corners.push_back(Point2f((float)x, (float)y));
            ++ncorners;
            if( maxCorners > 0 && (int)ncorners == maxCorners )
                break;
        }
    }
/*
    for( i = 0; i < total; i++ )
    {
        int ofs = (int)((const uchar*)tmpCorners[i] - eig.data);
        int y = (int)(ofs / eig.step);
        int x = (int)((ofs - y*eig.step)/sizeof(float));

        if( minDistance > 0 )
        {
            for( j = 0; j < ncorners; j++ )
            {
                float dx = x - corners[j].x;
                float dy = y - corners[j].y;
                if( dx*dx + dy*dy < minDistance )
                    break;
            }
            if( j < ncorners )
                continue;
        }

        corners.push_back(Point2f((float)x, (float)y));
        ++ncorners;
        if( maxCorners > 0 && (int)ncorners == maxCorners )
            break;
    }
*/
}
コード例 #7
0
void harris_detection(Mat &image,double threshold_value){
/*
    Mat dst, dst_norm, dst_norm_scaled;  
    dst = Mat::zeros( image.size(), CV_32FC1 );
    int blockSize = 2;
    int apertureSize = 3;
    double k = 0.01;
    int thresh = 100;
    int max_thresh = 255;
  
    /// Detecting corners
    cornerHarris( image, dst, blockSize, apertureSize, k );

    imwrite("outimage/dst.png",dst);
  
    /// Normalizing
    normalize( dst, dst_norm, 0, 255, NORM_MINMAX, CV_32FC1, Mat() );
    convertScaleAbs( dst_norm, dst_norm_scaled );
  
    /// Drawing a circle around corners
    for( int j = 0; j < dst_norm.rows ; j++ )
       { for( int i = 0; i < dst_norm.cols; i++ )
            {
              if( (int) dst_norm.at<float>(j,i) > thresh )
                {
                 circle( dst_norm_scaled, Point( i, j ), 5,  Scalar(0), 2, 8, 0 );
                }
            }
       }

	imwrite("outimage/dst_norm_scaled.png",dst_norm_scaled);
*/		

    int blockSize = 3;
    int apertureSize = 3;
    double k = 0.001;
    Mat cornerStrength;
    cornerHarris(image,cornerStrength,blockSize, apertureSize, k);
    threshold(cornerStrength,cornerStrength,threshold_value,255,THRESH_BINARY);
    imwrite("outimage/cornerStrength.png",cornerStrength);

    double maxStrength;
    double minStrength;
    minMaxLoc(cornerStrength,&minStrength,&maxStrength);
 
    Mat dilated;
    Mat locaMax;
    dilate(cornerStrength,dilated,Mat());
    compare(cornerStrength,dilated,locaMax,CMP_EQ);
 
    Mat cornerMap;
    double qualityLevel=0.01;
    double th=qualityLevel*maxStrength; 
    threshold(cornerStrength,cornerMap,th,255,THRESH_BINARY);
    cornerMap.convertTo(cornerMap,CV_8U);
    bitwise_and(cornerMap,locaMax,cornerMap);
 
    drawCornerOnImage(image,cornerMap);
  
   
    imwrite("outimage/harris_image.png",cornerMap);



}
コード例 #8
0
ファイル: Recognition.cpp プロジェクト: GiulioGx/ChessMate
/*
Point2f Recognition::RefineCornerPosition(Mat& img, Point2f ROICenter, vector<Point2f> refinedSquares){
	vector<Point2f> refinedCorners;
	//check if point to be refined is in an occluded part or there is a corner close!!
	unsigned int i= 0;
	bool found= false;
	while(i< refinedSquares.size() && !found){
		if(norm(ROICenter - refinedSquares[i]) < projectedSquareSize)
			found= true;
		i++;
	}
	//if found is true, there should be a corner any close and we refine the coordinates of it
	if(found){
		Mat srcGray;
		cvtColor(img, srcGray, CV_BGR2GRAY);

		Mat mask = 	Mat::zeros(img.size(), CV_8UC1);
		int edgeLenght= projectedSquareSize-5;
		int leftBoundX;
		int rightBoundX;
		int upperBoundY;
		int lowerBoundY;

		if((ROICenter.x- edgeLenght/2)< 0)  leftBoundX= 0;
		else leftBoundX= ROICenter.x- edgeLenght/2;

		if((ROICenter.x+ edgeLenght/2)> img.cols)  rightBoundX= img.cols;
		else rightBoundX= ROICenter.x+ edgeLenght/2;

		if((ROICenter.y- edgeLenght/2)< 0)  upperBoundY= 0;
		else upperBoundY= ROICenter.y- edgeLenght/2;

		if((ROICenter.y+ edgeLenght/2)> img.rows)  lowerBoundY= img.rows;
		else lowerBoundY= ROICenter.y+ edgeLenght/2;

		// set region of interest
		for (int i= leftBoundX ; i< rightBoundX; i++){
			for (int j= upperBoundY ; j< lowerBoundY; j++){
				mask.row(j).col(i) = 1;
			}
		}
		cornerHarris(img, OutputArray dst, int blockSize, int ksize, double k, int borderType=BORDER_DEFAULT )

		goodFeaturesToTrack(srcGray, refinedCorners, 1, .1, 0.2, mask);
	}
	if(refinedCorners.empty())
		return ROICenter;
	else
		return refinedCorners[0];
}
 */
vector<Point2f> Recognition::RefineCornerPositions(Mat& img, vector<Point2f> ROICenters, vector<Point2f> refinedSquares, int horizontalSize){
	Mat srcGray;
	Mat refinedCorners, refinedCorners_norm, refinedCorners_norm_scaled;
	vector<Point2f> finalMesh;
	int edgeLenght= projectedSquareSize-5;
	cvtColor(img, srcGray, CV_BGR2GRAY);

	cornerHarris(srcGray, refinedCorners, 2, 3, .04, BORDER_DEFAULT);
	normalize( refinedCorners, refinedCorners_norm, 0, 255, NORM_MINMAX, CV_32FC1, Mat() );
	convertScaleAbs( refinedCorners_norm, refinedCorners_norm_scaled );

	for(unsigned int i=0; i< ROICenters.size(); i++){
		int leftBoundX, rightBoundX, upperBoundY, lowerBoundY;

		if((ROICenters[i].x- edgeLenght/2)< 0)  leftBoundX= 0;
		else leftBoundX= ROICenters[i].x- edgeLenght/2;
		if((ROICenters[i].x+ edgeLenght/2)> img.cols)  rightBoundX= img.cols;
		else rightBoundX= ROICenters[i].x+ edgeLenght/2;
		if((ROICenters[i].y- edgeLenght/2)< 0)  upperBoundY= 0;
		else upperBoundY= ROICenters[i].y- edgeLenght/2;
		if((ROICenters[i].y+ edgeLenght/2)> img.rows)  lowerBoundY= img.rows;
		else lowerBoundY= ROICenters[i].y+ edgeLenght/2;

		Point2f maxCorner(0,0);

		for(int j=upperBoundY; j< lowerBoundY; j++){
			for(int k=leftBoundX; k< rightBoundX; k++){
				if( refinedCorners_norm.at<float>(j,k) > refinedCorners_norm.at<float>(maxCorner.y, maxCorner.x)){
					maxCorner.y= j;
					maxCorner.x= k;
				}
			}
		}
		//check if there is a square any close and return true if so
		unsigned int s= 0;
		bool found= false;
		while(s< refinedSquares.size() && !found){
			if(norm(ROICenters[i] - refinedSquares[s]) < projectedSquareSize*0.2)
				found= true;
			s++;
		}

		if(maxCorner.x!=0 && maxCorner.y!=0 && found){
			if(i==0)
				finalMesh.push_back(maxCorner);
			else if(i%(horizontalSize+1)== 0){
				if(fabs(finalMesh[i-(horizontalSize+1)].y - maxCorner.y) < 1.2*projectedSquareSize &&  fabs(finalMesh[i-(horizontalSize+1)].y - maxCorner.y)> .8*projectedSquareSize
						&& maxCorner.x< 1.2* finalMesh[i-(horizontalSize+1)].x &&  maxCorner.x> .8* finalMesh[i-(horizontalSize+1)].x)
					finalMesh.push_back(maxCorner);
				else
					finalMesh.push_back(Point2f(finalMesh[i-(horizontalSize+1)].x, finalMesh[i-(horizontalSize+1)].y+ projectedSquareSize));
			}
			else
				if(fabs(finalMesh[i-1].x - maxCorner.x) < 1.2*projectedSquareSize &&  fabs(finalMesh[i-1].x - maxCorner.x)> .8*projectedSquareSize
						&& maxCorner.y< 1.2* finalMesh[i-1].y &&  maxCorner.y> .8* finalMesh[i-1].y)
					finalMesh.push_back(maxCorner);
				else
					finalMesh.push_back(Point2f(finalMesh[i-1].x + projectedSquareSize, finalMesh[i-1].y));
		}
		else{
			if(i==0)
				finalMesh.push_back(ROICenters[i]);
			else if(i%(horizontalSize+1)== 0)
				finalMesh.push_back(Point2f(finalMesh[i-(horizontalSize+1)].x, finalMesh[i-(horizontalSize+1)].y+ projectedSquareSize));
			else
				finalMesh.push_back(Point2f(finalMesh[i-1].x + projectedSquareSize, finalMesh[i-1].y));
			//finalMesh.push_back(ROICenters[i]);
		}

	}
	return finalMesh;
}