C++ cvPutText函数代码示例

void AAMFit::CreateStat( IplImage *pFrame, int pMode, bool pDrawNumbers, CvScalar pRGB )
{
	CvFont font;
	char text[20];

	cvInitFont( &font, CV_FONT_HERSHEY_SIMPLEX, 0.1, 1.0, 0, 1, CV_AA );
	//_model->Draw(pFrame, pMode);

	if( _smoothedImagePoints.empty() )
	{
		for( int i = 0; i < _imagePoints.size(); i++ )
		{
			cvCircle( pFrame, cvPoint( _imagePoints[i].x, _imagePoints[i].y), 3, pRGB, -1 );

			if( pDrawNumbers )
			{
				sprintf( text, "%d", i );
				cvPutText( pFrame, text, cvPoint(_imagePoints[i].x, _imagePoints[i].y), &font, cvScalar(255, 255, 255, 0) );
			}
		}
	}
	else
	{
		for( int i = 0; i < _smoothedImagePoints.size(); i++ )
		{
			cvCircle( pFrame, cvPoint( _smoothedImagePoints[i].x, _smoothedImagePoints[i].y), 3, pRGB, -1 );

			if( pDrawNumbers )
			{
				sprintf( text, "%d", i );
				cvPutText( pFrame, text, cvPoint(_smoothedImagePoints[i].x, _smoothedImagePoints[i].y), &font, cvScalar(255, 255, 255, 0) );
			}
		}
	}
}

