C++ cvDestroyAllWindows函数代码示例

void mouseHandler(int event, int x, int y, int flags, void* param)
{	 
	if(event == CV_EVENT_LBUTTONDOWN) //If left click
	{
		int** input = param;
		
		*input[0] = x; //Get the current coordinates
		*input[1] = y;
		cvDestroyAllWindows(); //And close the window
	}
}

/*-----------------------------------------------------------
  Name     : CloseLRFShow
  Argument : int id (LRF ID)
  Return   : 0 (success) other(failed) 
  About    : Free IplImage & Windows for LRFShow 
  Version  : Ver 1.0
  Date     : 2014/05/25
  Author   : Ryodo Tanaka (Kyushu Institute of Technology)
------------------------------------------------------------*/
void CloseLRFShow(const int id)
{
  int i;

  cvDestroyAllWindows();
  if(id == LRF_ALL_ID)
    for(i=0; i<NUM_OF_LRF; i++)
      cvReleaseImage(&img[i]);
  else  
    cvReleaseImage(&img[id]);
}

void nymph_imhide(std::string window_name)
{
    if (window_name == "")
    {
        cvDestroyAllWindows();
    }
    else
    {
        cvDestroyWindow(window_name.data());
    }
}

void ctrlC_handler(const boost::system::error_code& error, int signal_number){
	if (error){
		std::cerr<<"signalHandler() :"<<error.message();
		return;
	}

	if(signal_number == SIGTERM) std::cout<<"Recvd SIGTERM, exiting...";
	if(signal_number == SIGINT) std::cout<<"Recvd SIGINT, exiting...";
	cvDestroyAllWindows();
	cvReleaseCapture(&capture);
	exit(0);
}

int main()
{
	
	TT_Initialize(); //setup TT cameras
	printf("Opening Calibration: %s\n", 
		TT_LoadCalibration("CalibrationResult 2010-11-02 5.03pm.cal") == NPRESULT_SUCCESS ?
		"PASS" : "ERROR");
	int cameraCount = TT_CameraCount();
	CameraData_t cameras[MAX_NUM_CAMERAS];
	pthread_t threads[MAX_NUM_CAMERAS]; 
	
	assert(MAX_NUM_CAMERAS == cameraCount);

	TT_SetCameraSettings(0, NPVIDEOTYPE_PRECISION,300, 150, 15);
	TT_SetCameraSettings(1, NPVIDEOTYPE_PRECISION,300, 150, 15);
	TT_SetCameraSettings(2, NPVIDEOTYPE_PRECISION,300, 150, 15);
	/* 1. Change camera settings ^
	   2. Allocate space for the displays 
	*/
	for(int i = 0; i < cameraCount; i++){
		cameras[i].i = i;
		cameras[i].displayImage = cvCreateImage(cvSize(W,H), IPL_DEPTH_8U, 1);
	}

	/* call the threads for display of camera data */
	
	pthread_mutex_init(&keyMutex, NULL);

	for(int i = 0; i < cameraCount; i++){
		if(pthread_create(&threads[i], NULL, showCameraWindow, (void*)&cameras[i])){
			printf("\aThread couldn't be created!");
			TT_Shutdown();
			TT_FinalCleanup();
			exit(0);
		}
	}
	
	printf("Press any Key to Exit!\n"); 
	while(!_kbhit()){
		int result = TT_Update();
		if(result != NPRESULT_SUCCESS)
			Sleep(70UL); //wait for updated frame 1/sleeptime[ms] = frame-rate
	}

	for(int i = 0; i < cameraCount; i++)
		pthread_join(threads[i], NULL);
	
	pthread_mutex_destroy(&keyMutex);
	cvDestroyAllWindows();
	TT_Shutdown();
	TT_FinalCleanup();
	return 0;
}

