C++ cvCreateHist函数代码示例

KMeans::KMeans(int anumOfCores,int anumOfSamples,int anumOfBins)
{
	int i;

	this->numOfCores= anumOfCores; 
	this->numOfSamples=anumOfSamples;
	this->numOfBins=anumOfBins;
	this->itemNum=new int [this->numOfCores];
	this->componentLength = 3*this->numOfBins;
	this->planeB=this->planeG=this->planeR=NULL;
	this->cores = new float * [this->numOfCores];
	this->old_cores = new float * [this->numOfCores];
	for(i=0;i<this->numOfCores;i++)
	{
		this->cores[i] = new float[this->componentLength];		
		this->old_cores[i] = new float[this->componentLength];
		for(int j=0;j<this->componentLength;j++)
		{
			this->cores[i][j]=-2;
			this->old_cores[i][j]=-2;
		}
	}

	if(this->numOfSamples)
	{
		this->candyset = new float * [this->numOfSamples];
		for(i=0;i<this->numOfSamples;i++) this->candyset[i] = new float[this->componentLength];
	}
	else this->candyset=NULL;

	this->imagehist=new float[this->componentLength];	

	this->rangesR = new float * [1];
	this->rangesR[0] = new float[2];
	this->rangesR[0][0]=0;this->rangesR[0][1]=255;

	this->rangesG = new float * [1];
	this->rangesG[0] = new float[2];
	this->rangesG[0][0]=0;this->rangesG[0][1]=255;

	this->rangesB = new float * [1];
	this->rangesB[0] = new float[2];
	this->rangesB[0][0]=0;this->rangesB[0][1]=255;

	this->histR = cvCreateHist(1,&this->numOfBins,CV_HIST_ARRAY,rangesR,1);
    this->histG = cvCreateHist(1,&this->numOfBins,CV_HIST_ARRAY,rangesG,1);
    this->histB = cvCreateHist(1,&this->numOfBins,CV_HIST_ARRAY,rangesB,1);
	 
	this->sorted = new vector<KMeansTriple *> [this->numOfCores];
	this->index=0;
}

void AdaptiveHistogramCamshift::Init(const CvSize& frameSize,
                                     const InitParams& initParams)
{
  // Get frame size
  m_frameSize = frameSize;

  // Load init params.
  m_histDims = initParams.histDims;
  m_vMin = initParams.vMin;
  m_vMax = initParams.vMax;
  m_sMin = initParams.sMin;
  m_sBox = initParams.sBox;
  m_histRanges[0] = initParams.histRanges[0] * 0.5f;
  m_histRanges[1] = initParams.histRanges[1] * 0.5f;

  // Create histograms
  float* histRanges[2] = { &m_histRanges[0], &m_histRanges[1] };
  m_hist = cvCreateHist(1, &m_histDims, CV_HIST_ARRAY, histRanges, 1);
  m_histSubdiv = cvCreateHist(1, &m_histDims, CV_HIST_ARRAY, histRanges, 1);
  m_histTrackWnd = cvCreateHist(1, &m_histDims, CV_HIST_ARRAY, histRanges, 1);

  // Create images
  m_imgHue = cvCreateImage(m_frameSize, 8, 1);
  m_imgMask = cvCreateImage(m_frameSize, 8, 1);
  m_imgHSV = cvCreateImage(m_frameSize, 8, 3);
  m_imgBackproject = cvCreateImage(m_frameSize, 8, 1);
  cvZero(m_imgBackproject);

  // Create histogram image
  m_histImg = cvCreateImage( m_frameSize, 8, 3 );
  cvZero( m_histImg );

  // Show controlsGUI, backproject, histogram
  if (initParams.showControlsGUI)
  {
    ShowControlsGUI();
  }
  if (initParams.showBackproject)
  {
    ShowBackproject();
  }
  if (initParams.showHistogram)
  {
    ShowHistogram();
  }

  // Set initialized flag
  m_initialized = true;
}