// Draw graphs      -- todo, adjust to fit in window
void Painting::drawGraph()
{
    // Paint the canvas white
    cvZero(mImage);
    cvRectangleR(mImage,cvRect(0,0,500,500),cvScalar(255,255,255), -1);

    CvFont font;
    double hScale=0.5;
    double vScale=0.5;
    int    lineWidth=1;
    cvInitFont(&font,CV_FONT_HERSHEY_SIMPLEX|CV_FONT_ITALIC, hScale,vScale,0,lineWidth);

    // Add text to canvas
    cvPutText (mImage,"Left",cvPoint(20,50), &font, cvScalar(200,0,0));
    cvPutText (mImage,"Right",cvPoint(420,50), &font, cvScalar(0,200,0));

    // Iterate the vector of data and center the selected objects
    if(mData.size())
    {
        int xScale = 200;
        int yScale = 20;
        int xOffSet = 250 - mData[mSelect].timeStamp * xScale;
        int yOffSet1 = 240 + mData[mSelect].pulsefreq * yScale;
        int yOffSet2 = 250 + mData[mSelect].blinkingfreq * yScale;
        int yOffSet3 = 260 + mData[mSelect].breathingfreq * yScale;
        int t = 1; //thick

        if(mSelect == 0)
            t = -1;

        drawCircle(mImage,cvPoint(mData[0].timeStamp * xScale + xOffSet,yOffSet1 - mData[0].pulsefreq * yScale),0,t);
        drawCircle(mImage,cvPoint(mData[0].timeStamp * xScale + xOffSet,yOffSet2 - mData[0].blinkingfreq * yScale),1,t);
        drawCircle(mImage,cvPoint(mData[0].timeStamp * xScale + xOffSet,yOffSet3 - mData[0].breathingfreq * yScale),2,t);

        for(unsigned int i = 1; i<mData.size(); i++)
        {
            int thick = 1;
            if((unsigned)mSelect == i)
                thick = -1;
            // Pulse
            drawCircle(mImage,cvPoint(mData[i].timeStamp * xScale + xOffSet, yOffSet1 - mData[i].pulsefreq * yScale),0,thick);
            cvLine(mImage,cvPoint(mData[i].timeStamp * xScale + xOffSet, yOffSet1 - mData[i].pulsefreq * yScale),
                   cvPoint(mData[i-1].timeStamp * xScale + xOffSet, yOffSet1 - mData[i-1].pulsefreq * yScale),cvScalar(0,0,255));
            // Blinking
            drawCircle(mImage,cvPoint(mData[i].timeStamp * xScale + xOffSet, yOffSet2 - mData[i].blinkingfreq * yScale),1,thick);
            cvLine(mImage,cvPoint(mData[i].timeStamp * xScale + xOffSet, yOffSet2 - mData[i].blinkingfreq * yScale),
                   cvPoint(mData[i-1].timeStamp * xScale + xOffSet, yOffSet2 - mData[i-1].blinkingfreq * yScale),cvScalar(0,255,0));
            // Breathing
            drawCircle(mImage,cvPoint(mData[i].timeStamp * xScale + xOffSet, yOffSet3 - mData[i].breathingfreq * yScale),2,thick);
            cvLine(mImage,cvPoint(mData[i].timeStamp * xScale + xOffSet, yOffSet3 - mData[i].breathingfreq * yScale),
                   cvPoint(mData[i-1].timeStamp * xScale + xOffSet, yOffSet3 - mData[i-1].breathingfreq * yScale),cvScalar(255,0,0));
        }
    }

    cvShowImage(WindowName, mImage);

}

   /* draw to video canvas */
   static void video (
         GtkWidget      *widget,
         GdkEventExpose *eev){

      //gtk_widget_queue_draw(GTK_WIDGET(widget));

      if(!start) return;

      if(cv_image!=NULL){

        double t =  microtime();

        /* vypsání ladícího textu */
        CvFont font;
        double hScale=0.5;
        double vScale=0.5;
        int lineWidth=1;
        char buffer[125];

        cvFlip(cv_image, cv_image, 1);

         cvInitFont(&font,CV_FONT_HERSHEY_SIMPLEX|CV_FONT_ITALIC, hScale, vScale, 0, lineWidth);
         sprintf(buffer,"Treshold %d/255 [key m,n]", treshold);
         cvPutText (cv_image, buffer, cvPoint(10, 20), &font, cvScalar(0, 255, 0));
         cvLine(cv_image, cvPoint(260,15), cvPoint(260 + treshold,15), cvScalar(0, 255, 0), 10, 4);

         sprintf(buffer,"Timer: %f | %f | %f | %f", timer[0], timer[1], timer[2], timer[3]);
         cvPutText (cv_image,buffer,cvPoint(10,40), &font, cvScalar(255, 0, 0));
         sprintf(buffer,"Fps: %d ", fps);
         cvPutText (cv_image,buffer,cvPoint(10,60), &font, cvScalar(255, 0, 0));

         //převedení opencv do gtk
         GdkPixbuf * pix = gdk_pixbuf_new_from_data(
               (guchar*)cv_image->imageData,
               GDK_COLORSPACE_RGB,
               FALSE,
               cv_image->depth,
               cv_image->width,
               cv_image->height,
               cv_image->widthStep,
               NULL,
               NULL);
          //gtkImg = gtk_image_new_from_pixbuf (pix);
         gdk_draw_pixbuf (widget->window,
                      widget->style->fg_gc[GTK_WIDGET_STATE (widget)],
                      pix,
                      0, 0, 0, 0, 640, 480, GDK_RGB_DITHER_NONE, 0, 0 );
         //gtk_widget_queue_draw(widget);
         gdk_pixbuf_unref (pix);
         
         timer[2] =  microtime() - t;
      } else {
         //printf("ERROR: Video nebylo načteno.\n");
      }

      currently_framing = 0;
   }

