void FeatureVectorBuilder::createProjectionHistogram(cv::Mat& projection, cv::Mat& output, int outSize, int type) {

	if (type == 0) {
		cv::Mat histImage(outSize, projection.cols, CV_8UC1, cv::Scalar(0, 0, 0));
		cv::normalize(projection, projection, 0, outSize, cv::NORM_MINMAX, -1, cv::Mat());

		for (int i = 1; i < projection.cols; i++) {
			float val = projection.at<float>(0, i);
			cv::circle(histImage, cv::Point(i, val), 1, cv::Scalar(255, 255, 255), 1, 1, 0);
		}
		cv::flip(histImage, histImage, 0);
		histImage.copyTo(output);
	}

	if (type == 1) {
		cv::Mat histImage(projection.rows, outSize, CV_8UC1, cv::Scalar(0, 0, 0));
		cv::normalize(projection, projection, 0, outSize, cv::NORM_MINMAX, -1, cv::Mat());

		for (int i = 1; i < projection.rows; i++) {
			float val = projection.at<float>(i, 0);

			cv::circle(histImage, cv::Point(val, i), 1, cv::Scalar(255, 255, 255), 1, 1, 0);
		}
		histImage.copyTo(output);
	}
}
Esempio n. 2
0
void draw_histogram(cv::Mat &img, std::string image_name="../ImagesForStudents/out_hist.png"){
  
  int histSize = 255;
  float range[] = {0,256};
  const float* histRange = {range};
  bool uniform = true; bool accumulate = false;
  cv::Mat hist = cv::Mat::zeros(512,400,CV_8UC1);
  calcHist( &img, 1, 0, cv::Mat(), hist, 1, &histSize, &histRange, uniform, accumulate );
  
  int hist_w = 512; int hist_h = 400;
  int bin_w = cvRound( (double) hist_w/histSize );
  
  cv::Mat histImage( hist_h, hist_w, CV_8UC1,cv::Scalar(255));
  
  cv::normalize(hist, hist, 0, histImage.rows, cv::NORM_MINMAX, -1, cv::Mat() );
  
  /// Draw for each channel
  for( int i = 1; i < histSize; i++ )
  {
	line( histImage, cv::Point( bin_w*(i-1), hist_h - cvRound(hist.at<float>(i-1)) ) ,
		  cv::Point( bin_w*(i), hist_h - cvRound(hist.at<float>(i)) ),
		  cv::Scalar( 0, 0, 0), 2, 8, 0  );
  }
  
  cv::imwrite(image_name,histImage);
  
}
Esempio n. 3
0
void
	 CImageAnalysis::Histogram()
{
	Mat mat = imread( "F:\\4点定位剪切图.bmp",CV_LOAD_IMAGE_ANYDEPTH|CV_LOAD_IMAGE_ANYCOLOR );
	Mat src,src1,src2;
	Mat hist;
	int histSize = 255;
	float range[] = { 0, 255 } ;
	const float* histRange = { range };
	bool uniform = true; 
	bool accumulate = false;
	calcHist( &src1, 1, 0, Mat(), hist, 1, &histSize, &histRange, uniform, accumulate );
	int hist_w = 400; int hist_h = 400;
	int bin_w = cvRound( (double) hist_w/histSize );

	Mat histImage( hist_w, hist_h, CV_8UC3, Scalar( 255,255,255) );
	normalize(hist, hist, 0, histImage.rows, NORM_MINMAX, -1, Mat() );
	for( int i = 1; i < histSize; i++ )
	{
		line( histImage, Point( bin_w*(i-1), hist_h - cvRound(hist.at<float>(i-1)) ) ,
			Point( bin_w*(i), hist_h - cvRound(hist.at<float>(i)) ),
			Scalar( 0, 0, 255), 2, 8, 0  );
	}
	namedWindow("calcHist Demo", CV_WINDOW_AUTOSIZE );
	imshow("calcHist Demo", histImage );
}
Esempio n. 4
0
void ReliabilityHistogram::displayHistogram( cv::Mat histogram)
{
    int hist_w = 512; int hist_h = 400;
    int bin_w = cvRound( (double) hist_w/numBins );

    cv::Mat histNorm, histImage( hist_h, hist_w, CV_8UC3, cv::Scalar( 0,0,0) );


    if(histNorm.data == NULL)
      cv::normalize(histogram, histNorm, 0, histImage.rows, cv::NORM_MINMAX, -1, cv::Mat() );


    for( int i = 1; i < this->numBins; i++ )
    {
        cv::line( histImage, cv::Point( bin_w*(i-1), hist_h - cvRound(histNorm.at<float>(i-1)) ) ,
                         cv::Point( bin_w*(i), hist_h - cvRound(histNorm.at<float>(i)) ),
                         cv::Scalar( 0, 255, 0), 2, 8, 0  );
    }

#ifdef __OPENCV3__
    cv::namedWindow("Reliability Histogram", cv::WINDOW_AUTOSIZE );
#else
    cv::namedWindow("Reliability Histogram", CV_WINDOW_AUTOSIZE );
#endif
    cv::imshow("Reliability Histogram", histImage );
}
Esempio n. 5
0
Mat Histogram::drawHist(MatND _histMat)
{

    if(_histMat.channels()>1)
        cvError(1,__FUNCTION__,"Only for 1D histograms",__FILE__,__LINE__);

   int w = 400; int h = 400;
   Mat histImage( h, w, CV_8UC3, Scalar( 0,0,0) );
   Mat i2;
   cv::normalize(_histMat,i2,0,255,CV_MINMAX);


   for( int i = 0; i < _histSize[0]; i++ )
    {
       int bin_w = cvRound( (double) w/_histSize[0]);
       rectangle( histImage, Point( i*bin_w, h ), Point( (i+1)*bin_w, h - cvRound( i2.at<float>(i)*h/255.0 ) ), Scalar( 0, 0, 255 ), -1 );
        /*line( histImage, Point( bin_w*(i-1), hist_h - cvRound(1*i2.at<float>(i-1)) ) ,
                         Point( bin_w*(i), hist_h - cvRound(1*i2.at<float>(i)) ),
                         Scalar( 255, 0, 0), 2, 8, 0  );
        /*line( histImage, Point( bin_w*(i-1), hist_h - cvRound(g_hist.at<float>(i-1)) ) ,
                         Point( bin_w*(i), hist_h - cvRound(g_hist.at<float>(i)) ),
                         Scalar( 0, 255, 0), 2, 8, 0  );
        line( histImage, Point( bin_w*(i-1), hist_h - cvRound(r_hist.at<float>(i-1)) ) ,
                         Point( bin_w*(i), hist_h - cvRound(r_hist.at<float>(i)) ),
                         Scalar( 0, 0, 255), 2, 8, 0  );*/
    }

   return histImage;
}
Esempio n. 6
0
//直方图函数
void histGram(Mat hist)
{
	//1直方图属性
	int histSize = 255;
	float range[] = { 0, 255 };
	const float* histRange = { range };

	//2计算直方图
	bool uniform = true, accumulate = false;
	Mat g_hist;
	calcHist(&hist, 1, 0, Mat(), g_hist, 1, &histSize, &histRange, uniform, accumulate);

	//--------------------了解Hist的内部结构????????????????????????
	/*namedWindow("g_hist",CV_WINDOW_NORMAL);
	imshow("g_hist", g_hist);*/

	//3创建画布
	int hist_w = 400;
	int hist_h = 400;
	int bin_w = cvRound((double)hist_w / histSize);
	Mat histImage(hist_w, hist_h, CV_8UC3, Scalar::all(0));

	//4归一化直方图到定义的窗口
	normalize(g_hist, g_hist, 0, histImage.rows, NORM_MINMAX, -1, Mat());

	//5在直方图上画布上画出直方图
	for (int i = 1; i < histSize; i++)
	{
		line(histImage, Point(bin_w*(i - 1), hist_h - cvRound(g_hist.at<float>(i - 1))),
			Point(bin_w*(i), hist_h - cvRound(g_hist.at<float>(i))), Scalar(0, 0, 250), 2, 8, 0);
	}
	//6显示直方图
	namedWindow("calcHist");
	imshow("calcHist", histImage);
}
Esempio n. 7
0
cv::Mat histogram(cv::Mat image,cv::Mat mask)
{
    int rangeMax=256;
    int histSize = rangeMax;
  float range[] = { 0, rangeMax } ;
  const float* histRange = { range };
  bool uniform = true;
  bool accumulate = false;
  cv::Mat hist;

  cv::calcHist( &image, 1, 0, mask, hist, 1, &histSize, &histRange, uniform, accumulate );

  //Draw the histogram
  int hist_w = 512; int hist_h = 400;
  int bin_w = cvRound( (double) hist_w/histSize );
  cv::Mat histImage( hist_h, hist_w, CV_8UC3, cv::Scalar( 0,0,0) );

  normalize(hist, hist, 0, histImage.rows, cv::NORM_MINMAX, -1, cv::Mat() );

  for( int i = 1; i < histSize; i++ )
  {
      cv::line( histImage, cv::Point( bin_w*(i-1), hist_h - cvRound(hist.at<float>(i-1)) ) , cv::Point( bin_w*(i), hist_h - cvRound(hist.at<float>(i)) ), cv::Scalar( 255, 0, 255), 2, 8, 0  );
  }

    return histImage;
}
void PlayFieldDetectionModule::showHistogram( cv::Mat histogram, char windowName[])
{
    int hist_w = 512; int hist_h = 400;
    int bin_w = cvRound( (double) hist_w/numBins );

    cv::Mat histNorm, histImage( hist_h, hist_w, CV_8UC3, cv::Scalar( 0,0,0) );

    if(histNorm.data == NULL)
      cv::normalize(histogram, histNorm, 0, histImage.rows, cv::NORM_MINMAX, -1, cv::Mat() );


    for( int i = 1; i < histogram.rows; i++ )
    {
        cv::line( histImage, cv::Point( bin_w*(i-1), hist_h - cvRound(histNorm.at<float>(i-1)) ) ,
                         cv::Point( bin_w*(i), hist_h - cvRound(histNorm.at<float>(i)) ),
                         cv::Scalar( 0, 255, 0), 2, 8, 0  );
    }

#ifdef __OPENCV3__
    cv::namedWindow(windowName, cv::WINDOW_AUTOSIZE );
#else
    cv::namedWindow(windowName, CV_WINDOW_AUTOSIZE );
#endif
    cv::imshow(windowName, histImage );
}
Esempio n. 9
0
/**
 *  Returns a 255 by 100 QImage containing a Histogram for the given channel.
 *  The background is transparent (Alpha 0, RGB=255) */
