Пример #1
0
//-------------------------------------------------------------------
  klt_tracker_t::~klt_tracker_t()
  {
    KLTFreeFeatureList(fl_);
    KLTFreeTrackingContext(tc_);
    delete [] img_pre_; 
    //delete [] img_post_;
  }
Пример #2
0
void KLTTracker::init(
        const CImg<uint8_t>& img,
        int numFeatures) {
    tracks.clear();
    
    if (tCtx != nullptr) {
        KLTFreeTrackingContext(tCtx);
    }
    
    tCtx = KLTCreateTrackingContext();

    if (curFL != nullptr) {
        KLTFreeFeatureList(curFL);
    }

    curFL = KLTCreateFeatureList(numFeatures);

    KLTSelectGoodFeatures(tCtx, const_cast<uint8_t*>(img.data()),
            img.width(), img.height(), curFL);

    tracks.resize(curFL->nFeatures);

    for (int i = 0; i < curFL->nFeatures; i++) {
        const auto& f = curFL->feature[i];

        if (f->val >= 0) {
            tracks[i].push_back(Eigen::Vector2f(f->x, f->y));
        }
    }
}
Пример #3
0
KLTTracker::~KLTTracker() {
    if (tCtx != nullptr) {
        KLTFreeTrackingContext(tCtx);
    }

    if (curFL != nullptr) {
        KLTFreeFeatureList(curFL);
    }
}
Пример #4
0
int main()
#endif
{
  unsigned char *img1, *img2;
  char fnamein[100], fnameout[100];
  KLT_TrackingContext tc;
  KLT_FeatureList fl;
  KLT_FeatureTable ft;
  int nFeatures = 150, nFrames = 10;
  int ncols, nrows;
  int i;

  tc = KLTCreateTrackingContext();
  fl = KLTCreateFeatureList(nFeatures);
  ft = KLTCreateFeatureTable(nFrames, nFeatures);
  tc->sequentialMode = TRUE;
  tc->writeInternalImages = FALSE;
  tc->affineConsistencyCheck = -1;  /* set this to 2 to turn on affine consistency check */
 
  img1 = pgmReadFile("img0.pgm", NULL, &ncols, &nrows);
  img2 = (unsigned char *) malloc(ncols*nrows*sizeof(unsigned char));

  KLTSelectGoodFeatures(tc, img1, ncols, nrows, fl);
  KLTStoreFeatureList(fl, ft, 0);
  KLTWriteFeatureListToPPM(fl, img1, ncols, nrows, "feat0.ppm");

  for (i = 1 ; i < nFrames ; i++)  {
    sprintf(fnamein, "img%d.pgm", i);
    pgmReadFile(fnamein, img2, &ncols, &nrows);
    KLTTrackFeatures(tc, img1, img2, ncols, nrows, fl);
#ifdef REPLACE
    KLTReplaceLostFeatures(tc, img2, ncols, nrows, fl);
#endif
    KLTStoreFeatureList(fl, ft, i);
    sprintf(fnameout, "feat%d.ppm", i);
    KLTWriteFeatureListToPPM(fl, img2, ncols, nrows, fnameout);
  }
  KLTWriteFeatureTable(ft, "features.txt", "%5.1f");
  KLTWriteFeatureTable(ft, "features.ft", NULL);

  KLTFreeFeatureTable(ft);
  KLTFreeFeatureList(fl);
  KLTFreeTrackingContext(tc);
  free(img1);
  free(img2);

  return 0;
}
Пример #5
0
int main( int argc, const char* argv[] )
{
  unsigned char *img1, *img2;
  KLT_TrackingContext tc;
  KLT_FeatureList fl;
  //KLT_FeatureTable ft;
  int ncols, nrows;
  int i, j;
  FILE *fp;

  int nFeatures = 430;
  int sFrame = 0;
  int eFrame = 0;
  char *fmt  = "%d";
  char *base;
  char fname[1024];
  char ffmt[1024];

  if( argc == 1 ) {
    printf( "Usage: %s  <basename_of_pgm_files>"
            "  [-fmt <pgm_sequence_format = %s>]"
	    "  [-ef <index_of_end_frame = %d>]"
	    "  [-np <#_of_tracking_points = %d>]"
	    "  [-sf <index_of_start_frame = %d>]\n"
	    "Ex) %s ../hotel/hotel.seq -fmt %%d -ef 100 -np 430 -sf 0\n"
	    "Ex) %s ../castle/castle. -fmt %%03d -ef 27 -np 110 -sf 0\n"
	    "Ex) %s ../medusa/medusa -fmt %%03d -sf 110 -ef 180 -np 830\n",
	    argv[0], fmt, eFrame, nFeatures, sFrame, argv[0], argv[0], argv[0] );
    return 0;
  }
  for( i = 1; i < argc; ++i ) {
    if( !strcmp( argv[i], "-sf" ) ) {
      sFrame = atoi( argv[++i] );
    } 
    else if( !strcmp( argv[i], "-ef" ) ) {
      eFrame = atoi( argv[++i] );
    } 
    else if( !strcmp( argv[i], "-np" ) ) {
      nFeatures = atoi( argv[++i] );
    } 
    else if( !strcmp( argv[i], "-fmt" ) ) {
      fmt = (char *)argv[++i];
    } 
    else {
      base = (char *)argv[i];
    }
  }
  sprintf(ffmt, "%%s%s%%s\0", fmt);
  
  tc = KLTCreateTrackingContext();
  tc->mindist = 15; // See klt.c for default values
  tc->window_width  = 50; 
  tc->window_height = 50;
  tc->max_residue = 30;
  tc->min_determinant = 0.001;
  //tc->min_eigenvalue = 3;
  //tc->borderx = 50;
  //tc->bordery = 50;
  //tc->affine_window_width = 51;
  //tc->affine_window_height = 51;
  KLTChangeTCPyramid(tc, 15);
  KLTUpdateTCBorder(tc);
  KLTPrintTrackingContext(tc);

  fl = KLTCreateFeatureList(nFeatures);
  //ft = KLTCreateFeatureTable(nFrames, nFeatures);
  tc->sequentialMode = TRUE;
  tc->writeInternalImages = FALSE;
  tc->affineConsistencyCheck = -1;  /* set this to 2 to turn on affine consistency check */

  i = sFrame;
  sprintf(fname, ffmt, base, i, ".pgm");
  img1 = pgmReadFile(fname, NULL, &ncols, &nrows);
  KLTSelectGoodFeatures(tc, img1, ncols, nrows, fl);
  // write
  sprintf(fname, ffmt, base, i, ".feat.ppm");   /* ppm file    */
  KLTWriteFeatureListToPPM(fl, img1, ncols, nrows, fname);
  //sprintf(fname, ffmt, base, i, ".feat.fl");  /* binary file */
  //KLTWriteFeatureList(fl, fname, NULL);
  sprintf(fname, ffmt, base, i, ".feat.txt");   /* text file   */
  //KLTWriteFeatureList(fl, fname, "%5.1f");
  MyKLTWriteFeatureList(fl, fname);
  
  for (i = sFrame+1; i <= eFrame; i++) {
    sprintf(fname, ffmt, base, i, ".pgm");
    img2 = pgmReadFile(fname, NULL, &ncols, &nrows);
    KLTTrackFeatures(tc, img1, img2, ncols, nrows, fl);
#ifdef REPLACE
    KLTReplaceLostFeatures(tc, img2, ncols, nrows, fl);
#endif

    // write
    sprintf(fname, ffmt, base, i, ".feat.ppm");   /* ppm file    */
    KLTWriteFeatureListToPPM(fl, img1, ncols, nrows, fname);
    //sprintf(fname, ffmt, base, i, ".feat.fl");  /* binary file */
    //KLTWriteFeatureList(fl, fname, NULL);
    sprintf(fname, ffmt, base, i, ".feat.txt");   /* text file   */
    //KLTWriteFeatureList(fl, fname, "%5.1f");
    MyKLTWriteFeatureList(fl, fname);

    img1 = img2;
  }
 
  sprintf(fname, ffmt, base, eFrame, ".feat.ppm");
  KLTWriteFeatureListToPPM(fl, img1, ncols, nrows, fname);

  //KLTFreeFeatureTable(ft);
  KLTFreeFeatureList(fl);
  KLTFreeTrackingContext(tc);
  free(img1);
  //free(img2);
  return 0;
}
Пример #6
0
int main(int argc, char ** argv)
{
    //Timer appTimer;
    //initTimer(&appTimer, "APP Time");

    unsigned char *img1, *img2;
    char fnamein[100], fnameout[100];
    KLT_TrackingContext tc;
    KLT_FeatureList fl;
    KLT_FeatureTable ft;
    int nFeatures;
    int nFrames;
    int ncols, nrows;
    int i;

    if(argc == 3)
    {
        nFeatures = atoi(argv[1]);
        nFrames = atoi(argv[2]);
    }
    else
    {
        nFeatures = 512;
        nFrames = 10;
    }

    tc = KLTCreateTrackingContext();
    fl = KLTCreateFeatureList(nFeatures);
    ft = KLTCreateFeatureTable(nFrames, nFeatures);
    tc->sequentialMode = TRUE;
    tc->writeInternalImages = FALSE;
    tc->affineConsistencyCheck = -1;  /* set this to 2 to turn on affine consistency check */

    //startTimer(&appTimer);
    img1 = pgmReadFile("img0.pgm", NULL, &ncols, &nrows);
    img2 = (unsigned char *) malloc(ncols*nrows*sizeof(unsigned char));

    KLTSelectGoodFeatures(tc, img1, ncols, nrows, fl);
    KLTStoreFeatureList(fl, ft, 0);
    KLTWriteFeatureListToPPM(fl, img1, ncols, nrows, "feat0.ppm");

    for (i = 1 ; i < nFrames ; i++)
    {
        sprintf(fnamein, "img%d.pgm", i);
        pgmReadFile(fnamein, img2, &ncols, &nrows);
        KLTTrackFeatures(tc, img1, img2, ncols, nrows, fl);

        #ifdef REPLACE
        KLTReplaceLostFeatures(tc, img2, ncols, nrows, fl);
        #endif

        KLTStoreFeatureList(fl, ft, i);
        sprintf(fnameout, "feat%d.ppm", i);
        KLTWriteFeatureListToPPM(fl, img2, ncols, nrows, fnameout);
    }
    //stopTimer(&appTimer);
    //printTime(appTimer);
    //printf("Frames per second = %4.2f\n", nFrames / getTime(appTimer) *1000 );

    KLTWriteFeatureTable(ft, "features.txt", "%5.1f");
    KLTWriteFeatureTable(ft, "features.ft", NULL);

    KLTFreeFeatureTable(ft);
    KLTFreeFeatureList(fl);
    KLTFreeTrackingContext(tc);
    free(img1);
    free(img2);

    return 0;
}
Пример #7
0
FeatureVector *KLTFeatureRetrievalGrey(unsigned char **GreyArray,int nCols,int nRows, int nFrames,int nFeatures)
{
  unsigned char *img1, *img2;
  FeatureVector *host_feature;
  int i,j;

  KLT_TrackingContext tc;
  KLT_FeatureList fl;
  KLT_FeatureTable ft;

  if (nFrames < 2) return NULL;
  if (nFeatures < 3) return NULL;

  host_feature = new FeatureVector[nFrames];
  for (i=0;i<nFrames;i++) host_feature[i].Create(nFeatures);

  img1 = &(GreyArray[0][0]);

  tc = KLTCreateTrackingContext();
  fl = KLTCreateFeatureList(nFeatures);
  ft = KLTCreateFeatureTable(nFrames, nFeatures);

  tc->sequentialMode = TRUE;
  tc->writeInternalImages = FALSE;
  tc->affineConsistencyCheck = -1;  /* set this to 2 to turn on affine consistency check */

  KLTSelectGoodFeatures(tc, img1, nCols, nRows, fl);
  KLTStoreFeatureList(fl, ft, 0);

//  KLTWriteFeatureListToPPM(fl, img1, nCols, nRows, "feat0.ppm");

  for (i = 1 ; i < nFrames ; i++)  {
//    sprintf(fnamein, "img%d.pgm", i);
	img2 = &(GreyArray[i][0]);
    KLTTrackFeatures(tc, img1, img2, nCols, nRows, fl);
//    KLTReplaceLostFeatures(tc, img2, ncols, nrows, fl);
    KLTStoreFeatureList(fl, ft, i);
//    sprintf(fnameout, "feat%d.ppm", i);
//    KLTWriteFeatureListToPPM(fl, img2, nCols, nRows, fnameout);
  }
//  KLTWriteFeatureTable(ft, "features.txt", "%5.1f");
//  KLTWriteFeatureTable(ft, "features.ft", NULL);

    for (j = 0 ; j < ft->nFeatures ; j++)  
	{
      for (i = 0 ; i < ft->nFrames ; i++)
	  {
		host_feature[i].vertex[j][0] = ft->feature[j][i]->x;
		host_feature[i].vertex[j][1] = ft->feature[j][i]->y;
		if (ft->feature[j][i]->val>=0) host_feature[i].isValid[j] = 1;
			else host_feature[i].isValid[j] = ft->feature[j][i]->val;
		
	  }
    }  

  KLTFreeFeatureTable(ft);
  KLTFreeFeatureList(fl);
  KLTFreeTrackingContext(tc);
  
  return host_feature;
}
Пример #8
0
FeatureVector *KLTFeatureRetrievalListMin(IMGList *RGBImgList,int nCols,int nRows, int nFrames,int nFeatures,int nMinFeatures)
{
  unsigned char *img1, *img2;
  IMGList *pImg,*GreyArray=NULL,**GreyArryTable;
  FeatureVector *host_feature;
  int i,j,nFeatCount,maxID;

  KLT_TrackingContext tc;
  KLT_FeatureList fl,fl_pre;
  KLT_FeatureTable ft;

  if (nFrames < 2) return NULL;
  if (nFeatures < 3) return NULL;
  if (!RGBImgList) return NULL;
  if (nFeatures<nMinFeatures) return NULL;


  host_feature = new FeatureVector[nFrames];
  for (i=0;i<nFrames;i++) host_feature[i].Create(nFeatures);

  GreyArryTable = new IMGList*[nFrames];

  pImg = RGBImgList;
  for (i=0;i<nFrames;i++)
  {
	  GreyArray = new IMGList(nCols,nRows,1);
	  GreyArryTable[i] = GreyArray;
	  _RGB_ToGray(pImg->Img,GreyArryTable[i]->Img,nCols*nRows);
	  GO_NEXT(pImg);
  }


  tc = KLTCreateTrackingContext();
  fl = KLTCreateFeatureList(nFeatures);
  fl_pre = KLTCreateFeatureList(nFeatures);
  ft = KLTCreateFeatureTable(nFrames, nFeatures);
	  
  	  img1 = GreyArryTable[0]->Img;

	  tc->sequentialMode = TRUE;
	  tc->writeInternalImages = FALSE;
	  tc->affineConsistencyCheck = -1;  /* set this to 2 to turn on affine consistency check */

	  KLTSelectGoodFeatures(tc, img1, nCols, nRows, fl);
	  KLTStoreFeatureList(fl, ft, 0);

	  for (i = 1; i < nFrames ; i++)  
	  {
		img2 = GreyArryTable[i]->Img;
		
		printf("Tracking %dth frame\n",i);
		KLTTrackFeatures(tc, img1, img2, nCols, nRows, fl);
		
		nFeatCount = 0;
		for (j=0;j<fl->nFeatures;j++)
			if (fl->feature[j]->val>=0) nFeatCount++;

		if (nFeatCount<nMinFeatures)
		{
			for (j=0;j<fl->nFeatures;j++)
				if (fl->feature[j]->val<0) 
					host_feature[i].isValid[j] = 13083;

			KLTReplaceLostFeatures(tc, img2, nCols, nRows, fl);
			KLTStoreFeatureList(fl, ft, i);
		}
		else
			KLTStoreFeatureList(fl, ft, i);
	  }

	  maxID = 0;
	  for (j = 0 ; j < ft->nFeatures ; j++)  
	  {
		  for (i=0;i<nFrames;i++)
		  {
				host_feature[i].vertex[j][0] = ft->feature[j][i]->x;
				host_feature[i].vertex[j][1] = ft->feature[j][i]->y;
				if (host_feature[i].isValid[j] ==13083) maxID++;
				if (ft->feature[j][i]->val>=0) 
				{
					host_feature[i].isValid[j] = maxID;
					if (i==nFrames-1)  {
						maxID++; 
						printf("Boundary ID = %d\n",maxID);
						continue;}
				}
				else 
				{
					host_feature[i].isValid[j] = ft->feature[j][i]->val;
					if (i>0)
					{
						if (ft->feature[j][i-1]->val>=0)
						{
								maxID++;
								printf("Internal ID = %d\n",maxID);
						}
					}
				}
		  }
	  }

	  KLTFreeFeatureTable(ft);
	  KLTFreeFeatureList(fl);
	  KLTFreeFeatureList(fl_pre);
	  KLTFreeTrackingContext(tc);

  for (i=0;i<nFrames;i++)
  {
	  pImg = GreyArryTable[i];
	  delete pImg;
  }
  delete[] GreyArryTable;

  return host_feature;
}
Пример #9
0
FeatureVector *KLTFeatureRetrievalList(IMGList *RGBImgList,int nCols,int nRows, int nFrames,int nFeatures)
{
  unsigned char *img1, *img2;
  IMGList *pImg,*GreyArray=NULL,**GreyArryTable;
  FeatureVector *host_feature;
  int i,j;

  KLT_TrackingContext tc;
  KLT_FeatureList fl;
  KLT_FeatureTable ft;

  if (nFrames < 2) return NULL;
  if (nFeatures < 3) return NULL;
  if (!RGBImgList) return NULL;
  

  host_feature = new FeatureVector[nFrames];
  for (i=0;i<nFrames;i++) host_feature[i].Create(nFeatures);


  GreyArryTable = new IMGList*[nFrames];

  pImg = RGBImgList;
  for (i=0;i<nFrames;i++)
  {
	  GreyArray = new IMGList(nCols,nRows,1);
	  GreyArryTable[i] = GreyArray;
	  _RGB_ToGray(pImg->Img,GreyArryTable[i]->Img,nCols*nRows);
	  GO_NEXT(pImg);
  }

  img1 = GreyArryTable[0]->Img;

  tc = KLTCreateTrackingContext();
  fl = KLTCreateFeatureList(nFeatures);
  ft = KLTCreateFeatureTable(nFrames, nFeatures);
  tc->sequentialMode = TRUE;
  tc->writeInternalImages = FALSE;
  tc->affineConsistencyCheck = -1;  /* set this to 2 to turn on affine consistency check */

  KLTSelectGoodFeatures(tc, img1, nCols, nRows, fl);
  KLTStoreFeatureList(fl, ft, 0);

//  KLTWriteFeatureListToPPM(fl, img1, nCols, nRows, "feat0.ppm");

  for (i = 1 ; i < nFrames ; i++)  {
//    sprintf(fnamein, "img%d.pgm", i);
	img2 = GreyArryTable[i]->Img;;
    KLTTrackFeatures(tc, img1, img2, nCols, nRows, fl);
//    KLTReplaceLostFeatures(tc, img2, ncols, nrows, fl);
    KLTStoreFeatureList(fl, ft, i);
//    sprintf(fnameout, "feat%d.ppm", i);
//    KLTWriteFeatureListToPPM(fl, img2, nCols, nRows, fnameout);
  }
//  KLTWriteFeatureTable(ft, "features.txt", "%5.1f");
//  KLTWriteFeatureTable(ft, "features.ft", NULL);

    for (j = 0 ; j < ft->nFeatures ; j++)  
	{
      for (i = 0 ; i < ft->nFrames ; i++)
	  {
		host_feature[i].vertex[j][0] = ft->feature[j][i]->x;
		host_feature[i].vertex[j][1] = ft->feature[j][i]->y;
		if (ft->feature[j][i]->val>=0) host_feature[i].isValid[j] = 1;
			else host_feature[i].isValid[j] = ft->feature[j][i]->val;
		
	  }
    }  

  KLTFreeFeatureTable(ft);
  KLTFreeFeatureList(fl);
  KLTFreeTrackingContext(tc);

  for (i=0;i<nFrames;i++)
  {
	  pImg = GreyArryTable[i];
	  delete pImg;
  }
  delete[] GreyArryTable;

  return host_feature;

}
Пример #10
0
/** ============================================================================
 *  @func   pool_notify_Execute
 *
 *  @desc   This function implements the execute phase for this application.
 *
 *  @modif  None
 *  ============================================================================
 */