int main (int argc, char **argv)
{
    int width=960, height=640;
    IplImage *img=0;
    double c, f;
    f = cvGetTickFrequency()*1000;
    
    int cx = width/2;
    int cy = height/2;
    double radius = 100;
    double angle = 0;
    CvScalar color = cvScalarAll(255);
    
    CvFont font;
    cvInitFont(&font, CV_FONT_HERSHEY_SIMPLEX, 0.5, 1.0, 1.0, 1, CV_AA);
    
    cvNamedWindow ("hexagon", CV_WINDOW_AUTOSIZE);
    while (1) {
        
        // (1)allocate and initialize an image
        img = cvCreateImage(cvSize(width, height), IPL_DEPTH_8U, 3);
        if(img == 0) return -1;
        cvZero(img);
        
        // (2) draw hexagon
        c = cvGetTickCount();
        myHexagon(img, cx, cy, radius, angle, color);
        printf("%fms\n", (cvGetTickCount()-c)/f);
        
        // (3)show the iamge, and press some key
        cvPutText(img, "Coordinate Right(D) Left(A) Up(W) Down(X)", cvPoint(10, 20), &font, cvScalarAll(255));
        cvPutText(img, "Rotate Right(R) Left(E)", cvPoint(10, 40), &font, cvScalarAll(255));
        cvPutText(img, "Radius Big(V) Small(C)", cvPoint(10, 60), &font, cvScalarAll(255));
        cvPutText(img, "Quit(Q, esc)", cvPoint(10, 80), &font, cvScalarAll(255));
        char s[64];
        sprintf(s, "cx:%d cy:%d radius:%f angle:%f", cx, cy, radius, angle);
        cvPutText(img, s, cvPoint(10, 110), &font, cvScalarAll(255));
        
        cvShowImage ("hexagon", img);
        char key = cvWaitKey (0);
        if (key == 27 || key == 'q') break;
        else if (key == 'r') angle += 5;
        else if (key == 'e') angle -= 5;
        else if (key == 'a') cx -= 5;
        else if (key == 'd') cx += 5;
        else if (key == 'w') cy -= 5;
        else if (key == 'x') cy += 5;
        else if (key == 'v') radius += 5;
        else if (key == 'c') radius -= 5;
    }
    
    cvDestroyWindow("hexagon");
    cvReleaseImage(&img);
    
    return 0;
}

void Bot::make()
{
	camera->update();
	if(camera->getFrame()){
		//
		// получаем кадр с камеры
		//
		if(image==0){
			image = cvCloneImage(camera->getFrame());
		}
		else{
			cvCopy(camera->getFrame(), image);
		}

		// для хранения центра объекта
		CvPoint2D32f point;

		//
		// передаём кадр на обработку детектору
		//
		bool result = detector->getCenter( image, point, BOT_THRESHOLD);

		char buf[128]; // для вывода информации

		if(result){
			//
			// объект обнаружен
			//

			printf("[i][Bot] point: %.2f : %.2f \n", point.x, point.y);

			if(gimbal){
				gimbal->make( cvPoint(image->width/2, image->height/2), cvPointFrom32f(point) );
			}

			// отметим центр
			cvCircle(image, cvPointFrom32f(point), 3, CV_RGB(0, 255, 0), 2);

			// выводим сообщение в верхнем левом углу картинки
			sprintf(buf, "Object detected: %.2f : %.2f", point.x, point.y);
			cvPutText(image, buf, cvPoint(10, 20), &font, CV_RGB(0, 255, 0));
		}
		else{
			//
			// объект не обнаружен
			//

			// выводим сообщение в верхнем левом углу картинки
			sprintf(buf, "Cant find object!");
			cvPutText(image, buf, cvPoint(10, 20), &font, CV_RGB(255 , 0, 0));
		}

		cvShowImage(window_name, image);
	}
}

void KfieldGui::DisplayErrors(float DistError, float RotError) {
	pthread_mutex_lock(&lock);

	tmp = Kutils::to_string(DistError); // boost::lexical_cast<string>(Belief.confidence);
	cvPutText(field, tmp.c_str(), cvPoint((2 * 675.0 + 6050 - 200) / SCALE, (2 * 675.0 + 4050 + 650) / SCALE), &font, cvScalar(255, 255, 255));

	tmp = Kutils::to_string(RotError * TO_DEG);
	cvPutText(field, tmp.c_str(), cvPoint((2 * 675.0 + 6050 - 200) / SCALE, (2 * 675.0 + 4050 + 850) / SCALE), &font, cvScalar(255, 255, 255));
	pthread_mutex_unlock(&lock);

}

