C++ cvCreateTrackbar函数代码示例

void the_project::project_binary()
{

	get_binary = cvCreateImage(image_size, IPL_DEPTH_8U, 1);

	int blue=100;
	int green=10;
	int red=10;
	cvCreateTrackbar("blue","win2",&blue,0xff);
	cvCreateTrackbar("green","win2",&green,0xff);
	cvCreateTrackbar("red","win2",&red,0xff);

	cvNamedWindow("win3");
	cout << "Press Space to continue...\n";
	while(1){
		char a = cvWaitKey(10);
		if(a==' ')
			break;
		cvInRangeS(get_change,cvScalarAll(0),CV_RGB(red,green,blue),get_binary);
		cvShowImage("win3",get_binary);
	}
	//cvWaitKey();
	

	get_path = cvCreateImage(image_size,8,1);
	cvCopyImage(get_binary,get_path);
}

void OpenCVAdapter::Loop(){
	f_loop=true;
	cvNamedWindow (windowNameCap.c_str(), CV_WINDOW_AUTOSIZE);
	cvNamedWindow (windowNameThr.c_str(), CV_WINDOW_AUTOSIZE);
	HWND hWndCap=(HWND)cvGetWindowHandle(windowNameCap.c_str());
	HWND hWndThr=(HWND)cvGetWindowHandle(windowNameThr.c_str());
	cvCreateTrackbar(trackbarName.c_str(),windowNameThr.c_str(),&trackbarPosition,100,NULL);
	cvCreateTrackbar(trackbarName2.c_str(),windowNameThr.c_str(),&trackbarPosition2,200,NULL);

	label = new unsigned char[xnum*ynum];
	labeled = new short[xnum*ynum];

	int fc=0;

	for(;f_loop;){
		if(f_start){
			GetFrame();
			LabelFrame();
			ProcFrame();
			cvShowImage (windowNameThr.c_str(), frame);
		}
		cvWaitKey (1000/fps);

	}
	SAFE_DELETE_ARRAY(label);
	SAFE_DELETE_ARRAY(labeled);

	cvDestroyWindow (windowNameCap.c_str());
	cvDestroyWindow (windowNameThr.c_str());
}

int main( int argc, char** argv )
{
    char* filename = argv[1];
    if( (image = cvLoadImage("5.bmp",1)) == 0 )
        return -1;
    
		
	kernel = cvCreateMat(kernel_size,kernel_size,CV_32FC1);

	src = cvCreateImage(cvSize(image->width,image->height),IPL_DEPTH_8U,1);

	cvCvtColor(image,src,CV_BGR2GRAY);
    dest = cvCloneImage(src);
	
    cvNamedWindow("Process window",1);

    cvShowImage("Process window",src);

    cvCreateTrackbar("Variance","Process window", &pos_var,50,Process);
    cvCreateTrackbar("Pulsation","Process window",&pos_w ,50,Process);
	cvCreateTrackbar("Phase","Process window",&pos_phase ,180,Process);

    cvWaitKey(0);
     
    cvReleaseImage(&src);
    cvReleaseImage(&image);
    cvReleaseImage(&dest);
    
    cvDestroyWindow("Process window"); 
    return 0;
}

int main()
{
	int low=0,high=128;
	CvCapture* capture;
	capture = cvCreateCameraCapture(-1);
	IplImage *frame,*grey,*res;
	char win[]="video_stream";
	char win2[]="outline_feed";
	cvNamedWindow(win,CV_WINDOW_AUTOSIZE);
	cvNamedWindow(win2,CV_WINDOW_AUTOSIZE);
	cvCreateTrackbar("Low",win2,&low,128);
	cvCreateTrackbar("High",win2,&high,128);

	frame=cvQueryFrame(capture);
	grey=cvCreateImage(cvSize(frame->width,frame->height),IPL_DEPTH_8U,1);
	res=cvCreateImage(cvSize(frame->width,frame->height),IPL_DEPTH_8U,1);

	while(1)
	{
		frame=cvQueryFrame(capture);
		cvCvtColor(frame,grey,CV_BGR2GRAY);
		cvCanny(grey,res,low,high,3);
		cvShowImage(win,frame);
		cvShowImage(win2,res);
		char c=cvWaitKey(33);
		if(c==27)
			break;
	}
	cvReleaseImage(&frame);
	cvReleaseImage(&res);
	cvReleaseCapture(&capture);
	cvDestroyWindow(win);
	cvDestroyWindow(win2);
	return 0;
}

