static

void icvGetNextFromBackgroundData( CvBackgroundData* data,

 CvBackgroundReader* reader )

{

IplImage* img = NULL;

size_t datasize = 0;

int round = 0;

int i = 0;

CvPoint offset = cvPoint(0,0);

assert( data != NULL && reader != NULL );

if( reader->src.data.ptr != NULL )

{

cvFree( &(reader->src.data.ptr) );

reader->src.data.ptr = NULL;

}

if( reader->img.data.ptr != NULL )

{

cvFree( &(reader->img.data.ptr) );

reader->img.data.ptr = NULL;

}

#ifdef CV_OPENMP

#pragma omp critical(c_background_data)

#endif /* CV_OPENMP */

{

for( i = 0; i < data->count; i++ )

{

round = data->round;

//#ifdef CV_VERBOSE

//            printf( "Open background image: %s\n", data->filename[data->last] );

//#endif /* CV_VERBOSE */

// original code

/*

data->last = rand() % data->count;

data->last %= data->count;

img = cvLoadImage( data->filename[data->last], 0 );

if( !img )

continue;

data->round += data->last / data->count;

data->round = data->round % (data->winsize.width * data->winsize.height);

*/

//*** begin (modified code by dark)

img = cvLoadImage( data->filename[data->last++], 0 );

if( !img )

continue;

if( img->height<data->winsize.height || img->width < data->winsize.width )

continue;

data->round += data->last / data->count;

data->round = data->round % (data->winsize.width * data->winsize.height);

data->last %= data->count;

//*** end

offset.x = round % data->winsize.width;

offset.y = round / data->winsize.width;

offset.x = MIN( offset.x, img->width - data->winsize.width );

offset.y = MIN( offset.y, img->height - data->winsize.height );

if( img != NULL && img->depth == IPL_DEPTH_8U && img->nChannels == 1 &&

offset.x >= 0 && offset.y >= 0 )

{

break;

}

if( img != NULL )

cvReleaseImage( &img );

img = NULL;

}

}

if( img == NULL )

{

/* no appropriate image */

#ifdef CV_VERBOSE

printf( "Invalid background description file.\n" );

#endif /* CV_VERBOSE */

assert( 0 );

exit( 1 );

}

datasize = sizeof( uchar ) * img->width * img->height;

reader->src = cvMat( img->height, img->width, CV_8UC1, (void*) cvAlloc( datasize ) );

cvCopy( img, &reader->src, NULL );

cvReleaseImage( &img );

img = NULL;

//reader->offset.x = round % data->winsize.width;

//reader->offset.y = round / data->winsize.width;

reader->offset = offset;

reader->point = reader->offset;

reader->scale = MAX(

((float) data->winsize.width + reader->point.x) / ((float) reader->src.cols),

((float) data->winsize.height + reader->point.y) / ((float) reader->src.rows) );

reader->img = cvMat( (int) (reader->scale * reader->src.rows + 0.5F),

(int) (reader->scale * reader->src.cols + 0.5F),

CV_8UC1, (void*) cvAlloc( datasize ) );

cvResize( &(reader->src), &(reader->img) );

}

static

int icvGetHaarTrainingData( CvHaarTrainingData* data, int first, int count,

  CvIntHaarClassifier* cascade,

  CvGetHaarTrainingDataCallback callback, void* userdata,

  int* consumed, double* acceptance_ratio )

{

int i = 0;

ccounter_t getcount = 0;

ccounter_t thread_getcount = 0;

ccounter_t consumed_count;

ccounter_t thread_consumed_count;

/* private variables */

CvMat img;

CvMat sum;

CvMat tilted;

CvMat sqsum;

sum_type* sumdata;

sum_type* tilteddata;

float*    normfactor;

/* end private variables */

assert( data != NULL );

assert( first + count <= data->maxnum );

assert( cascade != NULL );

assert( callback != NULL );

// if( !cvbgdata ) return 0; this check needs to be done in the callback for BG

CCOUNTER_SET_ZERO(getcount);

CCOUNTER_SET_ZERO(thread_getcount);

CCOUNTER_SET_ZERO(consumed_count);

CCOUNTER_SET_ZERO(thread_consumed_count);

#ifdef CV_OPENMP

#pragma omp parallel private(img, sum, tilted, sqsum, sumdata, tilteddata, \

normfactor, thread_consumed_count, thread_getcount)

#endif /* CV_OPENMP */

