void margBlobInterpolator :: makeInterpolated(vector<margBlob> current) {
if (prevBlobs.size() == 0) {
// If previous blobs ARE NOT saved. Save current and return them.
prevBlobs = current;
}
else {
int nBlobs = current.size();
vector<margBlob> currentCopy = current;
current.clear();
// If previous blobs ARE saved, continue and check for good pairs
int* pairs = findPairs(currentCopy);
for (int i = 0; i < nBlobs; i++) {
if (pairs[i] >= 0) {
if (prevBlobs[pairs[i]].pts.size() > 0) {
vector<margBlob> interBlobs = interpolate(prevBlobs[pairs[i]], currentCopy[i]);
for (int j = 0; j < interBlobs.size(); j++) {
current.push_back(interBlobs[j]);
}
}
}
else {
current.push_back(currentCopy[i]);
}
}
prevBlobs.clear();
prevBlobs = currentCopy;
finalBlobs.clear();
finalBlobs= current;
if(pairs != 0) delete[] pairs;
}
}
/* a rough implementation for object location */
int
locatePlanarObject( const CvSeq* objectKeypoints, const CvSeq* objectDescriptors,
const CvSeq* imageKeypoints, const CvSeq* imageDescriptors,
const CvPoint src_corners[4], CvPoint dst_corners[4] )
{
double h[9];
CvMat _h = cvMat(3, 3, CV_64F, h);
// vector<int> ptpairs;
// vector<CvPoint2D32f> pt1, pt2;
struct pairList * ptpairs = 0;
CvMat _pt1, _pt2;
int i, n;
findPairs( objectKeypoints, objectDescriptors, imageKeypoints, imageDescriptors, ptpairs );
n = (int)(ptpairs->currentItems);
if( n < 4 )
return 0;
struct pair * pairA = (struct pair *) malloc(sizeof(struct pair) * n );
struct pair * pairB = (struct pair *) malloc(sizeof(struct pair) * n );
for( i = 0; i < n; i+=2 )
{
// pairA[i].p1 = ptpairs[i].p1; // ((CvSURFPoint*)cvGetSeqElem(objectKeypoints,ptpairs[i*2]))->pt;
// pairA[i].p2 = ptpairs[i].p2; // ((CvSURFPoint*)cvGetSeqElem(objectKeypoints,ptpairs[i*2]))->pt;
// pairB[i].p1 = ptpairs[i+1].p1; // ((CvSURFPoint*)cvGetSeqElem(imageKeypoints,ptpairs[i*2+1]))->pt;
// pairB[i].p2 = ptpairs[i+1].p2; // ((CvSURFPoint*)cvGetSeqElem(imageKeypoints,ptpairs[i*2+1]))->pt;
}
_pt1 = cvMat(1, n, CV_32FC2, pairA );
_pt2 = cvMat(1, n, CV_32FC2, pairB );
if( !cvFindHomography( &_pt1, &_pt2, &_h, CV_RANSAC, 5 , 0 )) { return 0; }
for( i = 0; i < 4; i++ )
{
double x = src_corners[i].x, y = src_corners[i].y;
double Z = 1./(h[6]*x + h[7]*y + h[8]);
double X = (h[0]*x + h[1]*y + h[2])*Z;
double Y = (h[3]*x + h[4]*y + h[5])*Z;
dst_corners[i] = cvPoint(cvRound(X), cvRound(Y));
}
return 1;
}
/* a rough implementation for object location */
int
locatePlanarObject( const CvSeq* objectKeypoints, const CvSeq* objectDescriptors,
const CvSeq* imageKeypoints, const CvSeq* imageDescriptors,
const CvPoint src_corners[4], CvPoint dst_corners[4] )
{
double h[9];
CvMat _h = cvMat(3, 3, CV_64F, h);
vector<int> ptpairs;
vector<CvPoint2D32f> pt1, pt2;
CvMat _pt1, _pt2;
int i, n;
#ifdef USE_FLANN
flannFindPairs( objectKeypoints, objectDescriptors, imageKeypoints, imageDescriptors, ptpairs );
#else
findPairs( objectKeypoints, objectDescriptors, imageKeypoints, imageDescriptors, ptpairs );
#endif
n = ptpairs.size()/2;
if( n < 4 )
return 0;
pt1.resize(n);
pt2.resize(n);
for( i = 0; i < n; i++ )
{
pt1[i] = ((CvSURFPoint*)cvGetSeqElem(objectKeypoints,ptpairs[i*2]))->pt;
pt2[i] = ((CvSURFPoint*)cvGetSeqElem(imageKeypoints,ptpairs[i*2+1]))->pt;
}
_pt1 = cvMat(1, n, CV_32FC2, &pt1[0] );
_pt2 = cvMat(1, n, CV_32FC2, &pt2[0] );
if( !cvFindHomography( &_pt1, &_pt2, &_h, CV_RANSAC, 5 ))
return 0;
for( i = 0; i < 4; i++ )
{
double x = src_corners[i].x, y = src_corners[i].y;
double Z = 1./(h[6]*x + h[7]*y + h[8]);
double X = (h[0]*x + h[1]*y + h[2])*Z;
double Y = (h[3]*x + h[4]*y + h[5])*Z;
dst_corners[i] = cvPoint(cvRound(X), cvRound(Y));
}
return 1;
}
int openCV_SURFDetector(struct Image * pattern,struct Image * img)
{
StartTimer(FIND_OBJECTS_DELAY);
monochrome(img);
IplImage * image = cvCreateImage( cvSize(img->width,img->height), IPL_DEPTH_8U, img->depth);
char * opencvImagePointerRetainer = image->imageData; // UGLY HACK
image->imageData = (char*) img->pixels; // UGLY HACK
//cvCvtColor( image, image, CV_RGB2GRAY);
monochrome(pattern);
IplImage * object = cvCreateImage( cvSize(pattern->width,pattern->height), IPL_DEPTH_8U, pattern->depth);
char * opencvObjectPointerRetainer = object->imageData; // UGLY HACK
object->imageData = (char*) pattern->pixels; // UGLY HACK
//cvCvtColor( object, object, CV_RGB2GRAY);
CvMemStorage* storage = cvCreateMemStorage(0);
static CvScalar colors[] = { {{0,0,255}}, {{0,128,255}}, {{0,255,255}}, {{0,255,0}}, {{255,128,0}}, {{255,255,0}}, {{255,0,0}}, {{255,0,255}}, {{255,255,255}} };
IplImage* object_color = cvCreateImage(cvGetSize(object), 8, 3);
cvCvtColor( object, object_color, CV_GRAY2BGR );
CvSeq* objectKeypoints = 0, *objectDescriptors = 0;
CvSeq* imageKeypoints = 0, *imageDescriptors = 0;
int i;
CvSURFParams params = cvSURFParams(500, 1);
double tt = (double)cvGetTickCount();
cvExtractSURF( object, 0, &objectKeypoints, &objectDescriptors, storage, params , 0 );
//printf("Object Descriptors: %d\n", objectDescriptors->total);
cvExtractSURF( image, 0, &imageKeypoints, &imageDescriptors, storage, params , 0 );
//printf("Image Descriptors: %d\n", imageDescriptors->total);
tt = (double)cvGetTickCount() - tt;
//printf( "Extraction time = %gms\n", tt/(cvGetTickFrequency()*1000.));
CvPoint src_corners[4] = {{0,0}, {object->width,0}, {object->width, object->height}, {0, object->height}};
CvPoint dst_corners[4];
//IplImage* correspond = cvCreateImage( cvSize(image->width, object->height+image->height), 8, 1 );
//cvSetImageROI( correspond, cvRect( 0, 0, object->width, object->height ) );
//cvCopy( object, correspond , 0 );
//cvSetImageROI( correspond, cvRect( 0, object->height, correspond->width, correspond->height ) );
//cvCopy( image, correspond , 0 );
//cvResetImageROI( correspond );
if( locatePlanarObject( objectKeypoints, objectDescriptors, imageKeypoints, imageDescriptors, src_corners, dst_corners ))
{
for( i = 0; i < 4; i++ )
{
CvPoint r1 = dst_corners[i%4];
CvPoint r2 = dst_corners[(i+1)%4];
//cvLine( correspond, cvPoint(r1.x, r1.y+object->height ), cvPoint(r2.x, r2.y+object->height ), colors[8] , 1 ,8 ,0 );
}
}
struct pairList * ptpairs = 0;
findPairs( objectKeypoints, objectDescriptors, imageKeypoints, imageDescriptors, ptpairs );
printf(" Found %u pairs \n",(int) ptpairs->currentItems);
image->imageData = opencvImagePointerRetainer; // UGLY HACK
cvReleaseImage( &image );
image->imageData = opencvObjectPointerRetainer; // UGLY HACK
cvReleaseImage( &object );
EndTimer(FIND_OBJECTS_DELAY);
/*
for( i = 0; i < (int)ptpairs->currentItems; i++ )
{
CvSURFPoint* r1 = (CvSURFPoint*)cvGetSeqElem( objectKeypoints, ptpairs->item[i].p1; );
CvSURFPoint* r2 = (CvSURFPoint*)cvGetSeqElem( imageKeypoints, ptpairs->item[i].p2; );
cvLine( correspond, cvPointFrom32f(r1->pt),
cvPoint(cvRound(r2->pt.x), cvRound(r2->pt.y+object->height)), colors[8] );
}
cvShowImage( "Object Correspond", correspond );
for( i = 0; i < objectKeypoints->total; i++ )
{
CvSURFPoint* r = (CvSURFPoint*)cvGetSeqElem( objectKeypoints, i );
CvPoint center;
int radius;
center.x = cvRound(r->pt.x);
center.y = cvRound(r->pt.y);
radius = cvRound(r->size*1.2/9.*2);
cvCircle( object_color, center, radius, colors[0], 1, 8, 0 );
}
cvShowImage( "Object", object_color );
cvWaitKey(0);
cvDestroyWindow("Object");
cvDestroyWindow("Object Correspond");
*/
return 1;
}
int sift_affine(const char * filenameLeft , const char * filenameRight , double SIFTThreshold ,
unsigned int RANSACLoops ,
unsigned int stitchedBorder ,
double reprojectionThresholdX ,
double reprojectionThresholdY ,
unsigned int useOpenCVEstimator
)
{
fprintf(stderr,"Running SIFT on %s / %s \n" , filenameLeft , filenameRight);
cv::Mat left = cv::imread(filenameLeft , CV_LOAD_IMAGE_COLOR);
if(! left.data ) { fprintf(stderr,"Left Image missing \n"); return 1; }
cv::Mat right = cv::imread(filenameRight, CV_LOAD_IMAGE_COLOR);
if(! right.data ) { fprintf(stderr,"Right Image missing \n"); return 1; }
cv::DescriptorExtractor* extractor = new cv::SiftDescriptorExtractor();
cv::SiftFeatureDetector detector;
std::vector<cv::KeyPoint> keypointsLeft;
cv::Mat descriptorsLeft;
detector.detect(left, keypointsLeft);
extractor->compute(left, keypointsLeft, descriptorsLeft);
// Add results to image and save.
cv::Mat output;
cv::drawKeypoints(left, keypointsLeft, output);
cv::imwrite("sift_features_left.jpg", output);
std::vector<cv::KeyPoint> keypointsRight;
cv::Mat descriptorsRight;
detector.detect(right, keypointsRight);
extractor->compute(right, keypointsRight, descriptorsRight);
cv::drawKeypoints(right, keypointsRight, output);
cv::imwrite("sift_features_right.jpg", output);
//fprintf(stderr,"SIFT features ready \n");
std::vector<cv::Point2f> srcRANSACPoints;
std::vector<cv::Point2f> dstRANSACPoints;
std::vector<cv::Point2f> srcPoints;
std::vector<cv::Point2f> dstPoints;
findPairs( SIFTThreshold , keypointsLeft, descriptorsLeft, keypointsRight, descriptorsRight, srcPoints, dstPoints);
//printf("%zd keypoints are matched.\n", srcPoints.size());
visualizeMatches(
"sift_initial_match.jpg" ,
left ,
keypointsLeft,
descriptorsLeft,
right ,
keypointsRight,
descriptorsRight,
srcPoints,
dstPoints,
srcRANSACPoints,
dstRANSACPoints
);
cv::Mat warp_mat( 2, 3, CV_64FC1 );
double M[6]={0};
fitAffineTransformationMatchesRANSAC( RANSACLoops , reprojectionThresholdX , reprojectionThresholdY , M , warp_mat, srcPoints , dstPoints , srcRANSACPoints, dstRANSACPoints);
stitchAffineMatch(
"wrappedAffine.jpg" ,
stitchedBorder,
left ,
right ,
warp_mat
);
visualizeMatches(
"sift_affine_match.jpg" ,
left ,
keypointsLeft,
descriptorsLeft,
right ,
keypointsRight,
descriptorsRight,
srcPoints,
dstPoints ,
srcRANSACPoints,
dstRANSACPoints
);
cv::Mat homo_mat( 3, 3, CV_64FC1 );
double H[9]={0};
if (useOpenCVEstimator)
{
homo_mat = cv::findHomography(srcPoints , dstPoints , CV_RANSAC);
} else
{
fitHomographyTransformationMatchesRANSAC( RANSACLoops , reprojectionThresholdX , reprojectionThresholdY , H , homo_mat, srcPoints , dstPoints , srcRANSACPoints, dstRANSACPoints);
}
stitchHomographyMatch(
"wrappedHomography.jpg" ,
stitchedBorder,
left ,
right ,
homo_mat
);
visualizeMatches(
"sift_homography_match.jpg" ,
left ,
keypointsLeft,
descriptorsLeft,
right ,
keypointsRight,
descriptorsRight,
srcPoints,
dstPoints ,
srcRANSACPoints,
dstRANSACPoints
);
}
// chain function; this function does the actual processing
static GstFlowReturn
gst_surf_tracker_chain(GstPad *pad, GstBuffer *buf) {
GstSURFTracker *filter;
GstClockTime timestamp;
// sanity checks
g_return_val_if_fail(pad != NULL, GST_FLOW_ERROR);
g_return_val_if_fail(buf != NULL, GST_FLOW_ERROR);
filter = GST_SURF_TRACKER(GST_OBJECT_PARENT(pad));
filter->image->imageData = (char*) GST_BUFFER_DATA(buf);
// Create the gray image for the surf 'features' search process
cvCvtColor(filter->image, filter->gray, CV_BGR2GRAY);
++filter->frames_processed;
timestamp = GST_BUFFER_TIMESTAMP(buf);
// If exist stored_objects: search matching, update, cleaning
if ((filter->stored_objects != NULL) && (filter->stored_objects->len > 0)) {
CvMemStorage *surf_image_mem_storage;
CvSeq *surf_image_keypoints, *surf_image_descriptors;
guint i;
gint j;
// Update the match set 'features' for each object
surf_image_mem_storage = cvCreateMemStorage(0);
// Search 'features' in full image
surf_image_keypoints = surf_image_descriptors = NULL;
cvExtractSURF(filter->gray, NULL, &surf_image_keypoints, &surf_image_descriptors,
surf_image_mem_storage, filter->params, 0);
for (i = 0; i < filter->stored_objects->len; ++i) {
InstanceObject *object;
GArray *pairs;
object = &g_array_index(filter->stored_objects, InstanceObject, i);
pairs = g_array_new(FALSE, FALSE, sizeof(IntPair));
findPairs(object->surf_object_keypoints, object->surf_object_descriptors,
surf_image_keypoints, surf_image_descriptors, pairs);
// if match, update object
if (pairs->len && (float) pairs->len / object->surf_object_descriptors->total >= MIN_MATCH_OBJECT) {
object->range_viewed++;
object->last_frame_viewed = filter->frames_processed;
object->timestamp = timestamp;
if (object->surf_object_keypoints_last_match != NULL)
cvClearSeq(object->surf_object_keypoints_last_match);
object->surf_object_keypoints_last_match = getMatchPoints(surf_image_keypoints, pairs, 1, object->mem_storage);
if (object->surf_object_descriptors_last_match != NULL)
cvClearSeq(object->surf_object_descriptors_last_match);
object->surf_object_descriptors_last_match = getMatchPoints(surf_image_descriptors, pairs, 1, object->mem_storage);
// Estimate rect of objects localized
object->rect_estimated = rectDisplacement(object->surf_object_keypoints, surf_image_keypoints, pairs, object->rect, PAIRS_PERC_CONSIDERATE);
}
g_array_free(pairs, TRUE);
}
if (surf_image_keypoints != NULL) cvClearSeq(surf_image_keypoints);
if (surf_image_descriptors != NULL) cvClearSeq(surf_image_descriptors);
cvReleaseMemStorage(&surf_image_mem_storage);
// Clean old objects
for (j = filter->stored_objects->len - 1; j >= 0; --j) {
InstanceObject *object;
object = &g_array_index(filter->stored_objects, InstanceObject, j);
if ((filter->frames_processed - object->last_frame_viewed > DELOBJ_NFRAMES_IS_OLD) ||
(filter->frames_processed != object->last_frame_viewed && object->range_viewed < DELOBJ_COMBOFRAMES_IS_IRRELEVANT)) {
if (object->surf_object_keypoints != NULL) cvClearSeq(object->surf_object_keypoints);
if (object->surf_object_descriptors != NULL) cvClearSeq(object->surf_object_descriptors);
if (object->surf_object_keypoints_last_match != NULL) cvClearSeq(object->surf_object_keypoints_last_match);
if (object->surf_object_descriptors_last_match != NULL) cvClearSeq(object->surf_object_descriptors_last_match);
cvReleaseMemStorage(&object->mem_storage);
g_array_remove_index_fast(filter->stored_objects, j);
}
}
} // if any object exist
// Process all haar rects
if ((filter->rect_array != NULL) && (filter->rect_array->len > 0)) {
guint i, j;
for (i = 0; i < filter->rect_array->len; ++i) {
CvRect rect = g_array_index(filter->rect_array, CvRect, i);
// If already exist in 'stored_objects', update features. Else save
// as new.
for (j = 0; j < filter->stored_objects->len; ++j) {
InstanceObject *object;
object = &g_array_index(filter->stored_objects, InstanceObject, j);
// It is considered equal if the "centroid match features" is inner
// haar rect AND max area deviation is PERC_RECT_TO_SAME_OBJECT
if (pointIntoRect(rect, (object->surf_object_keypoints_last_match != NULL) ? surfCentroid(object->surf_object_keypoints_last_match, cvPoint(0, 0)) : surfCentroid(object->surf_object_keypoints, cvPoint(0, 0))) &&
((float) MIN((object->rect.width * object->rect.height), (rect.width * rect.height)) / (float) MAX((object->rect.width * object->rect.height), (rect.width * rect.height)) >= PERC_RECT_TO_SAME_OBJECT)) {
// Update the object features secound the new body rect
cvSetImageROI(filter->gray, rect);
cvExtractSURF(filter->gray, NULL, &object->surf_object_keypoints, &object->surf_object_descriptors,
object->mem_storage, filter->params, 0);
cvResetImageROI(filter->gray);
object->rect = object->rect_estimated = rect;
object->last_body_identify_timestamp = timestamp;
break;
}
}
// If new, create object and append in stored_objects
if (j >= filter->stored_objects->len) {
InstanceObject object;
object.surf_object_keypoints = 0;
object.surf_object_descriptors = 0;
object.mem_storage = cvCreateMemStorage(0);
cvSetImageROI(filter->gray, rect);
cvExtractSURF(filter->gray, NULL, &object.surf_object_keypoints, &object.surf_object_descriptors,
object.mem_storage, filter->params, 0);
cvResetImageROI(filter->gray);
if (object.surf_object_descriptors && object.surf_object_descriptors->total > 0) {
object.id = filter->static_count_objects++;
object.last_frame_viewed = filter->frames_processed;
object.range_viewed = 1;
object.rect = object.rect_estimated = rect;
object.timestamp = object.last_body_identify_timestamp = timestamp;
object.surf_object_keypoints_last_match = NULL;
object.surf_object_descriptors_last_match = NULL;
g_array_append_val(filter->stored_objects, object);
}
} // new
}
}
// Put the objects found in the frame in gstreamer pad
if ((filter->stored_objects != NULL) && (filter->stored_objects->len > 0)) {
guint i;
for (i = 0; i < filter->stored_objects->len; ++i) {
InstanceObject object = g_array_index(filter->stored_objects, InstanceObject, i);
// 'Continue' whether the object is not found in this frame
if (object.timestamp == timestamp) {
TrackedObject *tracked_object;
GstEvent *event;
CvRect rect;
rect = ((object.last_body_identify_timestamp == timestamp) ? object.rect : object.rect_estimated);
if (filter->verbose) {
GST_INFO("[object #%d rect] x: %d, y: %d, width: %d, height: %d\n", object.id, rect.x, rect.y, rect.width, rect.height);
// drawSurfPoints(object.surf_object_keypoints, cvPoint(object.rect.x, object.rect.y), filter->image, PRINT_COLOR, 0);
// drawSurfPoints(object.surf_object_keypoints_last_match, cvPoint(object.rect.x, object.rect.y), filter->image, PRINT_COLOR, 1);
}
if (filter->display_features) {
drawSurfPoints(object.surf_object_keypoints_last_match, cvPoint(0, 0), filter->image, PRINT_COLOR, 1);
}
if (filter->display) {
char *label;
float font_scaling;
font_scaling = ((filter->image->width * filter->image->height) > (320 * 240)) ? 0.5f : 0.3f;
cvRectangle(filter->image, cvPoint(rect.x, rect.y), cvPoint(rect.x + rect.width, rect.y + rect.height),
PRINT_COLOR, ((object.last_body_identify_timestamp == timestamp) ? 2 : 1), 8, 0);
label = g_strdup_printf("OBJ#%i", object.id);
printText(filter->image, cvPoint(rect.x + (rect.width / 2), rect.y + (rect.height / 2)), label, PRINT_COLOR, font_scaling, 1);
g_free(label);
}
// allocate and initialize 'TrackedObject' structure
tracked_object = tracked_object_new();
tracked_object->id = g_strdup_printf("PERSON#%d", object.id);
tracked_object->type = TRACKED_OBJECT_DYNAMIC;
tracked_object->height = rect.height;
tracked_object->timestamp = timestamp;
// add the points that the define the lower part of the object (i.e,
// the lower horizontal segment of the rectangle) as the objects perimeter
tracked_object_add_point(tracked_object, rect.x, rect.y + rect.height);
tracked_object_add_point(tracked_object, rect.x + rect.width, rect.y + rect.height);
// send downstream event
event = gst_event_new_custom(GST_EVENT_CUSTOM_DOWNSTREAM,
tracked_object_to_structure(tracked_object, "tracked-object"));
gst_pad_push_event(filter->srcpad, event);
}
}
}
// Clean body rects
g_array_free(filter->rect_array, TRUE);
filter->rect_array = g_array_sized_new(FALSE, FALSE, sizeof(CvRect), 1);
// Draw number of objects stored
if (filter->display) {
char *label = g_strdup_printf("N_STORED_OBJS: %3i", filter->stored_objects->len);
printText(filter->image, cvPoint(0, 0), label, PRINT_COLOR, .5, 1);
g_free(label);
}
gst_buffer_set_data(buf, (guint8*) filter->image->imageData, (guint) filter->image->imageSize);
return gst_pad_push(filter->srcpad, buf);
}
void surf_match(IplImage* object_color, IplImage* object, IplImage* image,const CvSeq *objectKeypoints,const CvSeq *imageKeypoints,const CvSeq * objectDescriptors,const CvSeq * imageDescriptors, CvPoint val[4])
{
cvNamedWindow("Object", 0);
cvNamedWindow("Object Correspond", 0);
static CvScalar colors[] =
{
{{0,0,255}},
{{0,128,255}},
{{0,255,255}},
{{0,255,0}},
{{255,128,0}},
{{255,255,0}},
{{255,0,0}},
{{255,0,255}},
{{255,255,255}}
};
int i;
CvPoint src_corners[4] = {{0,0}, {object->width,0}, {object->width, object->height}, {0, object->height}};
CvPoint dst_corners[4];
IplImage* correspond = cvCreateImage( cvSize(image->width, object->height+image->height), 8, 1 );
cvSetImageROI( correspond, cvRect( 0, 0, object->width, object->height ) );
cvCopy( object, correspond );
cvSetImageROI( correspond, cvRect( 0, object->height, correspond->width, correspond->height ) );
cvCopy( image, correspond );
cvResetImageROI( correspond );
#ifdef USE_FLANN
printf("Using approximate nearest neighbor search\n");
#endif
if( locatePlanarObject( objectKeypoints, objectDescriptors, imageKeypoints,
imageDescriptors, src_corners, dst_corners ))
{
for( i = 0; i < 4; i++ )
{
CvPoint r1 = dst_corners[i%4];
CvPoint r2 = dst_corners[(i+1)%4];
cvLine( correspond, cvPoint(r1.x, r1.y+object->height ),
cvPoint(r2.x, r2.y+object->height ), colors[8] );
}
}
vector<int> ptpairs;
#ifdef USE_FLANN
flannFindPairs( objectKeypoints, objectDescriptors, imageKeypoints, imageDescriptors, ptpairs );
#else
findPairs( objectKeypoints, objectDescriptors, imageKeypoints, imageDescriptors, ptpairs );
#endif
for( i = 0; i < (int)ptpairs.size(); i += 2 )
{
CvSURFPoint* r1 = (CvSURFPoint*)cvGetSeqElem( objectKeypoints, ptpairs[i] );
CvSURFPoint* r2 = (CvSURFPoint*)cvGetSeqElem( imageKeypoints, ptpairs[i+1] );
cvLine( correspond, cvPointFrom32f(r1->pt),
cvPoint(cvRound(r2->pt.x), cvRound(r2->pt.y+object->height)), colors[8] );
}
cvShowImage( "Object Correspond", correspond );
for( i = 0; i < objectKeypoints->total; i++ )
{
CvSURFPoint* r = (CvSURFPoint*)cvGetSeqElem( objectKeypoints, i );
CvPoint center;
int radius;
center.x = cvRound(r->pt.x);
center.y = cvRound(r->pt.y);
radius = cvRound(r->size*1.2/9.*2);
cvCircle( object_color, center, radius, colors[0], 1, 8, 0 );
}
cvShowImage( "Object", object_color );
cvWaitKey(0);
cvDestroyWindow("Object");
cvDestroyWindow("Object SURF");
cvDestroyWindow("Object Correspond");
//CvPoint val[4];
for(int k=0;k<4;k++)
{
// printf("%d %d \n", dst_corners[k].x, dst_corners[k].y);
val[k] = dst_corners[k];
val[k] = dst_corners[k];
}
}