int main(int argc, char* argv[])
{
  CvSize size = cvSize(640,480);
  CvCapture* capture = cvCaptureFromCAM(0);
  if(!capture)
    {
      fprintf(stderr, "Error in opening the Camera.\n");
      exit(1);
    }
  cvSetCaptureProperty(capture, CV_CAP_PROP_FRAME_WIDTH, 640);
  cvSetCaptureProperty(capture, CV_CAP_PROP_FRAME_HEIGHT, 480);
  
  cvNamedWindow("Camera", CV_WINDOW_AUTOSIZE);
  cvNamedWindow("HSV", CV_WINDOW_AUTOSIZE);
  cvNamedWindow("Hue", CV_WINDOW_AUTOSIZE);
  cvNamedWindow("Saturation", CV_WINDOW_AUTOSIZE);
  cvNamedWindow("Value", CV_WINDOW_AUTOSIZE);

  IplImage* frame = cvQueryFrame(capture);
  if(!frame)
    exit(1);
  IplImage* hsv = cvCreateImage(size, IPL_DEPTH_8U, 3);
  IplImage* hue = cvCreateImage(size, IPL_DEPTH_8U, 1);
  IplImage* saturation = cvCreateImage(size, IPL_DEPTH_8U, 1);
  IplImage* value = cvCreateImage(size, IPL_DEPTH_8U, 1);

  while(1)
    {
      frame = cvQueryFrame(capture);
      if(!frame)
	{
	  fprintf(stderr, "Failed to capture an Image.\n");
	  break;
	}
      cvCvtColor(frame, hsv, CV_BGR2HSV);
      cvSplit(hsv, hue, saturation, value, 0);
      cvSmooth(hue, hue, CV_GAUSSIAN,9,9,0,0);
      cvSmooth(saturation, saturation, CV_GAUSSIAN,9,9,0,0);
      cvShowImage("Camera", frame);
      cvShowImage("HSV", hsv);
      cvShowImage("Hue", hue);
      cvShowImage("Saturation", saturation);
      cvShowImage("Value", value);

      char c=cvWaitKey(33);
      if(c == 27)
	break;
    }
  cvDestroyAllWindows();
  cvReleaseCapture(&capture);
  cvReleaseImage(&frame);
  cvReleaseImage(&hsv);
}

int main()
{
    CvCapture* capture = cvCreateCameraCapture(1);
    if(!capture)
    {
        printf("Camera error.\n");
        return -1;
    }

    // set camera property
    cvSetCaptureProperty(capture, CV_CAP_PROP_FRAME_WIDTH, FRAMEWIDTH);
    cvSetCaptureProperty(capture, CV_CAP_PROP_FRAME_HEIGHT, FRAMEHEIGHT);

    IplImage* frame = cvQueryFrame(capture);
    IplImage* frame_prior = cvCreateImage(
        cvGetSize(frame), frame->depth, frame->nChannels);
    IplImage * diff12 = cvCreateImage(
        cvGetSize(frame), frame->depth, frame->nChannels);

    if(!frame)
    {
        return -1;
    }

    cvCopy(frame, frame_prior);
    char c;
    char file_name[128];
    int count_frame = 0;
    while( 1 ) 
    { 
        frame = cvQueryFrame(capture);
        if(!frame)
        {
            return -1;
        }

        cvAbsDiff(frame, frame_prior, diff12);
        cvCopy(frame, frame_prior);
        sprintf(file_name, "%sframe_%d.bmp", SAVEIMGDIR, count_frame++ );
       cvSaveImage(file_name, frame);
        printf("%d: %s\n", count_frame, file_name);

        cvShowImage("diff", diff12);
        c = cvWaitKey(50);
        if(c == 27)
        {
            break;
        }
    }

    cvDestroyAllWindows();
    cvReleaseImage(&frame);
}

void MoveHandler::disconnect()
{
	logger->LogEvent("Disconnecting controller.");
	
	cvDestroyAllWindows();
	this->frame = nullptr;
	for(int i = 0; i < this->connections; i++)
	{
		psmove_disconnect(this->controllers[i]);
	}
	psmove_tracker_free(this->tracker);
}

