bool Num_Extract::A_encloses_B(RotatedRect A, RotatedRect B){
	Point2f ptsA[4];
	Point2f ptsB[4];
	A.points(ptsA);
	B.points(ptsB);
	bool encloses = true;
	Point2f p1,p2,p3,p4;
	double m = 0;
	double indicator = 0;
	double test_val = 0;
	for(int i = 0 ; i < 4 ; i++){
		p1 = ptsA[i];
		p2 = ptsA[(i+1)%4];
		p3 = ptsA[(i+2)%4];
		m = (p2.y-p1.y)/(p2.x-p1.x);
		indicator = (p3.y-p1.y)-m*(p3.x-p1.x);
		for(int j = 0 ; j<4 ; j++){
			p4 = ptsB[j];
			test_val = (p4.y-p1.y)-m*(p4.x-p1.x);
			if(test_val*indicator<0){
				encloses = false;
				break;
			}
		}
		if(!encloses) break;
	}
	return encloses;
}
void checkRotatedRectangle()
{
	RNG rng(getTickCount());
	Mat filledRect = Mat::zeros(sz, CV_8UC1);

	Point center(rng.uniform(sz.width/4, sz.width*3/4),
				 rng.uniform(sz.height/4, sz.height*3/4));
	Size rect_size(rng.uniform(sz.width/8, sz.width/6),
				   rng.uniform(sz.height/8, sz.height/6));
	float angle = rng.uniform(0, 360);

	Point2f vertices[4];

	RotatedRect rRect = RotatedRect(center, rect_size, angle);

	rRect.points(vertices);
	for (int i = 0; i < 4; i++)
	{
		line(filledRect, vertices[i], vertices[(i + 1) % 4], Scalar(255), 3);
	}

	vector<Vec4i> lines;
	Ptr<LineSegmentDetector> ls = createLineSegmentDetectorPtr(LSD_REFINE_ADV);
	ls->detect(filledRect, lines);

    Mat drawnLines = Mat::zeros(filledRect.size(), CV_8UC1);
    ls->drawSegments(drawnLines, lines);
    imshow("checkRotatedRectangle", drawnLines);

	std::cout << "Check Rectangle- Number of lines: " << lines.size() << " - >= 4 Wanted." << std::endl;
}
Exemple #3
0
void Brushstroke::draw(Mat& alphaMap, Mat& mask,
                       double spacing, double jitter)
{
    Point2d normal = Point2d(cos(angle), sin(angle));

    Point2d point1 = normal * length1;
    Point2d point2 = normal * -length2;

    point1 += anchor;
    point2 += anchor;

    Point2d texCenter;
    RotatedRect maskRect;
    double texAngle;
    Size_<double> maskSize = mask.size();
    double ratio = (width + 2.0) / maskSize.width;

    Mat scaledMask;
    resize(mask, scaledMask, Size(), ratio, ratio, INTER_CUBIC);
    maskSize = scaledMask.size();

    RNG rng(0xFFFFFFFF);

    for(double dist = -length2; dist < length1; dist += spacing) {
        texCenter = anchor + normal * dist;
        texAngle = angle + jitter * rng.uniform(-1.0, 1.0);

        maskRect = RotatedRect(texCenter, maskSize, texAngle);
        Rect2d boundingRect = maskRect.boundingRect();

        renderTexture(alphaMap, scaledMask, maskRect);
    }
}
// Define trackbar callback functon. This function find contours,
// draw it and approximate it by ellipses.
void processImage(int /*h*/, void*)
{
    vector<vector<Point> > contours;
    Mat bimage = image >= sliderPos;
    
    findContours(bimage, contours, CV_RETR_LIST, CV_CHAIN_APPROX_NONE);

    Mat cimage = Mat::zeros(bimage.size(), CV_8UC3);

    for(size_t i = 0; i < contours.size(); i++)
    {
        size_t count = contours[i].size();
        if( count < 6 )
            continue;
        
        Mat pointsf;
        Mat(contours[i]).convertTo(pointsf, CV_32F);
        RotatedRect box = fitEllipse(pointsf);
        
        if( MAX(box.size.width, box.size.height) > MIN(box.size.width, box.size.height)*30 )
            continue;
        drawContours(cimage, contours, (int)i, Scalar::all(255), 1, 8);

        ellipse(cimage, box, Scalar(0,0,255), 1, CV_AA);
        ellipse(cimage, box.center, box.size*0.5f, box.angle, 0, 360, Scalar(0,255,255), 1, CV_AA);
        Point2f vtx[4];
        box.points(vtx);
        for( int j = 0; j < 4; j++ )
            line(cimage, vtx[j], vtx[(j+1)%4], Scalar(0,255,0), 1, CV_AA);
    }

    imshow("result", cimage);
}
Exemple #5
0
double get_skew_angle(Mat img)
{
  // Binarize
  threshold(img, img, 225, 255, THRESH_BINARY);
 
  // Invert colors
  bitwise_not(img, img);
  Mat element = getStructuringElement(MORPH_RECT, Size(5, 3));
  erode(img, img, element);

  vector<Point> points;
  Mat_<uchar>::iterator it = img.begin<uchar>();
  Mat_<uchar>::iterator end = img.end<uchar>();

  for (; it != end; ++it)
    if (*it)
      points.push_back(it.pos());

  RotatedRect box = minAreaRect(Mat(points));
  double angle = box.angle;

  if (angle < -45.)
    angle += 90.;

  Point2f vertices[4];
  box.points(vertices);

  for(int i = 0; i < 4; ++i)
    line(img, vertices[i], vertices[(i + 1) % 4], Scalar(255, 0, 0), 1, CV_AA);
 
return angle; 
}
Exemple #6
0
void camshift(	Mat &frame,
		Mat &hue_roi,
		Mat &mask_roi,
		Mat &backproj,
		Mat &thresh_img,
		Point2i &resol,
		Point2i &shift,
		Rect &searchwin,
		struct intrinsics *intrins,
		struct pose *body,
		ofstream& file	)
{

	Mat hsv, hue, mask;
	hue.create( resol.y, resol.x, CV_8UC1);
	mask.create(resol.y, resol.x, CV_8UC3);
	int ch[] = {0,0};

	float theta;
	RotatedRect orient;
	Point2f vertices[4];

	bool inframe = false;

	cvtColor( frame, hsv, COLOR_BGR2HSV );

	//Ignore pixels in HSV space with too high/low saturation and a high value:
	hv_threshold( hsv, mask );

	//Extract single channel Hue frames from HSV frames
	//Usage of ch[] means copying from channel 0 of source to channel 0 of destination
	mixChannels( &hsv, 1, &hue, 1, ch, 1 );

	//Compute backprojected frames:
	backprojection( binsize, hue_roi, hue, backproj, mask_roi, thresh_img );

	double res = 1;

	moment(thresh_img, res, searchwin, theta, inframe, shift);

	orient = RotatedRect(Point2f(searchwin.x, searchwin.y), Size2f(searchwin.width, searchwin.height), theta);
	orient.points(vertices);

	for (int i = 0; i < 4; i++){
	   	line(frame, vertices[i], vertices[(i+1)%4], Scalar(0,255,0), 2);
	}

	Rect brect = orient.boundingRect();
	rectangle( frame, brect, Scalar(0,0,255), 2 ); 
	
	imshow( "Source Stream", frame ) ; 

	
	if (inframe){
		simulate(inframe, searchwin, intrins, file); 
	}

}
Exemple #7
0
static void refineSegments(const Mat& img, Mat& mask, Mat& dst)
{
    int niters = 3;

    vector<vector<Point> > contours;
    vector<Vec4i> hierarchy;

    Mat temp;

    dilate(mask, temp, Mat(), Point(-1,-1), niters);
    erode(temp, temp, Mat(), Point(-1,-1), niters*2);
    dilate(temp, temp, Mat(), Point(-1,-1), niters);

    findContours( temp, contours, hierarchy, RETR_EXTERNAL, CHAIN_APPROX_SIMPLE );

    dst = Mat::zeros(img.size(), CV_8UC3);

    if( contours.size() == 0 ) {
        return;
    }

    // iterate through all the top-level contours,
    // draw each connected component with its own random color
    /*
    int idx = 0, largestComp = 0;
    double maxArea = 0;

    for( ; idx >= 0; idx = hierarchy[idx][0] )
    {
        const vector<Point>& c = contours[idx];
        double area = fabs(contourArea(Mat(c)));
        if( area > maxArea )
        {
            maxArea = area;
            largestComp = idx;
        }
    }
    Scalar color( 255, 255, 255 );
    drawContours( dst, contours, largestComp, color, FILLED, LINE_8, hierarchy );
    //drawContours( img, contours, largestComp, color, FILLED, LINE_8, hierarchy );
    */
    RNG& rng = theRNG();
    for (int x = 0; x < contours.size(); x++ ) {
        Scalar color = Scalar(rng.uniform(0, 255), rng.uniform(0, 255), rng.uniform(0, 255));
        drawContours(dst, contours, x, color, FILLED, LINE_8, hierarchy, 0, Point());
    }

    vector<Rect> boundRect(contours.size());
    for (int x = 0; x < contours.size(); x++) {
        RotatedRect box = minAreaRect(contours[x]);
        Point2f vertex[4];
        box.points(vertex);
        for (int y = 0; y < 4; y++) {
            line(img, vertex[y], vertex[(y+1)%4], Scalar(0, 255, 0), 2, LINE_AA);
        }
    }
}
int main(  )
{
	//改变console字体颜色
	system("color 1F"); 

	//显示帮助文字
	ShowHelpText();

	//初始化变量和随机值
	Mat image(600, 600, CV_8UC3);
	RNG& rng = theRNG();

	//循环,按下ESC,Q,q键程序退出,否则有键按下便一直更新
	while(1)
	{
		//参数初始化
		int count = rng.uniform(3, 103);//随机生成点的数量
		vector<Point> points;//点值

		//随机生成点坐标
		for(int  i = 0; i < count; i++ )
		{

			Point point;
			point.x = rng.uniform(image.cols/4, image.cols*3/4);
			point.y = rng.uniform(image.rows/4, image.rows*3/4);

			points.push_back(point);
		}

		//对给定的 2D 点集,寻找最小面积的包围矩形
		RotatedRect box = minAreaRect(Mat(points));
		Point2f vertex[4];
		box.points(vertex);

		//绘制出随机颜色的点
		image = Scalar::all(0);
		for( int i = 0; i < count; i++ )
			circle( image, points[i], 3, Scalar(rng.uniform(0, 255), rng.uniform(0, 255), rng.uniform(0, 255)), CV_FILLED, CV_AA );


		//绘制出最小面积的包围矩形
		for( int i = 0; i < 4; i++ )
			line(image, vertex[i], vertex[(i+1)%4], Scalar(100, 200, 211), 2, CV_AA);

		//显示窗口
		imshow( "矩形包围示例", image );

		//按下ESC,Q,或者q,程序退出
		char key = (char)waitKey();
		if( key == 27 || key == 'q' || key == 'Q' ) // 'ESC'
			break;
	}

	return 0;
}
int main(int argc, char** argv) {

	Mat media, variancia;
	Mat fundo, quadroAnterior;
	Mat rastro;
	VideoCapture vid(argv[1]);
	vector<Rastro> rastros;
	RotatedRect conjuntoDasVagas = RotatedRect(Point2f(550, 150), Size2f(200,70), 70);
	int cont = 0;

	

	MediaVariancia(1, argv[1], media, variancia);
	media.copyTo(rastro);

	Point2f vertices[4];
	conjuntoDasVagas.points(vertices);

	for (int i = 0; i < 4; i++)
		line(rastro, vertices[i], vertices[(i + 1) % 4], Scalar(0, 255, 0));

	while (vid.isOpened()) {
		Mat quadro;
		if (!vid.read(quadro)) {
			break;
		}
		else {
			Mat D;
			rectangle(quadro, Point2f(250, 140), Point2f(400, 500), Scalar(0, 0, 0), -1);
			if (!quadroAnterior.empty()) {
				D = Diferenca(quadro, quadroAnterior, 1, atoi(argv[2]));
				//Se os quadros não forem exatamente iguais atualiza o rastro
				if (contaZeros(D)>0) {
					Mat estrut;
					estrut = Mat::ones(6, 6, CV_8UC1);
					dilate(D, D, estrut, Point(-1, -1), 5);
					Mat dBranca = Branco3Canais(D);
					erode(dBranca, dBranca, Mat::ones(3, 3, CV_8UC1), Point(-1, -1), 1);
					Kalman(dBranca, rastro, rastros);

				}
				//imshow("Dilatada", D);
				imshow("rastro", rastro);
				imshow("Video", quadro);
				//imshow("Anterior", quadroAnterior);

				waitKey(1);
			}

			quadro.copyTo(quadroAnterior);
		}
	}

	return 0;
}
static Rect fitEllipse_check( vector<Point> contour )
{
    Mat pointsf;
    Mat(contour).convertTo(pointsf, CV_32F);
    RotatedRect box = fitEllipse(pointsf);
    //cout << box.size << "  " << box.size <<endl;
    return box.boundingRect();
    if( MAX(box.size.width, box.size.height) > MIN(box.size.width, box.size.height)*2 )
        return Rect(-1,-1,0,0);
    else
        return box.boundingRect();
}
Exemple #11
0
/*******************************************************************************
* Function:      thresholdByAreaRatioVar  
* Description:   thresholds the FG targets by area, aspect ratio and variance
* Arguments:
	minArea       -   minimum area to preserve
	maxArea       -   maximum area to preserve
	dilateSESize  -   structuring element size for dilation
	erodeSESize   -   structuring element size for erosion
	minAspRatio   -   minimum aspect ratio
	maxAspRatio   -   maximum aspect ratio
	varThresh     -   value of variance threshold
	
* Returns:       void
* Comments:
* Revision: 
*******************************************************************************/
void
FGExtraction::thresholdByAreaRatioVar(double minArea, double maxArea, 
                                          int dilateSESize, int erodeSESize, 
                                          double minAspRatio, double maxAspRatio, int varThresh)
{
	bool passArea, passRatio, passVar;
	vector<vector<Point> > contours;

	// connect separate parts before finding connected components
	Mat dilateSE = getStructuringElement(MORPH_ELLIPSE, Size(dilateSESize, dilateSESize));
	Mat erodeSE = getStructuringElement(MORPH_ELLIPSE, Size(erodeSESize, erodeSESize));
	dilate(_fgImg, _fgImg, dilateSE);
	erode(_fgImg, _fgImg, erodeSE);

	// extract contours of targets
    Mat tempImg = _fgImg.clone();
    findContours(tempImg, contours, RETR_EXTERNAL, CHAIN_APPROX_SIMPLE, Point());
    tempImg.release();

	for(size_t i = 0; i < contours.size(); ++i){
		passArea = passRatio = passVar = false;
		double area = contourArea(contours[i]);
		
		// check if the area is within the desired range
		if (contours[i][0].y > 0.35*_fgImg.rows && contours[i][0].y < 0.68*_fgImg.rows && area > 0.1*minArea && area < maxArea
			|| area > minArea && area < maxArea) 
			passArea = true;
		

		// check if the aspect ratio is within the desired range
		RotatedRect orientedRect = orientedBoundingBox(contours[i]);
		Point2f rectPoints [4]; orientedRect.points(rectPoints);
		double rectWidth = norm(rectPoints[0] - rectPoints[1]);
		double rectHeight = norm(rectPoints[1] - rectPoints[2]);
		double aspRatio = max(rectWidth / rectHeight, rectHeight / rectWidth);
		if (aspRatio > minAspRatio && aspRatio < maxAspRatio) passRatio = true;

		// check if the variance of pixel exceeds the threshold
		// TODO ...
		passVar = true;

		// remove the target if any of the tests fails
		if(!passArea || !passRatio || !passVar){
			//Rect uprightRect = boundingRect(Mat(contours[i]));
			//rectangle(_fgImg, uprightRect, Scalar(0), -1);
			drawContours(_fgImg, contours, i, Scalar(0), -1);
		}
	}

	/*namedWindow("fgImg", 0);
	imshow("fgImg", _fgImg);
	waitKey(0);*/
}
Exemple #12
0
/**
 * This is a (modified) test program written by Michael Young
 * (https://github.com/ayoungprogrammer/WebcamCodeScanner). It was modified to
 * work with the Raspicam.
 */
