static void detectSURF(const IplImage* img, std::back_insert_iterator< std::vector< MyKeypoint > > ins, const int border) { CvMemStorage* storage = cvCreateMemStorage(0); CvSeq* surf_kpts = NULL; // Using SURF's default param. Not computing descriptors CvSURFParams par; par.extended = 0; par.hessianThreshold = 1000; par.nOctaves = 3; par.nOctaveLayers = 4; cvExtractSURF(img, NULL, &surf_kpts, NULL, storage, par); int cnt = 0; for (int i=0; i < (surf_kpts?surf_kpts->total:0); i++ ) { CvSURFPoint kpt = *(CvSURFPoint*)cvGetSeqElem(surf_kpts, i); // Reject points too close to the border, round coordinates to integers int x = cvRound(kpt.pt.x); int y = cvRound(kpt.pt.y); if (x<border || x>=img->width-border || y<border || y>=img->height-border) continue; MyKeypoint p(kpt.pt.x, kpt.pt.y, kpt.size, kpt.dir, const_cast< IplImage* >(img)); *ins = p; ++cnt; } printf("[OK] Extracted %i keypoints\n", cnt); }
ReturnType KitechSurfObjectRecognitionComp::onStart() { PrintMessage ("SUCCESS : KitechSurfObjectRecognitionComp::onStart()\n"); // dll 파일이름을 확인하여 없으면 에러 리턴 if( !parameter.FindName("DBName") ) { PrintMessage("ERROR : KitechSurfObjectRecognitionComp::onStart() -> Can't find DataBase %s.\n", parameter.GetValue("DBName").c_str()); return OPROS_FIND_PROPERTY_ERROR; } _objName = parameter.GetValue("DBName").c_str(); IplImage *cvImage = cvLoadImage( _objName.c_str() ); if( cvImage ) { IplImage *grayImage = cvCreateImage( cvGetSize(cvImage), 8, 1 ); cvCvtColor( cvImage, grayImage, CV_BGR2GRAY ); _objectStorage = cvCreateMemStorage(0); cvExtractSURF( grayImage, 0, &_objectKeypoints, &_objectDescriptors, _objectStorage, cvSURFParams(500,1) ); PrintMessage("SUCCESS:SURF_ObjectRecognition::onStart() -> Successfully load %s\n", _objName.c_str()); _orgWidth = grayImage->width; _orgHeight = grayImage->height; cvReleaseImage( &grayImage ); cvReleaseImage( &cvImage ); } else { PrintMessage("ERROR:SURF_ObjectRecognition::enable() -> Fail to load %s\n", _objName.c_str()); return OPROS_CALLER_ERROR; } return OPROS_SUCCESS; }
void ObjectDefinition::Init(IplImage* image) { m_params = cvSURFParams(hessianThreshold, 1); m_corners[0] = cvPoint(0,0); m_corners[1] = cvPoint(image->width,0); m_corners[2] = cvPoint(image->width,image->height); m_corners[3] = cvPoint(0,image->height); if(image->nChannels == 3) { IplImage* grayImage = cvCreateImage(cvSize(image->width, image->height), 8, 1); cvCvtColor(image, grayImage, CV_RGB2GRAY); cvExtractSURF(grayImage, 0, &m_keypoints, &m_descriptor, m_storage, m_params); cvReleaseImage(&grayImage); } else{ cvExtractSURF(image, 0, &m_keypoints, &m_descriptor, m_storage, m_params); } cvReleaseImage(&image); }
int main(int argc, char** argv) { const char* filename = argv[1]; int x; int y; int size; sscanf(argv[2], "%d", &x); sscanf(argv[3], "%d", &y); sscanf(argv[4], "%d", &size); int SURF_EXTENDED = 0; int SURF_HESSIAN_THRESHOLD = 500; int SURF_NOCTAVES = 2; int SURF_NOCTAVELAYERS = 2; int MATCH_THRESHOLD = 20; CvSURFParams params = cvSURFParams(SURF_HESSIAN_THRESHOLD, SURF_EXTENDED); params.nOctaves=SURF_NOCTAVES; params.nOctaveLayers=SURF_NOCTAVELAYERS; CvMemStorage* storage = cvCreateMemStorage(0); IplImage* image = cvLoadImage(filename, CV_LOAD_IMAGE_GRAYSCALE ); CvSeq *objectKeypoints = 0, *objectDescriptors = 0; // set up the keypoint int useProvidedKeyPoints = 1; CvMemStorage* kp_storage = cvCreateMemStorage(0); CvSeq* surf_kp = cvCreateSeq(0, sizeof(CvSeq), sizeof(CvSURFPoint), kp_storage); int laplacian = 1; int direction = 0; int hessian = SURF_HESSIAN_THRESHOLD+1; CvSURFPoint point = cvSURFPoint(cvPoint2D32f(x, y), laplacian, size, direction, hessian); cvSeqPush(surf_kp, &point); // extract descriptor cvExtractSURF(image, 0, &surf_kp, &objectDescriptors, storage, params, useProvidedKeyPoints); // print to stdout /* // if keypoint info also wanted CvSeqReader kp_reader; cvStartReadSeq(surf_kp, &kp_reader); const CvSURFPoint* kp = (const CvSURFPoint*)kp_reader.ptr; printf("%.2f %.2f %.2f %d %d",kp->pt.x,kp->pt.y,kp->hessian,kp->laplacian,kp->size); */ const float* des = (const float*)cvGetSeqElem(objectDescriptors, 0); for (int i=0;i<64;i++){ printf("%.5f ",des[i]); } cvReleaseImage( &image ); }
void SurfFD::extractKeypoints(cv::Mat* m) { //memcpy( output_image_, input_image_, sizeof(input_image_) );//Replace by opencv copying //CvSURFParams params = cvSURFParams(500, 1); //CvMemStorage* storage = cvCreateMemStorage(0); //(*outputEK).extractKeypoints(); CvSURFParams params = cvSURFParams(500, 0); CvMemStorage* storage = cvCreateMemStorage(0); IplImage _img(*m); cvExtractSURF(&_img, 0, &keypoints_, &descriptors_, storage, params); }
void rspfOpenCVSURFFeatures::runUcharTransformation(rspfImageData* tile) { IplImage *input; IplImage *output; IplImage *temp; char* bSrc; char* bDst; //int nChannels = tile->getNumberOfBands(); //for(int k=0; k<nChannels; k++) { input = cvCreateImageHeader(cvSize(tile->getWidth(),tile->getHeight()),8,1); output = cvCreateImageHeader(cvSize(tile->getWidth(),tile->getHeight()),8,1); temp = cvCreateImage(cvGetSize(input),32,1); CvMemStorage* storage = cvCreateMemStorage(0); bSrc = static_cast<char*>(tile->getBuf(0)); input->imageData=bSrc; bDst = static_cast<char*>(theTile->getBuf()); output->imageData=bDst; CvSeq *imageKeypoints = NULL; cvCopy(input,output); CvSURFParams params = cvSURFParams(theHessianThreshold, 1); cvExtractSURF(input,NULL,&imageKeypoints,NULL,storage,params); int numKeyPoints = imageKeypoints->total; for (int i=0;i<numKeyPoints;i++){ CvSURFPoint* corner = (CvSURFPoint*)cvGetSeqElem(imageKeypoints,i); theKeyPoints.push_back(rspfDpt(corner->pt.x,corner->pt.y)+tile->getOrigin()); cvCircle(output,cvPointFrom32f(corner->pt),1,cvScalar(0),1); } cvReleaseImageHeader(&input); cvReleaseImageHeader(&output); cvReleaseImage(&temp); //} theTile->validate(); }
void ControlWidget::SURFImage() { if(this->m_storage_SURF == NULL) { this->surf_image = cvCreateImage(cvGetSize(this->imagerd), IPL_DEPTH_8U, 1); this->m_storage_SURF = cvCreateMemStorage(0); } else { this->surf_image = cvCreateImage(cvGetSize(this->imagerd), IPL_DEPTH_8U, 1); cvClearMemStorage(this->m_storage_SURF); } CvSURFParams params; params = cvSURFParams(this->surf_Hessian, 1); cvExtractSURF(this->gray_image, 0, &image_Keypoints, &image_Descriptors, this->m_storage_SURF, params, 0); this->surf_image = cvCloneImage(this->imagerd); for(int i = 0; i < image_Keypoints->total; ++i) { CvSURFPoint* point = (CvSURFPoint*)cvGetSeqElem(image_Keypoints, i); CvPoint center; int radius; center.x = cvRound(point->pt.x); center.y = cvRound(point->pt.y); // radius = cvRound(point->size * 1.2 / 9.0 * 2.0); // cvCircle(this->surf_image, center, radius, cvScalar(0, 0, 255), 1, 8, 0); cvCircle(this->surf_image, center, 2, cvScalar(0, 0, 255), -1, 0, 0); } QImage SURF_Image = QImage((const unsigned char*)(this->surf_image->imageData), this->surf_image->width, this->surf_image->height, QImage::Format_RGB888).rgbSwapped(); this->bufferSurfImage = new QPixmap(); *bufferSurfImage = QPixmap::fromImage(SURF_Image); *bufferSurfImage = bufferSurfImage->scaled(250, 200); cvZero(this->surf_image); }
vector<VisionRecognitionResult> KitechSurfObjectRecognitionComp::Recognize(vector<unsigned char> image,int width,int height,int pixelBytes) { vector<VisionRecognitionResult> _recognitionResult(0); IplImage *cvImage = cvCreateImageHeader( cvSize(width, height), 8, pixelBytes ); cvImage->imageData = (char *)&image[0]; IplImage *grayImage = cvCreateImage( cvGetSize(cvImage), 8, 1 ); cvCvtColor( cvImage, grayImage, CV_BGR2GRAY ); CvMemStorage *imageStorage = cvCreateMemStorage(0); CvSeq *imageKeypoints, *imageDescriptors; cvExtractSURF( grayImage, 0, &imageKeypoints, &imageDescriptors, imageStorage, cvSURFParams(500,1) ); CvPoint src_corners[4] = {{0,0}, {_orgWidth,0}, {_orgWidth, _orgHeight}, {0, _orgHeight}}; CvPoint dst_corners[4]; if( LocatePlanarObject( _objectKeypoints, _objectDescriptors, imageKeypoints, imageDescriptors, src_corners, dst_corners ) ) { _recognitionResult.resize(1); _recognitionResult[0].name = _objName; _recognitionResult[0].point1X = dst_corners[0].x; _recognitionResult[0].point1Y = dst_corners[0].y; _recognitionResult[0].point2X = dst_corners[1].x; _recognitionResult[0].point2Y = dst_corners[1].y; _recognitionResult[0].point3X = dst_corners[2].x; _recognitionResult[0].point3Y = dst_corners[2].y; _recognitionResult[0].point4X = dst_corners[3].x; _recognitionResult[0].point4Y = dst_corners[3].y; //PrintMessage("KitechSurfObjectRecognitionComp::recognize() -> I found data.(%s)\n", _recognitionResult[0].name.c_str()); } cvReleaseMemStorage( &imageStorage ); cvReleaseImage( &grayImage ); cvReleaseImageHeader( &cvImage ); return _recognitionResult; }
JNIEXPORT void JNICALL Java_com_userinterface_OpenCV_extractSURFFeature( JNIEnv* env, jobject thiz) { IplImage *pWorkImage=cvCreateImage(cvGetSize(pImage),IPL_DEPTH_8U,1); cvCvtColor(pImage,pWorkImage,CV_BGR2GRAY); CvMemStorage* storage = cvCreateMemStorage(0); CvSeq *imageKeypoints = 0, *imageDescriptors = 0; CvSURFParams params = cvSURFParams(2000, 0); cvExtractSURF( pWorkImage, 0, &imageKeypoints, &imageDescriptors, storage, params ); // show features for( int i = 0; i < imageKeypoints->total; i++ ) { CvSURFPoint* r = (CvSURFPoint*)cvGetSeqElem( imageKeypoints, 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( pImage, center, radius, CV_RGB(255,0,0), 1, CV_AA, 0 ); } cvReleaseImage(&pWorkImage); cvReleaseMemStorage(&storage); }
/*! Build the list of reference points. The computation of the points is made all over the image I. \param I : The gray scaled image where the reference points are computed. \return the number of reference points. */ unsigned int vpKeyPointSurf::buildReference(const vpImage<unsigned char> &I) { IplImage* model = NULL; if((I.getWidth() % 8) == 0){ int height = (int)I.getHeight(); int width = (int)I.getWidth(); CvSize size = cvSize(width, height); model = cvCreateImageHeader(size, IPL_DEPTH_8U, 1); model->imageData = (char*)I.bitmap; }else{ vpImageConvert::convert(I,model); } cvExtractSURF( model, 0, &ref_keypoints, &ref_descriptors, storage, params ); const unsigned int nbPoints = (unsigned int)ref_keypoints->total; referenceImagePointsList.resize(nbPoints); for(unsigned int i = 0; i < nbPoints; i++ ) { CvSURFPoint* r1 = (CvSURFPoint*)cvGetSeqElem(ref_keypoints, (int)i); referenceImagePointsList[i].set_i(r1->pt.y); referenceImagePointsList[i].set_j(r1->pt.x); } if((I.getWidth() % 8) == 0){ model->imageData = NULL; cvReleaseImageHeader(&model); }else{ cvReleaseImage(&model); } _reference_computed = true; return nbPoints; }
void ControlWidget::MatchingImage() { if(this->m_storage_Matching == NULL) { this->matching_image = cvCreateImage(cvGetSize(this->list_imagerd), IPL_DEPTH_8U, 1); this->m_storage_Matching = cvCreateMemStorage(0); } else { this->matching_image = cvCreateImage(cvGetSize(this->list_imagerd), IPL_DEPTH_8U, 1); cvClearMemStorage(this->m_storage_Matching); } for(int i = 0; i < 12; ++i) { this->True_Point[i] = 0; } CvSeq* keypoints2; CvSeq* descriptors2; CvSURFParams params; params = cvSURFParams(this->surf_Hessian, 1); cvExtractSURF(this->gray_list_image, 0, &keypoints2, &descriptors2, this->m_storage_Matching, params); cv::Vector<int> ptpairs; this->findPairs(this->image_Keypoints, this->image_Descriptors, keypoints2, descriptors2, ptpairs); this->matching_image = cvCloneImage(this->list_imagerd); for(int i = 0; i < (int)ptpairs.size(); i += 2) { CvSURFPoint* pt1 = (CvSURFPoint*)cvGetSeqElem(this->image_Keypoints, ptpairs[i]); CvSURFPoint* pt2 = (CvSURFPoint*)cvGetSeqElem(keypoints2, ptpairs[i + 1]); CvPoint center; int radius; center.x = cvRound(pt2->pt.x); center.y = cvRound(pt2->pt.y); // radius = cvRound(pt2->size * 1.2 / 9.0 * 2.0); // cvCircle(this->matching_image, center, radius, cvScalar(0, 0, 255), 1, 8, 0); cvCircle(this->matching_image, center, 2, cvScalar(0, 0, 255), -1, 0, 0); this->JudgePairs(center.x, center.y); } QImage Matching_Image = QImage((const unsigned char*)(this->matching_image->imageData), this->matching_image->width, this->matching_image->height, QImage::Format_RGB888).rgbSwapped(); this->bufferMatchingImage = new QPixmap(); *bufferMatchingImage = QPixmap::fromImage(Matching_Image); *bufferMatchingImage = bufferMatchingImage->scaled(800, 300); cvZero(this->matching_image); cvClearSeq(keypoints2); cvClearSeq(descriptors2); }
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; }
cv::Mat CBIR::getClustersIndices(QString path){ QString imgName = path.section('/', -1); IplImage* img = Utils::loadImage(path.toAscii().data(), true); if(img == NULL){ qDebug() << "La imagen no fue cargada."; exit(1); } //Computo los features. CvSeq *imgKeypoints, *imgDescriptors; CvSURFParams params = cvSURFParams(500, 1); imgKeypoints = 0; imgDescriptors = 0; CvMemStorage* storage = cvCreateMemStorage(0); cvExtractSURF(img, 0, &imgKeypoints, &imgDescriptors, storage, params); qDebug() << "Imagen" << path << "cargada con exito. Features:" << imgKeypoints->total; //Copio los descriptores a una Mat. cv::Mat queryDescriptorsMat(imgDescriptors->total, DESCRIPTOR_DIMS, CV_32F); float* img_ptr = queryDescriptorsMat.ptr<float>(0); CvSeqReader img_reader; cvStartReadSeq(imgDescriptors, &img_reader); for(int j=0; j<imgDescriptors->total; j++){ const float* descriptor = (const float*)img_reader.ptr; CV_NEXT_SEQ_ELEM(img_reader.seq->elem_size, img_reader); memcpy(img_ptr, descriptor, DESCRIPTOR_DIMS*sizeof(float)); img_ptr += DESCRIPTOR_DIMS; } cvReleaseMemStorage(&storage); cvReleaseImage(&img); if(clustersMat.data == NULL) exit(1); //Creo el índice para los cluster centers. cv::flann::KDTreeIndexParams kdtiParams = cv::flann::KDTreeIndexParams(8); cv::flann::Index clustersIndex(clustersMat, kdtiParams); //Clusterizo cada feature de la query según Knn-Search. cv::Mat indices(queryDescriptorsMat.rows, 1, CV_32S); cv::Mat dists(queryDescriptorsMat.rows, 1, CV_32F); clustersIndex.knnSearch(queryDescriptorsMat, indices, dists, 1, cv::flann::SearchParams(1024)); /***************************************************************************************************************/ //Guardo el archivo para realizar la query al índice. QFile query("cbir/lemur/query/" + imgName + ".query"); QTextStream stream(&query); if (!query.open(QIODevice::WriteOnly | QIODevice::Text)) qDebug() << "Ocurrio un error al intentar abrir el archivo" + imgName + ".query"; stream << "<DOC 1>" << endl; // Itero sobre todos los features de la imagen. for(int i=0; i<queryDescriptorsMat.rows ;i++){ stream << indices.at<int>(i, 0) << endl; } stream << "</DOC>"; query.close(); //Guardo el archivo con los parámetros de la query. QFile qP("cbir/lemur/query/query_params"); QTextStream qPStream(&qP); if (!qP.open(QIODevice::WriteOnly | QIODevice::Text)) qDebug() << "Ocurrio un error al intentar abrir el archivo query_params"; qPStream << "<parameters>" << endl << "<index>e:\\Proyectos\\Git\\keepc\\release\\cbir\\lemur\\index\\index.key</index>" << endl << "<retModel>tfidf</retModel>" << endl << "<textQuery>e:\\Proyectos\\Git\\keepc\\release\\cbir\\lemur\\query\\" << imgName << ".query</textQuery>" << endl << "<resultFile>e:\\Proyectos\\Git\\keepc\\release\\cbir\\lemur\\query\\" << imgName << ".results</resultFile>" << endl << "<TRECResultFormat>1</TRECResultFormat>" << endl << "<resultCount>10</resultCount>" << endl << "</parameters>"; qP.close(); return indices; }
static void computeVectors( IplImage* img, IplImage* dst, short wROI, short hROI){ if(DEBUG){ std::cout << "-- VECTOR COMPUTING" << std::endl; } double timestamp = (double)clock()/CLOCKS_PER_SEC; // get current time in seconds CvSize size = cvSize(img->width,img->height); // get current frame size 640x480 int i, idx1 = last, idx2; CvSeq* seq; CvRect comp_rect; CvRect roi; double count; double angle; CvPoint center; double magnitude; CvScalar color; //--SURF CORNERS-- if(DEBUG){ std::cout << "--- SURF CORNERS" << std::endl; } color = CV_RGB(0,255,0); CvMemStorage* storage2 = cvCreateMemStorage(0); CvSURFParams params = cvSURFParams(SURF_THRESHOLD, 1); CvSeq *imageKeypoints = 0, *imageDescriptors = 0; cvExtractSURF( dst, 0, &imageKeypoints, &imageDescriptors, storage2, params ); if(DEBUG){ printf("Image Descriptors: %d\n", imageDescriptors->total); } for( int j = 0; j < imageKeypoints->total; j++ ){ CvSURFPoint* r = (CvSURFPoint*)cvGetSeqElem( imageKeypoints, j ); center.x = cvRound(r->pt.x); center.y = cvRound(r->pt.y); if(DEBUG){ printf("j: %d \t", j); printf("total: %d \t", imageKeypoints->total); printf("valor hessiano: %f \t", r->hessian); printf("x: %d \t", center.x); printf("y: %d \n", center.y); } // Agrego el Punto en donde es la region que nos interesa cvCircle( dst, center, cvRound(r->hessian*0.02), color, 3, CV_AA, 0 ); // Lleno la matriz con los vectores relevancePointToVector(center.x, center.y, wROI, hROI, 5); } //--SURF CORNERS // calculate motion gradient orientation and valid orientation mask cvCalcMotionGradient( mhi, mask, orient, MAX_TIME_DELTA, MIN_TIME_DELTA, 3 ); // Compute Motion on 4x4 Cuadrants if(DEBUG){ std::cout << "--- MOTION CUADRANTS" << std::endl; } i = 25; color = CV_RGB(255,0,0); magnitude = 30; for (int r = 0; r < size.height; r += hROI){ for (int c = 0; c < size.width; c += wROI){ comp_rect.x = c; comp_rect.y = r; comp_rect.width = (c + wROI > size.width) ? (size.width - c) : wROI; comp_rect.height = (r + hROI > size.height) ? (size.height - r) : hROI; cvSetImageROI( mhi, comp_rect ); cvSetImageROI( orient, comp_rect ); cvSetImageROI( mask, comp_rect ); cvSetImageROI( silh, comp_rect ); cvSetImageROI( img, comp_rect ); // Process Motion angle = cvCalcGlobalOrientation( orient, mask, mhi, timestamp, MHI_DURATION); angle = 360.0 - angle; // adjust for images with top-left origin count = cvNorm( silh, 0, CV_L1, 0 ); // calculate number of points within silhouette ROI roi = cvGetImageROI(mhi); center = cvPoint( (comp_rect.x + comp_rect.width/2), (comp_rect.y + comp_rect.height/2) ); cvCircle( dst, center, cvRound(magnitude*1.2), color, 3, CV_AA, 0 ); cvLine( dst, center, cvPoint( cvRound( center.x + magnitude*cos(angle*CV_PI/180)), cvRound( center.y - magnitude*sin(angle*CV_PI/180))), color, 3, CV_AA, 0 ); if(DEBUG){ std::cout << "Motion " << i << " -> x: " << roi.x << " y: " << roi.y << " count: " << count << " angle: " << angle << std::endl; // print the roi } cvResetImageROI( mhi ); cvResetImageROI( orient ); cvResetImageROI( mask ); cvResetImageROI( silh ); cvResetImageROI(img); relevanceDirectionToVector(i, angle); ++i; } } // Compute Global Motion if(DEBUG){ std::cout << "--- MOTION GLOBAL" << std::endl; } comp_rect = cvRect( 0, 0, size.width, size.height ); color = CV_RGB(255,255,255); magnitude = 100; angle = cvCalcGlobalOrientation( orient, mask, mhi, timestamp, MHI_DURATION); angle = 360.0 - angle; // adjust for images with top-left origin count = cvNorm( silh, 0, CV_L1, 0 ); // calculate number of points within silhouette ROI roi = cvGetImageROI(mhi); center = cvPoint( (comp_rect.x + comp_rect.width/2), (comp_rect.y + comp_rect.height/2) ); cvCircle( dst, center, cvRound(magnitude*1.2), color, 3, CV_AA, 0 ); cvLine( dst, center, cvPoint( cvRound( center.x + magnitude*cos(angle*CV_PI/180)), cvRound( center.y - magnitude*sin(angle*CV_PI/180))), color, 3, CV_AA, 0 ); if(DEBUG){ std::cout << "Motion Main-> x: " << roi.x << " y: " << roi.y << " count: " << count << std::endl; // print the roi } relevanceDirectionToVector(50, angle); }
/*! Computes the SURF points in the current image I and try to matched them with the points in the reference list. Only the matched points are stored. \param I : The gray scaled image where the points are computed. \return the number of point which have been matched. */ unsigned int vpKeyPointSurf::matchPoint(const vpImage<unsigned char> &I) { IplImage* currentImage = NULL; if((I.getWidth() % 8) == 0){ int height = (int)I.getHeight(); int width = (int)I.getWidth(); CvSize size = cvSize(width, height); currentImage = cvCreateImageHeader(size, IPL_DEPTH_8U, 1); currentImage->imageData = (char*)I.bitmap; }else{ vpImageConvert::convert(I,currentImage); } /* we release the memory storage for the current points (it has to be kept allocated for the get descriptor points, ...) */ if(storage_cur != NULL){ cvReleaseMemStorage(&storage_cur); storage_cur = NULL; } storage_cur = cvCreateMemStorage(0); cvExtractSURF( currentImage, 0, &image_keypoints, &image_descriptors, storage_cur, params ); CvSeqReader reader, kreader; cvStartReadSeq( ref_keypoints, &kreader ); cvStartReadSeq( ref_descriptors, &reader ); std::list<int> indexImagePair; std::list<int> indexReferencePair; unsigned int nbrPair = 0; for(int i = 0; i < ref_descriptors->total; i++ ) { const CvSURFPoint* kp = (const CvSURFPoint*)kreader.ptr; const float* descriptor = (const float*)reader.ptr; CV_NEXT_SEQ_ELEM( kreader.seq->elem_size, kreader ); CV_NEXT_SEQ_ELEM( reader.seq->elem_size, reader ); int nearest_neighbor = naiveNearestNeighbor( descriptor, kp->laplacian, image_keypoints, image_descriptors ); if( nearest_neighbor >= 0 ) { indexReferencePair.push_back(i); indexImagePair.push_back(nearest_neighbor); nbrPair++; } } std::list<int>::const_iterator indexImagePairIter = indexImagePair.begin(); std::list<int>::const_iterator indexReferencePairIter = indexReferencePair.begin(); matchedReferencePoints.resize(0); if (nbrPair == 0) return (0); currentImagePointsList.resize(nbrPair); matchedReferencePoints.resize(nbrPair); for (unsigned int i = 0; i < nbrPair; i++) { int index = *indexImagePairIter; CvSURFPoint* r1 = (CvSURFPoint*)cvGetSeqElem(image_keypoints, index); currentImagePointsList[i].set_i(r1->pt.y); currentImagePointsList[i].set_j(r1->pt.x); matchedReferencePoints[i] = (unsigned int)*indexReferencePairIter; ++indexImagePairIter; ++indexReferencePairIter; } if((I.getWidth() % 8) == 0){ currentImage->imageData = NULL; cvReleaseImageHeader(¤tImage); }else{ cvReleaseImage(¤tImage); } return nbrPair; }
void CBIR::buildDescriptorsMatrix(QString path){ QString rootG = "../img/keepcon2-g/"; //QString root = "../img/keepcon2/"; QString root = path; QStringList images; QStringList fileDirs; //Carga todas las imágenes. QDir dir(root); dir.setFilter(QDir::Files | QDir::NoDotAndDotDot); dir.setSorting(QDir::Name); images << dir.entryList(); //Carga las imágenes de los grupos indicados. /* fileDirs << "auto" << "converse" << "doki"; for(int i=0; i<fileDirs.count(); i++){ QDir dir(rootG + fileDirs[i] + "/"); dir.setFilter(QDir::Files | QDir::NoDotAndDotDot); dir.setSorting(QDir::Name | QDir::Reversed); images << dir.entryList(); } */ //Carga de imágenes específicas. //images << "auto.jpg" << "auto-f.jpg" << "converse.jpg"; cout << "Cantidad de imagenes: " << images.count() << endl; //int length = (int)(imgDescriptors->elem_size/sizeof(float)); //descriptorsMat = cv::Mat(1106, DESCRIPTOR_DIMS, CV_32F); //float* img_ptr = descriptorsMat.ptr<float>(0); //CvSeqReader img_reader; CvSeq* totalDescriptors = 0; CvSeq* nextSeq = 0; IplImage* img; CvSeq *imgKeypoints, *imgDescriptors; CvSURFParams params = cvSURFParams(500, 1); //Calcula features para cada imagen for(int i=0; i<images.count(); i++){ img = NULL; imgKeypoints = 0; imgDescriptors = 0; qDebug() << "Intento de carga de la imagen" << images[i] << "."; img = Utils::loadImage((root + images[i]).toAscii().data(), true); if(img != NULL){ CvMemStorage* storage = cvCreateMemStorage(0); cvExtractSURF(img, 0, &imgKeypoints, &imgDescriptors, storage, params); qDebug() << "Imagen" << images[i] << "cargada con exito. Features:" << imgKeypoints->total; featuresCount.append(QPair<QString, int>(images[i], imgDescriptors->total)); //Linkeo la nueva secuencia de descriptores a la lista. if(totalDescriptors == 0){ totalDescriptors = imgDescriptors; nextSeq = totalDescriptors; }else{ nextSeq->h_next = imgDescriptors; nextSeq = nextSeq->h_next; } //Copiar los descriptores a la matriz de features /* cvStartReadSeq(imgDescriptors, &img_reader); for(int j=0; j<imgDescriptors->total; j++){ // j<1 para cargar un solo descriptor por cada imagen (prueba). const float* descriptor = (const float*)img_reader.ptr; CV_NEXT_SEQ_ELEM(img_reader.seq->elem_size, img_reader); memcpy(img_ptr, descriptor, DESCRIPTOR_DIMS*sizeof(float)); img_ptr += DESCRIPTOR_DIMS; } */ //cvReleaseMemStorage(&storage); cvReleaseImage(&img); } } int descriptorsCount = 0; int sequencesCount = 0; CvSeq* iterateSeq = totalDescriptors; while(iterateSeq != nextSeq){ descriptorsCount += iterateSeq->total; iterateSeq = iterateSeq->h_next; sequencesCount++; } if(iterateSeq != 0){ descriptorsCount += iterateSeq->total; sequencesCount++; } qDebug() << "Total de secuencias:" << sequencesCount; qDebug() << "Total de descriptores:" << descriptorsCount; //Creo la matriz de descriptores ahora que se conoce la cantidad. descriptorsMat = cv::Mat(descriptorsCount, DESCRIPTOR_DIMS, CV_32F); float* img_ptr = descriptorsMat.ptr<float>(0); CvSeqReader img_reader; //Copia los descriptores de la lista de secuencias a la matriz. iterateSeq = totalDescriptors; CvSeq* deallocateSeq = 0; for(int i=0; i<sequencesCount; i++){ deallocateSeq = iterateSeq; cvStartReadSeq(iterateSeq, &img_reader); int j; for(j=0; j<iterateSeq->total; j++){ const float* descriptor = (const float*)img_reader.ptr; CV_NEXT_SEQ_ELEM(img_reader.seq->elem_size, img_reader); memcpy(img_ptr, descriptor, DESCRIPTOR_DIMS*sizeof(float)); img_ptr += DESCRIPTOR_DIMS; } iterateSeq = iterateSeq->h_next; //Probar que efectivamente se libera la memoria. cvReleaseMemStorage(&deallocateSeq->storage); } }
bool Features::featuresBasedTransform(IplImage* object, IplImage* image, IplImage* img1, IplImage* img2, QTransform &transform) { CvMemStorage* storage = cvCreateMemStorage(0); //Búsqueda de features para ambas imágenes. CvSeq *objectKeypoints = 0, *objectDescriptors = 0; CvSeq *imageKeypoints = 0, *imageDescriptors = 0; CvSURFParams params = cvSURFParams(500, 1); double tt = (double)cvGetTickCount(); cvExtractSURF( object, 0, &objectKeypoints, &objectDescriptors, storage, params ); cvExtractSURF( image, 0, &imageKeypoints, &imageDescriptors, storage, params ); tt = (double)cvGetTickCount() - tt; if(VERBOSE){ qDebug() << "Features hallados en la imagen 1:" << objectDescriptors->total; qDebug() << "Features hallados en la imagen 2:" << imageDescriptors->total; qDebug() << "Tiempo de extraccion:" << tt/(cvGetTickFrequency()*1000.) << "ms." << endl; } //En caso de ser insuficiente la cantidad de features para alguna de las imágenes, se retorna sin resultado. if(objectKeypoints->total < MINPAIRS || imageKeypoints->total < MINPAIRS){ if(VERBOSE) qDebug() << "La cantidad de features encontrados es insuficiente para calcular una transformacion." << endl; cvReleaseMemStorage(&storage); return false; } //Busqueda de correspondencia entre puntos característicos (features). vector<int> ptpairs; #ifdef USE_FLANN Features::flannFindPairs( objectKeypoints, objectDescriptors, imageKeypoints, imageDescriptors, ptpairs ); #else Features::findPairs( objectKeypoints, objectDescriptors, imageKeypoints, imageDescriptors, ptpairs ); #endif //Utils::printPairsInfo(objectKeypoints, imageKeypoints, ptpairs); /**************************************************************************************************************/ Features::filterByDirection(objectKeypoints, imageKeypoints, ptpairs); /**************************************************************************************************************/ //En caso de ser insuficiente la cantidad de puntos de correspondencia, se retorna sin resultado. if(VERBOSE) qDebug() << "Cantidad de puntos de correspondencia:" << (int)(ptpairs.size()/2) << endl; if(ptpairs.size()/2 < MINPAIRS){ if(VERBOSE) qDebug() << "La cantidad de puntos de correspondencia entre las imagenes es insuficiente para calcular una transformacion." << endl; cvReleaseMemStorage(&storage); return false; } //Búsqueda de los triángulos que determinarán la transformación a realizar. vector<int> objTri, imgTri, objSize; objTri.reserve(3); imgTri.reserve(3); objSize.push_back(object->width); objSize.push_back(object->height); bool goodTriangle = Features::findGoodTriangles(objectKeypoints, imageKeypoints, ptpairs, objSize, objTri, imgTri); //En caso de no hallarse los triángulos de manera satisfactoria, se retorna sin resultado. if(!goodTriangle){ if(VERBOSE) qDebug() << "Los triangulos de correspondencia hallados no permiten realizar una transformacion correcta." << endl; cvReleaseMemStorage(&storage); return false; } //Se procede a calcular la transformación. transform = getTransformation(objectKeypoints, imageKeypoints, objTri, imgTri); //EIGENVALUES************************************************************************************************************** //Features::checkEigenvalues(QTransform(0.0, 1.5, -1.0, 1.5, 1.0, 0.0, -1.0, 0.0, 1.0)); if(!Features::checkEigenvalues(transform)){ if(VERBOSE) qDebug() << "Los triangulos de correspondencia hallados no permiten realizar una transformacion correcta." << endl; cvReleaseMemStorage(&storage); return false; } if(GRAPHIC){ IplImage* result = Utils::drawResultImage(img1, img2, objectKeypoints, imageKeypoints, objTri, imgTri, ptpairs); cvNamedWindow("Imagen de correspondencia", 1); cvMoveWindow("Imagen de correspondencia", 100, 100); cvShowImage("Imagen de correspondencia", result); cvWaitKey(0); cvDestroyAllWindows(); cvReleaseImage(&result); } cvReleaseMemStorage(&storage); return true; }
void Features::getFeatures(IplImage* img, CvSeq* &keypoints, CvSeq* &descriptors){ keypoints=0; descriptors=0; CvMemStorage* storage = cvCreateMemStorage(0); CvSURFParams params = cvSURFParams(500, 1); cvExtractSURF(img, 0, &keypoints, &descriptors, storage, params); }
// 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 FindObjectMain::process_surf() { if(!object_image) { // Only does greyscale object_image = cvCreateImage( cvSize(object_image_w, object_image_h), 8, 1); } if(!scene_image) { // Only does greyscale scene_image = cvCreateImage( cvSize(scene_image_w, scene_image_h), 8, 1); } // Select only region with image size // Does this do anything? cvSetImageROI( object_image, cvRect( 0, 0, object_w, object_h ) ); cvSetImageROI( scene_image, cvRect( 0, 0, scene_w, scene_h ) ); if(!prev_object) prev_object = new unsigned char[object_image_w * object_image_h]; memcpy(prev_object, object_image->imageData, object_image_w * object_image_h); grey_crop((unsigned char*)scene_image->imageData, get_input(scene_layer), scene_x1, scene_y1, scene_x2, scene_y2, scene_image_w, scene_image_h); grey_crop((unsigned char*)object_image->imageData, get_input(object_layer), object_x1, object_y1, object_x2, object_y2, object_image_w, object_image_h); if(!storage) storage = cvCreateMemStorage(0); CvSURFParams params = cvSURFParams(500, 1); //printf("FindObjectMain::process_surf %d\n", __LINE__); // Only compute keypoints if the image changed if(memcmp(prev_object, object_image->imageData, object_image_w * object_image_h)) { if(object_keypoints) cvClearSeq(object_keypoints); if(object_descriptors) cvClearSeq(object_descriptors); cvExtractSURF(object_image, 0, &object_keypoints, &object_descriptors, storage, params, 0); } //printf("FindObjectMain::process_surf %d object keypoints=%d\n", __LINE__, object_keypoints->total); // Draw the keypoints // for(int i = 0; i < object_keypoints->total; i++) // { // CvSURFPoint* r1 = (CvSURFPoint*)cvGetSeqElem( object_keypoints, i ); // int size = r1->size / 4; // draw_rect(frame[object_layer], // r1->pt.x + object_x1 - size, // r1->pt.y + object_y1 - size, // r1->pt.x + object_x1 + size, // r1->pt.y + object_y1 + size); // } //printf("FindObjectMain::process_surf %d\n", __LINE__); // TODO: make the surf data persistent & check for image changes instead if(scene_keypoints) cvClearSeq(scene_keypoints); if(scene_descriptors) cvClearSeq(scene_descriptors); cvExtractSURF(scene_image, 0, &scene_keypoints, &scene_descriptors, storage, params, 0); // Draw the keypoints // for(int i = 0; i < scene_keypoints->total; i++) // { // CvSURFPoint* r1 = (CvSURFPoint*)cvGetSeqElem( scene_keypoints, i ); // int size = r1->size / 4; // draw_rect(frame[scene_layer], // r1->pt.x + scene_x1 - size, // r1->pt.y + scene_y1 - size, // r1->pt.x + scene_x1 + size, // r1->pt.y + scene_y1 + size); // } // printf("FindObjectMain::process_surf %d %d %d scene keypoints=%d\n", // __LINE__, // scene_w, // scene_h, // scene_keypoints->total); int *point_pairs = 0; int total_pairs = 0; CvPoint src_corners[4] = { { 0, 0 }, { object_w, 0 }, { object_w, object_h }, { 0, object_h } }; CvPoint dst_corners[4] = { { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 } }; //printf("FindObjectMain::process_surf %d\n", __LINE__); if(scene_keypoints->total && object_keypoints->total && locatePlanarObject(object_keypoints, object_descriptors, scene_keypoints, scene_descriptors, src_corners, dst_corners, &point_pairs, &total_pairs)) { // Draw keypoints in the scene & object layer if(config.draw_keypoints) { //printf("FindObjectMain::process_surf %d total pairs=%d\n", __LINE__, total_pairs); for(int i = 0; i < total_pairs; i++) { CvSURFPoint* r1 = (CvSURFPoint*)cvGetSeqElem( object_keypoints, point_pairs[i * 2] ); CvSURFPoint* r2 = (CvSURFPoint*)cvGetSeqElem( scene_keypoints, point_pairs[i * 2 + 1] ); int size = r2->size * 1.2 / 9 * 2; draw_rect(get_input(scene_layer), r2->pt.x + scene_x1 - size, r2->pt.y + scene_y1 - size, r2->pt.x + scene_x1 + size, r2->pt.y + scene_y1 + size); draw_rect(get_input(object_layer), r1->pt.x + object_x1 - size, r1->pt.y + object_y1 - size, r1->pt.x + object_x1 + size, r1->pt.y + object_y1 + size); } } //printf("FindObjectMain::process_surf %d\n", __LINE__); // Get object outline in the scene layer border_x1 = dst_corners[0].x + scene_x1; border_y1 = dst_corners[0].y + scene_y1; border_x2 = dst_corners[1].x + scene_x1; border_y2 = dst_corners[1].y + scene_y1; border_x3 = dst_corners[2].x + scene_x1; border_y3 = dst_corners[2].y + scene_y1; border_x4 = dst_corners[3].x + scene_x1; border_y4 = dst_corners[3].y + scene_y1; //printf("FindObjectMain::process_surf %d\n", __LINE__); } //printf("FindObjectMain::process_surf %d\n", __LINE__); // for(int i = 0; i < object_y2 - object_y1; i++) // { // unsigned char *dst = get_input(object_layer)->get_rows()[i]; // unsigned char *src = (unsigned char*)object_image->imageData + i * (object_x2 - object_x1); // for(int j = 0; j < object_x2 - object_x1; j++) // { // *dst++ = *src; // *dst++ = 0x80; // *dst++ = 0x80; // src++; // } // } // Frees the image structures if(point_pairs) free(point_pairs); }
bool Classifier::extract(TTrainingFileList& fileList) { cout << "Classes:" << endl; for (int i = 0; i < (int)fileList.classes.size(); i++) { cout << fileList.classes[i] << " ("; int count = 0; for (int j = 0; j < (int)fileList.files.size(); j++) { if (fileList.files[j].label == fileList.classes[i]) { count += 1; } } cout << count << " samples)" << endl; } cout << endl; IplImage *image; int maxImages = INT_MAX; cout << "Processing images..." << endl; //vector<int> numIpoints(kNumObjectTypes); int minfiles = min(maxImages, (int)fileList.files.size()); for (int i = 0; i < minfiles; i++) { // skip too many others... if (fileList.files[i].label == "other" && --max_others < 0) continue; // show progress if (i % 10 == 0) showProgress(i, minfiles); image = cvLoadImage(fileList.files[i].filename.c_str(), 0); if (image == NULL) { cerr << "ERROR: could not load image " << fileList.files[i].filename.c_str() << endl; continue; } string label = fileList.files[i].label; CvSeq *keypoints = 0, *descriptors = 0; CvSURFParams params = cvSURFParams(100, SURF_SIZE == 128); cvExtractSURF(image, 0, &keypoints, &descriptors, storage, params); if (descriptors->total == 0) continue; vector<float> desc; desc.resize(descriptors->total * descriptors->elem_size/sizeof(float)); cvCvtSeqToArray(descriptors, &desc[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); } if (i % test_to_train == 1 || !test_on) set_train.push(stringToClassInt(label), features); else set_test.push(stringToClassInt(label), features); } cout << endl << "Extracted surf features. " << endl; cout << "Train Set" << endl; set_train.recount(); set_train.stats(); cout << "Test Set" << endl; set_train.recount(); set_test.stats(); return true; }
int main() { if(run_tests_only) { MyLine3D::runTest(); return 0; } //CvMat *camera_inner_calibration_matrix; bool show_surf_example=false; bool show_calibration_from_camera_and_undistortion=false; if(show_calibration_from_camera_and_undistortion) { CvMat *object_points_all=0; CvMat *image_points_all=0; CvMat *points_count_all=0; CvMat *camera_matr=0; CvMat *distor_coefs=0; CvMat *rotation_vecs=0; CvMat *transpose_vecs=0; vector<CvPoint2D32f> qu_calibr_points; IplImage* frameCam1; cvNamedWindow("WindowCam1",CV_WINDOW_KEEPRATIO); CvCapture *captureCam1=cvCreateCameraCapture(0); IplImage *quarterFrame; CvPoint2D32f *cornersFounded= new CvPoint2D32f[100]; int cornersCount=0; int result_Found=0; // getting snapshots for inner camera calibration from video camera bool capture_flag=false; while(true) { frameCam1=cvQueryFrame(captureCam1); quarterFrame=cvCreateImage(cvSize((frameCam1->width),(frameCam1->height)),IPL_DEPTH_8U,3); cvCopy(frameCam1,quarterFrame); if(capture_flag) { result_Found=cvFindChessboardCorners(quarterFrame,cvSize(chess_b_szW,chess_b_szH),cornersFounded,&cornersCount);//,CV_CALIB_CB_ADAPTIVE_THRESH | CV_CALIB_CB_FILTER_QUADS |CV_CALIB_CB_FAST_CHECK); cvDrawChessboardCorners(quarterFrame,cvSize(chess_b_szW,chess_b_szH),cornersFounded,cornersCount,result_Found); if(result_Found>0) AddPointsToInnerCalibrate(qu_calibr_points,cornersFounded,cornersCount); capture_flag=false; cvShowImage("WindowCam1",quarterFrame); if(result_Found>0) cvWaitKey(0); } char c=cvWaitKey(33); if(c==27) break; if(c==32 || c=='y' || c=='Y') capture_flag=true; cvShowImage("WindowCam1",quarterFrame); cvReleaseImage(&quarterFrame); } cvReleaseImage(&quarterFrame); cvReleaseCapture(&captureCam1); cvDestroyWindow("WindowCam1"); PrintAllPointsForInnerCalibrate(qu_calibr_points,chess_b_szW*chess_b_szH); InitCvMatPointsParametersForInnerCallibration_part1(qu_calibr_points,chess_b_szW*chess_b_szH,object_points_all,image_points_all,points_count_all,chess_b_szW,chess_b_szH); InitOtherCameraParametersForInnerCallibration_part2(qu_calibr_points.size()/(chess_b_szW*chess_b_szH),camera_matr,distor_coefs,rotation_vecs,transpose_vecs); double calibration_error_result=cvCalibrateCamera2(object_points_all, image_points_all, points_count_all, cvSize(imgW,imgH), camera_matr, distor_coefs, rotation_vecs, transpose_vecs, CV_CALIB_FIX_PRINCIPAL_POINT|CV_CALIB_FIX_ASPECT_RATIO|CV_CALIB_ZERO_TANGENT_DIST ); WriteMatrixCoef(camera_matr); WriteMatrixCoef(distor_coefs); //camera_inner_calibration_matrix=cvCreateMat(3,3,CV_32FC1); //cvCopy(camera_matr,camera_inner_calibration_matrix); cvSave("camera_calibration_inner.txt",camera_matr,"camera_inner_calibration_matrix"); cvSave("camera_calibration_dist.txt",distor_coefs,"distor_coefs","coeficients of distortions"); cout<<"Total Error:"<<calibration_error_result<<endl; cout<<"Average Calibration Error :"<<(calibration_error_result)/qu_calibr_points.size()<<endl; //undistortion example IplImage *frame_cur; IplImage *undistor_image; cvNamedWindow("cameraUndistor",CV_WINDOW_KEEPRATIO); CvCapture *captureCam2=cvCreateCameraCapture(0); bool undist_flag=false; while(true) { frame_cur= cvQueryFrame(captureCam2); undistor_image=cvCreateImage(cvSize((frame_cur->width),(frame_cur->height)),IPL_DEPTH_8U,3); if(undist_flag) { cvUndistort2(frame_cur,undistor_image,camera_matr,distor_coefs); } else { cvCopy(frame_cur,undistor_image); } cvShowImage("cameraUndistor",undistor_image); char c=cvWaitKey(33); if(c==27) break; if(c=='u'||c=='U') undist_flag=!undist_flag; cvReleaseImage(&undistor_image); } cvReleaseImage(&undistor_image); cvReleaseCapture(&captureCam2); cvDestroyWindow("cameraUndistor"); }//ending undistortion_example if(show_surf_example) { //using SURF initModule_nonfree();// added at 16.04.2013 CvCapture* capture_cam_3=cvCreateCameraCapture(0); cvNamedWindow("SURF from Cam",CV_WINDOW_KEEPRATIO); cvCreateTrackbar("Hessian Level","SURF from Cam",0,1000,onTrackbarSlide1); IplImage* buf_frame_3=0; IplImage* gray_copy=0; IplImage* buf_frame_3_copy=0; CvSeq *kp1,*descr1; CvMemStorage *storage=cvCreateMemStorage(0); CvSURFPoint *surf_pt; bool surf_flag=false; while(true) { buf_frame_3=cvQueryFrame(capture_cam_3); if(surf_flag) { surf_flag=false; gray_copy=cvCreateImage(cvSize((buf_frame_3->width),(buf_frame_3->height)),IPL_DEPTH_8U,1); buf_frame_3_copy=cvCreateImage(cvSize((buf_frame_3->width),(buf_frame_3->height)),IPL_DEPTH_8U,3); cvCvtColor(buf_frame_3,gray_copy,CV_RGB2GRAY); //cvSetImageROI(gray_copy,cvRect(280,200,40,40)); cvExtractSURF(gray_copy,NULL,&kp1,&descr1,storage,cvSURFParams(0.0,0)); cvReleaseImage(&gray_copy); re_draw=true; while(true) { if(re_draw) { cvCopy(buf_frame_3,buf_frame_3_copy); double pi=acos(-1.0); for(int i=0;i<kp1->total;i++) { surf_pt=(CvSURFPoint*)cvGetSeqElem(kp1,i); if(surf_pt->hessian<min_hessian) continue; int pt_x,pt_y; pt_x=(int)(surf_pt->pt.x); pt_y=(int)(surf_pt->pt.y); int sz=surf_pt->size; int rad_angle=(surf_pt->dir*pi)/180; cvCircle(buf_frame_3_copy,cvPoint(pt_x,pt_y),1/*sz*/,CV_RGB(0,255,0)); cvLine(buf_frame_3_copy,cvPoint(pt_x,pt_y),cvPoint(pt_x+sz*cosl(rad_angle),pt_y-sz*sinl(rad_angle)),CV_RGB(0,0,255)); } cvShowImage("SURF from Cam",buf_frame_3_copy); } char c=cvWaitKey(33); if(c==27) { break; } } cvReleaseImage(&buf_frame_3_copy); } cvShowImage("SURF from Cam",buf_frame_3); char ch=cvWaitKey(33); if(ch==27) break; if(ch==32) surf_flag=true; } if(gray_copy!=0) cvReleaseImage(&gray_copy); cvReleaseCapture(&capture_cam_3); cvDestroyWindow("SURF from Cam"); }//ending SURF_example CvFont my_font=cvFont(1,1); cvInitFont(&my_font,CV_FONT_HERSHEY_SIMPLEX,1.0,1.0); cvNamedWindow("twoSnapshots",CV_WINDOW_KEEPRATIO); cvCreateTrackbar("Select LLine","twoSnapshots",0,1000,onTrackbarSlideSelectLine); CvCapture *capture_4 = 0; IplImage* left_img=0; IplImage* right_img=0; IplImage* cur_frame_buf=0; IplImage* gray_img_left=0; IplImage* gray_img_right=0; IplImage* merged_images=0; IplImage* merged_images_copy=0; CvMat *fundamentalMatrix = 0; vector<KeyPoint> key_points_left; Mat descriptors_left; vector<KeyPoint> key_points_right; Mat descriptors_right; //CvMemStorage *mem_stor=cvCreateMemStorage(0);*/ float min_hessian_value=1001.0f; double startValueOfFocus = 350; char* left_image_file_path = "camera_picture_left.png"; char* right_image_file_path = "camera_picture_right.png"; Array left_points, right_points; left_points.init(1,1); right_points.init(1,1); Array forReconstructionLeftPoints, forReconstructionRightPoints; forReconstructionLeftPoints.init(1,1); forReconstructionRightPoints.init(1,1); while(true) { char ch=cvWaitKey(33); if(ch==27) break; // open left and right images if(ch == 'o' || ch == 'O') { openTwoImages(left_image_file_path, right_image_file_path, left_img, right_img ); MergeTwoImages(left_img,right_img,merged_images); } // save both left and right images from camera if(ch == 's' || ch == 'S') { if( left_img != 0 ) cvSaveImage(left_image_file_path, left_img); if( right_img != 0) cvSaveImage(right_image_file_path, right_img); } if(ch=='l'||ch=='L') { if(capture_4 == 0) { capture_4=cvCreateCameraCapture(0); } cur_frame_buf=cvQueryFrame(capture_4); if(left_img==0) left_img=cvCreateImage(cvSize(cur_frame_buf->width,cur_frame_buf->height),IPL_DEPTH_8U,3); cvCopy(cur_frame_buf,left_img); if(right_img == 0) { right_img=cvCreateImage(cvSize(cur_frame_buf->width,cur_frame_buf->height),IPL_DEPTH_8U,3); cvCopy(cur_frame_buf,right_img); } MergeTwoImages(left_img,right_img,merged_images); } if(ch=='r'||ch=='R') { if(capture_4 == 0) { capture_4=cvCreateCameraCapture(0); } cur_frame_buf=cvQueryFrame(capture_4); if(right_img==0) right_img=cvCreateImage(cvSize(cur_frame_buf->width,cur_frame_buf->height),IPL_DEPTH_8U,3); cvCopy(cur_frame_buf,right_img); if(left_img == 0) { left_img=cvCreateImage(cvSize(cur_frame_buf->width,cur_frame_buf->height),IPL_DEPTH_8U,3); cvCopy(cur_frame_buf,left_img); } MergeTwoImages(left_img,right_img,merged_images); } if(ch=='b'||ch=='B') { if(capture_4 == 0) { capture_4=cvCreateCameraCapture(0); } cur_frame_buf=cvQueryFrame(capture_4); cvCopy(cur_frame_buf,left_img); cvCopy(cur_frame_buf,right_img); } if(ch=='q'||ch=='Q' && left_img!=0) { //proceed left extractFeaturesFromImage(left_img, min_hessian_value, gray_img_left, key_points_left, descriptors_left); } if(ch=='w'||ch=='W' && right_img!=0) { //proceed right extractFeaturesFromImage(right_img, min_hessian_value, gray_img_right, key_points_right, descriptors_right); } if(ch=='m'||ch=='M' && left_img!=0 && right_img!=0) { //merge two images in to bigger one MergeTwoImages(left_img,right_img,merged_images); } if(ch=='c'||ch=='C' && merged_images!=0) { //comparison of two images if(fundamentalMatrix != 0) { cvReleaseMat(& fundamentalMatrix); fundamentalMatrix = 0; } left_to_right_corresponding_points.clear(); right_to_left_corresponding_points.clear(); GetCorrespondingPointsForSURF(key_points_left,descriptors_left,key_points_right,descriptors_right,left_to_right_corresponding_points,right_to_left_corresponding_points); } if(ch == 'E' || ch == 'e') { //drawing lines for corresponding points KeyPoint *leftPoint,*rightPoint,*leftPoint2,*rightPoint2; int width_part=merged_images->width>>1; /*for(int iL=0;iL<left_to_right_corresponding_points.size();iL++) { leftPoint=(CvSURFPoint*)cvGetSeqElem(key_points_left,left_to_right_corresponding_points[iL].first); rightPoint=(CvSURFPoint*)cvGetSeqElem(key_points_right,left_to_right_corresponding_points[iL].second); cvLine(merged_images,cvPoint(leftPoint->pt.x,leftPoint->pt.y),cvPoint(rightPoint->pt.x+width_part,rightPoint->pt.y),CV_RGB(255,0,0)); }*/ int sizeOfAccepptedLeftToRightCorrespondings = left_to_right_corresponding_points.size(); bool* acceptedLeftToRightCorrespondings = 0; getAcceptedCorrespondingsForFindingModelParameters(left_to_right_corresponding_points, key_points_left, key_points_right, fundamentalMatrix, acceptedLeftToRightCorrespondings, sizeOfAccepptedLeftToRightCorrespondings); while(true) { merged_images_copy=cvCreateImage(cvSize(merged_images->width,merged_images->height),merged_images->depth,3); cvCopy(merged_images,merged_images_copy); int iL=selectedLeftLine; int iR=iL; if(iL>=left_to_right_corresponding_points.size()) iL=left_to_right_corresponding_points.size()-1; if(iR>=right_to_left_corresponding_points.size()) iR=right_to_left_corresponding_points.size()-1; char str[100]={0}; if(iL >= 0 ) { bool isLeftToRightLineIsAccepted = acceptedLeftToRightCorrespondings[iL]; // difference value sprintf(str,"%f",left_to_right_corresponding_points[iL].comparer_value); cvPutText(merged_images_copy,str,cvPoint(0,merged_images_copy->height-40),&my_font,CV_RGB(0,255,0)); // count of Matches sprintf(str,"%d",left_to_right_corresponding_points[iL].counterOfMatches); cvPutText(merged_images_copy,str,cvPoint(200,merged_images_copy->height-40),&my_font,CV_RGB(255,255,0)); // median of compared values sprintf(str,"%lf",left_to_right_corresponding_points[iL].medianOfComparedMatches); cvPutText(merged_images_copy,str,cvPoint(250,merged_images_copy->height-40),&my_font,CV_RGB(255,0,0)); // Variance of compared values sprintf(str,"V=%lf",left_to_right_corresponding_points[iL].Variance()); cvPutText(merged_images_copy,str,cvPoint(0,merged_images_copy->height-80),&my_font,CV_RGB(0,255,0)); // Standard deviation of compared values sprintf(str,"SD=%lf",sqrt( left_to_right_corresponding_points[iL].Variance() )); cvPutText(merged_images_copy,str,cvPoint(250,merged_images_copy->height-80),&my_font,CV_RGB(0,255,0)); double SD = sqrt( left_to_right_corresponding_points[iL].Variance() ) ; double median = left_to_right_corresponding_points[iL].medianOfComparedMatches; double compValue = left_to_right_corresponding_points[iL].comparer_value; double mark_1_5 = median - 1.5 * SD - compValue; // Mark 1.5 sprintf(str,"m1.5=%lf", mark_1_5); cvPutText(merged_images_copy,str,cvPoint(0,merged_images_copy->height-120),&my_font,CV_RGB(0,255,0)); sprintf(str,"angle=%lf", left_to_right_corresponding_points[iL].degreesBetweenDeltaVector); cvPutText(merged_images_copy,str,cvPoint(0,merged_images_copy->height-150),&my_font,CV_RGB(0,255,0)); leftPoint= &(key_points_left[ left_to_right_corresponding_points[iL].comp_pair.first ]); rightPoint=&(key_points_right[ left_to_right_corresponding_points[iL].comp_pair.second ]); cvLine(merged_images_copy,cvPoint(leftPoint->pt.x,leftPoint->pt.y),cvPoint(rightPoint->pt.x+width_part,rightPoint->pt.y),CV_RGB(0,255,0)); drawEpipolarLinesOnLeftAndRightImages(merged_images_copy, cvPoint(leftPoint->pt.x,leftPoint->pt.y), cvPoint(rightPoint->pt.x,rightPoint->pt.y), fundamentalMatrix); CvScalar color = CV_RGB(255, 0, 0); if(isLeftToRightLineIsAccepted) { color = CV_RGB(0,255,0); } cvCircle(merged_images_copy, cvPoint(leftPoint->pt.x,leftPoint->pt.y), 5, color); cvCircle(merged_images_copy, cvPoint(rightPoint->pt.x+width_part,rightPoint->pt.y), 5, color); } //cvLine(merged_images_copy,cvPoint(leftPoint->pt.x,leftPoint->pt.y),cvPoint(rightPoint->pt.x,rightPoint->pt.y),CV_RGB(255,0,255)); if(iR >= 0 ) { sprintf(str,"%f",right_to_left_corresponding_points[iR].comparer_value); cvPutText(merged_images_copy,str,cvPoint(width_part,merged_images_copy->height-40),&my_font,CV_RGB(255,0,0)); rightPoint2= &(key_points_right [right_to_left_corresponding_points[iR].comp_pair.first]); leftPoint2= &(key_points_left [right_to_left_corresponding_points[iR].comp_pair.second]); cvLine(merged_images_copy,cvPoint(leftPoint2->pt.x,leftPoint2->pt.y),cvPoint(rightPoint2->pt.x+width_part,rightPoint2->pt.y),CV_RGB(255,0,0)); } //cvLine(merged_images_copy,cvPoint(leftPoint2->pt.x+width_part,leftPoint2->pt.y),cvPoint(rightPoint2->pt.x+width_part,rightPoint2->pt.y),CV_RGB(255,0,255)); cvShowImage("twoSnapshots",merged_images_copy); cvReleaseImage(&merged_images_copy); char ch2=cvWaitKey(33); if(ch2==27) break; if(ch2=='z' && selectedLeftLine>0) { selectedLeftLine--; } if(ch2=='x' && selectedLeftLine<1000) { selectedLeftLine++; } if( ch2 == 'a' || ch2 == 'A') { acceptedLeftToRightCorrespondings[selectedLeftLine] = true; } if( ch2 == 'd' || ch2 == 'D') { acceptedLeftToRightCorrespondings[selectedLeftLine] = false; } }//end of while(true) SaveAcceptedCorresspondings( left_to_right_corresponding_points, right_to_left_corresponding_points, key_points_left, key_points_right, acceptedLeftToRightCorrespondings, sizeOfAccepptedLeftToRightCorrespondings ); ConvertAcceptedCorresspondingsToMyArray(left_to_right_corresponding_points, right_to_left_corresponding_points, key_points_left, key_points_right, acceptedLeftToRightCorrespondings, sizeOfAccepptedLeftToRightCorrespondings, left_points, right_points ); delete[] acceptedLeftToRightCorrespondings; } if( ch == 'T' || ch == 't') { clock_t startTime = clock(); openTwoImages(left_image_file_path, right_image_file_path, left_img, right_img ); // proceed left extractFeaturesFromImage(left_img, min_hessian_value, gray_img_left, key_points_left, descriptors_left); //proceed right extractFeaturesFromImage(right_img, min_hessian_value, gray_img_right, key_points_right, descriptors_right); //comparison of two images if(fundamentalMatrix != 0) { cvReleaseMat(& fundamentalMatrix); fundamentalMatrix = 0; } left_to_right_corresponding_points.clear(); right_to_left_corresponding_points.clear(); GetCorrespondingPointsForSURF(key_points_left,descriptors_left,key_points_right,descriptors_right,left_to_right_corresponding_points,right_to_left_corresponding_points); // searching fundamental matrix and corresponding points findFundamentalMatrixAndCorrespondingPointsForReconstruction( left_to_right_corresponding_points, right_to_left_corresponding_points, fundamentalMatrix, key_points_left, key_points_right, descriptors_left, descriptors_right, left_img, right_img, gray_img_left, gray_img_right, forReconstructionLeftPoints, forReconstructionRightPoints, min_hessian_value, 450); // selecting points for finding model parameters int sizeOfAccepptedLeftToRightCorrespondings = left_to_right_corresponding_points.size(); bool* acceptedLeftToRightCorrespondings = 0; getAcceptedCorrespondingsForFindingModelParameters(left_to_right_corresponding_points, key_points_left, key_points_right, fundamentalMatrix, acceptedLeftToRightCorrespondings, sizeOfAccepptedLeftToRightCorrespondings); ConvertAcceptedCorresspondingsToMyArray(left_to_right_corresponding_points, right_to_left_corresponding_points, key_points_left, key_points_right, acceptedLeftToRightCorrespondings, sizeOfAccepptedLeftToRightCorrespondings, left_points, right_points ); delete[] acceptedLeftToRightCorrespondings; // start process of determination parameters of model and reconstruction of scene cv::Mat mat_left_img(left_img, true); cv::Mat mat_right_img(right_img, true); mainLevenbergMarkvardt_LMFIT(startValueOfFocus, "currentPLYExportFile", left_points, right_points, mat_left_img, mat_right_img, forReconstructionLeftPoints, forReconstructionRightPoints); mat_left_img.release(); mat_right_img.release(); cout << "Code execution time: "<< double( clock() - startTime ) / (double)CLOCKS_PER_SEC<< " seconds." << endl; } if( ch == 'I' || ch == 'i') { //-- Step 3: Matching descriptor vectors using FLANN matcher FlannBasedMatcher matcher; std::vector< DMatch > matches; matcher.match( descriptors_left, descriptors_right, matches ); //double max_dist = 0; double min_dist = 100; ////-- Quick calculation of max and min distances between keypoints //for( int i = 0; i < descriptors_left.rows; i++ ) //{ double dist = matches[i].distance; // if( dist < min_dist ) min_dist = dist; // if( dist > max_dist ) max_dist = dist; //} //printf("-- Max dist : %f \n", max_dist ); //printf("-- Min dist : %f \n", min_dist ); //-- Draw only "good" matches (i.e. whose distance is less than 2*min_dist, //-- or a small arbitary value ( 0.02 ) in the event that min_dist is very //-- small) //-- PS.- radiusMatch can also be used here. //std::vector< DMatch > good_matches; left_to_right_corresponding_points.clear(); right_to_left_corresponding_points.clear(); for( int i = 0; i < descriptors_left.rows; i++ ) { //if( matches[i].distance <= max(2*min_dist, 0.02) ) { //good_matches.push_back( matches[i]); left_to_right_corresponding_points.push_back( ComparedIndexes(matches[i].distance, pair<int, int> (i, matches[i].trainIdx)) ); } } cout<< "Count of good matches :" << left_to_right_corresponding_points.size() << endl; stable_sort(left_to_right_corresponding_points.begin(),left_to_right_corresponding_points.end(),my_comparator_for_stable_sort); } //if( ch == 'K' || ch == 'k') //{ // CvSURFPoint *leftPoint; // //proceed left // gray_img_left=cvCreateImage(cvSize((left_img->width),(left_img->height)),IPL_DEPTH_8U,1); // cvCvtColor(left_img,gray_img_left,CV_RGB2GRAY); // cvExtractSURF(gray_img_left,NULL,&key_points_left,&descriptors_left,mem_stor,cvSURFParams(min_hessian_value,0)); // cv::Mat mat_gray_leftImage(gray_img_left, true); // cvReleaseImage(&gray_img_left); // // proceed right // gray_img_right=cvCreateImage(cvSize((right_img->width),(right_img->height)),IPL_DEPTH_8U,1); // cvCvtColor(right_img,gray_img_right,CV_RGB2GRAY); // cv::Mat mat_gray_rightImage(gray_img_right, true); // cvReleaseImage(&gray_img_right); // vector<Point2f> LK_left_points; // vector<Point2f> LK_right_points; // LK_right_points.resize(key_points_left->total); // for( int i = 0; i < key_points_left->total; i++) // { // leftPoint=(CvSURFPoint*)cvGetSeqElem(key_points_left, i); // LK_left_points.push_back(Point2f( leftPoint->pt.x, leftPoint->pt.y)); // } // // vector<uchar> status; // vector<float> err; // cv::calcOpticalFlowPyrLK( // mat_gray_leftImage, // mat_gray_rightImage, // LK_left_points, // LK_right_points, // status, // err); // int width_part=merged_images->width>>1; // // float minErr = err[0]; // for(int k = 0; k < err.size(); k++) // { // if(status[k] && err[k] < minErr) // { // minErr = err[k]; // } // } // cout<< "Lucass Kanade min error: " << minErr<< endl; // int i = 0; // merged_images_copy=cvCreateImage(cvSize(merged_images->width,merged_images->height),merged_images->depth,3); // cvCopy(merged_images,merged_images_copy); // for(; i < LK_left_points.size(); ++i) // { // if(err[i] < 5 * minErr && status[i]) // { // cvLine(merged_images_copy,cvPoint(LK_left_points[i].x,LK_left_points[i].y),cvPoint(LK_right_points[i].x+width_part,LK_right_points[i].y), // CV_RGB(100 + (( i *3) % 155), 100+ ((i*7)%155), 100+ ((i*13)%155))); // } // } // cvShowImage("twoSnapshots",merged_images_copy); // // while(true) // { // char ch2=cvWaitKey(33); // if(ch2==27) // break; // // } // // cvReleaseImage(&merged_images_copy); // status.clear(); // err.clear(); // LK_left_points.clear(); // LK_right_points.clear(); // mat_gray_leftImage.release(); // mat_gray_rightImage.release(); //} if( ch == 'F' || ch == 'f') { findFundamentalMatrixAndCorrespondingPointsForReconstruction( left_to_right_corresponding_points, right_to_left_corresponding_points, fundamentalMatrix, key_points_left, key_points_right, descriptors_left, descriptors_right, left_img, right_img, gray_img_left, gray_img_right, forReconstructionLeftPoints, forReconstructionRightPoints, min_hessian_value); } if( ch == 'P' || ch == 'p') { cv::Mat mat_left_img(left_img, true); cv::Mat mat_right_img(right_img, true); mainLevenbergMarkvardt_LMFIT(startValueOfFocus, "currentPLYExportFile", left_points, right_points, mat_left_img, mat_right_img, forReconstructionLeftPoints, forReconstructionRightPoints); mat_left_img.release(); mat_right_img.release(); } if(merged_images!=0) { cvShowImage("twoSnapshots",merged_images); } }
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; }