C++ cvInRangeS函数代码示例

IplImage* GetThresholdedImage(IplImage* img, int color) {
    // Convert the image into an HSV image
    IplImage* imgHSV = cvCreateImage(cvGetSize(img), 8, 3);
    cvCvtColor(img, imgHSV, CV_BGR2HSV);

    IplImage* imgThreshed = cvCreateImage(cvGetSize(img), 8, 1);
    if (color == 1)
        //    cvInRangeS(imgHSV, cvScalar(10, 100, 100), cvScalar(20, 255, 255), imgThreshed);- orange paper
        //    cvInRangeS(imgHSV, cvScalar(155, 100, 100), cvScalar(165, 255, 255), imgThreshed); - pink one
        //    cvInRangeS(imgHSV, cvScalar(80, 100, 100), cvScalar(90, 255, 255), imgThreshed); - green robot
        //    cvInRangeS(imgHSV, cvScalar(40, 100, 100), cvScalar(50, 255, 255), imgThreshed);  - green paper
        //    cvInRangeS(imgHSV, cvScalar(100, 100, 100), cvScalar(110, 255, 255), imgThreshed); - blue tape


        cvInRangeS(imgHSV, cvScalar(40, 100, 100), cvScalar(50, 255, 255),
                imgThreshed);

    if (color == 2)
        cvInRangeS(imgHSV, cvScalar(100, 100, 100), cvScalar(110, 255, 255),
                imgThreshed);

    if (color == 3)

        cvInRangeS(imgHSV, cvScalar(155, 100, 100), cvScalar(165, 255, 255),
                imgThreshed);

    if (color == 4)
        cvInRangeS(imgHSV, cvScalar(10, 100, 100), cvScalar(20, 255, 255),
                imgThreshed);

    cvReleaseImage(&imgHSV);

    return imgThreshed;
}

//영역 추출 후 이진화
void ColorTracking::color_config(IplImage* image, std::string config){
	
	//추출할 영역 변수
	CvScalar hsv_min, hsv_max, hsv_min2, hsv_max2;
	if(image != NULL)
	{
		IplImage* m_tem1_img = cvCreateImage(cvGetSize(image), IPL_DEPTH_8U, 1);//영역 추출 이미지
		IplImage* m_tem2_img = cvCreateImage(cvGetSize(image), IPL_DEPTH_8U, 1);//영역 추출 이미지
	
		//필요한 색상 영역 으로 축소
		if(config == "Red")
		{
			//빨강 - 영역 두개로 잡아봄
			hsv_min = cvScalar(0, 85, 100, 0);
			hsv_max = cvScalar(10, 255, 255, 0);

			hsv_min2 = cvScalar(170, 85, 100, 0);
			hsv_max2 = cvScalar(220, 255, 255, 0);

		}
		else if(config =="Green")
		{
			//초록
			hsv_min = cvScalar(55, 80, 100, 0);
			hsv_max = cvScalar(75, 255, 255, 0);
		}
		else if(config == "Blue")
		{
			//파랑
			hsv_min = cvScalar(100, 100,100 , 0);
			hsv_max = cvScalar(130, 255, 200, 0);
		}
		else if(config =="Yellow")
		{
			//노랑
			hsv_min = cvScalar(20, 100, 100, 0);
			hsv_max = cvScalar(35, 255, 255, 0);
		}
		
		if(config == "Red")
		{
			//일단 레드는 두 영역으로 잡아봄
			cvInRangeS(image, hsv_min, hsv_max, m_tem1_img);
			cvInRangeS(image, hsv_min2, hsv_max2, m_tem2_img);

			//공통영역 추출
			cvOr(m_tem1_img, m_tem2_img , m_gray_img);
			
		}	
		else
		{
			//레드가 아닐 때는 그대로
			cvInRangeS(image, hsv_min, hsv_max, m_gray_img);
		}

		cvReleaseImage(&m_tem1_img);
		cvReleaseImage(&m_tem2_img);
	}
}

