featureCorrelator.C

//=============================================================================
#include "featureCorrelator.h"
#include "featureFinder.h"
#include <math.h>

#define INITIAL_FEATURES_PER_FRAME 50

featureCorrelator::featureCorrelator( const char *initProgressMsg,
				      movieIO &src, bool visible )
  : correlator( src.getWidth(), src.getHeight(), visible, false ),
    movie_(&src)
{
  int i;
  
  if ( initProgressMsg!=0 )
  {
    progressBarMsg( initProgressMsg );
  }

  numCorners_ = new int[src.getLength()];
  for ( i=src.getLength()-1; i>=0; i-- )
  {
    numCorners_[i] = INITIAL_FEATURES_PER_FRAME;
  }
  
  corners_ = new sortedSubWindowList[src.getLength()];
  rgbImage *rgbBuf;
  for ( i=0; i<src.getLength(); i++ )
  {
    rgbBuf = src.deepRGBFrame( i );
    addImageFrame( i, rgbBuf );
    featureFinder finder( rgbBuf );
    corners_[i] = finder.findFeatures( numCorners_[i] );
    src.delRGBFrame( rgbBuf );
    updatePercent( (float)i/(float)src.getLength() );
  }
  
  endProgressBar();
}
  
int 
featureCorrelator::findMidInterval( vector<subWindowListAnim> trackedList,
				    int length, int startFrm )
{
  float intLength = 0;
  int numFeatures = numFeatsAtFrame( startFrm, trackedList );
  for ( int i=startFrm+1; i<length; i++ )
  {
    if ( numFeatsAtFrame(i,trackedList)>numFeatures ) break;
    intLength += 1.0f;
  }
  startFrm +=
    rint( intLength/2.0f +
	  ((float)(rand()%2000-1000))*intLength/1500.0f );
  if ( startFrm<0 ) startFrm=0;
  else if ( startFrm>=length ) startFrm=length-1;
  return startFrm;
}

int 
featureCorrelator::numFeatsAtFrame( int frm,
				    const vector<subWindowListAnim> &featList )
{
  int num=0;
  vector<subWindowListAnim>::const_iterator iter = featList.begin();
  for ( ; iter!=featList.end(); iter++ )
  {
    if ( iter->includesFrame(frm) ) num++;
  }
  return num;
}

