bool Robot::adjustWorldCoordinate(IplImage* image, double coordAdjustRate)
{
IplImage *img;
IplImage* src1=cvCreateImage(cvGetSize(image),IPL_DEPTH_8U,1);
if(image->nChannels==3)
{
IplImage *hsv_img = get_hsv(image);
img=worldMap.getField(hsv_img);
cvReleaseImage(&hsv_img);
src1=img;
}
else
{
img=image;
src1=img;
//cvCvtColor(img, src1, CV_BGR2GRAY);
}
if( img != 0 )
{
IplImage* dst = cvCreateImage( cvGetSize(img), 8, 1 );
IplImage* color_dst = cvCreateImage( cvGetSize(img), 8, 3 );
CvMemStorage* storage = cvCreateMemStorage(0);
CvSeq* ls = 0;
int i;
cvCanny( src1, dst, 50, 200, 3 );
cvCvtColor( dst, color_dst, CV_GRAY2BGR );
ls = cvHoughLines2( dst, storage, CV_HOUGH_PROBABILISTIC, 2, CV_PI/90, 20, 5, 30 );
//ls = cvHoughLines2( dst, storage, CV_HOUGH_PROBABILISTIC, 5, CV_PI/30, 10, 20, 5 );
vector<myLine> tmplines;
for( i = 0; i < ls->total; i++ )
{
CvPoint* tmpl = (CvPoint*)cvGetSeqElem(ls,i);
cvLine( color_dst, tmpl[0], tmpl[1], CV_RGB(255,0,0), 1, 8 );
cv::Point2f tmpp[2];
cv::Point2f scrPos(tmpl[0].x,tmpl[0].y);
cv::Point2f roboPos=worldMap.coord_screen2robot(scrPos,true);
cv::Point2f worldPos=worldMap.coord_robot2world(roboPos);
tmpp[0]=worldPos;
scrPos=cv::Point2f(tmpl[1].x,tmpl[1].y);
roboPos=worldMap.coord_screen2robot(scrPos,true);
worldPos=worldMap.coord_robot2world(roboPos);
tmpp[1]=worldPos;
myLine templ(tmpp[0],tmpp[1]);
if(templ.l>LINE_LENGTH_LBOUND)
tmplines.push_back(templ);
// //printf("length=%f angle=%f\n",sqrt(float((tmpl[1].y-tmpl[0].y)*(tmpl[1].y-tmpl[0].y));
// +float((tmpl[1].x-tmpl[0].x)*(tmpl[1].x-tmpl[0].x)))
// ,atan2(float(tmpl[1].y-tmpl[0].y),float(tmpl[1].x-tmpl[0].x)));
}
//printf("\n");
cvNamedWindow( "Source", 1 );
cvShowImage( "Source", img );
cvNamedWindow( "Hough", 1 );
cvShowImage( "Hough", color_dst );
cvWaitKey(10);
cvReleaseImage(&dst);
cvReleaseImage(&src1);
cvReleaseImage(&color_dst);
cvReleaseMemStorage(&storage);
if(coordAdjustRate==0)
{
for(i=0;i<tmplines.size();++i)
{
lines.push_back(tmplines[i]);
}
}
else if(coordAdjustRate==2)
{
for(i=0;i<tmplines.size();++i)
{
lines.push_back(tmplines[i]);
}
//vector<double> oris;
vector<int> lineNums;
vector<double> lineValues;
int groupId=0;
for(i=0;i<lines.size();++i)
{
bool classified=false;
int j;
for(j=0;j<i;++j)
{
double angle=lines[i].theta-lines[j].theta+CV_PI/4.0; //to make the process simple, add 45 degree
//to turn the cared angles to the middle of a phase
if(angle<0)
angle+=CV_PI*2.0;
int phase=(int)(angle/(CV_PI/2.0));
double angle90=angle-CV_PI/2.0*(double)phase;
phase%=2;
if(abs(angle90-CV_PI/4.0)<CV_PI/60.0)//subtract the added 45 degree
{
lines[i].clsId=lines[j].clsId/2*2+phase;
++lineNums[lines[i].clsId];
lineValues[lines[i].clsId]+=lines[i].l;
classified=true;
break;
}
}
if(classified==false)
{
lines[i].clsId=groupId;
lineNums.push_back(1);
lineNums.push_back(0);
lineValues.push_back(lines[i].l);
lineValues.push_back(0);
groupId+=2;
}
}
int maxValueGroup=0;
double maxValue=0;
for(i=0;i<lineNums.size();i+=2)
{
if(lineValues[i]+lineValues[i+1]>maxValue)
{
maxValue=lineValues[i]+lineValues[i+1];
maxValueGroup=i;
}
}
maxValueGroup/=2;
double sumAngle=0;
double sumL=0;
for(i=0;i<lines.size();++i)
{
if(lines[i].clsId/2==maxValueGroup)
{
double angle=lines[i].theta+CV_PI/4.0;//similar strategy, add 45 degree
if(angle<0)
angle+=CV_PI*2.0;
double angle90=angle-CV_PI/2.0*(double)((int)(angle/(CV_PI/2.0)));
sumAngle+=(angle90-CV_PI/4.0)*lines[i].l;//subtract 45 degree
sumL+=lines[i].l;
}
}
if(sumL==0)
{
//printf("false 2 sumL=0\n");
return false;
}
mainAngle=sumAngle/sumL;
mainGroupId=maxValueGroup;
//printf("mainAngle=%f mainGroupId=%d\n",mainAngle,mainGroupId);
}
else if(coordAdjustRate==1)
{
CvRect bBox=worldMap.getMap_bbox();
//printf("in func param=1\n");
//printf("tmplines.size=%d\n",tmplines.size());
for(i=0;i<tmplines.size();++i)
{
cv::Point2f imgPos=world2image(tmplines[i].p[0]);
if(!(imgPos.x>bBox.x-BBOX_DELTA && imgPos.x<bBox.x+bBox.width+BBOX_DELTA && imgPos.y>bBox.y-BBOX_DELTA && imgPos.y<bBox.y+bBox.height+BBOX_DELTA))
continue;
bool classified=false;
double minAngle=CV_PI;
int minAnglePhase=0;
int bestJ=-1;
int j;
for(j=0;j<lines.size();++j)
{
if(lines[j].clsId/2!=mainGroupId)
continue;
double angle=tmplines[i].theta-lines[j].theta+CV_PI/4.0; //to make the process simple, add 45 degree
//to turn the cared angles to the middle of a phase
if(angle<0)
angle+=CV_PI*2.0;
int phase=(int)(angle/(CV_PI/2.0));
double angle90=angle-CV_PI/2.0*(double)phase;
phase%=2;
if(abs(angle90-CV_PI/4.0)<minAngle)//subtract the added 45 degree
{
minAngle=abs(angle90-CV_PI/4.0);
bestJ=j;
minAnglePhase=phase;
}
}
if(bestJ>-1)
{
//if(minAngle<CV_PI/6.0)
tmplines[i].clsId=mainGroupId*2+minAnglePhase;
classified=true;
//printf("nearest main ori found. angle diff=%f\n",minAngle);
}
}
double sumAngle=0;
double sumL=0;
for(i=0;i<tmplines.size();++i)
{
if(tmplines[i].clsId/2==mainGroupId)
{
//printf("comparing with a main line..i=%d\n",i);
double angle=tmplines[i].theta+CV_PI/4.0;//similar strategy, add 45 degree
if(angle<0)
angle+=CV_PI*2.0;
double angle90=angle-CV_PI/2.0*double((int)(angle/(CV_PI/2.0)));
sumAngle+=angle90*tmplines[i].l;//use the 45 degree to balance the unwanted lines
sumL+=tmplines[i].l;
}
}
if(sumL<LINE_LENGTH_SUM_LBOUND)
{
//printf("false sumL=%f<%d\n",sumL,LINE_LENGTH_SUM_LBOUND);
return false;
}
double curAngle=sumAngle/sumL-CV_PI/4.0;//subtract 45 degree
ori+=curAngle-mainAngle;
//printf("true oriChange=%f\n",curAngle-mainAngle);
}
}
return true;
}
bool CvCaptureCAM_DC1394_v2_CPP::initVidereRectifyMaps( const char* info,
IplImage* ml[2], IplImage* mr[2] )
{
float identity_data[] = {1, 0, 0, 0, 1, 0, 0, 0, 1};
CvMat l_rect = cvMat(3, 3, CV_32F, identity_data), r_rect = l_rect;
float l_intrinsic_data[] = {1, 0, 0, 0, 1, 0, 0, 0, 1};
float r_intrinsic_data[] = {1, 0, 0, 0, 1, 0, 0, 0, 1};
CvMat l_intrinsic = cvMat(3, 3, CV_32F, l_intrinsic_data);
CvMat r_intrinsic = cvMat(3, 3, CV_32F, r_intrinsic_data);
float l_distortion_data[] = {0,0,0,0,0}, r_distortion_data[] = {0,0,0,0,0};
CvMat l_distortion = cvMat(1, 5, CV_32F, l_distortion_data);
CvMat r_distortion = cvMat(1, 5, CV_32F, r_distortion_data);
IplImage* mx = cvCreateImage(cvGetSize(ml[0]), IPL_DEPTH_32F, 1);
IplImage* my = cvCreateImage(cvGetSize(ml[0]), IPL_DEPTH_32F, 1);
int k, j;
for( k = 0; k < 2; k++ )
{
const char* section_name = k == 0 ? "[left_camera]" : "[right_camera]";
static const char* param_names[] = { "f ", "fy", "Cx", "Cy" "kappa1", "kappa2", "tau1", "tau2", "kappa3", 0 };
const char* section_start = strstr( info, section_name );
CvMat* intrinsic = k == 0 ? &l_intrinsic : &r_intrinsic;
CvMat* distortion = k == 0 ? &l_distortion : &r_distortion;
CvMat* rectification = k == 0 ? &l_rect : &r_rect;
IplImage** dst = k == 0 ? ml : mr;
if( !section_start )
break;
section_start += strlen(section_name);
for( j = 0; param_names[j] != 0; j++ )
{
const char* param_value_start = strstr(section_start, param_names[j]);
float val=0;
if(!param_value_start)
break;
sscanf(param_value_start + strlen(param_names[j]), "%f", &val);
if( j < 4 )
intrinsic->data.fl[j == 0 ? 0 : j == 1 ? 4 : j == 2 ? 2 : 5] = val;
else
distortion->data.fl[j - 4] = val;
}
if( param_names[j] != 0 )
break;
// some sanity check for the principal point
if( fabs(mx->width*0.5 - intrinsic->data.fl[2]) > mx->width*0.1 ||
fabs(my->height*0.5 - intrinsic->data.fl[5]) > my->height*0.1 )
{
cvScale( &intrinsic, &intrinsic, 0.5 ); // try the corrected intrinsic matrix for 2x lower resolution
if( fabs(mx->width*0.5 - intrinsic->data.fl[2]) > mx->width*0.05 ||
fabs(my->height*0.5 - intrinsic->data.fl[5]) > my->height*0.05 )
cvScale( &intrinsic, &intrinsic, 2 ); // revert it back if the new variant is not much better
intrinsic->data.fl[8] = 1;
}
cvInitUndistortRectifyMap( intrinsic, distortion,
rectification, intrinsic, mx, my );
cvConvertMaps( mx, my, dst[0], dst[1] );
}
cvReleaseImage( &mx );
cvReleaseImage( &my );
return k >= 2;
}
size_t OpenCVImage::getWidth() const
{
return m_img ? cvGetSize(m_img).width : 0;
}
void face_detect_crop(IplImage * input,IplImage * output)
{
IplImage * img;
img = cvCreateImage(cvGetSize(input),IPL_DEPTH_8U,1);
cvCvtColor(input,img,CV_RGB2GRAY);//convert input to Greyscale and store in image
int face_origin_x,face_origin_y,width,hieght;//variables to crop face
cascade = (CvHaarClassifierCascade*)cvLoad( cascade_name, 0, 0, 0 ); //load the face detedction cascade
storage = cvCreateMemStorage(0);
int scale = 1;
CvPoint pt1,pt2;
int face_number;
CvSeq* faces = cvHaarDetectObjects( img, cascade, storage,1.1, 2, CV_HAAR_DO_CANNY_PRUNING,cvSize(40, 40) );
for( face_number = 0; face_number < (faces ? faces->total : 0); face_number++ )
{
CvRect* r = (CvRect*)cvGetSeqElem( faces, face_number );
//Specifies the points for rectangle.
/* pt1_____________
| |
| |
| |
|_____________pt2 */
pt1.x = r->x*scale;
pt2.x = (r->x+r->width)*scale;
pt1.y = r->y*scale;
pt2.y = (r->y+r->height)*scale;
cvRectangle( input, pt1, pt2, CV_RGB(255,255,255), 1, 8, 0 );
CvRect rs=*r;
//cvNamedWindow("i-O", 1);
//cvShowImage("i-O",input);
//cvWaitKey(0);
cvSetImageROI(img,rs);
}
IplImage * frame;
CvSize s1= {48,48};
frame=cvCreateImage(s1,IPL_DEPTH_8U,1);
cvResize(img,frame);
cvCvtColor(frame,output,CV_GRAY2RGB);
CvPoint pt;
cascade = (CvHaarClassifierCascade*)cvLoad( cascade_name_eye, 0, 0, 0 ); //load the face detedction cascade
CvSeq* faces1 = cvHaarDetectObjects( input, cascade, storage,1.1, 2, CV_HAAR_DO_CANNY_PRUNING,cvSize(40, 40) );
for( face_number = 0; face_number < (faces1 ? faces1->total : 0); face_number++ )
{
CvRect* r = (CvRect*)cvGetSeqElem( faces1, face_number );
pt.x = (r->x*scale);
pt2.x = ((r->x+r->width)*scale);
pt.y = (r->y*scale);
pt2.y = ((r->y+r->height)*scale);
cvRectangle( input, pt, pt2, CV_RGB(0,255,255), 1, 8, 0 );
}
}
int track( IplImage* frame, int flag,int Cx,int Cy,int R )
{
{
int i, bin_w, c;
LOGE("#######################Check1############################");
if( !image )
{
/* allocate all the buffers */
image = cvCreateImage( cvGetSize(frame), 8, 3 );
image->origin = frame->origin;
hsv = cvCreateImage( cvGetSize(frame), 8, 3 );
hue = cvCreateImage( cvGetSize(frame), 8, 1 );
mask = cvCreateImage( cvGetSize(frame), 8, 1 );
backproject = cvCreateImage( cvGetSize(frame), 8, 1 );
hist = cvCreateHist( 1, &hdims, CV_HIST_ARRAY, &hranges, 1 );
histimg = cvCreateImage( cvSize(320,200), 8, 3 );
cvZero( histimg );
LOGE("######################Check2###########################");
}
cvCopy( frame, image, 0 );
cvCvtColor( image, hsv, CV_BGR2HSV );
{
int _vmin = vmin, _vmax = vmax;
cvInRangeS( hsv, cvScalar(0,smin,MIN(_vmin,_vmax),0),
cvScalar(180,256,MAX(_vmin,_vmax),0), mask );
cvSplit( hsv, hue, 0, 0, 0 );
LOGE("###########################Check3######################");
if(flag==0)
{
LOGE("###############Initialized#############################");
selection.x=Cx-R;
selection.y=Cy-R;
selection.height=2*R;
selection.width=2*R;
float max_val = 0.f;
cvSetImageROI( hue, selection );
cvSetImageROI( mask, selection );
cvCalcHist( &hue, hist, 0, mask );
cvGetMinMaxHistValue( hist, 0, &max_val, 0, 0 );
cvConvertScale( hist->bins, hist->bins, max_val ? 255. / max_val : 0., 0 );
cvResetImageROI( hue );
cvResetImageROI( mask );
track_window = selection;
track_object = 1;
cvZero( histimg );
bin_w = histimg->width / hdims;
for( i = 0; i < hdims; i++ )
{
int val = cvRound( cvGetReal1D(hist->bins,i)*histimg->height/255 );
CvScalar color = hsv2rgb(i*180.f/hdims);
cvRectangle( histimg, cvPoint(i*bin_w,histimg->height),
cvPoint((i+1)*bin_w,histimg->height - val),
color, -1, 8, 0 );
}
LOGE("##############Check4#########################");
}
LOGE("##############Check5#########################");
cvCalcBackProject( &hue, backproject, hist );
cvAnd( backproject, mask, backproject, 0 );
cvCamShift( backproject, track_window,
cvTermCriteria( CV_TERMCRIT_EPS | CV_TERMCRIT_ITER, 10, 1 ),
&track_comp, &track_box );
track_window = track_comp.rect;
char buffer[50];
sprintf(buffer,"vals= %d %d and %d",track_window.x,track_window.y,track_window.width);
LOGE(buffer);
if( backproject_mode )
cvCvtColor( backproject, image, CV_GRAY2BGR );
if( image->origin )
track_box.angle = -track_box.angle;
cvEllipseBox( image, track_box, CV_RGB(255,0,0), 3, CV_AA, 0 );
}
if( select_object && selection.width > 0 && selection.height > 0 )
{
cvSetImageROI( image, selection );
cvXorS( image, cvScalarAll(255), image, 0 );
cvResetImageROI( image );
}
LOGE("!!!!!!!!!!!!!!!!!!Done Tracking!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
}
return 0;
}
//////////////////////////////////
// main()
//
int _tmain(int argc, _TCHAR* argv[])
{
// try_conv();
if( !initAll() )
exitProgram(-1);
// Capture and display video frames until a face
// is detected
int frame_count = 0;
while( (char)27!=cvWaitKey(1) )
{
//Retrieve next image and
// Look for a face in the next video frame
//read into pfd_pVideoFrameCopy
if (!captureVideoFrame()){
if (frame_count==0)
throw exception("Failed before reading anything");
break; //end of video..
}
++frame_count;
CvSeq* pSeq = 0;
detectFaces(pfd_pVideoFrameCopy,&pSeq);
//Do some filtration of pSeq into pSeqOut, based on history etc,
//update data structures (history ,face threads etc.)s
list<Face> & faces_in_this_frame = FdProcessFaces(pfd_pVideoFrameCopy,pSeq);
//== draw rectrangle for each detected face ==
if (!faces_in_this_frame.empty()){ //faces detected (??)
int i = 0;
for(list<Face>::iterator face_itr = faces_in_this_frame.begin(); face_itr != faces_in_this_frame.end(); ++face_itr)
{
CvPoint pt1 = cvPoint(face_itr->x,face_itr->y);
CvPoint pt2 = cvPoint(face_itr->x + face_itr->width,face_itr->y + face_itr->height);
if (face_itr->frame_id == frame_count) //detected for this frame
cvRectangle( pfd_pVideoFrameCopy, pt1, pt2, colorArr[i++%3],3,8,0);
else //from a previous frame
cvRectangle( pfd_pVideoFrameCopy, pt1, pt2, colorArr[i++%3],1,4,0);
}
}else{ //no faces detected
Sleep(100);
}
cvShowImage( DISPLAY_WINDOW, pfd_pVideoFrameCopy );
cvReleaseImage(&pfd_pVideoFrameCopy);
} //end input while
cout << "==========================================================" << endl;
cout << "========== Input finished ================================" << endl;
cout << "==========================================================" << endl << endl;
cout << "Press a key to continue with history playback" <<endl;
char cc = fgetc(stdin);
cout << "==========================================================" << endl;
cout << "==== Playback history + rectangles + =====" << endl;
cout << "==== create output video(s) =====" << endl;
cout << "==========================================================" << endl << endl;
list<FDHistoryEntry> & pHistory = FdGetHistorySeq();
//== VIDEO WRITER START =====================
int isColor = 1;
int fps = 12;//30;//25; // or 30
int frameW = 640; // 744 for firewire cameras
int frameH = 480; // 480 for firewire cameras
CvVideoWriter * playbackVidWriter=cvCreateVideoWriter((OUTPUT_PLAYBACK_VIDEOS_DIR + "\\playback.avi").c_str(),
PFD_VIDEO_OUTPUT_FORMAT,
fps,cvSize(frameW,frameH),isColor);
CvVideoWriter * croppedVidWriter = 0;
if (!playbackVidWriter) {
cerr << "can't create vid writer" << endl;
exitProgram(-1);
}
bool wasWrittenToVideo = false;
//== VIDEO WRITER END =====================
int index = 0;
// play recorded sequence----------------------------
// i.e. just what's in the history
int playback_counter = 0;
cout << "start finding consensus rect " << endl;
//find min max
bool found =false;
int min_x = INT_MAX,//pFaceRect->x,
max_x = 0,//pFaceRect->x+pFaceRect->width,
min_y = INT_MAX,//pFaceRect->y,
max_y = 0;//pFaceRect->y+pFaceRect->height;
for (list<FDHistoryEntry>::iterator itr = pHistory.begin() ; itr != pHistory.end(); ++itr)
{
CvSeq* pFacesSeq = itr->pFacesSeq;
assert(pFacesSeq);
//TODO Might want to convert to Face here
CvRect * pFaceRect = (CvRect*)cvGetSeqElem(pFacesSeq, 0); //works only on first rec series
if (pFaceRect){
found = true;
if (pFaceRect->x < min_x) min_x = pFaceRect->x;
if (pFaceRect->x+pFaceRect->width > max_x) max_x = pFaceRect->x + pFaceRect->width;
if (pFaceRect->y < min_y) min_y = pFaceRect->y;
if (pFaceRect->y+pFaceRect->height > max_y) max_y = pFaceRect->y+pFaceRect->height;
}
}
//assert(found); //some rect in history..
CvRect consensus_rect;
consensus_rect.x = min_x;
consensus_rect.y = min_y;
consensus_rect.width = max_x - min_x;
consensus_rect.height = max_y - min_y;
Sleep(3000); //just to make sure that pruneHistory isn't modifying..
cout << "start playback loop " << endl;
int k = 0;
for (list<FDHistoryEntry>::iterator itr = pHistory.begin() ; itr != pHistory.end(); ++itr)
{
cout << ++k << endl;
//cvResetImageROI(history_itr->pFrame); //now reset by FDFaceThread
pfd_pVideoFrameCopy = cvCreateImage( cvGetSize(itr->pFrame ), 8, 3 ); //TODO query image for its properties
cvCopy( itr->pFrame , pfd_pVideoFrameCopy, 0 );
CvSeq* pFacesSeq = itr->pFacesSeq;
#ifndef NO_RECTS_ON_PLAYBACK
for(int i = 0 ;i < pFacesSeq->total ;i++){
Face * pFaceRect = (Face*)cvGetSeqElem(pFacesSeq, i);
assert(pFaceRect != NULL);
CvPoint pt1 = cvPoint(pFaceRect->x,pFaceRect->y);
CvPoint pt2 = cvPoint(pFaceRect->x + pFaceRect->width,pFaceRect->y + pFaceRect->height);
if (itr->frame_id == pFaceRect->frame_id)
cvRectangle( pfd_pVideoFrameCopy, pt1, pt2, colorArr[i%3],3,8,0);
else
cvRectangle( pfd_pVideoFrameCopy, pt1, pt2, colorArr[i%3],1,4,0);
}
#endif
if (pFacesSeq->total > 0)
{
assert(found);
//write 1st sequence if exists to cropped vid
if (!croppedVidWriter)
croppedVidWriter=cvCreateVideoWriter((OUTPUT_PLAYBACK_VIDEOS_DIR + "\\cropped_playback.avi").c_str(),
PFD_VIDEO_OUTPUT_FORMAT,
fps,cvSize(max_x-min_x,max_y-min_y),isColor);
assert(croppedVidWriter);
cvResetImageROI(pfd_pVideoFrameCopy);
cvSetImageROI(pfd_pVideoFrameCopy,consensus_rect);
//write cropped image to video file
IplImage *croppedImg = cvCreateImage(cvGetSize(pfd_pVideoFrameCopy),
pfd_pVideoFrameCopy->depth,
pfd_pVideoFrameCopy->nChannels);
assert(croppedImg);
cvCopy(pfd_pVideoFrameCopy, croppedImg, NULL);
assert(croppedVidWriter);
cvWriteFrame(croppedVidWriter,croppedImg);
cvReleaseImage(&croppedImg);
}
cvShowImage( DISPLAY_WINDOW, pfd_pVideoFrameCopy );
cvResetImageROI(pfd_pVideoFrameCopy); //CROP_PLAYBACK_FACE
cvWriteFrame(playbackVidWriter,pfd_pVideoFrameCopy);
if( (char)27==cvWaitKey(1) ) break;//exitProgram(0);
Sleep(50);
++playback_counter;
}
cvReleaseVideoWriter(&playbackVidWriter);
cvReleaseVideoWriter(&croppedVidWriter);
exitProgram(0);
//-----------------------------------------------------------
//-----------------------------------------------------------
//-----------------------------------------------------------
}
void JDDetect(IplImage* sourceImage)
{
const int max_corners = 3;
const char* filename = "JINGLONGLONG.jpg";
int cornerCount = max_corners;//角点的最大数目
//用于保存角点的坐标
CvPoint2D32f corners[max_corners];
IplImage*grayImage = 0, *corners1 = 0, *corners2 = 0;
cvNamedWindow("IMAGE", CV_WINDOW_AUTOSIZE);
//读入图像，检测
//sourceImage=cvLoadImage(filename,1);
grayImage = cvCreateImage(cvGetSize(sourceImage), IPL_DEPTH_8U, 1);
//cvCvtColor(sourceImage,grayImage,CV_RGB2GRAY);
grayImage = sourceImage;
corners1 = cvCreateImage(cvGetSize(sourceImage), IPL_DEPTH_32F, 1);
corners2 = cvCreateImage(cvGetSize(sourceImage), IPL_DEPTH_32F, 1);
//void cvGoodFeaturesToTrack(
// const CvArr* image,
// CvArr* eig_image,
// CvArr* temp_image,
// CvPoint2D32f* corners,
// int* corner_count,
// double quality_level,
// double min_distance,
// const CvArr* mask=NULL
// int block_size =3,
// int use_harris =0,
// double k = 0.4)
cvGoodFeaturesToTrack(
grayImage, // const CvArr* image,
corners1, // CvArr* eig_image,
corners2, // CvArr* temp_image,
corners, // CvPoint2D32f* corners,
&cornerCount, // int* corner_count,
0.05, // double quality_level,
10, // double min_distance,
0, // const CvArr* mask=NULL
3, // int block_size =3,
0, // int use_harris =0,
0.4 // double k = 0.4)
);
if (cornerCount)
{
int i = 0;
CvScalar color = CV_RGB(0, 0, 255);
for (i; i<cornerCount; i++)
cvCircle(
sourceImage, //要画圆的图像
cvPoint((int)(corners[i].x), (int)(corners[i].y)), //圆心
6, //半径
color,//颜色
2, //貌似是线宽
CV_AA,//线型
0 //圆心坐标和和半径的小数点的数目
);
}
//cvShowImage("IMAGE", sourceImage);
//cvWaitKey(0);
//释放资源
cvReleaseImage(&corners1);
cvReleaseImage(&corners2);
cvReleaseImage(&grayImage);
cvDestroyWindow("IMAGE");
}
bool Classifier::run(const IplImage *frame, CObjectList *objects, bool scored)
{
double xDiff = 0, yDiff = 0;
optical_flow(frame, &xDiff, &yDiff);
totalXDiff += xDiff;
totalYDiff += yDiff;
if (!scored)
return true;
cout << "--------------------------------------" << endl;
cout << "\t\tRun" << endl;
assert((frame != NULL) && (objects != NULL));
printf("Let's go!\n");
for (int i = 0; i < (int)prevObjects.size(); ++i) {
if (prevObjects[i].rect.x > -20 && prevObjects[i].rect.x < frame->width
&& prevObjects[i].rect.y > -20 && prevObjects[i].rect.y < frame->height) {
objects->push_back(prevObjects[i]);
cout << prevObjects[i].label << " is now at (" << prevObjects[i].rect.x << ", " << prevObjects[i].rect.y << ")" << endl;
}
}
//printf("HEY OPTICAL FLOW!!!! %f %f\n", totalXDiff, totalYDiff);
// move old objects
for (int i = 0; i < (int)objects->size(); ++i) {
(*objects)[i].rect.x -= totalXDiff * 3;
(*objects)[i].rect.y -= totalYDiff * 3;
}
cout << "Flow: " << totalXDiff << " " << totalYDiff << endl;
totalYDiff = 0;
totalXDiff = 0;
// Convert to grayscale.
IplImage *gray = cvCreateImage(cvGetSize(frame), IPL_DEPTH_8U, 1);
cvCvtColor(frame, gray, CV_BGR2GRAY);
// Resize by half first, as per the handout.
double scale = 2.0;
IplImage *dst = cvCreateImage(cvSize(gray->width / scale, gray->height / scale), gray->depth, gray->nChannels);
cvResize(gray, dst);
printf("About to do SURF\n");
CvSeq *keypoints = 0, *descriptors = 0;
CvSURFParams params = cvSURFParams(100, SURF_SIZE == 128);
cvExtractSURF(dst, 0, &keypoints, &descriptors, storage, params);
cout << "desc: " << descriptors->total << endl;
if (descriptors->total == 0) return false;
vector<float> desc;
desc.resize(descriptors->total * descriptors->elem_size/sizeof(float));
cvCvtSeqToArray(descriptors, &desc[0]);
vector<CvSURFPoint> keypts;
keypts.resize(keypoints->total);
cvCvtSeqToArray(keypoints, &keypts[0]);
vector<float *> features;
int where = 0;
for (int pt = 0; pt < keypoints->total; ++pt) {
float *f = new float[SURF_SIZE];
for (int j = 0; j < SURF_SIZE; ++j) {
f[j] = desc[where];
++where;
}
features.push_back(f);
}
printf("Done SURF\n");
printf("Clustering...\n");
vector<int> cluster(features.size());
for (int i = 0; i < (int)features.size(); ++i) {
cluster[i] = best_cluster(centers, features[i]);
}
printf("Done clustering...\n");
vector<FoundObject> newObjects;
run_boxscan(dst, cluster, keypts, features, newObjects, objects);
for (int i = 0; i < (int)newObjects.size(); ++i) {
if (newObjects[i].object.rect.x > -20 && newObjects[i].object.rect.x < frame->width
&& newObjects[i].object.rect.y > -20 && newObjects[i].object.rect.y < frame->height) {
objects->push_back(newObjects[i].object);
cout << "Found object: " << newObjects[i].object.label << " at (" ;
cout << newObjects[i].object.rect.x << ", " << newObjects[i].object.rect.y << ")" << endl;
}
}
prevObjects = *objects;
cvReleaseImage(&gray);
return true;
}
static void
cvTsCalcHist( IplImage** _images, CvHistogram* hist, IplImage* _mask, int* channels )
{
int x, y, k, cdims;
union
{
float* fl;
uchar* ptr;
}
plane[CV_MAX_DIM];
int nch[CV_MAX_DIM];
int dims[CV_MAX_DIM];
int uniform = CV_IS_UNIFORM_HIST(hist);
CvSize img_size = cvGetSize(_images[0]);
CvMat images[CV_MAX_DIM], mask = cvMat(1,1,CV_8U);
int img_depth = _images[0]->depth;
cdims = cvGetDims( hist->bins, dims );
cvZero( hist->bins );
for( k = 0; k < cdims; k++ )
{
cvGetMat( _images[k], &images[k] );
nch[k] = _images[k]->nChannels;
}
if( _mask )
cvGetMat( _mask, &mask );
for( y = 0; y < img_size.height; y++ )
{
const uchar* mptr = _mask ? &CV_MAT_ELEM(mask, uchar, y, 0 ) : 0;
if( img_depth == IPL_DEPTH_8U )
for( k = 0; k < cdims; k++ )
plane[k].ptr = &CV_MAT_ELEM(images[k], uchar, y, 0 ) + channels[k];
else
for( k = 0; k < cdims; k++ )
plane[k].fl = &CV_MAT_ELEM(images[k], float, y, 0 ) + channels[k];
for( x = 0; x < img_size.width; x++ )
{
float val[CV_MAX_DIM];
int idx[CV_MAX_DIM];
if( mptr && !mptr[x] )
continue;
if( img_depth == IPL_DEPTH_8U )
for( k = 0; k < cdims; k++ )
val[k] = plane[k].ptr[x*nch[k]];
else
for( k = 0; k < cdims; k++ )
val[k] = plane[k].fl[x*nch[k]];
idx[cdims-1] = -1;
if( uniform )
{
for( k = 0; k < cdims; k++ )
{
double v = val[k], lo = hist->thresh[k][0], hi = hist->thresh[k][1];
idx[k] = cvFloor((v - lo)*dims[k]/(hi - lo));
if( idx[k] < 0 || idx[k] >= dims[k] )
break;
}
}
else
{
for( k = 0; k < cdims; k++ )
{
float v = val[k];
float* t = hist->thresh2[k];
int j, n = dims[k];
for( j = 0; j <= n; j++ )
if( v < t[j] )
break;
if( j <= 0 || j > n )
break;
idx[k] = j-1;
}
}
if( k < cdims )
continue;
(*(float*)cvPtrND( hist->bins, idx ))++;
}
}
}
int main(int argc, char* argv[])
{
IplImage* src = cvLoadImage(argv[1],CV_LOAD_IMAGE_UNCHANGED);
// get HSV form of image
IplImage* hsvSrc = cvCreateImage(cvGetSize(src),8,3);
cvCvtColor(src,hsvSrc,CV_BGR2HSV);
// initialize Histogram
int numBins = 256;
CvHistogram *hist = cvCreateHist(1,&numBins,CV_HIST_ARRAY,NULL,1);
cvClearHist(hist);
// Separate hsv image into 3 channels
IplImage* hueCh = cvCreateImage(cvGetSize(hsvSrc),8,1);
IplImage* satCh = cvCreateImage(cvGetSize(hsvSrc),8,1);
IplImage* valCh = cvCreateImage(cvGetSize(hsvSrc),8,1);
cvSplit(hsvSrc,hueCh,satCh,valCh,NULL);
// **** Rendering Histogram ****
// --- Hue Channel ---
cvCalcHist(&hueCh,hist, 0, NULL);
IplImage* imgHistHue = drawHistogram(hist);
cvClearHist(hist);
// --- Sat Channel ---
cvCalcHist(&satCh, hist, 0, NULL);
IplImage* imgHistSat = drawHistogram(hist);
cvClearHist(hist);
// --- Val Channel ---
cvCalcHist(&valCh, hist, 0, NULL);
IplImage* imgHistVal = drawHistogram(hist);
cvClearHist(hist);
cvStartWindowThread();
// display histogram
cvNamedWindow("Hue",CV_WINDOW_NORMAL);
cvNamedWindow("Sat",CV_WINDOW_NORMAL);
cvNamedWindow("Val",CV_WINDOW_NORMAL);
cvShowImage("Hue",imgHistHue);
cvShowImage("Sat",imgHistSat);
cvShowImage("Val",imgHistVal);
// wait for key press
cvWaitKey(0);
// release memory
cvDestroyAllWindows();
cvReleaseImage(&src);
cvReleaseImage(&hueCh);
cvReleaseImage(&satCh);
cvReleaseImage(&valCh);
cvReleaseImage(&imgHistHue);
cvReleaseImage(&imgHistSat);
cvReleaseImage(&imgHistVal);
return 0;
}// end of main
int main(int argc, char *argv[]) {
printf("\nentered main\n");
IplImage* img;
IplImage* img1;
CvCapture* capture;
int is_data_ready = 0;
int width, height, key;
width = 640;
height = 480;
printf("\nvars declared\n");
capture = cvCaptureFromCAM(0);
img = cvCreateImage(cvSize(width, height), IPL_DEPTH_8U, 1);
img = cvQueryFrame(capture);
img1 = cvCreateImage(cvGetSize(img), IPL_DEPTH_8U, 1);
cvZero(img);
cvZero(img1);
printf("\nstart capture\n");
/*
*********************************************************************/
int imgsize = img1->imageSize;
int sock; /* fd for socket connection */
struct sockaddr_in server; /* Socket info. for server */
struct sockaddr_in client; /* Socket info. about us */
int clientLen; /* Length of client socket struct. */
struct hostent *hp; /* Return value from gethostbyname() */
char buf[BUFFER_SIZE]; /* Received data buffer */
int i, bytes; /* loop counter */
printf("\ndeclaration\n");
if (argc != 2)
die("Usage: client hostname");
/* Open 3 sockets and send same message each time. */
for (i = 0; i < 3; ++i)
{
/* Open a socket --- not bound yet. */
/* Internet TCP type. */
if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0)
pdie("Opening stream socket");
/* Prepare to connect to server. */
bzero((char *) &server, sizeof(server));
server.sin_family = AF_INET;
if ((hp = gethostbyname(argv[1])) == NULL) {
sprintf(buf, "%s: unknown host\n", argv[1]);
die(buf);
}
bcopy(hp->h_addr, &server.sin_addr, hp->h_length);
server.sin_port = htons((u_short) SERVER_PORT);
/* Try to connect */
if (connect(sock, (struct sockaddr *) &server, sizeof(server)) < 0)
pdie("Connecting stream socket");
/* Determine what port client's using. */
clientLen = sizeof(client);
if (getsockname(sock, (struct sockaddr *) &client, &clientLen))
pdie("Getting socket name");
if (clientLen != sizeof(client))
die("getsockname() overwrote name structure");
printf("Client socket has port %hu\n", ntohs(client.sin_port));
while(1)
{
/* get a frame from camera */
img = cvQueryFrame(capture);
if (!img) break;
//img->origin = 0;
//pthread_mutex_lock(&mutex);
cvCvtColor(img, img1, CV_BGR2GRAY);
img1->origin = 0;
is_data_ready = 1;
// pthread_mutex_unlock(&mutex);
/* send the grayscaled frame, thread safe */
// pthread_mutex_lock(&mutex);
if (is_data_ready) {
bytes = send(sock, img1->imageData, imgsize, 0);
is_data_ready = 0;
}
// pthread_mutex_unlock(&mutex);
/* if something went wrong, restart the connection */
if (bytes != imgsize) {
fprintf(stderr, "Connection closed.\n");
//close(sock);
}
/* have we terminated yet? */
pthread_testcancel();
/* no, take a rest for a while */
usleep(1000);
}
printf("C: %s\n", buf);
/* Close this connection. */
close(sock);
}
exit(0);
}
std::list<Garbage*>
GarbageRecognition::garbageList(IplImage * src, IplImage * model){
std::list<Garbage*> garbageList;
//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++;
// printf("frame number:%d\n",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( ct->perimeterFilter(MINCONTOUR_PERIMETER,MAXCONTOUR_PERIMETER) &&
ct->rectangularAspectFilter(CONTOUR_RECTANGULAR_MIN_RATIO, CONTOUR_RECTANGULAR_MAX_RATIO) &&
ct->boxAreaFilter(BOXFILTER_TOLERANCE) &&
ct->histogramMatchingFilter(src,testImageHistogram, HIST_H_BINS,HIST_S_BINS,HIST_MIN)){
//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);
garbageList.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 garbageList;
}
int main(int argc, char *argv[])
{
IplImage* img = 0;
int height,width,step,channels;
unsigned char *data;
// load an image
img= cvLoadImage("kantai.png");
if(!img){
printf("Could not load image file: %s\n",argv[1]);
exit(0);
}
// get the image data
height = img->height;
width = img->width;
step = img->widthStep;
channels = img->nChannels;
data = (uchar *)img->imageData;
printf("Processing a %dx%d image with %d channels\n",height,width,channels);
printf("step = %d\n", step);
IplImage* imgGrayscale = cvCreateImage(cvGetSize(img), IPL_DEPTH_8U, 1); // 8-bit grayscale is enough.
// convert to grayscale.
cvCvtColor(img, imgGrayscale, CV_BGR2GRAY);
// Create an image for the outputs
IplImage* imgSobelX = cvCreateImage( cvGetSize(img), IPL_DEPTH_32F, 1 ); // to prevent overflow.
IplImage* imgSobelY = cvCreateImage( cvGetSize(img), IPL_DEPTH_32F, 1 );
IplImage* imgSobelAdded = cvCreateImage( cvGetSize(img), IPL_DEPTH_32F, 1 );
IplImage* imgSobel = cvCreateImage( cvGetSize(img), IPL_DEPTH_8U, 1 ); // final image is enough to be an 8-bit plane.
// Sobel
cvSobel(imgGrayscale, imgSobelX, 1, 0, 3);
cvSobel(imgGrayscale, imgSobelY, 0, 1, 3);
cvAdd(imgSobelX, imgSobelY, imgSobelAdded);
cvConvertScaleAbs(imgSobelAdded, imgSobel); //scaled to 8-bit level; important for visibility.
//----------------------- OULINE EXTRACTION -------------------------------
// Normal diff
IplImage* imgNormDiff = cvCreateImage(cvGetSize(img), 8, 1);
cvCopy(imgGrayscale,imgNormDiff);
norm_diff(imgNormDiff);
// Roberts
IplImage* imgRoberts = cvCreateImage(cvGetSize(img), 8, 1);
cvCopy(imgGrayscale,imgRoberts);
roberts(imgRoberts);
// Sobel
IplImage* imgSobel2 = cvCreateImage(cvGetSize(img), 8, 1);
cvCopy(imgGrayscale,imgSobel2);
sobel(imgSobel2);
// Laplacian
IplImage* imgLap = cvCreateImage(cvGetSize(img), 8, 1);
cvCopy(imgGrayscale,imgLap);
laplacian(imgLap);
//--------------------------- ENHANCEMENT --------------------------------
// Laplacian
IplImage* imgLap2 = cvCreateImage(cvGetSize(img), 8, 3);
IplImage* imgRed = cvCreateImage(cvGetSize(img), 8, 1);
IplImage* imgGreen = cvCreateImage(cvGetSize(img), 8, 1);
IplImage* imgBlue = cvCreateImage(cvGetSize(img), 8, 1);
cvSplit(img, imgRed, imgGreen, imgBlue, NULL);
laplacian2(imgBlue);
laplacian2(imgGreen);
laplacian2(imgRed);
cvMerge(imgRed,imgGreen,imgBlue, NULL, imgLap2);
// Variant
IplImage* imgVariant = cvCreateImage(cvGetSize(img), 8, 3);
IplImage* imgRed2 = cvCreateImage(cvGetSize(img), 8, 1);
IplImage* imgGreen2 = cvCreateImage(cvGetSize(img), 8, 1);
IplImage* imgBlue2 = cvCreateImage(cvGetSize(img), 8, 1);
cvSplit(img, imgRed2, imgGreen2, imgBlue2, NULL);
variant(imgBlue2);
variant(imgGreen2);
variant(imgRed2);
cvMerge(imgRed2,imgGreen2,imgBlue2, NULL, imgVariant);
// Sobel
IplImage* imgSobel3 = cvCreateImage(cvGetSize(img), 8, 3);
IplImage* imgRed3 = cvCreateImage(cvGetSize(img), 8, 1);
IplImage* imgGreen3 = cvCreateImage(cvGetSize(img), 8, 1);
IplImage* imgBlue3 = cvCreateImage(cvGetSize(img), 8, 1);
cvSplit(img, imgRed3, imgGreen3, imgBlue3, NULL);
sobel2(imgBlue3);
sobel2(imgGreen3);
sobel2(imgRed3);
cvMerge(imgRed3,imgGreen3,imgBlue3, NULL, imgSobel3);
// create a window
cvNamedWindow("Original", CV_WINDOW_KEEPRATIO);
cvNamedWindow("Normal different line", CV_WINDOW_KEEPRATIO);
cvNamedWindow("Roberts line", CV_WINDOW_FREERATIO);
cvNamedWindow("Sobel line", CV_WINDOW_FREERATIO);
cvNamedWindow("Laplacian line", CV_WINDOW_KEEPRATIO);
cvNamedWindow("Laplacian Color", CV_WINDOW_KEEPRATIO);
cvNamedWindow("Variant", CV_WINDOW_KEEPRATIO);
cvNamedWindow("Sobel", CV_WINDOW_KEEPRATIO);
/*cvNamedWindow( "Sobel-x" );
cvNamedWindow( "Sobel-y" );
cvNamedWindow( "Sobel-Added" );
cvNamedWindow( "Sobel-Added (scaled)" );*/
// show the image
cvShowImage("Original", img);
cvShowImage("Normal different line", imgNormDiff);
cvShowImage("Roberts line",imgRoberts);
cvShowImage("Sobel line", imgSobel2);
cvShowImage("Laplacian line", imgLap);
cvShowImage("Laplacian Color", imgLap2);
cvShowImage("Variant", imgVariant);
cvShowImage("Sobel", imgSobel3);
/*cvShowImage("Sobel-x", imgSobelX);
cvShowImage("Sobel-y", imgSobelY);
cvShowImage("Sobel-Added", imgSobelAdded);
cvShowImage("Sobel-Added (scaled)", imgSobel);*/
// wait for a key
cvWaitKey(0);
// release the image
cvReleaseImage(&img);
cvReleaseImage(&imgGrayscale);
cvReleaseImage(&imgNormDiff);
cvReleaseImage(&imgRoberts);
cvReleaseImage(&imgSobel2);
cvReleaseImage(&imgLap);
cvReleaseImage(&imgLap2);
cvReleaseImage(&imgVariant);
cvReleaseImage(&imgSobel3);
cvReleaseImage(&imgSobelX);
cvReleaseImage(&imgSobelY);
cvReleaseImage(&imgSobelAdded);
cvReleaseImage(&imgSobel);
return 0;
}
int main(int argc, char *argv[]) {
if (argc < 3){
printf("Usage: %s <image-file-name1> <image-file-name2>\n", argv[0]);
exit(1);
}
IplImage* img1 = cvLoadImage(argv[1], CV_LOAD_IMAGE_GRAYSCALE);
if (!img1) {
printf("Could not load image file: %s\n", argv[1]);
exit(1);
}
IplImage* img1f = cvCreateImage(cvGetSize(img1), IPL_DEPTH_32F, 1);
cvConvertScale(img1, img1f, 1.0 / 255.0);
IplImage* img2 = cvLoadImage(argv[2], CV_LOAD_IMAGE_GRAYSCALE);
if (!img2) {
printf("Could not load image file: %s\n", argv[2]);
exit(1);
}
IplImage* img2f = cvCreateImage(cvGetSize(img1), IPL_DEPTH_32F, 1);
cvConvertScale(img2, img2f, 1.0 / 255.0);
/**
* Aufgabe: Homographien (5 Punkte)
*
* Unter der Annahme, dass Bilder mit einer verzerrungsfreien Lochbildkamera
* aufgenommen werden, kann man Aufnahmen mit verschiedenen Bildebenen und
* gleichem Projektionszentren durch projektive Abbildungen, sogenannte
* Homographien, beschreiben.
*
* - Schreibe Translation als Homographie auf (auf Papier!).
* - Verschiebe die Bildebene eines Testbildes um 20 Pixel nach rechts, ohne
* das Projektionszentrum zu ändern. Benutze dafür \code{cvWarpPerspective}.
* - Wieviele Punktkorrespondenzen benötigt man mindestens, um eine projektive
* Abbildung zwischen zwei Bildern bis auf eine Skalierung eindeutig zu
* bestimmen? Warum? (Schriftlich beantworten!)
*/
/* TODO */
IplImage* img_moved = cvCreateImage(cvGetSize(img1), IPL_DEPTH_32F, 1);
cv::Mat matImg1f_task1 = cv::Mat(img1f);
cv::Mat matImgMoved = cv::Mat(img_moved);
float data[] = { 1, 0, -20, 0, 1, 0, 0, 0, 1 };
cv::Mat trans(3, 3, CV_32FC1, data);;
cv::warpPerspective(matImg1f_task1, matImgMoved, trans, matImgMoved.size());
cv::namedWindow("mainWin", CV_WINDOW_AUTOSIZE);
cv::Mat img_moved_final(img_moved);
cv::imshow("mainWin", img_moved_final);
cvWaitKey(0);
/**
* Aufgabe: Panorama (15 Punkte)
*
* Ziel dieser Aufgabe ist es, aus zwei gegebenen Bildern ein Panorama zu konstruieren.
* \begin{center}
* \includegraphics[width = 0.3\linewidth]{left.png}
* \includegraphics[width = 0.3\linewidth]{right.png}
* \end{center}
*
* Dafür muss zunächst aus den gegeben Punktkorrespondenzen
* \begin{center}
* \begin{tabular}{|c|c|}
* \hline
* linkes Bild & rechtes Bild \\
* $(x, y)$ & $(x, y)$ \\ \hline \hline
* (463, 164) & (225, 179)\\ \hline
* (530, 357) & (294, 370)\\ \hline
* (618, 357) &(379, 367)\\ \hline
* (610, 153) & (369, 168)\\ \hline
* \end{tabular}
* \end{center}
* eine perspektivische Transformation bestimmt werden, mit der die Bilder auf eine gemeinsame Bildebene transformiert werden können.
*
* - Berechne die Transformation aus den gegebenen Punktkorrespondenzen.
* Benutze die Funktion \code{cvGetPerspectiveTransform}. Was ist die
* zentrale Idee des DLT-Algorithmus, wie er in der Vorlesung vorgestellt
* wurde?
*/
/* TODO */
CvMat *P = cvCreateMat(3, 3, CV_32FC1);
CvPoint points1[] = { cvPoint(463, 164), cvPoint(530, 357), cvPoint(618, 357), cvPoint(610, 153) };
CvPoint points2[] = { cvPoint(225, 179), cvPoint(294, 370), cvPoint(379, 367), cvPoint(369, 168) };
CvPoint2D32f pt1[4], pt2[4];
for (int i = 0; i < 4; ++i) {
pt2[i].x = points2[i].x;
pt2[i].y = points2[i].y;
pt1[i].x = points1[i].x;
pt1[i].y = points1[i].y;
}
cvGetPerspectiveTransform(pt1, pt2, P);
/**
* - Bestimme die notwendige Bildgröße für das Panoramabild.
*/
/* TODO */
int h = img1f->height - 1;
int w = img1f->width - 1;
float p1[] = { 0.0, 0.0, 1.0 };
float p2[] = { 0.0, (float)(h), 1.0 };
float p3[] = { (float)(w), (float)(h), 1.0 };
float p4[] = { (float)(w), 0.0, 1.0 };
cv::Mat P1 = P * cv::Mat(3, 1, CV_32FC1, p1);
cv::Mat P2 = P * cv::Mat(3, 1, CV_32FC1, p2);
cv::Mat P3 = P * cv::Mat(3, 1, CV_32FC1, p3);
cv::Mat P4 = P * cv::Mat(3, 1, CV_32FC1, p4);
// mustn't be zero
assert(P1.at<float>(2,0) != 0 && P2.at<float>(2,0) != 0 && P3.at<float>(2,0) != 0 && P4.at<float>(2,0) != 0);
P1 = P1 / P1.at<float>(2,0);
P2 = P2 / P2.at<float>(2,0);
P3 = P3 / P3.at<float>(2,0);
P4 = P4 / P4.at<float>(2,0);
/**
* - Projiziere das linke Bild in die Bildebene des rechten Bildes. Beachte
* dabei, dass auch der linke Bildrand in das Panoramabild projiziert
* wird.
*/
/* TODO */
///////// Hier wird irgendwo ein fehler sein bei der Groesse...
std::vector<cv::Mat*> matrices;
matrices.push_back(&P1);
matrices.push_back(&P2);
matrices.push_back(&P3);
matrices.push_back(&P4);
cv::Point minP(P1.at<float>(0,0), P1.at<float>(1,0)), maxP(P1.at<float>(0,0), P1.at<float>(1,0));
for(int i = 0; i < matrices.size(); ++i) {
minP.x = (int)(min(matrices[i]->at<float>(0,0), (float)minP.x));
minP.y = (int)(min(matrices[i]->at<float>(1,0), (float)minP.y));
maxP.x = (int)(max(matrices[i]->at<float>(0,0), (float)maxP.x)+1.0);
maxP.y = (int)(max(matrices[i]->at<float>(1,0), (float)maxP.y)+1.0);
}
minP.x = min(minP.x, 0); minP.y = min(minP.y, 0);
maxP.x = max(maxP.x, img1f->width-1); maxP.y = max(maxP.y, img1f->height-1);
// create image
cv::Mat Panorama = cv::Mat(cv::Size(maxP-minP), CV_32FC1, cv::Scalar(0.0));
cv::Mat PLeft = cv::Mat(cv::Size(maxP-minP), CV_32FC1, cv::Scalar(0.0));
cv::Mat PRight = cv::Mat(cv::Size(maxP-minP), CV_32FC1, cv::Scalar(0.0));
cv::Mat matImg1f = cv::Mat( img1f);
cv::Mat matImg2f = cv::Mat( img2f);
for(int y=0; y < matImg1f.rows; ++y ) {
for(int x=0; x < matImg1f.cols; ++x ) {
PLeft.at<float>(y,x) = matImg1f.at<float>(y,x);
}
}
for(int y=0; y < matImg2f.rows; ++y ) {
for(int x=0; x < matImg2f.cols; ++x ) {
PRight.at<float>(y,x) = matImg2f.at<float>(y,x);
}
}
cv::imshow("mainWin", PLeft);
cv::waitKey(0);
cv::imshow("mainWin", PRight);
cv::waitKey(0);
float trans2[] = { 1.0, 0.0, -minP.x, 0.0, 1.0, -minP.y, 0.0, 0.0, 1.0};
cv::Mat translation(3,3,CV_32FC1,trans2);
//translate P
cv::Mat Pnew = translation*cv::Mat(P);
cv::warpPerspective(PLeft, Panorama, Pnew, Panorama.size());
cv::warpPerspective(PRight, PLeft, translation, PLeft.size());
PRight = PLeft.clone();
cv::imshow("mainWin", PLeft);
cv::waitKey(0);
cv::imshow("mainWin", Panorama);
cv::waitKey(0);
/**
* - Bilde das Panoramabild, so dass Pixel, für die zwei Werte vorhanden sind,
* den Mittelwert zugeordnet bekommen.
*/
cv::Mat mask = (Panorama > 0.0) & (PLeft > 0.0);
cv::imshow("mainWin", mask);
cv::waitKey(0);
mask.convertTo(mask,CV_32FC1, 0.5/255.);
cv::Mat weighted = cv::Mat(Panorama.size(), CV_32FC1, cv::Scalar(1.0)) - mask;
Panorama = Panorama + PLeft;
cv::multiply(Panorama, weighted, Panorama);
cv::imshow("mainWin", Panorama);
cv::waitKey(0);
/* TODO */
/**
* - Zeige das Panoramabild an.
*/
/* TODO */
}
}
CV_MAT_ELEM( *point_counts, int, t-1, 0 ) = nc;
}
else printf("Bad board! How did this happen?\n");
}
// calibrate
// Initialize the intrinsic matrix such that the two focal
// lengths have a ratio of 1.0
CV_MAT_ELEM( *intrinsic_matrix, float, 0, 0 ) = 1.0f;
CV_MAT_ELEM( *intrinsic_matrix, float, 1, 1 ) = 1.0f;
cvCalibrateCamera2(
object_points,
image_points,
point_counts,
cvGetSize(image),
intrinsic_matrix,
distortion_coeffs,
NULL,
NULL,
0 // CV_CALIB_FIX_ASPECT_RATIO
);
calibrated = true;
cvSave("intrinsic.dat", intrinsic_matrix);
cvSave("distortion.dat", distortion_coeffs);
matToScreen(intrinsic_matrix, "intrinsic");
matToScreen(distortion_coeffs, "distortion");
static void
cvTsCalcBackProject( IplImage** images, IplImage* dst, CvHistogram* hist, int* channels )
{
int x, y, k, cdims;
union
{
float* fl;
uchar* ptr;
}
plane[CV_MAX_DIM];
int nch[CV_MAX_DIM];
int dims[CV_MAX_DIM];
int uniform = CV_IS_UNIFORM_HIST(hist);
CvSize img_size = cvGetSize(images[0]);
int img_depth = images[0]->depth;
cdims = cvGetDims( hist->bins, dims );
for( k = 0; k < cdims; k++ )
nch[k] = images[k]->nChannels;
for( y = 0; y < img_size.height; y++ )
{
if( img_depth == IPL_DEPTH_8U )
for( k = 0; k < cdims; k++ )
plane[k].ptr = &CV_IMAGE_ELEM(images[k], uchar, y, 0 ) + channels[k];
else
for( k = 0; k < cdims; k++ )
plane[k].fl = &CV_IMAGE_ELEM(images[k], float, y, 0 ) + channels[k];
for( x = 0; x < img_size.width; x++ )
{
float val[CV_MAX_DIM];
float bin_val = 0;
int idx[CV_MAX_DIM];
if( img_depth == IPL_DEPTH_8U )
for( k = 0; k < cdims; k++ )
val[k] = plane[k].ptr[x*nch[k]];
else
for( k = 0; k < cdims; k++ )
val[k] = plane[k].fl[x*nch[k]];
idx[cdims-1] = -1;
if( uniform )
{
for( k = 0; k < cdims; k++ )
{
double v = val[k], lo = hist->thresh[k][0], hi = hist->thresh[k][1];
idx[k] = cvFloor((v - lo)*dims[k]/(hi - lo));
if( idx[k] < 0 || idx[k] >= dims[k] )
break;
}
}
else
{
for( k = 0; k < cdims; k++ )
{
float v = val[k];
float* t = hist->thresh2[k];
int j, n = dims[k];
for( j = 0; j <= n; j++ )
if( v < t[j] )
break;
if( j <= 0 || j > n )
break;
idx[k] = j-1;
}
}
if( k == cdims )
bin_val = (float)cvGetRealND( hist->bins, idx );
if( img_depth == IPL_DEPTH_8U )
{
int t = cvRound(bin_val);
CV_IMAGE_ELEM( dst, uchar, y, x ) = CV_CAST_8U(t);
}
else
CV_IMAGE_ELEM( dst, float, y, x ) = bin_val;
}
}
}
void *ControlThread(void *unused)
{
int i=0;
char fileName[30];
NvMediaTime pt1 ={0}, pt2 = {0};
NvU64 ptime1, ptime2;
struct timespec;
IplImage* imgOrigin;
IplImage* imgCanny;
// cvCreateImage
imgOrigin = cvCreateImage(cvSize(RESIZE_WIDTH, RESIZE_HEIGHT), IPL_DEPTH_8U, 3);
imgCanny = cvCreateImage(cvGetSize(imgOrigin), IPL_DEPTH_8U, 1);
int angle, speed;
IplImage* imgOrigin;
IplImage* imgResult;
unsigned char status;
unsigned int gain;
CarControlInit();
PositionControlOnOff_Write(UNCONTROL);
SpeedControlOnOff_Write(1);
//speed controller gain set
//P-gain
gain = SpeedPIDProportional_Read(); // default value = 10, range : 1~50
printf("SpeedPIDProportional_Read() = %d \n", gain);
gain = 20;
SpeedPIDProportional_Write(gain);
//I-gain
gain = SpeedPIDIntegral_Read(); // default value = 10, range : 1~50
printf("SpeedPIDIntegral_Read() = %d \n", gain);
gain = 20;
SpeedPIDIntegral_Write(gain);
//D-gain
gain = SpeedPIDDifferential_Read(); // default value = 10, range : 1~50
printf("SpeedPIDDefferential_Read() = %d \n", gain);
gain = 20;
SpeedPIDDifferential_Write(gain);
angle = 1460;
SteeringServoControl_Write(angle);
// cvCreateImage
imgOrigin = cvCreateImage(cvSize(RESIZE_WIDTH, RESIZE_HEIGHT), IPL_DEPTH_8U, 3);
imgResult = cvCreateImage(cvGetSize(imgOrigin), IPL_DEPTH_8U, 1);
int flag = 1;
while(1)
{
pthread_mutex_lock(&mutex);
pthread_cond_wait(&cond, &mutex);
GetTime(&pt1);
ptime1 = (NvU64)pt1.tv_sec * 1000000000LL + (NvU64)pt1.tv_nsec;
Frame2Ipl(imgOrigin); // save image to IplImage structure & resize image from 720x480 to 320x240
pthread_mutex_unlock(&mutex);
cvCanny(imgOrigin, imgCanny, 100, 100, 3);
sprintf(fileName, "captureImage/imgCanny%d.png", i);
cvSaveImage(fileName , imgCanny, 0);
Frame2Ipl(imgOrigin, imgResult); // save image to IplImage structure & resize image from 720x480 to 320x240
pthread_mutex_unlock(&mutex);
//cvCanny(imgOrigin, imgCanny, 100, 100, 3);
sprintf(fileName, "captureImage/imgyuv%d.png", i);
cvSaveImage(fileName , imgOrigin, 0);
//sprintf(fileName, "captureImage/imgOrigin%d.png", i);
//cvSaveImage(fileName, imgOrigin, 0);
// TODO : control steering angle based on captured image ---------------
//speed set
speed = DesireSpeed_Read();
printf("DesireSpeed_Read() = %d \n", speed);
//speed = -10;
//DesireSpeed_Write(speed);
if(flag == 1){
if(greenlight>1000)
{
printf("right go\n");
Winker_Write(LEFT_ON);
usleep(1000000);
//Winker_Write(ALL_OFF);
angle = 1400;
SteeringServoControl_Write(angle);
speed = 10;
DesireSpeed_Write(speed);
speed = DesireSpeed_Read();
printf("DesireSpeed_Read() = %d \n", speed);
sleep(1);
flag = 0;
}
else
{
printf("left go\n");
Winker_Write(RIGHT_ON);
usleep(10000);
Winker_Write(ALL_OFF);
speed = 20;
DesireSpeed_Write(speed);
usleep(1300000);
angle = 1950;
SteeringServoControl_Write(angle);
usleep(5000000);
angle = 1460;
SteeringServoControl_Write(angle);
usleep(1000000);
speed = 0;
DesireSpeed_Write(speed);
flag = 0;
}
}
// ---------------------------------------------------------------------
GetTime(&pt2);
ptime2 = (NvU64)pt2.tv_sec * 1000000000LL + (NvU64)pt2.tv_nsec;
printf("--------------------------------operation time=%llu.%09llu[s]\n", (ptime2-ptime1)/1000000000LL, (ptime2-ptime1)%1000000000LL);
i++;
}
}
//--------------------------------HOUGHLINES---------------------------------
void sendtoHoughLines(IplImage * img)
{
IplImage* src = cvCreateImage(
cvGetSize(img), 8, 1 );
cvCvtColor(img, src, CV_RGB2GRAY);
//-------------CREATING A IMAGE NAMED dst FOR EDGE SHOWING ON IT FROM CANNY RESULT--------------------
IplImage* dst = cvCreateImage(
cvGetSize(src), 8, 1 );
//---------------CREATING color_dst IMAGE FOR RESULT OF LINE DISPLAY PURPOSE---------------------------
IplImage *color_dst = cvCreateImage(
cvGetSize(src), 8, 3 );
//---------------CEATING A STORE POOL FOR LINE PURPOSE AND LINE DECLARATIVE PARAMETER-------------
CvMemStorage* storage =
cvCreateMemStorage(0);
CvSeq* lines = 0;
int i;
//---------------APPLYING THE CANNY FUNCTION ON SRC AND STORING THE EDGE RESULTS IN DST-------------
cvCanny( src, dst,30, 90, 3 );
cvDilate( dst, dst, 0, 1 );
//--------------CONVERTING THE CANNY RESULT IMAGE DST INTO RGB AND STORE IT IN COLORDST AND SHOWING A WINDOW OF IT--------------
cvCvtColor( dst, color_dst, CV_GRAY2BGR );
/*
//-----hough lines algo--------
lines = cvHoughLines2( dst, storage,
CV_HOUGH_PROBABILISTIC, 1, CV_PI/180, 30, 30, 0 );
//---------------ACCESING THE POINTS OF THE LINES AND DRAWING THOSE LINES ON THE GRAY TO RGB CONVERTED IMAGE NAMED color_dst--------------
for( i = 0; i < lines->total; i++ )
{
CvPoint* line =
(CvPoint*)cvGetSeqElem(lines,i);
cvLine( color_dst, line[0], line[1],
CV_RGB(255,0,0), 3, 8 );
//printf("\n i = %d x1 = %d y1 = %d x2 = %d y2 = %d ",i,line[0].x,line[0].y,line[1].x,line[1].y);
}
*/
lines = cvHoughLines2( dst, storage,
CV_HOUGH_STANDARD, 1, CV_PI/180, 30, 0, 0 );
for( i = 0; i < MIN(lines->total,100); i++ )
{
float* line =
(float*)cvGetSeqElem(lines,i);
float rho = line[0];
float theta = line[1];
printf("theta = %f",(theta*180/3.142));
CvPoint pt1, pt2;
double a = cos(theta), b = sin(theta);
double x0 = a*rho, y0 = b*rho;
printf("a= %f b=%f x0=%f y0=%f roh=%f\n", a,b,x0,y0,rho);
pt1.x = cvRound(x0 + 1000*(-b));
pt1.y = cvRound(y0 + 1000*(a));
pt2.x = cvRound(x0 - 1000*(-b));
pt2.y = cvRound(y0 - 1000*(a));
printf(" x1 = %d, y1 = %d",pt1.x,pt1.y);
printf(" x2 = %d, y2 = %d\n\n",pt2.x,pt2.y);
//if((theta*180/3.142) < 100 && (theta*180/3.142) > 79 )
cvLine( color_dst, pt1, pt2,
CV_RGB(255,0,0), 3, 8 );
}
cvNamedWindow("HoughLinesShow",1);
cvShowImage("HoughLinesShow",color_dst);
cvWaitKey(1000);
}
int OnNewvision(IplImage* currImageBefore, IplImage* maskImage)
{
//int pAPosition[6][2]={0};//pointArrayPosition
//pAPosition[0][0]=0; pAPosition[0][1]=6;
//pAPosition[1][0]=6; pAPosition[1][1]=0;
//pAPosition[2][0]=12;pAPosition[2][1]=6;
//pAPosition[3][0]=0; pAPosition[3][1]=9;
//pAPosition[4][0]=6; pAPosition[4][1]=12;
//pAPosition[5][0]=12;pAPosition[5][1]=9;
//ListPoint pointSet1;
//pointSet1.Item = (ArrayPoint*)MallocArrayPoint();
//for (int dIndex = 0; dIndex <3; dIndex++)
//{//cvPoint(wIndex, hIndex)
// pointSet1.Item->push_back(cvPoint(pAPosition[dIndex][0], pAPosition[dIndex][1]));
//}
//
//cvCircleObj outCircle1;
//if(pointSet1.Item->size() == 0)
// return;
//FitCircleObj(pointSet1, &outCircle1);
//ListPoint pointSet2;
//pointSet2.Item = (ArrayPoint*)MallocArrayPoint();
//for (int dIndex = 3; dIndex <6; dIndex++)
//{//cvPoint(wIndex, hIndex)
// pointSet2.Item->push_back(cvPoint(pAPosition[dIndex][0], pAPosition[dIndex][1]));
//}
//cvCircleObj outCircle2;
//if(pointSet2.Item->size() == 0)
// return;
//FitCircleObj(pointSet2, &outCircle2);
//IplImage* currImage1 = cvCreateImage(cvSize(2000, 3000), IPL_DEPTH_8U, 1);
//memset(currImage1->imageData, 0, currImage1->height*currImage1->widthStep*sizeof(unsigned char));
//int bwPosition = 0;
//for (int hIndex = 0; hIndex < currImage1->width; hIndex++)
//{
// int y1 = 0, y2 = 0;
// y1 = sqrt( outCircle1.Radius * outCircle1.Radius - hIndex * hIndex);
// y2 = sqrt( outCircle2.Radius * outCircle2.Radius - hIndex * hIndex);
// for (int wIndex = 0; wIndex < currImage1->height; wIndex++)
// {
// bwPosition = hIndex*currImage1->widthStep + wIndex;
// if( wIndex < y1)
// currImage1->imageData[bwPosition] = 0;
// else if (wIndex > y1 && wIndex < y2)
// currImage1->imageData[bwPosition] = 255;
// else
// currImage1->imageData[bwPosition] = 0;
// }
//}
//cvShowImage("currImage1",currImage1);
//cvWaitKey(0);
//cvReleaseImage(&currImage1);
//return;
int hIndex = 0, wIndex = 0, ImagePosition = 0, TempPosition = 0, colorValue = 0;
bool leakLight = false; int LeakLightNum = 5;
//IplImage* currImageBefore = cvLoadImage("00.bmp", CV_LOAD_IMAGE_GRAYSCALE);
if (currImageBefore == NULL)
return 1;
if (maskImage == NULL)
{
return 2;
}
IplImage* currImage = cvCreateImage(cvSize(currImageBefore->width, currImageBefore->height), IPL_DEPTH_8U, 1);
memset(currImage->imageData, 0, currImage->height*currImage->widthStep*sizeof(unsigned char));
//使用Mask
cvCopy(currImageBefore, currImage, maskImage);
//cvShowImage("currImage",currImage);
//cvWaitKey(0);
IplImage* EdgeImage = cvCreateImage(cvSize(currImageBefore->width, currImageBefore->height), IPL_DEPTH_8U, 1);
memset(EdgeImage->imageData, 0, EdgeImage->height*EdgeImage->widthStep*sizeof(unsigned char));
cvCanny(currImage, EdgeImage, 50, 180, 3);
//cvShowImage("EdgeImage", EdgeImage);
//cvWaitKey(0);
int edgeTempPosition = 0;
for (int hIndex = 1; hIndex < EdgeImage->height - 1; hIndex++)
{
for (int wIndex = 1; wIndex < EdgeImage->width - 1; wIndex++)
{
edgeTempPosition = hIndex*EdgeImage->widthStep + wIndex;
if (EdgeImage->imageData[edgeTempPosition] == 255)
if (maskImage->imageData[edgeTempPosition + 1] == 0
|| maskImage->imageData[edgeTempPosition - 1] == 0
|| maskImage->imageData[edgeTempPosition + maskImage->widthStep] == 0
|| maskImage->imageData[edgeTempPosition - maskImage->widthStep] == 0)
EdgeImage->imageData[edgeTempPosition] = 0;
}
}
//cvShowImage("EdgeImage2", EdgeImage);
////cvSaveImage("E:\\wuxi\\EdgeImage.jpg",EdgeImage);
//cvWaitKey(0);
ListPoint pointSet; ListPoint bestPoint; ListPoint tempPoint;
pointSet.Item = (ArrayPoint*)MallocArrayPoint();
bestPoint.Item = (ArrayPoint*)MallocArrayPoint();
tempPoint.Item = (ArrayPoint*)MallocArrayPoint();
ListPoint pointSet13, pointSet23, pointSet33;
ListPoint bestPoint13, bestPoint23, bestPoint33;
pointSet13.Item = (ArrayPoint*)MallocArrayPoint();
pointSet23.Item = (ArrayPoint*)MallocArrayPoint();
pointSet33.Item = (ArrayPoint*)MallocArrayPoint();
bestPoint13.Item = (ArrayPoint*)MallocArrayPoint();
bestPoint23.Item = (ArrayPoint*)MallocArrayPoint();
bestPoint33.Item = (ArrayPoint*)MallocArrayPoint();
IplImage* markImage = cvCreateImage(cvGetSize(currImage), IPL_DEPTH_8U, 1);
memset(markImage->imageData, 0, markImage->height*markImage->widthStep*sizeof(unsigned char));
//ArrayPoint* PointArray = (ArrayPoint*)MallocArrayPoint();
ListRect rectList; ListInt intAreaList;
rectList.Item = (ArrayRect*)MallocArrayRect();
intAreaList.Item = (ArrayInt *)MallocArrayInt();
ExtractAllEdgePointNumForItem(EdgeImage, markImage, cvRect(0, 0, currImageBefore->width, currImageBefore->height), 255, &pointSet);
//未搜寻到边缘点，可能是已经边缘效果不好或者是无料
if (pointSet.Item->size() == 0 || pointSet.Item->size() < 10)
{
cvReleaseImage(&currImageBefore);
//cvReleaseImage(&maskImage);
cvReleaseImage(&markImage);
cvReleaseImage(&currImage);
cvReleaseImage(&EdgeImage);
return 3;
}
CvPoint PartTempPoint;
for (int dIndex = 0; dIndex < pointSet.Item->size() / 3; dIndex++)
{
PartTempPoint = (*pointSet.Item)[dIndex];
AddArrayPoint(pointSet13.Item, PartTempPoint);
}
cvCircleObj TempCircle;
memset(markImage->imageData, 0, markImage->height*markImage->widthStep*sizeof(unsigned char));
//之前使用方法为全部进行ransac滤除，之后为缩短时间修改为1/3、1/3、1/3进行滤除
//RansacCirclePoint(pointSet, &bestPoint, &tempPoint);
//if(bestPoint.Item->size() == 0)
//{
// cvReleaseImage(&currImageBefore);
// cvReleaseImage(&maskImage);
// cvReleaseImage(&markImage);
// cvReleaseImage(&currImage);
// cvReleaseImage(&EdgeImage);
// return;
//}
//SortPointsListByXValue(&bestPoint);
RansacCirclePoint(pointSet13, &bestPoint13, &tempPoint);
if (bestPoint13.Item->size() == 0)
{
cvReleaseImage(&currImageBefore);
//cvReleaseImage(&maskImage);
cvReleaseImage(&markImage);
cvReleaseImage(&currImage);
cvReleaseImage(&EdgeImage);
return 4;
}
cvCircleObj outCircle;
cvCircleObj outCircle13, outCircle23, outCircle33;
//ListPoint bestPoint13, bestPoint23, bestPoint33;
//bestPoint13.Item = (ArrayPoint*)MallocArrayPoint();
//bestPoint23.Item = (ArrayPoint*)MallocArrayPoint();
//bestPoint33.Item = (ArrayPoint*)MallocArrayPoint();
//for (int dIndex = 0; dIndex< bestPoint.Item->size()/3; dIndex++)
//{
// AddArrayPoint(bestPoint13.Item, (*bestPoint.Item)[dIndex]);
//}
FitCircleObj(bestPoint13, &outCircle13);
if (outCircle13.CirclePoint.x < 0 || outCircle13.CirclePoint.y >0)
{
for (int dIndex = pointSet.Item->size() / 3; dIndex < 2 * pointSet.Item->size() / 3; dIndex++)
{
PartTempPoint = (*pointSet.Item)[dIndex];
AddArrayPoint(pointSet23.Item, PartTempPoint);
}
RansacCirclePoint(pointSet23, &bestPoint23, &tempPoint);
if (bestPoint23.Item->size() == 0)
{
cvReleaseImage(&currImageBefore);
//cvReleaseImage(&maskImage);
cvReleaseImage(&markImage);
cvReleaseImage(&currImage);
cvReleaseImage(&EdgeImage);
return 5;
}
FitCircleObj(bestPoint23, &outCircle23);
if (outCircle23.CirclePoint.x < 0 || outCircle23.CirclePoint.y >0)
{
for (int dIndex = 2 * pointSet.Item->size() / 3; dIndex < pointSet.Item->size(); dIndex++)
{
PartTempPoint = (*pointSet.Item)[dIndex];
AddArrayPoint(pointSet33.Item, PartTempPoint);
}
RansacCirclePoint(pointSet33, &bestPoint33, &tempPoint);
if (bestPoint33.Item->size() == 0)
{
cvReleaseImage(&currImageBefore);
//cvReleaseImage(&maskImage);
cvReleaseImage(&markImage);
cvReleaseImage(&currImage);
cvReleaseImage(&EdgeImage);
return 6;
}
FitCircleObj(bestPoint33, &outCircle33);
if (outCircle33.CirclePoint.x < 0 || outCircle33.CirclePoint.y >0)
{
outCircle.CirclePoint.x = 0;
outCircle.CirclePoint.y = 1;
outCircle.Radius = 1;
}
else
outCircle = outCircle33;;
}
else
outCircle = outCircle23;
}
else
outCircle = outCircle13;
//FitCircleObj(bestPoint, &outCircle);
if (outCircle.CirclePoint.y == 1 && outCircle.Radius == 1)
{
cvReleaseImage(&currImageBefore);
//cvReleaseImage(&maskImage);
cvReleaseImage(&markImage);
cvReleaseImage(&currImage);
cvReleaseImage(&EdgeImage);
return 7;
}
ListPoint pointOutCircleSet;
pointOutCircleSet.Item = (ArrayPoint*)MallocArrayPoint();
int radiusAdd = 0;
int radiusMove = 35;
for (int dIndex = 0; dIndex < VL_MAX(bestPoint.Item->size(), 0); dIndex++)
{
CvPoint TempPoint;
TempPoint.x = ((*bestPoint.Item)[dIndex]).x;
TempPoint.y = ((*bestPoint.Item)[dIndex]).y + radiusMove;
AddArrayPoint(pointOutCircleSet.Item, TempPoint);
}
ListPoint pointMoreCircleSet;
pointMoreCircleSet.Item = (ArrayPoint*)MallocArrayPoint();
for (int wIndex = 0; wIndex < currImageBefore->width; wIndex++)
{
CvPoint TempPoint;
CvPoint TempOutPoint;
float x = 0, y = 0;
x = wIndex - outCircle.CirclePoint.x;
//y = dIndex - outCircle.CirclePoint.y;
y = sqrt((outCircle.Radius + radiusMove) * (outCircle.Radius + radiusMove) - x * x);
TempPoint.x = wIndex;
if (outCircle.CirclePoint.y < 0)
y = VL_MAX(0, outCircle.CirclePoint.y + y);
else
y = VL_MAX(0, outCircle.CirclePoint.y - y);
TempPoint.y = y;
if (TempPoint.x >= 0 && TempPoint.y >= 0)
AddArrayPoint(pointMoreCircleSet.Item, TempPoint);
}
SortPointsListByXValue(&pointMoreCircleSet);
int maskCircleTemp = 0;
for (int wIndex = 0; wIndex < markImage->width; wIndex++)
{
for (int hIndex = 0; hIndex < markImage->height; hIndex++)
{
maskCircleTemp = hIndex*markImage->widthStep + wIndex;
if (hIndex <= ((*pointMoreCircleSet.Item)[wIndex]).y)
{
markImage->imageData[maskCircleTemp] = 255;
}
}
}
int a[4] = { 0 };
//currImageBefore = cvLoadImage("E:\\wuxi\\leak\\1532.bmp", CV_LOAD_IMAGE_GRAYSCALE);
getMaxDistance(currImageBefore, &pointMoreCircleSet, a);
int subPotion = 0;
for (int hIndex = 0; hIndex < markImage->height; hIndex++)
{
for (int wIndex = 0; wIndex < markImage->width; wIndex++)
{
subPotion = hIndex*markImage->widthStep + wIndex;
//currImageBefore->imageData[subPotion] -= maskCircle->imageData[subPotion];
//if (maskCircle->imageData[subPotion] == 255)
// currImageBefore->imageData[subPotion] = 0;
if (currImageBefore->imageData[subPotion] - markImage->imageData[subPotion] <= 0)
currImageBefore->imageData[subPotion] = 0;
if (currImageBefore->imageData[subPotion] - markImage->imageData[subPotion] >= 255)
currImageBefore->imageData[subPotion] = 255;
}
}
cvThreshold(currImageBefore, markImage, 110, 255, CV_THRESH_BINARY);
//cvShowImage("currbf", currImageBefore);
//cvWaitKey(0);
CvPoint LineCenter;
CvPoint LineCenter2;
LineCenter2.x = (int)outCircle.CirclePoint.x;
LineCenter2.y = (int)outCircle.CirclePoint.y;
//LineCenter.x = (a[1]+a[0]/2);
LineCenter.x = a[1] + a[0] / 2;
LineCenter.y = a[3];
CvSize imgSize = cvSize(currImageBefore->width, currImageBefore->height);
CvRect Zone;
Zone.x = 0;
Zone.y = 0;
Zone.width = 0;
Zone.height = 0;
int checkLightValue = 55;
bool Zone0 = false, Zone1 = false, Zone2 = false, Zone3 = false, Zone4 = false;
//没有豁口区域
if (a[0] == 0)
{
if (getMinYPositon(&pointMoreCircleSet, 0, currImage->width, &Zone, a, imgSize, 0))
{
if (getMinYPositon(&pointMoreCircleSet, 0, currImageBefore->width, &Zone, a, imgSize, 0))
Zone0 = CheckZoneLeak(currImageBefore, Zone, LeakLightNum, checkLightValue);
//IplImage* ZoneImg = cvCreateImage(cvSize(Zone.width, Zone.height), IPL_DEPTH_8U, 1);
//memset(ZoneImg->imageData, 0, ZoneImg->height*ZoneImg->widthStep*sizeof(unsigned char));
//IplImage* ZoneImg2 = cvCreateImage(cvSize(Zone.width, Zone.height), IPL_DEPTH_8U, 1);
//memset(ZoneImg2->imageData, 0, ZoneImg2->height*ZoneImg2->widthStep*sizeof(unsigned char));
//cvSetImageROI(currImageBefore,Zone);
//cvCopy(currImageBefore,ZoneImg);
//cvResetImageROI(currImageBefore);
//cvThreshold(ZoneImg, ZoneImg2, 110, 255, CV_THRESH_BINARY);
//int leakNum = 0;
//int bwPosition = 0;
//for (int hIndex = 0; hIndex < ZoneImg2->height; hIndex++)
//{
// for (int wIndex = 0; wIndex < ZoneImg2->width; wIndex++)
// {
// bwPosition = hIndex*ZoneImg2->widthStep + wIndex;
// if( ZoneImg2->imageData[bwPosition] == 255)
// leakNum++;
// }
//}
//if (leakNum > LeakLightNum)
//{
// leakLight = true;
// //cvShowImage("ZoneImage2", ZoneImg2);
// //cvWaitKey(0);
//}
//cvReleaseImage(&ZoneImg);
}
//getMinYPositon(ListPoint* line, int firstPosition, int lastPosition, CvRect* zone, int* a, int direction)
}
else//有豁口区域
{
//getMinYPositon
if (a[1] > currImageBefore->width / 2)
{
if (getMinYPositon(&pointMoreCircleSet, a[2], currImageBefore->width, &Zone, a, imgSize, 4))
Zone4 = CheckZoneLeak(currImageBefore, Zone, LeakLightNum, checkLightValue);
if (getMinYPositon(&pointMoreCircleSet, 0, a[1], &Zone, a, imgSize, 3))
Zone3 = CheckZoneLeak(currImageBefore, Zone, LeakLightNum, checkLightValue);
}
if (a[1] <= currImageBefore->width / 2)
{
if (getMinYPositon(&pointMoreCircleSet, 0, a[1], &Zone, a, imgSize, 1))
Zone1 = CheckZoneLeak(currImageBefore, Zone, LeakLightNum, checkLightValue);
if (getMinYPositon(&pointMoreCircleSet, a[2], currImageBefore->width, &Zone, a, imgSize, 2))
Zone2 = CheckZoneLeak(currImageBefore, Zone, LeakLightNum, checkLightValue);
}
}
cvReleaseImage(&currImageBefore);
//cvReleaseImage(&maskImage);
cvReleaseImage(&markImage);
cvReleaseImage(&currImage);
cvReleaseImage(&EdgeImage);
bool lastResult = false;
if (Zone0 || Zone1 || Zone2 || Zone3 || Zone4)
{
lastResult = true;
return -1;
}
lastResult = false;
return 0;
}
//-------DETECT FACE OF GADHIJI ---------------
void detectAllFaces( IplImage *img )
{
// -------THIS STRUCTURE TO GIVES DETAILS OF DETECTED FACE-----------
GandhitplMatch detectedimg[10];
//cvNamedWindow("displayface",1);
int k;
int cnt=0;
CvRect *r1;
CvScalar s;
int fl=0;
/* detect faces */
CvSeq *faces = cvHaarDetectObjects(
img,
cascade,
storage,
1.1,
1,
0 /*CV_HAAR_DO_CANNY_PRUNNING*/,
cvSize( 30, 30 ) );
globalmaximum=-999;
globalmaxindex=-1;
/* for each face found, draw a red box */
for( k = 0 ; k < ( faces ? faces->total : 0 ) ; k++ ) {
r1 = ( CvRect* )cvGetSeqElem( faces, k );
if((r1->height<100)&&(r1->width<100))
{
fl=1;
detectedimg[k].faceimg=cvCreateImage(cvGetSize(img),8,3);
cvCopyImage(img,detectedimg[k].faceimg);
detectedimg[k].height=r1->height;
detectedimg[k].width=r1->width;
detectedimg[k].x=r1->x;
detectedimg[k].y=r1->y;
// cvShowImage("displayface",detectedimg[k].faceimg);
//cvWaitKey(100);
/*cvRectangle( img,
cvPoint( r1->x, r1->y ),
cvPoint( r1->x + r1->width, r1->y + r1->height ),
CV_RGB( 255, 0, 0 ), 1, 8, 0 ); */
//printf("facedetection called");
// printf("width= %d height= %d",detectedimg[k].faceimg->width,detectedimg[k].faceimg->height);
for(int i=0;i<img->height;i++)
{
//printf("....");
for(int j=0;j<img->width;j++)
{
// printf("hi %d",j);
if((j<r1->x || j>r1->x + r1->width) || (i<r1->y || i>r1->y + r1->height))
{
s = cvGet2D(detectedimg[k].faceimg, i, j);
// printf("hi.....");
// s.
// s.val[3]=0.0;
s.val[0]=0.0;
s.val[1]=0.0;
s.val[2]=0.0;
cvSet2D(detectedimg[k].faceimg, i, j, s );
}
}
// printf("over j");
}
//cvShowImage("displayface",detectedimg[k].faceimg);
//cvWaitKey(10);
// printf("width %d height %d\n",r1->width,r1->height);
}
//-------SEND THE DETECTED FACE TO MATCH WITH FACE OF GANDHIJI---------
gandhijitplMatch(detectedimg[k],k);
}
//------KEEP THE MATCHED IMAGE WHOSE MATCH IS GREATER THAN 0.62-----------
if(faces->total>0 && globalmaximum>0.62)
{
GlobalGandhiji[globalcnt].faceimg=detectedimg[globalmaxindex].faceimg;
GlobalGandhiji[globalcnt].x=detectedimg[globalmaxindex].x;
GlobalGandhiji[globalcnt].y=detectedimg[globalmaxindex].y;
GlobalGandhiji[globalcnt].width=detectedimg[globalmaxindex].width;
GlobalGandhiji[globalcnt].height=detectedimg[globalmaxindex].height;
GlobalGandhiji[globalcnt].matchval=globalmaximum;
}
else
{
GlobalGandhiji[globalcnt].matchval=-1;//TO ELIMINATE THE IMAGES
}
globalcnt++;
/* display video */
// cvShowImage( "video", img );
//cvWaitKey(100);
}
IplImage* PlateFinder::FindPlate (IplImage *src) {
IplImage* plate;
IplImage* contourImg = cvCreateImage(cvGetSize(src), IPL_DEPTH_8U, 1); // anh tim contour
IplImage* grayImg = cvCreateImage(cvGetSize(src), IPL_DEPTH_8U, 1); // anh xam
cvCvtColor(src, grayImg, CV_RGB2GRAY);
IplImage* cloneImg = cvCreateImage(cvGetSize(src), IPL_DEPTH_8U, 3);
cloneImg = cvCloneImage(src);
// tien xu ly anh
cvCopy(grayImg, contourImg);
cvNormalize(contourImg, contourImg, 0, 255, CV_MINMAX);
ImageRestoration(contourImg);
IplImage* rectImg = cvCreateImage(cvGetSize(src), IPL_DEPTH_8U, 3);
cvMerge(contourImg, contourImg, contourImg, NULL, rectImg); // tron anh
// tim contour cua buc anh
CvMemStorage *storagePlate = cvCreateMemStorage(0);
CvSeq *contours = cvCreateSeq(CV_SEQ_ELTYPE_POINT, sizeof(CvSeq), sizeof(CvPoint), storagePlate);
cvFindContours(contourImg, storagePlate, &contours, sizeof(CvContour), CV_RETR_EXTERNAL, CV_CHAIN_APPROX_SIMPLE, cvPoint(0, 0));
//cvShowImage("contourImg", contourImg);
int xmin, ymin, xmax, ymax, w, h, s, r;
int count;
double ratio; // ty le chieu rong tren chieu cao
CvRect rectPlate;
// luu lai cac anh co kha nang la bien so
IplImage** plateArr = new IplImage *[5];
int j = 0;
for (int i = 0; i < 5; i++)
{
plateArr[i] = NULL;
}
while (contours) {
count = contours->total;
CvPoint *PointArray = new CvPoint[count];
cvCvtSeqToArray (contours, PointArray, CV_WHOLE_SEQ);
for (int i = 0; i < count; i++)
{
if (i == 0)
{
xmin = xmax = PointArray[i].x;
ymin = ymax = PointArray[i].y;
}
if (PointArray[i].x > xmax) {
xmax = PointArray[i].x;
}
if (PointArray[i].x < xmin) {
xmin = PointArray[i].x;
}
if (PointArray[i].y > ymax) {
ymax = PointArray[i].y;
}
if (PointArray[i].y < ymin) {
ymin = PointArray[i].y;
}
}
w = xmax - xmin;
h = ymax - ymin;
s = w * h;
cvRectangle (rectImg, cvPoint(xmin, ymin), cvPoint(xmax, ymax), RED);
// loai bo nhung hinh chu nhat co ti le khong dung
if (s != 0) {
r = (contourImg->height * contourImg->width) / s;
} else {
r = 1000;
}
if (w == 0 && h == 0) {
ratio = 0;
} else {
ratio = (double)w/h;
}
if (r > 30 && r < 270) {
// ve ra hcn mau xanh la
cvRectangle (rectImg, cvPoint(xmin, ymin), cvPoint(xmax, ymax), GREEN);
if (ratio > 2.6 && ratio < 7) {
cvRectangle (rectImg, cvPoint(xmin, ymin), cvPoint(xmax, ymax), BLUE);
if (w > 80 && w < 250 && h > 25 && h < 150) {
rectPlate = cvRect (xmin, ymin, w, h);
cvRectangle (cloneImg, cvPoint(rectPlate.x, rectPlate.y),
cvPoint(rectPlate.x + rectPlate.width, rectPlate.y + rectPlate.height), RED, 3);
// cat bien so
plate = cvCreateImage(cvSize(rectPlate.width, rectPlate.height), IPL_DEPTH_8U, 3);
cvSetImageROI(src, rectPlate);
cvCopy(src, plate, NULL);
cvResetImageROI(src);
// luu vao mang cac bien so plateArr
int cnt = CountCharacter(plate);
if (cnt >= 5) {
plateArr[j] = cvCloneImage(plate);
j++;
}
}
}
}
delete []PointArray;
contours = contours->h_next;
}
// sap xep
if (plateArr[0])
{
int w = plateArr[0]->width;
int flag;
for (int i = 1; i < 4; i++)
{
if (plateArr[i] && plateArr[i]->width < w)
{
flag = i;
}
}
plateArr[0] = plateArr[flag];
}
cvShowImage("cloneImg", cloneImg);
//cvShowImage("rectImg", rectImg);
//cvShowImage("plate", plateArr[0]);
cvReleaseImage(&contourImg);
cvReleaseImage(&rectImg);
cvReleaseImage(&plate);
return plateArr[0];
}
//--------THIS FUNCTION PERFORMS A TEMPLATE MATCH ON THE ORIGINAL IMAGE TO CROP THE IMAGE FROM BACKGROUND-----------
//-------IN ORDER TO IDENTIFY THE REGION WHERE THE NOTE IS PRESENT----------------
float NotetplMatch(IplImage *img1,int no)
{
//------------NotetplProcessed STORES THE IMAGE EXTRACTED FROM BACKGROUND-------------
NotetplProcessed[no]=cvCreateImage(cvGetSize(img1),8,3);
//-------VARIABLES USED FOR TEMPLATE MATCHING----------
IplImage *img;
IplImage *tpl;
IplImage *res;
CvPoint minloc, maxloc;
double minval, maxval;
int img_width, img_height;
int tpl_width, tpl_height;
int res_width, res_height;
float maxi=-1.0;
int index=0;
//cvNamedWindow( "reference", CV_WINDOW_AUTOSIZE );
//cvNamedWindow( "template", CV_WINDOW_AUTOSIZE );
//cvNamedWindow("result",CV_WINDOW_AUTOSIZE);
//-------TEMPORARY IMAGE-COLOR--------------
img=cvCreateImage(cvGetSize(img1),8,3);
//-----------THIS LOOP MATCHES THE IMAGE WITH 9 DIFFERENT TEMPLATES AS STORED IN THE GLOBAL
// (continued)VARIBLE Notetpl[]----------------
for(int km=0;km<9;km++)
{
cvCopy(img1,img,NULL);
tpl = cvLoadImage(Notetpl[km]);;
img_width = img->width;
img_height = img->height;
tpl_width = tpl->width;
tpl_height = tpl->height;
res_width = img_width - tpl_width + 1;
res_height = img_height - tpl_height + 1;
/* create new image for template matching computation */
res = cvCreateImage( cvSize( res_width, res_height ), IPL_DEPTH_32F, 1 );
/* choose template matching method to be used */
//cvMatchTemplate( img, tpl, res, CV_TM_SQDIFF );
//cvMatchTemplate( img, tpl, res, CV_TM_SQDIFF_NORMED );
//cvMatchTemplate( img, tpl, res, CV_TM_CCORR );
//cvMatchTemplate( img, tpl, res, CV_TM_CCORR_NORMED );
//cvMatchTemplate( img, tpl, res, CV_TM_CCOEFF );
cvMatchTemplate( img, tpl, res, CV_TM_CCOEFF_NORMED );
cvMinMaxLoc( res, &minval, &maxval,&minloc,&maxloc, 0);
/* draw red rectangle */
cvRectangle( img,
cvPoint( maxloc.x, maxloc.y ),
cvPoint( maxloc.x + tpl_width, maxloc.y + tpl_height ),
cvScalar( 0, 0, 255, 0 ), 1, 0, 0 );
CvScalar s;
// printf("\nminval= %f maxval= %f ",minval,maxval);
//------AS WE NEED ONLY HALF PART(RIGHT PART ) OF NOTE WHERE GANDHIJI IS PRESENT THIS LOOP ONLY BRINGS IN FOCUS THAT AREA
// (continued) OTHER PORTION IS BLACKENED--------
for(int i=1;i<img_height;i++)
{
for(int j=1;j<img_width;j++)
{
if((j<maxloc.x+(tpl_width/2) || j>maxloc.x + tpl_width) || (i<maxloc.y || i>maxloc.y + tpl_height))
{
s = cvGet2D(img, i, j);
s.val[0]=0.0;
s.val[1]=0.0;
s.val[2]=0.0;
cvSet2D(img, i, j, s );
}
}
}
//---------COMPARES AMONGST NINE TEMPLATES WHICH IS MAX MATCHED TEMPLATE--------
if(maxval>maxi)
{
maxi=maxval;
cvCopyImage(img,NotetplProcessed[no]);
}
//cvShowImage( "reference", img );
//cvShowImage( "template", tpl );
//cvShowImage("result",res);
//cvWaitKey(100);
}
//printf("\n\nWaiting for next image to load\n");
//cvDestroyWindow( "reference" );
//cvDestroyWindow( "template" );
//cvDestroyWindow( "result" );
return maxi;
}
ImageRAII match( IplImage * image1, IplImage * image2, std::pair< CvMat *, CvMat * > image1_keys, std::pair< CvMat *, CvMat * > image2_keys )
{
ImageRAII appended_images = appendimages( image1, image2 );
ImageRAII rgb_appended_images( cvCreateImage( cvGetSize( appended_images.image ), appended_images.image->depth, 3 ) );
cvCvtColor( appended_images.image, rgb_appended_images.image, CV_GRAY2RGB );
CvScalar red;
red.val[2] = 255;
std::vector< std::pair< int, int > > points;
// check for matches with the vectors in image1 and image2
for( int i = 0; i < image1_keys.first->height; i++ )
{
double magnitude1 = 0;
MatrixRAII current_vector( cvCreateMat( 1, image1_keys.first->cols, CV_32FC1 ) );
// keeps track of minimum row found b/t image1 and image2 vectors
MatrixRAII min( cvCreateMat( 1, image2_keys.first->cols, CV_32FC1 ) );
cvGetRow( image1_keys.first, current_vector.matrix, i );
CvPoint point1 = cvPoint( ( int )cvmGet( current_vector.matrix, 0, 1 ), ( int )cvmGet( current_vector.matrix, 0, 0 ) );
std::map< float, int > angles;
for( int k = 0; k < image1_keys.second->width; k++ )
magnitude1 += pow( cvmGet( image1_keys.second, i, k ), 2 );
magnitude1 = cvSqrt( magnitude1 );
// compare a vector in image1 to every vector in image2 by calculating the cosine simularity
for( int j = 0; j < image2_keys.first->height; j++ )
{
MatrixRAII descriptor1( cvCreateMat( 1, image1_keys.second->cols, CV_32FC1 ) );
MatrixRAII descriptor2( cvCreateMat( 1, image2_keys.second->cols, CV_32FC1 ) );
cvGetRow( image1_keys.second, descriptor1.matrix, i );
cvGetRow( image2_keys.second, descriptor2.matrix, j );
double dot_product = cvDotProduct( descriptor1.matrix, descriptor2.matrix );
double magnitude2 = 0;
for( int k = 0; k < image2_keys.second->width; k++ )
magnitude2 += pow( cvmGet( descriptor1.matrix, 0, k ), 2 );
magnitude2 = cvSqrt( magnitude2 );
angles.insert( std::pair< float, int >( acos( dot_product / ( magnitude1 * magnitude2 ) ), j ) );
}
std::map< float, int >::iterator it = angles.begin();
int index = it->second;
float angle = it->first;
it++;
if( angle < THRESHOLD * it->first )
{
points.push_back( std::make_pair( i, index ) );
}
}
std::vector< std::pair< int, int > >::iterator it;
for( it = points.begin(); it < points.end(); it++ )
{
CvPoint point1 = cvPoint( ( int )cvmGet( image1_keys.first, it->first, 1 ), ( int )cvmGet( image1_keys.first, it->first, 0 ) );
CvPoint point2 = cvPoint( ( int )cvmGet( image2_keys.first, it->second, 1 ) + image1->width, ( int )cvmGet( image2_keys.first, it->second, 0 ) );
cvLine( rgb_appended_images.image, point1, point2, red );
}
return rgb_appended_images;
}
int CvArrTest::validate_test_results( int test_case_idx )
{
static const char* arr_names[] = { "input", "input/output", "output",
"ref input/output", "ref output",
"temporary", "mask" };
int i, j;
prepare_to_validation( test_case_idx );
for( i = 0; i < 2; i++ )
{
int i0 = i == 0 ? OUTPUT : INPUT_OUTPUT;
int i1 = i == 0 ? REF_OUTPUT : REF_INPUT_OUTPUT;
int count = test_array[i0].size();
assert( count == test_array[i1].size() );
for( j = 0; j < count; j++ )
{
double err_level;
CvPoint idx = {0,0};
double max_diff = 0;
int code;
char msg[100];
if( !test_array[i1][j] )
continue;
err_level = get_success_error_level( test_case_idx, i0, j );
code = cvTsCmpEps( &test_mat[i0][j], &test_mat[i1][j], &max_diff, err_level, &idx,
element_wise_relative_error );
switch( code )
{
case -1:
sprintf( msg, "Too big difference (=%g)", max_diff );
code = CvTS::FAIL_BAD_ACCURACY;
break;
case -2:
strcpy( msg, "Invalid output" );
code = CvTS::FAIL_INVALID_OUTPUT;
break;
case -3:
strcpy( msg, "Invalid output in the reference array" );
code = CvTS::FAIL_INVALID_OUTPUT;
break;
default:
continue;
}
ts->printf( CvTS::LOG, "%s in %s array %d at (%d,%d)\n", msg,
arr_names[i0], j, idx.x, idx.y );
for( i0 = 0; i0 < max_arr; i0++ )
{
int count = test_array[i0].size();
if( i0 == REF_INPUT_OUTPUT || i0 == OUTPUT || i0 == TEMP )
continue;
for( i1 = 0; i1 < count; i1++ )
{
CvArr* arr = test_array[i0][i1];
if( arr )
{
CvSize size = cvGetSize(arr);
int type = cvGetElemType(arr);
ts->printf( CvTS::LOG, "%s array %d type=%sC%d, size=(%d,%d)\n",
arr_names[i0], i1, cvTsGetTypeName(type),
CV_MAT_CN(type), size.width, size.height );
}
}
}
ts->set_failed_test_info( code );
return code;
}
}
return 0;
}
bool CvCaptureCAM_DC1394_v2_CPP::grabFrame()
{
dc1394capture_policy_t policy = DC1394_CAPTURE_POLICY_WAIT;
bool code = false, isColor;
dc1394video_frame_t *dcFrame = 0, *fs = 0;
int i, nch;
if (!dcCam || (!started && !startCapture()))
return false;
dc1394_capture_dequeue(dcCam, policy, &dcFrame);
if (!dcFrame)
return false;
if (/*dcFrame->frames_behind > 1 ||*/ dc1394_capture_is_frame_corrupt(dcCam, dcFrame) == DC1394_TRUE)
{
goto _exit_;
}
isColor = dcFrame->color_coding != DC1394_COLOR_CODING_MONO8 &&
dcFrame->color_coding != DC1394_COLOR_CODING_MONO16 &&
dcFrame->color_coding != DC1394_COLOR_CODING_MONO16S;
if (nimages == 2)
{
fs = (dc1394video_frame_t*)calloc(1, sizeof(*fs));
//dc1394_deinterlace_stereo_frames(dcFrame, fs, DC1394_STEREO_METHOD_INTERLACED);
dc1394_deinterlace_stereo_frames_fixed(dcFrame, fs, DC1394_STEREO_METHOD_INTERLACED);
dc1394_capture_enqueue(dcCam, dcFrame); // release the captured frame as soon as possible
dcFrame = 0;
if (!fs->image)
goto _exit_;
isColor = colorStereo;
}
nch = isColor ? 3 : 1;
for (i = 0; i < nimages; i++)
{
IplImage fhdr;
dc1394video_frame_t f = fs ? *fs : *dcFrame, *fc = &f;
f.size[1] /= nimages;
f.image += f.size[0] * f.size[1] * i; // TODO: make it more universal
if (isColor)
{
if (!frameC)
frameC = (dc1394video_frame_t*)calloc(1, sizeof(*frameC));
frameC->color_coding = nch == 3 ? DC1394_COLOR_CODING_RGB8 : DC1394_COLOR_CODING_MONO8;
if (nimages == 1)
{
dc1394_convert_frames(&f, frameC);
dc1394_capture_enqueue(dcCam, dcFrame);
dcFrame = 0;
}
else
{
f.color_filter = bayerFilter;
dc1394_debayer_frames(&f, frameC, bayer);
}
fc = frameC;
}
if (!img[i])
img[i] = cvCreateImage(cvSize(fc->size[0], fc->size[1]), 8, nch);
cvInitImageHeader(&fhdr, cvSize(fc->size[0], fc->size[1]), 8, nch);
cvSetData(&fhdr, fc->image, fc->size[0]*nch);
// Swap R&B channels:
if (nch==3)
cvConvertImage(&fhdr,&fhdr,CV_CVTIMG_SWAP_RB);
if( rectify && cameraId == VIDERE && nimages == 2 )
{
if( !maps[0][0] || maps[0][0]->width != img[i]->width || maps[0][0]->height != img[i]->height )
{
CvSize size = cvGetSize(img[i]);
cvReleaseImage(&maps[0][0]);
cvReleaseImage(&maps[0][1]);
cvReleaseImage(&maps[1][0]);
cvReleaseImage(&maps[1][1]);
maps[0][0] = cvCreateImage(size, IPL_DEPTH_16S, 2);
maps[0][1] = cvCreateImage(size, IPL_DEPTH_16S, 1);
maps[1][0] = cvCreateImage(size, IPL_DEPTH_16S, 2);
maps[1][1] = cvCreateImage(size, IPL_DEPTH_16S, 1);
char buf[4*4096];
if( getVidereCalibrationInfo( buf, (int)sizeof(buf) ) &&
initVidereRectifyMaps( buf, maps[0], maps[1] ))
;
else
rectify = false;
}
cvRemap(&fhdr, img[i], maps[i][0], maps[i][1]);
}
else
cvCopy(&fhdr, img[i]);
}
code = true;
_exit_:
if (dcFrame)
dc1394_capture_enqueue(dcCam, dcFrame);
if (fs)
{
if (fs->image)
free(fs->image);
free(fs);
}
return code;
}
//I is just a sample image for allocation purposes
void AllocateImages(IplImage *I){ //I is passed in for sizing
IavgF = cvCreateImage( cvGetSize(I), IPL_DEPTH_32F, 3 );
IdiffF = cvCreateImage( cvGetSize(I), IPL_DEPTH_32F, 3 );
IprevF = cvCreateImage( cvGetSize(I), IPL_DEPTH_32F, 3 );
IhiF = cvCreateImage( cvGetSize(I), IPL_DEPTH_32F, 3 );
IlowF = cvCreateImage(cvGetSize(I), IPL_DEPTH_32F, 3 );
Ilow1 = cvCreateImage( cvGetSize(I), IPL_DEPTH_32F, 1 );
Ilow2 = cvCreateImage( cvGetSize(I), IPL_DEPTH_32F, 1 );
Ilow3 = cvCreateImage( cvGetSize(I), IPL_DEPTH_32F, 1 );
Ihi1 = cvCreateImage( cvGetSize(I), IPL_DEPTH_32F, 1 );
Ihi2 = cvCreateImage( cvGetSize(I), IPL_DEPTH_32F, 1 );
Ihi3 = cvCreateImage( cvGetSize(I), IPL_DEPTH_32F, 1 );
cvZero(IavgF );
cvZero(IdiffF );
cvZero(IprevF );
cvZero(IhiF );
cvZero(IlowF );
Icount = 0.00001; //Protect against divide by zero
Iscratch = cvCreateImage( cvGetSize(I), IPL_DEPTH_32F, 3 );
Iscratch2 = cvCreateImage( cvGetSize(I), IPL_DEPTH_32F, 3 );
Igray1 = cvCreateImage( cvGetSize(I), IPL_DEPTH_32F, 1 );
Igray2 = cvCreateImage( cvGetSize(I), IPL_DEPTH_32F, 1 );
Igray3 = cvCreateImage( cvGetSize(I), IPL_DEPTH_32F, 1 );
Imaskt = cvCreateImage( cvGetSize(I), IPL_DEPTH_8U, 1 );
cvZero(Iscratch);
cvZero(Iscratch2 );}
/*!
\fn CvGabor::get_image(int Type)
Get the speific type of image of Gabor
Parameters:
Type The Type of gabor kernel, e.g. REAL, IMAG, MAG, PHASE
Returns:
Pointer to image structure, or NULL on failure
Return an Image (gandalf image class) with a specific Type "REAL" "IMAG" "MAG" "PHASE"
*/
IplImage* CvGabor::get_image(int Type)
{
if(IsKernelCreate() == false)
{
perror("Error: the Gabor kernel has not been created in get_image()!\n");
return NULL;
}
else
{
IplImage* pImage;
IplImage *newimage;
newimage = cvCreateImage(cvSize(Width,Width), IPL_DEPTH_8U, 1 );
//printf("Width is %d.\n",(int)Width);
//printf("Sigma is %f.\n", Sigma);
//printf("F is %f.\n", F);
//printf("Phi is %f.\n", Phi);
//pImage = gan_image_alloc_gl_d(Width, Width);
pImage = cvCreateImage( cvSize(Width,Width), IPL_DEPTH_32F, 1 );
CvMat* kernel = cvCreateMat(Width, Width, CV_32FC1);
CvMat* re = cvCreateMat(Width, Width, CV_32FC1);
CvMat* im = cvCreateMat(Width, Width, CV_32FC1);
double ve, ve1,ve2;
CvScalar S;
CvSize size = cvGetSize( kernel );
int rows = size.height;
int cols = size.width;
switch(Type)
{
case 1: //Real
cvCopy( (CvMat*)Real, (CvMat*)kernel, NULL );
//pImage = cvGetImage( (CvMat*)kernel, pImageGL );
for (int i = 0; i < rows; i++)
{
for (int j = 0; j < cols; j++)
{
ve = cvGetReal2D((CvMat*)kernel, i, j);
cvSetReal2D( (IplImage*)pImage, j, i, ve );
}
}
break;
case 2: //Imag
cvCopy( (CvMat*)Imag, (CvMat*)kernel, NULL );
//pImage = cvGetImage( (CvMat*)kernel, pImageGL );
for (int i = 0; i < rows; i++)
{
for (int j = 0; j < cols; j++)
{
ve = cvGetReal2D((CvMat*)kernel, i, j);
cvSetReal2D( (IplImage*)pImage, j, i, ve );
}
}
break;
case 3: //Magnitude //add by yao
cvCopy( (CvMat*)Real, (CvMat*)re, NULL );
cvCopy( (CvMat*)Imag, (CvMat*)im, NULL );
for (int i = 0; i < rows; i++)
{
for (int j = 0; j < cols; j++)
{
ve1 = cvGetReal2D((CvMat*)re, i, j);
ve2 = cvGetReal2D((CvMat*)im, i, j);
ve = cvSqrt(ve1*ve1+ve2*ve2);
cvSetReal2D( (IplImage*)pImage, j, i, ve );
}
}
break;
case 4: //Phase
///@todo
break;
}
cvNormalize((IplImage*)pImage, (IplImage*)pImage, 0, 255, CV_MINMAX, NULL );
cvConvertScaleAbs( (IplImage*)pImage, (IplImage*)newimage, 1, 0 );
cvReleaseMat(&kernel);
cvReleaseImage(&pImage);
return newimage;
}
}
int MakeFeatureInMem(
IplImage* RGBA,
IplImage* depth,
IplImage* mask,
FEATURE* feature){
if (RGBA==NULL){
fprintf(stderr, "image file is required to create feature set!");
return 1;
}
IplImage *hsv_img, *h, *s, *v;
if (HUELBP_ON){
// convert to hsv image
hsv_img = cvCreateImage( cvGetSize(RGBA), IPL_DEPTH_8U, 3);
cvCvtColor(RGBA, hsv_img, CV_RGB2HSV);
h = cvCreateImage( cvGetSize(hsv_img), IPL_DEPTH_8U, 1 );
s = cvCreateImage( cvGetSize(hsv_img), IPL_DEPTH_8U, 1 );
v = cvCreateImage( cvGetSize(hsv_img), IPL_DEPTH_8U, 1 );
// Split image onto the color planes
cvSplit( hsv_img, h, s, v, NULL );
}
// convert to grayscale-image
IplImage* gray_img = RGBA;
if (RGBA->nChannels > 1) {
gray_img = cvCreateImage(cvGetSize(RGBA), IPL_DEPTH_8U, 1 );
cvCvtColor( RGBA, gray_img, CV_RGB2GRAY );
}
// cvEqualizeHist(gray_img,gray_img);
feature->grid_x = GRID_X;
feature->grid_y = GRID_Y;
feature->radius = RADIUS;
feature->neighbors = NEIGHBORS;
int numPatterns = UNIFORM_ON? (NEIGHBORS+2) : pow(2.0, NEIGHBORS);
//detect faces
CvSeq* faces;
int retCode = DetectFaces(gray_img, depth, &faces, FOREGRND_ON);
if (retCode){//no faces found
feature->histogram = NULL;
feature->hue_histogram = NULL;
feature->num_faces = 0;
return 0;
}else{
//calculate features
feature->num_faces = faces->total;
feature->histogram = (CvMat**) malloc(faces->total*sizeof(CvMat*));
feature->hue_histogram = (CvMat**) malloc(faces->total*sizeof(CvMat*));
for(int i = 0; i < faces->total; i++ )
{
// Create a new rectangle for drawing the face
CvRect* r = (CvRect*)cvGetSeqElem( faces, i ); // Find the dimensions of the face, and scale it if necessary
IplImage* face_img = CreateSubImg(gray_img, *r);
IplImage* lbp_img = CalcLBP(face_img, RADIUS, NEIGHBORS, UNIFORM_ON);
if (lbp_img==NULL){
fprintf(stderr, "failed to create lbp image!\n");
return 1;
}
feature->histogram[i] = CalcSpatialHistogram(lbp_img, numPatterns, GRID_X, GRID_Y);
if (feature->histogram[i]==NULL){
fprintf(stderr, "failed to create spatial histogram!\n");
return 2;
}
cvReleaseImage(&face_img);
cvReleaseImage(&lbp_img);
if (HUELBP_ON){
// Create a hue face image
IplImage* hue_face_img = CreateSubImg(h, *r);
//Create Hue LBP
IplImage* hue_lbp = CalcLBP(hue_face_img, RADIUS, NEIGHBORS, UNIFORM_ON);
if (hue_lbp==NULL){
fprintf(stderr, "failed to create hue-lbp image!\n");
return 1;
}
//Create Hue Spatial Histogram
feature->hue_histogram[i] = CalcSpatialHistogram(hue_lbp, numPatterns, GRID_X, GRID_Y);
if (feature->hue_histogram[i]==NULL){
fprintf(stderr, "failed to create hue spatial histogram!\n");
return 2;
}
cvReleaseImage(&hue_face_img);
cvReleaseImage(&hue_lbp);
}
}
}
if (HUELBP_ON){
cvReleaseImage(&hsv_img);
cvReleaseImage(&h);
cvReleaseImage(&s);
cvReleaseImage(&v);
}
if (RGBA->nChannels > 1) {
cvReleaseImage(&gray_img);
}
return 0;
}
size_t OpenCVImage::getHeight() const
{
return m_img ? cvGetSize(m_img).height : 0;
}
/*
// Getting feature pyramid
//
// API
// int getFeaturePyramid(IplImage * image, const filterObject **all_F,
const int n_f,
const int lambda, const int k,
const int startX, const int startY,
const int W, const int H, featurePyramid **maps);
// INPUT
// image - image
// lambda - resize scale
// k - size of cells
// startX - X coordinate of the image rectangle to search
// startY - Y coordinate of the image rectangle to search
// W - width of the image rectangle to search
// H - height of the image rectangle to search
// OUTPUT
// maps - feature maps for all levels
// RESULT
// Error status
*/
int getFeaturePyramid(IplImage * image,
const int lambda, const int k,
const int startX, const int startY,
const int W, const int H, CvLSVMFeaturePyramid **maps)
{
IplImage *img2, *imgTmp, *imgResize;
float step, tmp;
int cntStep;
int maxcall;
int i;
int err;
CvLSVMFeatureMap *map;
//geting subimage
cvSetImageROI(image, cvRect(startX, startY, W, H));
img2 = cvCreateImage(cvGetSize(image), image->depth, image->nChannels);
cvCopy(image, img2, NULL);
cvResetImageROI(image);
if(img2->depth != IPL_DEPTH_32F)
{
imgResize = cvCreateImage(cvSize(img2->width , img2->height) , IPL_DEPTH_32F , 3);
cvConvert(img2, imgResize);
}
else
{
imgResize = img2;
}
step = powf(2.0f, 1.0f/ ((float)lambda));
maxcall = W/k;
if( maxcall > H/k )
{
maxcall = H/k;
}
cntStep = (int)(logf((float)maxcall/(5.0f))/logf(step)) + 1;
//printf("Count step: %f %d\n", step, cntStep);
allocFeaturePyramidObject(maps, lambda, cntStep + lambda);
for(i = 0; i < lambda; i++)
{
tmp = 1.0f / powf(step, (float)i);
imgTmp = resize_opencv (imgResize, tmp);
//imgTmp = resize_article_dp(img2, tmp, 4);
err = getFeatureMaps_dp(imgTmp, 4, &map);
err = normalizationAndTruncationFeatureMaps(map, 0.2f);
err = PCAFeatureMaps(map);
(*maps)->pyramid[i] = map;
//printf("%d, %d\n", map->sizeY, map->sizeX);
cvReleaseImage(&imgTmp);
}
/**********************************one**************/
for(i = 0; i < cntStep; i++)
{
tmp = 1.0f / powf(step, (float)i);
imgTmp = resize_opencv (imgResize, tmp);
//imgTmp = resize_article_dp(imgResize, tmp, 8);
err = getFeatureMaps_dp(imgTmp, 8, &map);
err = normalizationAndTruncationFeatureMaps(map, 0.2f);
err = PCAFeatureMaps(map);
(*maps)->pyramid[i + lambda] = map;
//printf("%d, %d\n", map->sizeY, map->sizeX);
cvReleaseImage(&imgTmp);
}/*for(i = 0; i < cntStep; i++)*/
if(img2->depth != IPL_DEPTH_32F)
{
cvReleaseImage(&imgResize);
}
cvReleaseImage(&img2);
return LATENT_SVM_OK;
}