/////////////////////////////////////////////////////////////////////////////
// Panel::DetectBlob() 
// Description: This is the function which finds the largest blob in an 
//  image. It is used in this application to locate the tag after the 
//  InRange function is applied to the original image. It has no return 
//  value but displays a message indicating whether or not there was a 
//  blob of size specified in the funtion definition below. This value 
//  may need to be adjusted based on the camera angle and distance to the
//  part. 
/////////////////////////////////////////////////////////////////////////////
void Panel::DetectBlob(Mat image, bool debug)
{
	Mat grayImage, dilatedEroded, dilated, blurred;
	cvtColor(image, grayImage, CV_BGR2GRAY);

	// Setup SimpleBlobDetector parameters.
	std::vector<KeyPoint> keypoints;

	if (!debug)
		GetKeyPoints(grayImage, keypoints, false);
	else
	{
		namedWindow("Blob", CV_WINDOW_NORMAL);
		cvCreateTrackbar("Blob Area", "Blob", &m_blobArea, 2000);
		cvCreateTrackbar("Threshhold", "Blob", &m_lowTagThreshold, 255);
		while (true)
		{
			GetKeyPoints(grayImage, keypoints, true);
			if (waitKey(50) == 27)
				break;
		}
	}
	// Pass/Fail Message
	if (!keypoints.empty())
		ShowMessage("Tag detected");
	else
		ShowMessage("No tag detected");
}

int main( int argc, char** argv )
{
    char* filename = 0;

    help();

    filename = argc == 2 ? argv[1] : (char*)"baboon.jpg";
    if( (src = cvLoadImage(filename,1)) == 0 )
    {
        printf("Cannot load file image %s\n", filename);
        help();
        return -1;
    }



    dst = cvCloneImage(src);

    //create windows for output images
    cvNamedWindow("Open/Close",1);
    cvNamedWindow("Erode/Dilate",1);

    open_close_pos = erode_dilate_pos = max_iters;
    cvCreateTrackbar("iterations", "Open/Close",&open_close_pos,max_iters*2+1,OpenClose);
    cvCreateTrackbar("iterations", "Erode/Dilate",&erode_dilate_pos,max_iters*2+1,ErodeDilate);

    for(;;)
    {
        int c;

        OpenClose(open_close_pos);
        ErodeDilate(erode_dilate_pos);
        c = cvWaitKey(0);

        if( (char)c == 27 )
            break;
        if( (char)c == 'e' )
            element_shape = CV_SHAPE_ELLIPSE;
        else if( (char)c == 'r' )
            element_shape = CV_SHAPE_RECT;
        else if( (char)c == 'c' )
            element_shape = CV_SHAPE_CROSS;
        else if( (char)c == ' ' )
            element_shape = (element_shape + 1) % 3;
    }

    //release images
    cvReleaseImage(&src);
    cvReleaseImage(&dst);

    //destroy windows
    cvDestroyWindow("Open/Close");
    cvDestroyWindow("Erode/Dilate");

    return 0;
}

int main( int argc, char** argv )
{
    char* filename = argc == 2 ? argv[1] : (char*)"baboon.jpg";
    if( (src = cvLoadImage(filename,1)) == 0 )
        return -1;

    printf( "Hot keys: \n"
        "\tESC - quit the program\n"
        "\tr - use rectangle structuring element\n"
        "\te - use elliptic structuring element\n"
        "\tc - use cross-shaped structuring element\n"
        "\tSPACE - loop through all the options\n" );

    dst = cvCloneImage(src);

    //create windows for output images
    cvNamedWindow("Open/Close",1);
    cvNamedWindow("Erode/Dilate",1);

    open_close_pos = erode_dilate_pos = max_iters;
    cvCreateTrackbar("iterations", "Open/Close",&open_close_pos,max_iters*2+1,OpenClose);
    cvCreateTrackbar("iterations", "Erode/Dilate",&erode_dilate_pos,max_iters*2+1,ErodeDilate);

    for(;;)
    {
        int c;

        OpenClose(open_close_pos);
        ErodeDilate(erode_dilate_pos);
        c = cvWaitKey(0);

        if( (char)c == 27 )
            break;
        if( (char)c == 'e' )
            element_shape = CV_SHAPE_ELLIPSE;
        else if( (char)c == 'r' )
            element_shape = CV_SHAPE_RECT;
        else if( (char)c == 'c' )
            element_shape = CV_SHAPE_CROSS;
        else if( (char)c == ' ' )
            element_shape = (element_shape + 1) % 3;
    }

    //release images
    cvReleaseImage(&src);
    cvReleaseImage(&dst);

    //destroy windows
    cvDestroyWindow("Open/Close");
    cvDestroyWindow("Erode/Dilate");

    return 0;
}