/**
 * \brief	Takes frame and applies image processing techniques to filter out non-laser line points. Updates images used for runtime display.
 */
int filterFrame() {
	args[0] = frame;
	cvCvtColor(frame, frameHSV, CV_BGR2HSV);	//convert RGB values of frame to HSV and place in frameHSV
	cvSplit(frameHSV, hue, saturation, value, NULL);	//split frameHSV into constituent components and place appropriately; we are done with frameHSV
	args[1] = hue;
	args[2] = value;
	cvCopy(saturation, saturation2);	//make an additional copy of saturation for display
	//args[8] = saturation2;
	//cvShowImage("saturation", saturation2);
	cvSmooth(frame, frameHSV, CV_BLUR, 20, 20 );   //smooth frame and store in frameHSV
	//cvShowImage("Smoothed frame", frameHSV);
	cvSplit(frame, blue, green, red, NULL);	//split frame into its RGB components
	cvSplit(frameHSV, blue2, green2, red2, NULL);	//split the smoothed version into its RGB components
	cvMin(blue, green, min_bg);	//take the min of blue and green and store in min_bg
	args[3] = min_bg;
	//cvShowImage("minimum of blue and green", min_bg);
	cvSub(red, min_bg, red_last);	//take red less the min of the blue and green
	//cvShowImage("red_last = red - min_bg", red_last);
	cvThreshold(red_last, red_last, thresholdValue, 255, CV_THRESH_BINARY_INV);	//threshold the red_last
	//cvShowImage("threshold of red_last", red_last);
	args[4] = red_last;
	cvSub(red, red2, deltaRed);
	//cvShowImage("deltaRed = Original red - smooth red", deltaRed);
	cvThreshold(deltaRed, deltaRed, thresholdValue, 255, CV_THRESH_BINARY);
	//cvShowImage("threshold(deltaRed)", deltaRed);
	cvCopy(deltaRed, alpha);
	cvInRangeS(saturation, cvScalar(0), cvScalar(25), saturation);
	//cvShowImage("Low saturation in original frame", saturation);
	cvInRangeS(hue, cvScalar(49), cvScalar(125), beta);
	//cvShowImage("Mixed hue in original frame", beta);
	cvOr(beta, saturation, beta);
	//cvShowImage("beta = Low saturation OR mixed hue", beta);
	cvOr(beta, red_last, beta);
	//cvShowImage("beta = beta OR red_last", beta);
	//args[5] = alpha;
	args[5] = beta;

	IplConvKernel*mask= cvCreateStructuringElementEx(5, 5, 2, 2, 2, NULL );

	cvDilate(saturation2,dialated, mask, 20);
	//cvShowImage("dilate original saturation", dialated);
	args[6] = dialated;
	cvThreshold(dialated, dialated, 100, 255, CV_THRESH_BINARY);
	cvErode(dialated,eroded, mask, 30);

	args[7] = eroded;
	cvSub(alpha, beta, orig_filter);
	args[8] = orig_filter;
	cvAnd(orig_filter, eroded, zeta);
	args[9] = zeta;
	return 0;
}

