#include "precomp.hpp"

#include <stdio.h>

#include "opencv2/core/internal.hpp"

#if CV_SSE2

# if 1 /*!CV_SSE4_1 && !CV_SSE4_2*/

# define _mm_blendv_pd(a, b, m) _mm_xor_pd(a, _mm_and_pd(_mm_xor_pd(b, a), m))

# define _mm_blendv_ps(a, b, m) _mm_xor_ps(a, _mm_and_ps(_mm_xor_ps(b, a), m))

# endif

#endif

#if 0 /*CV_AVX*/

# define CV_HAAR_USE_AVX 1

# if defined _MSC_VER

# pragma warning( disable : 4752 )

# endif

#else

# if CV_SSE2

# define CV_HAAR_USE_SSE 1

# endif

#endif

#define CV_ADJUST_FEATURES 1

#define CV_ADJUST_WEIGHTS 0

typedef int sumtype;

typedef double sqsumtype;

typedef struct CvHidHaarFeature

} CvHidHaarFeature;

typedef struct CvHidHaarTreeNode

} CvHidHaarTreeNode;

typedef struct CvHidHaarClassifier

} CvHidHaarClassifier;

typedef struct CvHidHaarStageClassifier

} CvHidHaarStageClassifier;

typedef struct CvHidHaarClassifierCascade

} CvHidHaarClassifierCascade;

const int icv_object_win_border = 1;

const float icv_stage_threshold_bias = 0.0001f;

static CvHaarClassifierCascade*

icvCreateHaarClassifierCascade( int stage_count )

{

CvHaarClassifierCascade* cascade = 0;

int block_size = sizeof(*cascade) + stage_count*sizeof(*cascade->stage_classifier);

if( stage_count <= 0 )

CV_Error( CV_StsOutOfRange, "Number of stages should be positive" );

cascade = (CvHaarClassifierCascade*)cvAlloc( block_size );

memset( cascade, 0, block_size );

cascade->stage_classifier = (CvHaarStageClassifier*)(cascade + 1);

cascade->flags = CV_HAAR_MAGIC_VAL;

cascade->count = stage_count;

return cascade;

}

static void

icvReleaseHidHaarClassifierCascade( CvHidHaarClassifierCascade** _cascade )

}

static CvHidHaarClassifierCascade*

icvCreateHidHaarClassifierCascade( CvHaarClassifierCascade* cascade )