int detect_obstacles()
{
	CvCapture* capture = 0;
	capture = cvCaptureFromCAM(0);
	IplImage *frame, *imHSV;
    cvNamedWindow("result", 0);	
    int Hthresh = 0;
    int Vthresh = 0;
    cvCreateTrackbar("hue thresh", "result", &Hthresh, 10000, NULL);
    cvCreateTrackbar("value thresh", "result", &Vthresh, 100, NULL);
    IplImage* h_plane ;
    IplImage* s_plane ;
    IplImage* v_plane ;
	for(;;)
	{
		frame = cvQueryFrame( capture );
		if(frame){
		  cvSmooth(frame, frame, CV_GAUSSIAN, 25, 25, 0, 0);
		  cvSetImageROI(frame, cvRect(0,(frame->height/2),frame->width, (frame->height/2)));
		  
		  h_plane = cvCreateImage( cvGetSize(frame ), 8, 1 );
		  s_plane = cvCreateImage( cvGetSize( frame), 8, 1 );
		  v_plane = cvCreateImage( cvGetSize( frame ), 8, 1 );
		  imHSV = cvCreateImage(cvGetSize(frame), IPL_DEPTH_8U, 3);
		  cvCvtColor(frame,imHSV,CV_BGR2HSV);
		  cvCvtPixToPlane( imHSV , h_plane, s_plane, v_plane, 0 );
		  CvHistogram* hist_h,*hist_v;
		  int h_bins = H_BINS, v_bins = V_BINS;
		  
		  hist_h = create_histogram(h_plane, H_MAX, &h_bins);
		  hist_v = create_histogram(v_plane, V_MAX, &v_bins);
		  
		  if(process_frame(frame, h_plane, v_plane, hist_h, hist_v, Hthresh, Vthresh)==-1)
		    break;
		}
		cvReleaseImage(&imHSV );
		cvReleaseImage(&h_plane );
		cvReleaseImage(&v_plane );
	}

	cvReleaseCapture( &capture );
	cvDestroyWindow("Display");

	//  cvDestroyWindow("FinalDisplay");
	cvDestroyWindow("VDisplay");
	cvDestroyWindow("Result");
	cvDestroyWindow("Display1");
	return 0;
}

bool _stdcall opencvProcess(LPWSTR csInputPath, LPWSTR csOutputPath)
{
	char inputPath[SIZE] = "";
	WideCharToMultiByte(950, 0, csInputPath, -1, inputPath, SIZE, NULL, NULL);//wchar_t * to char
	char outputPath[SIZE] = "";
	WideCharToMultiByte(950, 0, csOutputPath, -1, outputPath, SIZE, NULL, NULL);//wchar_t * to char *

	//load image
	img = cvLoadImage(inputPath, 1);
	if(!img)
		return false;
	else  
	{
		CvSize size = cvGetSize(img); 

		int xScreen = GetSystemMetrics(SM_CXSCREEN);
		int yScreen = GetSystemMetrics(SM_CYSCREEN);
		
		while(size.width + 100 > xScreen || size.height + 100 > yScreen)
		{
			size.width /= 1.4;
			size.height /= 1.4;
		}//end while

		cvNamedWindow(windowName, 0);
		cvResizeWindow(windowName, size.width, size.height); 
		cvMoveWindow(windowName, (xScreen-size.width)/2, (yScreen-size.height)/2 );

		CvSize panelSize = cvSize(600, 135);
		cvNamedWindow(ctrlPanel, 1);
		cvResizeWindow(ctrlPanel, panelSize.width, panelSize.height);
		cvMoveWindow(ctrlPanel, (xScreen-size.width)/2, (yScreen-size.height)/2 ); 
		cvCreateTrackbar("黑白/彩色", ctrlPanel, &isColor, 1, onTrackbar);
		cvCreateTrackbar("水平/垂直", ctrlPanel, &isY, 1, onTrackbar);
		cvCreateTrackbar("大小", ctrlPanel, &aSize, 7, onTrackbar);
		cvShowImage(ctrlPanel, NULL);

		onTrackbar(0);
		cvWaitKey(0);

		//release
		cvSaveImage(outputPath, dst);
		cvReleaseImage(&dst);
		cvReleaseImage(&img);
		cvDestroyAllWindows();
		return true;
	}//end else
	return false;
}//end opencvProcess

  ImageConverter(): it_(nh_)
  {
    
    image_sub_ = it_.subscribe("/camera/rgb/image_raw", 1, &ImageConverter::imageCb, this);
    image_pub_ = it_.advertise("/image_converter/output_video", 1);
    
    cvNamedWindow( "Imagen Fuente");
    cvNamedWindow( "Imagen filtrada");
   
	// TrackBar
	cvCreateTrackbar("Hue Upper","Imagen filtrada",&hupper,360,NULL);
	cvCreateTrackbar("Hue Lower","Imagen filtrada",&hlower,360,NULL);
	//cvCreateButton("Save",ImageConverter::callbackButton,NULL,CV_PUSH_BUTTON,0);
 
  }