void EyeTracker::drawTrasholds()
{
	CvFont font;
	char s[20];
	sprintf(s, "HIGH THRESHOLD = %d", highThreshold);
	cvInitFont(&font, CV_FONT_HERSHEY_SIMPLEX | CV_FONT_ITALIC, 1, 1, 0, 1);
	cvPutText(grayEyeImagePts, s, cvPoint(10, 40), &font, cvScalar(255, 255, 0));

	sprintf(s, "SQUARE THRESHOLD = %d", squareThreshold);
	cvInitFont(&font, CV_FONT_HERSHEY_SIMPLEX | CV_FONT_ITALIC, 1, 1, 0, 1);
	cvPutText(grayEyeImagePts, s, cvPoint(10, 100), &font, cvScalar(255, 255, 0));
}

void draw_digit(int width, int x, int y, char *digit,
				IplImage *debug, CvFont *font)
{
	char text[3] = { digit[0] + 48, 0, 0 };
	if (text[0] > '9') {
		text[0] -= 10;
		text[1] = '.';
	}
	CvPoint origin = cvPoint(debug->width * x / width, debug->height - y);
	cvPutText(debug, text, origin, font, cvScalar(0, 0, 0, 255));
	origin.x--;
	cvPutText(debug, text, origin, font, cvScalar(0, 0, 255, 255));
}

void kalman::showlist(bool flag ,QPlainTextEdit *&plain)
{
	cvSet(img, cvScalar(255, 255, 255, 0));
	cvRectangle(img, cvPoint(rect.x, rect.y), cvPoint(rect.x + rect.width, rect.y + rect.height), cvScalar(255, 0, 0));

	CvFont font;
	cvInitFont(&font, CV_FONT_HERSHEY_SIMPLEX, 0.5f, 0.5f, 0, 1, 8);
	if (nl->next)
	{
		node * p = nl->next;
		if (num >= 5 || flag)
		{
			while (p)
			{
				if (p->done)
				{
					cvCircle(img, cvPoint(p->x, p->y), 5, CV_RGB(255, 0, 0), 3);
 					p->done = false;
					p = p->next;
				}
				else
				{
					qDebug("dy:%d", p->dy);
					
					if (p->dy >= 10)
					{
						sum = sum - 1;
						qDebug("The Number : %d", sum);
						cvPutText(img, sum + "", cvPoint(0, 20), &font, cvScalar(0, 0, 255));

					}
					else if (p->dy <= -10)
					{
						sum++;
						qDebug("The Number : %d", sum);
						cvPutText(img, sum + "", cvPoint(0, 20), &font, cvScalar(0, 0, 255));
					}
					plain->appendPlainText("The Number :"+QString::number(sum));
					p = deleteNode(nl, p);
				}

			}
			num = 0;
		}
		else
		{
			num++;
		}
	}
	//cvShowImage("kalman",img);
 }

