Where is the memory leak

Question

The code is for motion tracking. It tracks different points across 2 images. However, the memory size increases a lot every time the function is called. I know it probably has something to do with the cvPoints probably. What's a good way to fix it? Thanks

 float calcorient(IplImage *imgA, IplImage *imgB) {
    // Initialize, load two images from the file system, and
    // allocate the images and other structures we will need for
    // results.
    //
    const int MAX_CORNERS = 500;
    CvSize    img_sz   = cvGetSize( imgA );
    int       win_size = 10;
    IplImage* imgC = cvCreateImage( img_sz, IPL_DEPTH_32F, 3 );
    // The first thing we need to do is get the features
    // we want to track.
    //
    IplImage* eig_image = cvCreateImage( img_sz, IPL_DEPTH_32F, 1 );
    IplImage* tmp_image = cvCreateImage( img_sz, IPL_DEPTH_32F, 1 );
    int           corner_count = MAX_CORNERS;
    CvPoint2D32f* cornersA     = new CvPoint2D32f[ MAX_CORNERS ];
    cvGoodFeaturesToTrack(
        imgA,
        eig_image,
        tmp_image,
        cornersA,
        &corner_count,
        0.01,
        5.0,
        0,
        3,
        0,
        0.04
        );
    cvFindCornerSubPix(
        imgA,
        cornersA,
        corner_count,
        cvSize(win_size,win_size),
        cvSize(-1,-1),
        cvTermCriteria(CV_TERMCRIT_ITER|CV_TERMCRIT_EPS,20,0.03)
        );
    // Call the Lucas Kanade algorithm
    //
    char  features_found[ MAX_CORNERS ];
    float feature_errors[ MAX_CORNERS ];
    CvSize pyr_sz = cvSize( imgA->width+8, imgB->height/3 );
    IplImage* pyrA = cvCreateImage( pyr_sz, IPL_DEPTH_32F, 1 );
    IplImage* pyrB = cvCreateImage( pyr_sz, IPL_DEPTH_32F, 1 );
    CvPoint2D32f* cornersB     = new CvPoint2D32f[ MAX_CORNERS ];
    cvCalcOpticalFlowPyrLK(
        imgA,
        imgB, 
        pyrA,
        pyrB,
        cornersA,
        cornersB,
        corner_count,
        cvSize( win_size,win_size ),
        5,
        features_found,
        feature_errors,
        cvTermCriteria( CV_TERMCRIT_ITER | CV_TERMCRIT_EPS, 20, .3 ),
        0
        );
    // Now make some image of what we are looking at:
    //
    float sum=0;

    for( int i=0; i<corner_count; i++ ) {
        if( features_found[i]==0|| feature_errors[i]>550 ) {
            //printf("Error is %f\n",feature_errors[i]);
            continue;
        }
        //printf("Got it\n");
        sum+=cornersA[i].x-cornersB[i].x;
        //printf("%f\n",sum);
        CvPoint p0 = cvPoint(
            cvRound( cornersA[i].x ),
            cvRound( cornersA[i].y )
            );
        CvPoint p1 = cvPoint(
            cvRound( cornersB[i].x ),
            cvRound( cornersB[i].y )
            );
        cvLine( imgC, p0, p1, CV_RGB(255,0,0),2 );
    }
    //cvNamedWindow("ImageA",0);
    //cvNamedWindow("ImageB",0);
    //cvNamedWindow("LKpyr_OpticalFlow",0);
    //cvShowImage("ImageA",imgA);
    //cvShowImage("ImageB",imgB);
    //cvShowImage("LKpyr_OpticalFlow",imgC);
    //cvWaitKey(1);
    return sum;
}

Answer 1

You must release your IplImages thanks to CvReleaseImage.

Answer 2

Looks like you're allocating a bunch of memory and not deleting it.

Try adding the lines:

delete [] cornersA; 
delete [] cornersB;

at the end of your function.

You might also check out the cvCreate calls -- if they are not getting freed up elsewhere those could be contributing to the problem.