예제 #1
0
BOOL CDlg_AppInfo::OnInitDialog() 
{
	CDialog::OnInitDialog();
	Sizer.InitSizer(this,objSettings.iStickPix,HKEY_CURRENT_USER,PROG_REGKEY"\\Wnd_AppInfo");
	Sizer.SetOptions(STICKABLE|SIZEABLE);
	CRect minRect(0,0,260,100);
	Sizer.SetMinRect(minRect);
	Sizer.AddDialogElement(IDOK,widthSize|heightSize);
	Sizer.AddDialogElement(IDC_EDIT,0);
	Sizer.AddDialogElement(ID_OPEN,widthSize|heightSize);
	Sizer.AddDialogElement(ID_WNDS,widthSize|heightSize|hidable);
	Sizer.AddLeftTopAlign(IDC_EDIT,0,4);
	Sizer.AddRightTopAlign(IDC_EDIT,0,4);
	Sizer.AddRightBottomAlign(IDOK,0,-4);
	Sizer.AddBottomAlign(ID_OPEN,0,-4);
	Sizer.AddBottomAlign(ID_WNDS,0,-4);
	Sizer.AddRightAlign(ID_OPEN,IDOK,leftPos,-4);
	Sizer.AddRightAlign(ID_WNDS,ID_OPEN,leftPos,-4);
	Sizer.AddBottomAlign(IDC_EDIT,IDOK,topPos,-4);
	SetWindowText(_l("Application info"));
	GetDlgItem(ID_OPEN)->SetWindowText(_l("Application folder"));
	GetDlgItem(ID_WNDS)->SetWindowText(_l("Actions")+"...");
	SetIcon(theApp.MainImageList.ExtractIcon(13),TRUE);
	SetIcon(theApp.MainImageList.ExtractIcon(13),FALSE);
	SetTaskbarButton(this->GetSafeHwnd());	
	SwitchToWindow(this->GetSafeHwnd());
	return TRUE;
}
void BallDetector::contourDetection()
{
    Canny(thrs,cannyImg, 50, 150, 3);
    vector<vector<Point> > contours;
    vector<Vec4i> hierarchy;
    findContours(cannyImg, contours, hierarchy, RETR_TREE, CHAIN_APPROX_SIMPLE, Point(0,0));
    vector<RotatedRect> minRect(contours.size());
    vector<Point2f> center(contours.size());
    vector<float> radius(contours.size());
    for( size_t i = 0; i < contours.size(); i++)
    {
        if(contours[i].size() > 5)
            minRect[i] = fitEllipse(Mat(contours[i]));
        minEnclosingCircle(contours[i],center[i],radius[i]);
    }
    
    RNG rng(12345);
    Mat drawing = Mat::zeros(cannyImg.size(),CV_8UC3);
    for( size_t i = 0; i < contours.size(); i++)
    {
        Scalar color = Scalar(rng.uniform(0,255),rng.uniform(0,255),rng.uniform(0,255));
        Size2f s = minRect[i].size;
        Point2f c = minRect[i].center;
        if(contours[i].size() > 5 && s.width/s.height > 0.7 && s.width/s.height < 1.4 && s.width > 5 && s.height > 5)
            // && arcLength(contours[i],true)/(2*CV_PI*radius[i])>0.8 && arcLength(contours[i],true)/(2*CV_PI*radius[i]) < 1.2 )
        {
            drawContours(drawing, contours, (int)i, color, -1, 8, hierarchy, 0, Point());
            cout<<c.x<<" "<<c.y<<endl;
            cout<<s.width<<" "<<s.height<<endl<<endl;
        }
    }
    imshow("contours",drawing);
    imwrite("images/contours.png",drawing);
}
예제 #3
0
Mat IPS_simple::applyContourns(Mat src){
    vector<vector<Point> > contours;
    vector<Vec4i> hierarchy;
    RNG rng(12345);
    Mat src2 = src.clone();
    Mat dst = src.clone();
    Mat src_gray = src.clone();
    Mat final = imread(Constants::IMG_RAW);

    cvtColor( src, src_gray, CV_BGR2GRAY );
    // Eliminar ruido
    src2 = applyBlur(src_gray);
    findContours( src2, contours, hierarchy,CV_CHAIN_APPROX_SIMPLE, CV_CHAIN_APPROX_SIMPLE, Point(0, 0) );

    qDebug() << contours.data();
    // Rotar los rectangulos buscando el area minima
    vector<RotatedRect> minRect( contours.size() );
    for( int i = 0; i < contours.size(); i++ ){
         minRect[i] = minAreaRect( Mat(contours[i]) );
     }

    //  Dibujar rectangulos
     Scalar color = Scalar( rng.uniform(0,0), rng.uniform(250,250), rng.uniform(0,0) );
     for( int i = 0; i< contours.size(); i++ ){
         Point2f rect_points[4]; minRect[i].points( rect_points );

         if( pow((int)(rect_points[0].x-(rect_points[1]).x), 2.0) + pow((int)(rect_points[0].y-(rect_points[1]).y), 2.0) > pow(Constants::CONTOURS_MIN_CONTOURS, 2.0) &&
             pow((int)(rect_points[1].x-(rect_points[2]).x), 2.0) + pow((int)(rect_points[1].y-(rect_points[2]).y), 2.0) > pow(Constants::CONTOURS_MIN_CONTOURS, 2.0))
             {
            for(int j = 0; j < 4; j++ ){
                line( dst, rect_points[j], rect_points[(j+1)%4], color, 2, 8 );
                line( final, rect_points[j], rect_points[(j+1)%4], color, 2, 8 );
            }
         }
     }
     imwrite(Constants::IMG_FINAL,final);
    return dst;
}
예제 #4
0
/*****************************************************************************************
* Method Name: FindGate
* Description: The function search for a couple of white vertical rectangles, whose buttom points
* 				are on green && upper part is not on green.
* 				This rectangles are marked as gate posts.
* 				If only one post is present in the frame, the function tries to find the direction
* 				of the second vertical post, using the upper post direction.
* Arguments: BWImage, Output - DetectedGate
* Return Values: DetectedGate object
* Owner: Hen Shoob, Assaf Rabinowitz
*****************************************************************************************/
DetectedObject* GateDetector::FindGate(Mat& inputImage)
{
	Mat onlyWhiteImage;
	GetWhiteImage(inputImage, onlyWhiteImage);

	Mat whiteVertical = onlyWhiteImage.clone();
	GetVerticalObjects(whiteVertical);

	//creating Mat thr with contours, using canny
	Mat src;
	cvtColor(whiteVertical, src, CV_GRAY2BGR);
	Mat canny;
	Canny(whiteVertical, canny, 50, 190, 3, false);
	ImageShowOnDebug("canny", canny);

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

	findContours(canny, contours, hierarchy, CV_RETR_EXTERNAL, CV_CHAIN_APPROX_SIMPLE, Point(0, 0));

	cvtColor(canny, canny, CV_GRAY2BGR);
	//finding the blocking rectangles of the contours
	vector<RotatedRect> minRect(contours.size());
	for (size_t i = 0; i < contours.size(); i++)
	{
		minRect[i] = minAreaRect(Mat(contours[i]));
		DrawRectangle(canny, minRect[i]);
	}
	ImageShowOnDebug("contours", canny);

	Mat field;
	FindField(inputImage, field);

	//Showing the contours + field in one image
	cvtColor(canny, canny, CV_BGR2GRAY);
//	Mat or;
//	bitwise_or(field, canny, or);
//	ImageShowOnDebug("convex", or);

	vector<RotatedRect> post1Candidates;
	FindPostCandidates(field, minRect, post1Candidates);

	RotatedRect post1 = FindLargestCandidate(post1Candidates);
	DrawRectangle(src, post1);
	ImageShowOnDebug("post1", src);

	vector<RotatedRect> post2Candidates;
	for (size_t i = 0; i < post1Candidates.size(); i++)
	{
		if (post1Candidates[i].center.x != post1.center.x)
		{
			post2Candidates.push_back(post1Candidates[i]);
		}
	}

	RotatedRect post2 = FindLargestCandidate(post2Candidates);
	DrawRectangle(src, post2);
	ImageShowOnDebug("post2", src);

	//////////////////////////////////////////////////////////////////////////////////////////

	if (post1.size.area() > 0 && post2.size.area() > 0)
	{
		return new DetectedGate(post1, post2);
	}

	if (post1.size.area() == 0 && post2.size.area() == 0)
	{
		return new DetectedGate();
	}

	// One post - detect which.

	float longSide = (post1.size.height > post1.size.width) ? post1.size.height : post1.size.width;
	float shortSide = (post1.size.height < post1.size.width) ? post1.size.height : post1.size.width;

	Mat whiteHorizontal = onlyWhiteImage.clone();
	GetHorizontalObjects(whiteHorizontal);
	ImageShowOnDebug("whiteHorizontal", whiteHorizontal);

	//counting white pixels near the top of the post on both sides
	// We set the range to look for white pixels in the upper post.
	float upperPostTop = MAX(post1.center.y - longSide / 2 - 10, 0);
	float upperPostButtom = upperPostTop + shortSide + 5;	

	//Counting near the left post
	float upperPostLeft = MAX(post1.center.x - shortSide * 3, 0);
	float upperPostRight = MAX(post1.center.x - shortSide, 0);
	unsigned int leftCounter = CountAndDrawWhitePixels(whiteHorizontal, src, upperPostTop, upperPostButtom, upperPostLeft, upperPostRight);

	//finding right check rectangle, left and right side
	upperPostRight = MIN(post1.center.x + shortSide * 3, FRAME_WIDTH - 1);
	upperPostLeft = MIN(post1.center.x + shortSide, FRAME_WIDTH - 1);
	unsigned int rightCounter = CountAndDrawWhitePixels(whiteHorizontal, src, upperPostTop, upperPostButtom, upperPostLeft, upperPostRight);
	
	if (rightCounter > leftCounter  &&  rightCounter - leftCounter > 5)
	{
		return new DetectedGate(post1, E_DetectedPost_LEFT);
	}
	else if (rightCounter < leftCounter  &&  leftCounter - rightCounter > 5)
	{
		return new DetectedGate(post1, E_DetectedPost_RIGHT);
	}
	else
	{
		PrintStringOnImage(src, "Move camera up");
		return new DetectedGate();
	}	
}
예제 #5
0
  void do_work(const sensor_msgs::ImageConstPtr& msg, const std::string input_frame_from_msg)
  {
    // Work on the image.
    try
    {
      // Convert the image into something opencv can handle.
      cv::Mat frame = cv_bridge::toCvShare(msg, msg->encoding)->image;

      // Messages
      opencv_apps::RotatedRectArrayStamped rects_msg, ellipses_msg;
      rects_msg.header = msg->header;
      ellipses_msg.header = msg->header;

      // Do the work
      cv::Mat src_gray;

      /// Convert image to gray and blur it
      if ( frame.channels() > 1 ) {
        cv::cvtColor( frame, src_gray, cv::COLOR_RGB2GRAY );
      } else {
        src_gray = frame;
      }
      cv::blur( src_gray, src_gray, cv::Size(3,3) );

      /// Create window
      if( debug_view_) {
        cv::namedWindow( window_name_, cv::WINDOW_AUTOSIZE );
      }

      cv::Mat threshold_output;
      int max_thresh = 255;
      std::vector<std::vector<cv::Point> > contours;
      std::vector<cv::Vec4i> hierarchy;
      cv::RNG rng(12345);

      /// Detect edges using Threshold
      cv::threshold( src_gray, threshold_output, threshold_, 255, cv::THRESH_BINARY );

      /// Find contours
      cv::findContours( threshold_output, contours, hierarchy, CV_RETR_TREE, CV_CHAIN_APPROX_SIMPLE, cv::Point(0, 0) );

      /// Find the rotated rectangles and ellipses for each contour
      std::vector<cv::RotatedRect> minRect( contours.size() );
      std::vector<cv::RotatedRect> minEllipse( contours.size() );

      for( size_t i = 0; i < contours.size(); i++ )
      { minRect[i] = cv::minAreaRect( cv::Mat(contours[i]) );
        if( contours[i].size() > 5 )
        { minEllipse[i] = cv::fitEllipse( cv::Mat(contours[i]) ); }
      }

      /// Draw contours + rotated rects + ellipses
      cv::Mat drawing = cv::Mat::zeros( threshold_output.size(), CV_8UC3 );
      for( size_t i = 0; i< contours.size(); i++ )
      {
        cv::Scalar color = cv::Scalar( rng.uniform(0, 255), rng.uniform(0,255), rng.uniform(0,255) );
        // contour
        cv::drawContours( drawing, contours, (int)i, color, 1, 8, std::vector<cv::Vec4i>(), 0, cv::Point() );
        // ellipse
        cv::ellipse( drawing, minEllipse[i], color, 2, 8 );
        // rotated rectangle
        cv::Point2f rect_points[4]; minRect[i].points( rect_points );
        for( int j = 0; j < 4; j++ )
          cv::line( drawing, rect_points[j], rect_points[(j+1)%4], color, 1, 8 );

        opencv_apps::RotatedRect rect_msg;
        opencv_apps::Point2D rect_center;
        opencv_apps::Size rect_size;
        rect_center.x = minRect[i].center.x;
        rect_center.y = minRect[i].center.y;
        rect_size.width = minRect[i].size.width;
        rect_size.height = minRect[i].size.height;
        rect_msg.center = rect_center;
        rect_msg.size = rect_size;
        rect_msg.angle = minRect[i].angle;
        opencv_apps::RotatedRect ellipse_msg;
        opencv_apps::Point2D ellipse_center;
        opencv_apps::Size ellipse_size;
        ellipse_center.x = minEllipse[i].center.x;
        ellipse_center.y = minEllipse[i].center.y;
        ellipse_size.width = minEllipse[i].size.width;
        ellipse_size.height = minEllipse[i].size.height;
        ellipse_msg.center = ellipse_center;
        ellipse_msg.size = ellipse_size;
        ellipse_msg.angle = minEllipse[i].angle;

        rects_msg.rects.push_back(rect_msg);
        ellipses_msg.rects.push_back(ellipse_msg);
      }

      /// Create a Trackbar for user to enter threshold
      if( debug_view_) {
        if (need_config_update_) {
          config_.threshold = threshold_;
          srv.updateConfig(config_);
          need_config_update_ = false;
        }
        cv::createTrackbar( "Threshold:", window_name_, &threshold_, max_thresh, trackbarCallback);

        cv::imshow( window_name_, drawing );
        int c = cv::waitKey(1);
      }

      // Publish the image.
      sensor_msgs::Image::Ptr out_img = cv_bridge::CvImage(msg->header, sensor_msgs::image_encodings::BGR8, drawing).toImageMsg();
      img_pub_.publish(out_img);
      rects_pub_.publish(rects_msg);
      ellipses_pub_.publish(ellipses_msg);
    }
    catch (cv::Exception &e)
    {
      NODELET_ERROR("Image processing error: %s %s %s %i", e.err.c_str(), e.func.c_str(), e.file.c_str(), e.line);
    }

    prev_stamp_ = msg->header.stamp;
  }
  void imageCb(const sensor_msgs::ImageConstPtr& msg)
  {
    cv_bridge::CvImagePtr cv_ptr;
    try
      {
	cv_ptr = cv_bridge::toCvCopy(msg, enc::BGR8);
      }
    catch (cv_bridge::Exception& e)
      {
	ROS_ERROR("cv_bridge exception: %s", e.what());
	return;
      }

    /* Add any OpenCV processing here */
    /* Gray scale image */
    cv::Mat filtered_image;
    cv::cvtColor(cv_ptr->image,filtered_image,CV_BGR2GRAY);
    
    // Image Filtering 
    cv::Mat element5(5,5,CV_8U,cv::Scalar(1));
    cv::morphologyEx(filtered_image,filtered_image,cv::MORPH_CLOSE,element5);
    cv::morphologyEx(filtered_image,filtered_image,cv::MORPH_OPEN,element5);

    cv::blur(filtered_image,filtered_image,cv::Size(3,3));    

    // Show final filtered image 
    cv::namedWindow("Filtered Image");
    cv::imshow("Filtered Image",filtered_image);

    // Finding Contours 
    cv::Mat contoured_image;
    cv::morphologyEx(filtered_image,contoured_image,cv::MORPH_GRADIENT,cv::Mat());
    cv::namedWindow("MORPH_GRADIENT contours");
    cv::imshow("MORPH_GRADIENT contours",contoured_image);

    // threshold image 
    cv::Mat threshold_image;
    cv::threshold(contoured_image,threshold_image,global_min_threshold,255,cv::THRESH_BINARY);
    cv::namedWindow("Threshold Image");
    cv::imshow("Threshold Image",threshold_image);
    cv::createTrackbar("Min Threshold:","Threshold Image",&global_min_threshold,255,update_global_min_threshold);
    update_global_min_threshold(global_min_threshold,0);
    
    // Make bounding boxes:
    //// detect edges using threshold image
    std::vector<std::vector<cv::Point> > contours;
    std::vector<cv::Vec4i> hierarchy;

    cv::findContours(threshold_image,contours,hierarchy,CV_RETR_TREE,CV_CHAIN_APPROX_SIMPLE);

    //// find the rotated rectangles
    std::vector<cv::RotatedRect> minRect(contours.size());
    cv::RotatedRect new_rectangle;
    
    double length_side_a, length_side_b;
    cv::Point2f new_rect_points[4];
    

    for (int i=0; i<contours.size(); i++) {
      // only keep track of rectangles that might be cubelets... needs work
      
      new_rectangle=cv::minAreaRect(cv::Mat(contours[i]));
      new_rectangle.points(new_rect_points);
      
      std::cout<<"INFO:\t point.x = "<<new_rect_points[0].x<<std::endl;
      length_side_a=pow(new_rect_points[0].x-new_rect_points[1].x,2)+
        pow(new_rect_points[0].y-new_rect_points[1].y,2);
      length_side_b=pow(new_rect_points[0].x-new_rect_points[3].x,2)+
        pow(new_rect_points[0].y-new_rect_points[3].y,2);
      
      std::cout<<"INFO:\tsize, l_a/l_b = "<<new_rectangle.size.area()<<" ,"<<length_side_a/length_side_b<<std::endl;
      if (new_rectangle.size.area()>=500 && // minimum size requirement
          length_side_a/length_side_b>(100.0-global_squareness_ratio)/100.0 && // minimum squareness
          length_side_a/length_side_b<(100.0+global_squareness_ratio)/100.0) {
        minRect[i]=new_rectangle;
      }
    }
    
    //// Draw contours & rectangles
    cv::Mat contour_output(threshold_image.size(),CV_8U,cv::Scalar(255));
    cv::Mat bounding_boxes=cv::Mat::zeros(contour_output.size(),CV_8UC3);;
    int i=0;
    for (; i >=0; i=hierarchy[i][0]) {
      cv::Point2f rect_points[4];
      minRect[i].points(rect_points);
      cv::drawContours(bounding_boxes,contours,i,cv::Scalar(255,255,255),1,8,hierarchy,0,cv::Point());
      for (int j=0; j<4; j++) {
        cv::line(bounding_boxes,rect_points[j],rect_points[(j+1)%4],cv::Scalar(255),2,8);
      }
    }
    cv::namedWindow("bounding boxes");
    cv::imshow("bounding boxes",bounding_boxes);
    cv::createTrackbar("Out-of-square acceptance: ","bounding boxes",&global_squareness_ratio,100,update_global_squareness_ratio);

   // end of processing
    cv::imshow(WINDOW, cv_ptr->image);
    cv::waitKey(3);
    
    image_pub_.publish(cv_ptr->toImageMsg());
  }