QImage Histogram::getImage(Channel channel = LChannel, QBrush pen = Qt::gray)
{
    // Create blank QImage and fill it with transparent background:
    QImage histImage(255, 100, QImage::Format_ARGB32);
    histImage.fill(0);
    QPainter painter(&histImage);
    painter.setBrush(Qt::transparent); 
    painter.setPen(Qt::transparent);
    painter.drawRect(0,0,255,100);

    // Calculate the aspect ratio using the maximal value of the color histograms
    int maximum = (channel == LChannel ? maximumValue(LChannel) :  maximumValue(RGB));
    float ratio = 100.0/float(maximum);

    // Preparing the painter:
    painter.setBrush(pen);
    painter.setPen(pen.color());

    int h;
    // Draw histogram
    QHash<int, int>* hist = get(channel);
    QHash<int, int>::const_iterator cit = hist->begin();

    while (cit != hist->end())
    {
        h = 100 - floor(ratio*cit.value());
        painter.drawLine(cit.key(), h, cit.key(), 100);
        ++cit;
    }

    return histImage;
}
void showHist(Mat src)
{
	Mat  hsv_src,dst;

	if( !src.data )
		cout<<"The image data is null!"<<endl;

	/// 分割成3个单通道图像 ( R, G 和 B )
	vector<Mat> hsv_planes;
	cvtColor(src,hsv_src,CV_BGR2HSV);
	split( hsv_src, hsv_planes );

	/// 设定bin数目
	int histSize = 255;

	/// 设定取值范围 ( R,G,B) )
	float range[] = { 0, 255 } ;
	const float* histRange = { range };

	bool uniform = true; bool accumulate = false;

	Mat h_hist, s_hist, v_hist;

	/// 计算直方图:
	calcHist( &hsv_planes[0], 1, 0, Mat(), h_hist, 1, &histSize, &histRange, uniform, accumulate );
	calcHist( &hsv_planes[1], 1, 0, Mat(), s_hist, 1, &histSize, &histRange, uniform, accumulate );
	calcHist( &hsv_planes[2], 1, 0, Mat(), v_hist, 1, &histSize, &histRange, uniform, accumulate );

	// 创建直方图画布
	int hist_w = 400; int hist_h = 400;
	int bin_w = cvRound( (double) hist_w/histSize );

	Mat histImage( hist_w, hist_h, CV_8UC3, Scalar( 0,0,0) );

	/// 将直方图归一化到范围 [ 0, histImage.rows ]
	normalize(h_hist, h_hist, 0, histImage.rows, NORM_MINMAX, -1, Mat() );
	normalize(s_hist, s_hist, 0, histImage.rows, NORM_MINMAX, -1, Mat() );
	normalize(v_hist, v_hist, 0, histImage.rows, NORM_MINMAX, -1, Mat() );

	/// 在直方图画布上画出直方图
	for( int i = 1; i < histSize; i++ )
	{
		line( histImage, Point( bin_w*(i-1), hist_h - cvRound(h_hist.at<float>(i-1)) ) ,
			Point( bin_w*(i), hist_h - cvRound(h_hist.at<float>(i)) ),
			Scalar( 0, 0, 255), 2, 8, 0  );
		line( histImage, Point( bin_w*(i-1), hist_h - cvRound(s_hist.at<float>(i-1)) ) ,
			Point( bin_w*(i), hist_h - cvRound(s_hist.at<float>(i)) ),
			Scalar( 0, 255, 0), 2, 8, 0  );
		line( histImage, Point( bin_w*(i-1), hist_h - cvRound(v_hist.at<float>(i-1)) ) ,
			Point( bin_w*(i), hist_h - cvRound(v_hist.at<float>(i)) ),
			Scalar( 255, 0, 0), 2, 8, 0  );
	}

	/// 显示直方图
	namedWindow("calcHist Demo", CV_WINDOW_AUTOSIZE );
	imshow("calcHist Demo", histImage );

	waitKey(5);

}
Esempio n. 11
0
/** ###############################################################################
 * @Draw histogram
 * Takes in triple vector of values e.g. std::vector<Mat> bgrPixels(3);
 */