double pghMatchShapes(CvSeq *shape1, CvSeq *shape2) {
	int dims[] = {8, 8};
	float range[] = {-180, 180, -100, 100};
	float *ranges[] = {&range[0], &range[2]};
    CvHistogram* hist1 = cvCreateHist(2, dims, CV_HIST_ARRAY, ranges, 1);
    CvHistogram* hist2 = cvCreateHist(2, dims, CV_HIST_ARRAY, ranges, 1);
	cvCalcPGH(shape1, hist1);
    cvCalcPGH(shape2, hist2);
	cvNormalizeHist(hist1, 100.0f);
	cvNormalizeHist(hist2, 100.0f);
    double corr = cvCompareHist(hist1, hist2, CV_COMP_BHATTACHARYYA);
    cvReleaseHist(&hist1);
    cvReleaseHist(&hist2);
	return corr;
}

Histogram* Histogram::createHSHistogram(const Image* image, const Mask* mask, int sizeH, int sizeS)
{
    Histogram* hist = new Histogram();
    IplImage* hsv = cvCreateImage(image->size(), 8, 3);	//Create HSV image from BGR image
    cvCvtColor(image->cvImage(), hsv, CV_BGR2HSV);
	
    IplImage* h = cvCreateImage(image->size(), 8, 1);	// create diferents planes
    IplImage* s = cvCreateImage(image->size(), 8, 1);
    IplImage* v = cvCreateImage(image->size(), 8, 1);
	
    IplImage* planes[] = {h, s};
	
    cvCvtPixToPlane(hsv, h, s, v, NULL);
	
    int histSize[] = {sizeH, sizeS};
    float hRanges[] = { 0, 180 }; /* hue varies from 0 (~0°red) to 180 (~360°red again) */
    float sRanges[] = { 0, 255 }; /* saturation varies from 0 (black-gray-white) to 255 (pure spectrum color) */
    float* ranges[] = {hRanges, sRanges};
	
    hist->m_histogram = cvCreateHist(2, histSize, CV_HIST_ARRAY, ranges, 1);
    cvCalcHist(planes, hist->m_histogram, false, mask ? mask->cvImage() : NULL);

    cvReleaseImage(&hsv);
    cvReleaseImage(&h);
    cvReleaseImage(&s);
    cvReleaseImage(&v);
    return hist;
}

//default values h_bins=30,s_bins=32,scale=10
CvHistogram * Histogram::getHShistogramFromRGB(IplImage* src){
	IplImage* h_plane = cvCreateImage( cvGetSize(src), 8, 1 );
	IplImage* s_plane = cvCreateImage( cvGetSize(src), 8, 1 );
	IplImage* v_plane = cvCreateImage( cvGetSize(src), 8, 1 );
	IplImage* planes[] = { h_plane, s_plane };
	IplImage* hsv = cvCreateImage( cvGetSize(src), 8, 3 );
	
	int hist_size[] = {this->h_bins, this->s_bins};
	float h_ranges[] = { 0, 180 }; /* hue varies from 0 (~0°red) to 180 (~360°red again) */
	float s_ranges[] = { 0, 255 }; /* saturation varies from 0 (black-gray-white) to 255 (pure spectrum color) */
	float* ranges[] = { h_ranges, s_ranges };
	
	CvHistogram* hist;

	
	cvCvtColor( src, hsv, CV_BGR2HSV );
	cvCvtPixToPlane( hsv, h_plane, s_plane, v_plane, 0 );
	hist = cvCreateHist( 2, hist_size, CV_HIST_ARRAY, ranges, 1 );
	cvCalcHist( planes, hist, 0, 0 );
	cvNormalizeHist(hist,1.0);
	
	cvReleaseImage(&hsv);
	cvReleaseImage(&h_plane);
	cvReleaseImage(&s_plane);
	cvReleaseImage(&v_plane);
	
	
	return hist;
	
}

CamShift::CamShift(const ImgBgr& img)
{
  
  hist = NULL;
  hue = NULL;
  hdims = 16;
  hsv = NULL;
  backproject = NULL;
  histimg = NULL;
  mask = NULL;
  
  float hranges_arr[] = {0,180};
  float* hranges = hranges_arr;
  ImgIplImage frame(img);
  image = cvCreateImage( cvGetSize(frame), 8, 3 );
  image->origin = ((IplImage*) frame)->origin;
  hsv = cvCreateImage( cvGetSize(frame), 8, 3 );
  hue = cvCreateImage( cvGetSize(frame), 8, 1 );
  mask = cvCreateImage( cvGetSize(frame), 8, 1 );
  backproject = cvCreateImage( cvGetSize(frame), 8, 1 );
  hist = cvCreateHist( 1, &hdims, CV_HIST_ARRAY, &hranges, 1 );
  histimg = cvCreateImage( cvSize(320,200), 8, 3 );
  cvZero( histimg );
  //cvReleaseImage( &frame );
  vmin = 10; vmax = 256; smin = 30;

}