int filterByHSV(IplImage *src, CvScalar minHSV, CvScalar maxHSV, IplImage *dst) {
	IplImage *tmp3d = cvCloneImage(src);
	cvSmooth(tmp3d, tmp3d, CV_GAUSSIAN, 13, 0, 0, 0);

	cvCvtColor(tmp3d, tmp3d, CV_BGR2HSV);
	IplImage *tmp1dH_mask = cvCreateImage(cvGetSize(src), IPL_DEPTH_8U, 1);
	IplImage *tmp1dS_mask = cvCreateImage(cvGetSize(src), IPL_DEPTH_8U, 1);
	IplImage *tmp1dV_mask = cvCreateImage(cvGetSize(src), IPL_DEPTH_8U, 1);
	cvSplit(tmp3d, tmp1dH_mask, tmp1dS_mask, tmp1dV_mask, NULL);

	//printf("\rmin: %03d,%03d,%03d", (int)minHSV.val[0], (int)minHSV.val[1], (int)minHSV.val[2]);
	//printf("\tmax: %03d,%03d,%03d", (int)maxHSV.val[0], (int)maxHSV.val[1], (int)maxHSV.val[2]);

	if (minHSV.val[0] < maxHSV.val[0]) {
		cvInRangeS(tmp1dH_mask, cvScalar(minHSV.val[0], 0, 0), cvScalar(maxHSV.val[0], 0, 0), tmp1dH_mask);
	} else {
		IplImage *tmp1d = cvCloneImage(tmp1dH_mask);
		cvInRangeS(tmp1dH_mask, cvScalar(0, 0, 0), cvScalar(maxHSV.val[0], 0, 0), tmp1d);
		cvInRangeS(tmp1dH_mask, cvScalar(minHSV.val[0], 0, 0), cvScalar(255, 0, 0), tmp1dH_mask);
		cvOr(tmp1d, tmp1dH_mask, tmp1dH_mask, NULL);
		cvReleaseImage(&tmp1d);
	}

	cvInRangeS(tmp1dS_mask, cvScalar(minHSV.val[1], 0, 0), cvScalar(maxHSV.val[1], 0, 0), tmp1dS_mask);
	cvInRangeS(tmp1dV_mask, cvScalar(minHSV.val[2], 0, 0), cvScalar(maxHSV.val[2], 0, 0), tmp1dV_mask);

	IplImage *tmp1d_mask = cvCreateImage(cvGetSize(src), IPL_DEPTH_8U, 1);
	cvSet(tmp1d_mask, cvScalarAll(255), NULL);
	cvAnd(tmp1d_mask, tmp1dH_mask, tmp1d_mask, NULL);
	cvAnd(tmp1d_mask, tmp1dS_mask, tmp1d_mask, NULL);
	cvAnd(tmp1d_mask, tmp1dV_mask, tmp1d_mask, NULL);

	cvReleaseImage(&tmp1dH_mask);
	cvReleaseImage(&tmp1dS_mask);
	cvReleaseImage(&tmp1dV_mask);

	cvClose(tmp1d_mask, tmp1d_mask, NULL, 2);

#define CONTROLS_WIDTHA  640/2
#define CONTROLS_HEIGHTA 480/2
#if 1
	cvNamedWindow(CONTROL_WINDOW  "4", 0);
	cvResizeWindow(CONTROL_WINDOW "4", CONTROLS_WIDTHA, CONTROLS_HEIGHTA);
	cvShowImage(CONTROL_WINDOW    "4", tmp1d_mask);
#endif

	cvCopy2(src, dst, tmp1d_mask);

	cvReleaseImage(&tmp1d_mask);

	return 0;
}

IplImage* getThresholdImage(IplImage* img)
{
  IplImage* imgHSV = cvCreateImage(cvGetSize(img), 8, 3);
	cvCvtColor(img, imgHSV, CV_BGR2HSV);  	//Convert image to HSV
	
	IplImage* thresholded = cvCreateImage(cvGetSize(img), 8, 1);
	
  if(minC.val[0] == NULL && maxC.val[0] == NULL){cvInRangeS(imgHSV, hsv_min, hsv_max, thresholded);}  
	else{cvInRangeS(imgHSV, minC, maxC, thresholded);}

	cvReleaseImage(&imgHSV);
	return thresholded;
}

