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;
}
/*
* @src Frame image
* @contour contour processing
* @testImageHistogram histogram from model image
* @h_bins number of hue bins
* @s_bins number of sat bins
* @min minimum similarity to achieve when comparing histograms
*/
int Contours::histogramMatchingFilter(IplImage * src, CvHistogram * testImageHistogram,int h_bins,int s_bins, double min){
CvRect box;
CvMemStorage* mem = cvCreateMemStorage(0);
double val;
//get contour bounding box
box=cvBoundingRect(this->c,0);
//printf("box x:%d y:%d \n",box.x,box.y);
IplImage * src_bbox=cvCreateImage(cvSize(box.width,box.height),src->depth,src->nChannels);
//gets subimage bounded by box
cvGetSubArr( src,(CvMat*)src_bbox, box );
//gets subimage histogram
utils::Histogram * h = new Histogram(h_bins,s_bins);
CvHistogram* hist = h->getHShistogramFromRGB(src_bbox);
//compares with object histogram
val=cvCompareHist(hist,testImageHistogram,CV_COMP_BHATTACHARYYA);
cvReleaseHist(&hist);
cvReleaseImage(&src_bbox);
cvReleaseMemStorage(&mem);
delete h;
return (val<min);
}
void AdaptiveHistogramCamshift::Deinit()
{
// Free buffers that enable tracking.
StopTracking();
cvReleaseImage(&m_imgHue);
cvReleaseImage(&m_imgMask);
cvReleaseImage(&m_imgHSV);
cvReleaseImage(&m_imgBackproject);
cvReleaseImage(&m_histImg);
cvReleaseHist(&m_hist);
cvReleaseHist(&m_histSubdiv);
cvReleaseHist(&m_histTrackWnd);
m_initialized = false;
}
CamShift::~CamShift(void)
{
cvReleaseImage(&_hsv);
cvReleaseImage(&_hue);
cvReleaseImage(&_mask);
cvReleaseImage(&_backproject);
cvReleaseHist(&_hist);
}
void releaseCamshift(camshift * cs)
{
cvReleaseImage( &cs->HSVImg );
cvReleaseImage( &cs->hueImg );
cvReleaseImage( &cs->mask );
cvReleaseImage( &cs->probImg );
cvReleaseHist( &cs->hist );
}
void CV_BaseHistTest::clear()
{
int i;
CvTest::clear();
for( i = 0; i < MAX_HIST; i++ )
cvReleaseHist( &hist[i] );
delete[] _ranges;
_ranges = 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);
}
}
/* Release resources from tracked object. */
void FaceBl0r::destroy_tracked_object (TrackedObj* obj) {
cvReleaseImage(&obj->hsv);
cvReleaseImage(&obj->hue);
cvReleaseImage(&obj->mask);
cvReleaseImage(&obj->prob);
cvReleaseHist(&obj->hist);
free(obj);
}
void PathObject::Clear()
{
mNearColor= CV_RGB(0,0,0);
mFarColor = CV_RGB(0,0,0);
mMainThreshold = 0;
mMinNoiseSizePercent = 0;
mTemplateThreshold = 0;
mDebug = false;
cvReleaseImage(&mNearImage);
cvReleaseImage(&mFarImage);
cvReleaseImage(&mTemplate);
cvReleaseHist(&mNearHist);
cvReleaseHist(&mFarHist);
mMaskOptions.clear();
//delete mSeg;
//delete mThresh;
//delete mRatio;
}
//////////////////////////////////
// releaseTracker()
//
void releaseTracker(camshift * cs)
{
// Release all tracker resources
cvReleaseImage( &cs->pHSVImg );
cvReleaseImage( &cs->pHueImg );
cvReleaseImage( &cs->pMask );
cvReleaseImage( &cs->pProbImg );
cvReleaseHist( &cs->pHist );
}
// releaseTracker()
//
void releaseTracker()
{
// Release all tracker resources
cvReleaseImage( &pHSVImg );
cvReleaseImage( &pHueImg );
cvReleaseImage( &pMask );
cvReleaseImage( &pProbImg );
cvReleaseHist( &pHist );
}
int main( int argc, char** argv )
{
IplImage *src = 0;
IplImage *histimg = 0;
CvHistogram *hist = 0;
int hbins = 255; // 划分HIST的个数，越高越精确
int maxcount = 255;
float hranges_arr[] = {0,maxcount};//
float* hranges = hranges_arr;
int bin_w;
float max_val;
int i;
if((src=cvLoadImage("../cvtest/7newsample.jpg", CV_LOAD_IMAGE_GRAYSCALE)) == NULL) // force to gray image
return -1;
cvNamedWindow( "Histogram", 0 );
cvNamedWindow( "src", 0);
hist = cvCreateHist( 1, &hbins, CV_HIST_ARRAY, &hranges, 1 ); // 计算直方图
histimg = cvCreateImage( cvSize(320,200), 8, 3 );
cvZero( histimg );
cvCalcHist( &src, hist, 0, 0 ); // 计算直方图
float min_val = 0;
cvGetMinMaxHistValue( hist, &min_val, &max_val, 0, 0 ); // 只找最大值
printf("max_val:%.4f,min:%.4f\n",max_val,min_val);
cvConvertScale( hist->bins, hist->bins, max_val ? 255. / max_val : 0., 0 ); // 缩放 bin 到区间 [0,255]
cvZero( histimg );
bin_w = histimg->width / hbins; // hbins: 条的个数，则 bin_w 为条的宽度
// 画直方图
for( i = 0; i < hbins; i++ )
{
double val = ( cvGetReal1D(hist->bins,i)/*255份中的几份*/*histimg->height/maxcount );
CvScalar color = CV_RGB(255,255,0); //(hsv2rgb(i*180.f/hbins);
cvRectangle( histimg, cvPoint(i*bin_w,histimg->height),
cvPoint((i+1)*bin_w,(int)(histimg->height - val)),
color, 1, 8, 0 );
printf("(%d,%d),(%d,%d)\n",i*bin_w,histimg->height,(i+1)*bin_w,(int)(histimg->height - val));
}
cvShowImage( "src", src);
cvShowImage( "Histogram", histimg );
cvWaitKey(0);
cvDestroyWindow("src");
cvDestroyWindow("Histogram");
cvReleaseImage( &src );
cvReleaseImage( &histimg );
cvReleaseHist ( &hist );
return 0;
}
size_t calcularHistograma(IplImage *src, size_t *binsCount, size_t **bins) {
if (src == NULL || bins == NULL) {
return -1;
}
static int _trueChannels = 1;
static int _trueChannel = 1;
int channels = src->nChannels;
int hist_size = 256;
if (*bins == NULL) {
*bins = (size_t *)calloc(channels * hist_size, sizeof(size_t));
*binsCount = channels;
}
//if (channels == 3) printf("%d (%p)", *binsCount, *bins);
//Actuo en funcion la cantidad de colores de la imagen
if (channels == 1) {
float range[] = { 0, 256 };
float* ranges[] = { range };
CvHistogram *hist_bw = cvCreateHist(1, &hist_size, CV_HIST_ARRAY, ranges, 1);
cvCalcHist(&src, hist_bw, 0, NULL);
for (int i = 0; i < hist_size; i++) {
(*bins)[_trueChannel * hist_size + i] = cvRound(cvGetReal1D(hist_bw->bins, i));
}
cvReleaseHist(&hist_bw);
} else if (src->nChannels == 3) {
_trueChannels = 3;
IplImage *channelA = cvCreateImage(cvGetSize(src), IPL_DEPTH_8U, 1);
IplImage *channelB = cvCreateImage(cvGetSize(src), IPL_DEPTH_8U, 1);
IplImage *channelC = cvCreateImage(cvGetSize(src), IPL_DEPTH_8U, 1);
cvSplit(src, channelA, channelB, channelC, NULL);
_trueChannel = 0;
calcularHistograma(channelA, binsCount, bins);
cvReleaseImage(&channelA);
_trueChannel = 1;
calcularHistograma(channelB, binsCount, bins);
cvReleaseImage(&channelB);
_trueChannel = 2;
calcularHistograma(channelC, binsCount, bins);
cvReleaseImage(&channelC);
_trueChannels = 1;
_trueChannel = 1;
} else {
return -1;
}
return 0;
}
void CamShiftPlugin::ProcessStatic
( int i, ImagePlus *img, ImagePlus *oimg, int *hsizes, CvTermCriteria criteria,
IplImage** &planes, CvHistogram* &hist, IplImage* &backproject, CvRect &orect, CvPoint &ocenter, CvRect &searchwin, CvMat* &rotation, CvMat* &shift, bool oready){
if (hist && hist->mat.dim[0].size!=hsizes[0])
cvReleaseHist(&hist);
if( !hist )
hist = cvCreateHist( 3, hsizes, CV_HIST_ARRAY, NULL, 0);
if( !backproject )
backproject = cvCreateImage( cvGetSize(img->orig), IPL_DEPTH_8U, 1 );
if( !planes ){
planes = (IplImage**) malloc(3 * sizeof(IplImage*));
for (int p=0; p<3; p++)
planes[p] = cvCreateImage( cvGetSize(img->orig), 8, 1 );
}
if (!rotation)
rotation = cvCreateMat(2,3,CV_32FC1);
if (!shift)
shift = cvCreateMat(2,1,CV_32FC1);
if (!oready){
orect = cvBoundingRect(oimg->contourArray[i],1);
cvCvtPixToPlane( oimg->orig, planes[0], planes[1], planes[2], 0 );
for (int p=0; p<3; p++)
cvSetImageROI(planes[p],orect);
cvCalcHist( planes, hist, 0, NULL );
cvNormalizeHist(hist, 255);
for (int p=0; p<3; p++)
cvResetImageROI(planes[p]);
searchwin = orect; //cvRect(0,0,img->orig->width, img->orig->height);
ocenter = cvPoint(orect.x+orect.width/2, orect.y+orect.height/2);
}
//The following checks shouldn't be needed.
RestrictRect(searchwin, cvRect(0,0,backproject->width,backproject->height));
cvCvtPixToPlane( img->orig, planes[0], planes[1], planes[2], 0 );
cvCalcBackProject( planes, backproject, hist );
CvBox2D track_box;
CvConnectedComp track_comp;
cvCamShift( backproject, searchwin,
criteria,
&track_comp, &track_box );
searchwin = track_comp.rect;
cvmSet(shift,0,0,track_box.center.x - ocenter.x);
cvmSet(shift,1,0,track_box.center.y - ocenter.y);
// shift->data.fl[0] = track_box.center.x - ocenter.x;
// shift->data.fl[1] = track_box.center.y - ocenter.y;
cv2DRotationMatrix(track_box.center, track_box.angle, 1.0, rotation);
cvTransform(oimg->contourArray[i],img->contourArray[i],rotation,shift);
// CvMat *ofm = FeatPointsToMat(oimg->feats[i]);
// Cvmat *fm = FeatPointsToMat(img->feats[i]);
// cvTransform(ofm,img->contourArray[i],rotation,shift);
TransformFeatPoints(oimg->feats[i], img->feats[i], rotation, shift);
}
KMeans::~KMeans()
{
int i;
vector<KMeansTriple*>::iterator p;
for(i=0;i<this->numOfCores;i++)
{
for(p=this->sorted[i].begin();p!=this->sorted[i].end();) delete *p++;
this->sorted[i].erase(this->sorted[i].begin(),this->sorted[i].end());
delete this->cores[i];
delete this->old_cores[i];
}
delete[] this->itemNum;
delete[] this->sorted;
delete[] this->cores;
delete[] this->old_cores;
for(i=0;i<this->numOfSamples;i++)
{
delete this->candyset[i];
}
if(this->numOfSamples) delete[] this->candyset;
delete[] this->imagehist;
cvReleaseHist(&this->histR);
cvReleaseHist(&this->histG);
cvReleaseHist(&this->histB);
if(this->planeR) cvReleaseImage(&this->planeR);
if(this->planeG) cvReleaseImage(&this->planeG);
if(this->planeB) cvReleaseImage(&this->planeB);
delete this->rangesR[0];
delete[] this->rangesR;
delete this->rangesG[0];
delete[] this->rangesG;
delete this->rangesB[0];
delete[] this->rangesB;
}
size_t calcularHistograma(IplImage *src, size_t *binsCount, size_t **bins) {
if (src == NULL || bins == NULL) {
return -1;
}
int channels = src->nChannels;
int hist_size = 256;
if (*bins == NULL) {
*bins = (size_t*)calloc(channels * hist_size, sizeof(size_t));
*binsCount = channels;
}
//if (channels == 3) printf("%d (%p)", *binsCount, *bins);
//Actúo en función de la cantidad de colores de la imágen
if (channels == 1) {
float range[] = { 0, 256 };
float* ranges[] = { range };
float max = 0.0;
float w_scale = 0.0;
CvHistogram *hist_bw = cvCreateHist(1, &hist_size, CV_HIST_ARRAY, ranges, 1);
cvCalcHist(&src, hist_bw, 0, NULL);
//float max_value = 0.0;
//cvGetMinMaxHistValue(hist_bw, 0, &max_value, 0, 0);
//cvScale(hist_bw->bins, hist_bw->bins, (float)(src->width*src->height) / max_value, 0);
for (int i = 1; i < hist_size; i++) {
(*bins)[(*binsCount - 1) * hist_size + i] = cvRound(cvGetReal1D(hist_bw->bins, i));
}
cvReleaseHist(&hist_bw);
} else if (src->nChannels == 3) {
IplImage *channelA = cvCreateImage(cvGetSize(src), IPL_DEPTH_8U, 1);
IplImage *channelB = cvCreateImage(cvGetSize(src), IPL_DEPTH_8U, 1);
IplImage *channelC = cvCreateImage(cvGetSize(src), IPL_DEPTH_8U, 1);
cvSplit(src, channelA, channelB, channelC, NULL);
calcularHistograma(channelA, binsCount, bins);
cvReleaseImage(&channelA);
calcularHistograma(channelB, binsCount, bins);
cvReleaseImage(&channelB);
calcularHistograma(channelC, binsCount, bins);
cvReleaseImage(&channelC);
} else {
return -1;
}
return 0;
}
int th_create_hist(CvHistogram** hist, int dims, int* sizes, int type, float** ranges, int uniform) {
int R = 0;
CvHistogram* src = *hist;
if (src == 0x0) {
// yes it exists, but has wrong properties -> delete it!
if (src != 0x0)
cvReleaseHist(hist);
// now the new one can safely be created
*hist = cvCreateHist(dims, sizes, type, ranges, uniform);
R = 1;
}
return R;
}
void CamShiftPlugin::ReleaseTemps()
{
if (backproject) cvReleaseImage(&backproject);
if (hist) cvReleaseHist(&hist);
if (planes){
for (int p=0; p<3; p++){
if (planes[p])
cvReleaseImage(&planes[p]);
}
free(planes); planes = NULL;
}
if (rotation) cvReleaseMat(&rotation);
if (shift) cvReleaseMat(&shift);
}
void
kms_pointer_detector_finalize (GObject * object)
{
KmsPointerDetector *pointerdetector = KMS_POINTER_DETECTOR (object);
GST_DEBUG_OBJECT (pointerdetector, "finalize");
/* clean up object here */
if (pointerdetector->buttonsLayoutList != NULL) {
kms_pointer_detector_dispose_buttons_layout_list (pointerdetector);
}
if (pointerdetector->buttonsLayout != NULL) {
gst_structure_free (pointerdetector->buttonsLayout);
}
if (pointerdetector->cvImage != NULL) {
cvReleaseImageHeader (&pointerdetector->cvImage);
}
if (pointerdetector->cvImageAux1 != NULL) {
cvReleaseImage (&pointerdetector->cvImageAux1);
}
cvReleaseHist (&pointerdetector->histCompare);
cvReleaseHist (&pointerdetector->histModel);
cvReleaseHist (&pointerdetector->histSetUp1);
cvReleaseHist (&pointerdetector->histSetUp2);
cvReleaseHist (&pointerdetector->histSetUpRef);
remove_recursive (pointerdetector->images_dir);
g_free (pointerdetector->images_dir);
if (pointerdetector->previousButtonClickedId != NULL) {
g_free (pointerdetector->previousButtonClickedId);
}
G_OBJECT_CLASS (kms_pointer_detector_parent_class)->finalize (object);
}
static void
cvTsCalcBackProjectPatch( IplImage** images, IplImage* dst, CvSize patch_size,
CvHistogram* hist, int method,
double factor, int* channels )
{
CvHistogram* model = 0;
IplImage imgstub[CV_MAX_DIM], *img[CV_MAX_DIM];
IplROI roi;
int i, dims;
int x, y;
CvSize size = cvGetSize(dst);
dims = cvGetDims( hist->bins );
cvCopyHist( hist, &model );
cvNormalizeHist( hist, factor );
cvZero( dst );
for( i = 0; i < dims; i++ )
{
CvMat stub, *mat;
mat = cvGetMat( images[i], &stub, 0, 0 );
img[i] = cvGetImage( mat, &imgstub[i] );
img[i]->roi = &roi;
}
roi.coi = 0;
for( y = 0; y < size.height; y++ )
{
for( x = 0; x < size.width; x++ )
{
double result;
roi.xOffset = x;
roi.yOffset = y;
roi.width = patch_size.width;
roi.height = patch_size.height;
cvTsCalcHist( img, model, 0, channels );
cvNormalizeHist( model, factor );
result = cvCompareHist( model, hist, method );
CV_IMAGE_ELEM( dst, float, y, x ) = (float)result;
}
}
cvReleaseHist( &model );
}
void COpenCVMFCView::OnImageHistogram()
{
// TODO: Add your command handler code here
IplImage *src;
IplImage *histimg = 0;
CvHistogram *hist = 0;
int hdims = 256; // Divide Number of HIST, the more the accurator
float hranges_arr[] = {0,255};
float* hranges = hranges_arr;
int bin_w;
float max_val;
int i;
src = workImg;
cvNamedWindow( "Histogram", 0 );
hist = cvCreateHist( 1, &hdims, CV_HIST_ARRAY, &hranges, 1 ); // Create Hist
histimg = cvCreateImage( cvSize(320,200), 8, 3 );
cvZero( histimg );
cvCalcHist( &src, hist, 0, 0 ); // Caculate Hist
cvGetMinMaxHistValue( hist, 0, &max_val, 0, 0 ); // just wanna the Max
cvConvertScale( hist->bins, hist->bins,
max_val ? 255. / max_val : 0., 0 ); // resize bin to [0,255]
cvZero( histimg );
bin_w = histimg->width / hdims;
// Draw It
for( i = 0; i < hdims; i++ )
{
double val = ( cvGetReal1D(hist->bins,i)*histimg->height/255 );
CvScalar color = CV_RGB(255,255,0); //(hsv2rgb(i*180.f/hdims);
cvRectangle( histimg, cvPoint(i*bin_w,histimg->height),
cvPoint((i+1)*bin_w,(int)(histimg->height - val)),
color, 1, 8, 0 );
}
cvShowImage( "Histogram", histimg );
cvReleaseImage( &histimg );
cvReleaseHist ( &hist );
cvWaitKey(0);
cvDestroyWindow("Histogram");
}
void Widget::zhifangtu(IplImage *hist_img)
{
IplImage *histimg = 0;
CvHistogram *hist = 0; //直方图
int hdims=255;
float hranges_arr[] = {0,255};
float* hranges = hranges_arr;
int bin_w;
float max_val,min_val;
int i;
cvNamedWindow( "Histogram", 0 );
// cvNamedWindow( "src", 0);
hist = cvCreateHist( 1, &hdims, CV_HIST_ARRAY, &hranges, 1 ); //创建直方图
histimg = cvCreateImage( cvSize(320,200), 8, 3 );
cvZero( histimg ); //清零
cvCalcHist( &hist_img, hist, 0, 0 ); // 计算直方图,即每个bin的大小
cvGetMinMaxHistValue( hist, &min_val, &max_val, 0, 0 ); // 只找最大值
cvThreshHist(hist,50);
//qDebug("max:%4.2f",max_val);
//qDebug("min:%4.2f",min_val);
cvConvertScale( hist->bins,hist->bins, max_val ? 255. / max_val : 0., 0 ); // 缩放 bin 到区间 [0,255]
cvZero( histimg );
bin_w = histimg->width / hdims; // hdims: 直方图竖条的个数，则 bin_w 为条的宽度
// 画直方图
for( i = 0; i < hdims; i++ )
{
double val = ( cvGetReal1D(hist->bins,i)*histimg->height/255 );
CvScalar color = CV_RGB(255,255,0); //(hsv2rgb(i*180.f/hdims);
cvRectangle( histimg, cvPoint(i*bin_w,histimg->height),
cvPoint((i+1)*bin_w,(int)(histimg->height - val)),
color, 1, 8, 0 );
}
// cvShowImage( "src", hue);
cvShowImage( "Histogram", histimg );
cv::waitKey(0);
// cvDestroyWindow("src");
cvDestroyWindow("Histogram");
//cvReleaseImage( &src );
cvReleaseImage( &histimg );
cvReleaseHist ( &hist );
}
void MaxEntropy(IplImage *src, IplImage *dst)
{
assert(src != NULL);
assert(src->depth == 8 && dst->depth == 8);
assert(src->nChannels == 1);
CvHistogram * hist = cvCreateHist(1, &HistogramBins, CV_HIST_ARRAY, HistogramRange);
cvCalcHist(&src, hist);
double maxentropy = -1.0;
int max_index = -1;
for (int i = 0; i < HistogramBins; i++) {
double cur_entropy =
caculateCurrentEntropy(hist, i, object) + caculateCurrentEntropy(hist, i, back);
if (cur_entropy > maxentropy){
maxentropy = cur_entropy;
max_index = i;
}
}
cvThreshold(src, dst, (double)max_index, 255, CV_THRESH_BINARY);
cvReleaseHist(&hist);
}
void HistgramEqualization(IplImage* src,IplImage* dst)
{
CvHistogram *hist = 0;
const HDIM=256;
int n = HDIM;
double nn[HDIM];
uchar T[HDIM];
CvMat *T_mat;
int x;
int sum = 0; // sum of pixels of the source image 图像中象素点的总和
double val = 0;
// calculate histgram 计算直方图
hist = cvCreateHist( 1, &n, CV_HIST_ARRAY, 0, 1 );
cvCalcHist( &src, hist, 0, 0 );
// Create Accumulative Distribute Function of histgram
val = 0;
for ( x = 0; x < n; x++)
{
val = val + cvGetReal1D (hist->bins, x);
nn[x] = val;
}
// Compute intensity transformation 计算变换函数的离散形式
sum = src->height * src->width;
for( x = 0; x < n; x++ )
{
T[x] = (uchar) (255 * nn[x] / sum); // range is [0,255]
}
// Do intensity transform for source image
cvCopyImage(src, dst);
T_mat = cvCreateMatHeader( 1, 256, CV_8UC1 );
cvSetData( T_mat, T, 0 );
// directly use look-up-table function 直接调用内部函数完成 look-up-table 的过程
cvLUT( src, dst, T_mat );
cvReleaseHist ( &hist );
}
CvAdaptiveSkinDetector::Histogram::~Histogram()
{
cvReleaseHist(&fHistogram);
};
Histogram::~Histogram()
{
cvReleaseHist(&m_histogram);
}
/*************************************************************************
* @函数名称：
* blurIdentify()
* @输入:
* IplImage* input - 输入灰度图像
* @返回值:
* uchar - 返回图像标志，清晰返回1，模糊返回0
* @说明:
* 该函数通过计算梯度图像，并进行直方图分析，计算相关鉴别指标GMG和NGN，
* 实现模糊鉴别功能
*************************************************************************/
uchar blurIdentify(const IplImage* input)
{
int rows=input->height;
int cols=input->width;
int i=0,j=0;
uchar flag=0;
CvSize size1,size2;
size1.width=cols;
size1.height=rows;
size2.width=2*cols;
size2.height=rows;
IplImage* tempr=cvCreateImage(size1,IPL_DEPTH_8U,1);
IplImage* tempc=cvCreateImage(size1,IPL_DEPTH_8U,1);
cvZero(tempr);
cvZero(tempc);
/*计算水平梯度图像*/
for (i=0;i<rows;i++)
{
uchar* input_data=(uchar*)(input->imageData+i*input->widthStep);
uchar* tempr_data=(uchar*)(tempr->imageData+i*tempr->widthStep);
for (j=0;j<cols-1;j++)
{
tempr_data[j]=abs(input_data[j+1]-input_data[j]);
}
}
/*计算垂直梯度图像*/
for (i = 0; i<rows - 1; i++)
{
uchar* input_data1 = (uchar*)(input->imageData + i*input->widthStep);
uchar* input_data2 = (uchar*)(input->imageData + (i + 1)*input->widthStep);
uchar* tempc_data = (uchar*)(tempc->imageData + i*tempc->widthStep);
for (j = 0; j<cols; j++)
{
tempc_data[j]=abs(input_data2[j]-input_data1[j]);
}
}
/*将两个梯度图像合并为一个，以便统计计算*/
IplImage* gradient=cvCreateImage(size2,IPL_DEPTH_8U,1);
cvZero(gradient);
cvSetImageROI(gradient,cvRect(0,0,cols,rows));
cvCopy(tempr,gradient); //将水平梯度图存入
cvResetImageROI(gradient);
cvSetImageROI(gradient,cvRect(cols,0,cols,rows));
cvCopy(tempc,gradient); //将垂直梯度图存入
cvResetImageROI(gradient);
int nHistSize=256;
float fRange[]={0,255}; //灰度级范围
float* pfRanges[]={fRange};
//CvHistogram* hist=cvCreateHist(1,&nHistSize,CV_HIST_ARRAY,pfRanges); //CV_HIST_ARRAY多维密集数组
//cvCalcHist(&gradient,hist);
CvHistogram* hist1=cvCreateHist(1,&nHistSize,CV_HIST_ARRAY,pfRanges); //CV_HIST_ARRAY多维密集数组
CvHistogram* hist2=cvCreateHist(1,&nHistSize,CV_HIST_ARRAY,pfRanges); //CV_HIST_ARRAY多维密集数组
cvCalcHist(&tempr,hist1);
cvCalcHist(&tempc, hist2);
//int NGN=cvCountNonZero(hist->bins);
int NX=cvCountNonZero(hist1->bins);
int NY = cvCountNonZero(hist2->bins);
double GMG=calGMG(input);
double s = (NX + NY) / (2 * 256.0);
double BIM=s*GMG;
if(BIM>700)
{
flag=1;
}
//测试代码，显示梯度图像
/*cvNamedWindow("gx",1);
cvShowImage("gx",tempr);
cvNamedWindow("gy",1);
cvShowImage("gy",tempc);
cvNamedWindow("g",1);
cvShowImage("g",gradient);*/
printf("GMG=%f,NX=%d,NY=%d,s=%f,BIM=%f\n", GMG, NX, NY,s, BIM);
//for(i=0;i<256;i++)
//{
// printf("%.f ",((CvMatND*)hist->bins)->data.fl[i]);
//}
cvReleaseImage(&tempr);
cvReleaseImage(&tempc);
cvReleaseImage(&gradient);
cvReleaseHist(&hist1);
cvReleaseHist(&hist2);
return 1;
}
std::list<utils::Garbage*> GarbageRecognition::garbageList(IplImage * src, IplImage * model){
std::list<utils::Garbage*>::iterator it;
for ( it=garbages.begin() ; it != garbages.end() ; it++ )
delete *it;
garbages.clear();
//cvNamedWindow("output",CV_WINDOW_AUTOSIZE);
//object model
//image for the histogram-based filter
//could be a parameter
utils::Histogram * h = new Histogram(HIST_H_BINS,HIST_S_BINS);
CvHistogram * testImageHistogram = h->getHShistogramFromRGB(model);
//~ int frameWidth=cvGetCaptureProperty(capture,CV_CAP_PROP_FRAME_WIDTH);
//~ int frameHeight=cvGetCaptureProperty(capture,CV_CAP_PROP_FRAME_HEIGHT);
//gets a frame for setting image size
//CvSize srcSize = cvSize(frameWidth,frameHeight);
CvSize srcSize = cvGetSize(src);
//images for HSV conversion
IplImage* hsv = cvCreateImage( srcSize, 8, 3 );
IplImage* h_plane = cvCreateImage( srcSize, 8, 1 );
IplImage* s_plane = cvCreateImage( srcSize, 8, 1 );
IplImage* v_plane = cvCreateImage( srcSize, 8, 1 );
//Image for thresholding
IplImage * threshImage=cvCreateImage(srcSize,8,1);
//image for equalization
IplImage * equalizedImage=cvCreateImage(srcSize,8,1);
//image for Morphing operations(Dilate-erode)
IplImage * morphImage=cvCreateImage(srcSize,8,1);
//image for image smoothing
IplImage * smoothImage=cvCreateImage(srcSize,8,1);
//image for contour-finding operations
IplImage * contourImage=cvCreateImage(srcSize,8,3);
int frameCounter=1;
int cont_index=0;
//convolution kernel for morph operations
IplConvKernel* element;
CvRect boundingRect;
//contours
CvSeq * contours;
//Main loop
frameCounter++;
//convert image to hsv
cvCvtColor( src, hsv, CV_BGR2HSV );
cvCvtPixToPlane( hsv, h_plane, s_plane, v_plane, 0 );
//equalize Saturation Channel image
cvEqualizeHist(s_plane,equalizedImage);
//threshold the equalized Saturation channel image
cvThreshold(equalizedImage,threshImage,THRESHOLD_VALUE,255,
CV_THRESH_BINARY);
//apply morphologic operations
element = cvCreateStructuringElementEx( MORPH_KERNEL_SIZE*2+1,
MORPH_KERNEL_SIZE*2+1, MORPH_KERNEL_SIZE, MORPH_KERNEL_SIZE,
CV_SHAPE_RECT, NULL);
cvDilate(threshImage,morphImage,element,MORPH_DILATE_ITER);
cvErode(morphImage,morphImage,element,MORPH_ERODE_ITER);
//apply smooth gaussian-filter
cvSmooth(morphImage,smoothImage,CV_GAUSSIAN,3,0,0,0);
//get all contours
contours = myFindContours(smoothImage);
cont_index=0;
cvCopy(src,contourImage,0);
while(contours!=NULL){
CvSeq * aContour=getPolygon(contours);
utils::Contours * ct = new Contours(aContour);
int pf = ct->perimeterFilter(MINCONTOUR_PERIMETER,MAXCONTOUR_PERIMETER);
int raf = ct->rectangularAspectFilter(CONTOUR_RECTANGULAR_MIN_RATIO, CONTOUR_RECTANGULAR_MAX_RATIO);
// int af = ct->areaFilter(MINCONTOUR_AREA,MAXCONTOUR_AREA);
int baf = ct->boxAreaFilter(BOXFILTER_TOLERANCE);
int hmf = ct->histogramMatchingFilter(src,testImageHistogram, HIST_H_BINS,HIST_S_BINS,HIST_MIN);
//apply filters
if( pf && raf && baf && hmf ){
//if passed filters
ct->printContour(3,cvScalar(127,127,0,0),
contourImage);
//get contour bounding box
boundingRect=cvBoundingRect(ct->getContour(),0);
cvRectangle(contourImage,cvPoint(boundingRect.x,boundingRect.y),
cvPoint(boundingRect.x+boundingRect.width,
boundingRect.y+boundingRect.height),
_GREEN,1,8,0);
//build garbage List
//printf(" c %d,%d\n",boundingRect.x,boundingRect.y);
utils::MinimalBoundingRectangle * r = new utils::MinimalBoundingRectangle(boundingRect.x,
boundingRect.y,boundingRect.width,boundingRect.height);
utils::Garbage * aGarbage = new utils::Garbage(r);
// printf("%d , %d - %d , %d\n",boundingRect.x,boundingRect.y,boundingRect.width,boundingRect.height);
garbages.push_back(aGarbage);
}
delete ct;
cvReleaseMemStorage( &aContour->storage );
contours=contours->h_next;
cont_index++;
}
// cvShowImage("output",contourImage);
// cvWaitKey(0);
delete h;
cvReleaseHist(&testImageHistogram);
//Image for thresholding
//cvReleaseMemStorage( &contours->storage );
cvReleaseImage(&threshImage);
cvReleaseImage(&equalizedImage);
cvReleaseImage(&morphImage);
cvReleaseImage(&smoothImage);
cvReleaseImage(&contourImage);
cvReleaseImage(&hsv);
cvReleaseImage(&h_plane);
cvReleaseImage(&s_plane);
cvReleaseImage(&v_plane);
return garbages;
}
CvBox2D CamShiftIris::track( IplImage* image, CvRect selection, bool isIris){
CamShiftIris camshift;
select_object1=1;
track_object1=-1;
origin1=cvPoint(0,0);
///////////////////////////////
int i, bin_w, c;
//frame = cvQueryFrame( capture );
//
// frame=cvCloneImage(image);
// if( !frame )
// return 0;
if( image ){
/* allocate all the buffers */
// image = cvCreateImage( cvGetSize(frame), 8, 3 );
// image->origin = frame->origin;
hsv1 = cvCreateImage( cvGetSize(image), 8, 3 );
h = cvCreateImage( cvGetSize(image), 8, 1 );
s = cvCreateImage( cvGetSize(image), 8, 1 );
v = cvCreateImage( cvGetSize(image), 8, 1);
hue1 = cvCreateImage( cvGetSize(image), 8, 1 );
mask1 = cvCreateImage( cvGetSize(image), 8, 1 );
backproject1 = cvCreateImage( cvGetSize(image), 8, 1 );
hist1= cvCreateHist( 1, &hdims1, CV_HIST_ARRAY, &hranges1, 1 );
histimg1 = cvCreateImage( cvSize(320,200), 8, 3 );
cvZero( histimg1 );
}
cvCvtColor( image, hsv1, CV_BGR2HSV );
///////////////////Equalize v in hsv///////////
cvSplit( hsv1, h, s, v, 0 );
cvEqualizeHist(v,v);
cvMerge(h,s,v,0,hsv1);
///////////////////Equalize v in hsv///////////
if( track_object1 !=0 ){
int _vmin1 = vmin1, _vmax1 = vmax1;
cvInRangeS( hsv1, cvScalar(0,smin1,MIN(_vmin1,_vmax1),0),
cvScalar(180,256,MAX(_vmin1,_vmax1),0), mask1 );
cvSplit( hsv1, hue1, 0, 0, 0 );
if( track_object1 < 0 ){
float max_val = 0.f;
cvSetImageROI( hue1, selection );
cvSetImageROI( mask1, selection );
cvCalcHist( &hue1, hist1, 0, mask1 );
cvGetMinMaxHistValue( hist1, 0, &max_val, 0, 0 );
cvConvertScale( hist1->bins, hist1->bins, max_val ? 255. / max_val : 0., 0 );
cvResetImageROI( hue1 );
cvResetImageROI( mask1 );
track_window1 = selection;
track_object1 = 1;
cvZero( histimg1 );
bin_w = histimg1->width / hdims1;
for( i = 0; i < hdims1; i++ )
{
int val = cvRound( cvGetReal1D(hist1->bins,i)*histimg1->height/255 );
CvScalar color = camshift.hsvrgb(i*180.f/hdims1);
cvRectangle( histimg1, cvPoint(i*bin_w,histimg1->height),
cvPoint((i+1)*bin_w,histimg1->height - val),
color, -1, 8, 0 );
}
}
cvCalcBackProject( &hue1, backproject1, hist1);
cvAnd( backproject1, mask1, backproject1, 0 );
try{
cvCamShift( backproject1, track_window1,
cvTermCriteria( CV_TERMCRIT_EPS | CV_TERMCRIT_ITER, 10, 1 ),
&track_comp1, &track_box1 );
}catch(...){
cvReleaseImage(&hsv1);
cvReleaseImage(&h);
cvReleaseImage(&s);
cvReleaseImage(&v);
cvReleaseImage(&hue1);
cvReleaseImage(&mask1);
cvReleaseImage(&backproject1);
cvReleaseHist(&hist1);
cvReleaseImage(&histimg1);
}
track_window1 = track_comp1.rect;
if( backproject1_mode )
cvCvtColor( backproject1, image, CV_GRAY2BGR );
if( !image->origin )
track_box1.angle = -track_box1.angle;
if(isIris)
cvEllipseBox( image, track_box1, CV_RGB(255,0,0), 3, CV_AA, 0 );
}
cvShowImage( "CamShift Tracking", image );
//cvShowImage( "Histogram", histimg1 );
// c = cvWaitKey(10);
// if( (char) c == 27 )
// cout<<"esc pressed";
// //return; //break;
// switch( (char) c ){
// case 'b':
// backproject1_mode ^= 1;
// break;
// case 'c':
// track_object1 = 0;
// cvZero( histimg1 );
// break;
// case 'h':
// show_hist1^= 1;
// if( !show_hist1)
// cvDestroyWindow( "Histogram" );
// else
// cvNamedWindow( "Histogram", 1 );
// break;
// default:
// ;
// }
//cvReleaseImage(&image);
cvReleaseImage(&hsv1);
cvReleaseImage(&h);
cvReleaseImage(&s);
cvReleaseImage(&v);
cvReleaseImage(&hue1);
cvReleaseImage(&mask1);
cvReleaseImage(&backproject1);
cvReleaseHist(&hist1);
cvReleaseImage(&histimg1);
return track_box1;
}
//命令模式： 程序名 文件名1 文件名2.。。。。。
int main( int argc, char** argv )
{
IplImage* frame;
if(argc<2)
return 0;
frame= cvLoadImage(argv[1],1);
//获取直方图
IplImage* r_plane = cvCreateImage(cvGetSize(frame),8,1);
IplImage* g_plane = cvCreateImage(cvGetSize(frame),8,1);
IplImage* b_plane = cvCreateImage(cvGetSize(frame),8,1);
IplImage* gray_plane = cvCreateImage(cvGetSize(frame),8,1);
cvCvtPixToPlane(frame,b_plane,g_plane,r_plane,0);
cvCvtColor(frame,gray_plane,CV_BGR2GRAY);
//直方图均衡化
//cvEqualizeHist(gray_plane,gray_plane);
int hist_size=256;
float range[] = {0,255};
float* ranges[]={range};
CvHistogram* r_hist = cvCreateHist(1,&hist_size,CV_HIST_ARRAY,ranges,1);
CvHistogram* g_hist = cvCreateHist(1,&hist_size,CV_HIST_ARRAY,ranges,1);
CvHistogram* b_hist = cvCreateHist(1,&hist_size,CV_HIST_ARRAY,ranges,1);
CvHistogram* gray_hist = cvCreateHist(1,&hist_size,CV_HIST_ARRAY,ranges,1);
//CvRect rect={0,0,1,frame->height};
//cvSetImageROI(b_plane,rect);
cvCalcHist( &r_plane, r_hist, 0, 0 );
cvCalcHist( &g_plane, g_hist, 0, 0 );
cvCalcHist( &b_plane, b_hist, 0, 0 );
cvCalcHist( &gray_plane, gray_hist, 0, 0 );
//归一成1.0为最高
cvNormalizeHist(gray_hist,1.0);
#if 1
//替代的功能相同的直方图均衡化算法
float F[256];
unsigned char G[256];
for (int i=0;i<hist_size;i++)
{
float s= cvQueryHistValue_1D(gray_hist,i) *255;
if(0==i)
F[i]=s;
else
F[i]=F[i-1]+s;
}
for (int i=0;i<hist_size;i++)
G[i]=(unsigned char)(int)F[i];
CvMat lookup=cvMat(1,256,CV_8U,G);
cvLUT(gray_plane,gray_plane,&lookup);
cvCalcHist( &gray_plane, gray_hist, 0, 0 );
//归一成1.0为最高
cvNormalizeHist(gray_hist,1.0);
#endif
//获取直方图的最大值和最大值处在的位置
float max_value = 0;
int max_idx=0;
cvGetMinMaxHistValue(gray_hist, NULL, &max_value, 0, &max_idx);
double k=0;
for (int i=0;i<hist_size;i++)
{
float bins= cvQueryHistValue_1D(gray_hist,i);
// if(i>=179 &&i<=200)
// k+=bins;
// printf("%d=%f\n",i,bins);
printf("%d=%f",i,bins);
for(int j=0;j<(int)(bins/0.0001);j++)
{
printf("-");
}
printf("\n");
}
printf("%f",k);
cvReleaseHist(&r_hist);
cvReleaseHist(&g_hist);
cvReleaseHist(&b_hist);
cvReleaseHist(&gray_hist);
cvSaveImage( argv[1], frame );
cvReleaseImage(&frame);
return 0;
}