Tracker::Tracker(const IplImage * pImg)
{
	// Parameters
	nHistBins = 30;                 // number of histogram bins
	rangesArr[0]= 0;          // histogram range
	rangesArr[1] = 180;
	vmin = 65;
	vmax = 256;
	smin = 55; // limits for calculating hue


	// File-level variables
	pHSVImg  = 0; // the input image converted to HSV color mode
	pHueImg  = 0; // the Hue channel of the HSV image
	pMask    = 0; // this image is used for masking pixels
	pProbImg = 0; // the face probability estimates for each pixel
	pHist = 0; // histogram of hue in the original face image


	nFrames = 0;
	// Allocate the main data structures ahead of time
	float * pRanges = rangesArr;
	pHSVImg  = cvCreateImage( cvGetSize(pImg), 8, 3 );
	pHueImg  = cvCreateImage( cvGetSize(pImg), 8, 1 );
	pMask    = cvCreateImage( cvGetSize(pImg), 8, 1 );
	pProbImg = cvCreateImage( cvGetSize(pImg), 8, 1 );

	pHist = cvCreateHist( 1, &nHistBins, CV_HIST_ARRAY, &pRanges, 1 );
}

	int LocalisationPupil::estimateThreshold(IplImage *im){
		IplImage* im2 = cvCloneImage(im);
		
		// supprimer les bruits
		cvSmooth( im2, im2, CV_GAUSSIAN,3 ,3);
		
		int bins = 50;
		int index_min,index_max;
		int hsize[] = {bins};
		float max_value = 0, min_value = 0;
		//ranges - grayscale 0 to 50
		float xranges[] = { 0, 50 };
		float* ranges[] = { xranges };
		CvHistogram* hist = cvCreateHist( 1, hsize, CV_HIST_ARRAY, ranges,1);
		cvCalcHist( &im2, hist, 0, NULL);
		cvGetMinMaxHistValue( hist, &min_value, &max_value,&index_min,&index_max);
		
		int thresh;
		
		thresh = index_max+10;
		
		cvReleaseImage( &im2);
		
		return thresh;
	}

CvAdaptiveSkinDetector::Histogram::Histogram()
{
    int histogramSize[] = { HistogramSize };
    float range[] = { GSD_HUE_LT, GSD_HUE_UT };
    float *ranges[] = { range };
    fHistogram = cvCreateHist(1, histogramSize, CV_HIST_ARRAY, ranges, 1);
    cvClearHist(fHistogram);
};

static UNUSED IplImage*
test_find_edges_hist(IplImage *im)
{
  int w = im->width;
  int h = im->height;
  CvSize small_size = {w / 8, h / 8};
  CvPoint middle = {w/2, h/2};

  IplImage *small = cvCreateImage(small_size, IPL_DEPTH_8U, 1); /*for quicker histogram */
  IplImage *mask = cvCreateImage(cvGetSize(im), IPL_DEPTH_8U, 1);
  IplImage *green = cvCreateImage(cvGetSize(im), IPL_DEPTH_8U, 1);
  cvSplit(im, NULL, green, NULL, NULL);

  cvResize(green, small, CV_INTER_NN);
  //small = green;

  int hist_size[] = {255};
  float range[] = {0, 255};
  float *ranges[] = {range};
  CvHistogram* hist = cvCreateHist(1, hist_size, CV_HIST_ARRAY, ranges, 1);
  cvCalcHist(&small, hist, 0, NULL);

  int pixels = small->width * small->height;
  int min_black = pixels / 8;
  int max_black = pixels / 2;
  int totals[256] = {0};

  int best_d = pixels + 1;
  int best_t = 0;

  int total = 0;
  for (int i = 0; i < 255; i++){
    int v = (int)cvQueryHistValue_1D(hist, i + 2);
    total += v;
    totals[i] = total;
    if (total > min_black){
      if (i > 5){
        int diff = totals[i] - totals[i - 5];
        if (diff < best_d){
          best_d = diff;
          best_t = i;
        }
        if (total >= max_black){
          break;
        }
      }
    }
  }
  best_t -= 2;
  printf("found best threshold %d -- %d pixel change at %d/%d pixels\n",
      best_t, best_d, totals[best_t], pixels);

  cvCmpS(green, best_t, mask, CV_CMP_GT);
  IplImage *mask2 = cvCreateImage(cvGetSize(im), IPL_DEPTH_8U, 1);
  memset(mask2->imageData, 255, w*h);
  floodfill_mono_superfast(mask, mask2, middle);
  return mask2;
}