//--------------------------------------------------------------
void ofApp::update(){
	ofBackground(0, 0, 0);

	
    bool bNewFrame = false;

	#ifdef _USE_LIVE_VIDEO
       vidGrabber.update();
	   bNewFrame = vidGrabber.isFrameNew();
    #else
        vidPlayer.update();
        bNewFrame = vidPlayer.isFrameNew();
	#endif

	if (bNewFrame){

		#ifdef _USE_LIVE_VIDEO
            cvColorImage.setFromPixels(vidGrabber.getPixels());
	    #else
            cvColorImage.setFromPixels(vidPlayer.getPixels());
        #endif

        hsvImage = cvColorImage;
        hsvImage.convertRgbToHsv();
		threshedImage.setFromColorImage(hsvImage);

		cvInRangeS(hsvImage.getCvImage(), cvScalar(targetHue-5, 70,70/*targetSat - 70, targetVal-30*/), cvScalar(targetHue + 5, 255, 255), threshedImage.getCvImage());
		//threshedImage.draw(2*IMG_X_OFFSET, 0);


		// find contours which are between the size of 20 pixels and 1/3 the w*h pixels.
		// also, find holes is set to true so we will get interior contours as well....
		contourFinder.findContours(threshedImage, 10, (width * height)/3, 10, true);	// find holes
	}
}

int convRGB(IplImage* srcRGB, IplImage* dstRGB, CvSize sizIm)
{
	// создаем Image 
	srcR = cvCreateImage( sizIm, IPL_DEPTH_8U, 1 );
	srcG = cvCreateImage( sizIm, IPL_DEPTH_8U, 1 );
	srcB = cvCreateImage( sizIm, IPL_DEPTH_8U, 1 );

	srcRR = cvCreateImage( sizIm, IPL_DEPTH_8U, 1 );
	
	// разбиваем на каналы
	cvSplit(srcRGB, srcB, srcG, srcR, 0);
		
	// выделяем для каждого канала границы
	cvInRangeS(srcR, cvScalar(aRmin), cvScalar(aRmax), srcRR);
	
	cvCopy( srcRR, dstRGB );

	// выводим в окне изображение
	cvShowImage("RGBVideo", srcRR);
	
	// освобождаем ресурсы
	cvReleaseImage( &srcR );
	cvReleaseImage( &srcG );
	cvReleaseImage( &srcB );
	cvReleaseImage( &srcRR );
	
	return 0;
}

IplImage* Panoramic::GetHsvFeature(IplImage* src,int H,int S,int V,int Scale ,int Scale_1 ,int Scale_2)
{
	IplImage *colorImg	  = cvCreateImage(cvGetSize(src),8,3);
    IplImage *hsvImg	  = cvCreateImage(cvGetSize(src),8,3);
	cvCopy(src,colorImg);
	IplImage *Plane_1	  = cvCreateImage( cvGetSize(colorImg), 8, 1);//H plane
    IplImage *Plane_2	  = cvCreateImage( cvGetSize(colorImg), 8, 1);//S plane
	IplImage *Plane_3	  = cvCreateImage( cvGetSize(colorImg), 8, 1);//V plane
	IplImage *dst	      = cvCreateImage( cvGetSize(src),8,1);
	cvCvtColor(colorImg,hsvImg,CV_BGR2HSV);
	cvCvtPixToPlane( hsvImg, Plane_1, Plane_2, Plane_3, 0 );

	cvEqualizeHist(Plane_2,Plane_2);//s_plane
	cvEqualizeHist(Plane_3,Plane_3);//v_plane
	cvMerge(Plane_1,Plane_2,Plane_3,0,hsvImg);
	cvInRangeS(hsvImg, cvScalar(H,S, V), cvScalar(5*Scale+H,5*Scale_1+S,5*Scale_2+V), dst);//cvScalar(0,40, 40), cvScalar(60, 170, 255)
	cvErode(dst,dst,0,2);

	/*cvNamedWindow("HSV_ROI",0);
	cvShowImage ("HSV_ROI",dst);*/

	cvReleaseImage(&colorImg);
	cvReleaseImage(&hsvImg);
	cvReleaseImage(&Plane_1);
	cvReleaseImage(&Plane_2);
	cvReleaseImage(&Plane_3);

	return dst;
}

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);
}

