//-------------------------------------------------------------------
klt_tracker_t::~klt_tracker_t()
{
KLTFreeFeatureList(fl_);
KLTFreeTrackingContext(tc_);
delete [] img_pre_;
//delete [] img_post_;
}
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));
}
}
}
KLTTracker::~KLTTracker() {
if (tCtx != nullptr) {
KLTFreeTrackingContext(tCtx);
}
if (curFL != nullptr) {
KLTFreeFeatureList(curFL);
}
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
/** ============================================================================
* @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 ;
}