void asef_destroy(AsefEyeLocator *asef){ cvReleaseMemStorage( &asef->face_detection_buffer ); cvReleaseHaarClassifierCascade( &asef->face_detection_classifier ); cvReleaseMat(&asef->lfilter); cvReleaseMat(&asef->rfilter); cvReleaseMat(&asef->lfilter_dft); cvReleaseMat(&asef->rfilter_dft); cvReleaseMat(&asef->scaled_face_image_32fc1); cvReleaseMat(&asef->scaled_face_image_8uc1); cvReleaseMat(&asef->lcorr); cvReleaseMat(&asef->rcorr); cvReleaseMat(&asef->lroi); cvReleaseMat(&asef->rroi); cvReleaseMat(&asef->lut); }
void CvGBTrees::clear() { if( weak ) { CvSeqReader reader; CvSlice slice = CV_WHOLE_SEQ; CvDTree* tree; //data->shared = false; for (int i=0; i<class_count; ++i) { int weak_count = cvSliceLength( slice, weak[i] ); if ((weak[i]) && (weak_count)) { cvStartReadSeq( weak[i], &reader ); cvSetSeqReaderPos( &reader, slice.start_index ); for (int j=0; j<weak_count; ++j) { CV_READ_SEQ_ELEM( tree, reader ); //tree->clear(); delete tree; tree = 0; } } } for (int i=0; i<class_count; ++i) if (weak[i]) cvReleaseMemStorage( &(weak[i]->storage) ); delete[] weak; } if (data) { data->shared = false; delete data; } weak = 0; data = 0; delta = 0.0f; cvReleaseMat( &orig_response ); cvReleaseMat( &sum_response ); cvReleaseMat( &sum_response_tmp ); cvReleaseMat( &subsample_train ); cvReleaseMat( &subsample_test ); cvReleaseMat( &sample_idx ); cvReleaseMat( &missing ); cvReleaseMat( &class_labels ); }
CvSeq*cvSegmentFGMask(CvArr* _mask, int poly1Hull0, float perimScale, CvMemStorage* storage, CvPoint offset) { CvMat mstub, *mask = cvGetMat(_mask, &mstub); CvMemStorage* tempStorage = storage ? storage : cvCreateMemStorage(); CvSeq *contours, *c; int nContours = 0; CvContourScanner scanner; // clean up raw mask cvMorphologyEx(mask, mask, 0, 0, CV_MOP_OPEN, 1); cvMorphologyEx(mask, mask, 0, 0, CV_MOP_CLOSE, 1); // find contours around only bigger regions scanner = cvStartFindContours(mask, tempStorage, sizeof(CvContour), CV_RETR_EXTERNAL, CV_CHAIN_APPROX_SIMPLE, offset); while ((c = cvFindNextContour(scanner)) != 0) { double len = cvContourPerimeter(c); double q = (mask->rows + mask->cols) / perimScale; // calculate perimeter len threshold if (len < q) //Get rid of blob if it's perimeter is too small cvSubstituteContour(scanner, 0); else //Smooth it's edges if it's large enough { CvSeq* newC; if (poly1Hull0) //Polygonal approximation of the segmentation newC = cvApproxPoly(c, sizeof(CvContour), tempStorage, CV_POLY_APPROX_DP, 2, 0); else //Convex Hull of the segmentation newC = cvConvexHull2(c, tempStorage, CV_CLOCKWISE, 1); cvSubstituteContour(scanner, newC); nContours++; } } contours = cvEndFindContours(&scanner); // paint the found regions back into the image cvZero(mask); for (c = contours; c != 0; c = c->h_next) cvDrawContours(mask, c, cvScalarAll(255), cvScalarAll(0), -1, CV_FILLED, 8, cvPoint(-offset.x, -offset.y)); if (tempStorage != storage) { cvReleaseMemStorage(&tempStorage); contours = 0; } return contours; }
/*! \fn CvGaborFeature::writeXML(const char* filename) const */ void CvGaborFeature::writeXML(const char* filename) const { CvMemStorage* storage = cvCreateMemStorage( 0 ); CvFileStorage* fs = cvOpenFileStorage( filename, storage, CV_STORAGE_WRITE); cvStartWriteStruct( fs, "CvGaborFeature", CV_NODE_MAP, NULL, cvAttrList(0,0)); cvWriteInt(fs, "x", getx()); cvWriteInt(fs, "y", gety()); cvWriteInt(fs, "Mu",getMu()); cvWriteInt(fs, "Nu",getNu()); cvEndWriteStruct(fs); cvEndWriteStruct( fs ); cvReleaseFileStorage(&fs); cvReleaseMemStorage(&storage); }
CvSeq* HoughCircle::locateHoughCircles(IplImage* img,double min_distance, double upperThreshold, double accumulatorThreshold, double min_radius, double max_radius ){ //IplImage* gray = cvCreateImage(cvGetSize(img), IPL_DEPTH_8U, 1); //storage = cvCreateMemStorage(0); IplImage* gray=cvCreateImage(cvGetSize(img), IPL_DEPTH_8U, 1); CvMemStorage* storage = cvCreateMemStorage(0); cvCvtColor( img, gray, CV_BGR2GRAY ); // cvShowImage("Gray",gray); // cvEqualizeHist(gray,gray); // cvShowImage("Hist Eq Gray",gray); CvSeq* circle = cvHoughCircles( gray, storage, CV_HOUGH_GRADIENT, 2, min_distance, upperThreshold, accumulatorThreshold, min_radius, max_radius); cvReleaseImage(&gray); cvReleaseMemStorage(&storage); return circle; }
/* Clean up */ static void gst_face_blur_finalize (GObject * obj) { GstFaceBlur *filter = GST_FACE_BLUR (obj); if (filter->cvGray) cvReleaseImage (&filter->cvGray); if (filter->cvStorage) cvReleaseMemStorage (&filter->cvStorage); if (filter->cvCascade) cvReleaseHaarClassifierCascade (&filter->cvCascade); g_free (filter->profile); G_OBJECT_CLASS (gst_face_blur_parent_class)->finalize (obj); }
CHandDrawEffect::~CHandDrawEffect() { for(int i = 0; i < PATT_NUM; i++) { if(hatching[i]) cvReleaseImage(&hatching[i]); } if(hsv) cvReleaseImage(&hsv); if(grayImage) cvReleaseImage(&grayImage); if(binaryImage) cvReleaseImage(&binaryImage); if(imageA) cvReleaseImage(&imageA); if(imageB) cvReleaseImage(&imageB); if(imageC) cvReleaseImage(&imageC); if(imageD) cvReleaseImage(&imageD); if(imageE) cvReleaseImage(&imageE); if(scanningLine) cvReleaseImage(&scanningLine); if(memStorage0) cvReleaseMemStorage(&memStorage0); }
void moBlobFinderModule::applyFilter(IplImage *src) { this->storage = cvCreateMemStorage(0); this->clearBlobs(); this->storage = cvCreateMemStorage(0); cvCopy(src, this->output_buffer); CvSeq *contours = 0; cvFindContours(this->output_buffer, this->storage, &contours, sizeof(CvContour), CV_RETR_CCOMP); cvDrawContours(this->output_buffer, contours, cvScalarAll(255), cvScalarAll(255), 100); // Consider each contour a blob and extract the blob infos from it. int size; int ratio; int min_size = this->property("min_size").asInteger(); int max_size = this->property("max_size").asInteger(); CvSeq *cur_cont = contours; while (cur_cont != 0) { CvRect rect = cvBoundingRect(cur_cont, 0); size = rect.width * rect.height; // Check ratio to make sure blob can physically represent a finger // magic number 6 is used for now to represent maximum ratio of // Length/thickness of finger if (rect.width < rect.height) { ratio = rect.height / (double)rect.width; } else { ratio = rect.width / (double)rect.height; } if ((ratio <= 6) && (size >= min_size) && (size <= max_size)) { moDataGenericContainer *blob = new moDataGenericContainer(); blob->properties["implements"] = new moProperty("pos,size"); blob->properties["x"] = new moProperty((rect.x + rect.width / 2) / (double) src->width); blob->properties["y"] = new moProperty((rect.y + rect.height / 2) / (double) src->height); blob->properties["width"] = new moProperty(rect.width); blob->properties["height"] = new moProperty(rect.height); this->blobs->push_back(blob); cvRectangle(this->output_buffer, cvPoint(rect.x,rect.y), cvPoint(rect.x + rect.width,rect.x + rect.height), cvScalar(250,10,10), 1); } cur_cont = cur_cont->h_next; } cvReleaseMemStorage(&this->storage); this->output_data->push(this->blobs); }
// Perform face detection on the input image, using the given Haar Cascade. // Returns a rectangle for the detected region in the given image. CvRect detectFaceInImage(IplImage* inputImg, CvHaarClassifierCascade* cascade, CvSize faceSize) { // Only search for 1 face. int flags = CV_HAAR_FIND_BIGGEST_OBJECT | CV_HAAR_DO_ROUGH_SEARCH; // How detailed should the search be. float search_scale_factor = 1.1f; IplImage *detectImg = NULL; IplImage *greyImg = NULL; CvMemStorage* storage = NULL; CvSeq* rects = NULL; CvSize srcSize; CvRect rc; int nFaces; storage = cvCreateMemStorage(0); // Allocate 64KB memory space cvClearMemStorage(storage); // If the image is color, use a greyscale copy of the image. detectImg = (IplImage*)inputImg; if (inputImg->nChannels > 1) { srcSize = cvSize(inputImg->width, inputImg->height); greyImg = cvCreateImage(srcSize, IPL_DEPTH_8U, 1); cvCvtColor(inputImg, greyImg, CV_BGR2GRAY); detectImg = greyImg; // Use the greyscale image. } // Detect all the faces in the greyscale image. rects = cvHaarDetectObjects(detectImg, cascade, storage, search_scale_factor, 3, flags, faceSize); nFaces = rects->total; // Get the first detected face (the biggest). if (nFaces > 0) rc = *(CvRect*)cvGetSeqElem(rects, 0); else rc = cvRect(-1, -1, -1, -1); // Couldn't find the face. if (greyImg != NULL) cvReleaseImage(&greyImg); cvReleaseMemStorage(&storage); return rc; // Return the biggest face found, or (-1,-1,-1,-1). }
int main() { const int imgHeight = 500; const int imgWidth = 500; IplImage* pImgSrc = cvCreateImage(cvSize(imgWidth, imgHeight), IPL_DEPTH_8U, 1); // Ôʼͼ IplImage* pImgContour = NULL; // ÂÖÀªÍ¼ CvMemStorage* pMemStorage = cvCreateMemStorage(0); // ÁÙʱ´æ´¢Çø CvSeq* pContour = 0; // ´æ´¢ÂÖÀªµã // »æÖÆÔʼͼƬ DrawImage(pImgSrc); // ÏÔʾÔʼͼ cvNamedWindow("Source", CV_WINDOW_AUTOSIZE); cvShowImage("Source", pImgSrc); // ΪÂÖÀªÍ¼ÉêÇë¿Õ¼ä, 3ͨµÀͼÏñ pImgContour = cvCreateImage(cvGetSize(pImgSrc), IPL_DEPTH_8U, 3); // ½«µ¥Í¨µÀ»Ò¶Èͼת»¯Îª3ͨµÀ»Ò¶Èͼ //cvCvtColor(pImgSrc, pImgContour, CV_GRAY2BGR); cvZero(pImgContour); // ²éÕÒÂÖÀª cvFindContours(pImgSrc, pMemStorage, &pContour, sizeof(CvContour), CV_RETR_TREE, CV_CHAIN_APPROX_SIMPLE, cvPoint(0, 0)); // ½«ÂÖÀª»³ö cvDrawContours(pImgContour, pContour, CV_RGB(0, 0, 255), CV_RGB(255, 0, 0), 2, 2, 8, cvPoint(0, 0)); // ÏÔʾÂÖÀªÍ¼ cvNamedWindow("Contour", CV_WINDOW_AUTOSIZE); cvShowImage("Contour", pImgContour); cvWaitKey(0); cvDestroyWindow("Contour"); cvDestroyWindow("Source"); cvReleaseImage(&pImgSrc); cvReleaseImage(&pImgContour); cvReleaseMemStorage(&pMemStorage); return 0; }
FindObjectMain::~FindObjectMain() { // This releases all the arrays if(storage) cvReleaseMemStorage(&storage); if(object_image) cvReleaseImage(&object_image); if(scene_image) cvReleaseImage(&scene_image); if(prev_object) delete [] prev_object; delete affine; delete temp; delete overlayer; if(blob_param.pBT) cvReleaseBlobTracker(&blob_param.pBT); if(blob_param.pBD) cvReleaseBlobDetector(&blob_param.pBD); if(blob_param.pBTGen) cvReleaseBlobTrackGen(&blob_param.pBTGen); if(blob_param.pBTA) cvReleaseBlobTrackAnalysis(&blob_param.pBTA); if(blob_param.pFG) cvReleaseFGDetector(&blob_param.pFG); if(blob_pTracker) cvReleaseBlobTrackerAuto(&blob_pTracker); }
void catcierge_haar_matcher_destroy(catcierge_matcher_t **octx) { catcierge_haar_matcher_t *ctx; if (!octx || !(*octx)) return; ctx = (catcierge_haar_matcher_t *)*octx; if (ctx->cascade) { cv2CascadeClassifier_destroy(ctx->cascade); ctx->cascade = NULL; } if (ctx->kernel2x2) { cvReleaseStructuringElement(&ctx->kernel2x2); ctx->kernel2x2 = NULL; } if (ctx->kernel3x3) { cvReleaseStructuringElement(&ctx->kernel3x3); ctx->kernel3x3 = NULL; } if (ctx->kernel5x1) { cvReleaseStructuringElement(&ctx->kernel5x1); ctx->kernel5x1 = NULL; } if (ctx->storage) { cvReleaseMemStorage(&ctx->storage); ctx->storage = NULL; } free(ctx); *octx = NULL; }
/* * Prints a contour on a dst Image. Used for debugging. * prints text at the side of a contour. * depthLevel sets the level in the contour tree(to include/exclue holes) */ void Contours::printContour(int depthLevel, CvScalar color,IplImage * dst){ CvFont font; int line_type=CV_AA; char * a=(char *) malloc(20); char * b=(char *) malloc(20); char * c=(char *) malloc(20); char * d=(char *) malloc(20); char * e=(char *) malloc(20); cvDrawContours( dst, this->c, CV_RGB(255,0,0), CV_RGB(0,255,0), depthLevel, 3, CV_AA, cvPoint(0,0) ); CvMemStorage* mem = cvCreateMemStorage(0); CvBox2D box=cvMinAreaRect2(this->c,mem); //~ traversePoints(this->c); std::vector<int> centroid=this->getCentroid(); CvPoint pt2=cvPoint(centroid[0]+5,centroid[1]+5); CvPoint pt3=cvPoint(centroid[0]+5,centroid[1]+15); CvPoint pt4=cvPoint(centroid[0]+5,centroid[1]+25); CvPoint pt5=cvPoint(centroid[0]+5,centroid[1]+35); CvPoint pt6=cvPoint(centroid[0]+5,centroid[1]+45); sprintf(a,"per: %g",this->getPerimeter()); sprintf(b,"zone: %d",getPointZone(this->x,this->y)); sprintf(c,"area: %g",this->getArea()); sprintf(d,"ecc: %g",this->getPerimeter()*this->getPerimeter()/this->getArea()); //~ sprintf(d,"boxArea: %g",(double) this->getArea()/(box.size.width*box.size.height)); cvInitFont( &font, CV_FONT_HERSHEY_COMPLEX, 0.5, 0.5, 0.0,0.5, line_type ); cvPutText( dst, a, pt2, &font, CV_RGB(255,255,0)); cvPutText( dst, c, pt3, &font, CV_RGB(255,255,0)); cvPutText( dst, b, pt4, &font, CV_RGB(255,255,0)); cvPutText( dst, d, pt5, &font, CV_RGB(255,255,0)); //~ free(a); cvReleaseMemStorage(&mem); }
CV_IMPL void icvStartScanGraph( CvGraph* graph, CvGraphScanner* scanner, CvGraphVtx* vtx, int mask ) { CvMemStorage* child_storage = 0; CV_FUNCNAME("icvStartScanGraph"); __BEGIN__; if( !graph || !scanner ) CV_ERROR_FROM_STATUS( CV_NULLPTR_ERR ); if( !(graph->storage )) CV_ERROR_FROM_STATUS( CV_NULLPTR_ERR ); memset( scanner, 0, sizeof(*scanner)); scanner->graph = graph; scanner->mask = mask; scanner->vtx = vtx; scanner->index = vtx == 0 ? 0 : -1; CV_CALL( child_storage = cvCreateChildMemStorage( graph->storage )); CV_CALL( scanner->stack = cvCreateSeq( 0, sizeof(CvSet), sizeof(CvGraphItem), child_storage )); CV_CALL( icvSeqElemsClearMask( (CvSeq*)graph, CV_FIELD_OFFSET( flags, CvGraphVtx ), CV_GRAPH_ITEM_VISITED_FLAG| CV_GRAPH_SEARCH_TREE_NODE_FLAG )); CV_CALL( icvSeqElemsClearMask( (CvSeq*)(graph->edges), CV_FIELD_OFFSET( flags, CvGraphEdge ), CV_GRAPH_ITEM_VISITED_FLAG )); __END__; if( cvGetErrStatus() < 0 ) cvReleaseMemStorage( &child_storage ); }
int main( int argc, char** argv ) { CvCapture *capture; IplImage *frame; int key; //NamNguyen comment and add(2lines below) //char *filename = "haarcascade_frontalface_alt.xml"; char filename[] = "haarcascade_frontalface_alt.xml"; cascade = ( CvHaarClassifierCascade* )cvLoad( filename, 0, 0, 0 ); storage = cvCreateMemStorage( 0 ); capture = cvCaptureFromCAM( 0 ); assert( cascade && storage && capture ); cvNamedWindow( "video", 1 ); while( key != 'q' ) { frame = cvQueryFrame( capture ); if( !frame ) { fprintf( stderr, "Cannot query frame!\n" ); break; } cvFlip( frame, frame, -1 ); frame->origin = 0; detectFaces( frame ); key = cvWaitKey( 10 ); } cvReleaseCapture( &capture ); cvDestroyWindow( "video" ); cvReleaseHaarClassifierCascade( &cascade ); cvReleaseMemStorage( &storage ); return 0; }
/* boxArea filter - checks that the area of a contour * is at least minAreaRatio of that of the contour bounding box*/ int Contours::boxAreaFilter(double minAreaRatio){ CvBox2D box; CvMemStorage* mem = cvCreateMemStorage(0); double boxArea,contourArea,dif,ret; box=cvMinAreaRect2(this->c,mem); boxArea=box.size.width*box.size.height; contourArea=this->getArea(); dif=boxArea-contourArea; ret=(1- (dif/boxArea)); /* Use this to set it by zone int zone=getPointZone(this->x,this->y); double minAreaRatioByZone[]={0,0.6,0.55,0.55,0.55}; return ret > minAreaRatioByZone[zone]; */ cvReleaseMemStorage( &mem ); return ret > minAreaRatio; }
/* rectangular aspect filter - checks that a contour bounding rectangle * has certain width/height proportions */ int Contours::rectangularAspectFilter(double minWidthHeightRatio, double maxWidthHeightRatio ){ CvBox2D box; CvMemStorage* mem = cvCreateMemStorage(0); int ret; box=cvMinAreaRect2(this->c,mem); if( (box.size.width > minWidthHeightRatio* box.size.height) && (box.size.width < (maxWidthHeightRatio)* box.size.height) || (box.size.height > minWidthHeightRatio* box.size.width) && (box.size.height < (maxWidthHeightRatio)*box.size.width)){ ret=1; } else{ ret=0; } cvReleaseMemStorage( &mem ); return ret; }
static void kms_face_detector_finalize (GObject * object) { KmsFaceDetector *facedetector = KMS_FACE_DETECTOR (object); cvReleaseImageHeader (&facedetector->priv->cvImage); cvReleaseImage (&facedetector->priv->cvResizedImage); if (facedetector->priv->pStorageFace != NULL) cvClearMemStorage (facedetector->priv->pStorageFace); if (facedetector->priv->pFaceRectSeq != NULL) cvClearSeq (facedetector->priv->pFaceRectSeq); cvReleaseMemStorage (&facedetector->priv->pStorageFace); cvReleaseHaarClassifierCascade (&facedetector->priv->pCascadeFace); g_mutex_clear (&facedetector->priv->mutex); G_OBJECT_CLASS (kms_face_detector_parent_class)->finalize (object); }
IplImage* BouyBaseObject::SegmentationMask(const IplImage * imgIn) const { IplImage * imgOut = cvCreateImage(cvGetSize(imgIn),IPL_DEPTH_8U, 1); IplImage * src = cvCreateImage(cvGetSize(imgIn),IPL_DEPTH_8U, 1); IplImage* hsv = cvCreateImage( cvGetSize(imgIn), 8, 3 ); IplImage * chan0 = cvCreateImage(cvGetSize(imgIn),IPL_DEPTH_8U, 1); IplImage * chan1 = cvCreateImage(cvGetSize(imgIn),IPL_DEPTH_8U, 1); IplImage * chan2 = cvCreateImage(cvGetSize(imgIn),IPL_DEPTH_8U, 1); IplImage * chan3 = cvCreateImage(cvGetSize(imgIn),IPL_DEPTH_8U, 1); cvCvtColor( imgIn, hsv, CV_BGR2YCrCb ); cvSplit(hsv,chan0,chan1,chan2, NULL); //cvConvertImage(imgIn,src); src = cvCloneImage(chan0); CvMemStorage* storage = cvCreateMemStorage(0); CvSeq* comp = NULL; //lower last param for more segments cvPyrSegmentation( src, imgOut, storage, &comp, 3, 200, 50 ); cvAbsDiffS(imgOut,imgOut,CV_RGB(255,255,255)); //cvNormalize(imgOut,imgOut,255,0, CV_MINMAX); //cvThreshold(imgOut,imgOut,250,255,CV_THRESH_TOZERO); // int n_comp = comp->total; // for( int i=0; i<n_comp; i++ ) // { // CvConnectedComp* cc = (CvConnectedComp*) cvGetSeqElem( comp, i ); // cvDrawRect(imgOut,cvPoint(cc->rect.x,cc->rect.y),cvPoint(cc->rect.x+cc->rect.width,cc->rect.y+cc->rect.height),CV_RGB(255,255,255)); // //do_something_with( cc ); // } cvReleaseImage(&src); cvReleaseImage(&hsv); cvReleaseImage(&chan0); cvReleaseImage(&chan1); cvReleaseImage(&chan2); cvReleaseImage(&chan3); cvReleaseMemStorage( &storage ); return imgOut; }
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; }
/** Finds SIFT features in an image using user-specified parameter values. All detected features are stored in the array pointed to by \a feat. @param img the image in which to detect features @param fea a pointer to an array in which to store detected features @param intvls the number of intervals sampled per octave of scale space @param sigma the amount of Gaussian smoothing applied to each image level before building the scale space representation for an octave @param cont_thr a threshold on the value of the scale space function \f$\left|D(\hat{x})\right|\f$, where \f$\hat{x}\f$ is a vector specifying feature location and scale, used to reject unstable features; assumes pixel values in the range [0, 1] @param curv_thr threshold on a feature's ratio of principle curvatures used to reject features that are too edge-like @param img_dbl should be 1 if image doubling prior to scale space construction is desired or 0 if not @param descr_width the width, \f$n\f$, of the \f$n \times n\f$ array of orientation histograms used to compute a feature's descriptor @param descr_hist_bins the number of orientations in each of the histograms in the array used to compute a feature's descriptor @return Returns the number of keypoints stored in \a feat or -1 on failure @see sift_keypoints() */ int _sift_features( IplImage* img, struct feature** feat, int intvls, double sigma, double contr_thr, int curv_thr, int img_dbl, int descr_width, int descr_hist_bins ) { IplImage *init_img; IplImage ***gauss_pyr, ***dog_pyr; CvMemStorage *storage; CvSeq *features; int octvs, i, n = 0; /* build scale space pyramid; smallest dimension of top level is ~4 pixels */ init_img = create_init_img( img, img_dbl, sigma ); octvs = log( MIN( init_img->width, init_img->height ) ) / log(2) - 2; gauss_pyr = build_gauss_pyr( init_img, octvs, intvls, sigma ); dog_pyr = build_dog_pyr( gauss_pyr, octvs, intvls ); storage = cvCreateMemStorage( 0 ); features = scale_space_extrema( dog_pyr, octvs, intvls, contr_thr, curv_thr, storage ); calc_feature_scales( features, sigma, intvls ); if( img_dbl ) adjust_for_img_dbl( features ); calc_feature_oris( features, gauss_pyr ); compute_descriptors( features, gauss_pyr, descr_width, descr_hist_bins ); /* sort features by decreasing scale and move from CvSeq to array */ cvSeqSort( features, (CvCmpFunc)feature_cmp, NULL ); n = features->total; *feat = calloc( n, sizeof(struct feature) ); *feat = cvCvtSeqToArray( features, *feat, CV_WHOLE_SEQ ); for( i = 0; i < n; i++ ) { free( (*feat)[i].feature_data ); (*feat)[i].feature_data = NULL; } cvReleaseMemStorage( &storage ); cvReleaseImage( &init_img ); release_pyr( &gauss_pyr, octvs, intvls + 3 ); release_pyr( &dog_pyr, octvs, intvls + 2 ); return n; }
void EnclosingCircle(IplImage* _image, IplImage *dem) { assert(_image != 0); IplImage* bin = cvCreateImage( cvGetSize(_image), IPL_DEPTH_8U, 1); // конвертируем в градации серого cvConvertImage(_image, bin, CV_BGR2GRAY); // находим границы cvCanny(bin, bin, 100, 200); //cvNamedWindow( "bin", 1 ); //cvShowImage("bin", bin); // хранилище памяти для контуров CvMemStorage* storage = cvCreateMemStorage(0); CvSeq* contours = 0; // находим контуры int contoursCont = cvFindContours( bin, storage, &contours, sizeof(CvContour), CV_RETR_LIST, CV_CHAIN_APPROX_SIMPLE, cvPoint(0,0)); assert(contours != 0); CvPoint2D32f center; float radius = 0; // обходим все контуры for( CvSeq* current = contours; current != NULL; current = current->h_next ) { // находим параметры окружности cvMinEnclosingCircle(current, ¢er, &radius); // рисуем cvCircle(dem, cvPointFrom32f(center), radius, CV_RGB(255, 0, 0), 1, 1); } // освобождаем ресурсы cvReleaseMemStorage(&storage); cvReleaseImage(&bin); }
//-------------------------------------------------------------- void Vision::checkHoles(){ //Duplicate the 1st part of findContour in ofxCvContourFinder Class // get width/height disregarding ROI ofxCvGrayscaleImage input = grayDiff; IplImage* ipltemp = input.getCvImage(); int _width; int _height; _width = ipltemp->width; _height = ipltemp->height; ofxCvGrayscaleImage inputCopy; inputCopy.setUseTexture(false); if( inputCopy.getWidth() == 0 ) { inputCopy.allocate( _width, _height ); } else if( inputCopy.getWidth() != _width || inputCopy.getHeight() != _height ) { // reallocate to new size inputCopy.clear(); inputCopy.allocate( _width, _height ); } inputCopy.setROI( input.getROI() ); inputCopy = input; CvSeq* contour_list = NULL; CvMemStorage* contour_storage = cvCreateMemStorage(1000); cvFindContours( inputCopy.getCvImage(), contour_storage, &contour_list, sizeof(CvContour), CV_RETR_TREE, CV_CHAIN_APPROX_SIMPLE); //-----------------------------------// cardDetection(contour_list); //-----------------------------------// // Free the storage memory. // Warning: do this inside this function otherwise a strange memory leak if( contour_storage != NULL ) { cvReleaseMemStorage(&contour_storage); } }
// this should be replaced by c++ 2.0 api style code once available vector<cv::Vec4i> convexityDefects(const vector<cv::Point>& contour) { vector<int> hullIndices; convexHull(Mat(contour), hullIndices, false, false); vector<cv::Vec4i> convexityDefects; if(hullIndices.size() > 0 && contour.size() > 0) { CvMat contourMat = cvMat(1, contour.size(), CV_32SC2, (void*) &contour[0]); CvMat hullMat = cvMat(1, hullIndices.size(), CV_32SC1, (void*) &hullIndices[0]); CvMemStorage* storage = cvCreateMemStorage(0); CvSeq* defects = cvConvexityDefects(&contourMat, &hullMat, storage); for(int i = 0; i < defects->total; i++){ CvConvexityDefect* cur = (CvConvexityDefect*) cvGetSeqElem(defects, i); cv::Vec4i defect; defect[0] = cur->depth_point->x; defect[1] = cur->depth_point->y; defect[2] = (cur->start->x + cur->end->x) / 2; defect[3] = (cur->start->y + cur->end->y) / 2; convexityDefects.push_back(defect); } cvReleaseMemStorage(&storage); } return convexityDefects; }
void ofxCvHaarFinder::setup(string haarFile) { if(cascade != NULL) cvReleaseHaarClassifierCascade(&cascade); this->haarFile = haarFile; haarFile = ofToDataPath(haarFile); cascade = (CvHaarClassifierCascade*) cvLoad(haarFile.c_str(), 0, 0, 0); #ifdef HAAR_HACK // http://thread.gmane.org/gmane.comp.lib.opencv/16540/focus=17400 // http://www.openframeworks.cc/forum/viewtopic.php?f=10&t=1853&hilit=haar ofxCvGrayscaleImage hack; hack.allocate(8, 8); CvMemStorage* storage = cvCreateMemStorage(); cvHaarDetectObjects(hack.getCvImage(), cascade, storage, scaleHaar, 2, CV_HAAR_DO_CANNY_PRUNING); cvReleaseMemStorage(&storage); #endif if (!cascade) printf("Could not load Haar cascade: %s\n", haarFile.c_str()); }
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); }
void releaseBGMeanStatModel( BGMeanStatModel** _model ){ CV_FUNCNAME( "releaseBGMeanStatModel" ); __BEGIN__; if( !_model ) CV_ERROR( CV_StsNullPtr, "" ); if( *_model ){ BGMeanStatModel* model = *_model; cvFree( &model->frame_cbuffer ); cvFree( &model->mean ); cvFree( &model->std_dev ); cvReleaseImage( &model->foreground ); cvReleaseImage( &model->background ); cvReleaseMemStorage(&model->storage); cvFree( _model ); } __END__; }
void exit_nicely(char* msg) { cvDestroyAllWindows(); if (capture) cvReleaseCapture(&capture); if (gray) cvReleaseImage(&gray); if (prev) cvReleaseImage(&prev); if (diff) cvReleaseImage(&diff); if (tpl) cvReleaseImage(&tpl); if (storage) cvReleaseMemStorage(&storage); if (msg != NULL) { fprintf(stderr, msg); fprintf(stderr, "/n"); exit(1); } exit(0); }
//对序列中的每个元素进行操作,此序列的元素是由cvPyrSegmentation返回的连续区域 void f( IplImage* src, IplImage* dst ) { // 分配存储区域,storage指针指向opencv存储区 CvMemStorage* storage = cvCreateMemStorage(0); // 序列的初始位置 CvSeq* comp = NULL; // 金字塔处理,参数分别为:输入、输出、存储、位置指针、金字塔层数、建立连接时的错误阈值,分割簇的错误阈值 // 建立连接时的错误阈值:小于等于该值得点连接;分割簇的错误阈值:小于等于该值的点看做一个区域 cvPyrSegmentation( src, dst, storage, &comp, 4, 200, 50 ); // 获取序列元素的个数 int n_comp = comp->total; for( int i=0; i<n_comp; i++ ) { // 依次获得每一个元素的值 CvConnectedComp* cc = (CvConnectedComp*) cvGetSeqElem( comp, i ); // do_something_with( cc ); // 这里可以做点什么 } // 释放内存 cvReleaseMemStorage( &storage ); }
ViennaMap::~ViennaMap() { SDL_mutex *mut = cvRessourcesGuard; //free cv ressources and their guard if (SDL_mutexP(mut) == -1) throw "could not acquire cvRessourcesGuard to destruct ViennaMap"; cvRessourcesGuard = 0; cvReleaseMemStorage(&cvMemStorage); cvReleaseImage(&tempBinarizedImage); if (SDL_mutexV(mut) == -1) throw "could not release cvRessourcesGuard after freeing cv ressources"; SDL_DestroyMutex(mut); //free fragments and their guard mut = fragmentGuard; if (SDL_mutexP(mut) == -1) throw "could not acquire fragment guard to destruct ViennaMap"; fragmentGuard = 0; std::vector<MapFragment*>::iterator it=fragments.begin(), end = fragments.end(); for(;it != end; it++) if (*it != NULL) { freePolygonList((*it)->polygons); freePolygonList((*it)->incompletePolygons); delete *it; *it = NULL; } fragments.clear(); if (SDL_mutexV(mut) == -1) throw "could not release fragmentGuard after freeing fragments"; }