int main()
{
    IplImage* src = cvLoadImage("src.png", CV_LOAD_IMAGE_UNCHANGED);

    // c:0 0 1 9
    IplImage* gaussian_one_nine = cvCreateImage(        
        cvGetSize(src), src->depth, src->nChannels );
    // d:0 0 9 1
    IplImage* gaussian_nine_one = cvCreateImage( 
        cvGetSize(src), src->depth, src->nChannels );
    // e:0 0 1 9 --> 0 0 9 1
    IplImage* gaussian_twice = cvCreateImage( 
        cvGetSize(src), src->depth, src->nChannels );
    // f:
    IplImage* gaussian_fpart = cvCreateImage( 
        cvGetSize(src), src->depth, src->nChannels );


    printf("0 0 1 9\n");
    cvSmooth(src, gaussian_one_nine, CV_GAUSSIAN, 0, 0, 1, 9);
    printf("\n0 0 9 1\n");
    cvSmooth(src, gaussian_nine_one, CV_GAUSSIAN, 0, 0, 9, 1);
    printf("\n0 0 1 9 --> 0 0 9 1\n");
    // 7 55 1 9
    cvSmooth(src, gaussian_twice, CV_GAUSSIAN, 0, 0, 1, 9);
    // 55 7 9 1
    cvSmooth(gaussian_twice, gaussian_twice, CV_GAUSSIAN, 0, 0, 9, 1);

    // 55 55 9 9
    cvSmooth(src, gaussian_fpart, CV_GAUSSIAN, 0, 0, 9, 9);
    
    //cvSmooth(gaussian_fpart, gaussian_fpart, CV_GAUSSIAN, 9, 9, 0, 0);
    
    double dMSE = 0, dPSNR = 0;
    calculateGrayImgsPSNR(gaussian_twice, gaussian_fpart, dMSE, dPSNR);
    printf("MSE: %f\tPSNR: %f\n", dMSE, dPSNR);

    cvShowImage("src", src);
    cvShowImage("one_nine", gaussian_one_nine);
    cvSaveImage( "0019.png", gaussian_one_nine );
    cvShowImage("nine_one", gaussian_nine_one);
    cvSaveImage("0091.png", gaussian_nine_one);
    cvShowImage("twice", gaussian_twice);
    cvSaveImage("twice.png", gaussian_twice);
    cvShowImage("fpart", gaussian_fpart);
    cvSaveImage( "fpart.png", gaussian_fpart );
    cvWaitKey(0);

    cvDestroyAllWindows();
    cvReleaseImage(&src);
    return 0;
}

void the_project::project_clear()
{
	cout << "Finished...\n";
	cvDestroyAllWindows();
	//cvReleaseImage(&get_in);
	cvReleaseImage(&get_change);
	cvReleaseImage(&get_binary);
	cvReleaseImage(&get_path);
	cvReleaseVideoWriter(&wr1);
	cvReleaseVideoWriter(&wr2);
	cvReleaseCapture(&for_video);
	cvReleaseCapture(&for_cam);
}

int _tmain(int argc, _TCHAR* argv[])
{
	CCharRecognition myCC;

#ifdef TrainML
		for(int i=1;i<214;i++)
#else
		for(int i=1; i<=121; i++)	
#endif
	{
		// 产生文件名
		char fn[1024];
#ifdef TrainML
		sprintf(fn, ".//sample//b (%d).jpg", i);
#else
		sprintf(fn, ".//train//T (%d).jpg", i);
		
#endif
		// 读取图片
		IplImage* gray = cvLoadImage(fn);//, CV_LOAD_IMAGE_GRAYSCALE);
		IplImage* gray2 = cvLoadImage(fn);//, CV_LOAD_IMAGE_GRAYSCALE);
		
		cvShowImage("1", gray2);
		cvWaitKey(10);

#ifdef TrainML
		myCC.GetSamples(gray);
#else
		string ss=myCC.RecogniteCharImage(gray);
		std::cout<<ss<<std::endl;
#endif

		char ch=cvWaitKey(0);
		#ifndef TrainML
			static int right=0;
			static int sum=0;
			if(ch=='a')
				right++;
			sum++;
			std::cout<<'\t'<<right<<'\\'<<sum;
		#endif

		std::cout<<std::endl;

		cvReleaseImage(&gray);
		cvReleaseImage(&gray2);
	}
	cvDestroyAllWindows();
	system("pause");
	return 0;
}