int main(int argc, char* argv[])
{
	PiCamera cam; // open the video camera no. 0
	ImageScanner scanner;  
	scanner.set_config(ZBAR_NONE, ZBAR_CFG_ENABLE, 1);  

	namedWindow("MyVideo",CV_WINDOW_AUTOSIZE); //create a window called "MyVideo"

	while (1)
	{
		Mat frame = cam.Snap();
		Mat grey;
		cvtColor(frame,grey,CV_BGR2GRAY);

		int width = frame.cols;  
		int height = frame.rows;  
		uchar *raw = (uchar *)grey.data;  
		// wrap image data  
		zbar::Image image(width, height, "Y800", raw, width * height);  
		// scan the image for barcodes  
		int n = scanner.scan(image);  
		// extract results  
		for(Image::SymbolIterator symbol = image.symbol_begin();  
				symbol != image.symbol_end();  
				++symbol) {  
			vector<Point> vp;  
			// do something useful with results  
			cout << "decoded " << symbol->get_type_name()  << " symbol \"" << symbol->get_data() << '"' <<" "<< endl;  
			int n = symbol->get_location_size();  
			for(int i=0;i<n;i++){  
				vp.push_back(Point(symbol->get_location_x(i),symbol->get_location_y(i))); 
			}  
			RotatedRect r = minAreaRect(vp);  
			Point2f pts[4];  
			r.points(pts);  
			for(int i=0;i<4;i++){  
				line(frame,pts[i],pts[(i+1)%4],Scalar(255,0,0),3);  
			}  
		}  

		imshow("MyVideo", frame); //show the frame in "MyVideo" window

		if (waitKey(30) == 27) //wait for 'esc' key press for 30ms. If 'esc' key is pressed, break loop
		{
			cout << "esc key is pressed by user" << endl;
			break; 
		}
	}
	return 0;

}
void get_min_box(vector<Point> r, RotatedRect box) {

	if ((box.size.width < 500) && (box.size.width < 500)) {
		if (min_rect.size() == 0)	{		// first rect
			min_rect.push_back(box);
			min_r.push_back(r);
		}
		else {							// every other rect
			bool is_inside = true;
			for (int i = 0; i < int(min_rect.size()); ++i) {
				if (box.boundingRect().contains(min_rect[i].center)) { 	// if hierachical boxes break; else add box
					is_inside = true;
					break;
				}
				else {
					is_inside = false;
				}
			}
			if (is_inside == false) {
				min_rect.push_back(box);
				min_r.push_back(r);
			}
		}				
	}
}
bool contains(RotatedRect rect, Point pt)
{
	Point2f vertices[4];
	rect.points(vertices);

	bool chk = true;

	for (int i = 0; i < 4; ++i)
	{
		float m = (vertices[i].y - vertices[(i+1) % 4].y)/(vertices[i].x - vertices[(i+1) % 4].x);
		float c = vertices[i].y - m*vertices[i].x;

		float val_pt = pt.y - m*pt.x - c;
		float val_center = rect.center.y - m*rect.center.x - c;

		if (val_pt * val_center > 0)
			chk = true;
		else
		{
			chk = false;
			break;
		}
	}

	return chk;
}
Exemple #15
0
void drawRotatedRect(Mat* img, RotatedRect rect, Scalar color, int thickness)
{
  Point2f rect_points[4];
  rect.points( rect_points );
  for( int j = 0; j < 4; j++ )
    line( *img, rect_points[j], rect_points[(j+1)%4], color, thickness, 8 );
}
double xyVision::GetTarget::computeRotatedRect(const vector<Point>& contour, cv::Size sz, RotatedRect box, Mat& bi)
{
	Point2f vertices[4];
	box.points(vertices);
	Point points[4];
	unsigned int i = 0;
	for (int i = 0; i < 4; ++i)
	{
		points[i] = Point((int)vertices[i].x, (int)vertices[i].y);
	}

	Mat tmp = Mat::zeros(sz, CV_8U);
	cv::fillConvexPoly(tmp, points, 4, Scalar(1));

	Mat boxIdx;
	findNonZero(tmp, boxIdx);
	double n_pixels = (double)boxIdx.total();
	double n_nonZero = 0;
	for (i = 0; i < boxIdx.total(); ++i)
	{
		Point _p = boxIdx.at<Point>(i);
		if (bi.at<unsigned char>(_p.y, _p.x) > 0)
		{
			n_nonZero = n_nonZero + 1;
		}
	}
	return n_nonZero / (n_pixels+1e-5);
}
void dispRotatedRectangle(RotatedRect rect, Mat & frame)
{
    Point2f vertices[4];
    rect.points(vertices);
    for (int i = 0; i < 4; i++)
        line(frame, vertices[i], vertices[(i+1)%4], Scalar(0,255,0));

}
bool compareRects(RotatedRect a, RotatedRect b) 
{
    double areaa = 0.0;
    double areab = 0.0;
    Point2f ptsa[4];
    Point2f ptsb[4];
    a.points(ptsa);
    b.points(ptsb);

    areaa = (sqrt(pow(ptsa[0].x - ptsa[1].x,2) + pow(ptsa[0].y - ptsa[1].y,2) ) *
            sqrt(pow(ptsa[1].x - ptsa[2].x,2) + pow(ptsa[1].y - ptsa[2].y,2) ) );

    areab = (sqrt(pow(ptsb[0].x - ptsb[1].x,2) + pow(ptsb[0].y - ptsb[1].y,2) ) *
            sqrt(pow(ptsb[1].x - ptsb[2].x,2) + pow(ptsb[1].y - ptsb[2].y,2) ) );

	return (areaa > areab) ? true : false;
}
Exemple #19
0
Mat visionUtils::drawRotatedRect(Mat image, RotatedRect rRect, Scalar colourIn)
{

    Point2f vertices[4];
    rRect.points(vertices);
    for (int i = 0; i < 4; i++)
        line(image, vertices[i], vertices[(i+1)%4], colourIn, 3); //Scalar(0,255,0));

    return image;
}
//***** DRAW GRIPPER
void Detection::drawGripper(Mat img, Point2i center, Rect rect, float angle)
{
	RotatedRect rRect = RotatedRect(center, Size2f(rect.width, rect.height), angle);
	CString str;
	str.Format(_T("%d"), center.x);
	//AfxMessageBox(str);
	if (sample.size() < sampleSize && this->hasVision)
	{
		sample.push_back(Point2i(center.x, center.y));
		CString str;
		str.Format(_T("%d"), sample[sample.size()-1]);
		//AfxMessageBox(str);
	}

	Point2f vertices[4];
	rRect.points(vertices);
	for (int i = 0; i < 4; i++)
		line(img, vertices[i], vertices[(i + 1) % 4], Scalar(0, 255, 0));
}
int main( int argc, char** argv )
{
    Mat img(500, 500, CV_8UC3);
    RNG& rng = theRNG();
    help();
    for(;;)
    {
        int i, count = rng.uniform(1, 101);
        vector<Point> points;
        for( i = 0; i < count; i++ )
        {
            Point pt;
            pt.x = rng.uniform(img.cols/4, img.cols*3/4);
            pt.y = rng.uniform(img.rows/4, img.rows*3/4);
            
            points.push_back(pt);
        }
        
        
        RotatedRect box = minAreaRect(Mat(points));
        Point2f center, vtx[4];
        float radius = 0;
        minEnclosingCircle(Mat(points), center, radius);
        box.points(vtx);
        
        img = Scalar::all(0);
        for( i = 0; i < count; i++ )
            circle( img, points[i], 3, Scalar(0, 0, 255), CV_FILLED, CV_AA );

        for( i = 0; i < 4; i++ )
            line(img, vtx[i], vtx[(i+1)%4], Scalar(0, 255, 0), 1, CV_AA);
        
        //circle(img, center, cvRound(radius), Scalar(0, 255, 255), 1, CV_AA); 

        imshow( "rect & circle", img );

        char key = (char)cvWaitKey();
        if( key == 27 || key == 'q' || key == 'Q' ) // 'ESC'
            break;
    }
    return 0;
}
geometry_msgs::Pose getFeature(Mat img, Mat dst, Scalar low, Scalar high, Scalar draw)
{
  // Threshold image
  Mat bw, hsv;
  cv::cvtColor(img, hsv, CV_BGR2HSV);
  vector<vector<Point> > contours;

  inRange(hsv, low, high, bw);
  findContours(bw.clone(), contours, CV_RETR_EXTERNAL, CV_CHAIN_APPROX_SIMPLE);

  for(size_t i=0; i < contours.size(); i++)
  {
    double area = contourArea(contours[i]);
    // Ensure minimum area and symmetry for circles
    if(area > 200){
      RotatedRect minEllipse;
      minEllipse = fitEllipse(Mat(contours[i]));
      double eW = minEllipse.boundingRect().width;
      double eH = minEllipse.boundingRect().height;
      if(abs(eW-eH)<6){

        ellipse(dst, minEllipse, draw, 2, 8);

        cv::imshow("Range window", dst);
        cv::imshow("HSV window", hsv);
        geometry_msgs::Point pt;
        geometry_msgs::Quaternion q;
        pt.x = minEllipse.center.y;
        pt.y = minEllipse.center.x;
        pt.z = 0.0;
        geometry_msgs::Pose p;
        p.position = pt;
        p.orientation = q;
        return p;
      }
    }
  }
  cv::imshow("Range window", dst);
  cv::imshow("HSV window", hsv);
  return geometry_msgs::Pose();
}
/////////////////////////////////////////////////////////////////////
// showimgcontours() 
// Description: This function finds the largest contour in original    
//  and draws the minimum bounding rectangle on the same image. As
//  you can see the original image is passed by reference so the 
//  calling function receieves the modified image on which the 
//  minimum area rectangle is drawn.
////////////////////////////////////////////////////////////////////
void showimgcontours(Mat &threshedimg, Mat &original)
{
	vector<vector<Point> > contours;
	RotatedRect rect;
	vector<Vec4i> hierarchy;
	Point2f rectPoints[4];
	Scalar color = Scalar(255, 0, 0);
	double largest_area = 0;
	int largest_contour_index = 0;
	findContours(threshedimg, contours, hierarchy, CV_RETR_TREE, CV_CHAIN_APPROX_SIMPLE);
	//this will find largest contour
	for (size_t i = 0; i< contours.size(); i++) // iterate through each contour. 
	{
		double a = contourArea(contours[i], false);  //  Find the area of contour
		if (a>largest_area)
	{
			largest_area = a;
			largest_contour_index = i;                //Store the index of largest contour
	}

}
	//search for largest contour has end

	if (contours.size() > 0)
{
		drawContours(original, contours, largest_contour_index, CV_RGB(0, 255, 0), 2, 8, hierarchy);
		//if want to show all contours use below one
		//drawContours(original,contours,-1, CV_RGB(0, 255, 0), 2, 8, hierarchy);

		// Find and add bounding rectangle
		rect = minAreaRect(contours[largest_contour_index]);
		rect.points(rectPoints);
		int j = 0;
		for (j; j < 4; j++)
			line(original, rectPoints[j], rectPoints[(j + 1) % 4], color, 1, 8);
		string strDim = "Min Area Rectangle Dimensions:\n" + 
			to_string(rect.size.height) + " x " + to_string(rect.size.width);
		imshow("Largest Contour", original);
		ShowMessage(strDim);
	}
}
Exemple #24
0
Target getTarget(vector <Point> points) {
	convexHull(Mat(points), points);
	RotatedRect rect = minAreaRect(Mat(points));
	Target t;
	t.x = rect.center.x;
	t.y = rect.center.y;
	t.width = ((rect.size.width>rect.size.height) ? rect.size.width : rect.size.height);
	t.height = ((rect.size.width>rect.size.height) ? rect.size.height : rect.size.width);
	t.angle = ((rect.size.width>rect.size.height) ? rect.angle : (rect.angle+90));
	Point2f rectPoints[4];
	rect.points(rectPoints);
	for (int i = 0; i < 4; i++) {
		t.pointsX[i] = rectPoints[i].x;
		t.pointsY[i] = rectPoints[i].y;
	}
	t.area = contourArea(points);
	t.ratio = t.width / (float)t.height;
	t.dist = 0;
	t.distError = 0; // Don't worry, I'm always right
	return t;
}
Exemple #25
0
int FeatureExtract(Mat &Input,Mat FeaturePoints,Mat &Output){

	/*-----------------minAreaRect-----------------------*/

	RotatedRect box = minAreaRect(FeaturePoints); 
	Point2f vtx[4];
	box.points(vtx);//get the vertices of rectangle

	for( int i = 0; i < 4; i++ )  
	{
		line(Input, vtx[i], vtx[(i+1)%4], Scalar(255), 1, CV_AA);  
	}

	Output=Input;
	/*------------------Hu Moments----------------------*/
	Moments h;
	double hu[7];
	h=moments(Input,false);
	HuMoments(h,hu);
	
	/*-----------------------Area of Hand------------------*/
	double HandArea=FeaturePoints.total();


	/*-------------------Area of minRect--------------------*/
	double leng=sqrt((vtx[0].x-vtx[1].x)*(vtx[0].x-vtx[1].x)+(vtx[0].y-vtx[1].y)*(vtx[0].y-vtx[1].y));
	double width=sqrt((vtx[1].x-vtx[2].x)*(vtx[1].x-vtx[2].x)+(vtx[1].y-vtx[2].y)*(vtx[1].y-vtx[2].y));

	double MinrectArea=leng*width;

	double ratio=HandArea/MinrectArea;

	double feature[5]={hu[0],hu[1],hu[2],hu[3],ratio};
	
	/*----------------write into a txt file-------------------*/
	WriteIntoTxt(feature);

	return 1;
	
}
Exemple #26
0
static bool is_right_lean(const RotatedRect &rotated_rect)
{
    Point2f vertices[4];
    rotated_rect.points(vertices);
    vector<Point2f> points;
    for(int i=0; i<4; ++i) {
        points.push_back(vertices[0]);
    }
    sort(points.begin(), points.end(), compare_y_func);

    return points[0].x  + points[1].x > 2 * rotated_rect.center.x;

}
	/**
		Only keep the pixels of a image that lay inside a bounding rect
		@param src:			A image with no type restrictions
		@param dst			The src image after applying the mask
		@param boundingRect: The shape of the mask
	*/
	void applyRectangleMask(const cv::Mat& src, cv::Mat& dst, RotatedRect boundingRect) {
		Mat rectMask = Mat::zeros(src.size(), CV_8UC1);
		Point2f vertices2f[4];
		Point vertices[4];
		boundingRect.points(vertices2f);
		for (int i = 0; i < 4; i++) {
			vertices[i] = vertices2f[i];
			line(rectMask, vertices2f[i], vertices2f[(i + 1) % 4], Scalar(255));
		}
		cv::fillConvexPoly(rectMask, vertices, 4, cv::Scalar(255));

		src.copyTo(dst, rectMask);
	}