// called by the loop to actually grab the frames
int capture_image(int fd,CvFont *font, int *set_quality, IplImage* frame,CvMat *cvmat,char *capture_title,v4l2_buffer *buf, uint32_t *start_time, uint32_t *image_count) {

    // request a new frame
    if(-1 == xioctl(fd, VIDIOC_QBUF, buf)) {
        perror("Query Buffer");
        return 1;
    }

    // wait up to 2 sec for a new frame to arive
    fd_set fds;
    FD_ZERO(&fds);
    FD_SET(fd, &fds);
    struct timeval tv = {0};
    tv.tv_sec = 2;
    int r = select(fd+1, &fds, NULL, NULL, &tv);
    if(-1 == r) {
        perror("Waiting for Frame");
        return 1;
    }

    // read it
    if(-1 == xioctl(fd, VIDIOC_DQBUF, buf)) {
        perror("Retrieving Frame");
        return 1;
    }

    // convert v4l2 buffer to opencv image
    *cvmat = cvMat(height, width, CV_8UC3, (void*)buffer);
    frame = cvDecodeImage(cvmat, 1);

    // add title, reused tv from select-wait
    gettimeofday(&tv, NULL);
    time_t secs = time(0);
    struct tm *local = localtime(&secs);
    sprintf(capture_title, CAPTURE_PROTO, local->tm_hour, local->tm_min, local->tm_sec, (int)((unsigned long long)(tv.tv_usec) / 1000)%1000);

    (*image_count)++;
    printf("%s @ %2.2f fps\n",capture_title, round((float)(*image_count)*100/(time(0)-(*start_time)))/100 );
    cvPutText(frame, capture_title, cvPoint(22, 22), font, cvScalar(0,0,0,0));
    cvPutText(frame, capture_title, cvPoint(24, 24), font, cvScalar(200,200,200,0));

    // save to disk ... well RAM
    cvSaveImage("/dev/shm/mjpeg/cam_full.part.jpg", frame, set_quality);
    rename("/dev/shm/mjpeg/cam_full.part.jpg","/dev/shm/mjpeg/cam_full.jpg");

    // important to avoid mem leakage
    cvReleaseImage(&frame);

    return 0;
}

void PrintText(IplImage* img, char* text,CvScalar color, int l1_2){
	char* num=new char[20];
	itoa(fileCount,num,10);
//	strcat(text,num);
	if(l1_2==1){
		if(text!=NULL) cvPutText(img, text, cvPoint(10, 130), &font, color);
		else cvPutText(img, num, cvPoint(10, 130), &font, color);
	}
	else{
		if(text!=NULL) cvPutText(img, text, cvPoint(10, 230), &font, color);
		else cvPutText(img, num, cvPoint(10, 230), &font, color);
	}
	delete num;
}

void CvButtons::paintButtons(IplImage *img){
	vector<PushButton>::iterator it = buttonList.begin();
	while (it != buttonList.end()) {
		
		// Grab button variables:
		int x = it->x_pos;
		int y = it->y_pos;
		int w = it->width;
		int h = it->height;
		int x2 = x+w;
		int y2 = y+h;
		
		// Highlight mouseover position:
		if( mx >= x && mx <= x2 && my >= y && my <= y2 ){
			cvRectangle( img, cvPoint(x-4,y-4), cvPoint(x2+4,y2+4), C2, 1,CV_AA );
			
			// Check for mouse pressed event:
			if( me == CV_EVENT_LBUTTONDOWN/* || mf & CV_EVENT_FLAG_LBUTTON */){
				
				// Check if toggle button has to change state:
				if( it->toggle == 0 || it->toggle == 1 ) it->toggle = !it->toggle;
				
				// Call callback function:
				it->cb(it->toggle);
				
				// Draw confirmation rectangle:
				cvRectangle( img, cvPoint(x,y), cvPoint(x2,y2), C2,CV_FILLED,CV_AA );
				
				// Reset event (avoid flickering buttons):
				me = CV_EVENT_MOUSEMOVE;
			}
		}
		
		// Draw toggle state:
		if( it->toggle == 1 )
			cvRectangle( img, cvPoint(x,y), cvPoint(x2,y2), C2,CV_FILLED,CV_AA );
			
		// Draw button with text:
		cvRectangle( img, cvPoint(x,y), cvPoint(x2,y2), C2,1,CV_AA );
		if( it->toggle == 1 )
			cvPutText( img, it->text, cvPoint(x+5,y+15), &font, C1 );
		else
			cvPutText( img, it->text, cvPoint(x+5,y+15), &font, C2 );
        
        // Step to next button:
        it++;
	}
}