int visionUtils::drawHist(std::vector<Mat> pixelPlanes, int histBlurPixels)//( int, char** argv )
{
    /// Establish the number of bins
    int histSize = 256;

    /// Set the ranges ( for B,G,R) )
    float range[] = { 0, 256 } ;
    const float* histRange = { range };

    bool uniform = true;
    bool accumulate = false;

    Mat b_hist, g_hist, r_hist;

    /// Compute the histograms:
    calcHist( &pixelPlanes[0], 1, 0, Mat(), b_hist, 1, &histSize, &histRange, uniform, accumulate );
    calcHist( &pixelPlanes[1], 1, 0, Mat(), g_hist, 1, &histSize, &histRange, uniform, accumulate );
    calcHist( &pixelPlanes[2], 1, 0, Mat(), r_hist, 1, &histSize, &histRange, uniform, accumulate );

    // Draw the histograms for B, G and R or H S V
    int hist_w = 512;
    int hist_h = 400;
    int bin_w = cvRound( (double) hist_w/histSize );

    Mat histImage( hist_h, hist_w, CV_8UC3, Scalar( 0,0,0) );
    // Smooth hists if needed
    if (histBlurPixels>0)
    {
        GaussianBlur(b_hist, b_hist, Size(1,histBlurPixels), 1, 1);
        GaussianBlur(g_hist, g_hist, Size(1,histBlurPixels), 1, 1);
        GaussianBlur(r_hist, r_hist, Size(1,histBlurPixels), 1, 1);
    }

    /// Normalize the result to [ 0, histImage.rows ]
    cv::normalize(b_hist, b_hist, 0, histImage.rows, NORM_MINMAX, -1, Mat() );
    cv::normalize(g_hist, g_hist, 0, histImage.rows, NORM_MINMAX, -1, Mat() );
    cv::normalize(r_hist, r_hist, 0, histImage.rows, NORM_MINMAX, -1, Mat() );

    /// Draw for each channel
    for( int i = 1; i < histSize; i++ )
    {
        line( histImage, Point( bin_w*(i-1), hist_h - cvRound(b_hist.at<float>(i-1)) ) ,
              Point( bin_w*(i), hist_h - cvRound(b_hist.at<float>(i)) ),
              Scalar( 255, 0, 0), 2, 8, 0  );
        line( histImage, Point( bin_w*(i-1), hist_h - cvRound(g_hist.at<float>(i-1)) ) ,
              Point( bin_w*(i), hist_h - cvRound(g_hist.at<float>(i)) ),
              Scalar( 0, 255, 0), 2, 8, 0  );
        line( histImage, Point( bin_w*(i-1), hist_h - cvRound(r_hist.at<float>(i-1)) ) ,
              Point( bin_w*(i), hist_h - cvRound(r_hist.at<float>(i)) ),
              Scalar( 0, 0, 255), 2, 8, 0  );
    }

    /// Display
    namedWindow("calcHist Demo", WINDOW_AUTOSIZE );
    imshow("calcHist Demo", histImage );
    waitKey(1);
    return 0;
}
Esempio n. 12
0
void RGBLineChartThread::run()
{
	Mat frame;
	Mat b_hist,g_hist,r_hist;
	std::vector<Mat> bgr_planes;
	
	int histSize = 256;
	float range[] = {0,256};
	const float* histRange = {range};
	bool uniform = true;
	bool accumulate = false;

	int hist_w = 512;
	int hist_h = 400;
	int bin_w = cvRound((double)hist_w / histSize);
	Mat histImage(hist_h , hist_w , CV_8UC3 , Scalar(0,0,0));
	Mat MergedImage;

	if( !cap.isOpened() )
		return;

	while(true)
	{
		cap >> frame;
		split(frame , bgr_planes);
		histImage = Mat::zeros(hist_h , hist_w , CV_8UC3);

		cv::calcHist(&bgr_planes[0],1,0,Mat(),b_hist,1,&histSize,&histRange,uniform,accumulate);
		cv::calcHist(&bgr_planes[1],1,0,Mat(),g_hist,1,&histSize,&histRange,uniform,accumulate);
		cv::calcHist(&bgr_planes[2],1,0,Mat(),r_hist,1,&histSize,&histRange,uniform,accumulate);

		cv::normalize(b_hist,b_hist,0,histImage.rows,NORM_MINMAX,-1,Mat());
		cv::normalize(g_hist,g_hist,0,histImage.rows,NORM_MINMAX,-1,Mat());
		cv::normalize(r_hist,r_hist,0,histImage.rows,NORM_MINMAX,-1,Mat());

		for(int i=1; i<histSize; i++)
		{
			cv::line(histImage,Point(bin_w*(i-1) , hist_h - cvRound(b_hist.at<float>(i - 1)) ),Point(bin_w*i , hist_h - cvRound(b_hist.at<float>(i)) ),Scalar(255,0,0),2,8,0);
			cv::line(histImage,Point(bin_w*(i-1) , hist_h - cvRound(g_hist.at<float>(i - 1)) ),Point(bin_w*i , hist_h - cvRound(g_hist.at<float>(i))),Scalar(0,255,0),2,8,0);
			cv::line(histImage,Point(bin_w*(i-1) , hist_h - cvRound(r_hist.at<float>(i - 1)) ),Point(bin_w*i , hist_h - cvRound(r_hist.at<float>(i))),Scalar(0,0,255),2,8,0);
		}
		merge(bgr_planes,frame);

		resize(frame,frame,cv::Size(histImage.cols,histImage.rows));
		int totalCols = histImage.cols + frame.cols;
		MergedImage.create(histImage.rows, totalCols,histImage.type());
		Mat subImage = MergedImage.colRange(0,histImage.cols);
		histImage.copyTo(subImage);
		subImage = MergedImage.colRange(histImage.cols , totalCols);
		frame.copyTo(subImage);

		emit NewLineChart(&MergedImage);

		bgr_planes.clear();
		waitKey(30);
	}
	return;
}
int main( int argc, char* argv[] )
{
    if( argc != 2 )
    {
        std::cerr << "Usage: " << argv[0] << " <InputImage>" << std::endl;
        return EXIT_FAILURE;
    }


    cv::Mat image = cv::imread( argv[1],1);
    if(!image.data)
    {
        return EXIT_FAILURE;
    }

    std::vector<cv::Mat> bgr_planes;
    cv::split( image, bgr_planes );

    int histSize = 256;
    float range[] = { 0, 256 } ;
    const float* histRange = { range };
    bool uniform = true;
    bool accumulate = false;
    cv::Mat b_hist, g_hist, r_hist;

    cv::calcHist( &bgr_planes[0], 1, 0, cv::Mat(), b_hist, 1, &histSize, &histRange, uniform, accumulate );
    cv::calcHist( &bgr_planes[1], 1, 0, cv::Mat(), g_hist, 1, &histSize, &histRange, uniform, accumulate );
    cv::calcHist( &bgr_planes[2], 1, 0, cv::Mat(), r_hist, 1, &histSize, &histRange, uniform, accumulate );

    //Draw the histograms
    int hist_w = 512;
    int hist_h = 400;
    int bin_w = cvRound( (double) hist_w/histSize );
    cv::Mat histImage( hist_h, hist_w, CV_8UC3, cv::Scalar( 0,0,0) );

    normalize(b_hist, b_hist, 0, histImage.rows, cv::NORM_MINMAX, -1, cv::Mat() );
    normalize(g_hist, g_hist, 0, histImage.rows, cv::NORM_MINMAX, -1, cv::Mat() );
    normalize(r_hist, r_hist, 0, histImage.rows, cv::NORM_MINMAX, -1, cv::Mat() );

    for( int i = 1; i < histSize; i++ )
    {
        cv::line( histImage, cv::Point( bin_w*(i-1), hist_h - cvRound(b_hist.at<float>(i-1)) ) , cv::Point( bin_w*(i), hist_h - cvRound(b_hist.at<float>(i)) ), cv::Scalar( 255, 0, 0), 2, 8, 0  );
        cv::line( histImage, cv::Point( bin_w*(i-1), hist_h - cvRound(g_hist.at<float>(i-1)) ) , cv::Point( bin_w*(i), hist_h - cvRound(g_hist.at<float>(i)) ), cv::Scalar( 0, 255, 0), 2, 8, 0  );
        cv::line( histImage, cv::Point( bin_w*(i-1), hist_h - cvRound(r_hist.at<float>(i-1)) ) , cv::Point( bin_w*(i), hist_h - cvRound(r_hist.at<float>(i)) ), cv::Scalar( 0, 0, 255), 2, 8, 0  );
    }

    //Display histogram
    cv::namedWindow( argv[1], CV_WINDOW_AUTOSIZE );
    cv::imshow( argv[1], histImage );

    cv::waitKey(0);

    return EXIT_SUCCESS;
}
Esempio n. 14
0
void caclBGRHist()
{
	Mat src = imread("C:\\Users\\Administrator\\Desktop\\lena.jpg");	//Load image
	Mat dst;

	if( !src.data ) exit(0);

	// Separate the image in 3 places ( B, G and R )
	vector<Mat> bgr_planes;
	split( src, bgr_planes );

	int histSize = 256; // Establish the number of bins
	float range[] = { 0, 256 }; /// Set the ranges ( for B,G,R) )
	const float* histRange = { range };

	bool uniform = true; 
	bool accumulate = false;
	Mat b_hist, g_hist, r_hist;

	// Compute the histograms:
	calcHist( &bgr_planes[0], 1, 0, Mat(), b_hist, 1, &histSize, &histRange, uniform, accumulate );
	calcHist( &bgr_planes[1], 1, 0, Mat(), g_hist, 1, &histSize, &histRange, uniform, accumulate );
	calcHist( &bgr_planes[2], 1, 0, Mat(), r_hist, 1, &histSize, &histRange, uniform, accumulate );

	// Draw the histograms for B, G and R
	int hist_w = 600; int hist_h = 400;
	int bin_w = cvRound( (double) hist_w/histSize );

	Mat histImage( hist_h, hist_w, CV_8UC3, Scalar( 0,0,0) );

	// Normalize the result to [ 0, histImage.rows ]
	normalize(b_hist, b_hist, 0, histImage.rows, NORM_MINMAX, -1, Mat() );
	normalize(g_hist, g_hist, 0, histImage.rows, NORM_MINMAX, -1, Mat() );
	normalize(r_hist, r_hist, 0, histImage.rows, NORM_MINMAX, -1, Mat() );

	// Draw for each channel
	for( int i = 1; i < histSize; i++ ){
		line( histImage, Point( bin_w*(i-1), hist_h - cvRound(b_hist.at<float>(i-1)) ) ,
			Point( bin_w*(i), hist_h - cvRound(b_hist.at<float>(i)) ),
			Scalar( 255, 0, 0), 2, 8, 0  );
		line( histImage, Point( bin_w*(i-1), hist_h - cvRound(g_hist.at<float>(i-1)) ) ,
			Point( bin_w*(i), hist_h - cvRound(g_hist.at<float>(i)) ),
			Scalar( 0, 255, 0), 2, 8, 0  );
		line( histImage, Point( bin_w*(i-1), hist_h - cvRound(r_hist.at<float>(i-1)) ) ,
			Point( bin_w*(i), hist_h - cvRound(r_hist.at<float>(i)) ),
			Scalar( 0, 0, 255), 2, 8, 0  );
	}

	namedWindow("calcHist", CV_WINDOW_AUTOSIZE );
	imshow("calcHist", histImage );
	waitKey(0);

}
Esempio n. 15
0
cv::Mat channelHistogram(cv::Mat image,cv::Mat mask,int minRange, int maxRange, int maxRange2)
{

    std::vector<cv::Mat> channels;
    cv::split( image, channels );

    int histSize = maxRange-minRange;
    float range[] = { minRange, maxRange } ;
    const float* histRange = { range };
    bool uniform = true;
    bool accumulate = false;
    cv::Mat b_hist, g_hist, r_hist;
    if (maxRange2!=0)
    {
        int histSize2 = maxRange2-minRange;
        float range2[] = { minRange, maxRange2 } ;
        const float* histRange2 = { range2 };
        cv::calcHist( &channels[0], 1, 0, mask, b_hist, 1, &histSize2, &histRange2, uniform, accumulate );
    }
    else
    {
        cv::calcHist( &channels[0], 1, 0, mask, b_hist, 1, &histSize, &histRange, uniform, accumulate );
    }
    cv::calcHist( &channels[1], 1, 0, mask, g_hist, 1, &histSize, &histRange, uniform, accumulate );
    cv::calcHist( &channels[2], 1, 0, mask, r_hist, 1, &histSize, &histRange, uniform, accumulate );

    //Draw the histograms
    int hist_w = 512; int hist_h = 400;
    int bin_w = cvRound( (double) hist_w/histSize );
    cv::Mat histImage( hist_h, hist_w, CV_8UC3, cv::Scalar( 0,0,0) );

    normalize(b_hist, b_hist, 0, histImage.rows, cv::NORM_MINMAX, -1, cv::Mat() );
    normalize(g_hist, g_hist, 0, histImage.rows, cv::NORM_MINMAX, -1, cv::Mat() );
    normalize(r_hist, r_hist, 0, histImage.rows, cv::NORM_MINMAX, -1, cv::Mat() );

    for( int i = 1; i < histSize; i++ )
    {
        if(i<(maxRange2-minRange))
        {
            cv::line( histImage, cv::Point( bin_w*(i-1), hist_h - cvRound(b_hist.at<float>(i-1)) ) , cv::Point( bin_w*(i), hist_h - cvRound(b_hist.at<float>(i)) ), cv::Scalar( 255, 0, 0), 2, 8, 0  );
        }
        cv::line( histImage, cv::Point( bin_w*(i-1), hist_h - cvRound(g_hist.at<float>(i-1)) ) , cv::Point( bin_w*(i), hist_h - cvRound(g_hist.at<float>(i)) ), cv::Scalar( 0, 255, 0), 2, 8, 0  );
        cv::line( histImage, cv::Point( bin_w*(i-1), hist_h - cvRound(r_hist.at<float>(i-1)) ) , cv::Point( bin_w*(i), hist_h - cvRound(r_hist.at<float>(i)) ), cv::Scalar( 0, 0, 255), 2, 8, 0  );
    }

return histImage;

}
void FeatureVectorBuilder::createSingleHistogramImage(cv::Mat& histogram, cv::Mat& output, int histSize, int histW, int histH) {
	int bin_w = cvRound((double) histW / histSize);

	cv::Mat histImage(histH, histW, CV_8UC3, cv::Scalar(0, 0, 0));

	/// Normalize the result to [ 0, histImage.rows ]
	cv::normalize(histogram, histogram, 0, histImage.rows, cv::NORM_MINMAX, -1, cv::Mat());

	/// Draw for each channel
	for (int i = 1; i < histSize; i++) {
		cv::line(histImage, cv::Point(bin_w * (i - 1), histH - cvRound(histogram.at<float>(i - 1))),
				cv::Point(bin_w * (i), histH - cvRound(histogram.at<float>(i))), cv::Scalar(255, 0, 0), 2, 8, 0);
	}

	histImage.copyTo(output);
}
Esempio n. 17
0
void histDisplay(int histogram[], const char* name)
{
	int hist[256];
	for (int i = 0; i < 256; i++)
	{
		hist[i] = histogram[i];
	}
	// draw the histograms
	int hist_w = 512; int hist_h = 400;
	int bin_w = cvRound((double)hist_w / 256);

	cv::Mat histImage(hist_h, hist_w, CV_8UC1, cv::Scalar(255, 255, 255));

	// find the maximum intensity element from histogram
	int max = hist[0];
	for (int i = 1; i < 256; i++){
		if (max < hist[i]){
			max = hist[i];
		}
	}

	// normalize the histogram between 0 and histImage.rows

	for (int i = 0; i < 256; i++){
		hist[i] = ((double)hist[i] / max)*histImage.rows;
	}


	// draw the intensity line for histogram
	for (int i = 0; i < 256; i++)
	{
		line(histImage, cv::Point(bin_w*(i), hist_h),
			cv::Point(bin_w*(i), hist_h - hist[i]),
			cv::Scalar(0, 0, 0), 1, 8, 0);
	}

	// display histogram
	cv::namedWindow(name, CV_WINDOW_AUTOSIZE);
	imshow(name, histImage);
}
Esempio n. 18
0
cv::Mat FSVision::histogram(cv::Mat &img)
{
    /// Separate the image in 3 places ( B, G and R )

    /// Establish the number of bins
    int histSize = 256;

    /// Set the ranges ( for B,G,R) )
    float range[] = { 0, 256 } ;
    const float* histRange = { range };

    bool uniform = true;
    bool accumulate = false;

    cv::Mat hist;

    /// Compute the histograms:
    //cv::calcHist()
    cv::calcHist(&img, 1, 0, cv::Mat(), hist, 1, &histSize, &histRange, uniform, accumulate );

    // Draw the histograms for B, G and R
    int hist_w = 512;
    int hist_h = 400;
    int bin_w = cvRound( (double) hist_w/histSize );

    cv::Mat histImage( hist_h, hist_w, CV_8UC3, cv::Scalar(0,0,0) );

    /// Normalize the result to [ 0, histImage.rows ]
    cv::normalize(hist, hist, 0, histImage.rows, cv::NORM_MINMAX, -1, cv::Mat() );

    /// Draw for each channel
    for( int i = 1; i < histSize; i++ )
    {
        cv::line( histImage, cv::Point( bin_w*(i-1), hist_h - cvRound(hist.at<float>(i-1)) ) ,
                  cv::Point( bin_w*(i), hist_h - cvRound(hist.at<float>(i)) ),
                  cv::Scalar( 255, 0, 0), 2, 8, 0  );
    }
    return histImage;
}
void BlobDetection::showHist(cv::Mat& img, string name) const {
#ifdef DEBUG
/// Establish the number of bins
  int histSize = 256;

  /// Set the ranges ( for B,G,R) )
  float range[] = { 0, 256 } ;
  const float* histRange = { range };

  bool uniform = true; bool accumulate = false;

  Mat hist;

  /// Compute the histograms:
  calcHist( &img, 1, 0, Mat(), hist, 1, &histSize, &histRange, uniform, accumulate );

  // Draw the histograms for B, G and R
  int hist_w = 512; int hist_h = 400;
  int bin_w = cvRound( (double) hist_w / histSize );

  Mat histImage( hist_h, hist_w, CV_8UC1, Scalar( 0) );

  /// Normalize the result to [ 0, histImage.rows ]
  normalize(hist, hist, 0, histImage.rows, NORM_MINMAX, -1, Mat() );

  /// Draw hist
  for( int i = 1; i < histSize; i++ )
      line( histImage, Point( bin_w * (i-1), hist_h - cvRound(hist.at<float>(i-1)) ), Point( bin_w*(i), hist_h - cvRound(hist.at<float>(i)) ), Scalar( 255), 2, 8, 0  );

  int upperBound = 42;
  n.getParam("upperBound", upperBound);
  cv::line(histImage, cv::Point( bin_w * upperBound, 0), cv::Point( bin_w * upperBound, hist_h - 1), Scalar(127), 2, 8, 0 );

  /// Display
  namedWindow(name, CV_WINDOW_AUTOSIZE );
  imshow(name, histImage );
#endif
}
Esempio n. 20
0
int main( int argc, char** argv )
{
  cv::Mat src, dst;

  /// Load image
  src = cv::imread("fontana.jpeg", 1);
  if( !src.data )
    return -1;

  /// Separate the image in 3 places (B,G,R) one for each channel
  std::vector<cv::Mat> bgr_planes;
  split( src, bgr_planes );

  /// Establish the number of bins
  int histSize = 256;

  /// Set the ranges ( for B,G,R) between 0 and 255
  float range[] = { 0, 256 } ;
  const float* histRange = { range };

  bool uniform = true; 
  bool accumulate = false;

  /// Creation of 3 Mat objects to save each histogramm
  cv::Mat b_hist, g_hist, r_hist;

  /// Compute the histograms:
  cv::calcHist( &bgr_planes[0], 1, 0, cv::Mat(), b_hist, 1, &histSize, &histRange, uniform, accumulate );
  cv::calcHist( &bgr_planes[1], 1, 0, cv::Mat(), g_hist, 1, &histSize, &histRange, uniform, accumulate );
  cv::calcHist( &bgr_planes[2], 1, 0, cv::Mat(), r_hist, 1, &histSize, &histRange, uniform, accumulate );

  /// Draw the histograms for B, G and R
  int hist_w = 512; 
  int hist_h = 400;
  int bin_w = cvRound( (double) hist_w/histSize );

  cv::Mat histImage( hist_h, hist_w, CV_8UC3, cv::Scalar( 0,0,0) );

  /// Normalize the result to [ 0, histImage.rows ]
  cv::normalize(b_hist, b_hist, 0, histImage.rows, cv::NORM_MINMAX, -1, cv::Mat() );
  cv::normalize(g_hist, g_hist, 0, histImage.rows, cv::NORM_MINMAX, -1, cv::Mat() );
  cv::normalize(r_hist, r_hist, 0, histImage.rows, cv::NORM_MINMAX, -1, cv::Mat() );

  /// Draw for each channel
  for( int i = 1; i < histSize; i++ )
  {
      cv::line( histImage, cv::Point( bin_w*(i-1), hist_h - cvRound(b_hist.at<float>(i-1)) ) ,
                       cv::Point( bin_w*(i), hist_h - cvRound(b_hist.at<float>(i)) ),
                       cv::Scalar( 255, 0, 0), 2, 8, 0  );
      cv::line( histImage, cv::Point( bin_w*(i-1), hist_h - cvRound(g_hist.at<float>(i-1)) ) ,
                       cv::Point( bin_w*(i), hist_h - cvRound(g_hist.at<float>(i)) ),
                       cv::Scalar( 0, 255, 0), 2, 8, 0  );
      cv::line( histImage, cv::Point( bin_w*(i-1), hist_h - cvRound(r_hist.at<float>(i-1)) ) ,
                       cv::Point( bin_w*(i), hist_h - cvRound(r_hist.at<float>(i)) ),
                       cv::Scalar( 0, 0, 255), 2, 8, 0  );
  }

  /// Display
 
  cv::imshow("calcHist Demo", histImage );
  cv::waitKey(0);

  return 0;
}
Esempio n. 21
0
CvPoint2D32f getPupilCenter(Mat &eye_box){
	//find x and y gradients
	Mat gradientX = computeGradient(eye_box);
	Mat gradientY = computeGradient(eye_box.t()).t();

	//normalize and threshold the gradient
	Mat mags = matrixMagnitude(gradientX, gradientY);

	//create a blurred and inverted image for weighting
	Mat weight;
	bitwise_not(eye_box, weight);
	blur(weight, weight, Size(2,2));

	//weight the magnitudes, convert to 8-bit for thresholding
	weight.convertTo(weight, CV_32F);
	mags = mags.mul(weight);
	normalize(mags, mags, 0, 1, NORM_MINMAX, CV_32F);
	mags.convertTo(mags, CV_8UC1, 255);

	//threshold using Otsu's method
	threshold(mags, mags, 0, 255, THRESH_BINARY | THRESH_OTSU);

	//convert to CV_32S and filter gradients
	mags.convertTo(mags, CV_32S);
	gradientY = gradientY.mul(mags);
	gradientX = gradientX.mul(mags);

	//resize arrays to same size
	resize(gradientX, gradientX, Size(EYE_FRAME_SIZE, EYE_FRAME_SIZE), 0, 0, INTER_NEAREST);
	resize(gradientY, gradientY, Size(EYE_FRAME_SIZE, EYE_FRAME_SIZE), 0, 0, INTER_NEAREST);
	resize(weight, weight, Size(EYE_FRAME_SIZE, EYE_FRAME_SIZE), 0, 0, INTER_NEAREST);

	//imshow("gradY", gradientY * 255);
	//imshow("weight", weight / 255);

	//run the algorithm:
	//	for each possible gradient location
	//	Note: these loops are reversed from the way the paper does them
	//	it evaluates every possible center for each gradient location instead of
	//	every possible gradient location for every center.
	Mat out = Mat::zeros(weight.rows,weight.cols, CV_32F);
	float max_val = 0;
	//for all pixels in the image
	for (int y = 0; y < EYE_FRAME_SIZE; ++y) {
		const int *grad_x = gradientX.ptr<int>(y), *grad_y = gradientY.ptr<int>(y);
		for (int x = 0; x < EYE_FRAME_SIZE; ++x) {
			int gX = grad_x[x], gY = grad_y[x];
			if (gX == 0 && gY == 0) {
				continue;
			}
			//for all possible centers
			for (int cy = 0; cy < EYE_FRAME_SIZE; ++cy) {
				float *Or = out.ptr<float>(cy);
				const float *Wr = weight.ptr<float>(cy);
				for (int cx = 0; cx < EYE_FRAME_SIZE; ++cx) {
					//ignore center of box
					if (x == cx && y == cy) {
						continue;
					}
					//create a vector from the possible center to the gradient origin
					int dx = x - cx;
					int dy = y - cy;

					//compute dot product using lookup table
					float dotProduct;
					if(dx > 0 && dy > 0){
						dotProduct = dpX[dx+EYE_FRAME_SIZE*dy]*gX + dpY[dx+EYE_FRAME_SIZE*dy]*gY;
					}else if(dx > 0){
						dotProduct = dpX[dx-EYE_FRAME_SIZE*dy]*gX - dpY[dx-EYE_FRAME_SIZE*dy]*gY;
					}else if(dy > 0){
						dotProduct = -dpX[-dx+EYE_FRAME_SIZE*dy]*gX - dpY[-dx+EYE_FRAME_SIZE*dy]*gY;
					}else{
						dotProduct = -dpX[-dx-EYE_FRAME_SIZE*dy]*gX - dpY[-dx-EYE_FRAME_SIZE*dy]*gY;
					}

					//ignore negative dot products as they point away from eye
					if(dotProduct <= 0.0){
						continue;
					}

					//square and multiply by the weight
					Or[cx] += dotProduct * dotProduct * Wr[cx];

					//compare with max
					if(Or[cx] > max_val){
						max_val = Or[cx];
					}
				}
			}
		}
	}

	//resize for debugging
	resize(out, out, Size(500,500), 0, 0, INTER_NEAREST);

	out = 255 * out / max_val;
	//imshow("calc", out / 255);

	//histogram setup
	Mat hist;
	int histSize = 256;
	float range[] = { 0, 256 } ;
	const float* histRange = { range };
	//calculate the histogram
	calcHist(&out,1, 0, Mat(), hist, 1, &histSize, &histRange,
		true,	//uniform
		true	//accumulate
	);

	//get cutoff for top 10 pixels
	float top_end_sum = 0;
	int top_end = 0.92 * 255;
	for (int i = 255; i > 0; i--) {
		top_end_sum += hist.at<float>(i);
		if(top_end_sum > 3000){
			top_end = i;
			break;
		}
	}

	//draw image for debugging
	Mat histImage(400, 512, CV_8UC3, Scalar(0,0,0));
	int bin_w = cvRound( (double) 512/histSize );
	normalize(hist, hist, 0, histImage.rows, NORM_MINMAX, -1, Mat());
	/// Draw for each channel
	for( int i = 1; i < histSize; i++)
	{
		line(histImage, Point(bin_w*(i), 400 - cvRound(hist.at<float>(i))),
						Point(bin_w*(i), 400),
						Scalar(i, i, i), 2, 8, 0);
	}
	//imshow("hist", histImage);

	//threshold to get just the pupil
	//printf("top_end: %d\n", top_end);
	threshold(out, out, top_end, 255, THRESH_TOZERO);

	//calc center of mass
	float sum = 0;
	float sum_x = 0;
	float sum_y = 0;
	for (int y = 0; y < out.rows; ++y)
	{
		float* row = out.ptr<float>(y);
		for (int x = 0; x < out.cols; ++x)
		{
			float val = row[x]*row[x];
			if(val > 0){
				sum += val;
				sum_x += val*x;
				sum_y += val*y;
			}
		}
	}
	Size eye_box_size = eye_box.size();
	Size out_size = out.size();
	//cout << "Size1: "+to_string(eye_box_size.width)+","+to_string(eye_box_size.height)+"\n";
	//cout << "Size2: "+to_string(out_size.width)+","+to_string(out_size.height)+"\n";
	float x_scale = (float) eye_box_size.width / out_size.width;
	float y_scale = (float) eye_box_size.height / out_size.height;
	CvPoint2D32f max = cvPoint2D32f(x_scale*sum_x/sum, y_scale*sum_y/sum);
	//circle(out, max, 3, 0);
	//imshow("thresh", out / 255);
	return max;
}
Esempio n. 22
0
int main(int argc, char* argv[])
{
	char* filename = argc == 2 ? argv[1] : "test.avi";
	VideoCapture capture(filename); 
	
	if (!capture.isOpened()) 
		return -1;

	namedWindow("Video", CV_WINDOW_AUTOSIZE);
	//namedWindow("Hist", CV_WINDOW_AUTOSIZE);

	vector<int> vec;
	int number = 0;
	int width = capture.get(CV_CAP_PROP_FRAME_WIDTH);
	int height = capture.get(CV_CAP_PROP_FRAME_HEIGHT);
	int wait = 1000 / capture.get(CV_CAP_PROP_FPS);
	int temp = width * PERCENT_EDGE;
	long int amount_pixels = (width * height) - (2 * temp * height);
	cv::Mat mask(height, width, CV_8U, 0.0); // создание маски, дл¤ подсчета гистограммы без учЄта краЄв
	rectangle(mask, cv::Point(temp,0), cv::Point(width - temp, height), 1, CV_FILLED);

	// ѕараметры гистограммы
	int histSize = 256;
	float range[] = { 0, 256 };
	const float* histRange = { range };
	bool uniform = true; 
	bool accumulate = false;
	int hist_w = 512; 
	int hist_h = 400;
	int bin_w = cvRound((double)hist_w / histSize);

	while (capture.isOpened())
	{
		Mat src;
		if (!capture.read(src)) break;
		imshow("Video", src);

		// Ѕудем считать гистогрмму только дл¤ канала R
		std::vector<Mat> bgr_planes;
		split(src, bgr_planes);

		Mat r_hist;

		calcHist(&bgr_planes[2], 1, 0, mask, r_hist, 1, &histSize, &histRange, uniform, accumulate);

		Mat histImage(hist_h, hist_w, CV_8UC3, Scalar(0, 0, 0));

		HistEvidenceAnaliz(&r_hist,  histSize, amount_pixels, &vec, number);

		// Normalize the result to [ 0, histImage.rows ]
		//normalize(r_hist, r_hist, 0, histImage.rows, NORM_MINMAX, -1, Mat());

		// Draw Hist
		/*for (int i = 1; i < histSize; i++)
		{
			line(histImage, Point(bin_w*(i - 1), hist_h - cvRound(r_hist.at<float>(i - 1))),
				Point(bin_w*(i), hist_h - cvRound(r_hist.at<float>(i))),
				Scalar(0, 0, 255), 2, 8, 0);
		}*/

		//imshow("Hist", histImage);

		if (waitKey(wait) >= 0) break;
	}

	vector<pair<int, int>> linking_frames;
	int counter = 0;
	int start = 0;

	for (vector<int>::iterator it = vec.begin(); it != vec.end(); it++)
	{ // рассчЄт мест сшивки, чтобы избежать попадани¤ случайных кадров
		if ((it + 1) != vec.end())
		{
			if (*(it + 1) - *it <= THRESHOLD_GAP_FRAME)
			{
				if (counter == 0) start = *it;
				counter++;
			}
			else
			{
				if (counter < THRESHOLD_FRAME_SEQUENCE) counter = 0;
				else
				{
					if ((*it) - start > MIN_LENGTH_SEQUENCE_FRAME) linking_frames.push_back(pair<int, int>(start, *it));
					counter = 0;
				}
			}
		}
		else if (counter >= THRESHOLD_FRAME_SEQUENCE)
		{
			if ((*it) - start > MIN_LENGTH_SEQUENCE_FRAME)
				linking_frames.push_back(pair<int, int>(start, *it));
		}
	}

	cout << "Linking frames:" << endl;
	for (vector<pair<int, int>>::iterator it = linking_frames.begin(); it != linking_frames.end(); it++)
		cout << it->first << " - " << it->second << endl;

	getchar();

	return 0;
}
Esempio n. 23
0
void CImageAnalysis::OnBnClickedHough()
{
	CMainFrame * pwnd = (CMainFrame *)AfxGetMainWnd();
	GetDlgItem(IDC_Show);
	Mat mat = imread( "F:\\4点定位剪切图.bmp",CV_LOAD_IMAGE_ANYDEPTH|CV_LOAD_IMAGE_ANYCOLOR );
	Mat src,src1,src2;
	
	mat.copyTo(src);
	medianBlur(src,src1,5);//中值滤波
	int threshold1=100;

	Mat hist;
	int histSize = 255;
	float range[] = { 0, 255 } ;
	const float* histRange = { range };
	bool uniform = true; 
	bool accumulate = false;
	calcHist( &src1, 1, 0, Mat(), hist, 1, &histSize, &histRange, uniform, accumulate );
	int hist_w = 400; int hist_h = 400;
	int bin_w = cvRound( (double) 3*hist_w/histSize );

	Mat histImage( hist_w, hist_h, CV_8UC3, Scalar( 255,255,255) );
	normalize(hist, hist, 0, histImage.rows, NORM_MINMAX, -1, Mat() );


	for( int i = 1; i < 255; i++ )
	{
		line( histImage, Point( bin_w*(i-1), hist_h - cvRound(hist.at<float>(i-1)) ) ,
			Point( bin_w*(i), hist_h - cvRound(hist.at<float>(i)) ),
			Scalar( 0, 0, 0), 2, 8, 0  );
		/*line( histImage, Point( bin_w*(i), hist_h - cvRound(hist.at<float>(i)) ) ,
			Point( bin_w*(i), hist_h  ),
			Scalar( 0, 0, 0), 2, 8, 0  );*/
	}
	
	namedWindow("calcHist Demo", CV_WINDOW_AUTOSIZE );
	imshow("calcHist Demo", histImage );
	imwrite("hist.bmp",histImage);
	//Histogram();

	//m_Show.ShowImage(hist,0);
	//threshold(src1,src1,threshold1,255,THRESH_BINARY);//二值图的生成;
	//vector<vector<Point> > contours;
	//vector<Vec3f> circles;
	//findContours(src2,contours,CV_RETR_LIST,CV_CHAIN_APPROX_NONE);

	// Apply the Hough Transform to find the circles
	/*HoughCircles( src,circles, CV_HOUGH_GRADIENT, 1, 1, 200, 10, 2,1000);
	for( size_t i = 0; i < circles.size(); i++ )
	{
		Point center(cvRound(circles[i][0]), cvRound(circles[i][1]));
		int radius = cvRound(circles[i][2]);
		// circle center
		circle( src, center, 3, Scalar(0,255,0), -1, 8, 0 );
		// circle outline
		circle( src, center, radius, Scalar(0,0,255), 3, 8, 0 );
	}*/
	/*pwnd->m_imageprocess.ImageRotate(src1,src2,1.5);
	Mat src3=Mat::zeros(src2.rows,src2.cols,src2.type());//src2.cols+10
	Mat dst=Mat::zeros(src2.rows,src2.cols,src2.type());
	int src2_half_rows=src2.rows/2;
	int src1_half_rows=src1.rows/2;
	int i,j,k;
	uchar *p,*q;
	MatIterator_<uchar> begin1,begin2;
	begin1=src1.begin<uchar>();
	begin2=src2.begin<uchar>();

	for(i=src2_half_rows-src1_half_rows;i!=src2_half_rows+src1_half_rows;++i)
	{
		p=src3.ptr<uchar>(i);

		for(j=0;j!=src1.cols;++j)
		{
			p[j]=*begin1;
			++begin1;
		}
	}
	int dx=825,dy=5;//dst中只装载src1  小于(828,0)则向原点移动
	for (int i = 0; i < dst.rows; i++)
	{
		p = dst.ptr<uchar>(i);
		for (int j = 0; j < dst.cols; j++)
		{
			//平移后坐标映射到原图像
			int x = j - dx;
			int y = i - dy;

			//保证映射后的坐标在原图像范围内
			if (x >= 0 && y >= 0 && x <src3. cols && y < src3.rows)
				p[j] = src3.ptr<uchar>(y)[x];
		}
	}

	for(i=0;i!=src2.rows;++i)
	{
		q=dst.ptr<uchar>(i);
		for(j=0;j!=src2.cols;++j)//src2.cols+10
		{
			k=q[j]/2+*begin2/2;
			
			q[j]=k;
			
			++begin2;
		}
	}
	//m_Show.ShowImage(src2,0);
	//m_Show.ShowImage(dst,0);
	//imwrite("F:\\result1.bmp",dst);
	threshold(dst,dst,threshold1,255,THRESH_BINARY);//二值图的生成;
	vector<vector<Point> > contours;
	findContours(dst,contours,CV_RETR_LIST,CV_CHAIN_APPROX_NONE);
	//system("pause");
	/// 绘出轮廓
	Mat gray ;
	cvtColor(dst,gray , CV_GRAY2BGR); 
	for( int i = 0; i<contours.size(); i++ )
	{
		drawContours( gray, contours, i, Scalar(255,0,0), 2, 8, contours[0], 0, Point() );
	}
	

	m_Show.ShowImage(hist,0);*/

}
Esempio n. 24
0
void showHistogram(Mat im,string str)
{
	im.convertTo(im, CV_8U);
	cout << "th1=" <<TH1<< endl;
	string savePath;
	/// 设定bin数目
	int histSize = 256-TH1;

	/// 设定取值范围 ( R,G,B) )
	float range[] = { TH1, 255 };
	const float* histRange = { range };

	bool uniform = true; 
	bool accumulate = true;

	Mat r_hist;

	/// 计算直方图:
	calcHist(&im, 1, 0, Mat(), r_hist, 1, &histSize, &histRange, uniform, true);

	savePath = "./output/histogram_" + str + ".xls";
	outXls(savePath,r_hist,"float" );

	Mat accumulate_hist = Mat::zeros(r_hist.rows, 1, CV_32F);

	// 创建直方图画布
	int hist_w = 400; int hist_h = 400;
	int bin_w = cvRound((double)hist_w / histSize);

	Mat histImage(hist_w, hist_h, CV_8UC3, Scalar(0, 0, 0));

	//将负的直方图扩展进来
	
	//accumulate histogram
	for (int m = 0; m < r_hist.rows;m++)
	{
		accumulate_hist.at<float>(m, 0) = sum(r_hist,m);
	}
	outXls("./output/accuxls.xls", accumulate_hist, "float");

	/// 将直方图归一化到范围 [ 0, histImage.rows ],[0,400]
	normalize(r_hist, r_hist, 0, histImage.rows, NORM_MINMAX, -1, Mat());
	//normalize(accumulate_hist, accumulate_hist, 0, histImage.rows, NORM_MINMAX, -1, Mat());
	
	/// 在直方图画布上画出直方图
	for (int i = 1; i < histSize; i++)
	{
		/*Point up(bin_w*(i - 1), hist_h - cvRound(r_hist.at<float>(i - 1)));
		Point bottom(bin_w*(i - 1), hist_h);
		line(histImage, bottom, up, Scalar(0, 0, 255), 2, 8, 0);*/

		/*line(histImage, Point(bin_w*(i - 1), hist_h - cvRound(accumulate_hist.at<float>(i - 1))),
			Point(bin_w*(i), hist_h - cvRound(accumulate_hist.at<float>(i))),
				Scalar(0, 0, 255), 2, 8, 0);*/
		line(histImage, Point(bin_w*(i - 1), hist_h - cvRound(r_hist.at<float>(i - 1))),
			Point(bin_w*(i), hist_h - cvRound(r_hist.at<float>(i))),
			Scalar(0, 0, 255), 2, 8, 0);
	}


	/// 显示直方图
	imshow(str, histImage);

}
//-----------------------------------------------------------------------------------------------------
void FrameAnalyzerHistogram::analyze(Mat &input, Mat &output) {
    lastFrame=currentFrame;
    currentFrame=input;
    frameList.append(input);
    std::cout << frameList.length() << std::endl;

    /// ----------------------------------------------------------------------
    vector<Mat> bgr_planes; /// Separate the image in 3 places ( B, G and R )
    split(input, bgr_planes);

    // Установка количества бинов:
    int histSize = 256;

    // Установка граничных значений ( for B,G,R) )
    float range[] = { 0, 256 };
    const float* histRange = { range };

    bool uniform = true;
    bool accumulate = false;

    Mat b_hist, g_hist, r_hist;

    // Вычислить гистограммы:
    calcHist(&bgr_planes[0], 1, 0, Mat(), b_hist, 1, &histSize, &histRange,
            uniform, accumulate);
    calcHist(&bgr_planes[1], 1, 0, Mat(), g_hist, 1, &histSize, &histRange,
            uniform, accumulate);
    calcHist(&bgr_planes[2], 1, 0, Mat(), r_hist, 1, &histSize, &histRange,
            uniform, accumulate);

    // Отрисовать гистограммы для B, G и R
    int hist_w = 640;
    int hist_h = 480;
    int bin_w = cvRound((double) hist_w / histSize);

    Mat histImage(hist_h, hist_w, CV_8UC3, Scalar(0, 0, 0));

    // Нормализация результата к [ 0, histImage.rows ]
    normalize(b_hist, b_hist, 0, histImage.rows, NORM_MINMAX, -1, Mat());
    normalize(g_hist, g_hist, 0, histImage.rows, NORM_MINMAX, -1, Mat());
    normalize(r_hist, r_hist, 0, histImage.rows, NORM_MINMAX, -1, Mat());

    // Отрисовать для каждого канала
    for (int i = 1; i < histSize; i++) {
        line(histImage,
                Point(bin_w * (i - 1),
                        hist_h - cvRound(b_hist.at<float>(i - 1))),
                Point(bin_w * (i), hist_h - cvRound(b_hist.at<float>(i))),
                Scalar(255, 0, 0), 2, 8, 0);
        line(histImage,
                Point(bin_w * (i - 1),
                        hist_h - cvRound(g_hist.at<float>(i - 1))),
                Point(bin_w * (i), hist_h - cvRound(g_hist.at<float>(i))),
                Scalar(0, 255, 0), 2, 8, 0);
        line(histImage,
                Point(bin_w * (i - 1),
                        hist_h - cvRound(r_hist.at<float>(i - 1))),
                Point(bin_w * (i), hist_h - cvRound(r_hist.at<float>(i))),
                Scalar(0, 0, 255), 2, 8, 0);
    }
    output = histImage;
    /*
     /// Display
     namedWindow("calcHist Demo", CV_WINDOW_AUTOSIZE);
     imshow("calcHist Demo", histImage);
     */
}