{

CvRect* ipp_features = 0;

float *ipp_weights = 0, *ipp_thresholds = 0, *ipp_val1 = 0, *ipp_val2 = 0;

int* ipp_counts = 0;

CvHidHaarClassifierCascade* out = 0;

int i, j, k, l;

int datasize;

int total_classifiers = 0;

int total_nodes = 0;

char errorstr[1000];

CvHidHaarClassifier* haar_classifier_ptr;

CvHidHaarTreeNode* haar_node_ptr;

CvSize orig_window_size;

int has_tilted_features = 0;

int max_count = 0;

if( !CV_IS_HAAR_CLASSIFIER(cascade) )

CV_Error( !cascade ? CV_StsNullPtr : CV_StsBadArg, "Invalid classifier pointer" );

if( cascade->hid_cascade )

CV_Error( CV_StsError, "hid_cascade has been already created" );

if( !cascade->stage_classifier )

CV_Error( CV_StsNullPtr, "" );

if( cascade->count <= 0 )

CV_Error( CV_StsOutOfRange, "Negative number of cascade stages" );

orig_window_size = cascade->orig_window_size;

/* check input structure correctness and calculate total memory size needed for

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

{

CvHaarStageClassifier* stage_classifier = cascade->stage_classifier + i;

if( !stage_classifier->classifier ||

stage_classifier->count <= 0 )

{

sprintf( errorstr, "header of the stage classifier #%d is invalid "

"(has null pointers or non-positive classfier count)", i );

CV_Error( CV_StsError, errorstr );

}

max_count = MAX( max_count, stage_classifier->count );

total_classifiers += stage_classifier->count;

for( j = 0; j < stage_classifier->count; j++ )

{

CvHaarClassifier* classifier = stage_classifier->classifier + j;

total_nodes += classifier->count;

for( l = 0; l < classifier->count; l++ )

{

for( k = 0; k < CV_HAAR_FEATURE_MAX; k++ )

{

if( classifier->haar_feature[l].rect[k].r.width )

{

CvRect r = classifier->haar_feature[l].rect[k].r;

int tilted = classifier->haar_feature[l].tilted;

has_tilted_features |= tilted != 0;

if( r.width < 0 || r.height < 0 || r.y < 0 ||

r.x + r.width > orig_window_size.width

||

(!tilted &&

(r.x < 0 || r.y + r.height > orig_window_size.height))

||

(tilted && (r.x - r.height < 0 ||

r.y + r.width + r.height > orig_window_size.height)))

{

sprintf( errorstr, "rectangle #%d of the classifier #%d of "

"the stage classifier #%d is not inside "

"the reference (original) cascade window", k, j, i );

CV_Error( CV_StsNullPtr, errorstr );

}

}

}

}

}

}

// this is an upper boundary for the whole hidden cascade size

datasize = sizeof(CvHidHaarClassifierCascade) +

sizeof(CvHidHaarStageClassifier)*cascade->count +

sizeof(CvHidHaarClassifier) * total_classifiers +

sizeof(CvHidHaarTreeNode) * total_nodes +

sizeof(void*)*(total_nodes + total_classifiers);

out = (CvHidHaarClassifierCascade*)cvAlloc( datasize );

memset( out, 0, sizeof(*out) );

/* init header */

out->count = cascade->count;

out->stage_classifier = (CvHidHaarStageClassifier*)(out + 1);

haar_classifier_ptr = (CvHidHaarClassifier*)(out->stage_classifier + cascade->count);

haar_node_ptr = (CvHidHaarTreeNode*)(haar_classifier_ptr + total_classifiers);

out->isStumpBased = 1;

out->has_tilted_features = has_tilted_features;

out->is_tree = 0;

/* initialize internal representation */

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

{

CvHaarStageClassifier* stage_classifier = cascade->stage_classifier + i;

CvHidHaarStageClassifier* hid_stage_classifier = out->stage_classifier + i;

hid_stage_classifier->count = stage_classifier->count;

hid_stage_classifier->threshold = stage_classifier->threshold - icv_stage_threshold_bias;

hid_stage_classifier->classifier = haar_classifier_ptr;

hid_stage_classifier->two_rects = 1;

haar_classifier_ptr += stage_classifier->count;

hid_stage_classifier->parent = (stage_classifier->parent == -1)

? NULL : out->stage_classifier + stage_classifier->parent;

hid_stage_classifier->next = (stage_classifier->next == -1)

? NULL : out->stage_classifier + stage_classifier->next;

hid_stage_classifier->child = (stage_classifier->child == -1)

? NULL : out->stage_classifier + stage_classifier->child;

out->is_tree |= hid_stage_classifier->next != NULL;

for( j = 0; j < stage_classifier->count; j++ )

{

CvHaarClassifier* classifier = stage_classifier->classifier + j;

CvHidHaarClassifier* hid_classifier = hid_stage_classifier->classifier + j;

int node_count = classifier->count;

float* alpha_ptr = (float*)(haar_node_ptr + node_count);

hid_classifier->count = node_count;

hid_classifier->node = haar_node_ptr;

hid_classifier->alpha = alpha_ptr;

for( l = 0; l < node_count; l++ )

{

CvHidHaarTreeNode* node = hid_classifier->node + l;

CvHaarFeature* feature = classifier->haar_feature + l;

memset( node, -1, sizeof(*node) );

node->threshold = classifier->threshold[l];

node->left = classifier->left[l];

node->right = classifier->right[l];

if( fabs(feature->rect[2].weight) < DBL_EPSILON ||

feature->rect[2].r.width == 0 ||

feature->rect[2].r.height == 0 )

memset( &(node->feature.rect[2]), 0, sizeof(node->feature.rect[2]) );

else

hid_stage_classifier->two_rects = 0;

}

memcpy( alpha_ptr, classifier->alpha, (node_count+1)*sizeof(alpha_ptr[0]));

haar_node_ptr =

(CvHidHaarTreeNode*)cvAlignPtr(alpha_ptr+node_count+1, sizeof(void*));

out->isStumpBased &= node_count == 1;

}

}

cascade->hid_cascade = out;

assert( (char*)haar_node_ptr - (char*)out <= datasize );

cvFree( &ipp_features );

cvFree( &ipp_weights );

cvFree( &ipp_thresholds );

cvFree( &ipp_val1 );

cvFree( &ipp_val2 );

cvFree( &ipp_counts );

return out;

}

#define sum_elem_ptr(sum,row,col) \

((sumtype*)CV_MAT_ELEM_PTR_FAST((sum),(row),(col),sizeof(sumtype)))

#define sqsum_elem_ptr(sqsum,row,col) \

((sqsumtype*)CV_MAT_ELEM_PTR_FAST((sqsum),(row),(col),sizeof(sqsumtype)))

#define calc_sum(rect,offset) \

((rect).p0[offset] - (rect).p1[offset] - (rect).p2[offset] + (rect).p3[offset])

#define calc_sumf(rect,offset) \

static_cast<float>((rect).p0[offset] - (rect).p1[offset] - (rect).p2[offset] + (rect).p3[offset])

CV_IMPL void

cvSetImagesForHaarClassifierCascade( CvHaarClassifierCascade* _cascade,

}

#ifdef CV_HAAR_USE_AVX

CV_INLINE

double icvEvalHidHaarClassifierAVX( CvHidHaarClassifier* classifier,

}

#endif //CV_HAAR_USE_AVX

CV_INLINE

double icvEvalHidHaarClassifier( CvHidHaarClassifier* classifier,

}

static int

cvRunHaarClassifierCascadeSum( const CvHaarClassifierCascade* _cascade,