CBlobResult getBlobs(IplImage* tmp_frame, IplImage* binFore){
//IplImage* binFore = cvCreateImage(cvGetSize(tmp_frame),IPL_DEPTH_8U,1);
//get the binary foreground object
//cvSub( getBinaryImage(tmp_frame) , binBack, binFore, NULL );
//if(!cvSaveImage("binFore.jpg",binFore)) printf("Could not save the backgroundimage\n");
//!Starting the extracting of Blob
CBlobResult blobs;
//! get the blobs from the image, with no mask, using a threshold of 100
blobs = CBlobResult( binFore, NULL, 10, true );
//! Create a file with all the found blob
blobs.PrintBlobs( "blobs.txt" );
//! discard the blobs with less area than 60 pixels
blobs.Filter( blobs, B_INCLUDE, CBlobGetArea(), B_GREATER, 40);
//!This two row of code are to filter the blob find from the library by a bug that match ablob like all the image and return the center of it
blobs.Filter( blobs, B_INCLUDE, CBlobGetArea(), B_LESS, (tmp_frame->height)*(tmp_frame->width)*0.8);
blobs.Filter( blobs, B_INCLUDE, CBlobGetPerimeter(), B_LESS, (tmp_frame->height)+(tmp_frame->width)*2*0.8);
//! Create a file with filtered results
blobs.PrintBlobs( "filteredBlobs.txt" );
//return blobs;
return blobs;
}
void ForegroundDetector::nextIteration(const Mat &img)
{
if(bgImg.empty())
{
return;
}
Mat absImg = Mat(img.cols, img.rows, img.type());
Mat threshImg = Mat(img.cols, img.rows, img.type());
absdiff(bgImg, img, absImg);
threshold(absImg, threshImg, fgThreshold, 255, CV_THRESH_BINARY);
IplImage im = (IplImage)threshImg;
CBlobResult blobs = CBlobResult(&im, NULL, 0);
blobs.Filter(blobs, B_EXCLUDE, CBlobGetArea(), B_LESS, minBlobSize);
vector<Rect>* fgList = detectionResult->fgList;
fgList->clear();
for(int i = 0; i < blobs.GetNumBlobs(); i++)
{
CBlob *blob = blobs.GetBlob(i);
CvRect rect = blob->GetBoundingBox();
fgList->push_back(rect);
}
}
/* Detect blobs larger than min_size in a given IplImage. */
CBlobResult MarkerCapture::detect_blobs(IplImage *img, int min_size = 10){
// find white blobs in thresholded image
CBlobResult blobs = CBlobResult(img, NULL, 0);
// exclude ones smaller than min_size.
blobs.Filter(blobs, B_EXCLUDE, CBlobGetArea(), B_LESS, min_size);
return blobs;
}
CBlobResult computeWhiteMaskOtsu(Mat& imgRGBin, Mat& imgHSVIn, CBlobResult& blobs, int limitRGB, int limitHSV, double RGBratio, double HSVratio, int bmin, int bmax, int i){
waitKey(30);
Mat BGRbands[3];
split(imgRGBin,BGRbands);
Mat imgHSV;
cvtColor(imgHSVIn,imgHSV,CV_BGR2HSV);
Mat HSVbands[3];
split(imgHSV,HSVbands);
Mat maskHSV, maskRGB, maskT;
int otsuTRGB = getThreshVal_Otsu_8u(BGRbands[2]);
do{
threshold(BGRbands[2],maskRGB,otsuTRGB,255,THRESH_BINARY);
otsuTRGB++;
}while(countNonZero(maskRGB)>(RGBratio*limitRGB) & otsuTRGB<=255);
int otsuTHSV = getThreshVal_Otsu_8u(HSVbands[1]);
do{
threshold(HSVbands[1],maskHSV,otsuTHSV,255,THRESH_BINARY_INV);
otsuTHSV--;
}while(countNonZero(maskHSV)>(HSVratio*limitHSV) & otsuTHSV>=0); // 0.1
bitwise_or(maskHSV,maskRGB,maskT);
int blobSizeBefore = blobs.GetNumBlobs();
blobs = blobs + CBlobResult( maskT ,Mat(),8);
blobs.Filter( blobs, B_EXCLUDE, CBlobGetLength(), B_GREATER, bmax );
blobs.Filter( blobs, B_EXCLUDE, CBlobGetLength(), B_LESS, bmin );
int blobSizeAfter = blobs.GetNumBlobs();
Mat newMask(maskT.size(),maskT.type());
newMask.setTo(0);
for(;i<blobs.GetNumBlobs();i++){
double area = blobs.GetBlob(i)->Area();
if(area < 5000 && area > 400)
blobs.GetBlob(i)->FillBlob(newMask,CV_RGB(255,255,255),0,0,true);
}
if(countNonZero(maskRGB)>400 && countNonZero(maskHSV)>400 && blobSizeBefore!=blobSizeAfter){
vector<Mat> BGRbands; split(imgRGBin,BGRbands);
Mat maskedRGB = applyMaskBandByBand(newMask,BGRbands);
bitwise_not(newMask,newMask);
split(imgHSVIn,BGRbands);
Mat maskedHSV = applyMaskBandByBand(newMask,BGRbands);
blobs = computeWhiteMaskOtsu(maskedRGB, maskedHSV, blobs, countNonZero(maskRGB),countNonZero(maskHSV),RGBratio, HSVratio, bmin, bmax, i-1);
}
return blobs;
}
void givedepth(IplImage *localimagergb)
{ IplImage*localimage=cvCreateImage(cvGetSize(localimagergb),IPL_DEPTH_8U,3);
cvCvtColor(localimagergb,localimage,CV_BGR2HSV);
IplImage *blobbedscaling=cvCreateImage(cvGetSize(localimagergb),IPL_DEPTH_8U,3);
uchar *itemp=(uchar *)(localimage->imageData);
IplImage *binaryscaling=cvCreateImage(cvGetSize(localimagergb),IPL_DEPTH_8U,1);
uchar *itemp1=(uchar *)(binaryscaling ->imageData);
for(int i=0;i<hi2->height;i++){
for(int j=0;j<hi2->width;j++){
if((itemp[i*localimage->widthStep+j*localimage->nChannels] <hh)
&&
(itemp[i*localimage->widthStep+j*localimage->nChannels]>hl)
&&
(itemp[i*localimage->widthStep+j*localimage->nChannels+1]<sh)
&&
(itemp[i*localimage->widthStep+j*localimage->nChannels+1]>sl)
&&
( itemp[i*localimage->widthStep+j*localimage->nChannels+2]<vh)
&&
( itemp[i*localimage->widthStep+j*localimage->nChannels+2]>vl) //previous 124
) {
itemp1[i*binaryscaling->widthStep+j]=0; //dark regions black rest white
}
else
itemp1[i*binaryscaling->widthStep+j]=255;
}}
cvErode( binaryscaling, binaryscaling, NULL, 4);
cvDilate(binaryscaling, binaryscaling, NULL, 4);
CBlobResult blob;
CBlob *currentBlob=NULL;
blob=CBlobResult(binaryscaling,NULL,255);
blob.Filter(blob,B_EXCLUDE,CBlobGetArea(),B_LESS,500);
cvMerge(binaryscaling,binaryscaling,binaryscaling,NULL,blobbedscaling);
CBlob hand1,hand2; //two blobs,one for each hand
blob.GetNthBlob( CBlobGetArea(), 0, (hand2));
blob.GetNthBlob( CBlobGetArea(), 1, (hand1 ));
hand1.FillBlob(blobbedscaling,CV_RGB(0,0,255)); //fill the color of blob of hand one with blue
hand2.FillBlob(blobbedscaling,CV_RGB(0,255,0)); //fill the color of blob of hand two with green
coordinates (blobbedscaling,0);
}
// threshold trackbar callback
void on_trackbar( int dummy )
{
if(!originalThr)
{
originalThr = cvCreateImage(cvGetSize(original), IPL_DEPTH_8U,1);
}
if(!displayedImage)
{
displayedImage = cvCreateImage(cvGetSize(original), IPL_DEPTH_8U,3);
}
// threshold input image
cvThreshold( original, originalThr, param1, 255, CV_THRESH_BINARY );
// get blobs and filter them using its area
CBlobResult blobs;
int i;
CBlob *currentBlob;
// find blobs in image
blobs = CBlobResult( originalThr, NULL, 255 );
blobs.Filter( blobs, B_EXCLUDE, CBlobGetArea(), B_LESS, param2 );
// display filtered blobs
cvMerge( originalThr, originalThr, originalThr, NULL, displayedImage );
for (i = 0; i < blobs.GetNumBlobs(); i++ )
{
currentBlob = blobs.GetBlob(i);
currentBlob->FillBlob( displayedImage, CV_RGB(255,0,0));
}
cvShowImage( wndname, displayedImage );
}
int main() {
CvPoint pt1,pt2;
CvRect regt;
CvPoint cir_center;
CvPoint frame_center;
CvPoint A,B,C,D;
CvPoint temp;
double angle,spinsize;
int cir_radius=1;
int frame_width=160, frame_height=120;
CvCapture* capture = cvCaptureFromCAM( CV_CAP_ANY );
if ( !capture ) {
fprintf(stderr, "ERROR: capture is NULL \n" );
getchar();
return -1;
}
cvSetCaptureProperty(capture,CV_CAP_PROP_FRAME_WIDTH,frame_width);// 120x160
cvSetCaptureProperty(capture,CV_CAP_PROP_FRAME_HEIGHT,frame_height);
//cvSetCaptureProperty(capture, CV_CAP_PROP_FPS,10);
// cvSetCaptureProperty(capture,CV_CAP_PROP_POS_FRAMES,5);
// Create a window in which the captured images will be presented
cvNamedWindow( "mywindow", CV_WINDOW_AUTOSIZE );
// Show the image captured from the camera in the window and repeat
while ( 1 ) {
// Get one frame
IplImage* frame = cvQueryFrame( capture );
if ( !frame ) {
fprintf( stderr, "ERROR: frame is null...\n" );
getchar();
break;
}
int modfheight, modfwidth;
modfheight = frame->height;
modfwidth = frame->width;
// create modified frame with 1/4th the original size
IplImage* modframe = cvCreateImage(cvSize((int)(modfwidth/4),(int)(modfheight/4)),frame->depth,frame->nChannels); //cvCreateImage(size of frame, depth, noofchannels)
cvResize(frame, modframe,CV_INTER_LINEAR);
// create HSV(Hue, Saturation, Value) frame
IplImage* hsvframe = cvCreateImage(cvGetSize(modframe),8, 3);
cvCvtColor(modframe, hsvframe, CV_BGR2HSV); //cvCvtColor(input frame,outputframe,method)
// create a frame within threshold.
IplImage* threshframe = cvCreateImage(cvGetSize(hsvframe),8,1);
cvInRangeS(hsvframe,cvScalar(15, 100, 100),cvScalar(60, 220, 220),threshframe); //cvInRangeS(input frame, cvScalar(min range),cvScalar(max range),output frame)
// created dilated image
IplImage* dilframe = cvCreateImage(cvGetSize(threshframe),8,1);
cvDilate(threshframe,dilframe,NULL,2); //cvDilate(input frame, output frame, mask, number of times to dilate)
CBlobResult blobs;
blobs = CBlobResult(dilframe,NULL,0); // CBlobresult(inputframe, mask, threshold) Will filter all white parts of image
blobs.Filter(blobs,B_EXCLUDE,CBlobGetArea(),B_LESS,50);//blobs.Filter(input, cond, criteria, cond, const) Filter all images whose area is less than 50 pixels
CBlob biggestblob;
blobs.GetNthBlob(CBlobGetArea(),0,biggestblob); //GetNthBlob(criteria, number, output) Get only the largest blob based on CblobGetArea()
// get 4 points to define the rectangle
pt1.x = biggestblob.MinX()*4;
pt1.y = biggestblob.MinY()*4;
pt2.x = biggestblob.MaxX()*4;
pt2.y = biggestblob.MaxY()*4;
cir_center.x=(pt1.x+pt2.x)/2;
cir_center.y=(pt1.y+pt2.y)/2;
frame_center.x=frame_width/2;
frame_center.y=frame_height/2;
A.x=frame_center.x-4;
A.y=frame_center.y;
B.x=frame_center.x+4;
B.y=frame_center.y;
C.y=frame_center.y-4;
C.x=frame_center.x;
D.y=frame_center.y+4;
D.x=frame_center.x;
cvRectangle(frame,pt1,pt2,cvScalar(255,0,0),1,8,0); // draw rectangle around the biggest blob
cvCircle( frame, cir_center, cir_radius, cvScalar(0,255,255), 1, 8, 0 ); // center point of the rectangle
cvLine(frame, A, B,cvScalar(255,0,255),2,8,0);
cvLine(frame, C, D,cvScalar(255,0,255),2,8,0);
if (cir_center.x!=0&&cir_center.y!=0){
spinsize=sqrt((cir_center.x-frame_center.x)*(cir_center.x-frame_center.x) +(cir_center.y-frame_center.y)*(cir_center.y-frame_center.y));
angle = atan2((double)cir_center.y-frame_center.y,(double)cir_center.x-frame_center.x);
temp.x=(int)(frame_center.x+spinsize/5*cos(angle+3.1416/4));
temp.y=(int)(frame_center.y+spinsize/5*sin(angle+3.1415/4));
cvLine(frame, temp, frame_center,cvScalar(0,255,0),1,8,0);
temp.x=(int)(frame_center.x+spinsize/5*cos(angle-3.1416/4));
temp.y=(int)(frame_center.y+spinsize/5*sin(angle-3.1415/4));
cvLine(frame, temp, frame_center,cvScalar(0,255,0),1,8,0);
cvLine(frame, cir_center, frame_center,cvScalar(0,255,0),1,8,0);
//cvCircle( frame, frame_center, cir_radius, cvScalar(0,255,255), 2, 8, 0 );
}
cvShowImage( "mywindow", frame); // show output image
// Do not release the frame!
//If ESC key pressed, Key=0x10001B under OpenCV 0.9.7(linux version),
//remove higher bits using AND operator
if ( (cvWaitKey(10) & 255) == 27 ) break;
}
// Release the capture device housekeeping
cvReleaseCapture( &capture );
cvDestroyWindow( "mywindow" );
return 0;
}
void TrackerCvBlobsLib::trackBlobs(const Mat &mat, const Mat &areaMask, bool history, std::vector<Area> *pareas)
{
double min_area = *m_pmin_area;
double max_area = *m_pmax_area;
double max_radius_2 = *m_pmax_radius * *m_pmax_radius;
double x, y, min_x, min_y, max_x, max_y;
double min_depth,max_depth;
Scalar sdepth, sstddev;
cBlob temp;
bool new_hand(true);
int mat_area(mat.size().width*mat.size().height);
// we will convert the matrix object passed from our cFilter class to an object of type IplImage for calling the CBlobResult constructor
IplImage img;
IplImage areaImg;
// storage of the current blobs and the blobs from the previous frame
Size s; Point p;
mat.locateROI(s,p);
areaImg = areaMask;
// convert our OpenCV matrix object to one of type IplImage
img = mat;
// cvblobslib blob extraction
blob_result = CBlobResult(&img, NULL, 1/*img∈{0,255}->thresh unimportant*/, false);
blob_result.Filter(blob_result, B_EXCLUDE, CBlobGetArea(), B_LESS, min_area);
blob_result.Filter(blob_result, B_EXCLUDE, CBlobGetArea(), B_GREATER, max_area);
// clear the blobs from two frames ago
blobs_previous.clear();
// before we populate the blobs vector with the current frame, we need to store the live blobs in blobs_previous
for (int i = 0; i < blobs.size(); i++)
if (blobs[i].event != BLOB_UP)
blobs_previous.push_back(blobs[i]);
// populate the blobs vector with the current frame
blobs.clear();
for (int i = 0; i < blob_result.GetNumBlobs(); i++) {
current_blob = blob_result.GetBlob(i);
x = XCenter(current_blob)/*+m_pSettingKinect->m_kinectProp.roi.x*/;
y = YCenter(current_blob)/*+m_pSettingKinect->m_kinectProp.roi.y*/;
// temp.areaid = areaMask.at<uchar>((int)x+p.x,(int)y+p.y);//?!not works
temp.areaid = (uchar) areaImg.imageData[ ((int)x+p.x) + ((int)y+p.y)*areaMask.size().width];//works
if( temp.areaid == 0 ) continue;
min_x = MinX(current_blob);
min_y = MinY(current_blob);
max_x = MaxX(current_blob);
max_y = MaxY(current_blob);
if( (max_x-min_x)*(max_y-min_y) > 0.9*mat_area) continue;// fix blob detection issue?!
temp.location.x = temp.origin.x = x;
temp.location.y = temp.origin.y = y;
temp.min.x = min_x; temp.min.y = min_y;
temp.max.x = max_x; temp.max.y = max_y;
//Rect r(min_x+p.x,min_y+p.x, max_x-min_y, max_y-min_y);
//Rect r(min_x,min_y, max_x-min_x, max_y-min_y);//width, height +1?!
Rect r( x-3, y-3, min(7,max_x-min_x), min(7, max_y-min_y));
//z = mean( mat(r), mat(r) )[0];/* mean is not good. The blob can include many pixel behind the frame depth*/
/* Depth detection. The measurement method is flexible. */
if( m_pSettingKinect->m_kinectProp.areaThresh ){
/* Mean is ok, because all pixels of the blob are in front of the frame. */
max_depth = mean( mat(r), mat(r) )[0]+4;/*correct blur(1) and area thresh shift (3)*/
//meanStdDev( mat(r), sdepth, sstddev, mat(r) );
//max_depth = sdepth[0]+3*sstddev[0];
//minMaxLoc( mat(r), &min_depth, &max_depth, NULL, NULL, mat(r) );
}else if( pareas != NULL){
/* Remove values behind the area depth and count mean of rest.
This is problematic/choppy if to many pixels are removed.
*/
max_depth = max( (*pareas)[temp.areaid-1].depth-22,
mean( mat(r), mat(r)>(*pareas)[temp.areaid-1].depth-2 )[0] + 1);
}else{
/* Very few information. Use maximum of blob. (Choppy).
* Can be improved, if mean of i.e. 10 biggest values is used
* minMaxLoc require filtered/blured images.
* */
//max_depth = 0;
minMaxLoc( mat(r), &min_depth, &max_depth, NULL, NULL, mat(r) );
}
//printf("Compared depth of area/blob: %i %f\n",(*pareas)[temp.areaid-1].depth ,max_depth);
/* Compare depth of hand with depth of area and throw blob away if hand to far away. */
if(pareas != NULL && max_depth - (*pareas)[temp.areaid-1].depth < -1 ){
//printf("Hand not reached area depth.\n");
continue ;
}
temp.location.z = temp.origin.z = max_depth;
blobs.push_back(temp);
}
// initialize previous blobs to untracked
float d1,d2;
for (int i = 0; i < blobs_previous.size(); i++) blobs_previous[i].tracked = false;
// main tracking loop -- O(n^2) -- simply looks for a blob in the previous frame within a specified radius
for (int i = 0; i < blobs.size(); i++) {
cBlob &blobi = blobs[i];
new_hand = true;
for (int j = 0; j < blobs_previous.size(); j++) {
if (blobs_previous[j].tracked) continue;
d1=blobs[i].location.x - blobs_previous[j].location.x;
d2=blobs[i].location.y - blobs_previous[j].location.y;
if (blobs[i].areaid == blobs_previous[j].areaid
&& (d1*d1 + d2*d2) < max_radius_2) {
blobs_previous[j].tracked = true;
blobs[i].event = BLOB_MOVE;
blobs[i].origin.x = history ? blobs_previous[j].origin.x : blobs_previous[j].location.x;
blobs[i].origin.y = history ? blobs_previous[j].origin.y : blobs_previous[j].location.y;
blobs[i].origin.z = history ? blobs_previous[j].origin.z : blobs_previous[j].location.z;
blobs[i].handid = blobs_previous[j].handid;
blobs[i].cursor = blobs_previous[j].cursor;
blobs[i].cursor25D = blobs_previous[j].cursor25D;
new_hand = false;
break;
}
}
/* assing free handid if new blob */
if( new_hand){
//search next free id.
int next_handid = (last_handid+1) % MAXHANDS;//or = 0;
while( handids[next_handid]==true && next_handid!=last_handid ){
next_handid = (next_handid+1) % MAXHANDS;
} //if array full -> next_handid = last_handid
blobs[i].event = BLOB_DOWN;
blobs[i].handid = next_handid;
blobs[i].cursor = NULL;
blobs[i].cursor25D = NULL;
handids[next_handid] = true;
last_handid = next_handid;
}
}
// add any blobs from the previous frame that weren't tracked as having been removed
for (int i = 0; i < blobs_previous.size(); i++) {
if (!blobs_previous[i].tracked) {
//free handid
handids[blobs_previous[i].handid] = false;
blobs_previous[i].event = BLOB_UP;
blobs.push_back(blobs_previous[i]);
}
}
/*
for (int i = 1; i < blob_result.GetNumBlobs(); i++) {
current_blob = blob_result.GetBlob(i);
printf("Blobcoordsd %f, %f\n", XCenter(current_blob), YCenter(current_blob) );
}
*/
int counter = 0;
cBlob tb;
for (int i = 0; i < blobs.size(); i++) {
if( blobs[i].event != BLOB_UP ){
counter++;
tb = blobs[i];
//printf("Blobcoordsd %f, %f\n", blobs[i].location.x, blobs[i].location.y );
//printf("Blob areaid: %i, handid: %i, (%f,%f)\n", blobs[i].areaid, blobs[i].handid, blobs[i].location.x, blobs[i].location.y );
if(! *m_pnotDrawBlob ){
cvLine(&img,
Point((int)tb.origin.x,(int)tb.origin.y),
Point((int)tb.location.x,(int)tb.location.y),Scalar(244),2);
cvRectangle(&img,
Point((int)tb.min.x,(int)tb.min.y),
Point((int)tb.max.x,(int)tb.max.y),Scalar(255),2);
}
}
}
// printf("Active blobs: %i %i %i\n",counter, blobs.size(), blob_result.GetNumBlobs());
/* for(int i=0; i<MAXHANDS; i++){
printf("%i,", (handids[i]==true)?1:0);
}
printf("\n");*/
}
int main() {
CvPoint pt1b,pt2b, pt1t,pt2t,ptarry[4];
int tempwidth,tempheight;
CvRect regt,rectROIbot,rectROItop;
rectROItop=cvRect(0,0,80,10);
rectROIbot=cvRect(0,50,80,10);
CvPoint b_cir_center,t_cir_center;
CvPoint frame_center;
CvPoint A,B,C,D;
CvPoint temp;
double angle,spinsize;
int cir_radius=1;
int frame_width=160, frame_height=120;
IplImage* frame;
IplImage* threshframe;
IplImage* hsvframe;
IplImage* threshframebot;
IplImage* threshframetop;
IplImage* modframe;
IplImage* dilframetop;
IplImage* dilframebot;
int moddiv=2,seq=0,seqdiv=2;
int release=0, rmax=100;
int modfheight, modfwidth;
unsigned char sendBuf;/*
int serial;
serial = openSerial("/dev/ttyACM0");
if (serial == -1)
serial = openSerial("/dev/ttyACM1");
if (serial == -1)
serial = openSerial("/dev/ttyACM2");
if (serial == -1)
serial = openSerial("/dev/ttyACM3");
if (serial == -1)
serial = openSerial("/dev/ttyACM4");
if (serial == -1)
serial = openSerial("/dev/ttyACM5");
if (serial == -1)
serial = openSerial("/dev/ttyACM6");
if (serial == -1)
serial = openSerial("/dev/ttyACM7");
if (serial == -1)
serial = openSerial("/dev/ttyACM8");
if( serial == -1 ) {
return -1;
}*/
//CvCapture* capture = cvCaptureFromCAM( CV_CAP_ANY );
CvCapture* capture = cvCaptureFromCAM( 1 );
if ( !capture ) {
fprintf(stderr, "ERROR: capture is NULL \n" );
getchar();
return -1;
}
cvSetCaptureProperty(capture,CV_CAP_PROP_FRAME_WIDTH,frame_width);// 120x160
cvSetCaptureProperty(capture,CV_CAP_PROP_FRAME_HEIGHT,frame_height);
// cvSetCaptureProperty(capture, CV_CAP_PROP_FPS,10);
// cvSetCaptureProperty(capture,CV_CAP_PROP_POS_FRAMES,5);
// Create a window in which the captured images will be presented
cvNamedWindow( "mywindow", CV_WINDOW_AUTOSIZE );
// Show the image captured from the camera in the window and repeat
while ( 1 ) {
// Get one frame
frame = cvQueryFrame( capture );
if ( !frame ) {
fprintf( stderr, "ERROR: frame is null...\n" );
getchar();
break;
}
modfheight = frame->height;
modfwidth = frame->width;
modframe = cvCreateImage(cvSize((int)(modfwidth/moddiv),(int)(modfheight/moddiv)),frame->depth,frame->nChannels); //cvCreateImage(size of frame, depth, noofchannels)
cvResize(frame, modframe,CV_INTER_LINEAR);
// create HSV(Hue, Saturation, Value) frame
hsvframe = cvCreateImage(cvGetSize(modframe),8, 3);
cvCvtColor(modframe, hsvframe, CV_BGR2HSV); //cvCvtColor(input frame,outputframe,method)
threshframe = cvCreateImage(cvGetSize(hsvframe),8,1);
// cvInRangeS(hsvframe,cvScalar(0, 180, 140),cvScalar(15, 230, 235),threshframe); //cvInRangeS(input frame, cvScalar(min range),cvScalar(max range),output frame) red
cvInRangeS(hsvframe,cvScalar(70, 180, 40),cvScalar(100, 230, 90),threshframe); //cvInRangeS(input frame, cvScalar(min range),cvScalar(max range),output frame)
threshframebot=cvCloneImage(threshframe);
cvSetImageROI(threshframebot,rectROIbot);
threshframetop=cvCloneImage(threshframe);
cvSetImageROI(threshframetop,rectROItop);
//////////////////////////////////////////////////////////////////////////////////////////
if (seq==0) {
threshframebot=cvCloneImage(threshframe);
cvSetImageROI(threshframebot,rectROIbot);
dilframebot = cvCreateImage(cvGetSize(threshframebot),8,1);
cvDilate(threshframebot,dilframebot,NULL,2); //cvDilate(input frame,
// tempwidth=cvGetSize(dilframebot).width;
// tempheight=cvGetSize(dilframebot).height;
// printf("dilframe: %d, %d \n",tempwidth,tempheight);
CBlobResult blobs_bot;
blobs_bot = CBlobResult(dilframebot,NULL,0); // CBlobresult(inputframe, mask, threshold) Will filter all white parts of image
blobs_bot.Filter(blobs_bot,B_EXCLUDE,CBlobGetArea(),B_LESS,50);//blobs.Filter(input, cond, criteria, cond, const) Filter all images whose area is less than 50 pixels
CBlob biggestblob_bot;
blobs_bot.GetNthBlob(CBlobGetArea(),0,biggestblob_bot); //GetNthBlob(criteria, number, output) Get only the largest blob based on CblobGetArea()
// get 4 points to define the rectangle
pt1b.x = biggestblob_bot.MinX()*moddiv;
pt1b.y = biggestblob_bot.MinY()*moddiv+100;
pt2b.x = biggestblob_bot.MaxX()*moddiv;
pt2b.y = biggestblob_bot.MaxY()*moddiv+100;
b_cir_center.x=(pt1b.x+pt2b.x)/2;
b_cir_center.y=(pt1b.y+pt2b.y)/2;}
//////////////////////////////////////////////////////////////////////////////////////////
if(seq==seqdiv){
threshframetop=cvCloneImage(threshframe);
cvSetImageROI(threshframetop,rectROItop);
dilframetop = cvCreateImage(cvGetSize(threshframetop),8,1);
cvDilate(threshframetop,dilframetop,NULL,2); //cvDilate(input frame,
CBlobResult blobs_top;
blobs_top = CBlobResult(dilframetop,NULL,0); // CBlobresult(inputframe, mask, threshold) Will filter all white parts of image
blobs_top.Filter(blobs_top,B_EXCLUDE,CBlobGetArea(),B_LESS,50);//blobs.Filter(input, cond, criteria, cond, const) Filter all images whose area is less than 50 pixels
CBlob biggestblob_top;
blobs_top.GetNthBlob(CBlobGetArea(),0,biggestblob_top); //GetNthBlob(criteria, number, output) Get only the largest blob based on CblobGetArea()
// get 4 points to define the rectangle
pt1t.x = biggestblob_top.MinX()*moddiv;
pt1t.y = biggestblob_top.MinY()*moddiv;
pt2t.x = biggestblob_top.MaxX()*moddiv;
pt2t.y = biggestblob_top.MaxY()*moddiv;
t_cir_center.x=(pt1t.x+pt2t.x)/2;
t_cir_center.y=(pt1t.y+pt2t.y)/2;}
//////////////////////////////////////////////////////////////////////////////////////
if(seq==seqdiv+2) {
frame_center.x=frame_width/2;
frame_center.y=frame_height/2;
A.x=frame_center.x-4;
A.y=frame_center.y;
B.x=frame_center.x+4;
B.y=frame_center.y;
C.y=frame_center.y-4;
C.x=frame_center.x;
D.y=frame_center.y+4;
D.x=frame_center.x;
cvRectangle(frame,pt1t,pt2t,cvScalar(255,0,0),1,8,0);
cvRectangle(frame,pt1b,pt2b,cvScalar(255,0,0),1,8,0); // draw rectangle around the biggest blob
//cvRectangle(frame,pt1,pt2,cvScalar(255,0,0),1,8,0);
cvCircle( frame, b_cir_center, cir_radius, cvScalar(0,255,255), 1, 8, 0 ); // center point of the rectangle
cvLine(frame, A, B,cvScalar(255,0,255),2,8,0);
cvLine(frame, C, D,cvScalar(255,0,255),2,8,0);
if (b_cir_center.x!=0&&b_cir_center.y!=100)
{
cvLine(frame, b_cir_center, frame_center,cvScalar(0,255,0),1,8,0);
}
if(t_cir_center.x!=0&&t_cir_center.y!=0)
{
cvLine(frame, frame_center, t_cir_center,cvScalar(255,255,0),1,8,0);
}
if ((b_cir_center.x!=0&&b_cir_center.y!=100)&&(t_cir_center.x!=0&&t_cir_center.y!=0))
{
cvLine(frame, b_cir_center, t_cir_center,cvScalar(0,255,255),1,8,0);
printf("%d, %d, %d, %d\n",t_cir_center.x,t_cir_center.y,b_cir_center.x,b_cir_center.y);
}
}
seq++;
seq=seq%(seqdiv+4);
cvShowImage( "mywindow", frame); // show output image
cvShowImage( "bot", threshframebot);
cvShowImage( "top", threshframetop);
// cvShowImage("croped",cropped);
//cvShowImage( "mywindow3", dilframeROI);
// Do not release the frame!
//If ESC key pressed, Key=0x10001B under OpenCV 0.9.7(linux version),
//remove higher bits using AND operator
if ( (cvWaitKey(10) & 255) == 27 ) break;
}
// Release the capture device housekeeping
cvReleaseCapture( &capture );
cvDestroyWindow( "mywindow" );
return 0;
}
void
Auvsi_Recognize::extractShape( void )
{
typedef cv::Vec<T, 1> VT;
// Reduce input to two colors
cv::Mat reducedColors = doClustering<T>( _image, 2 );
cv::Mat grayScaled, binary;
// Make output grayscale
grayScaled = convertToGray( reducedColors );
//cv::cvtColor( reducedColors, grayScaled, CV_RGB2GRAY );
// Make binary
double min, max;
cv::minMaxLoc( grayScaled, &min, &max );
cv::threshold( grayScaled, binary, min, 1.0, cv::THRESH_BINARY );
// ensure that background is black, image white
if( binary.at<VT>(0, 0)[0] > 0.0f )
cv::threshold( grayScaled, binary, min, 1.0, cv::THRESH_BINARY_INV );
binary.convertTo( binary, CV_8U, 255.0f );
// Fill in all black regions smaller than largest black region with white
CBlobResult blobs;
CBlob * currentBlob;
IplImage binaryIpl = binary;
blobs = CBlobResult( &binaryIpl, NULL, 255 );
// Get area of biggest blob
CBlob biggestBlob;
blobs.GetNthBlob( CBlobGetArea(), 0, biggestBlob );
// Remove all blobs of smaller area
blobs.Filter( blobs, B_EXCLUDE, CBlobGetArea(), B_GREATER_OR_EQUAL, biggestBlob.Area() );
for (int i = 0; i < blobs.GetNumBlobs(); i++ )
{
currentBlob = blobs.GetBlob(i);
currentBlob->FillBlob( &binaryIpl, cvScalar(255));
}
// Fill in all small white regions black
blobs = CBlobResult( &binaryIpl, NULL, 0 );
blobs.GetNthBlob( CBlobGetArea(), 0, biggestBlob );
blobs.Filter( blobs, B_EXCLUDE, CBlobGetArea(), B_GREATER_OR_EQUAL, biggestBlob.Area() );
for (int i = 0; i < blobs.GetNumBlobs(); i++ )
{
currentBlob = blobs.GetBlob(i);
currentBlob->FillBlob( &binaryIpl, cvScalar(0));
}
binary = cv::Scalar(0);
biggestBlob.FillBlob( &binaryIpl, cvScalar(255));
_shape = binary;
}
int main() {
CvPoint pt1b,pt2b, pt1t,pt2t,ptarry[4];
int tempwidth,tempheight;
CvRect regt,rectROIbot,rectROItop;
rectROItop=cvRect(0,0,80,10);
rectROIbot=cvRect(0,50,80,10);
CvPoint b_cir_center,t_cir_center;
CvPoint frame_center;
CvPoint A,B,C,D;
CvPoint temp;
double angle,spinsize;
int cir_radius=1;
int frame_width=160, frame_height=120;
IplImage* frame;
IplImage* threshframe;
IplImage* hsvframe;
IplImage* threshframebot;
IplImage* threshframetop;
IplImage* modframe;
IplImage* dilframetop;
IplImage* dilframebot;
int release=0, rmax=100;
int modfheight, modfwidth;
int_serial();
unsigned char sendBuf;
CvCapture* capture = cvCaptureFromCAM( -1 );
if ( !capture ) {
fprintf(stderr, "ERROR: capture is NULL \n" );
getchar();
return -1;
}
cvSetCaptureProperty(capture,CV_CAP_PROP_FRAME_WIDTH,frame_width);// 120x160
cvSetCaptureProperty(capture,CV_CAP_PROP_FRAME_HEIGHT,frame_height);
cvNamedWindow( "mywindow", CV_WINDOW_AUTOSIZE );
while ( 1 ) {
// Get one frame
frame = cvQueryFrame( capture );
if ( !frame ) {
fprintf( stderr, "ERROR: frame is null...\n" );
getchar();
break;
}
modfheight = frame->height;
modfwidth = frame->width;
modframe = cvCreateImage(cvSize((int)(modfwidth/moddiv),(int)(modfheight/moddiv)),frame->depth,frame->nChannels); //cvCreateImage(size of frame, depth, noofchannels)
cvResize(frame, modframe,CV_INTER_LINEAR);
hsvframe = cvCreateImage(cvGetSize(modframe),8, 3);
cvCvtColor(modframe, hsvframe, CV_BGR2HSV); //cvCvtColor(input frame,outputframe,method)
threshframe = cvCreateImage(cvGetSize(hsvframe),8,1);
// cvInRangeS(hsvframe,cvScalar(0, 180, 140),cvScalar(15, 230, 235),threshframe); //cvInRangeS(input frame, cvScalar(min range),cvScalar(max range),output frame) red
cvInRangeS(hsvframe,cvScalar(100, 20, 40),cvScalar(140, 120, 100),threshframe); //cvInRangeS(input frame, cvScalar(min range),cvScalar(max range),output frame)
threshframebot=cvCloneImage(threshframe);
cvSetImageROI(threshframebot,rectROIbot);
threshframetop=cvCloneImage(threshframe);
cvSetImageROI(threshframetop,rectROItop);
//////////////////////////////////////////////////////////////////////////////////////////
if (seq==0) {
threshframebot=cvCloneImage(threshframe);
cvSetImageROI(threshframebot,rectROIbot);
dilframebot = cvCreateImage(cvGetSize(threshframebot),8,1);
cvDilate(threshframebot,dilframebot,NULL,2); //cvDilate(input frame,
CBlobResult blobs_bot;
blobs_bot = CBlobResult(dilframebot,NULL,0); // CBlobresult(inputframe, mask, threshold) Will filter all white parts of image
blobs_bot.Filter(blobs_bot,B_EXCLUDE,CBlobGetArea(),B_LESS,50);//blobs.Filter(input, cond, criteria, cond, const) Filter all images whose area is less than 50 pixels
CBlob biggestblob_bot;
blobs_bot.GetNthBlob(CBlobGetArea(),0,biggestblob_bot); //GetNthBlob(criteria, number, output) Get only the largest blob based on CblobGetArea()
// get 4 points to define the rectangle
pt1b.x = biggestblob_bot.MinX()*moddiv;
pt1b.y = biggestblob_bot.MinY()*moddiv+100;
pt2b.x = biggestblob_bot.MaxX()*moddiv;
pt2b.y = biggestblob_bot.MaxY()*moddiv+100;
b_cir_center.x=(pt1b.x+pt2b.x)/2;
b_cir_center.y=(pt1b.y+pt2b.y)/2;//}
//////////////////////////////////////////////////////////////////////////////////////////
// if(seq==seqdiv){
threshframetop=cvCloneImage(threshframe);
cvSetImageROI(threshframetop,rectROItop);
dilframetop = cvCreateImage(cvGetSize(threshframetop),8,1);
cvDilate(threshframetop,dilframetop,NULL,2); //cvDilate(input frame,
CBlobResult blobs_top;
blobs_top = CBlobResult(dilframetop,NULL,0); // CBlobresult(inputframe, mask, threshold) Will filter all white parts of image
blobs_top.Filter(blobs_top,B_EXCLUDE,CBlobGetArea(),B_LESS,50);//blobs.Filter(input, cond, criteria, cond, const) Filter all images whose area is less than 50 pixels
CBlob biggestblob_top;
blobs_top.GetNthBlob(CBlobGetArea(),0,biggestblob_top); //GetNthBlob(criteria, number, output) Get only the largest blob based on CblobGetArea()
// get 4 points to define the rectangle
pt1t.x = biggestblob_top.MinX()*moddiv;
pt1t.y = biggestblob_top.MinY()*moddiv;
pt2t.x = biggestblob_top.MaxX()*moddiv;
pt2t.y = biggestblob_top.MaxY()*moddiv;
t_cir_center.x=(pt1t.x+pt2t.x)/2;
t_cir_center.y=(pt1t.y+pt2t.y)/2;// }
//////////////////////////////////////////////////////////////////////////////////////
// if(seq==seqdiv+1) {
frame_center.x=frame_width/2;
frame_center.y=frame_height/2;
A.x=frame_center.x-4;
A.y=frame_center.y;
B.x=frame_center.x+4;
B.y=frame_center.y;
C.y=frame_center.y-4;
C.x=frame_center.x;
D.y=frame_center.y+4;
D.x=frame_center.x;
cvRectangle(frame,pt1t,pt2t,cvScalar(255,0,0),1,8,0);
cvRectangle(frame,pt1b,pt2b,cvScalar(255,0,0),1,8,0); // draw rectangle around the biggest blob
//cvRectangle(frame,pt1,pt2,cvScalar(255,0,0),1,8,0);
cvCircle( frame, b_cir_center, cir_radius, cvScalar(0,255,255), 1, 8, 0 ); // center point of the rectangle
cvLine(frame, A, B,cvScalar(255,0,255),2,8,0);
cvLine(frame, C, D,cvScalar(255,0,255),2,8,0);
if (b_cir_center.x!=0&&b_cir_center.y!=100)
{
cvLine(frame, b_cir_center, frame_center,cvScalar(0,255,0),1,8,0);
sendchar(253);sendchar(255);sendchar(255);
sendchar(254);sendchar(b_cir_center.x);sendchar(b_cir_center.y);
printf("top:(255, 255); bottom: (%3d, %3d)\n",b_cir_center.x,b_cir_center.y);
}
if(t_cir_center.x!=0&&t_cir_center.y!=0)
{
cvLine(frame, frame_center, t_cir_center,cvScalar(255,255,0),1,8,0);
sendchar(253);sendchar(t_cir_center.x);sendchar(t_cir_center.y);
sendchar(254);sendchar(255); sendchar(255);
printf("top:(%3d, %3d); bottom: (255, 255)\n",t_cir_center.x,t_cir_center.y);
}
if ((b_cir_center.x!=0&&b_cir_center.y!=100)&&(t_cir_center.x!=0&&t_cir_center.y!=0))
{
cvLine(frame, b_cir_center, t_cir_center,cvScalar(0,255,255),1,8,0);
printf("top:(%3d, %3d); bottom: (%3d, %3d)\n",t_cir_center.x,t_cir_center.y,b_cir_center.x,b_cir_center.y);
sendchar(253);sendchar(t_cir_center.x); sendchar(t_cir_center.y);
sendchar(254);sendchar(b_cir_center.x);sendchar(b_cir_center.y);
}
}
seq++;
seq=seq%(seqdiv+1);
cvShowImage( "mywindow", frame); // show output image
// cvShowImage( "bot", threshframebot);
// cvShowImage( "top", threshframetop);
//remove higher bits using AND operator
if ( (cvWaitKey(10) & 255) == 27 ) break;
}
// Release the capture device housekeeping
cvReleaseCapture( &capture );
//v4l.flush();
cvDestroyWindow( "mywindow" );
return 0;
}
float thresholdSegmentation(Rect r, ntk::RGBDImage* current_frame, Mat& dst){
Mat depth = current_frame->depth();
Rect& rr = r;
Mat depthROI = depth(rr), maskROI;
Mat& rDepthROI = depthROI, &rMaskROI = maskROI;
double var = 0.3;
// maskROI for nonZero values in the Face Region
inRange(depthROI, Scalar::all(0.001), Scalar::all(255), maskROI);
// Mean depth of Face Region
Scalar mFace = cv::mean(rDepthROI, rMaskROI);
//mFace[0] = mFace[0] - mFace[0] * var;
inRange(depthROI, Scalar::all(0.001), mFace, maskROI);
mFace = cv::mean(rDepthROI, rMaskROI);
//inRange(depthROI, Scalar::all(0.001), mFace, maskROI);
//mFace = cv::mean(rDepthROI, rMaskROI);
// Mask for nearer than the mean of face.
inRange(depth, Scalar::all(0.001), mFace, dst);
Mat rgbImage = current_frame->rgb();
Mat outFrame = cvCreateMat(rgbImage.rows, rgbImage.cols, CV_32FC3);
rgbImage.copyTo(outFrame, dst);
Mat outFrameROI;
outFrameROI = outFrame(rr);
//cvCopy(&rgbImage, &outFrame, &dst);
//rgbImageROI = rgbImageROI(rr);
imshow("ROI", outFrameROI);
//imshow("thresholdSeg", dst);
// For debug of cvblobslib
// Display the color image
//imshow("faceRIO", maskROI);
imshow("faceRIO", outFrameROI);
bool iswrite;
const int nchannel = 1;
vector<Rect> faces;
//iswrite = imwrite("faceROI.png", maskROI);
iswrite = imwrite("faceROI.png", outFrameROI);
//iswrite = cvSaveImage("faceROI.jpeg", pOutFrame, &nchannel);
// ---- blob segmentation on maskROI by using cvblobslib ----
// --- Third Trial ---
//visualizeBlobs("faceROI.png", "faceRIO");
// --- First Trial Not Successful ---
//Mat maskROIThr=cvCreateMat(maskROI.rows, maskROI.cols, CV_8UC1);
//maskROIThr = maskROI;
//IplImage imgMaskROIThr = maskROIThr;
//IplImage* pImgMaskROIThr = &imgMaskROIThr;
//cvThreshold(pImgMaskROIThr, pImgMaskROIThr, 0.1, 255, CV_THRESH_BINARY_INV);
// --- Second Trial ---
IplImage* original = cvLoadImage("faceROI.png", 0);
IplImage* originalThr = cvCreateImage(cvGetSize(original), IPL_DEPTH_8U, 1);
IplImage* displayBiggestBlob = cvCreateImage(cvGetSize(original), IPL_DEPTH_8U, 3);
CBlobResult blobs;
CBlob biggestBlob;
//IplImage source = maskROIThr; IplImage* pSource = &source;
//blobs = CBlobResult(
cvThreshold(original, originalThr, 0.1, 255, CV_THRESH_BINARY_INV);
blobs = CBlobResult( originalThr, NULL, 255);
printf("%d blobs \n", blobs.GetNumBlobs());
blobs.GetNthBlob(CBlobGetArea(), 0, biggestBlob);
biggestBlob.FillBlob(displayBiggestBlob, CV_RGB(255, 0, 0));
// Drawing the eclipse and Rect on the blob
Mat mat(displayBiggestBlob);
cv::RotatedRect blobEllipseContour;
cv::Rect blobRectContour;
//RotatedRect blobEllipseContour;
blobEllipseContour = biggestBlob.GetEllipse();
blobRectContour = biggestBlob.GetBoundingBox();
//cv::ellipse(
cv::ellipse(mat, blobEllipseContour, cv::Scalar(0,255, 0), 3, CV_AA);
cv::rectangle(mat, blobRectContour, cv::Scalar(255, 0, 0), 3, CV_AA);
//cv::ellipse(mat, blobEllipseContour);
float headOritation = blobEllipseContour.angle;
if (headOritation <= 180)
headOritation = headOritation - 90;
else
headOritation = headOritation - 270;
cv::putText(mat,
cv::format("%f degree", headOritation),
Point(10,20), 0, 0.5, Scalar(255,0,0,255));
cv::imshow("faceRIO", mat);
return(headOritation);
}
/*
* thread for displaying the opencv content
*/
void *cv_threadfunc (void *ptr) {
IplImage* timg = cvCloneImage(rgbimg); // Image we do our processing on
IplImage* dimg = cvCloneImage(rgbimg); // Image we draw on
CvSize sz = cvSize( timg->width & -2, timg->height & -2);
IplImage* outimg = cvCreateImage(sz, 8, 3);
CvMemStorage* storage = cvCreateMemStorage(0);
CvSeq* squares; // Sequence for squares - sets of 4 points
CvSeq* contours; // Raw contours list
CvSeq* result; // Single contour being processed
CBlobResult blobs;
CBlob *currentBlob;
IplImage *pyr = cvCreateImage(cvSize(sz.width/2, sz.height/2), 8, 1);
// Set region of interest
cvSetImageROI(timg, cvRect(0, 0, sz.width, sz.height));
cvSetImageROI(dimg, cvRect(0, 0, sz.width, sz.height));
// Processing and contours
while (1) {
squares = cvCreateSeq(0, sizeof(CvSeq), sizeof(CvPoint), storage);
pthread_mutex_lock( &mutex_rgb );
cvCopy(rgbimg, dimg, 0);
cvCopy(rgbimg, timg, 0);
pthread_mutex_unlock( &mutex_rgb );
// BLUR TEST
// cvPyrDown(dimg, pyr, 7);
// cvPyrUp(pyr, timg, 7);
// DILATE TEST
IplConvKernel* element = cvCreateStructuringElementEx(5, 5, 2, 2, 0);
IplConvKernel* element2 = cvCreateStructuringElementEx(3, 3, 1, 1, 0);
cvDilate(timg, timg, element, 2);
cvErode(timg, timg, element2, 3);
// THRESHOLD TEST
cvThreshold(timg, timg, 200, 255, CV_THRESH_BINARY);
// Output processed or raw image.
cvCvtColor(timg, outimg, CV_GRAY2BGR);
// BLOB TEST
blobs = CBlobResult( timg, (IplImage*)NULL, 0, true );
// blobs.Filter( blobs, B_EXCLUDE, CBlobGetArea(), B_LESS, 50 );
printf("Blobs: %d\n", blobs.GetNumBlobs());
CBlob biggestBlob;
blobs.GetNthBlob( CBlobGetArea(), 1, biggestBlob );
biggestBlob.FillBlob( outimg, CV_RGB(255, 0, 0) );
CvSeq* dest;
biggestBlob.GetConvexHull(dest);
// for (int i = 0; i < blobs.GetNumBlobs(); i++ )
// {
// currentBlob = blobs.GetBlob(i);
// currentBlob->FillBlob( outimg, CV_RGB(255,0,0) );
// }
// // CONTOUR FINDING
// cvFindContours(timg, storage, &contours, sizeof(CvContour), CV_RETR_LIST, CV_CHAIN_APPROX_SIMPLE, cvPoint(0,0));
//
// while (contours)
// {
// // Approximate contour, accuracy proportional to perimeter of contour; may want to tune accuracy.
// result = cvApproxPoly(contours, sizeof(CvContour), storage, CV_POLY_APPROX_DP, cvContourPerimeter(contours) * 0.02, 0);
// // Filter small contours and contours w/o 4 vertices (filters noise, finds rectangles)
// if (result->total == 4 &&
// fabs(cvContourArea(result, CV_WHOLE_SEQ)) > 600 &&
// cvCheckContourConvexity(result))
// {
// // Skipped checking whether angles were close to 90 degrees here; may want to implement.
// // Probably also want to check if it's square enough to filter out ex. long windows.
//
// for (int i = 0; i < 4; i++)
// {
// // Write vertices to output sequence
// cvSeqPush(squares, (CvPoint*)cvGetSeqElem(result, i));
// }
// }
//
// // Take next contour
// contours = contours->h_next;
// }
//
//
// // DRAW RECTANGLES
// CvSeqReader reader;
// cvStartReadSeq(squares, &reader, 0);
//
// // Read 4 points at a time
// CvPoint pt[4];
// CvPoint *rect = pt;
// CvRect out[4];
// CvRect *outrect = out;
// for (int i = 0; i < squares->total; i += 4)
// {
// int count = 4;
//
// // Which point is which corner is unpredictable.
// CV_READ_SEQ_ELEM(pt[0], reader);
// CV_READ_SEQ_ELEM(pt[1], reader);
// CV_READ_SEQ_ELEM(pt[2], reader);
// CV_READ_SEQ_ELEM(pt[3], reader);
// // Draw rectangle on output
// cvPolyLine(outimg, &rect, &count, 1, 1, CV_RGB(0,255,0), 1, CV_AA, 0);
// // Make rectangles
// // Print (temporary)
// printf("Rect[0]: %d, %d\n", pt[0].x, pt[0].y);
// printf("Rect[1]: %d, %d\n", pt[1].x, pt[1].y);
// printf("Rect[2]: %d, %d\n", pt[2].x, pt[2].y);
// printf("Rect[3]: %d, %d\n\n", pt[3].x, pt[3].y);
// fflush(stdout);
//
// }
//
// Print on order
if( cvWaitKey( 15 )==27 )
{
}
cvShowImage (FREENECTOPENCV_WINDOW_N,outimg);
cvClearMemStorage(storage);
}
pthread_exit(NULL);
}
int main() {
CvPoint pt1,pt2;
CvRect regt;
CvCapture* capture = cvCaptureFromCAM( CV_CAP_ANY );
if ( !capture ) {
fprintf(stderr, "ERROR: capture is NULL \n" );
getchar();
return -1;
}
cvSetCaptureProperty(capture,CV_CAP_PROP_FRAME_HEIGHT,144);
cvSetCaptureProperty(capture,CV_CAP_PROP_FRAME_WIDTH,216);
// Create a window in which the captured images will be presented
cvNamedWindow( "mywindow", CV_WINDOW_AUTOSIZE );
// Show the image captured from the camera in the window and repeat
while ( 1 ) {
// Get one frame
IplImage* frame = cvQueryFrame( capture );
if ( !frame ) {
fprintf( stderr, "ERROR: frame is null...\n" );
getchar();
break;
}
int modfheight, modfwidth;
modfheight = frame->height;
modfwidth = frame->width;
// create modified frame with 1/4th the original size
IplImage* modframe = cvCreateImage(cvSize((int)(modfwidth/4),(int)(modfheight/4)),frame->depth,frame->nChannels); //cvCreateImage(size of frame, depth, noofchannels)
cvResize(frame, modframe,CV_INTER_LINEAR);
// create HSV(Hue, Saturation, Value) frame
IplImage* hsvframe = cvCreateImage(cvGetSize(modframe),8, 3);
cvCvtColor(modframe, hsvframe, CV_BGR2HSV); //cvCvtColor(input frame,outputframe,method)
// create a frame within threshold.
IplImage* threshframe = cvCreateImage(cvGetSize(hsvframe),8,1);
cvInRangeS(hsvframe,cvScalar(30, 25, 150),cvScalar(60, 60, 220),threshframe); //cvInRangeS(input frame, cvScalar(min range),cvScalar(max range),output frame)
// created dilated image
IplImage* dilframe = cvCreateImage(cvGetSize(threshframe),8,1);
cvDilate(threshframe,dilframe,NULL,2); //cvDilate(input frame, output frame, mask, number of times to dilate)
CBlobResult blobs;
blobs = CBlobResult(dilframe,NULL,0); // CBlobresult(inputframe, mask, threshold) Will filter all white parts of image
blobs.Filter(blobs,B_EXCLUDE,CBlobGetArea(),B_LESS,50);//blobs.Filter(input, cond, criteria, cond, const) Filter all images whose area is less than 50 pixels
CBlob biggestblob;
blobs.GetNthBlob(CBlobGetArea(),0,biggestblob); //GetNthBlob(criteria, number, output) Get only the largest blob based on CblobGetArea()
// get 4 points to define the rectangle
pt1.x = biggestblob.MinX()*4;
pt1.y = biggestblob.MinY()*4;
pt2.x = biggestblob.MaxX()*4;
pt2.y = biggestblob.MaxY()*4;
cvRectangle(frame,pt1,pt2,cvScalar(255,0,0),1,8,0); // draw rectangle around the biggest blob
cvShowImage( "mywindow", frame); // show output image
// Do not release the frame!
//If ESC key pressed, Key=0x10001B under OpenCV 0.9.7(linux version),
//remove higher bits using AND operator
if ( (cvWaitKey(10) & 255) == 27 ) break;
}
// Release the capture device housekeeping
cvReleaseCapture( &capture );
cvDestroyWindow( "mywindow" );
return 0;
}
int main()
{
CBlobResult blobs;
CBlob *currentBlob;
CvPoint pt1, pt2;
CvRect cvRect;
int key = 0;
IplImage* frame = 0;
// Initialize capturing live feed from video file or camera
CvCapture* capture = cvCaptureFromFile( "MOV.MPG" );
// Get the frames per second
int fps = ( int )cvGetCaptureProperty( capture,
CV_CAP_PROP_FPS );
// Can't get device? Complain and quit
if( !capture )
{
printf( "Could not initialize capturing...\n" );
return -1;
}
// Windows used to display input video with bounding rectangles
// and the thresholded video
cvNamedWindow( "video" );
cvNamedWindow( "thresh" );
// An infinite loop
while( key != 'x' )
{
// If we couldn't grab a frame... quit
if( !( frame = cvQueryFrame( capture ) ) )
break;
// Get object's thresholded image (blue = white, rest = black)
IplImage* imgThresh = GetThresholdedImageHSV( frame );
// Detect the white blobs from the black background
blobs = CBlobResult( imgThresh, NULL, 0 );
// Exclude white blobs smaller than the given value (10)
// The bigger the last parameter, the bigger the blobs need
// to be for inclusion
blobs.Filter( blobs,
B_EXCLUDE,
CBlobGetArea(),
B_LESS,
10 );
// Attach a bounding rectangle for each blob discovered
int num_blobs = blobs.GetNumBlobs();
for ( int i = 0; i < num_blobs; i++ )
{
currentBlob = blobs.GetBlob( i );
cvRect = currentBlob->GetBoundingBox();
pt1.x = cvRect.x;
pt1.y = cvRect.y;
pt2.x = cvRect.x + cvRect.width;
pt2.y = cvRect.y + cvRect.height;
// Attach bounding rect to blob in orginal video input
cvRectangle( frame,
pt1,
pt2,
cvScalar(0, 0, 0, 0),
1,
8,
0 );
}
// Add the black and white and original images
cvShowImage( "thresh", imgThresh );
cvShowImage( "video", frame );
// Optional - used to slow up the display of frames
key = cvWaitKey( 2000 / fps );
// Prevent memory leaks by releasing thresholded image
cvReleaseImage( &imgThresh );
}
// We're through with using camera.
cvReleaseCapture( &capture );
return 0;
}
// A Simple Camera Capture Framework
int main() {
CvCapture* capture = cvCaptureFromCAM( 0 );
if( !capture ) {
fprintf( stderr, "ERROR: capture is NULL \n" );
return -1;
}
#ifdef HALF_SIZE_CAPTURE
cvSetCaptureProperty(capture, CV_CAP_PROP_FRAME_WIDTH, 352/2);
cvSetCaptureProperty(capture, CV_CAP_PROP_FRAME_HEIGHT, 288/2);
#endif
// Create a window in which the captured images will be presented
cvNamedWindow( "Source Image Window", CV_WINDOW_AUTOSIZE );
cvNamedWindow( "Back Projected Image", CV_WINDOW_AUTOSIZE );
cvNamedWindow( "Brightness and Contrast Window", CV_WINDOW_AUTOSIZE );
cvNamedWindow( "Blob Output Window", CV_WINDOW_AUTOSIZE );
cvNamedWindow( "Histogram Window", 0);
cvNamedWindow( "Rainbow Window", CV_WINDOW_AUTOSIZE );
// Capture one frame to get image attributes:
source_frame = cvQueryFrame( capture );
if( !source_frame ) {
fprintf( stderr, "ERROR: frame is null...\n" );
return -1;
}
cvCreateTrackbar("histogram\nnormalization", "Back Projected Image", &normalization_sum, 6000, NULL);
cvCreateTrackbar("brightness", "Brightness and Contrast Window", &_brightness, 200, NULL);
cvCreateTrackbar("contrast", "Brightness and Contrast Window", &_contrast, 200, NULL);
cvCreateTrackbar("threshold", "Blob Output Window", &blob_extraction_threshold, 255, NULL);
cvCreateTrackbar("min blob size", "Blob Output Window", &min_blob_size, 2000, NULL);
cvCreateTrackbar("max blob size", "Blob Output Window", &max_blob_size, source_frame->width*source_frame->height/4, NULL);
inputImage = cvCreateImage(cvGetSize(source_frame), IPL_DEPTH_8U, 1);
histAdjustedImage = cvCreateImage(cvGetSize(source_frame), IPL_DEPTH_8U, 1);
outputImage = cvCreateImage(cvGetSize(source_frame), IPL_DEPTH_8U, 3 );
hist_image = cvCreateImage(cvSize(320,200), 8, 1);
rainbowImage = cvCreateImage(cvGetSize(source_frame), IPL_DEPTH_8U, 3 );
// object that will contain blobs of inputImage
CBlobResult blobs;
CBlob my_enumerated_blob;
cvInitFont(&font, CV_FONT_HERSHEY_SIMPLEX|CV_FONT_ITALIC, hScale, vScale, 0, lineWidth);
// Some brightness/contrast stuff:
bright_cont_image = cvCloneImage(inputImage);
lut_mat = cvCreateMatHeader( 1, 256, CV_8UC1 );
cvSetData( lut_mat, lut, 0 );
while( 1 ) {
// Get one frame
source_frame = cvQueryFrame( capture );
if( !source_frame ) {
fprintf( stderr, "ERROR: frame is null...\n" );
getchar();
break;
}
cvShowImage( "Source Image Window", source_frame );
// Do not release the frame!
cvCvtColor(source_frame, inputImage, CV_RGB2GRAY);
// Histogram Stuff!
my_hist = cvCreateHist(1, hist_size_array, CV_HIST_ARRAY, ranges, 1);
cvCalcHist( &inputImage, my_hist, 0, NULL );
cvNormalizeHist(my_hist, normalization_sum);
// NOTE: First argument MUST have an ampersand, or a segmentation fault will result
cvCalcBackProject(&inputImage, histAdjustedImage, my_hist);
// Histogram Picture
int bin_w;
float max_value = 0;
cvGetMinMaxHistValue( my_hist, 0, &max_value, 0, 0 );
cvScale( my_hist->bins, my_hist->bins, ((double)hist_image->height)/max_value, 0 );
cvSet( hist_image, cvScalarAll(255), 0 );
bin_w = cvRound((double)hist_image->width/hist_size);
for(int i = 0; i < hist_size; i++ )
cvRectangle( hist_image, cvPoint(i*bin_w, hist_image->height), cvPoint((i+1)*bin_w, hist_image->height - cvRound(cvGetReal1D(my_hist->bins,i))), cvScalarAll(0), -1, 8, 0 );
cvShowImage( "Histogram Window", hist_image );
cvShowImage("Back Projected Image", histAdjustedImage);
// Brightness/contrast loop stuff:
int brightness = _brightness - 100;
int contrast = _contrast - 100;
/*
* The algorithm is by Werner D. Streidt
* (http://visca.com/ffactory/archives/5-99/msg00021.html)
*/
if( contrast > 0 ) {
double delta = 127.*contrast/100;
double a = 255./(255. - delta*2);
double b = a*(brightness - delta);
for(int i = 0; i < 256; i++ )
{
int v = cvRound(a*i + b);
if( v < 0 ) v = 0;
if( v > 255 ) v = 255;
lut[i] = (uchar)v;
}
}
else {
double delta = -128.*contrast/100;
double a = (256.-delta*2)/255.;
double b = a*brightness + delta;
for(int i = 0; i < 256; i++ ) {
int v = cvRound(a*i + b);
if( v < 0 )
v = 0;
if( v > 255 )
v = 255;
lut[i] = (uchar)v;
}
}
cvLUT( inputImage, bright_cont_image, lut_mat );
cvShowImage( "Brightness and Contrast Window", bright_cont_image);
// ---------------
// Blob Manipulation Code begins here:
// Extract the blobs using a threshold of 100 in the image
blobs = CBlobResult( bright_cont_image, NULL, blob_extraction_threshold, true );
// discard the blobs with less area than 5000 pixels
// ( the criteria to filter can be any class derived from COperadorBlob )
blobs.Filter( blobs, B_INCLUDE, CBlobGetArea(), B_GREATER_OR_EQUAL, min_blob_size);
blobs.Filter( blobs, B_EXCLUDE, CBlobGetArea(), B_GREATER, max_blob_size);
// build an output image equal to the input but with 3 channels (to draw the coloured blobs)
cvMerge( bright_cont_image, bright_cont_image, bright_cont_image, NULL, outputImage );
// plot the selected blobs in a output image
for (int i=0; i < blobs.GetNumBlobs(); i++) {
blobs.GetNthBlob( CBlobGetArea(), i, my_enumerated_blob );
// Color 5/6 of the color wheel (300 degrees)
my_enumerated_blob.FillBlob( outputImage, cv_hsv2rgb((float)i/blobs.GetNumBlobs() * 300, 1, 1));
}
// END Blob Manipulation Code
// ---------------
sprintf(str, "Count: %d", blobs.GetNumBlobs());
cvPutText(outputImage, str, cvPoint(50, 25), &font, cvScalar(255,0,255));
cvShowImage("Blob Output Window", outputImage);
/*
// Rainbow manipulation:
for (int i=0; i < CV_CAP_PROP_FRAME_WIDTH; i++) {
for (int j=0; j < CV_CAP_PROP_FRAME_HEIGHT; j++) {
// This line is not figure out yet...
// pixel_color_set = ((uchar*)(rainbowImage->imageData + rainbowImage->widthStep * j))[i * 3]
((uchar*)(rainbowImage->imageData + rainbowImage->widthStep * j))[i * 3] = 30;
((uchar*)(rainbowImage->imageData + rainbowImage->widthStep * j))[i * 3 + 1] = 30;
((uchar*)(rainbowImage->imageData + rainbowImage->widthStep * j))[i * 3 + 2] = 30;
}
}
cvShowImage("Rainbow Window", rainbowImage);
*/
//If ESC key pressed, Key=0x10001B under OpenCV 0.9.7(linux version),
//remove higher bits using AND operator
if( (cvWaitKey(10) & 255) == 27 ) break;
}
cvReleaseImage(&inputImage);
cvReleaseImage(&histAdjustedImage);
cvReleaseImage(&hist_image);
cvReleaseImage(&bright_cont_image);
cvReleaseImage(&outputImage);
cvReleaseImage(&rainbowImage);
// Release the capture device housekeeping
cvReleaseCapture( &capture );
cvDestroyAllWindows();
return 0;
}
SHModel* ShapeModel( CvCapture* g_capture,StaticBGModel* BGModel , BGModelParams* BGParams){
int num_frames = 0;
int total_blobs=0;
float Sumatorio = 0;
float SumatorioDes = 0;
IplImage* frame = NULL;
STFrame* frameData = NULL;
SHModel* Shape = NULL;
CBlobResult blobs;
CBlob *currentBlob;
IplImage* ImGris = cvCreateImage(cvGetSize( BGModel->Imed ), 8, 1 );
IplImage* Imblob = cvCreateImage(cvGetSize( BGModel->Imed ), 8, 3 );
IplImage* lastBG = cvCreateImage( cvGetSize( BGModel->Imed ),8, 1 );
IplImage* lastIdes = cvCreateImage( cvGetSize( BGModel->Imed ), IPL_DEPTH_32F, 1);
cvZero(Imblob);
// Iniciar estructura para modelo de forma
Shape = ( SHModel *) malloc( sizeof( SHModel));
if ( !Shape ) {error(4);return 0;}
Shape->FlyAreaDes = 0;
Shape->FlyAreaMedia=0;
//Pone a 0 los valores del vector areas
//EXTRACCION DE LOS BLOBS Y CALCULO DE MEDIANA/MEDIA Y DESVIACION TIPICA PARA TODOS LOS FRAMES
cvSetCaptureProperty( g_capture,1,BGParams->initDelay ); // establecemos la posición
while( num_frames < ShParams->FramesTraining ){
frame = cvQueryFrame( g_capture );
if ( !frame ) {
error(2);
break;
}
if ( (cvWaitKey(10) & 255) == 27 ) break;
ImPreProcess( frame, ImGris, BGModel->ImFMask, 0, BGModel->DataFROI);
// Cargamos datos del fondo
if(!frameData ) { //en la primera iteración iniciamos el modelo dinamico al estático
// Iniciar estructura para datos del nuevo frame
frameData = InitNewFrameData( frame );
cvCopy( BGModel->Imed,frameData->BGModel);
cvSet(frameData->IDesvf, cvScalar(1));
cvCopy( BGModel->Imed,lastBG);
}
else{ // cargamos los últimos parámetros del fondo.
cvCopy( lastBG, frameData->BGModel);
cvCopy( lastIdes,frameData->IDesvf );
}
// obtener la mascara del FG y la lista con los datos de sus blobs.
//// BACKGROUND UPDATE
// Actualización del fondo
// establecer parametros
UpdateBGModel( ImGris,frameData->BGModel,frameData->IDesvf, BGParams, BGModel->DataFROI, BGModel->ImFMask );
/////// BACKGROUND DIFERENCE. Obtención de la máscara del foreground
BackgroundDifference( ImGris, frameData->BGModel,frameData->IDesvf, frameData->FG ,BGParams, BGModel->DataFROI);
// guardamos las imagenes para iniciar el siguiente frame
cvCopy( frameData->BGModel, lastBG);
cvCopy( frameData->IDesvf,lastIdes);
//Obtener los Blobs y excluir aquellos que no interesan por su tamaño
// cvSetImageROI( frameData->FG , BGModel->DataFROI);
blobs = CBlobResult( frameData->FG, NULL, 100, true );
blobs.Filter( blobs, B_EXCLUDE, CBlobGetArea(),B_GREATER,100);
blobs.Filter( blobs, B_EXCLUDE, CBlobGetPerimeter(),B_GREATER,1000);
int j = blobs.GetNumBlobs();//numero de blos encontrados en el frame
total_blobs=total_blobs+j; // Contabiliza los blobs encontrados para todos los frames
//Recorrer Blob a blob y obtener las caracteristicas del AREA de cada uno de ellos
for (int i = 0; i < blobs.GetNumBlobs(); i++ ){ //for 1
currentBlob = blobs.GetBlob(i);
CBlobGetArea();
if(ShParams->SHOW_DATA_AREAS) {
//printf("Area blob %d = %f ",i,currentBlob->area);
}
//Estimar la media de las Areas
Sumatorio = Sumatorio + currentBlob->area;
SumatorioDes = SumatorioDes + currentBlob->area*currentBlob->area;
muestrearAreas( currentBlob->area);
currentBlob->FillBlob( Imblob, CV_RGB(255,0,0));
}//Fin del For 1
Shape->FlyAreaMedia = Sumatorio / total_blobs;
Shape->FlyAreaDes = (SumatorioDes / total_blobs) - Shape->FlyAreaMedia*Shape->FlyAreaMedia;
num_frames += 1;
// cvResetImageROI(frameData->FG);
DraWWindow(Imblob, frameData, BGModel, SHOW_SHAPE_MODELING, COMPLETO);
DraWWindow(Imblob, frameData, BGModel, SHAPE,SIMPLE );
}
desvanecer( NULL, 20);
Shape->FlyAreaDes = sqrt(abs(Shape->FlyAreaDes) ) ;
if( Shape->FlyAreaDes == 0){
printf("hola");
}
//Mostrar mediana y media para todos los frames
if(ShParams->SHOW_DATA_AREAS )
printf("\n MEDIA AREAS: %f \t DESVIACION AREAS: %f",Shape->FlyAreaMedia,Shape->FlyAreaDes);
free( ShParams);
liberarSTFrame( frameData );
cvReleaseImage( &ImGris);
cvReleaseImage( &Imblob);
cvReleaseImage( &lastIdes);
cvReleaseImage( &lastBG);
return Shape;
}//Fin de la función ShapeModel2
void
Auvsi_Recognize::extractLetter( void )
{
typedef cv::Vec<unsigned char, 1> VT_binary;
#ifdef TWO_CHANNEL
typedef cv::Vec<T, 2> VT;
#else
typedef cv::Vec<T, 3> VT;
#endif
typedef cv::Vec<int, 1> IT;
// Erode input slightly
cv::Mat input;
cv::erode( _shape, input, cv::Mat() );
// Remove any small white blobs left over
CBlobResult blobs;
CBlob * currentBlob;
CBlob biggestBlob;
IplImage binaryIpl = input;
blobs = CBlobResult( &binaryIpl, NULL, 0 );
blobs.GetNthBlob( CBlobGetArea(), 0, biggestBlob );
blobs.Filter( blobs, B_EXCLUDE, CBlobGetArea(), B_GREATER_OR_EQUAL, biggestBlob.Area() );
for (int i = 0; i < blobs.GetNumBlobs(); i++ )
{
currentBlob = blobs.GetBlob(i);
currentBlob->FillBlob( &binaryIpl, cvScalar(0));
}
// Perform k-means on this region only
int areaLetter = (int)biggestBlob.Area();
cv::Mat kMeansInput = cv::Mat( areaLetter, 1, _image.type() );
// Discard if we couldn't extract a letter
if( areaLetter <= 0 )
{
_letter = cv::Mat( _shape );
_letter = cv::Scalar(0);
return;
}
cv::MatIterator_<VT_binary> binaryIterator = input.begin<VT_binary>();
cv::MatIterator_<VT_binary> binaryEnd = input.end<VT_binary>();
cv::MatIterator_<VT> kMeansIterator = kMeansInput.begin<VT>();
for( ; binaryIterator != binaryEnd; ++binaryIterator )
{
if( (*binaryIterator)[0] > 0 )
{
(*kMeansIterator) = _image.at<VT>( binaryIterator.pos() );
++kMeansIterator;
}
}
// Get k-means labels
cv::Mat labels = doClustering<T>( kMeansInput, 2, false );
int numZeros = areaLetter - cv::countNonZero( labels );
bool useZeros = numZeros < cv::countNonZero( labels );
// Reshape into original form
_letter = cv::Mat( _shape.size(), _shape.type() );
_letter = cv::Scalar(0);
binaryIterator = input.begin<VT_binary>();
binaryEnd = input.end<VT_binary>();
cv::MatIterator_<IT> labelsIterator = labels.begin<IT>();
for( int index = 0; binaryIterator != binaryEnd; ++binaryIterator )
{
if( (*binaryIterator)[0] > 0 )
{
// Whichever label was the minority, we make that value white and all other values black
unsigned char value = (*labelsIterator)[0];
if( useZeros )
if( value )
value = 0;
else
value = 255;
else
if( value )
value = 255;
else
value = 0;
_letter.at<VT_binary>( binaryIterator.pos() ) = VT_binary( value );
++labelsIterator;
}
}
}
void blobbing( IplImage *hi, char * win1, char * win2, int check ) {
cvCvtColor(hi,hi2,CV_BGR2HSV);
uchar *itemp=(uchar *)(hi2->imageData);
uchar *itemp1=(uchar *)(hitemp->imageData);
// binary conversion
for(int i=0;i<hi2->height;i++){
for(int j=0;j<hi2->width;j++){
if((itemp[i*hi2->widthStep+j*hi2->nChannels] <hh)
&&
(itemp[i*hi2->widthStep+j*hi2->nChannels]>hl)
&&
(itemp[i*hi2->widthStep+j*hi2->nChannels+1]<sh)
&&
(itemp[i*hi2->widthStep+j*hi2->nChannels+1]>sl)
&&
( itemp[i*hi2->widthStep+j*hi2->nChannels+2]<vh)
&&
( itemp[i*hi2->widthStep+j*hi2->nChannels+2]>vl) //previous 124
)
{
itemp1[i*hitemp->widthStep+j]=0; //dark regions black rest white
}
else
itemp1[i*hitemp->widthStep+j]=255;
}}
cvErode( hitemp, hitemp1, NULL, 3);
cvDilate(hitemp1, hitemp1, NULL, 3);
hitemp=hitemp1;
CBlobResult blob;
CBlob *currentBlob=NULL;
blob=CBlobResult(hitemp1,NULL,255);
blob.Filter(blob,B_EXCLUDE,CBlobGetArea(),B_LESS,500);
cvMerge(hitemp1,hitemp1,hitemp1,NULL,out);
CBlob hand1,hand2; //two blobs,one for each hand
blob.GetNthBlob( CBlobGetArea(), 0, (hand2));
blob.GetNthBlob( CBlobGetArea(), 1, (hand1 ));
hand1.FillBlob(out,CV_RGB(0,0,255)); //fill the color of blob of hand one with blue
hand2.FillBlob(out,CV_RGB(0,255,0)); //fill the color of blob of hand two with green
coordinates (out,check); //to find the coordinates of the hands we pass the image onto the function coordinates
int greater1,greater2,lesser1,lesser2;
if(x>X) {
greater1=x,greater2=y;
lesser1=X,lesser2=Y;
}
else {
greater1=X,greater2=Y;
lesser1=x,lesser2=y;
}
/*cvCircle ( hi, cvPoint(greater1,greater2), 10,
cvScalar(0,0,255), -1, 8 );
cvCircle ( hi, cvPoint(lesser1,lesser2), 10,
cvScalar(0,255,255), -1, 8 );
*/
cvResizeWindow(win2,280,280);
cvMoveWindow(win2,0,0);
cvShowImage(win2,out);
return ;
}