IplImage * showPoints(IplImage * img)
{
	int i,x1,y1,x2,y2;
	CvFont font; 
	cvInitFont(&font,CV_FONT_HERSHEY_SIMPLEX|CV_FONT_ITALIC, 0.5,0.5,0,1);

	for(i=0;i<line_set_cnt;i++)
	{
		x1 = point_val[line_set[i][0]][0];
		y1 = point_val[line_set[i][0]][1];
		x2 = point_val[line_set[i][1]][0];
		y2 = point_val[line_set[i][1]][1];
		
		if(x1>=0&&x2>=0)
		{
			cvLine(showim,cvPoint(x1,y1),cvPoint(x2,y2),CV_RGB(100,100,100),POINT_RADIUS);
		}
	}

	for(i=0;i<point_set_cnt;i++)
	{
		if(point_val[i][0]>=0)
		{
			cvCircle(img,cvPoint(point_val[i][0],point_val[i][1]),POINT_RADIUS,cvScalar(0,0,255),-1);
			cvPutText(img,point_set[i],cvPoint(point_val[i][0]+POINT_RADIUS,point_val[i][1]),&font,CV_RGB(100,200,255));
		}
	}

	return img;
}

std::list<CvBox2D> PathObject::GetBounding(const IplImage * imgIn, IplImage * debugOut) const
{

    std::list<CvBox2D> blobList;
    if(imgIn == NULL) return blobList;
    IplImage * imgOut1 = GetMask(imgIn);
    //cvShowImage("imgout1",imgOut1);
    CvFont font;
    cvInitFont(&font, CV_FONT_HERSHEY_SIMPLEX, 1,1);
    if(imgOut1)
    {
        blobList = Zebulon::Vision::VisionUtils::GetBlobBoxes(imgOut1,.001,.95);
        if (debugOut)
        {
            for(std::list<CvBox2D>::iterator it = blobList.begin(); it != blobList.end(); it++)
            {
//                CvPoint2D32f boxCorners[4];
//                cvBoxPoints(*it,boxCorners);

                std::ostringstream s;
                s << "(" << it->angle << ")";
                cvPutText(debugOut,s.str().c_str(),cvPointFrom32f(it->center),&font,mNearColor);
                Zebulon::Vision::VisionUtils::DrawSquare(debugOut,*it,mNearColor);
            }
        }
        cvReleaseImage(&imgOut1);
    }

    return blobList;

}

int main(int argc, char** argv) {
  CvCapture* capture = 0;
  IplImage* input = 0;
  IplImage* output = 0;
  int tick = 0, prev_tick = 0;
  double now = 0.0;
  CvFont font;
  char buffer[256];
  const char* windowName = "median";

  if (argc == 1 || (argc == 2 && strlen(argv[1]) == 1 && isdigit(argv[1][0]))) {
    capture = cvCreateCameraCapture(argc == 2 ? argv[1][0] - '0' : 0);
  } else if (argc == 2) {
    capture = cvCreateFileCapture(argv[1]);
  }
  if (!capture) {
    fprintf(stderr, "ERROR: capture is NULL \n");
    return (-1);
  }

  cvNamedWindow(windowName, CV_WINDOW_AUTOSIZE);
  cvInitFont(&font, CV_FONT_HERSHEY_SIMPLEX, 1.0, 1.0, 0.0, 1, 0);
  input = cvQueryFrame(capture);
  if (!input) {
    fprintf(stderr, "Could not query frame...\n");
    return (-1);
  }
  output = cvCreateImage(cvSize(input->width, input->height), IPL_DEPTH_8U, 3);

  while (1) {
    input = cvQueryFrame(capture);
    if (!input) {
      fprintf(stderr, "Could not query frame...\n");
      break;
    }

    process(input, output);

    sprintf(buffer, "%3.1lfms", now / 1000);
    cvPutText(output, buffer, cvPoint(50, 150), &font, CV_RGB(255, 0, 0));

    cvShowImage(windowName, output);

    //If a certain key pressed
    if (cvWaitKey(10) >= 0) {
      break;
    }

    tick = cvGetTickCount();
    now = (tick - prev_tick) / cvGetTickFrequency();
    prev_tick = tick;
  }

  cvReleaseImage(&output);

  cvReleaseCapture(&capture);
  cvDestroyWindow(windowName);

  return 0;
}