void test_yolo(char *cfgfile, char *weightfile, char *filename, float thresh)
{

    network net = parse_network_cfg(cfgfile);
    if(weightfile){
        load_weights(&net, weightfile);
    }
    detection_layer l = net.layers[net.n-1];
    set_batch_network(&net, 1);
    srand(2222222);
    clock_t time;
    char buff[256];
    char *input = buff;
    int j;
    float nms=.5;
    box *boxes = calloc(l.side*l.side*l.n, sizeof(box));
    float **probs = calloc(l.side*l.side*l.n, sizeof(float *));
    for(j = 0; j < l.side*l.side*l.n; ++j) probs[j] = calloc(l.classes, sizeof(float *));
    while(1){
        if(filename){
            strncpy(input, filename, 256);
        } else {
            printf("Enter Image Path: ");
            fflush(stdout);
            input = fgets(input, 256, stdin);
            if(!input) return;
            strtok(input, "\n");
        }
        image im = load_image_color(input,0,0);
        image sized = resize_image(im, net.w, net.h);
        float *X = sized.data;
        time=clock();
        float *predictions = network_predict(net, X);
        printf("%s: Predicted in %f seconds.\n", input, sec(clock()-time));
        convert_yolo_detections(predictions, l.classes, l.n, l.sqrt, l.side, 1, 1, thresh, probs, boxes, 0);
        if (nms) do_nms_sort(boxes, probs, l.side*l.side*l.n, l.classes, nms);
        //draw_detections(im, l.side*l.side*l.n, thresh, boxes, probs, voc_names, voc_labels, 20);
        draw_detections(im, l.side*l.side*l.n, thresh, boxes, probs, voc_names, 0, 20);
        show_image(im, "predictions");
        save_image(im, "predictions");

        show_image(sized, "resized");
        free_image(im);
        free_image(sized);
#ifdef OPENCV
        cvWaitKey(0);
        cvDestroyAllWindows();
#endif
        if (filename) break;
    }
}

void viewImage(IplImage* img)
{
	if (img->depth == IPL_DEPTH_16U)
	{
		cvConvertImage(img,showImage);
		cvShowImage("Image", showImage);
	}
	else
	{
		cvShowImage("Image",img);
	}
	cvWaitKey();
	cvDestroyAllWindows();
}

int main(int argc, char* argv[])
{
    cvNamedWindow("Original",CV_WINDOW_AUTOSIZE);
    cvNamedWindow("Binaria",CV_WINDOW_AUTOSIZE);
    cvNamedWindow("Histograma",CV_WINDOW_AUTOSIZE);
    imatge = cvLoadImage("C:\\EUPMT\\Projects\\OpenCV_Contours\\exemple03.jpg", 0);
    IplImage* binaria = cvCreateImage(cvGetSize(imatge), 8, 1);
    imgHistogram = 0;


    int hsize[] = {bins};
    float max_value = 0, min_value = 0;
    float xranges[] = { 0, 256 };
    float* ranges[] = { xranges };

    hist = cvCreateHist( 1, hsize, CV_HIST_ARRAY, ranges,1);
    cvCalcHist( &imatge, hist, 0, NULL);
    cvGetMinMaxHistValue( hist, &min_value, &max_value);

    dibuixarHistograma(max_value);


    int llindar = llindar_gaussian(imatge, hist);

    int step =imatge->widthStep;
    int canals = imatge->nChannels;
    uchar* imgData = (uchar*) imatge->imageData;
    uchar* imgDataBinaria = (uchar*) binaria->imageData;

    for( int i = 0; i < imatge->height; i++)
        for( int j = 0; j < imatge->width; j++)
        {
            if((imgData[i*step+j*canals]) > llindar)
            {
                imgDataBinaria[i*binaria->widthStep+j*binaria->nChannels]=0;
            }
            else
            {
                imgDataBinaria[i*binaria->widthStep+j*binaria->nChannels]=255;
            }
        }


    cvShowImage("Original", imatge);
    cvShowImage("Histograma", imgHistogram);
    cvShowImage("Binaria", binaria);
    cvWaitKey(0);
    cvDestroyAllWindows();
    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