int CV_CannyTest::validate_test_results( int test_case_idx )
{
int code = CvTS::OK, nz0;
prepare_to_validation(test_case_idx);
double err = cvNorm(&test_mat[OUTPUT][0], &test_mat[REF_OUTPUT][0], CV_L1);
if( err == 0 )
goto _exit_;
if( err != cvRound(err) || cvRound(err)%255 != 0 )
{
ts->printf( CvTS::LOG, "Some of the pixels, produced by Canny, are not 0's or 255's; the difference is %g\n", err );
code = CvTS::FAIL_INVALID_OUTPUT;
goto _exit_;
}
nz0 = cvCountNonZero(&test_mat[REF_OUTPUT][0]);
err = (err/255/MAX(nz0,100))*100;
if( err > 1 )
{
ts->printf( CvTS::LOG, "Too high percentage of non-matching edge pixels = %g%%\n", err);
code = CvTS::FAIL_BAD_ACCURACY;
goto _exit_;
}
_exit_:
if( code < 0 )
ts->set_failed_test_info( code );
return code;
}
// Other Image Operations
//
//
int ofCvImage::countNonZeroInRegion( int x, int y, int w, int h ) const {
int count = 0;
cvSetImageROI( cvImage, cvRect(x,y,w,h) );
count = cvCountNonZero( cvImage );
cvResetImageROI( cvImage );
return count;
}
void get_hand_interval_2 (IplImage *body, int *interval)
{
CvMat *data, *labels, *means;
int count;
#define CLUSTERS 2
count = cvCountNonZero(body);
data = cvCreateMat(count, 1, CV_32FC1);
labels = cvCreateMat(count, 1, CV_32SC1);
means = cvCreateMat(CLUSTERS, 1, CV_32FC1);
fill_mat(body, data);
cvKMeans2(data, CLUSTERS, labels,
cvTermCriteria(CV_TERMCRIT_EPS + CV_TERMCRIT_ITER, 10, 10.0),
1, 0, 0, means, 0);
double tmp;
cvMinMaxLoc(body, &tmp, NULL, NULL, NULL, NULL);
interval[0] = tmp;
cvMinMaxLoc(means, &tmp, NULL, NULL, NULL, NULL);
interval[1] = tmp;
cvReleaseMat(&data);
cvReleaseMat(&labels);
}
int CV_MHIGlobalOrientTest::validate_test_results( int test_case_idx )
{
double ref_angle = cvTsCalcGlobalOrientation( &test_mat[INPUT][2], &test_mat[INPUT][1],
&test_mat[INPUT][0], timestamp, duration );
double err_level = get_success_error_level( test_case_idx, 0, 0 );
int code = CvTS::OK;
int nz = cvCountNonZero( test_array[INPUT][1] );
if( nz > 32 && !(min_angle - err_level <= angle &&
max_angle + err_level >= angle) &&
!(min_angle - err_level <= angle+360 &&
max_angle + err_level >= angle+360) )
{
ts->printf( CvTS::LOG, "The angle=%g is outside (%g,%g) range\n",
angle, min_angle - err_level, max_angle + err_level );
code = CvTS::FAIL_BAD_ACCURACY;
}
else if( fabs(angle - ref_angle) > err_level &&
fabs(360 - fabs(angle - ref_angle)) > err_level )
{
ts->printf( CvTS::LOG, "The angle=%g differs too much from reference value=%g\n",
angle, ref_angle );
code = CvTS::FAIL_BAD_ACCURACY;
}
if( code < 0 )
ts->set_failed_test_info( code );
return code;
}
//! 字符尺寸验证
bool verifyImgCharSizes(IplImage *r){
//Char sizes 45x90
float aspect = 45.0f / 90.0f;
float charAspect = (float)r->width / (float)r->height;
float error = 0.7;
float minHeight = 10;
float maxHeight = 35;
float minWidth = 8;
float maxWidth = 16;
//We have a different aspect ratio for number 1, and it can be ~0.2
float minAspect = 0.05;
float maxAspect = aspect + aspect*error;
//area of pixels
//float area = cvContourArea(r);
float area = cvCountNonZero(r);
//bb area
float bbArea = r->width*r->height;
//% of pixel in area
float percPixels = area / bbArea;
if (percPixels < 1 && charAspect > minAspect && charAspect < maxAspect && r->height >= minHeight && r->height < maxHeight && r->width>minWidth && r->width < maxWidth)
return true;
else
return false;
}
static void
kms_crowd_detector_roi_analysis (KmsCrowdDetector * crowddetector,
IplImage * low_speed_map, IplImage * high_speed_map)
{
int curve;
for (curve = 0; curve < crowddetector->priv->num_rois; curve++) {
int high_speed_points = 0;
int low_speed_points = 0;
int total_pixels_occupied = 0;
double occupation_percentage = 0.0;
CvRect container =
kms_crowd_detector_get_square_roi_contaniner (crowddetector, curve);
cvRectangle (low_speed_map, cvPoint (container.x, container.y),
cvPoint (container.x + container.width, container.y + container.height),
cvScalar (0, 255, 0, 0), 1, 8, 0);
cvSetImageROI (low_speed_map, container);
cvSetImageROI (high_speed_map, container);
low_speed_points = cvCountNonZero (low_speed_map);
high_speed_points = cvCountNonZero (high_speed_map);
cvResetImageROI (low_speed_map);
cvResetImageROI (high_speed_map);
total_pixels_occupied = high_speed_points + low_speed_points;
if (crowddetector->priv->rois_data[curve].n_pixels_roi > 0) {
occupation_percentage = ((double) total_pixels_occupied * 100 /
crowddetector->priv->rois_data[curve].n_pixels_roi);
} else {
occupation_percentage = 0.0;
}
kms_crowd_detector_roi_occup_analysis (crowddetector,
occupation_percentage,
crowddetector->priv->rois_data[curve].occupancy_num_frames_to_event,
crowddetector->priv->rois_data[curve].occupancy_level_min,
crowddetector->priv->rois_data[curve].occupancy_level_med,
crowddetector->priv->rois_data[curve].occupancy_level_max, curve);
kms_crowd_detector_roi_fluidity_analysis (crowddetector,
high_speed_points, low_speed_points,
crowddetector->priv->rois_data[curve].fluidity_num_frames_to_event,
crowddetector->priv->rois_data[curve].fluidity_level_min,
crowddetector->priv->rois_data[curve].fluidity_level_med,
crowddetector->priv->rois_data[curve].fluidity_level_max, curve);
}
}
// Function cvRefineForegroundMaskBySegm preforms FG post-processing based on segmentation
// (all pixels of the segment will be classified as FG if majority of pixels of the region are FG).
// parameters:
// segments - pointer to result of segmentation (for example MeanShiftSegmentation)
// bg_model - pointer to CvBGStatModel structure
CV_IMPL void cvRefineForegroundMaskBySegm(CvSeq* segments, CvBGStatModel* bg_model) {
IplImage* tmp_image = cvCreateImage(cvSize(bg_model->foreground->width, bg_model->foreground->height),
IPL_DEPTH_8U, 1);
for (; segments; segments = ((CvSeq*)segments)->h_next) {
CvSeq seq = *segments;
seq.v_next = seq.h_next = NULL;
cvZero(tmp_image);
cvDrawContours(tmp_image, &seq, CV_RGB(0, 0, 255), CV_RGB(0, 0, 255), 10, -1);
int num1 = cvCountNonZero(tmp_image);
cvAnd(tmp_image, bg_model->foreground, tmp_image);
int num2 = cvCountNonZero(tmp_image);
if (num2 > num1 * 0.5) {
cvDrawContours(bg_model->foreground, &seq, CV_RGB(0, 0, 255), CV_RGB(0, 0, 255), 10, -1);
} else {
cvDrawContours(bg_model->foreground, &seq, CV_RGB(0, 0, 0), CV_RGB(0, 0, 0), 10, -1);
}
}
cvReleaseImage(&tmp_image);
}
void cvRefineForegroundMaskBySegm(CvSeq* segments, IplImage* pFrImg)
{
IplImage* tmp_image = cvCreateImage(cvSize(pFrImg->width, pFrImg->height), IPL_DEPTH_8U, 1);
for (; segments; segments = ((CvSeq*)segments)->h_next)
{
CvSeq seq = *segments;
seq.v_next = seq.h_next = NULL;
cvZero(tmp_image);
cvDrawContours(tmp_image, &seq, CV_RGB(0, 0, 255), CV_RGB(0, 0, 255), 10, -1);
int num1 = cvCountNonZero(tmp_image);
cvAnd(tmp_image, pFrImg, tmp_image);
int num2 = cvCountNonZero(tmp_image);
if (num2 > num1*0.5)
cvDrawContours(pFrImg, &seq, CV_RGB(0, 0, 255), CV_RGB(0, 0, 255), 10, -1);
else
cvDrawContours(pFrImg, &seq, CV_RGB(0, 0, 0), CV_RGB(0, 0, 0), 10, -1);
}
cvReleaseImage(&tmp_image);
}
/**
* \brief Returns all nonzero points in image into x- and y-coordinate sets
*/
void getPointsFromImageHough(int *Px, int *Py, int *numPoints) {
unsigned char* rawROI = NULL; int ssize;
cvGetRawData(zeta, &rawROI, &ssize, NULL);
int num = cvCountNonZero(zeta); num = 0; int i,j;
for (j = max_of_2(0,yGuess - height); j < min_of_2(height, yGuess + height); j++){
for (i = max_of_2(0, xGuess - width); i < min_of_2(width, xGuess + width); i++){
if (rawROI[i+j*width] != 0){ Px[num] = i; Py[num] = j; num++; }
}
}
*numPoints = num;
}
void THISCLASS::OnStep() {
// Get the input image
IplImage* inputimage = mCore->mDataStructureImageGray.mImage;
if (! inputimage) {
AddError(wxT("No image on selected input."));
return;
}
// Calculate non-zero elements
if (mCalculateNonZero) {
int non_zero= cvCountNonZero(inputimage);
CommunicationMessage m(wxT("STATS_NONZERO"));
m.AddInt(non_zero);
mCore->mCommunicationInterface->Send(&m);
}
// Calculate sum
if (mCalculateSum) {
CvScalar sum= cvSum(inputimage);
CommunicationMessage m(wxT("STATS_SUM"));
m.AddDouble(sum.val[0]);
mCore->mCommunicationInterface->Send(&m);
}
// Calculate mean and standard deviation
if (mCalculateMeanStdDev) {
CvScalar mean;
CvScalar std_dev;
cvAvgSdv(inputimage, &mean, &std_dev, NULL);
CommunicationMessage m(wxT("STATS_MEANSTDDEV"));
m.AddDouble(mean.val[0]);
m.AddDouble(std_dev.val[0]);
mCore->mCommunicationInterface->Send(&m);
}
// Calculate min and max
if (mCalculateMinMax) {
double min_val;
double max_val;
cvMinMaxLoc(inputimage, &min_val, &max_val, NULL, NULL, NULL);
CommunicationMessage m(wxT("STATS_MINMAX"));
m.AddDouble(min_val);
m.AddDouble(max_val);
mCore->mCommunicationInterface->Send(&m);
}
// Set the display
DisplayEditor de(&mDisplayOutput);
if (de.IsActive()) {
de.SetMainImage(inputimage);
}
}
//--------------------------------------------------------------------------------
int ofxCvImage::countNonZeroInRegion( int x, int y, int w, int h ) {
//TODO: test this method
if (w == 0 || h == 0) return 0;
int count = 0;
// intersect the global ROI with the region to check
ofRectangle iRoi = getIntersectionROI( getROI(), ofRectangle(x,y,w,h) );
ofRectangle lastROI = getROI();
setROI(iRoi);
count = cvCountNonZero( cvImage );
setROI(lastROI);
return count;
}
//--------------------------------------------------------------------------------
int ofxCvImage::countNonZeroInRegion( int x, int y, int w, int h ) {
if( !bAllocated ){
ofLog(OF_LOG_ERROR, "in countNonZeroInRegion, need to allocate image first");
return 0;
}
//TODO: test this method
if (w == 0 || h == 0) return 0;
int count = 0;
// intersect the global ROI with the region to check
ofRectangle iRoi = getIntersectionROI( getROI(), ofRectangle(x,y,w,h) );
ofRectangle lastROI = getROI();
setROI(iRoi);
count = cvCountNonZero( cvImage );
setROI(lastROI);
return count;
}
static void
kms_crowd_detector_count_num_pixels_rois (KmsCrowdDetector * self)
{
int curve;
IplImage *src = cvCreateImage (cvSize (self->priv->actual_image->width,
self->priv->actual_image->height), IPL_DEPTH_8U, 1);
cvZero (src);
for (curve = 0; curve < self->priv->num_rois; curve++) {
cvFillConvexPoly (src, self->priv->curves[curve],
self->priv->n_points[curve], cvScalar (255, 255, 255, 0), 8, 0);
self->priv->rois_data[curve].n_pixels_roi = cvCountNonZero (src);
self->priv->rois_data[curve].actual_occupation_level = 0;
self->priv->rois_data[curve].potential_occupation_level = 0;
self->priv->rois_data[curve].num_frames_potential_occupancy_level = 0;
cvSetZero ((src));
}
cvReleaseImage (&src);
}
//--------------------------------------------------------------------------------
int ofxCvImage::countNonZeroInRegion( int x, int y, int w, int h ) {
if( !bAllocated ){
ofLogError("ofxCvImage") << "countNonZeroInRegion(): image not allocated";
return 0;
}
//TODO: test this method
if (w == 0 || h == 0) return 0;
int count = 0;
// intersect the global ROI with the region to check
ofRectangle iRoi = getIntersectionROI( getROI(), ofRectangle(x,y,w,h) );
ofRectangle lastROI = getROI();
setROI(iRoi);
count = cvCountNonZero( cvImage );
setROI(lastROI);
return count;
}
int ImageAnalysis::ImageDiff(IplImage* n, IplImage *p)
{
IplImage *n_gry,*prev_gry,*diff;
n_gry=cvCreateImage(cvGetSize(n),IPL_DEPTH_8U,1);
prev_gry=cvCreateImage(cvGetSize(p),IPL_DEPTH_8U,1);
diff=cvCreateImage(cvGetSize(n),IPL_DEPTH_8U,1);
cvCvtColor(n,n_gry,CV_RGB2GRAY);
cvCvtColor(p,prev_gry,CV_RGB2GRAY);
cvAbsDiff(prev_gry,n_gry,diff);
cvThreshold(diff,diff,45,255,CV_THRESH_TOZERO);
int percent=(cvCountNonZero(diff)*100)/(diff->height*diff->width);//calculate percent
cvReleaseImage(&n_gry);
cvReleaseImage(&prev_gry);
cvReleaseImage(&diff);
return percent;
}
/*!
* \brief Compute depth interval defined by the hand.
*
* Starting from the depth body image this function computes the depth
* interval related to the hand, these two depth values are later used
* as thresholds for the binarization procedure. This interval is
* calculated through a K-means clustering of the body image.
*
* \param[in] body depth image
* \param[out] hand depth min max values
*/
void get_hand_interval (IplImage *body, int *interval)
{
CvMat *data, *par, *means;
double var;
int min, count = cvCountNonZero(body);
data = cvCreateMat(count, 1, CV_32FC1);
par = cvCreateMat(count, 1, CV_8UC1);
means = cvCreateMat(K, 1, CV_32FC1);
fill_mat(body, data);
min = kmeans_clustering(data, means, par);
//var = get_cluster_var(data, par);
interval[0] = min;
interval[1] = (int)cvmGet(means, 0, 0); //- var;
cvReleaseMat(&data);
cvReleaseMat(&par);
cvReleaseMat(&means);
}
void my_mouse_callback( int event, int x, int y, int flags, void* param )
{
unsigned int hsv[3] = {};
for(k=0;k<channels;k++)
{
char c = 0;
if (k==0)
c = 'H';
else if (k==1)
c='S';
else
c='V';
hsv[k] = hsv_data[y*step+x*channels+k];
//printf("%c: %d\t", c, hsv[k]);
}
// Save <H,S,V>
if (event == CV_EVENT_LBUTTONDOWN)
{
hues[recorded_count] = hsv[0];
sats[recorded_count] = hsv[1];
vals[recorded_count] = hsv[2];
++recorded_count;
}
// Draw new image with whites in places that match
else if (event == CV_EVENT_RBUTTONDOWN)
{
h_min = getMinFromArray(hues,recorded_count);
s_min = getMinFromArray(sats,recorded_count);
v_min = getMinFromArray(vals,recorded_count);
h_max = getMaxFromArray(hues,recorded_count);
s_max = getMaxFromArray(sats,recorded_count);
v_max = getMaxFromArray(vals,recorded_count);
IplImage* img = cvCreateImage(cvSize(width,height), IPL_DEPTH_8U, 1);
cvInRangeS(img_hsv,cvScalar(h_min,s_min,v_min,0),cvScalar(h_max,s_max,v_max,0),img);
int count = cvCountNonZero(img);
printf("count: %d\n", count);
cvNamedWindow("secondwindow",CV_GUI_EXPANDED);
cvShowImage("secondwindow",img);
key = 0;
while (key != 's')
{
key = cvWaitKey(0);
}
memset(hues,0,recorded_count);
memset(sats,0,recorded_count);
memset(vals,0,recorded_count);
recorded_count=0;
cvReleaseImage(&img);
cvDestroyWindow("secondwindow");
}
//printf("\n");
}
/*-------------------------------------------------------------------------------------*/
void icvComputeProjectMatrixStatus(CvMat *objPoints4D,CvMat *points2,CvMat *status, CvMat *projMatr)
{
/* Compute number of good points */
int num = cvCountNonZero(status);
/* Create arrays */
CvMat *objPoints = 0;
objPoints = cvCreateMat(4,num,CV_64F);
CvMat *points2D = 0;
points2D = cvCreateMat(2,num,CV_64F);
int currVis = 0;
int i;
#if 1
FILE *file;
file = fopen("d:\\test\\projStatus.txt","w");
#endif
int totalNum = objPoints4D->cols;
for( i = 0; i < totalNum; i++ )
{
fprintf(file,"%d (%d) ",i,status->data.ptr[i]);
if( status->data.ptr[i] )
{
#if 1
double X,Y,Z,W;
double x,y;
X = cvmGet(objPoints4D,0,i);
Y = cvmGet(objPoints4D,1,i);
Z = cvmGet(objPoints4D,2,i);
W = cvmGet(objPoints4D,3,i);
x = cvmGet(points2,0,i);
y = cvmGet(points2,1,i);
fprintf(file,"%d (%lf %lf %lf %lf) - (%lf %lf)",i,X,Y,Z,W,x,y );
#endif
cvmSet(objPoints,0,currVis,cvmGet(objPoints4D,0,i));
cvmSet(objPoints,1,currVis,cvmGet(objPoints4D,1,i));
cvmSet(objPoints,2,currVis,cvmGet(objPoints4D,2,i));
cvmSet(objPoints,3,currVis,cvmGet(objPoints4D,3,i));
cvmSet(points2D,0,currVis,cvmGet(points2,0,i));
cvmSet(points2D,1,currVis,cvmGet(points2,1,i));
currVis++;
}
fprintf(file,"\n");
}
#if 1
fclose(file);
#endif
icvComputeProjectMatrix(objPoints,points2D,projMatr);
/* Free allocated memory */
cvReleaseMat(&objPoints);
cvReleaseMat(&points2D);
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
CvMat *tgso (CvMat &tmap, int ntex, double sigma, double theta, CvMat &tsim, int useChi2) {
CvMat *roundTmap=cvCreateMat(tmap.rows,tmap.cols,CV_32FC1);
CvMat *comp=cvCreateMat(tmap.rows,tmap.cols,CV_32FC1);
for (int i=0;i<tmap.rows;i++)
for (int j=0;j<tmap.cols;j++)
cvSetReal2D(roundTmap,i,j,cvRound(cvGetReal2D(&tmap,i,j)));
cvSub(&tmap,roundTmap,comp);
if (cvCountNonZero(comp)) {
printf("texton labels not integral");
cvReleaseMat(&roundTmap);
cvReleaseMat(&comp);
exit(1);
}
double min,max;
cvMinMaxLoc(&tmap,&min,&max);
if (min<1 && max>ntex) {
char *msg=new char[50];
printf(msg,"texton labels out of range [1,%d]",ntex);
cvReleaseMat(&roundTmap);
cvReleaseMat(&comp);
exit(1);
}
cvReleaseMat(&roundTmap);
cvReleaseMat(&comp);
double wr=floor(sigma); //sigma=radius (Leo)
CvMat *x=cvCreateMat(1,wr-(-wr)+1, CV_64FC1);
CvMat *y=cvCreateMat(wr-(-wr)+1,1, CV_64FC1);
CvMat *u=cvCreateMat(wr-(-wr)+1,wr-(-wr)+1, CV_64FC1);
CvMat *v=cvCreateMat(wr-(-wr)+1,wr-(-wr)+1, CV_64FC1);
CvMat *gamma=cvCreateMat(u->rows,v->rows, CV_64FC1);
// Set x,y directions
for (int j=-wr;j<=wr;j++) {
cvSetReal2D(x,0,(j+wr),j);
cvSetReal2D(y,(j+wr),0,j);
}
// Set u,v, meshgrids
for (int i=0;i<u->rows;i++) {
cvRepeat(x,u);
cvRepeat(y,v);
}
// Compute the gamma matrix from the grid
for (int i=0;i<u->rows;i++)
for (int j=0;j<u->cols;j++)
cvSetReal2D(gamma,i,j,atan2(cvGetReal2D(v,i,j),cvGetReal2D(u,i,j)));
cvReleaseMat(&x);
cvReleaseMat(&y);
CvMat *sum=cvCreateMat(u->rows,u->cols, CV_64FC1);
cvMul(u,u,u);
cvMul(v,v,v);
cvAdd(u,v,sum);
CvMat *mask=cvCreateMat(u->rows,u->cols, CV_8UC1);
cvCmpS(sum,sigma*sigma,mask,CV_CMP_LE);
cvConvertScale(mask,mask,1.0/255);
cvSetReal2D(mask,wr,wr,0);
int count=cvCountNonZero(mask);
cvReleaseMat(&u);
cvReleaseMat(&v);
cvReleaseMat(&sum);
CvMat *sub=cvCreateMat(mask->rows,mask->cols, CV_64FC1);
CvMat *side=cvCreateMat(mask->rows,mask->cols, CV_8UC1);
cvSubS(gamma,cvScalar(theta),sub);
cvReleaseMat(&gamma);
for (int i=0;i<mask->rows;i++){
for (int j=0;j<mask->cols;j++) {
double n=cvmGet(sub,i,j);
double n_mod = n-floor(n/(2*M_PI))*2*M_PI;
cvSetReal2D(side,i,j, 1 + int(n_mod < M_PI));
}
}
cvMul(side,mask,side);
cvReleaseMat(&sub);
cvReleaseMat(&mask);
CvMat *lmask=cvCreateMat(side->rows,side->cols, CV_8UC1);
CvMat *rmask=cvCreateMat(side->rows,side->cols, CV_8UC1);
cvCmpS(side,1,lmask,CV_CMP_EQ);
cvCmpS(side,2,rmask,CV_CMP_EQ);
int count1=cvCountNonZero(lmask), count2=cvCountNonZero(rmask);
if (count1 != count2) {
printf("Bug: imbalance\n");
}
CvMat *rlmask=cvCreateMat(side->rows,side->cols, CV_32FC1);
CvMat *rrmask=cvCreateMat(side->rows,side->cols, CV_32FC1);
cvConvertScale(lmask,rlmask,1.0/(255*count)*2);
cvConvertScale(rmask,rrmask,1.0/(255*count)*2);
cvReleaseMat(&lmask);
cvReleaseMat(&rmask);
cvReleaseMat(&side);
int h=tmap.rows;
int w=tmap.cols;
CvMat *d = cvCreateMat(h*w,ntex,CV_32FC1);
CvMat *coltemp = cvCreateMat(h*w,1,CV_32FC1);
CvMat *tgL = cvCreateMat(h,w, CV_32FC1);
CvMat *tgR = cvCreateMat(h,w, CV_32FC1);
CvMat *temp = cvCreateMat(h,w,CV_8UC1);
CvMat *im = cvCreateMat(h,w, CV_32FC1);
CvMat *sub2 = cvCreateMat(h,w,CV_32FC1);
CvMat *sub2t = cvCreateMat(w,h,CV_32FC1);
CvMat *prod = cvCreateMat(h*w,ntex,CV_32FC1);
CvMat reshapehdr,*reshape;
CvMat* tgL_pad = cvCreateMat(h+rlmask->rows-1,w+rlmask->cols-1,CV_32FC1);
CvMat* tgR_pad = cvCreateMat(h+rlmask->rows-1,w+rlmask->cols-1,CV_32FC1);
CvMat* im_pad = cvCreateMat(h+rlmask->rows-1,w+rlmask->cols-1,CV_32FC1);
CvMat *tg=cvCreateMat(h,w,CV_32FC1);
cvZero(tg);
if (useChi2 == 1){
CvMat* temp_add1 = cvCreateMat(h,w,CV_32FC1);
for (int i=0;i<ntex;i++) {
cvCmpS(&tmap,i+1,temp,CV_CMP_EQ);
cvConvertScale(temp,im,1.0/255);
cvCopyMakeBorder(tgL,tgL_pad,cvPoint((rlmask->cols-1)/2,(rlmask->rows-1)/2),IPL_BORDER_CONSTANT);
cvCopyMakeBorder(tgR,tgR_pad,cvPoint((rlmask->cols-1)/2,(rlmask->rows-1)/2),IPL_BORDER_CONSTANT);
cvCopyMakeBorder(im,im_pad,cvPoint((rlmask->cols-1)/2,(rlmask->rows-1)/2),IPL_BORDER_CONSTANT);
cvFilter2D(im_pad,tgL_pad,rlmask,cvPoint((rlmask->cols-1)/2,(rlmask->rows-1)/2));
cvFilter2D(im_pad,tgR_pad,rrmask,cvPoint((rlmask->cols-1)/2,(rlmask->rows-1)/2));
cvGetSubRect(tgL_pad,tgL,cvRect((rlmask->cols-1)/2,(rlmask->rows-1)/2,tgL->cols,tgL->rows));
cvGetSubRect(tgR_pad,tgR,cvRect((rlmask->cols-1)/2,(rlmask->rows-1)/2,tgR->cols,tgR->rows));
cvSub(tgL,tgR,sub2);
cvPow(sub2,sub2,2.0);
cvAdd(tgL,tgR,temp_add1);
cvAddS(temp_add1,cvScalar(0.0000000001),temp_add1);
cvDiv(sub2,temp_add1,sub2);
cvAdd(tg,sub2,tg);
}
cvScale(tg,tg,0.5);
cvReleaseMat(&temp_add1);
}
else{// if not chi^2
for (int i=0;i<ntex;i++) {
cvCmpS(&tmap,i+1,temp,CV_CMP_EQ);
cvConvertScale(temp,im,1.0/255);
cvCopyMakeBorder(tgL,tgL_pad,cvPoint((rlmask->cols-1)/2,(rlmask->rows-1)/2),IPL_BORDER_CONSTANT);
cvCopyMakeBorder(tgR,tgR_pad,cvPoint((rlmask->cols-1)/2,(rlmask->rows-1)/2),IPL_BORDER_CONSTANT);
cvCopyMakeBorder(im,im_pad,cvPoint((rlmask->cols-1)/2,(rlmask->rows-1)/2),IPL_BORDER_CONSTANT);
cvFilter2D(im_pad,tgL_pad,rlmask,cvPoint((rlmask->cols-1)/2,(rlmask->rows-1)/2));
cvFilter2D(im_pad,tgR_pad,rrmask,cvPoint((rlmask->cols-1)/2,(rlmask->rows-1)/2));
cvGetSubRect(tgL_pad,tgL,cvRect((rlmask->cols-1)/2,(rlmask->rows-1)/2,tgL->cols,tgL->rows));
cvGetSubRect(tgR_pad,tgR,cvRect((rlmask->cols-1)/2,(rlmask->rows-1)/2,tgR->cols,tgR->rows));
cvSub(tgL,tgR,sub2);
cvAbs(sub2,sub2);
cvTranspose(sub2,sub2t);
reshape=cvReshape(sub2t,&reshapehdr,0,h*w);
cvGetCol(d,coltemp,i);
cvCopy(reshape,coltemp);
}
cvMatMul(d,&tsim,prod);
cvMul(prod,d,prod);
CvMat *sumcols=cvCreateMat(h*w,1,CV_32FC1);
cvSetZero(sumcols);
for (int i=0;i<prod->cols;i++) {
cvGetCol(prod,coltemp,i);
cvAdd(sumcols,coltemp,sumcols);
}
reshape=cvReshape(sumcols,&reshapehdr,0,w);
cvTranspose(reshape,tg);
cvReleaseMat(&sumcols);
}
//Smooth the gradient now!!
tg=fitparab(*tg,sigma,sigma/4,theta);
cvMaxS(tg,0,tg);
cvReleaseMat(&im_pad);
cvReleaseMat(&tgL_pad);
cvReleaseMat(&tgR_pad);
cvReleaseMat(&rlmask);
cvReleaseMat(&rrmask);
cvReleaseMat(&im);
cvReleaseMat(&tgL);
cvReleaseMat(&tgR);
cvReleaseMat(&temp);
cvReleaseMat(&coltemp);
cvReleaseMat(&sub2);
cvReleaseMat(&sub2t);
cvReleaseMat(&d);
cvReleaseMat(&prod);
return tg;
}
int main(int argc, char *argv[])
{
string dir = string(dirPrefix);
vector<string> files = vector<string>();
getdir(dir,files);
// for (unsigned int i = 0;i < files.size();i++) {
// cout << files[i] << endl;
// }
// return 0;
// vector<float> joint_angles;
// vector<float> t_matrix;
pcl::PointCloud<pcl::PointXYZ> cloud;
pcl::PointCloud<pcl::Normal> normals;
vector<int> indices;
int normals_k_neighbors = 50;
double minVal, maxVal;
vector<CvMat*> matXYZ, matNorms;
vector<Rect> rects;
// cvMinMaxLoc(mat[2], &minVal, &maxVal, NULL, NULL, mat[4]); // Z-axis
vector<float> hist;
vector<float> feature_vec;
vector<float> vecZ, vecNormZ, vecCurv;
IplImage *m, *m2;
CvMat *mm, *mmask; CvMat tmp, tmp2;
float binWidth;
int nBins = 9;
for (int nFile = 125; nFile < files.size(); nFile++) {
loadPCDFile((dir+"pcd"+files[nFile].substr(4,4)+".txt").c_str(),cloud,indices);
calculateNormals(cloud,normals,normals_k_neighbors);
matXYZ = convertXYZToCvMat(indices, cloud);
matNorms = convertNormalsToCvMat(indices, normals, true);
loadRects(rects,(dir+files[nFile].substr(0,8)+"_pos.txt").c_str(),(dir+files[nFile].substr(0,8)+"_pos.txt").c_str());
// loadAnglesFile(anglesFile,joint_angles,t_matrix);
// for (int i=0;i<rects.size();i++) {
// cout << rects[i] << endl;
// }
for (int rectNum = 0;rectNum < rects.size(); rectNum++) {
cout << (rects[rectNum].isPos?1:0) << " qid:" << (nFile+1);
// For z values
binWidth = 0.05;
extractRect(matXYZ[2], rects[rectNum],m);
mm = cvGetMat(m, &tmp);
extractRect(matXYZ[3], rects[rectNum],m2);
mmask = cvGetMat(m2, &tmp2);
// Need to erode the mask due to interpolation errors from rotating
cvErode(mmask,mmask);
if (cvCountNonZero(mmask) == 0) {
feature_vec.clear();
feature_vec.resize(3*nBins*3);
for (int i=0;i<feature_vec.size();i++)
feature_vec[i] = 0;
for (int i=0;i<feature_vec.size();i++) {
printf(" %d:%.3f",i+1,feature_vec[i]);
// if (i%nBins==nBins-1) printf("\n");
}
printf("\n");
continue;
}
// printf("w: %d, h: %d, t: %d\n",mm->width,mm->height,mm->width*mm->height);
// cvMinMaxLoc(mm, &minVal, &maxVal, NULL, NULL, mmask); // Z-axis
// printf("min: %f, max: %f\n",minVal,maxVal);
// Get the vector for
getHistogramFeatureVectorDirect(mm,nBins,binWidth,mmask,vecZ,true);
cvReleaseImage(&m);
cvReleaseImage(&m2);
// For normZ values
binWidth = 0.1;
extractRect(matNorms[2], rects[rectNum],m);
mm = cvGetMat(m, &tmp);
extractRect(matNorms[4], rects[rectNum],m2);
mmask = cvGetMat(m2, &tmp2);
// Need to erode the mask due to interpolation errors from rotating
cvErode(mmask,mmask);
// printf("w: %d, h: %d, t: %d\n",mm->width,mm->height,mm->width*mm->height);
// cvMinMaxLoc(mm, &minVal, &maxVal, NULL, NULL, mmask); // Z-axis
// printf("min: %f, max: %f\n",minVal,maxVal);
// Get the vector for
getHistogramFeatureVectorDirect(mm,nBins,binWidth,mmask,vecNormZ,false);
cvReleaseImage(&m);
cvReleaseImage(&m2);
// For curv values
binWidth = 0.01;
extractRect(matNorms[3], rects[rectNum],m);
mm = cvGetMat(m, &tmp);
extractRect(matNorms[4], rects[rectNum],m2);
mmask = cvGetMat(m2, &tmp2);
// Need to erode the mask due to interpolation errors from rotating
cvErode(mmask,mmask);
// printf("w: %d, h: %d, t: %d\n",mm->width,mm->height,mm->width*mm->height);
// cvMinMaxLoc(mm, &minVal, &maxVal, NULL, NULL, mmask); // Z-axis
// printf("min: %f, max: %f\n",minVal,maxVal);
// Get the vector for
getHistogramFeatureVectorDirect(mm,nBins,binWidth,mmask,vecCurv,false);
cvReleaseImage(&m);
cvReleaseImage(&m2);
feature_vec.clear();
feature_vec.resize(3*nBins*3);
for (int i=0;i<nBins*3;i++) {
feature_vec[i] = vecZ[i];
feature_vec[i+nBins*3] = vecNormZ[i];
feature_vec[i+nBins*6] = vecCurv[i];
}
// feature_vec.insert(feature_vec.end(), vecZ.begin(), vecZ.end());
// feature_vec.insert(feature_vec.end(), vecNormZ.begin(), vecNormZ.end());
// feature_vec.insert(feature_vec.end(), vecCurv.begin(), vecCurv.end());
for (int i=0;i<feature_vec.size();i++) {
printf(" %d:%.3f",i+1,feature_vec[i]);
// if (i%nBins==nBins-1) printf("\n");
}
printf("\n");
}
}
return 0;
/*
mat = convertNormalsToCvMat(indices, normals);
//vector<CvMat*> mat = convertXYZToCvMat(indices, cloud);
cvNamedWindow("Results", CV_WINDOW_AUTOSIZE);
for (int i=0;i<mat.size();i++) {
cvMinMaxLoc(mat[i], &minVal, &maxVal);
printf("min: %g max: %g\n",minVal,maxVal);
cvConvertScale(mat[i],mat[i],1.0/(maxVal-minVal),-minVal/(maxVal-minVal));
cvShowImage("Results", mat[i]);
cvWaitKey(0);
}
mat = convertXYZToCvMat(indices, cloud);
for (int i=0;i<mat.size();i++) {
cvMinMaxLoc(mat[i], &minVal, &maxVal);
printf("min: %g max: %g\n",minVal,maxVal);
cvConvertScale(mat[i],mat[i],1.0/(maxVal-minVal),-minVal/(maxVal-minVal));
cvShowImage("Results", mat[i]);
cvWaitKey(0);
}
printf("Global frame:\n");
transform_to_global_frame(cloud,t_matrix);
calculateNormals(cloud,normals,normals_k_neighbors);
for (int i=0;i<10;i++) {
printf("%d %.3f %.3f %.3f %.3f %.3f %.3f %.3f\n",
indices[i],cloud.points[i].x,cloud.points[i].y,cloud.points[i].z,
normals.points[i].normal[0],normals.points[i].normal[1],normals.points[i].normal[2],
normals.points[i].curvature);
}
mat = convertNormalsToCvMat(indices, normals);
//vector<CvMat*> mat = convertXYZToCvMat(indices, cloud);
cvNamedWindow("Results", CV_WINDOW_AUTOSIZE);
for (int i=0;i<mat.size();i++) {
cvMinMaxLoc(mat[i], &minVal, &maxVal);
printf("min: %g max: %g\n",minVal,maxVal);
cvConvertScale(mat[i],mat[i],1.0/(maxVal-minVal),-minVal/(maxVal-minVal));
cvShowImage("Results", mat[i]);
cvWaitKey(0);
}
mat = convertXYZToCvMat(indices, cloud);
for (int i=0;i<mat.size();i++) {
cvMinMaxLoc(mat[i], &minVal, &maxVal);
printf("min: %g max: %g\n",minVal,maxVal);
cvConvertScale(mat[i],mat[i],1.0/(maxVal-minVal),-minVal/(maxVal-minVal));
cvShowImage("Results", mat[i]);
cvWaitKey(0);
}*/
//cvReleaseImage(&img);
//cvDestroyWindow("Results");
//return 0;
}
static GstFlowReturn gst_gcs_transform_ip(GstBaseTransform * btrans, GstBuffer * gstbuf)
{
GstGcs *gcs = GST_GCS (btrans);
GST_GCS_LOCK (gcs);
//////////////////////////////////////////////////////////////////////////////
// get image data from the input, which is RGBA or BGRA
gcs->pImageRGBA->imageData = (char*)GST_BUFFER_DATA(gstbuf);
cvSplit(gcs->pImageRGBA, gcs->pImgCh1, gcs->pImgCh2, gcs->pImgCh3, gcs->pImgChX );
cvCvtColor(gcs->pImageRGBA, gcs->pImgRGB, CV_BGRA2BGR);
//////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////MOTION CUES INTEGR////
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
// apply step 1. filtering using bilateral filter. Cannot happen in-place => scratch
cvSmooth(gcs->pImgRGB, gcs->pImgScratch, CV_BILATERAL, 3, 50, 3, 0);
// create GRAY image
cvCvtColor(gcs->pImgScratch, gcs->pImgGRAY, CV_BGR2GRAY);
// Frame difference the GRAY and the previous one
// not intuitive: first smooth frames, then
cvCopy( gcs->pImgGRAY, gcs->pImgGRAY_copy, NULL);
cvCopy( gcs->pImgGRAY_1, gcs->pImgGRAY_1copy, NULL);
get_frame_difference( gcs->pImgGRAY_copy, gcs->pImgGRAY_1copy, gcs->pImgGRAY_diff);
cvErode( gcs->pImgGRAY_diff, gcs->pImgGRAY_diff, NULL, 3);
cvDilate( gcs->pImgGRAY_diff, gcs->pImgGRAY_diff, NULL, 3);
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
// ghost mapping
gcs->dstTri[0].x = gcs->facepos.x - gcs->facepos.width/2 ;
gcs->dstTri[0].y = gcs->facepos.y - gcs->facepos.height/2;
gcs->dstTri[1].x = gcs->facepos.x - gcs->facepos.width/2;
gcs->dstTri[1].y = gcs->facepos.y + gcs->facepos.height/2;
gcs->dstTri[2].x = gcs->facepos.x + gcs->facepos.width/2;
gcs->dstTri[2].y = gcs->facepos.y + gcs->facepos.height/2;
if( gcs->ghostfilename){
cvGetAffineTransform( gcs->srcTri, gcs->dstTri, gcs->warp_mat );
cvWarpAffine( gcs->cvGhostBwResized, gcs->cvGhostBwAffined, gcs->warp_mat );
}
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
// GrabCut algorithm preparation and running
gcs->facepos.x = gcs->facepos.x - gcs->facepos.width/2;
gcs->facepos.y = gcs->facepos.y - gcs->facepos.height/2;
// create an IplImage with the skin colour pixels as 255
compose_skin_matrix(gcs->pImgRGB, gcs->pImg_skin);
// And the skin pixels with the movement mask
cvAnd( gcs->pImg_skin, gcs->pImgGRAY_diff, gcs->pImgGRAY_diff);
//cvErode( gcs->pImgGRAY_diff, gcs->pImgGRAY_diff, cvCreateStructuringElementEx(5, 5, 3, 3, CV_SHAPE_RECT,NULL), 1);
cvDilate(gcs->pImgGRAY_diff, gcs->pImgGRAY_diff, cvCreateStructuringElementEx(7,7, 5,5, CV_SHAPE_RECT,NULL), 2);
cvErode( gcs->pImgGRAY_diff, gcs->pImgGRAY_diff, cvCreateStructuringElementEx(5,5, 3,3, CV_SHAPE_RECT,NULL), 2);
// if there is alpha==all 1's coming in, then we ignore it: prevents from no vibe before us
if((0.75*(gcs->width * gcs->height) <= cvCountNonZero(gcs->pImgChX)))
cvZero(gcs->pImgChX);
// OR the input Alpha
cvOr( gcs->pImgChX, gcs->pImgGRAY_diff, gcs->pImgGRAY_diff);
//////////////////////////////////////////////////////////////////////////////
// try to consolidate a single mask from all the sub-patches
cvDilate(gcs->pImgGRAY_diff, gcs->pImgGRAY_diff, cvCreateStructuringElementEx(7,7, 5,5, CV_SHAPE_RECT,NULL), 3);
cvErode( gcs->pImgGRAY_diff, gcs->pImgGRAY_diff, cvCreateStructuringElementEx(5,5, 3,3, CV_SHAPE_RECT,NULL), 4);
//////////////////////////////////////////////////////////////////////////////
// use either Ghost or boxes-model to create a PR foreground starting point in gcs->grabcut_mask
if( gcs->ghostfilename)
compose_grabcut_seedmatrix3(gcs->grabcut_mask, gcs->cvGhostBwAffined, gcs->pImgGRAY_diff );
else{
// toss it all to the bbox creation function, together with the face position and size
compose_grabcut_seedmatrix2(gcs->grabcut_mask, gcs->facepos, gcs->pImgGRAY_diff, gcs->facefound );
}
//////////////////////////////////////////////////////////////////////////////
#ifdef KMEANS
gcs->num_clusters = 18; // keep it even to simplify integer arithmetics
cvCopy(gcs->pImgRGB, gcs->pImgRGB_kmeans, NULL);
posterize_image(gcs->pImgRGB_kmeans);
create_kmeans_clusters(gcs->pImgRGB_kmeans, gcs->kmeans_points, gcs->kmeans_clusters,
gcs->num_clusters, gcs->num_samples);
adjust_bodybbox_w_clusters(gcs->grabcut_mask, gcs->pImgRGB_kmeans, gcs->num_clusters, gcs->facepos);
#endif //KMEANS
//////////////////////////////////////////////////////////////////////////////
if( gcs->debug < 70)
run_graphcut_iteration( &(gcs->GC), gcs->pImgRGB, gcs->grabcut_mask, &gcs->bbox_prev);
// get a copy of GRAY for the next iteration
cvCopy(gcs->pImgGRAY, gcs->pImgGRAY_1, NULL);
//////////////////////////////////////////////////////////////////////////////
// if we want to display, just overwrite the output
if( gcs->display ){
int outputimage = gcs->debug;
switch( outputimage ){
case 1: // output the GRAY difference
cvCvtColor( gcs->pImgGRAY_diff, gcs->pImgRGB, CV_GRAY2BGR );
break;
case 50:// Ghost remapped
cvCvtColor( gcs->cvGhostBwAffined, gcs->pImgRGB, CV_GRAY2BGR );
break;
case 51:// Ghost applied
cvAnd( gcs->cvGhostBwAffined, gcs->pImgGRAY, gcs->pImgGRAY, NULL );
cvCvtColor( gcs->pImgGRAY, gcs->pImgRGB, CV_GRAY2BGR );
break;
case 60:// Graphcut
cvAndS(gcs->grabcut_mask, cvScalar(1), gcs->grabcut_mask, NULL); // get only FG
cvConvertScale( gcs->grabcut_mask, gcs->grabcut_mask, 127.0);
cvCvtColor( gcs->grabcut_mask, gcs->pImgRGB, CV_GRAY2BGR );
break;
case 61:// Graphcut applied on input/output image
cvAndS(gcs->grabcut_mask, cvScalar(1), gcs->grabcut_mask, NULL); // get only FG, PR_FG
cvConvertScale( gcs->grabcut_mask, gcs->grabcut_mask, 255.0);
cvAnd( gcs->grabcut_mask, gcs->pImgGRAY, gcs->pImgGRAY, NULL);
cvCvtColor( gcs->pImgGRAY, gcs->pImgRGB, CV_GRAY2BGR );
cvRectangle(gcs->pImgRGB, cvPoint(gcs->bbox_now.x, gcs->bbox_now.y),
cvPoint(gcs->bbox_now.x + gcs->bbox_now.width, gcs->bbox_now.y+gcs->bbox_now.height),
cvScalar(127,0.0), 1, 8, 0 );
break;
case 70:// bboxes
cvZero( gcs->pImgGRAY );
cvMul( gcs->grabcut_mask, gcs->grabcut_mask, gcs->pImgGRAY, 40.0 );
cvCvtColor( gcs->pImgGRAY, gcs->pImgRGB, CV_GRAY2BGR );
break;
case 71:// bboxes applied on the original image
cvAndS(gcs->grabcut_mask, cvScalar(1), gcs->grabcut_mask, NULL); // get only FG, PR_FG
cvMul( gcs->grabcut_mask, gcs->pImgGRAY, gcs->pImgGRAY, 1.0 );
cvCvtColor( gcs->pImgGRAY, gcs->pImgRGB, CV_GRAY2BGR );
break;
case 72: // input alpha channel mapped to output
cvCvtColor( gcs->pImgChX, gcs->pImgRGB, CV_GRAY2BGR );
break;
#ifdef KMEANS
case 80:// k-means output
cvCopy(gcs->pImgRGB_kmeans, gcs->pImgRGB, NULL);
break;
case 81:// k-means output filtered with bbox/ghost mask
cvSplit(gcs->pImgRGB_kmeans, gcs->pImgCh1, gcs->pImgCh2, gcs->pImgCh3, NULL );
cvAndS(gcs->grabcut_mask, cvScalar(1), gcs->grabcut_mask, NULL); // get FG and PR_FG
cvConvertScale( gcs->grabcut_mask, gcs->grabcut_mask, 255.0); // scale any to 255.
cvAnd( gcs->grabcut_mask, gcs->pImgCh1, gcs->pImgCh1, NULL );
cvAnd( gcs->grabcut_mask, gcs->pImgCh2, gcs->pImgCh2, NULL );
cvAnd( gcs->grabcut_mask, gcs->pImgCh3, gcs->pImgCh3, NULL );
cvMerge( gcs->pImgCh1, gcs->pImgCh2, gcs->pImgCh3, NULL, gcs->pImgRGB);
break;
#endif //KMEANS
default:
break;
}
}
//////////////////////////////////////////////////////////////////////////////
// copy anyhow the fg/bg to the alpha channel in the output image alpha ch
cvSplit(gcs->pImgRGB, gcs->pImgCh1, gcs->pImgCh2, gcs->pImgCh3, NULL );
cvAndS(gcs->grabcut_mask, cvScalar(1), gcs->grabcut_mask, NULL); // get only FG and possible FG
cvConvertScale( gcs->grabcut_mask, gcs->grabcut_mask, 255.0);
gcs->pImgChA->imageData = (char*)gcs->grabcut_mask->data.ptr;
cvMerge( gcs->pImgCh1, gcs->pImgCh2, gcs->pImgCh3, gcs->pImgChA, gcs->pImageRGBA);
gcs->numframes++;
GST_GCS_UNLOCK (gcs);
return GST_FLOW_OK;
}
void PlateFinder::ImageRestoration(IplImage *src)
{
int w = src->width;
int h = src->height;
IplImage *mImg = cvCreateImage(cvSize(w/2, h/2), IPL_DEPTH_8U, 1); // Anh su dung cho bien doi hinh thai hoc
IplImage *src_pyrdown = cvCreateImage (cvSize(w/2, h/2), IPL_DEPTH_8U, 1);
IplImage *tmp = cvCreateImage (cvSize(w/2, h/2), IPL_DEPTH_8U, 1);
IplImage *thresholed = cvCreateImage (cvSize(w/2, h/2), IPL_DEPTH_8U, 1); // Anh nhi phan voi nguong
IplImage *mini_thresh = cvCreateImage (cvSize(w/2, h/2), IPL_DEPTH_8U, 1);
IplImage *dst = cvCreateImage (cvSize(w/2, h/2), IPL_DEPTH_8U, 1); // Anh lam ro vung bien so
cvPyrDown (src, src_pyrdown);
cvMorphologyEx(src_pyrdown, mImg, tmp, S2, CV_MOP_BLACKHAT);
cvNormalize(mImg, mImg, 0, 255, CV_MINMAX);
// Nhi phan hoa anh mImg
cvThreshold(mImg, thresholed, (int)10*cvAvg(mImg).val[0], 255, CV_THRESH_BINARY);
cvZero(dst);
cvCopy(thresholed, mini_thresh);
// Su dung hinh chu nhat co size = 8x16 truot tren toan bo anh
int cnt;
int nonZero1, nonZero2, nonZero3, nonZero4;
CvRect rect;
for (int i = 0; i < mini_thresh->width-32; i+=4)
{
for (int j = 0; j < mini_thresh->height-16; j+=4)
{
rect = cvRect(i, j, 16, 8);
cvSetImageROI (mini_thresh, rect); //ROI = Region of Interest
nonZero1 = cvCountNonZero(mini_thresh);
cvResetImageROI(mini_thresh);
rect = cvRect(i+16, j, 16, 8);
cvSetImageROI (mini_thresh, rect); //ROI = Region of Interest
nonZero2 = cvCountNonZero(mini_thresh);
cvResetImageROI(mini_thresh);
rect = cvRect(i, j+8, 16, 8);
cvSetImageROI (mini_thresh, rect); //ROI = Region of Interest
nonZero3 = cvCountNonZero(mini_thresh);
cvResetImageROI(mini_thresh);
rect = cvRect(i+16, j+8, 16, 8);
cvSetImageROI (mini_thresh, rect); //ROI = Region of Interest
nonZero4 = cvCountNonZero(mini_thresh);
cvResetImageROI(mini_thresh);
cnt = 0;
if (nonZero1 > 15) { cnt++; }
if (nonZero2 > 15) { cnt++; }
if (nonZero3 > 15) { cnt++; }
if (nonZero4 > 15) { cnt++; }
if (cnt > 2)
{
rect = cvRect (i, j, 32, 16);
cvSetImageROI(dst, rect);
cvSetImageROI(mini_thresh, rect);
cvCopy(mini_thresh, dst);
cvResetImageROI(dst);
cvResetImageROI(mini_thresh);
}
}
}
IplImage* dst_clone = cvCloneImage(dst);
cvDilate(dst, dst, NULL, 2);
cvErode(dst, dst, NULL, 2);
cvDilate(dst, dst, S1, 9);
cvErode(dst, dst, S1, 10);
cvDilate(dst, dst);
/*cvShowImage("Source" , src);
cvShowImage("mImg", mImg);
cvShowImage("mini_thresh", mini_thresh);
cvShowImage("dst_clone", dst_clone);
cvShowImage("dst", dst);*/
cvPyrUp(dst, src);
cvReleaseImage(&mini_thresh);
cvReleaseImage(&mImg);
cvReleaseImage(&tmp);
cvReleaseImage(&dst);
cvReleaseImage(&src_pyrdown);
cvReleaseImage(&thresholed);
cvReleaseImage(&dst_clone);
}
double Frame::ratioBW() {
double w = cvCountNonZero(image);
double b = ((image->height)*(image->width))-w;
return w/b;
}
void CvMorphology::init( int _operation, int _max_width, int _src_dst_type,
int _element_shape, CvMat* _element,
CvSize _ksize, CvPoint _anchor,
int _border_mode, CvScalar _border_value )
{
CV_FUNCNAME( "CvMorphology::init" );
__BEGIN__;
int depth = CV_MAT_DEPTH(_src_dst_type);
int el_type = 0, nz = -1;
if( _operation != ERODE && _operation != DILATE )
CV_ERROR( CV_StsBadArg, "Unknown/unsupported morphological operation" );
if( _element_shape == CUSTOM )
{
if( !CV_IS_MAT(_element) )
CV_ERROR( CV_StsBadArg,
"structuring element should be valid matrix if CUSTOM element shape is specified" );
el_type = CV_MAT_TYPE(_element->type);
if( el_type != CV_8UC1 && el_type != CV_32SC1 )
CV_ERROR( CV_StsUnsupportedFormat, "the structuring element must have 8uC1 or 32sC1 type" );
_ksize = cvGetMatSize(_element);
CV_CALL( nz = cvCountNonZero(_element));
if( nz == _ksize.width*_ksize.height )
_element_shape = RECT;
}
operation = _operation;
el_shape = _element_shape;
CV_CALL( CvBaseImageFilter::init( _max_width, _src_dst_type, _src_dst_type,
_element_shape == RECT, _ksize, _anchor, _border_mode, _border_value ));
if( el_shape == RECT )
{
if( operation == ERODE )
{
if( depth == CV_8U )
x_func = (CvRowFilterFunc)icvErodeRectRow_8u,
y_func = (CvColumnFilterFunc)icvErodeRectCol_8u;
else if( depth == CV_16U )
x_func = (CvRowFilterFunc)icvErodeRectRow_16u,
y_func = (CvColumnFilterFunc)icvErodeRectCol_16u;
else if( depth == CV_32F )
x_func = (CvRowFilterFunc)icvErodeRectRow_32f,
y_func = (CvColumnFilterFunc)icvErodeRectCol_32f;
}
else
{
assert( operation == DILATE );
if( depth == CV_8U )
x_func = (CvRowFilterFunc)icvDilateRectRow_8u,
y_func = (CvColumnFilterFunc)icvDilateRectCol_8u;
else if( depth == CV_16U )
x_func = (CvRowFilterFunc)icvDilateRectRow_16u,
y_func = (CvColumnFilterFunc)icvDilateRectCol_16u;
else if( depth == CV_32F )
x_func = (CvRowFilterFunc)icvDilateRectRow_32f,
y_func = (CvColumnFilterFunc)icvDilateRectCol_32f;
}
}
else
{
int i, j, k = 0;
int cn = CV_MAT_CN(src_type);
CvPoint* nz_loc;
if( !(element && el_sparse &&
_ksize.width == element->cols && _ksize.height == element->rows) )
{
cvReleaseMat( &element );
cvFree( &el_sparse );
CV_CALL( element = cvCreateMat( _ksize.height, _ksize.width, CV_8UC1 ));
CV_CALL( el_sparse = (uchar*)cvAlloc(
ksize.width*ksize.height*(2*sizeof(int) + sizeof(uchar*))));
}
if( el_shape == CUSTOM )
{
CV_CALL( cvConvert( _element, element ));
}
else
{
CV_CALL( init_binary_element( element, el_shape, anchor ));
}
if( operation == ERODE )
{
if( depth == CV_8U )
y_func = (CvColumnFilterFunc)icvErodeAny_8u;
else if( depth == CV_16U )
y_func = (CvColumnFilterFunc)icvErodeAny_16u;
else if( depth == CV_32F )
y_func = (CvColumnFilterFunc)icvErodeAny_32f;
}
else
{
assert( operation == DILATE );
if( depth == CV_8U )
y_func = (CvColumnFilterFunc)icvDilateAny_8u;
else if( depth == CV_16U )
y_func = (CvColumnFilterFunc)icvDilateAny_16u;
else if( depth == CV_32F )
y_func = (CvColumnFilterFunc)icvDilateAny_32f;
}
nz_loc = (CvPoint*)el_sparse;
for( i = 0; i < ksize.height; i++ )
for( j = 0; j < ksize.width; j++ )
{
if( element->data.ptr[i*element->step+j] )
nz_loc[k++] = cvPoint(j*cn,i);
}
if( k == 0 )
nz_loc[k++] = cvPoint(anchor.x*cn,anchor.y);
el_sparse_count = k;
}
if( depth == CV_32F && border_mode == IPL_BORDER_CONSTANT )
{
int i, cn = CV_MAT_CN(src_type);
int* bt = (int*)border_tab;
for( i = 0; i < cn; i++ )
bt[i] = CV_TOGGLE_FLT(bt[i]);
}
__END__;
}
// parameters:
// img - input video frame
// dst - resultant motion picture
// args - optional parameters
void update_mhi( IplImage* img, IplImage* dst, int diff_threshold )
{
double timestamp = (double)clock()/CLOCKS_PER_SEC; // get current time in seconds
CvSize size = cvSize(img->width,img->height); // get current frame size
int i, idx1 = last, idx2;
IplImage* silh;
CvSeq* seq;
CvRect comp_rect;
double count;
double angle;
CvPoint center;
double magnitude;
CvScalar color;
// allocate images at the beginning or
// reallocate them if the frame size is changed
if( !mhi || mhi->width != size.width || mhi->height != size.height ) {
if( buf == 0 ) {
buf = (IplImage**)malloc(N*sizeof(buf[0]));
memset( buf, 0, N*sizeof(buf[0]));
}
for( i = 0; i < N; i++ ) {
cvReleaseImage( &buf[i] );
buf[i] = cvCreateImage( size, IPL_DEPTH_8U, 1 );
cvZero( buf[i] );
}
cvReleaseImage( &mhi );
cvReleaseImage( &orient );
cvReleaseImage( &segmask );
cvReleaseImage( &mask );
mhi = cvCreateImage( size, IPL_DEPTH_32F, 1 );
cvZero( mhi ); // clear MHI at the beginning
orient = cvCreateImage( size, IPL_DEPTH_32F, 1 );
segmask = cvCreateImage( size, IPL_DEPTH_32F, 1 );
mask = cvCreateImage( size, IPL_DEPTH_8U, 1 );
}
cvCvtColor( img, buf[last], CV_BGR2GRAY ); // convert frame to grayscale
idx2 = (last + 1) % N; // index of (last - (N-1))th frame
last = idx2;
silh = buf[idx2];
cvAbsDiff( buf[idx1], buf[idx2], silh ); // get difference between frames
cvThreshold( silh, silh, diff_threshold, 1, CV_THRESH_BINARY ); // and threshold it
cvUpdateMotionHistory( silh, mhi, timestamp, MHI_DURATION ); // update MHI
// convert MHI to blue 8u image
cvCvtScale( mhi, mask, 255./MHI_DURATION,
(MHI_DURATION - timestamp)*255./MHI_DURATION );
cvZero( dst );
cvMerge( mask, 0, 0, 0, dst );
// calculate motion gradient orientation and valid orientation mask
cvCalcMotionGradient( mhi, mask, orient, MAX_TIME_DELTA, MIN_TIME_DELTA, 3 );
printf("Nonzero count %d\n", cvCountNonZero(mask));
if( !storage )
storage = cvCreateMemStorage(0);
else
cvClearMemStorage(storage);
// segment motion: get sequence of motion components
// segmask is marked motion components map. It is not used further
seq = cvSegmentMotion( mhi, segmask, storage, timestamp, MAX_TIME_DELTA );
// iterate through the motion components,
// One more iteration (i == -1) corresponds to the whole image (global motion)
for( i = -1; i < seq->total; i++ ) {
if( i < 0 ) { // case of the whole image
comp_rect = cvRect( 0, 0, size.width, size.height );
color = CV_RGB(255,255,255);
magnitude = 100;
}
else { // i-th motion component
comp_rect = ((CvConnectedComp*)cvGetSeqElem( seq, i ))->rect;
if( comp_rect.width + comp_rect.height < 100 ) // reject very small components
continue;
color = CV_RGB(255,0,0);
magnitude = 30;
}
// select component ROI
cvSetImageROI( silh, comp_rect );
cvSetImageROI( mhi, comp_rect );
cvSetImageROI( orient, comp_rect );
cvSetImageROI( mask, comp_rect );
// calculate orientation
angle = cvCalcGlobalOrientation( orient, mask, mhi, timestamp, MHI_DURATION);
angle = 360.0 - angle; // adjust for images with top-left origin
count = cvNorm( silh, 0, CV_L1, 0 ); // calculate number of points within silhouette ROI
cvResetImageROI( mhi );
cvResetImageROI( orient );
cvResetImageROI( mask );
cvResetImageROI( silh );
// check for the case of little motion
if( count < comp_rect.width*comp_rect.height * 0.05 )
continue;
// draw a clock with arrow indicating the direction
center = cvPoint( (comp_rect.x + comp_rect.width/2),
(comp_rect.y + comp_rect.height/2) );
cvCircle( dst, center, cvRound(magnitude*1.2), color, 3, CV_AA, 0 );
cvLine( dst, center, cvPoint( cvRound( center.x + magnitude*cos(angle*CV_PI/180)),
cvRound( center.y - magnitude*sin(angle*CV_PI/180))), color, 3, CV_AA, 0 );
}
}
double proj = fabs(x*cos(i*binSize+M_PI/2) + y*sin(i*binSize+M_PI/2));
double value = (proj < gap) ? 0.01: 1;
CV_IMAGE_ELEM(leftDisc[i],float,y+wr,x+wr) = (theta < M_PI) ? value :0;
CV_IMAGE_ELEM(rightDisc[i],float,y+wr,x+wr)= (theta >= M_PI) ? value :0;
if (theta < M_PI){
leftDiscTot += value;
}
else{
rightDiscTot += value;
}
}
}
}
// normalize
int count1 = cvCountNonZero(leftDisc[i]);
int count2 = cvCountNonZero(rightDisc[i]);
if (count1 != count2){
printf("Discs imBalance: count1 %d count2 %d\n",count1,count2);
exit(1);
}
cvConvertScale(leftDisc[i], leftDisc[i], 1.0/leftDiscTot);
cvConvertScale(rightDisc[i], rightDisc[i], 1.0/rightDiscTot);
}
}
// calculate c1c2c3 based 3D color histogram
void getColorHist(IplImage** imgc1c2c3_float,
const int numImg,
double* hist_c1c2c3,
WSNATIVE_EXPORT bool ProcessFrame(IplImage * detection, IplImage * image, float m_GSD = 20, bgfg_cb_t bgfg_cb = 0)
{
//too few or too much detection?
float mask_area = image->width*image->height;
int width = image->width, height = image->width;
float det_area = cvCountNonZero(detection);
if (det_area < mask_area*0.00001 || det_area > mask_area*0.5 )
return false;
CvMemStorage* storage, *storage1;
storage = cvCreateMemStorage(0);
storage1 = cvCreateMemStorage(0);
CvSeq* contour;
cvFindContours( detection, storage, &contour, sizeof(CvContour), CV_RETR_TREE, CV_CHAIN_APPROX_NONE);
CvRect rectBlob[MAXBLOBCNT];
CvBox2D rectBlob2D[MAXBLOBCNT];
int nBlobNum = 0;
//note: this line erase all detected foreground pixels
cvZero(detection);
//go over all the blobs
for( ; contour != 0; contour = contour->h_next )
{
double fContourArea = fabs(cvContourArea(contour, CV_WHOLE_SEQ ));
CvRect tmpRect = cvBoundingRect(contour, 1);
float fRatio = 1.0*tmpRect.height/tmpRect.width;
float occupy = fContourArea/(tmpRect.height*tmpRect.width);
//TODO: make it an option
cvDrawContours(detection,contour,CV_RGB(255,255,255),CV_RGB(255,255,255),0,CV_FILLED,8);
//get the GSD(Ground Sampling Distance) for that location
float GSD = 20;
/*
if (tmpRect.height/2.0 +tmpRect.y < m_Y1 )
GSD = m_GSD1;
else if (tmpRect.height/2.0 +tmpRect.y > m_Y2 )
GSD = m_GSD2;
else
GSD = 1.0*m_GSD1*(m_Y2 - tmpRect.y - tmpRect.height/2.0 )/(m_Y2-m_Y1)+ 1.0*m_GSD2*(tmpRect.height/2.0 +tmpRect.y -m_Y1)/(m_Y2-m_Y1);
*/
CvRect tmpROI = cvBoundingRect( contour, 1);
float boundary = 3; //pixels
float min_area = GSD*GSD*0.10 /*0.25 for regular*/, max_area = width*height;
if ( ( (tmpROI.x >= boundary && tmpROI.x+tmpROI.width <= width-boundary) || fContourArea > std::min<float>(1600.0 ,max_area/36) ) &&
fContourArea<max_area && fContourArea >= min_area &&
!( (occupy < 0.5 && fContourArea/(GSD*GSD) > 4.0 ) || occupy <0.33 ) && //TODO: make it adaptive?
nBlobNum< MAXBLOBCNT)
{
rectBlob[nBlobNum] = tmpROI;
CvBox2D box2d = cvFitEllipse2( contour);
rectBlob2D[nBlobNum] = box2d;
nBlobNum++;
//draw outline
//cvDrawContours(showimage,contour,CV_RGB(255,255,255),CV_RGB(255,255,255),1,1,8);
}
}
for (int j = 0; j< nBlobNum; j++)
{
//get the attributes of each blob here
if(bgfg_cb) {
const CvRect& r = rectBlob[j];
bgfg_cb(r.x, r.y, r.width, r.height);
}
}
cvReleaseMemStorage( &storage);
cvReleaseMemStorage( &storage1);
return true;
}
/*************************************************************************
* @函数名称：
* 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;
}
//--------------------------------------------------------------
void kinectTracker::update()
{
bool newFrame = false;
for (int i = 0; i < NUM_KINECTS; i++)
{
kinectDevice[i].update();
if (kinectDevice[i].isFrameNew())
{
newFrame = true;
kinectGrayFBO[i].begin();
ofClear(0, 0, 0);
kinectDevice[i].drawDepth(kinectOffset[i].x, kinectOffset[i].y, kinectGrayFBO[i].getWidth(), kinectGrayFBO[i].getHeight());
kinectGrayFBO[i].end();
}
}
if(newFrame)
{
for (int i = 0; i < NUM_KINECTS; i++)
{
kinectGrayFBO[i].readToPixels(kinectPixels[i]);
cvi[i].setFromPixels(kinectPixels[i]);
kinectGrayImage[i] = cvi[i];
int rx = kinectDevice[i].getWidth() * (i%2);
int ry = kinectDevice[i].getHeight() * (i/2);
grayImage.setROI(rx, ry, kinectDevice[i].getWidth(), kinectDevice[i].getHeight());
grayImage.setRoiFromPixels(kinectGrayImage[i].getPixels(), kinectGrayImage[i].width, kinectGrayImage[i].height);
}
grayImage.setROI(0, 0, grayImage.width, grayImage.height);
// we do two thresholds - one for the far plane and one for the near plane
// we then do a cvAnd to get the pixels which are a union of the two thresholds
if (erodeIterations > 0)
{
grayImage.erode(erodeIterations);
}
if (dilateIterations > 0)
{
grayImage.dilate(dilateIterations);
}
if (enableBlur)
{
grayImage.blurHeavily();
}
grayThreshNear = grayImage;
grayThreshFar = grayImage;
grayThreshNear.threshold(nearThreshold, true);
grayThreshFar.threshold(farThreshold);
cvAnd(grayThreshNear.getCvImage(), grayThreshFar.getCvImage(), grayImage.getCvImage(), NULL);
grayImage.flagImageChanged();
activePixels = cvCountNonZero(grayImage.getCvImage());
cvXor(grayImage.getCvImage(), prevGrayImage.getCvImage(), grayImageXorred.getCvImage(), 0);
deltaPixels = cvCountNonZero(grayImageXorred.getCvImage());
grayImageXorred.flagImageChanged();
activePixelsHistory.push_front(activePixels);
deltaPixelsHistory.push_front(deltaPixels);
while (activePixelsHistory.size() > numAverageSamples)
{
activePixelsHistory.pop_back();
}
while (deltaPixelsHistory.size() > numAverageSamples)
{
deltaPixelsHistory.pop_back();
}
prevGrayImage = grayImage;
// contourFinder.findContours(grayImage, 1000, (grayImage.width*grayImage.height)/2, 20, false);
// blobsManager.update(contourFinder.blobs);
contourFinder.findContours(grayImageXorred, 1000, (grayImage.width*grayImage.height)/2, 20, false);
blobsManager.update(contourFinder.blobs);
}
}
/* Returns number of corresponding points */
int icvFindCorrForGivenPoints( IplImage *image1,/* Image 1 */
IplImage *image2,/* Image 2 */
CvMat *points1,
CvMat *pntStatus1,
CvMat *points2,
CvMat *pntStatus2,
int useFilter,/*Use fundamental matrix to filter points */
double threshold)/* Threshold for good points in filter */
{
int resNumCorrPoints = 0;
CvPoint2D32f* cornerPoints1 = 0;
CvPoint2D32f* cornerPoints2 = 0;
char* status = 0;
float* errors = 0;
CvMat* tmpPoints1 = 0;
CvMat* tmpPoints2 = 0;
CvMat* pStatus = 0;
IplImage *grayImage1 = 0;
IplImage *grayImage2 = 0;
IplImage *pyrImage1 = 0;
IplImage *pyrImage2 = 0;
CV_FUNCNAME( "icvFindCorrForGivenPoints" );
__BEGIN__;
/* Test input data for errors */
/* Test for null pointers */
if( image1 == 0 || image2 == 0 ||
points1 == 0 || points2 == 0 ||
pntStatus1 == 0 || pntStatus2 == 0)
{
CV_ERROR( CV_StsNullPtr, "Some of parameters is a NULL pointer" );
}
/* Test image size */
int w,h;
w = image1->width;
h = image1->height;
if( w <= 0 || h <= 0)
{
CV_ERROR( CV_StsOutOfRange, "Size of image1 must be > 0" );
}
if( image2->width != w || image2->height != h )
{
CV_ERROR( CV_StsUnmatchedSizes, "Size of images must be the same" );
}
/* Test for matrices */
if( !CV_IS_MAT(points1) || !CV_IS_MAT(points2) ||
!CV_IS_MAT(pntStatus1) || !CV_IS_MAT(pntStatus2) )
{
CV_ERROR( CV_StsUnsupportedFormat, "Input parameters (points and status) must be a matrices" );
}
/* Test type of status matrices */
if( !CV_IS_MASK_ARR(pntStatus1) || !CV_IS_MASK_ARR(pntStatus2) )
{
CV_ERROR( CV_StsUnsupportedFormat, "Statuses must be a mask arrays" );
}
/* Test number of points */
int numPoints;
numPoints = points1->cols;
if( numPoints <= 0 )
{
CV_ERROR( CV_StsOutOfRange, "Number of points1 must be > 0" );
}
if( points2->cols != numPoints || pntStatus1->cols != numPoints || pntStatus2->cols != numPoints )
{
CV_ERROR( CV_StsUnmatchedSizes, "Number of points and statuses must be the same" );
}
if( points1->rows != 2 || points2->rows != 2 )
{
CV_ERROR( CV_StsOutOfRange, "Number of points coordinates must be 2" );
}
if( pntStatus1->rows != 1 || pntStatus2->rows != 1 )
{
CV_ERROR( CV_StsOutOfRange, "Status must be a matrix 1xN" );
}
/* ----- End test ----- */
/* Compute number of visible points on image1 */
int numVisPoints;
numVisPoints = cvCountNonZero(pntStatus1);
if( numVisPoints > 0 )
{
/* Create temporary images */
/* We must use iplImage againts hughgui images */
/*
CvvImage grayImage1;
CvvImage grayImage2;
CvvImage pyrImage1;
CvvImage pyrImage2;
*/
/* Create Ipl images */
CV_CALL( grayImage1 = cvCreateImage(cvSize(w,h),8,1) );
CV_CALL( grayImage2 = cvCreateImage(cvSize(w,h),8,1) );
CV_CALL( pyrImage1 = cvCreateImage(cvSize(w,h),8,1) );
CV_CALL( pyrImage2 = cvCreateImage(cvSize(w,h),8,1) );
CV_CALL( cornerPoints1 = (CvPoint2D32f*)cvAlloc( sizeof(CvPoint2D32f)*numVisPoints) );
CV_CALL( cornerPoints2 = (CvPoint2D32f*)cvAlloc( sizeof(CvPoint2D32f)*numVisPoints) );
CV_CALL( status = (char*)cvAlloc( sizeof(char)*numVisPoints) );
CV_CALL( errors = (float*)cvAlloc( 2 * sizeof(float)*numVisPoints) );
int i;
for( i = 0; i < numVisPoints; i++ )
{
status[i] = 1;
}
/* !!! Need test creation errors */
/*
if( !grayImage1.Create(w,h,8)) EXIT;
if( !grayImage2.Create(w,h,8)) EXIT;
if( !pyrImage1. Create(w,h,8)) EXIT;
if( !pyrImage2. Create(w,h,8)) EXIT;
*/
cvCvtColor(image1,grayImage1,CV_BGR2GRAY);
cvCvtColor(image2,grayImage2,CV_BGR2GRAY);
/*
grayImage1.CopyOf(image1,0);
grayImage2.CopyOf(image2,0);
*/
/* Copy points good points from input data */
uchar *stat1 = pntStatus1->data.ptr;
uchar *stat2 = pntStatus2->data.ptr;
int curr = 0;
for( i = 0; i < numPoints; i++ )
{
if( stat1[i] )
{
cornerPoints1[curr].x = (float)cvmGet(points1,0,i);
cornerPoints1[curr].y = (float)cvmGet(points1,1,i);
curr++;
}
}
/* Define number of levels of pyramid */
cvCalcOpticalFlowPyrLK( grayImage1, grayImage2,
pyrImage1, pyrImage2,
cornerPoints1, cornerPoints2,
numVisPoints, cvSize(10,10), 3,
status, errors,
cvTermCriteria(CV_TERMCRIT_ITER|CV_TERMCRIT_EPS,20,0.03),
0/*CV_LKFLOW_PYR_A_READY*/ );
memset(stat2,0,sizeof(uchar)*numPoints);
int currVis = 0;
int totalCorns = 0;
/* Copy new points and set status */
/* stat1 may not be the same as stat2 */
for( i = 0; i < numPoints; i++ )
{
if( stat1[i] )
{
if( status[currVis] && errors[currVis] < 1000 )
{
stat2[i] = 1;
cvmSet(points2,0,i,cornerPoints2[currVis].x);
cvmSet(points2,1,i,cornerPoints2[currVis].y);
totalCorns++;
}
currVis++;
}
}
resNumCorrPoints = totalCorns;
/* Filter points using RANSAC */
if( useFilter )
{
resNumCorrPoints = 0;
/* Use RANSAC filter for found points */
if( totalCorns > 7 )
{
/* Create array with good points only */
CV_CALL( tmpPoints1 = cvCreateMat(2,totalCorns,CV_64F) );
CV_CALL( tmpPoints2 = cvCreateMat(2,totalCorns,CV_64F) );
/* Copy just good points */
int currPoint = 0;
for( i = 0; i < numPoints; i++ )
{
if( stat2[i] )
{
cvmSet(tmpPoints1,0,currPoint,cvmGet(points1,0,i));
cvmSet(tmpPoints1,1,currPoint,cvmGet(points1,1,i));
cvmSet(tmpPoints2,0,currPoint,cvmGet(points2,0,i));
cvmSet(tmpPoints2,1,currPoint,cvmGet(points2,1,i));
currPoint++;
}
}
/* Compute fundamental matrix */
CvMat fundMatr;
double fundMatr_dat[9];
fundMatr = cvMat(3,3,CV_64F,fundMatr_dat);
CV_CALL( pStatus = cvCreateMat(1,totalCorns,CV_32F) );
int num = cvFindFundamentalMat(tmpPoints1,tmpPoints2,&fundMatr,CV_FM_RANSAC,threshold,0.99,pStatus);
if( num > 0 )
{
int curr = 0;
/* Set final status for points2 */
for( i = 0; i < numPoints; i++ )
{
if( stat2[i] )
{
if( cvmGet(pStatus,0,curr) == 0 )
{
stat2[i] = 0;
}
curr++;
}
}
resNumCorrPoints = curr;
}
}
}
}
__END__;
/* Free allocated memory */
cvFree(&cornerPoints1);
cvFree(&cornerPoints2);
cvFree(&status);
cvFree(&errors);
cvFree(&tmpPoints1);
cvFree(&tmpPoints2);
cvReleaseMat( &pStatus );
cvReleaseImage( &grayImage1 );
cvReleaseImage( &grayImage2 );
cvReleaseImage( &pyrImage1 );
cvReleaseImage( &pyrImage2 );
return resNumCorrPoints;
}