// calibration function to be run at the beginning only
vector<double> calibrate(){
	
	cvSmooth(frame, imageFiltree, CV_BLUR,seuilFiltre,seuilFiltre,0.0,0.0);
	cvCvtColor(imageFiltree, imageHSV,CV_BGR2HSV);
	cvInRangeS(imageHSV,cvScalar(hmin, smin, vmin, 0.0),cvScalar(hmax, smax, vmax, 0.0),imageBinaire);
	cvErode(imageBinaire, imageErodee, NULL, nbErosions);
	cvDilate(imageErodee, imageDilatee, NULL, nbDilatations);
	
	imageObjectRGB = multBinColor(imageDilatee, frame);
	imageObjectHSV = multBinColor(imageDilatee, imageHSV);
	
	vector<vector<CvPoint3D32f> > vecDistinctPoints = findPoint();
	
	// find the centroid of the object and trace it
	vector<CvPoint> centroid = centroiding(vecDistinctPoints);
	sort(centroid);
	
	vector<double> tanAlphaT = vector<double>(centroid.size(),0);
	double p;
	
	for (int i=0; i<centroid.size(); i++){
		p = abs(centroid[i].x - (frame->width / 2));
		tanAlphaT[i] = atan(d/D-p*ratioPixelSizeF);
	}
	return tanAlphaT;
}

void filter_and_threshold(struct ctx *ctx)
{

	/* Soften image */
	cvSmooth(ctx->image, ctx->temp_image3, CV_GAUSSIAN, 11, 11, 0, 0);
	/* Remove some impulsive noise */
	cvSmooth(ctx->temp_image3, ctx->temp_image3, CV_MEDIAN, 11, 11, 0, 0);
	cvCvtColor(ctx->temp_image3, ctx->temp_image3, CV_BGR2HSV);

	/*
	 * Apply threshold on HSV values to detect skin color
	 */
/*	cvInRangeS(ctx->temp_image3,
		   cvScalar(0, 55, 90, 255), // cvScalar( (b), (g), (r), 0 )
		   cvScalar(28, 175, 230, 255),
		   ctx->thr_image);
*/
	cvInRangeS(ctx->temp_image3,
		   cvScalar(100, 200, 200, 0), // cvScalar( (b), (g), (r), 0 )
		   cvScalar(200, 220, 255, 0),
		   ctx->thr_image);


	/* Apply morphological opening */
	cvMorphologyEx(ctx->thr_image, ctx->thr_image, NULL, ctx->kernel,
		       CV_MOP_OPEN, 1);  // 2 interations of opening
	cvSmooth(ctx->thr_image, ctx->thr_image, CV_GAUSSIAN, 3, 3, 0, 0);
}

IplImage* CamShiftPatch::getInRangeMask(CvScalar maskRange, IplImage* &hue)
{
	IplImage *mask = 0;
	mask = cvCreateImage(cvGetSize(originImage), 8, 1);//遮罩空間，單通道

	IplImage *hsv = 0;
	hue = cvCreateImage(cvGetSize(originImage), 8, 1); //1 channel
	hsv = cvCreateImage(cvGetSize(originImage), 8, 3);
	cvCvtColor(originImage, hsv, CV_BGR2HSV); //彩色空間轉換BGR to HSV 


	//cvShowImage("hsv", hsv);
	cvInRangeS(//cvInRangeS 功能為 => 檢查數組元素是否在兩個數量之間
		hsv, //第一個原數組
		cvScalar(0, maskRange.val[2], MIN(maskRange.val[0], maskRange.val[1]), 0),  //包括進的下邊界
		cvScalar(180, 256, MAX(maskRange.val[0], maskRange.val[1]), 0), //不包括進的上邊界
		mask);
	//得到二值的MASK  
	cvSplit(hsv, hue, 0, 0, 0); //只提取HUE分量  
	
	//cvShowImage("mask", mask);

	IplImage* returnImg = nullptr;
	returnImg = cvCloneImage(mask);

	cvReleaseImage(&mask);
	cvReleaseImage(&hsv);

	return returnImg;
}