HandDetect::HandDetect()
{
	numColorBins = 256;
	max_val = 0.f;
	hand1 = cvLoadImage("hand.png");
	hand2 = cvLoadImage("hand2.png");
	hist1 = cvCreateHist(1, &numColorBins, CV_HIST_ARRAY);
	hist2 = cvCreateHist(1, &numColorBins, CV_HIST_ARRAY);
	
	rad=0;
	vmin=10, vmax=256, smin=30;

	capture = cvCaptureFromCAM(0);
	setImage();
	backproject = cvCreateImage(cvGetSize(image), 8, 1);
	gray = cvCreateImage(cvGetSize(image), 8, 1);
	track_window = cvRect((int)image->width/2, (int)image->height/2, 1, 1);
	track_box.center.x=-1;
	track_box.center.y=-1;

	hsvHand1 = cvCreateImage(cvGetSize(hand1), 8, 3);
	mskHand1 = cvCreateImage(cvGetSize(hand1), 8, 1);
	hueHand1 = cvCreateImage(cvGetSize(hand1), 8, 1);

	hsvHand2 = cvCreateImage(cvGetSize(hand2), 8, 3);
	mskHand2 = cvCreateImage(cvGetSize(hand2), 8, 1);
	hueHand2 = cvCreateImage(cvGetSize(hand2), 8, 1);	

	cvCvtColor(hand1, hsvHand1, CV_RGB2HSV);
	cvInRangeS(hsvHand1, cvScalar(0, smin, MIN(vmin, vmax), 0), cvScalar(180, 256, MAX(vmin, vmax), 0), mskHand1);
	cvSplit(hsvHand1, hueHand1, 0, 0, 0);

	cvCalcHist(&hueHand1, hist1, 0, mskHand1);
	cvGetMinMaxHistValue(hist1, 0, &max_val, 0, 0);
	cvConvertScale(hist1->bins, hist1->bins, max_val ? 255. / max_val : 0., 0);


	cvCvtColor(hand2, hsvHand2, CV_RGB2HSV);
	cvInRangeS(hsvHand2, cvScalar(0, smin, MIN(vmin, vmax), 0), cvScalar(180, 256, MAX(vmin, vmax), 0), mskHand2);
	cvSplit(hsvHand2, hueHand2, 0, 0, 0);

	cvCalcHist(&hueHand2, hist2, 0, mskHand2);
	cvGetMinMaxHistValue(hist2, 0, &max_val, 0, 0);
	cvConvertScale(hist2->bins, hist2->bins, max_val ? 255. / max_val : 0., 0);
}

int main() {
	while(true) {
		int hist_size[] = {40};
		float range[] = {0.0f,255.0f};
		float* ranges[] = {range};
		CvHistogram* hist = cvCreateHist(1, hist_size, CV_HIST_ARRAY, ranges, 1);
		cvReleaseHist(&hist);
	}
}

Histogram::Histogram(int dims,
                     int* sizes,
                     float** ranges,
                     int type,
                     Histogram* histToAcomul)
        : m_histogram(histToAcomul ? histToAcomul->m_histogram : NULL)
{
        m_histogram = cvCreateHist(dims, sizes, type, ranges, histToAcomul ? 0 : 1);
}

CvHistogram* create_histogram(IplImage* plane, int range, int* bins)
{
	
	float ranges[] = { 0, range };
	float* temp_range[] = { ranges };
	CvHistogram* hist = cvCreateHist( 1, bins, CV_HIST_ARRAY, temp_range, 1 );
	cvCalcHist(&plane, hist, 0, 0 ); // Compute histogram
	return hist;
}

CvHistogram *make_hist(IplImage *img)
{
    int numBins = 256;
    float range[] = {0, 255};
    float *ranges[] = { range };
    CvHistogram *hist = cvCreateHist(1, &numBins, CV_HIST_ARRAY, ranges, 1);
    cvCalcHist(&img, hist, 0, 0);
    return hist;
}