int main( int argc, char** argv )
{
    char* filename = argc == 2 ? argv[1] : (char*)"fruits.jpg";
    
    if( (image = cvLoadImage( filename, 1)) == 0 )
        return -1;

    // Create the output image
    cedge = cvCreateImage(cvSize(image->width,image->height), IPL_DEPTH_8U, 3);

    // Convert to grayscale
    gray = cvCreateImage(cvSize(image->width,image->height), IPL_DEPTH_8U, 1);
    edge = cvCreateImage(cvSize(image->width,image->height), IPL_DEPTH_8U, 1);
    cvCvtColor(image, gray, CV_BGR2GRAY);

    // Create a window
    cvNamedWindow(wndname, 1);

    // create a toolbar 
    cvCreateTrackbar(tbarname, wndname, &edge_thresh, 100, on_trackbar);

    // Show the image
    on_trackbar(0);

    // Wait for a key stroke; the same function arranges events processing
    cvWaitKey(0);
    cvReleaseImage(&image);
    cvReleaseImage(&gray);
    cvReleaseImage(&edge);
    cvDestroyWindow(wndname);

    return 0;
}

void COpenCVMFCView::OnThresholding1()
{
	// TODO: Add your command handler code here

	threImage  = cvCloneImage(workImg);
	cvFlip(threImage);
	threImage0 = cvCloneImage(threImage);

	cvNamedWindow(threWin, 0);
	cvResizeWindow(threWin, 300, 320);

	cvCreateTrackbar( "Thresh", threWin, &Threshold, 255, onThreChange );
	onThreChange(0);

	cvWaitKey(0);

	cvReleaseImage(&threImage);
	cvDestroyWindow(threWin);

	cvFlip(threImage0);
	m_dibFlag = imageReplace(threImage0,&workImg);

	m_ImageType = -1;
	Invalidate();
}

int main( int argc, char** argv )
{
    const char* filename = argc == 2 ? argv[1] : (char*)"stuff.jpg";

    // load image and force it to be grayscale
    if( (image03 = cvLoadImage(filename, 0)) == 0 )
        return -1;

    // Create the destination images
    image02 = cvCloneImage( image03 );
    image04 = cvCloneImage( image03 );

    // Create windows.
    cvNamedWindow("Source", 1);
    cvNamedWindow("Result", 1);

    // Show the image.
    cvShowImage("Source", image03);

    // Create toolbars. HighGUI use.
    cvCreateTrackbar( "Threshold", "Result", &slider_pos, 255, process_image );

    process_image(0);

    // Wait for a key stroke; the same function arranges events processing
    cvWaitKey(0);
    cvReleaseImage(&image02);
    cvReleaseImage(&image03);

    cvDestroyWindow("Source");
    cvDestroyWindow("Result");

    return 0;
}

int readVideoWithATrackbar(char *fileName)
{
	cvNamedWindow( "win_1", CV_WINDOW_AUTOSIZE );
	g_capture = cvCreateFileCapture( fileName );
	int frames = (int) cvGetCaptureProperty(
			g_capture,
			CV_CAP_PROP_FRAME_COUNT
			);
	if( frames != 0 ) {
		cvCreateTrackbar(
				"Position",
				"win_1",
				&g_slider_position,
				frames,
				onTrackbarSlide
				);
	}
	IplImage* frame;
	while (1) {
		frame = cvQueryFrame( g_capture );
		if ( !frame ) {
			break;
		}
		cvShowImage( "win_1", frame );
		char c = cvWaitKey(33);
		if ( c == 27 ) {
			break;
		}

	}
	return (0);
}

void AdaptiveHistogramCamshift::ShowControlsGUI()
{
  cvNamedWindow(m_controlsGUIWndName.c_str(), 1);
  cvNamedWindow("Trackbars", 1);
  if (!m_showControlsGUI)
  {
    cvMoveWindow(m_controlsGUIWndName.c_str(), m_frameSize.width + 10, 0);
    cvCreateTrackbar(ControlNames[ControlName_VMin], "Trackbars", &m_vMin, 256, 0);
    cvCreateTrackbar(ControlNames[ControlName_VMax], "Trackbars", &m_vMax, 256, 0);
    cvCreateTrackbar(ControlNames[ControlName_SMin], "Trackbars", &m_sMin, 256, 0);
    cvCreateTrackbar(ControlNames[ControlName_SBox], "Trackbars", &m_sBox, 64, 0);
    cvCreateTrackbar(ControlNames[ControlName_AgingFactor], "Trackbars", &m_ageRatio, 100, 0);
    cvSetMouseCallback(m_controlsGUIWndName.c_str(), &AdaptiveHistogramCamshift::OnMouse, &m_id);
  }
  m_showControlsGUI = true;
}