--- /dev/null
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+// By downloading, copying, installing or using the software you agree to this license.
+// If you do not agree to this license, do not download, install,
+// copy or use the software.
+//
+//
+// Intel License Agreement
+// For Open Source Computer Vision Library
+//
+// Copyright (C) 2000, Intel Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+// * Redistribution's of source code must retain the above copyright notice,
+// this list of conditions and the following disclaimer.
+//
+// * Redistribution's in binary form must reproduce the above copyright notice,
+// this list of conditions and the following disclaimer in the documentation
+// and/or other materials provided with the distribution.
+//
+// * The name of Intel Corporation may not be used to endorse or promote products
+// derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+/*
+ * cvhaarclassifier.cpp
+ *
+ * haar classifiers (stump, CART, stage, cascade)
+ */
+
+#include "_cvhaartraining.h"
+
+
+CvIntHaarClassifier* icvCreateCARTHaarClassifier( int count )
+{
+ CvCARTHaarClassifier* cart;
+ size_t datasize;
+
+ datasize = sizeof( *cart ) +
+ ( sizeof( int ) +
+ sizeof( CvTHaarFeature ) + sizeof( CvFastHaarFeature ) +
+ sizeof( float ) + sizeof( int ) + sizeof( int ) ) * count +
+ sizeof( float ) * (count + 1);
+
+ cart = (CvCARTHaarClassifier*) cvAlloc( datasize );
+ memset( cart, 0, datasize );
+
+ cart->feature = (CvTHaarFeature*) (cart + 1);
+ cart->fastfeature = (CvFastHaarFeature*) (cart->feature + count);
+ cart->threshold = (float*) (cart->fastfeature + count);
+ cart->left = (int*) (cart->threshold + count);
+ cart->right = (int*) (cart->left + count);
+ cart->val = (float*) (cart->right + count);
+ cart->compidx = (int*) (cart->val + count + 1 );
+ cart->count = count;
+ cart->eval = icvEvalCARTHaarClassifier;
+ cart->save = icvSaveCARTHaarClassifier;
+ cart->release = icvReleaseHaarClassifier;
+
+ return (CvIntHaarClassifier*) cart;
+}
+
+
+void icvReleaseHaarClassifier( CvIntHaarClassifier** classifier )
+{
+ cvFree( classifier );
+ *classifier = NULL;
+}
+
+
+void icvInitCARTHaarClassifier( CvCARTHaarClassifier* carthaar, CvCARTClassifier* cart,
+ CvIntHaarFeatures* intHaarFeatures )
+{
+ int i;
+
+ for( i = 0; i < cart->count; i++ )
+ {
+ carthaar->feature[i] = intHaarFeatures->feature[cart->compidx[i]];
+ carthaar->fastfeature[i] = intHaarFeatures->fastfeature[cart->compidx[i]];
+ carthaar->threshold[i] = cart->threshold[i];
+ carthaar->left[i] = cart->left[i];
+ carthaar->right[i] = cart->right[i];
+ carthaar->val[i] = cart->val[i];
+ carthaar->compidx[i] = cart->compidx[i];
+ }
+ carthaar->count = cart->count;
+ carthaar->val[cart->count] = cart->val[cart->count];
+}
+
+
+float icvEvalCARTHaarClassifier( CvIntHaarClassifier* classifier,
+ sum_type* sum, sum_type* tilted, float normfactor )
+{
+ int idx = 0;
+
+ do
+ {
+ if( cvEvalFastHaarFeature(
+ ((CvCARTHaarClassifier*) classifier)->fastfeature + idx, sum, tilted )
+ < (((CvCARTHaarClassifier*) classifier)->threshold[idx] * normfactor) )
+ {
+ idx = ((CvCARTHaarClassifier*) classifier)->left[idx];
+ }
+ else
+ {
+ idx = ((CvCARTHaarClassifier*) classifier)->right[idx];
+ }
+ } while( idx > 0 );
+
+ return ((CvCARTHaarClassifier*) classifier)->val[-idx];
+}
+
+
+CvIntHaarClassifier* icvCreateStageHaarClassifier( int count, float threshold )
+{
+ CvStageHaarClassifier* stage;
+ size_t datasize;
+
+ datasize = sizeof( *stage ) + sizeof( CvIntHaarClassifier* ) * count;
+ stage = (CvStageHaarClassifier*) cvAlloc( datasize );
+ memset( stage, 0, datasize );
+
+ stage->count = count;
+ stage->threshold = threshold;
+ stage->classifier = (CvIntHaarClassifier**) (stage + 1);
+
+ stage->eval = icvEvalStageHaarClassifier;
+ stage->save = icvSaveStageHaarClassifier;
+ stage->release = icvReleaseStageHaarClassifier;
+
+ return (CvIntHaarClassifier*) stage;
+}
+
+
+void icvReleaseStageHaarClassifier( CvIntHaarClassifier** classifier )
+{
+ int i;
+
+ for( i = 0; i < ((CvStageHaarClassifier*) *classifier)->count; i++ )
+ {
+ if( ((CvStageHaarClassifier*) *classifier)->classifier[i] != NULL )
+ {
+ ((CvStageHaarClassifier*) *classifier)->classifier[i]->release(
+ &(((CvStageHaarClassifier*) *classifier)->classifier[i]) );
+ }
+ }
+
+ cvFree( classifier );
+ *classifier = NULL;
+}
+
+
+float icvEvalStageHaarClassifier( CvIntHaarClassifier* classifier,
+ sum_type* sum, sum_type* tilted, float normfactor )
+{
+ int i;
+ float stage_sum;
+
+ stage_sum = 0.0F;
+ for( i = 0; i < ((CvStageHaarClassifier*) classifier)->count; i++ )
+ {
+ stage_sum +=
+ ((CvStageHaarClassifier*) classifier)->classifier[i]->eval(
+ ((CvStageHaarClassifier*) classifier)->classifier[i],
+ sum, tilted, normfactor );
+ }
+
+ return stage_sum;
+}
+
+
+CvIntHaarClassifier* icvCreateCascadeHaarClassifier( int count )
+{
+ CvCascadeHaarClassifier* ptr;
+ size_t datasize;
+
+ datasize = sizeof( *ptr ) + sizeof( CvIntHaarClassifier* ) * count;
+ ptr = (CvCascadeHaarClassifier*) cvAlloc( datasize );
+ memset( ptr, 0, datasize );
+
+ ptr->count = count;
+ ptr->classifier = (CvIntHaarClassifier**) (ptr + 1);
+
+ ptr->eval = icvEvalCascadeHaarClassifier;
+ ptr->save = NULL;
+ ptr->release = icvReleaseCascadeHaarClassifier;
+
+ return (CvIntHaarClassifier*) ptr;
+}
+
+
+void icvReleaseCascadeHaarClassifier( CvIntHaarClassifier** classifier )
+{
+ int i;
+
+ for( i = 0; i < ((CvCascadeHaarClassifier*) *classifier)->count; i++ )
+ {
+ if( ((CvCascadeHaarClassifier*) *classifier)->classifier[i] != NULL )
+ {
+ ((CvCascadeHaarClassifier*) *classifier)->classifier[i]->release(
+ &(((CvCascadeHaarClassifier*) *classifier)->classifier[i]) );
+ }
+ }
+
+ cvFree( classifier );
+ *classifier = NULL;
+}
+
+
+float icvEvalCascadeHaarClassifier( CvIntHaarClassifier* classifier,
+ sum_type* sum, sum_type* tilted, float normfactor )
+{
+ int i;
+
+ for( i = 0; i < ((CvCascadeHaarClassifier*) classifier)->count; i++ )
+ {
+ if( ((CvCascadeHaarClassifier*) classifier)->classifier[i]->eval(
+ ((CvCascadeHaarClassifier*) classifier)->classifier[i],
+ sum, tilted, normfactor )
+ < ( ((CvStageHaarClassifier*)
+ ((CvCascadeHaarClassifier*) classifier)->classifier[i])->threshold
+ - CV_THRESHOLD_EPS) )
+ {
+ return 0.0;
+ }
+ }
+
+ return 1.0;
+}
+
+
+void icvSaveHaarFeature( CvTHaarFeature* feature, FILE* file )
+{
+ fprintf( file, "%d\n", ( ( feature->rect[2].weight == 0.0F ) ? 2 : 3) );
+ fprintf( file, "%d %d %d %d %d %d\n",
+ feature->rect[0].r.x,
+ feature->rect[0].r.y,
+ feature->rect[0].r.width,
+ feature->rect[0].r.height,
+ 0,
+ (int) (feature->rect[0].weight) );
+ fprintf( file, "%d %d %d %d %d %d\n",
+ feature->rect[1].r.x,
+ feature->rect[1].r.y,
+ feature->rect[1].r.width,
+ feature->rect[1].r.height,
+ 0,
+ (int) (feature->rect[1].weight) );
+ if( feature->rect[2].weight != 0.0F )
+ {
+ fprintf( file, "%d %d %d %d %d %d\n",
+ feature->rect[2].r.x,
+ feature->rect[2].r.y,
+ feature->rect[2].r.width,
+ feature->rect[2].r.height,
+ 0,
+ (int) (feature->rect[2].weight) );
+ }
+ fprintf( file, "%s\n", &(feature->desc[0]) );
+}
+
+
+void icvLoadHaarFeature( CvTHaarFeature* feature, FILE* file )
+{
+ int nrect;
+ int j;
+ int tmp;
+ int weight;
+
+ nrect = 0;
+ fscanf( file, "%d", &nrect );
+
+ assert( nrect <= CV_HAAR_FEATURE_MAX );
+
+ for( j = 0; j < nrect; j++ )
+ {
+ fscanf( file, "%d %d %d %d %d %d",
+ &(feature->rect[j].r.x),
+ &(feature->rect[j].r.y),
+ &(feature->rect[j].r.width),
+ &(feature->rect[j].r.height),
+ &tmp, &weight );
+ feature->rect[j].weight = (float) weight;
+ }
+ for( j = nrect; j < CV_HAAR_FEATURE_MAX; j++ )
+ {
+ feature->rect[j].r.x = 0;
+ feature->rect[j].r.y = 0;
+ feature->rect[j].r.width = 0;
+ feature->rect[j].r.height = 0;
+ feature->rect[j].weight = 0.0f;
+ }
+ fscanf( file, "%s", &(feature->desc[0]) );
+ feature->tilted = ( feature->desc[0] == 't' );
+}
+
+
+void icvSaveCARTHaarClassifier( CvIntHaarClassifier* classifier, FILE* file )
+{
+ int i;
+ int count;
+
+ count = ((CvCARTHaarClassifier*) classifier)->count;
+ fprintf( file, "%d\n", count );
+ for( i = 0; i < count; i++ )
+ {
+ icvSaveHaarFeature( &(((CvCARTHaarClassifier*) classifier)->feature[i]), file );
+ fprintf( file, "%e %d %d\n",
+ ((CvCARTHaarClassifier*) classifier)->threshold[i],
+ ((CvCARTHaarClassifier*) classifier)->left[i],
+ ((CvCARTHaarClassifier*) classifier)->right[i] );
+ }
+ for( i = 0; i <= count; i++ )
+ {
+ fprintf( file, "%e ", ((CvCARTHaarClassifier*) classifier)->val[i] );
+ }
+ fprintf( file, "\n" );
+}
+
+
+CvIntHaarClassifier* icvLoadCARTHaarClassifier( FILE* file, int step )
+{
+ CvCARTHaarClassifier* ptr;
+ int i;
+ int count;
+
+ ptr = NULL;
+ fscanf( file, "%d", &count );
+ if( count > 0 )
+ {
+ ptr = (CvCARTHaarClassifier*) icvCreateCARTHaarClassifier( count );
+ for( i = 0; i < count; i++ )
+ {
+ icvLoadHaarFeature( &(ptr->feature[i]), file );
+ fscanf( file, "%f %d %d", &(ptr->threshold[i]), &(ptr->left[i]),
+ &(ptr->right[i]) );
+ }
+ for( i = 0; i <= count; i++ )
+ {
+ fscanf( file, "%f", &(ptr->val[i]) );
+ }
+ icvConvertToFastHaarFeature( ptr->feature, ptr->fastfeature, ptr->count, step );
+ }
+
+ return (CvIntHaarClassifier*) ptr;
+}
+
+
+void icvSaveStageHaarClassifier( CvIntHaarClassifier* classifier, FILE* file )
+{
+ int count;
+ int i;
+ float threshold;
+
+ count = ((CvStageHaarClassifier*) classifier)->count;
+ fprintf( file, "%d\n", count );
+ for( i = 0; i < count; i++ )
+ {
+ ((CvStageHaarClassifier*) classifier)->classifier[i]->save(
+ ((CvStageHaarClassifier*) classifier)->classifier[i], file );
+ }
+
+ threshold = ((CvStageHaarClassifier*) classifier)->threshold;
+
+ /* to be compatible with the previous implementation */
+ /* threshold = 2.0F * ((CvStageHaarClassifier*) classifier)->threshold - count; */
+
+ fprintf( file, "%e\n", threshold );
+}
+
+
+
+CvIntHaarClassifier* icvLoadCARTStageHaarClassifierF( FILE* file, int step )
+{
+ CvStageHaarClassifier* ptr = NULL;
+
+ //CV_FUNCNAME( "icvLoadCARTStageHaarClassifierF" );
+
+ __BEGIN__;
+
+ if( file != NULL )
+ {
+ int count;
+ int i;
+ float threshold;
+
+ count = 0;
+ fscanf( file, "%d", &count );
+ if( count > 0 )
+ {
+ ptr = (CvStageHaarClassifier*) icvCreateStageHaarClassifier( count, 0.0F );
+ for( i = 0; i < count; i++ )
+ {
+ ptr->classifier[i] = icvLoadCARTHaarClassifier( file, step );
+ }
+
+ fscanf( file, "%f", &threshold );
+
+ ptr->threshold = threshold;
+ /* to be compatible with the previous implementation */
+ /* ptr->threshold = 0.5F * (threshold + count); */
+ }
+ if( feof( file ) )
+ {
+ ptr->release( (CvIntHaarClassifier**) &ptr );
+ ptr = NULL;
+ }
+ }
+
+ __END__;
+
+ return (CvIntHaarClassifier*) ptr;
+}
+
+
+CvIntHaarClassifier* icvLoadCARTStageHaarClassifier( const char* filename, int step )
+{
+ CvIntHaarClassifier* ptr = NULL;
+
+ CV_FUNCNAME( "icvLoadCARTStageHaarClassifier" );
+
+ __BEGIN__;
+
+ FILE* file;
+
+ file = fopen( filename, "r" );
+ if( file )
+ {
+ CV_CALL( ptr = icvLoadCARTStageHaarClassifierF( file, step ) );
+ fclose( file );
+ }
+
+ __END__;
+
+ return ptr;
+}
+
+/* tree cascade classifier */
+
+/* evaluates a tree cascade classifier */
+
+float icvEvalTreeCascadeClassifier( CvIntHaarClassifier* classifier,
+ sum_type* sum, sum_type* tilted, float normfactor )
+{
+ CvTreeCascadeNode* ptr;
+
+ ptr = ((CvTreeCascadeClassifier*) classifier)->root;
+
+ while( ptr )
+ {
+ if( ptr->stage->eval( (CvIntHaarClassifier*) ptr->stage,
+ sum, tilted, normfactor )
+ >= ptr->stage->threshold - CV_THRESHOLD_EPS )
+ {
+ ptr = ptr->child;
+ }
+ else
+ {
+ while( ptr && ptr->next == NULL ) ptr = ptr->parent;
+ if( ptr == NULL ) return 0.0F;
+ ptr = ptr->next;
+ }
+ }
+
+ return 1.0F;
+}
+
+/* sets path int the tree form the root to the leaf node */
+
+void icvSetLeafNode( CvTreeCascadeClassifier* tcc, CvTreeCascadeNode* leaf )
+{
+ CV_FUNCNAME( "icvSetLeafNode" );
+
+ __BEGIN__;
+
+ CvTreeCascadeNode* ptr;
+
+ ptr = NULL;
+ while( leaf )
+ {
+ leaf->child_eval = ptr;
+ ptr = leaf;
+ leaf = leaf->parent;
+ }
+
+ leaf = tcc->root;
+ while( leaf && leaf != ptr ) leaf = leaf->next;
+ if( leaf != ptr )
+ CV_ERROR( CV_StsError, "Invalid tcc or leaf node." );
+
+ tcc->root_eval = ptr;
+
+ __END__;
+}
+
+/* evaluates a tree cascade classifier. used in filtering */
+
+float icvEvalTreeCascadeClassifierFilter( CvIntHaarClassifier* classifier, sum_type* sum,
+ sum_type* tilted, float normfactor )
+{
+ CvTreeCascadeNode* ptr;
+ CvTreeCascadeClassifier* tree;
+
+ tree = (CvTreeCascadeClassifier*) classifier;
+
+
+
+ ptr = ((CvTreeCascadeClassifier*) classifier)->root_eval;
+ while( ptr )
+ {
+ if( ptr->stage->eval( (CvIntHaarClassifier*) ptr->stage,
+ sum, tilted, normfactor )
+ < ptr->stage->threshold - CV_THRESHOLD_EPS )
+ {
+ return 0.0F;
+ }
+ ptr = ptr->child_eval;
+ }
+
+ return 1.0F;
+}
+
+/* creates tree cascade node */
+
+CvTreeCascadeNode* icvCreateTreeCascadeNode()
+{
+ CvTreeCascadeNode* ptr = NULL;
+
+ CV_FUNCNAME( "icvCreateTreeCascadeNode" );
+
+ __BEGIN__;
+ size_t data_size;
+
+ data_size = sizeof( *ptr );
+ CV_CALL( ptr = (CvTreeCascadeNode*) cvAlloc( data_size ) );
+ memset( ptr, 0, data_size );
+
+ __END__;
+
+ return ptr;
+}
+
+/* releases all tree cascade nodes accessible via links */
+
+void icvReleaseTreeCascadeNodes( CvTreeCascadeNode** node )
+{
+ //CV_FUNCNAME( "icvReleaseTreeCascadeNodes" );
+
+ __BEGIN__;
+
+ if( node && *node )
+ {
+ CvTreeCascadeNode* ptr;
+ CvTreeCascadeNode* ptr_;
+
+ ptr = *node;
+
+ while( ptr )
+ {
+ while( ptr->child ) ptr = ptr->child;
+
+ if( ptr->stage ) ptr->stage->release( (CvIntHaarClassifier**) &ptr->stage );
+ ptr_ = ptr;
+
+ while( ptr && ptr->next == NULL ) ptr = ptr->parent;
+ if( ptr ) ptr = ptr->next;
+
+ cvFree( &ptr_ );
+ }
+ }
+
+ __END__;
+}
+
+
+/* releases tree cascade classifier */
+
+void icvReleaseTreeCascadeClassifier( CvIntHaarClassifier** classifier )
+{
+ if( classifier && *classifier )
+ {
+ icvReleaseTreeCascadeNodes( &((CvTreeCascadeClassifier*) *classifier)->root );
+ cvFree( classifier );
+ *classifier = NULL;
+ }
+}
+
+
+void icvPrintTreeCascade( CvTreeCascadeNode* root )
+{
+ //CV_FUNCNAME( "icvPrintTreeCascade" );
+
+ __BEGIN__;
+
+ CvTreeCascadeNode* node;
+ CvTreeCascadeNode* n;
+ char buf0[256];
+ char buf[256];
+ int level;
+ int i;
+ int max_level;
+
+ node = root;
+ level = max_level = 0;
+ while( node )
+ {
+ while( node->child ) { node = node->child; level++; }
+ if( level > max_level ) { max_level = level; }
+ while( node && !node->next ) { node = node->parent; level--; }
+ if( node ) node = node->next;
+ }
+
+ printf( "\nTree Classifier\n" );
+ printf( "Stage\n" );
+ for( i = 0; i <= max_level; i++ ) printf( "+---" );
+ printf( "+\n" );
+ for( i = 0; i <= max_level; i++ ) printf( "|%3d", i );
+ printf( "|\n" );
+ for( i = 0; i <= max_level; i++ ) printf( "+---" );
+ printf( "+\n\n" );
+
+ node = root;
+
+ buf[0] = 0;
+ while( node )
+ {
+ sprintf( buf + strlen( buf ), "%3d", node->idx );
+ while( node->child )
+ {
+ node = node->child;
+ sprintf( buf + strlen( buf ),
+ ((node->idx < 10) ? "---%d" : ((node->idx < 100) ? "--%d" : "-%d")),
+ node->idx );
+ }
+ printf( " %s\n", buf );
+
+ while( node && !node->next ) { node = node->parent; }
+ if( node )
+ {
+ node = node->next;
+
+ n = node->parent;
+ buf[0] = 0;
+ while( n )
+ {
+ if( n->next )
+ sprintf( buf0, " | %s", buf );
+ else
+ sprintf( buf0, " %s", buf );
+ strcpy( buf, buf0 );
+ n = n->parent;
+ }
+ printf( " %s |\n", buf );
+ }
+ }
+ printf( "\n" );
+ fflush( stdout );
+
+ __END__;
+}
+
+
+
+CvIntHaarClassifier* icvLoadTreeCascadeClassifier( const char* filename, int step,
+ int* splits )
+{
+ CvTreeCascadeClassifier* ptr = NULL;
+ CvTreeCascadeNode** nodes = NULL;
+
+ CV_FUNCNAME( "icvLoadTreeCascadeClassifier" );
+
+ __BEGIN__;
+
+ size_t data_size;
+ CvStageHaarClassifier* stage;
+ char stage_name[PATH_MAX];
+ char* suffix;
+ int i, num;
+ FILE* f;
+ int result, parent=0, next=0;
+ int stub;
+
+ if( !splits ) splits = &stub;
+
+ *splits = 0;
+
+ data_size = sizeof( *ptr );
+
+ CV_CALL( ptr = (CvTreeCascadeClassifier*) cvAlloc( data_size ) );
+ memset( ptr, 0, data_size );
+
+ ptr->eval = icvEvalTreeCascadeClassifier;
+ ptr->release = icvReleaseTreeCascadeClassifier;
+
+ sprintf( stage_name, "%s/", filename );
+ suffix = stage_name + strlen( stage_name );
+
+ for( i = 0; ; i++ )
+ {
+ sprintf( suffix, "%d/%s", i, CV_STAGE_CART_FILE_NAME );
+ f = fopen( stage_name, "r" );
+ if( !f ) break;
+ fclose( f );
+ }
+ num = i;
+
+ if( num < 1 ) EXIT;
+
+ data_size = sizeof( *nodes ) * num;
+ CV_CALL( nodes = (CvTreeCascadeNode**) cvAlloc( data_size ) );
+
+ for( i = 0; i < num; i++ )
+ {
+ sprintf( suffix, "%d/%s", i, CV_STAGE_CART_FILE_NAME );
+ f = fopen( stage_name, "r" );
+ CV_CALL( stage = (CvStageHaarClassifier*)
+ icvLoadCARTStageHaarClassifierF( f, step ) );
+
+ result = ( f && stage ) ? fscanf( f, "%d%d", &parent, &next ) : 0;
+ if( f ) fclose( f );
+
+ if( result != 2 )
+ {
+ num = i;
+ break;
+ }
+
+ printf( "Stage %d loaded\n", i );
+
+ if( parent >= i || (next != -1 && next != i + 1) )
+ CV_ERROR( CV_StsError, "Invalid tree links" );
+
+ CV_CALL( nodes[i] = icvCreateTreeCascadeNode() );
+ nodes[i]->stage = stage;
+ nodes[i]->idx = i;
+ nodes[i]->parent = (parent != -1 ) ? nodes[parent] : NULL;
+ nodes[i]->next = ( next != -1 ) ? nodes[i] : NULL;
+ nodes[i]->child = NULL;
+ }
+ for( i = 0; i < num; i++ )
+ {
+ if( nodes[i]->next )
+ {
+ (*splits)++;
+ nodes[i]->next = nodes[i+1];
+ }
+ if( nodes[i]->parent && nodes[i]->parent->child == NULL )
+ {
+ nodes[i]->parent->child = nodes[i];
+ }
+ }
+ ptr->root = nodes[0];
+ ptr->next_idx = num;
+
+ __END__;
+
+ cvFree( &nodes );
+
+ return (CvIntHaarClassifier*) ptr;
+}
+
+
+CvTreeCascadeNode* icvFindDeepestLeaves( CvTreeCascadeClassifier* tcc )
+{
+ CvTreeCascadeNode* leaves;
+
+ //CV_FUNCNAME( "icvFindDeepestLeaves" );
+
+ __BEGIN__;
+
+ int level, cur_level;
+ CvTreeCascadeNode* ptr;
+ CvTreeCascadeNode* last;
+
+ leaves = last = NULL;
+
+ ptr = tcc->root;
+ level = -1;
+ cur_level = 0;
+
+ /* find leaves with maximal level */
+ while( ptr )
+ {
+ if( ptr->child ) { ptr = ptr->child; cur_level++; }
+ else
+ {
+ if( cur_level == level )
+ {
+ last->next_same_level = ptr;
+ ptr->next_same_level = NULL;
+ last = ptr;
+ }
+ if( cur_level > level )
+ {
+ level = cur_level;
+ leaves = last = ptr;
+ ptr->next_same_level = NULL;
+ }
+ while( ptr && ptr->next == NULL ) { ptr = ptr->parent; cur_level--; }
+ if( ptr ) ptr = ptr->next;
+ }
+ }
+
+ __END__;
+
+ return leaves;
+}
+
+/* End of file. */
projects / opencv / blobdiff