Exemple #28
0
Mat CControl::GetSubsetImg(RotatedRect n_rotatedrect)
{
  // cout<<n_rotatedrect<<endl;
  //根据旋转矩形,从nimgraw中获得新图像。
  //获得边界矩形。
  Rect n_boundrect=n_rotatedrect.boundingRect();
  //将边界在原图像上画出。
  Point2f vertices[4];
  n_rotatedrect.points(vertices);
  // Mat n_imgraw;
  // nImgRaw.copyTo(n_imgraw);
  // for (int i = 0; i < 4; i++)
  // line(n_imgraw, vertices[i], vertices[(i+1)%4], Scalar(0,255,0));
  // imshow("raw",n_imgraw);
  

  //获得子图像。
  Mat n_boundmatemp=nImgRaw(n_boundrect);
  Mat n_boundmat;
  n_boundmatemp.copyTo(n_boundmat);
  // imshow("prerotated",n_boundmat);
  //获得旋转变换参数矩阵
  //这里的中心不再是原图像的中心,而是子图的中心。(原中心-左上角)
  Point2f n_pt1=n_rotatedrect.center;
  Point2f n_pt2=n_boundrect.tl();
  Point2f n_ptcenter=n_pt1-n_pt2;
  Mat n_rotatematparam=getRotationMatrix2D(n_ptcenter,n_rotatedrect.angle,1.0);
  //进行仿射变换。
  Mat n_rotatedMat;
  warpAffine(n_boundmat, n_rotatedMat,n_rotatematparam,n_boundmat.size(),INTER_CUBIC);
  //截取子图像。
  Mat n_croppedmat;
  Size n_subsize(nControlOptions.nWidth,nControlOptions.nHeight);
  getRectSubPix(n_rotatedMat,n_subsize,n_ptcenter,n_croppedmat);
  // imshow("rotated",n_croppedmat);
  // waitKey(0);
  return n_croppedmat;
}
    int track(Mat &image,Rect &rect)
    {
        int status=0;
        cvtColor(image, hsv, CV_BGR2HSV_FULL);
        selection=rect;
        if(rect.width!=0&&rect.height!=0)
        {
            if(trackObject==false)
                buildHistogram ();
            if(trackObject==true)
            {
                Rect trackWindow=selection;
                Mat backproj=calcProbability ();
                RotatedRect trackBox = CamShift(backproj,trackWindow,TermCriteria( CV_TERMCRIT_EPS | CV_TERMCRIT_ITER, 10, 1 ));
                if( trackWindow.area() <= 1 )
                {
                    int cols = backproj.cols, rows = backproj.rows, r = (MIN(cols, rows) + 5)/6;
                    trackWindow = Rect(0,0,0,0);
                    trackObject=false;
                }
                else
                {
                    Point2f rect_points[4]; trackBox.points( rect_points );
                          for( int j = 0; j < 4; j++ )
                              line( image, rect_points[j], rect_points[(j+1)%4], Scalar(0,0,255), 1, 8 );

                }

            }
        }
        else
        {
            trackObject=false;
        }

        status=1;
        return status;
    }
Exemple #30
0
void CoreApplication::saveOldVideo(QString path) {
    emit processStatusChanged(CoreApplication::SAVE_VIDEO, true);
    VideoWriter record(path.toStdString(), videoFourCCCodec,25,originalVideo->getSize());
    assert(record.isOpened());
    for (int f = 0; f < originalVideo->getFrameCount(); f++) {
        emit processProgressChanged((float)f/originalVideo->getFrameCount());
        const Frame* frame = originalVideo->getFrameAt(f);
        Mat image = frame->getOriginalData().clone();
        const Rect_<int>& cropBox = originalVideo->getCropBox();
        if (f == 0) {
            cv::rectangle(image, cropBox, Scalar(0,255,0), 3);
        } else {
            const Mat& update = frame->getUpdateTransform();
            RotatedRect newCrop = Tools::transformRectangle(update, cropBox);
            Point2f verts[4];
            newCrop.points(verts);
            for (int i = 0; i < 4; i++) {
                line(image, verts[i], verts[(i+1)%4], Scalar(0,255,0),3);
            }
        }
        record << image;
    }
    emit processStatusChanged(CoreApplication::SAVE_VIDEO, false);
}