vector<subWindowListAnim> 
featureCorrelator::buildTrackedFeatureList( const char *trackProgressMsg,
					    int minNumFeaturesPerFrm,
					    int minFeatureTrackLen,
					    int maxX, int maxY )
{
  int srcFrame;
  vector<subWindowListAnim> features;
  int minNumbFeatures, minFeatureFrame;
  subWindow currFeature, currCorner;

  if ( maxX==-1 )
  {
    maxX=imgWidth_;
    maxY=imgHeight_;
  }
  else if ( maxY==-1 )
  {
    maxY=maxX;
  }
  
  if ( trackProgressMsg!=0 )
  {
    progressBarMsg( trackProgressMsg );
  }

  while (true) {
    // Find the frame with the minimum number of dected features
    minNumbFeatures=INT_MAX;
    for ( srcFrame=0; srcFrame<numFrames_; srcFrame++ )
    {
      int featsAtFrm = numFeatsAtFrame( srcFrame, features );
      if ( featsAtFrm<minNumbFeatures )
      {
	minNumbFeatures = featsAtFrm;
	minFeatureFrame = srcFrame;
      }
    }

    // If the minimum is greater than the number of features per frame
    // we're looking for, we're done!
    if ( minNumbFeatures>=minNumFeaturesPerFrm ) break;

    // Choose a quasi-random mid-point in the interval of the movie for which
    // we have minFeatureFrame features.
    srcFrame = findMidInterval( features, numFrames_, minFeatureFrame );

    // Choose the next harris detected corner for which no existing feature
    // in our list overlaps
    for ( int i=0; i<corners_[srcFrame].getSize(); i++ )
    {
      currCorner = corners_[srcFrame][i];
      vector<subWindowListAnim>::iterator iter = features.begin();
      for ( ; iter!=features.end(); iter++ )
      {
	if ( iter->includesFrame(srcFrame) )
	{
	  if ( (*iter)[srcFrame].overlaps(currCorner) ) break;
	}
      }
      if ( iter==features.end() ) break;
    }

    // All our corners overlap with existing features!
    // Increase the corner detection for that frame and continue on
    if ( i>=corners_[srcFrame].getSize() )
    {
      numCorners_[srcFrame] *= 1.5;
      rgbImage *rgbBuf = movie_->getRGBFrame(srcFrame);
      featureFinder finder( rgbBuf );
      corners_[srcFrame] = finder.findFeatures(numCorners_[srcFrame]);
      movie_->releaseRGBFrame( rgbBuf );
    }
    else
    {
      clearWindow();
      currCorner=currCorner*2;
      if ( currCorner.sizeX()>maxX ) currCorner.sizeX()=maxX;
      if ( currCorner.sizeY()>maxY ) currCorner.sizeY()=maxY;
      subWindowListAnim currTrackedFeat =
	trackFeatures( srcFrame, currCorner );
      corners_[srcFrame].delSubWindow(i);
      if ( currTrackedFeat.getLength()>minFeatureTrackLen )
      {
	for ( i=currTrackedFeat.getInterval().getStart();
	      i<=currTrackedFeat.getInterval().getEnd(); i++ )
	{
	  if ( currTrackedFeat.getSubWindow(i).sizeX() > maxX )
	    currTrackedFeat.getSubWindow(i).sizeX()=maxX;
	  if ( currTrackedFeat.getSubWindow(i).sizeY() > maxY )
	    currTrackedFeat.getSubWindow(i).sizeY()=maxY;
	}
	features.push_back(currTrackedFeat);
	if ( showingPercent() )
	{
	  updatePercent( estimatePercent( minNumFeaturesPerFrm,
					  features, numFrames_ ) );
	}
      }
    }
  }
  
  endProgressBar();
  return features;
}

subWindowListAnim
featureCorrelator::trackFeatures( int srcFrame, 
				  const subWindow &src )
{
  int initSearchWin = (getWidth()>getHeight()) ? getWidth() : getHeight();
  initSearchWin = rint(initSearchWin * 0.1f);
  int secdSearchWin = rint(initSearchWin/1.5f);
  
  int bestX, bestY;
  float minAcceptCorrel = 0.95f;
  int currSrcX = src.centerX();
  int currSrcY = src.centerY();
  int sizeX = src.sizeX()/2;
  int sizeY = src.sizeY()/2;
  bool findFirst = true;
  int dX, dY;

  subWindowListAnim retList;
  retList.addSubWindow( srcFrame, src );

  for ( int frm=srcFrame-1; frm>=0; frm-- )
  {
    if ( findFirst )
    {
      if ( !findNearestCorrel( frm+1, frm,
			       currSrcX, currSrcY, sizeX, sizeY, 0, 0,
			       initSearchWin, initSearchWin, minAcceptCorrel,
			       bestX, bestY ) )
	break;
      findFirst=false;
    }
    else
    {
      dX = currSrcX-retList[frm+2].centerX();
      dY = currSrcY-retList[frm+2].centerY();
      if ( !findNearestCorrel( frm+1, frm,
			       currSrcX, currSrcY, sizeX, sizeY, dX, dY,
			       secdSearchWin, secdSearchWin, minAcceptCorrel,
			       bestX, bestY ) )
	break;
    }

    retList.addSubWindow( frm,
			  subWindow(bestX, bestY, src.sizeX(), src.sizeY() ) );

    currSrcX = bestX;
    currSrcY = bestY;
  }
  
  currSrcX = src.centerX();
  currSrcY = src.centerY();
  for ( frm=srcFrame+1; frm<getNumFrames(); frm++ )
  {
    if ( findFirst )
    {
      if ( !findNearestCorrel( frm-1, frm,
			       currSrcX, currSrcY, sizeX, sizeY, 0, 0,
			       initSearchWin, initSearchWin, minAcceptCorrel,
			       bestX, bestY ) )
	break;
      findFirst=false;
    }
    else
    {
      dX = currSrcX-retList[frm-2].centerX();
      dY = currSrcY-retList[frm-2].centerY();
      if ( !findNearestCorrel( frm-1, frm,
			       currSrcX, currSrcY, sizeX, sizeY, dX, dY,
			       secdSearchWin, secdSearchWin, minAcceptCorrel,
			       bestX, bestY ) )
	break;
    }

    retList.addSubWindow( frm,
			  subWindow(bestX, bestY, src.sizeX(), src.sizeY() ) );

    currSrcX = bestX;
    currSrcY = bestY;
  }

  return retList;
}
		    