{

sumdata    = NULL;

tilteddata = NULL;

normfactor = NULL;

CCOUNTER_SET_ZERO(thread_getcount);

CCOUNTER_SET_ZERO(thread_consumed_count);

int ok = 1;

img = cvMat( data->winsize.height, data->winsize.width, CV_8UC1,

cvAlloc( sizeof( uchar ) * data->winsize.height * data->winsize.width ) );

sum = cvMat( data->winsize.height + 1, data->winsize.width + 1,

CV_SUM_MAT_TYPE, NULL );

tilted = cvMat( data->winsize.height + 1, data->winsize.width + 1,

CV_SUM_MAT_TYPE, NULL );

sqsum = cvMat( data->winsize.height + 1, data->winsize.width + 1, CV_SQSUM_MAT_TYPE,

cvAlloc( sizeof( sqsum_type ) * (data->winsize.height + 1)

* (data->winsize.width + 1) ) );

//*** begin (prevent infinit loop)

int start_neg_index = cvbgdata->round * cvbgdata->count + cvbgdata->last;

bool neg_updated = false;

//*** end

#ifdef CV_OPENMP

#pragma omp for schedule(static, 1)

#endif /* CV_OPENMP */

for( i = first; (i < first + count); i++ )

{

if( !ok )

continue;

for( ; ; )

{

//*** prevent infinite loop

int neg_index = cvbgdata->round * cvbgdata->count + cvbgdata->last;

if(neg_index!=start_neg_index)

neg_updated = true;

if(neg_updated && neg_index==start_neg_index)

{

i = first + count - 1;

break;

}

//*** end

ok = callback( &img, userdata );

if( !ok )

break;

CCOUNTER_INC(thread_consumed_count);

sumdata = (sum_type*) (data->sum.data.ptr + i * data->sum.step);

tilteddata = (sum_type*) (data->tilted.data.ptr + i * data->tilted.step);

normfactor = data->normfactor.data.fl + i;

sum.data.ptr = (uchar*) sumdata;

tilted.data.ptr = (uchar*) tilteddata;

icvGetAuxImages( &img, &sum, &tilted, &sqsum, normfactor );

if( cascade->eval( cascade, sumdata, tilteddata, *normfactor ) != 0.0F )

{

CCOUNTER_INC(thread_getcount);

break;

}

}

#ifdef CV_VERBOSE

if( (i - first) % 500 == 0 )

{

fprintf( stderr, "%3d%%\r", (int) ( 100.0 * (i - first) / count ) );

fflush( stderr );

}

#endif /* CV_VERBOSE */

}

cvFree( &(img.data.ptr) );

cvFree( &(sqsum.data.ptr) );

#ifdef CV_OPENMP

#pragma omp critical (c_consumed_count)

#endif /* CV_OPENMP */

{

/* consumed_count += thread_consumed_count; */

CCOUNTER_ADD(getcount, thread_getcount);

CCOUNTER_ADD(consumed_count, thread_consumed_count);

}

} /* omp parallel */

if( consumed != NULL )

{

*consumed = (int)consumed_count;

}

if( acceptance_ratio != NULL )

{

/* *acceptance_ratio = ((double) count) / consumed_count; */

*acceptance_ratio = CCOUNTER_DIV(count, consumed_count);

}

return static_cast<int>(getcount);

}

class CvCascadeImageReader

{

public:

bool create( const String _posFilename, const String _negFilename, Size _winSize );

void restart() { posReader.restart(); }

bool getNeg(Mat &_img) { return negReader.get( _img ); }

bool getPos(Mat &_img) { return posReader.get( _img ); }

//*** begin (prevent infinit loop)

int getNegIndex()

{

size_t count = negReader.imgFilenames.size();

return negReader.round*count + negReader.last;

}

//*** end

private:

class PosReader

{

public:

PosReader();

virtual ~PosReader();

bool create( const String _filename );

bool get( Mat &_img );

void restart();

short* vec;

FILE*  file;

int    count;

int    vecSize;

int    last;

int    base;

} posReader;

class NegReader

{

public:

NegReader();

bool create( const String _filename, Size _winSize );

bool get( Mat& _img );

bool nextImg();

Mat     src, img;

vector<String> imgFilenames;

Point   offset, point;

float   scale;

float   scaleFactor;

float   stepFactor;

size_t  last, round;

Size    winSize;

} negReader;

};

int CvCascadeClassifier::fillPassedSamples( int first, int count, bool isPositive, int64& consumed )

{

//*** begin (prevent infinit loop)

int start_neg_index = imgReader.getNegIndex();

bool neg_updated = false;

//*** end

int getcount = 0;

Mat img(cascadeParams.winSize, CV_8UC1);

for( int i = first; i < first + count; i++ )

{

// if(i%10==0) cout << i-first << "/" << count << "[" << imgReader.getNegCount() << "]" << endl;

for( ; ; )

{

//*** prevent infinite loop

int neg_index = imgReader.getNegIndex();

if(neg_index!=start_neg_index)

neg_updated = true;

if(neg_updated && neg_index==start_neg_index)

return getcount;

//*** end

bool isGetImg = isPositive ? imgReader.getPos( img ) :

imgReader.getNeg( img );

if( !isGetImg )

return getcount;

consumed++;

featureEvaluator->setImage( img, isPositive ? 1 : 0, i );

if( predict( i ) == 1.0F )

{

getcount++;

break;

}

}

}

return getcount;

}