IplImage* threshImage(IplImage *imgOrig, CvScalar lower, CvScalar upper, int n)
{
	IplImage* imgHSV = cvCreateImage(cvGetSize(imgOrig), 8, 3);   //size, depth, channels
	cvCvtColor(imgOrig, imgHSV, CV_BGR2HSV);   //check!

	IplImage* imgThresh = cvCreateImage(cvGetSize(imgOrig), 8, 1);
	cvInRangeS(imgHSV, lower, upper, imgThresh);

	
	CvMoments *moments = (CvMoments*)malloc(sizeof(CvMoments));
	cvMoments (imgThresh, moments, 1);

	double moment10 = cvGetSpatialMoment(moments, 1, 0);
	double moment01 = cvGetSpatialMoment(moments, 0, 1);
	double area = cvGetSpatialMoment(moments, 0, 0);

	static int posX = 0;
	static int posY = 0;


	posX = moment10/area;
	posY = moment01/area;

	int curX = posX * XRATIO;
	int curY = posY * YRATIO;

	SetCursorPos(1366-curX, curY);

	delete moments;
	cvReleaseImage(&imgHSV);

	return imgThresh;
}

CamShift::Box CamShift::Track(const ImgBgr& img)
{
	cvCopy(ImgIplImage(img), image, 0 );
  cvCvtColor( image, hsv, CV_BGR2HSV );
  cvFlip(hsv,hsv,0);
  int _vmin = vmin, _vmax = vmax;
  
  cvInRangeS( hsv, cvScalar(0,smin,MIN(_vmin,_vmax),0),
  cvScalar(180,256,MAX(_vmin,_vmax),0), mask );
  cvSplit( hsv, hue, 0, 0, 0 );
  cvCalcBackProject( &hue, backproject, hist );
  //cvSaveImage("backproject.bmp", backproject);
  cvAnd( backproject, mask, backproject, 0 );
  //cvSaveImage("backproject.bmp", backproject);
  cvCamShift( backproject, track_window,
    cvTermCriteria( CV_TERMCRIT_EPS | CV_TERMCRIT_ITER, 10, 1 ),
    &track_comp, &track_box );
  track_window = track_comp.rect;

  Box result;
  result.angle= track_box.angle;
  result.center.x= static_cast<LONG>( track_box.center.x );
  result.center.y= static_cast<LONG>( img.Height()-track_box.center.y-1 );
  result.size.cy = static_cast<LONG>( track_box.size.width );
  result.size.cx = static_cast<LONG>( track_box.size.height );
  return result;
}

//Filtra una imagen dada según determinado rango de color en formato HSV, devuelve una imagen en blanco y negro 
IplImage* filterByColorHSV(IplImage *img, CvScalar min, CvScalar max){

	cvNamedWindow("filtro");

	double dWidth = cvGetSize(img).width;
    double dHeight = cvGetSize(img).height;
	IplImage *hsvframe=cvCreateImage(cvSize(dWidth,dHeight),8,3);//Image in HSV color space
	IplImage *threshy=cvCreateImage(cvSize(dWidth,dHeight),8,1); //Threshold image of defined color
	
	//smooth the original image using Gaussian kernel
	cvSmooth(img, img, CV_MEDIAN,7,7);  //----------------> el kernel es el método que se usa para remover ruido, habría que ver cual es el mejor para
										  //				  lo que queremos. Aca están las opciones: http://docs.opencv.org/modules/imgproc/doc/filtering.html
	//Changing the color space from BGR to HSV
	cvCvtColor(img,hsvframe,CV_BGR2HSV);
	//Thresholding the frame for the color given
	cvInRangeS(hsvframe,min, max,threshy);
	//smooth the thresholded image using Median kernel
    cvSmooth(threshy,threshy,CV_MEDIAN,7,7);
	
	cvShowImage("filtro",threshy);
	
	return threshy;
	cvReleaseImage(&threshy);
	cvReleaseImage(&hsvframe);
}