bool
featureCorrelator::findNearestCorrel( int srcFrame, int othFrame,
				      int srcX, int srcY, int sizeX, int sizeY,
				      int deltaX, int deltaY,
				      int searchWinX, int searchWinY,
				      float minAcceptCorrel,
				      int &bestX, int &bestY )
{
  int srcULX = srcX-sizeX;
  int srcULY = srcY-sizeY;
  int srcLRX = srcX+sizeX;
  int srcLRY = srcY+sizeY;
  int winSizeX = searchWinX/2;
  int winSizeY = searchWinY/2;

  float correl, bestCorrel = -FLT_MAX;
  setCorrelationSrc( srcFrame, srcULX, srcULY, srcLRX, srcLRY );
  for ( int y=-winSizeY; y<winSizeY; y++ )
  {
    for ( int x=-winSizeX; x<winSizeX; x++ )
    {
      correl = correlateWith( othFrame, deltaX+x, deltaY+y );
      if ( correl>bestCorrel )
      {
	bestCorrel=correl;
	bestX=srcX+deltaX+x;
	bestY=srcY+deltaY+y;
      }
    }
  }

  if ( bestCorrel<minAcceptCorrel )
  {
    bestX=-1;
    bestY=-1;
    return false;
  }
    
  srcULX = bestX-sizeX;
  srcULY = bestY-sizeY;
  srcLRX = bestX+sizeX;
  srcLRY = bestY+sizeY;

  deltaX = bestX-srcX;
  deltaY = bestY-srcY;
  winSizeX /= 2;
  winSizeY /= 2;
  
  int reverseX, reverseY;
    
  bestCorrel = -FLT_MAX;
  setCorrelationSrc( othFrame, srcULX, srcULY, srcLRX, srcLRY );
  for ( y=-winSizeY; y<winSizeY; y++ )
  {
    for ( int x=-winSizeX; x<winSizeX; x++ )
    {
      correl = correlateWith( srcFrame, -deltaX+x, -deltaY+y );
      if ( correl>bestCorrel )
      {
	bestCorrel=correl;
	reverseX=bestX-deltaX+x;
	reverseY=bestY-deltaY+y;
      }
    }
  }
  
  if ( (abs(reverseX-srcX)>1) || (abs(reverseY-srcY)>1) )
  {
    bestX *= -1;
    bestY *= -1;
    return false;
  }

  return true;
}

float 
featureCorrelator::estimatePercent( int minNumFeats,
				    const vector<subWindowListAnim> &trackedList,
				    int length )
{
  int totNumFeats=0;
  int currNumFeats;
  for ( int i=0; i<length; i++ )
  {
    currNumFeats = numFeatsAtFrame(i,trackedList);
    totNumFeats += (currNumFeats>=minNumFeats) ? minNumFeats : currNumFeats;
  }

  float percentFound = (float)totNumFeats/(float)(length*minNumFeats);
  return percentFound*percentFound;
  return ( sqrtf( percentFound*0.3f+0.7f ) - 0.835f ) / 0.165f;
}
featureCorrelator.C
Page URL
File URL
Prev 7/50 Next
Download ( 8 KB )
Comments
Total ratings:
Average rating:
Page 0 of total 0 pages
Would you like to comment?

Join DriveHQ for a free account, or Logon if you are already a member.