NORMAL_API
DSP_STATUS
pool_notify_Execute (IN Uint32 numIterations, Uint8 processorId, IN Char8 * strFeatures, IN Char8 * strFrames)
{
    DSP_STATUS  status    = DSP_SOK ;

    long long start;
	
	// Variables for klt
    unsigned char *img1, *img2;
    char fnamein[100], fnameout[100];
    KLT_TrackingContext tc;
    KLT_FeatureList fl;
    KLT_FeatureTable ft;
    int ncols, nrows;
    int i;
    int nFeatures;
    int nFrames;


#if defined(DSP)
    unsigned char *buf_dsp;
#endif

#ifdef DEBUG
    printf ("Entered pool_notify_Execute ()\n") ;
#endif

    nFeatures = atoi(strFeatures);
    nFrames = atoi(strFrames);


    unit_init();

    start = get_usec();

	tc = KLTCreateTrackingContext();
    fl = KLTCreateFeatureList(nFeatures);
    ft = KLTCreateFeatureTable(nFrames, nFeatures);
    tc->sequentialMode = TRUE;
    tc->writeInternalImages = FALSE;
    tc->affineConsistencyCheck = -1;  /* set this to 2 to turn on affine consistency check */

    //startTimer(&appTimer);
    img1 = pgmReadFile("img0.pgm", NULL, &ncols, &nrows);
    img2 = (unsigned char *) malloc(ncols*nrows*sizeof(unsigned char));

    KLTSelectGoodFeatures(tc, img1, ncols, nrows, fl);
    KLTStoreFeatureList(fl, ft, 0);
    KLTWriteFeatureListToPPM(fl, img1, ncols, nrows, "feat0.ppm");

    for (i = 1 ; i < nFrames ; i++)
    {
        sprintf(fnamein, "img%d.pgm", i);
        pgmReadFile(fnamein, img2, &ncols, &nrows);
        KLTTrackFeatures(tc, img1, img2, ncols, nrows, fl);

        #ifdef REPLACE
        KLTReplaceLostFeatures(tc, img2, ncols, nrows, fl);
        #endif

        KLTStoreFeatureList(fl, ft, i);
        sprintf(fnameout, "feat%d.ppm", i);
        KLTWriteFeatureListToPPM(fl, img2, ncols, nrows, fnameout);
    }
    //stopTimer(&appTimer);
    //printTime(appTimer);
    //printf("Frames per second = %4.2f\n", nFrames / getTime(appTimer) *1000 );

    KLTWriteFeatureTable(ft, "features.txt", "%5.1f");
    KLTWriteFeatureTable(ft, "features.ft", NULL);

    KLTFreeFeatureTable(ft);
    KLTFreeFeatureList(fl);
    KLTFreeTrackingContext(tc);
    free(img1);
    free(img2);




#if !defined(DSP)
    printf(" Result is %d \n", sum_dsp(pool_notify_DataBuf,pool_notify_BufferSize));
#endif

#if defined(DSP)
    POOL_writeback (POOL_makePoolId(processorId, SAMPLE_POOL_ID),
                    pool_notify_DataBuf,
                    pool_notify_BufferSize);

    POOL_translateAddr ( POOL_makePoolId(processorId, SAMPLE_POOL_ID),
                         (void*)&buf_dsp,
                         AddrType_Dsp,
                         (Void *) pool_notify_DataBuf,
                         AddrType_Usr) ;
    NOTIFY_notify (processorId,pool_notify_IPS_ID,pool_notify_IPS_EVENTNO,1);

    sem_wait(&sem);
#endif

    printf("Sum execution time %lld us.\n", get_usec()-start);

    return status ;
}