//
//M*/
-/* Haar features calculation */
-//#define EMU
-
#include "precomp.hpp"
#include <stdio.h>
#include <string>
-#ifdef EMU
-#include "runCL.h"
-#endif
+
using namespace cv;
using namespace cv::ocl;
using namespace std;
args.push_back ( make_pair(sizeof(cl_int4) , (void *)&p ));
args.push_back ( make_pair(sizeof(cl_int4) , (void *)&pq ));
args.push_back ( make_pair(sizeof(cl_float) , (void *)&correction ));
- /*
- openCLSafeCall(clSetKernelArg(kernel, argcount++, sizeof(cl_mem), (void *)&stagebuffer));
- openCLSafeCall(clSetKernelArg(kernel, argcount++, sizeof(cl_mem), (void *)&scaleinfobuffer));
- openCLSafeCall(clSetKernelArg(kernel, argcount++, sizeof(cl_mem), (void *)&nodebuffer));
- openCLSafeCall(clSetKernelArg(kernel, argcount++, sizeof(cl_mem), (void *)&gsum.data));
- openCLSafeCall(clSetKernelArg(kernel, argcount++, sizeof(cl_mem), (void *)&gsqsum.data));
- openCLSafeCall(clSetKernelArg(kernel, argcount++, sizeof(cl_mem), (void *)&candidatebuffer));
- openCLSafeCall(clSetKernelArg(kernel, argcount++, sizeof(cl_int), (void *)&pixelstep));
- openCLSafeCall(clSetKernelArg(kernel, argcount++, sizeof(cl_int), (void *)&loopcount));
- openCLSafeCall(clSetKernelArg(kernel, argcount++, sizeof(cl_int), (void *)&startstage));
- openCLSafeCall(clSetKernelArg(kernel, argcount++, sizeof(cl_int), (void *)&splitstage));
- openCLSafeCall(clSetKernelArg(kernel, argcount++, sizeof(cl_int), (void *)&endstage));
- openCLSafeCall(clSetKernelArg(kernel, argcount++, sizeof(cl_int), (void *)&startnode));
- openCLSafeCall(clSetKernelArg(kernel, argcount++, sizeof(cl_int), (void *)&splitnode));
- openCLSafeCall(clSetKernelArg(kernel, argcount++, sizeof(cl_int4), (void *)&p));
- openCLSafeCall(clSetKernelArg(kernel, argcount++, sizeof(cl_int4), (void *)&pq));
- openCLSafeCall(clSetKernelArg(kernel, argcount++, sizeof(cl_float), (void *)&correction));*/
- //openCLSafeCall(clSetKernelArg(kernel,argcount++,sizeof(cl_int),(void*)&n));
- //openCLSafeCall(clSetKernelArg(kernel,argcount++,sizeof(cl_int),(void*)&grpnumperline));
- //openCLSafeCall(clSetKernelArg(kernel,argcount++,sizeof(cl_int),(void*)&totalgrp));
-
- // openCLSafeCall(clEnqueueNDRangeKernel(gsum.clCxt->impl->clCmdQueue, kernel, 2, NULL, globalThreads, localThreads, 0, NULL, NULL));
-
- // openCLSafeCall(clFinish(gsum.clCxt->impl->clCmdQueue));
+
openCLExecuteKernel(gsum.clCxt, &haarobjectdetect, "gpuRunHaarClassifierCascade", globalThreads, localThreads, args, -1, -1);
//t = (double)cvGetTickCount() - t;
//printf( "detection time = %g ms\n", t/((double)cvGetTickFrequency()*1000.) );
scaleinfo[i].factor = factor;
int startnodenum = nodenum * i;
float factor2 = (float)factor;
- /*
- openCLSafeCall(clSetKernelArg(kernel2, argcounts++, sizeof(cl_mem), (void *)&nodebuffer));
- openCLSafeCall(clSetKernelArg(kernel2, argcounts++, sizeof(cl_mem), (void *)&newnodebuffer));
- openCLSafeCall(clSetKernelArg(kernel2, argcounts++, sizeof(cl_float), (void *)&factor2));
- openCLSafeCall(clSetKernelArg(kernel2, argcounts++, sizeof(cl_float), (void *)&correction[i]));
- openCLSafeCall(clSetKernelArg(kernel2, argcounts++, sizeof(cl_int), (void *)&startnodenum));
- */
vector<pair<size_t, const void *> > args1;
args1.push_back ( make_pair(sizeof(cl_mem) , (void *)&nodebuffer ));
correctionbuffer = openCLCreateBuffer(gsum.clCxt, CL_MEM_READ_ONLY, sizeof(cl_float) * loopcount);
openCLSafeCall(clEnqueueWriteBuffer(gsum.clCxt->impl->clCmdQueue, correctionbuffer, 1, 0, sizeof(cl_float)*loopcount, correction, 0, NULL, NULL));
//int argcount = 0;
- /*openCLSafeCall(clSetKernelArg(kernel, argcount++, sizeof(cl_mem), (void *)&stagebuffer));
- openCLSafeCall(clSetKernelArg(kernel, argcount++, sizeof(cl_mem), (void *)&scaleinfobuffer));
- openCLSafeCall(clSetKernelArg(kernel, argcount++, sizeof(cl_mem), (void *)&newnodebuffer));
- openCLSafeCall(clSetKernelArg(kernel, argcount++, sizeof(cl_mem), (void *)&gsum.data));
- openCLSafeCall(clSetKernelArg(kernel, argcount++, sizeof(cl_mem), (void *)&gsqsum.data));
- openCLSafeCall(clSetKernelArg(kernel, argcount++, sizeof(cl_mem), (void *)&candidatebuffer));
- openCLSafeCall(clSetKernelArg(kernel, argcount++, sizeof(cl_int), (void *)&step));
- openCLSafeCall(clSetKernelArg(kernel, argcount++, sizeof(cl_int), (void *)&loopcount));
- openCLSafeCall(clSetKernelArg(kernel, argcount++, sizeof(cl_int), (void *)&startstage));
- openCLSafeCall(clSetKernelArg(kernel, argcount++, sizeof(cl_int), (void *)&splitstage));
- openCLSafeCall(clSetKernelArg(kernel, argcount++, sizeof(cl_int), (void *)&endstage));
- openCLSafeCall(clSetKernelArg(kernel, argcount++, sizeof(cl_int), (void *)&startnode));
- openCLSafeCall(clSetKernelArg(kernel, argcount++, sizeof(cl_int), (void *)&splitnode));
- openCLSafeCall(clSetKernelArg(kernel, argcount++, sizeof(cl_mem), (void *)&pbuffer));
- openCLSafeCall(clSetKernelArg(kernel, argcount++, sizeof(cl_mem), (void *)&correctionbuffer));
- openCLSafeCall(clSetKernelArg(kernel, argcount++, sizeof(cl_int), (void *)&nodenum));*/
vector<pair<size_t, const void *> > args;
args.push_back ( make_pair(sizeof(cl_mem) , (void *)&stagebuffer ));
openCLExecuteKernel(gsum.clCxt, &haarobjectdetect_scaled2, "gpuRunHaarClassifierCascade_scaled2", globalThreads, localThreads, args, -1, -1);
- //openCLSafeCall(clEnqueueNDRangeKernel(gsum.clCxt->impl->clCmdQueue, kernel, 2, NULL, globalThreads, localThreads, 0, NULL, NULL));
- //openCLSafeCall(clFinish(gsum.clCxt->impl->clCmdQueue));
//openCLSafeCall(clEnqueueReadBuffer(gsum.clCxt->clCmdQueue,candidatebuffer,1,0,4*sizeof(int)*outputsz,candidate,0,NULL,NULL));
candidate = (int *)clEnqueueMapBuffer(gsum.clCxt->impl->clCmdQueue, candidatebuffer, 1, CL_MAP_READ, 0, 4 * sizeof(int), 0, 0, 0, &status);
}
-// static CvHaarClassifierCascade * gpuLoadCascadeCART( const char **input_cascade, int n, CvSize orig_window_size )
-// {
-// int i;
-// CvHaarClassifierCascade *cascade = gpuCreateHaarClassifierCascade(n);
-// cascade->orig_window_size = orig_window_size;
-
-// for( i = 0; i < n; i++ )
-// {
-// int j, count, l;
-// float threshold = 0;
-// const char *stage = input_cascade[i];
-// int dl = 0;
-
-// /* tree links */
-// int parent = -1;
-// int next = -1;
-
-// sscanf( stage, "%d%n", &count, &dl );
-// stage += dl;
-
-// assert( count > 0 );
-// cascade->stage_classifier[i].count = count;
-// cascade->stage_classifier[i].classifier =
-// (CvHaarClassifier *)cvAlloc( count * sizeof(cascade->stage_classifier[i].classifier[0]));
-
-// for( j = 0; j < count; j++ )
-// {
-// CvHaarClassifier *classifier = cascade->stage_classifier[i].classifier + j;
-// int k, rects = 0;
-// char str[100];
-
-// sscanf( stage, "%d%n", &classifier->count, &dl );
-// stage += dl;
-
-// classifier->haar_feature = (CvHaarFeature *) cvAlloc(
-// classifier->count * ( sizeof( *classifier->haar_feature ) +
-// sizeof( *classifier->threshold ) +
-// sizeof( *classifier->left ) +
-// sizeof( *classifier->right ) ) +
-// (classifier->count + 1) * sizeof( *classifier->alpha ) );
-// classifier->threshold = (float *) (classifier->haar_feature + classifier->count);
-// classifier->left = (int *) (classifier->threshold + classifier->count);
-// classifier->right = (int *) (classifier->left + classifier->count);
-// classifier->alpha = (float *) (classifier->right + classifier->count);
-
-// for( l = 0; l < classifier->count; l++ )
-// {
-// sscanf( stage, "%d%n", &rects, &dl );
-// stage += dl;
-
-// assert( rects >= 2 && rects <= CV_HAAR_FEATURE_MAX );
-
-// for( k = 0; k < rects; k++ )
-// {
-// CvRect r;
-// int band = 0;
-// sscanf( stage, "%d%d%d%d%d%f%n",
-// &r.x, &r.y, &r.width, &r.height, &band,
-// &(classifier->haar_feature[l].rect[k].weight), &dl );
-// stage += dl;
-// classifier->haar_feature[l].rect[k].r = r;
-// }
-// sscanf( stage, "%s%n", str, &dl );
-// stage += dl;
-
-// classifier->haar_feature[l].tilted = strncmp( str, "tilted", 6 ) == 0;
-
-// for( k = rects; k < CV_HAAR_FEATURE_MAX; k++ )
-// {
-// memset( classifier->haar_feature[l].rect + k, 0,
-// sizeof(classifier->haar_feature[l].rect[k]) );
-// }
-
-// sscanf( stage, "%f%d%d%n", &(classifier->threshold[l]),
-// &(classifier->left[l]),
-// &(classifier->right[l]), &dl );
-// stage += dl;
-// }
-// for( l = 0; l <= classifier->count; l++ )
-// {
-// sscanf( stage, "%f%n", &(classifier->alpha[l]), &dl );
-// stage += dl;
-// }
-// }
-
-// sscanf( stage, "%f%n", &threshold, &dl );
-// stage += dl;
-
-// cascade->stage_classifier[i].threshold = threshold;
-
-// /* load tree links */
-// if( sscanf( stage, "%d%d%n", &parent, &next, &dl ) != 2 )
-// {
-// parent = i - 1;
-// next = -1;
-// }
-// stage += dl;
-
-// cascade->stage_classifier[i].parent = parent;
-// cascade->stage_classifier[i].next = next;
-// cascade->stage_classifier[i].child = -1;
-
-// if( parent != -1 && cascade->stage_classifier[parent].child == -1 )
-// {
-// cascade->stage_classifier[parent].child = i;
-// }
-// }
-
-// return cascade;
-// }
-
#ifndef _MAX_PATH
#define _MAX_PATH 1024
#endif
-// static CvHaarClassifierCascade * gpuLoadHaarClassifierCascade( const char *directory, CvSize orig_window_size )
-// {
-// const char **input_cascade = 0;
-// CvHaarClassifierCascade *cascade = 0;
-
-// int i, n;
-// const char *slash;
-// char name[_MAX_PATH];
-// int size = 0;
-// char *ptr = 0;
-
-// if( !directory )
-// CV_Error( CV_StsNullPtr, "Null path is passed" );
-
-// n = (int)strlen(directory) - 1;
-// slash = directory[n] == '\\' || directory[n] == '/' ? "" : "/";
-
-// /* try to read the classifier from directory */
-// for( n = 0; ; n++ )
-// {
-// sprintf( name, "%s%s%d/AdaBoostCARTHaarClassifier.txt", directory, slash, n );
-// FILE *f = fopen( name, "rb" );
-// if( !f )
-// break;
-// fseek( f, 0, SEEK_END );
-// size += ftell( f ) + 1;
-// fclose(f);
-// }
-
-// if( n == 0 && slash[0] )
-// return (CvHaarClassifierCascade *)cvLoad( directory );
-
-// if( n == 0 )
-// CV_Error( CV_StsBadArg, "Invalid path" );
-
-// size += (n + 1) * sizeof(char *);
-// input_cascade = (const char **)cvAlloc( size );
-// ptr = (char *)(input_cascade + n + 1);
-
-// for( i = 0; i < n; i++ )
-// {
-// sprintf( name, "%s/%d/AdaBoostCARTHaarClassifier.txt", directory, i );
-// FILE *f = fopen( name, "rb" );
-// if( !f )
-// CV_Error( CV_StsError, "" );
-// fseek( f, 0, SEEK_END );
-// size = ftell( f );
-// fseek( f, 0, SEEK_SET );
-// CV_Assert((size_t)size == fread( ptr, 1, size, f ));
-// fclose(f);
-// input_cascade[i] = ptr;
-// ptr += size;
-// *ptr++ = '\0';
-// }
-
-// input_cascade[n] = 0;
-// cascade = gpuLoadCascadeCART( input_cascade, n, orig_window_size );
-
-// if( input_cascade )
-// cvFree( &input_cascade );
-
-// return cascade;
-// }
-
-
-// static void gpuReleaseHaarClassifierCascade( CvHaarClassifierCascade **_cascade )
-// {
-// if( _cascade && *_cascade )
-// {
-// int i, j;
-// CvHaarClassifierCascade *cascade = *_cascade;
-
-// for( i = 0; i < cascade->count; i++ )
-// {
-// for( j = 0; j < cascade->stage_classifier[i].count; j++ )
-// cvFree( &cascade->stage_classifier[i].classifier[j].haar_feature );
-// cvFree( &cascade->stage_classifier[i].classifier );
-// }
-// gpuReleaseHidHaarClassifierCascade( (GpuHidHaarClassifierCascade **)&cascade->hid_cascade );
-// cvFree( _cascade );
-// }
-// }
-
/****************************************************************************************\
* Persistence functions *
#define ICV_HAAR_PARENT_NAME "parent"
#define ICV_HAAR_NEXT_NAME "next"
-// static int gpuIsHaarClassifier( const void *struct_ptr )
-// {
-// return CV_IS_HAAR_CLASSIFIER( struct_ptr );
-// }
-
-// static void * gpuReadHaarClassifier( CvFileStorage *fs, CvFileNode *node )
-// {
-// CvHaarClassifierCascade *cascade = NULL;
-
-// char buf[256];
-// CvFileNode *seq_fn = NULL; /* sequence */
-// CvFileNode *fn = NULL;
-// CvFileNode *stages_fn = NULL;
-// CvSeqReader stages_reader;
-// int n;
-// int i, j, k, l;
-// int parent, next;
-
-// stages_fn = cvGetFileNodeByName( fs, node, ICV_HAAR_STAGES_NAME );
-// if( !stages_fn || !CV_NODE_IS_SEQ( stages_fn->tag) )
-// CV_Error( CV_StsError, "Invalid stages node" );
-
-// n = stages_fn->data.seq->total;
-// cascade = gpuCreateHaarClassifierCascade(n);
-
-// /* read size */
-// seq_fn = cvGetFileNodeByName( fs, node, ICV_HAAR_SIZE_NAME );
-// if( !seq_fn || !CV_NODE_IS_SEQ( seq_fn->tag ) || seq_fn->data.seq->total != 2 )
-// CV_Error( CV_StsError, "size node is not a valid sequence." );
-// fn = (CvFileNode *) cvGetSeqElem( seq_fn->data.seq, 0 );
-// if( !CV_NODE_IS_INT( fn->tag ) || fn->data.i <= 0 )
-// CV_Error( CV_StsError, "Invalid size node: width must be positive integer" );
-// cascade->orig_window_size.width = fn->data.i;
-// fn = (CvFileNode *) cvGetSeqElem( seq_fn->data.seq, 1 );
-// if( !CV_NODE_IS_INT( fn->tag ) || fn->data.i <= 0 )
-// CV_Error( CV_StsError, "Invalid size node: height must be positive integer" );
-// cascade->orig_window_size.height = fn->data.i;
-
-// cvStartReadSeq( stages_fn->data.seq, &stages_reader );
-// for( i = 0; i < n; ++i )
-// {
-// CvFileNode *stage_fn;
-// CvFileNode *trees_fn;
-// CvSeqReader trees_reader;
-
-// stage_fn = (CvFileNode *) stages_reader.ptr;
-// if( !CV_NODE_IS_MAP( stage_fn->tag ) )
-// {
-// sprintf( buf, "Invalid stage %d", i );
-// CV_Error( CV_StsError, buf );
-// }
-
-// trees_fn = cvGetFileNodeByName( fs, stage_fn, ICV_HAAR_TREES_NAME );
-// if( !trees_fn || !CV_NODE_IS_SEQ( trees_fn->tag )
-// || trees_fn->data.seq->total <= 0 )
-// {
-// sprintf( buf, "Trees node is not a valid sequence. (stage %d)", i );
-// CV_Error( CV_StsError, buf );
-// }
-
-// cascade->stage_classifier[i].classifier =
-// (CvHaarClassifier *) cvAlloc( trees_fn->data.seq->total
-// * sizeof( cascade->stage_classifier[i].classifier[0] ) );
-// for( j = 0; j < trees_fn->data.seq->total; ++j )
-// {
-// cascade->stage_classifier[i].classifier[j].haar_feature = NULL;
-// }
-// cascade->stage_classifier[i].count = trees_fn->data.seq->total;
-
-// cvStartReadSeq( trees_fn->data.seq, &trees_reader );
-// for( j = 0; j < trees_fn->data.seq->total; ++j )
-// {
-// CvFileNode *tree_fn;
-// CvSeqReader tree_reader;
-// CvHaarClassifier *classifier;
-// int last_idx;
-
-// classifier = &cascade->stage_classifier[i].classifier[j];
-// tree_fn = (CvFileNode *) trees_reader.ptr;
-// if( !CV_NODE_IS_SEQ( tree_fn->tag ) || tree_fn->data.seq->total <= 0 )
-// {
-// sprintf( buf, "Tree node is not a valid sequence."
-// " (stage %d, tree %d)", i, j );
-// CV_Error( CV_StsError, buf );
-// }
-
-// classifier->count = tree_fn->data.seq->total;
-// classifier->haar_feature = (CvHaarFeature *) cvAlloc(
-// classifier->count * ( sizeof( *classifier->haar_feature ) +
-// sizeof( *classifier->threshold ) +
-// sizeof( *classifier->left ) +
-// sizeof( *classifier->right ) ) +
-// (classifier->count + 1) * sizeof( *classifier->alpha ) );
-// classifier->threshold = (float *) (classifier->haar_feature + classifier->count);
-// classifier->left = (int *) (classifier->threshold + classifier->count);
-// classifier->right = (int *) (classifier->left + classifier->count);
-// classifier->alpha = (float *) (classifier->right + classifier->count);
-
-// cvStartReadSeq( tree_fn->data.seq, &tree_reader );
-// for( k = 0, last_idx = 0; k < tree_fn->data.seq->total; ++k )
-// {
-// CvFileNode *node_fn;
-// CvFileNode *feature_fn;
-// CvFileNode *rects_fn;
-// CvSeqReader rects_reader;
-
-// node_fn = (CvFileNode *) tree_reader.ptr;
-// if( !CV_NODE_IS_MAP( node_fn->tag ) )
-// {
-// sprintf( buf, "Tree node %d is not a valid map. (stage %d, tree %d)",
-// k, i, j );
-// CV_Error( CV_StsError, buf );
-// }
-// feature_fn = cvGetFileNodeByName( fs, node_fn, ICV_HAAR_FEATURE_NAME );
-// if( !feature_fn || !CV_NODE_IS_MAP( feature_fn->tag ) )
-// {
-// sprintf( buf, "Feature node is not a valid map. "
-// "(stage %d, tree %d, node %d)", i, j, k );
-// CV_Error( CV_StsError, buf );
-// }
-// rects_fn = cvGetFileNodeByName( fs, feature_fn, ICV_HAAR_RECTS_NAME );
-// if( !rects_fn || !CV_NODE_IS_SEQ( rects_fn->tag )
-// || rects_fn->data.seq->total < 1
-// || rects_fn->data.seq->total > CV_HAAR_FEATURE_MAX )
-// {
-// sprintf( buf, "Rects node is not a valid sequence. "
-// "(stage %d, tree %d, node %d)", i, j, k );
-// CV_Error( CV_StsError, buf );
-// }
-// cvStartReadSeq( rects_fn->data.seq, &rects_reader );
-// for( l = 0; l < rects_fn->data.seq->total; ++l )
-// {
-// CvFileNode *rect_fn;
-// CvRect r;
-
-// rect_fn = (CvFileNode *) rects_reader.ptr;
-// if( !CV_NODE_IS_SEQ( rect_fn->tag ) || rect_fn->data.seq->total != 5 )
-// {
-// sprintf( buf, "Rect %d is not a valid sequence. "
-// "(stage %d, tree %d, node %d)", l, i, j, k );
-// CV_Error( CV_StsError, buf );
-// }
-
-// fn = CV_SEQ_ELEM( rect_fn->data.seq, CvFileNode, 0 );
-// if( !CV_NODE_IS_INT( fn->tag ) || fn->data.i < 0 )
-// {
-// sprintf( buf, "x coordinate must be non-negative integer. "
-// "(stage %d, tree %d, node %d, rect %d)", i, j, k, l );
-// CV_Error( CV_StsError, buf );
-// }
-// r.x = fn->data.i;
-// fn = CV_SEQ_ELEM( rect_fn->data.seq, CvFileNode, 1 );
-// if( !CV_NODE_IS_INT( fn->tag ) || fn->data.i < 0 )
-// {
-// sprintf( buf, "y coordinate must be non-negative integer. "
-// "(stage %d, tree %d, node %d, rect %d)", i, j, k, l );
-// CV_Error( CV_StsError, buf );
-// }
-// r.y = fn->data.i;
-// fn = CV_SEQ_ELEM( rect_fn->data.seq, CvFileNode, 2 );
-// if( !CV_NODE_IS_INT( fn->tag ) || fn->data.i <= 0
-// || r.x + fn->data.i > cascade->orig_window_size.width )
-// {
-// sprintf( buf, "width must be positive integer and "
-// "(x + width) must not exceed window width. "
-// "(stage %d, tree %d, node %d, rect %d)", i, j, k, l );
-// CV_Error( CV_StsError, buf );
-// }
-// r.width = fn->data.i;
-// fn = CV_SEQ_ELEM( rect_fn->data.seq, CvFileNode, 3 );
-// if( !CV_NODE_IS_INT( fn->tag ) || fn->data.i <= 0
-// || r.y + fn->data.i > cascade->orig_window_size.height )
-// {
-// sprintf( buf, "height must be positive integer and "
-// "(y + height) must not exceed window height. "
-// "(stage %d, tree %d, node %d, rect %d)", i, j, k, l );
-// CV_Error( CV_StsError, buf );
-// }
-// r.height = fn->data.i;
-// fn = CV_SEQ_ELEM( rect_fn->data.seq, CvFileNode, 4 );
-// if( !CV_NODE_IS_REAL( fn->tag ) )
-// {
-// sprintf( buf, "weight must be real number. "
-// "(stage %d, tree %d, node %d, rect %d)", i, j, k, l );
-// CV_Error( CV_StsError, buf );
-// }
-
-// classifier->haar_feature[k].rect[l].weight = (float) fn->data.f;
-// classifier->haar_feature[k].rect[l].r = r;
-
-// CV_NEXT_SEQ_ELEM( sizeof( *rect_fn ), rects_reader );
-// } /* for each rect */
-// for( l = rects_fn->data.seq->total; l < CV_HAAR_FEATURE_MAX; ++l )
-// {
-// classifier->haar_feature[k].rect[l].weight = 0;
-// classifier->haar_feature[k].rect[l].r = cvRect( 0, 0, 0, 0 );
-// }
-
-// fn = cvGetFileNodeByName( fs, feature_fn, ICV_HAAR_TILTED_NAME);
-// if( !fn || !CV_NODE_IS_INT( fn->tag ) )
-// {
-// sprintf( buf, "tilted must be 0 or 1. "
-// "(stage %d, tree %d, node %d)", i, j, k );
-// CV_Error( CV_StsError, buf );
-// }
-// classifier->haar_feature[k].tilted = ( fn->data.i != 0 );
-// fn = cvGetFileNodeByName( fs, node_fn, ICV_HAAR_THRESHOLD_NAME);
-// if( !fn || !CV_NODE_IS_REAL( fn->tag ) )
-// {
-// sprintf( buf, "threshold must be real number. "
-// "(stage %d, tree %d, node %d)", i, j, k );
-// CV_Error( CV_StsError, buf );
-// }
-// classifier->threshold[k] = (float) fn->data.f;
-// fn = cvGetFileNodeByName( fs, node_fn, ICV_HAAR_LEFT_NODE_NAME);
-// if( fn )
-// {
-// if( !CV_NODE_IS_INT( fn->tag ) || fn->data.i <= k
-// || fn->data.i >= tree_fn->data.seq->total )
-// {
-// sprintf( buf, "left node must be valid node number. "
-// "(stage %d, tree %d, node %d)", i, j, k );
-// CV_Error( CV_StsError, buf );
-// }
-// /* left node */
-// classifier->left[k] = fn->data.i;
-// }
-// else
-// {
-// fn = cvGetFileNodeByName( fs, node_fn, ICV_HAAR_LEFT_VAL_NAME );
-// if( !fn )
-// {
-// sprintf( buf, "left node or left value must be specified. "
-// "(stage %d, tree %d, node %d)", i, j, k );
-// CV_Error( CV_StsError, buf );
-// }
-// if( !CV_NODE_IS_REAL( fn->tag ) )
-// {
-// sprintf( buf, "left value must be real number. "
-// "(stage %d, tree %d, node %d)", i, j, k );
-// CV_Error( CV_StsError, buf );
-// }
-// /* left value */
-// if( last_idx >= classifier->count + 1 )
-// {
-// sprintf( buf, "Tree structure is broken: too many values. "
-// "(stage %d, tree %d, node %d)", i, j, k );
-// CV_Error( CV_StsError, buf );
-// }
-// classifier->left[k] = -last_idx;
-// classifier->alpha[last_idx++] = (float) fn->data.f;
-// }
-// fn = cvGetFileNodeByName( fs, node_fn, ICV_HAAR_RIGHT_NODE_NAME);
-// if( fn )
-// {
-// if( !CV_NODE_IS_INT( fn->tag ) || fn->data.i <= k
-// || fn->data.i >= tree_fn->data.seq->total )
-// {
-// sprintf( buf, "right node must be valid node number. "
-// "(stage %d, tree %d, node %d)", i, j, k );
-// CV_Error( CV_StsError, buf );
-// }
-// /* right node */
-// classifier->right[k] = fn->data.i;
-// }
-// else
-// {
-// fn = cvGetFileNodeByName( fs, node_fn, ICV_HAAR_RIGHT_VAL_NAME );
-// if( !fn )
-// {
-// sprintf( buf, "right node or right value must be specified. "
-// "(stage %d, tree %d, node %d)", i, j, k );
-// CV_Error( CV_StsError, buf );
-// }
-// if( !CV_NODE_IS_REAL( fn->tag ) )
-// {
-// sprintf( buf, "right value must be real number. "
-// "(stage %d, tree %d, node %d)", i, j, k );
-// CV_Error( CV_StsError, buf );
-// }
-// /* right value */
-// if( last_idx >= classifier->count + 1 )
-// {
-// sprintf( buf, "Tree structure is broken: too many values. "
-// "(stage %d, tree %d, node %d)", i, j, k );
-// CV_Error( CV_StsError, buf );
-// }
-// classifier->right[k] = -last_idx;
-// classifier->alpha[last_idx++] = (float) fn->data.f;
-// }
-
-// CV_NEXT_SEQ_ELEM( sizeof( *node_fn ), tree_reader );
-// } /* for each node */
-// if( last_idx != classifier->count + 1 )
-// {
-// sprintf( buf, "Tree structure is broken: too few values. "
-// "(stage %d, tree %d)", i, j );
-// CV_Error( CV_StsError, buf );
-// }
-
-// CV_NEXT_SEQ_ELEM( sizeof( *tree_fn ), trees_reader );
-// } /* for each tree */
-
-// fn = cvGetFileNodeByName( fs, stage_fn, ICV_HAAR_STAGE_THRESHOLD_NAME);
-// if( !fn || !CV_NODE_IS_REAL( fn->tag ) )
-// {
-// sprintf( buf, "stage threshold must be real number. (stage %d)", i );
-// CV_Error( CV_StsError, buf );
-// }
-// cascade->stage_classifier[i].threshold = (float) fn->data.f;
-
-// parent = i - 1;
-// next = -1;
-
-// fn = cvGetFileNodeByName( fs, stage_fn, ICV_HAAR_PARENT_NAME );
-// if( !fn || !CV_NODE_IS_INT( fn->tag )
-// || fn->data.i < -1 || fn->data.i >= cascade->count )
-// {
-// sprintf( buf, "parent must be integer number. (stage %d)", i );
-// CV_Error( CV_StsError, buf );
-// }
-// parent = fn->data.i;
-// fn = cvGetFileNodeByName( fs, stage_fn, ICV_HAAR_NEXT_NAME );
-// if( !fn || !CV_NODE_IS_INT( fn->tag )
-// || fn->data.i < -1 || fn->data.i >= cascade->count )
-// {
-// sprintf( buf, "next must be integer number. (stage %d)", i );
-// CV_Error( CV_StsError, buf );
-// }
-// next = fn->data.i;
-
-// cascade->stage_classifier[i].parent = parent;
-// cascade->stage_classifier[i].next = next;
-// cascade->stage_classifier[i].child = -1;
-
-// if( parent != -1 && cascade->stage_classifier[parent].child == -1 )
-// {
-// cascade->stage_classifier[parent].child = i;
-// }
-
-// CV_NEXT_SEQ_ELEM( sizeof( *stage_fn ), stages_reader );
-// } /* for each stage */
-
-// return cascade;
-// }
-
-// static void gpuWriteHaarClassifier( CvFileStorage *fs, const char *name, const void *struct_ptr,
-// CvAttrList attributes )
-// {
-// int i, j, k, l;
-// char buf[256];
-// const CvHaarClassifierCascade *cascade = (const CvHaarClassifierCascade *) struct_ptr;
-
-// /* TODO: parameters check */
-
-// cvStartWriteStruct( fs, name, CV_NODE_MAP, CV_TYPE_NAME_HAAR, attributes );
-
-// cvStartWriteStruct( fs, ICV_HAAR_SIZE_NAME, CV_NODE_SEQ | CV_NODE_FLOW );
-// cvWriteInt( fs, NULL, cascade->orig_window_size.width );
-// cvWriteInt( fs, NULL, cascade->orig_window_size.height );
-// cvEndWriteStruct( fs ); /* size */
-
-// cvStartWriteStruct( fs, ICV_HAAR_STAGES_NAME, CV_NODE_SEQ );
-// for( i = 0; i < cascade->count; ++i )
-// {
-// cvStartWriteStruct( fs, NULL, CV_NODE_MAP );
-// sprintf( buf, "stage %d", i );
-// cvWriteComment( fs, buf, 1 );
-
-// cvStartWriteStruct( fs, ICV_HAAR_TREES_NAME, CV_NODE_SEQ );
-
-// for( j = 0; j < cascade->stage_classifier[i].count; ++j )
-// {
-// CvHaarClassifier *tree = &cascade->stage_classifier[i].classifier[j];
-
-// cvStartWriteStruct( fs, NULL, CV_NODE_SEQ );
-// sprintf( buf, "tree %d", j );
-// cvWriteComment( fs, buf, 1 );
-
-// for( k = 0; k < tree->count; ++k )
-// {
-// CvHaarFeature *feature = &tree->haar_feature[k];
-
-// cvStartWriteStruct( fs, NULL, CV_NODE_MAP );
-// if( k )
-// {
-// sprintf( buf, "node %d", k );
-// }
-// else
-// {
-// sprintf( buf, "root node" );
-// }
-// cvWriteComment( fs, buf, 1 );
-
-// cvStartWriteStruct( fs, ICV_HAAR_FEATURE_NAME, CV_NODE_MAP );
-
-// cvStartWriteStruct( fs, ICV_HAAR_RECTS_NAME, CV_NODE_SEQ );
-// for( l = 0; l < CV_HAAR_FEATURE_MAX && feature->rect[l].r.width != 0; ++l )
-// {
-// cvStartWriteStruct( fs, NULL, CV_NODE_SEQ | CV_NODE_FLOW );
-// cvWriteInt( fs, NULL, feature->rect[l].r.x );
-// cvWriteInt( fs, NULL, feature->rect[l].r.y );
-// cvWriteInt( fs, NULL, feature->rect[l].r.width );
-// cvWriteInt( fs, NULL, feature->rect[l].r.height );
-// cvWriteReal( fs, NULL, feature->rect[l].weight );
-// cvEndWriteStruct( fs ); /* rect */
-// }
-// cvEndWriteStruct( fs ); /* rects */
-// cvWriteInt( fs, ICV_HAAR_TILTED_NAME, feature->tilted );
-// cvEndWriteStruct( fs ); /* feature */
-
-// cvWriteReal( fs, ICV_HAAR_THRESHOLD_NAME, tree->threshold[k]);
-
-// if( tree->left[k] > 0 )
-// {
-// cvWriteInt( fs, ICV_HAAR_LEFT_NODE_NAME, tree->left[k] );
-// }
-// else
-// {
-// cvWriteReal( fs, ICV_HAAR_LEFT_VAL_NAME,
-// tree->alpha[-tree->left[k]] );
-// }
-
-// if( tree->right[k] > 0 )
-// {
-// cvWriteInt( fs, ICV_HAAR_RIGHT_NODE_NAME, tree->right[k] );
-// }
-// else
-// {
-// cvWriteReal( fs, ICV_HAAR_RIGHT_VAL_NAME,
-// tree->alpha[-tree->right[k]] );
-// }
-
-// cvEndWriteStruct( fs ); /* split */
-// }
-
-// cvEndWriteStruct( fs ); /* tree */
-// }
-
-// cvEndWriteStruct( fs ); /* trees */
-
-// cvWriteReal( fs, ICV_HAAR_STAGE_THRESHOLD_NAME, cascade->stage_classifier[i].threshold);
-// cvWriteInt( fs, ICV_HAAR_PARENT_NAME, cascade->stage_classifier[i].parent );
-// cvWriteInt( fs, ICV_HAAR_NEXT_NAME, cascade->stage_classifier[i].next );
-
-// cvEndWriteStruct( fs ); /* stage */
-// } /* for each stage */
-
-// cvEndWriteStruct( fs ); /* stages */
-// cvEndWriteStruct( fs ); /* root */
-// }
-
-// static void * gpuCloneHaarClassifier( const void *struct_ptr )
-// {
-// CvHaarClassifierCascade *cascade = NULL;
-
-// int i, j, k, n;
-// const CvHaarClassifierCascade *cascade_src =
-// (const CvHaarClassifierCascade *) struct_ptr;
-
-// n = cascade_src->count;
-// cascade = gpuCreateHaarClassifierCascade(n);
-// cascade->orig_window_size = cascade_src->orig_window_size;
-
-// for( i = 0; i < n; ++i )
-// {
-// cascade->stage_classifier[i].parent = cascade_src->stage_classifier[i].parent;
-// cascade->stage_classifier[i].next = cascade_src->stage_classifier[i].next;
-// cascade->stage_classifier[i].child = cascade_src->stage_classifier[i].child;
-// cascade->stage_classifier[i].threshold = cascade_src->stage_classifier[i].threshold;
-
-// cascade->stage_classifier[i].count = 0;
-// cascade->stage_classifier[i].classifier =
-// (CvHaarClassifier *) cvAlloc( cascade_src->stage_classifier[i].count
-// * sizeof( cascade->stage_classifier[i].classifier[0] ) );
-
-// cascade->stage_classifier[i].count = cascade_src->stage_classifier[i].count;
-
-// for( j = 0; j < cascade->stage_classifier[i].count; ++j )
-// cascade->stage_classifier[i].classifier[j].haar_feature = NULL;
-
-// for( j = 0; j < cascade->stage_classifier[i].count; ++j )
-// {
-// const CvHaarClassifier *classifier_src =
-// &cascade_src->stage_classifier[i].classifier[j];
-// CvHaarClassifier *classifier =
-// &cascade->stage_classifier[i].classifier[j];
-
-// classifier->count = classifier_src->count;
-// classifier->haar_feature = (CvHaarFeature *) cvAlloc(
-// classifier->count * ( sizeof( *classifier->haar_feature ) +
-// sizeof( *classifier->threshold ) +
-// sizeof( *classifier->left ) +
-// sizeof( *classifier->right ) ) +
-// (classifier->count + 1) * sizeof( *classifier->alpha ) );
-// classifier->threshold = (float *) (classifier->haar_feature + classifier->count);
-// classifier->left = (int *) (classifier->threshold + classifier->count);
-// classifier->right = (int *) (classifier->left + classifier->count);
-// classifier->alpha = (float *) (classifier->right + classifier->count);
-// for( k = 0; k < classifier->count; ++k )
-// {
-// classifier->haar_feature[k] = classifier_src->haar_feature[k];
-// classifier->threshold[k] = classifier_src->threshold[k];
-// classifier->left[k] = classifier_src->left[k];
-// classifier->right[k] = classifier_src->right[k];
-// classifier->alpha[k] = classifier_src->alpha[k];
-// }
-// classifier->alpha[classifier->count] =
-// classifier_src->alpha[classifier->count];
-// }
-// }
-
-// return cascade;
-// }
-
-#if 0
-CvType haar_type( CV_TYPE_NAME_HAAR, gpuIsHaarClassifier,
- (CvReleaseFunc)gpuReleaseHaarClassifierCascade,
- gpuReadHaarClassifier, gpuWriteHaarClassifier,
- gpuCloneHaarClassifier );
-
-
-namespace cv
-{
-
-HaarClassifierCascade::HaarClassifierCascade() {}
-HaarClassifierCascade::HaarClassifierCascade(const String &filename)
-{
- load(filename);
-}
-
-bool HaarClassifierCascade::load(const String &filename)
-{
- cascade = Ptr<CvHaarClassifierCascade>((CvHaarClassifierCascade *)cvLoad(filename.c_str(), 0, 0, 0));
- return (CvHaarClassifierCascade *)cascade != 0;
-}
-
-void HaarClassifierCascade::detectMultiScale( const Mat &image,
- Vector<Rect> &objects, double scaleFactor,
- int minNeighbors, int flags,
- Size minSize )
-{
- MemStorage storage(cvCreateMemStorage(0));
- CvMat _image = image;
- CvSeq *_objects = gpuHaarDetectObjects( &_image, cascade, storage, scaleFactor,
- minNeighbors, flags, minSize );
- Seq<Rect>(_objects).copyTo(objects);
-}
-
-int HaarClassifierCascade::runAt(Point pt, int startStage, int) const
-{
- return gpuRunHaarClassifierCascade(cascade, pt, startStage);
-}
-
-void HaarClassifierCascade::setImages( const Mat &sum, const Mat &sqsum,
- const Mat &tilted, double scale )
-{
- CvMat _sum = sum, _sqsum = sqsum, _tilted = tilted;
- gpuSetImagesForHaarClassifierCascade( cascade, &_sum, &_sqsum, &_tilted, scale );
-}
-
-}
-#endif
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////reserved functios//////////////////////////////////////////////////////////////////////////
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-
-/*#if CV_SSE2
-# if CV_SSE4 || defined __SSE4__
-# include <smmintrin.h>
-# else
-# 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
-#if defined CV_ICC
-# define CV_HAAR_USE_SSE 1
-#endif
-#endif*/
-
-
-/*
-CV_IMPL void
-gpuSetImagesForHaarClassifierCascade( CvHaarClassifierCascade* _cascade,
-const CvArr* _sum,
-const CvArr* _sqsum,
-const CvArr* _tilted_sum,
-double scale )
-{
-CvMat sum_stub, *sum = (CvMat*)_sum;
-CvMat sqsum_stub, *sqsum = (CvMat*)_sqsum;
-CvMat tilted_stub, *tilted = (CvMat*)_tilted_sum;
-GpuHidHaarClassifierCascade* cascade;
-int coi0 = 0, coi1 = 0;
-int i;
-int datasize;
-int totalclassifier;
-CvRect equRect;
-double weight_scale;
-int rows,cols;
-
-if( !CV_IS_HAAR_CLASSIFIER(_cascade) )
-CV_Error( !_cascade ? CV_StsNullPtr : CV_StsBadArg, "Invalid classifier pointer" );
-
-if( scale <= 0 )
-CV_Error( CV_StsOutOfRange, "Scale must be positive" );
-
-sum = cvGetMat( sum, &sum_stub, &coi0 );
-sqsum = cvGetMat( sqsum, &sqsum_stub, &coi1 );
-
-if( coi0 || coi1 )
-CV_Error( CV_BadCOI, "COI is not supported" );
-
-if( !CV_ARE_SIZES_EQ( sum, sqsum ))
-CV_Error( CV_StsUnmatchedSizes, "All integral images must have the same size" );
-
-if( CV_MAT_TYPE(sqsum->type) != CV_64FC1 ||
-CV_MAT_TYPE(sum->type) != CV_32SC1 )
-CV_Error( CV_StsUnsupportedFormat,
-"Only (32s, 64f, 32s) combination of (sum,sqsum,tilted_sum) formats is allowed" );
-
-if( !_cascade->hid_cascade )
-gpuCreateHidHaarClassifierCascade(_cascade,&datasize,&totalclassifier);
-
-cascade =(GpuHidHaarClassifierCascade *)_cascade->hid_cascade;
-
-if( cascade->has_tilted_features )
-{
-tilted = cvGetMat( tilted, &tilted_stub, &coi1 );
-
-if( CV_MAT_TYPE(tilted->type) != CV_32SC1 )
-CV_Error( CV_StsUnsupportedFormat,
-"Only (32s, 64f, 32s) combination of (sum,sqsum,tilted_sum) formats is allowed" );
-
-if( sum->step != tilted->step )
-CV_Error( CV_StsUnmatchedSizes,
-"Sum and tilted_sum must have the same stride (step, widthStep)" );
-
-if( !CV_ARE_SIZES_EQ( sum, tilted ))
-CV_Error( CV_StsUnmatchedSizes, "All integral images must have the same size" );
-//cascade->tilted = *tilted;
-}
-
-_cascade->scale = scale;
-_cascade->real_window_size.width = cvRound( _cascade->orig_window_size.width * scale );
-_cascade->real_window_size.height = cvRound( _cascade->orig_window_size.height * scale );
-
-//cascade->sum = *sum;
-//cascade->sqsum = *sqsum;
-
-equRect.x = equRect.y = cvRound(scale);
-equRect.width = cvRound((_cascade->orig_window_size.width-2)*scale);
-equRect.height = cvRound((_cascade->orig_window_size.height-2)*scale);
-weight_scale = 1./(equRect.width*equRect.height);
-cascade->inv_window_area = weight_scale;
-
-cascade->p0 = sum_elem_ptr(*sum, equRect.y, equRect.x);
-cascade->p1 = sum_elem_ptr(*sum, equRect.y, equRect.x + equRect.width );
-cascade->p2 = sum_elem_ptr(*sum, equRect.y + equRect.height, equRect.x );
-cascade->p3 = sum_elem_ptr(*sum, equRect.y + equRect.height,
-equRect.x + equRect.width );
-*/
-/* rows=sum->rows;
-cols=sum->cols;
-cascade->p0 = equRect.y*cols + equRect.x;
-cascade->p1 = equRect.y*cols + equRect.x + equRect.width;
-cascade->p2 = (equRect.y + equRect.height) * cols + equRect.x;
-cascade->p3 = (equRect.y + equRect.height) * cols + equRect.x + equRect.width ;
-*/
-/*
-cascade->pq0 = sqsum_elem_ptr(*sqsum, equRect.y, equRect.x);
-cascade->pq1 = sqsum_elem_ptr(*sqsum, equRect.y, equRect.x + equRect.width );
-cascade->pq2 = sqsum_elem_ptr(*sqsum, equRect.y + equRect.height, equRect.x );
-cascade->pq3 = sqsum_elem_ptr(*sqsum, equRect.y + equRect.height,
-equRect.x + equRect.width );
-*/
-/* init pointers in haar features according to real window size and
-given image pointers */
-/* for( i = 0; i < _cascade->count; i++ )
-{
-int j, k, l;
-for( j = 0; j < cascade->stage_classifier[i].count; j++ )
-{
-for( l = 0; l < cascade->stage_classifier[i].classifier[j].count; l++ )
-{
-CvHaarFeature* feature =
-&_cascade->stage_classifier[i].classifier[j].haar_feature[l];
-*/ /* GpuHidHaarClassifier* classifier =
-cascade->stage_classifier[i].classifier + j; */
-//GpuHidHaarFeature* hidfeature =
-// &cascade->stage_classifier[i].classifier[j].node[l].feature;
-/* double sum0 = 0, area0 = 0;
-CvRect r[3];
-
-int base_w = -1, base_h = -1;
-int new_base_w = 0, new_base_h = 0;
-int kx, ky;
-int flagx = 0, flagy = 0;
-int x0 = 0, y0 = 0;
-int nr;
-*/
-/* align blocks */
-/* for( k = 0; k < CV_HAAR_FEATURE_MAX; k++ )
-{
-//if( !hidfeature->rect[k].p0 )
-// break;
-r[k] = feature->rect[k].r;
-base_w = (int)CV_IMIN( (unsigned)base_w, (unsigned)(r[k].width-1) );
-base_w = (int)CV_IMIN( (unsigned)base_w, (unsigned)(r[k].x - r[0].x-1) );
-base_h = (int)CV_IMIN( (unsigned)base_h, (unsigned)(r[k].height-1) );
-base_h = (int)CV_IMIN( (unsigned)base_h, (unsigned)(r[k].y - r[0].y-1) );
-}
-
-nr = k;
-
-base_w += 1;
-base_h += 1;
-kx = r[0].width / base_w;
-ky = r[0].height / base_h;
-
-if( kx <= 0 )
-{
-flagx = 1;
-new_base_w = cvRound( r[0].width * scale ) / kx;
-x0 = cvRound( r[0].x * scale );
-}
-
-if( ky <= 0 )
-{
-flagy = 1;
-new_base_h = cvRound( r[0].height * scale ) / ky;
-y0 = cvRound( r[0].y * scale );
-}
-
-for( k = 0; k < nr; k++ )
-{
-CvRect tr;
-double correction_ratio;
-
-if( flagx )
-{
-tr.x = (r[k].x - r[0].x) * new_base_w / base_w + x0;
-tr.width = r[k].width * new_base_w / base_w;
-}
-else
+static int gpuRunHaarClassifierCascade( /*const CvHaarClassifierCascade *_cascade, CvPoint pt, int start_stage */)
{
-tr.x = cvRound( r[k].x * scale );
-tr.width = cvRound( r[k].width * scale );
-}
-
-if( flagy )
-{
-tr.y = (r[k].y - r[0].y) * new_base_h / base_h + y0;
-tr.height = r[k].height * new_base_h / base_h;
-}
-else
-{
-tr.y = cvRound( r[k].y * scale );
-tr.height = cvRound( r[k].height * scale );
-}
-
-#if CV_ADJUST_WEIGHTS
-{
-// RAINER START
-const float orig_feature_size = (float)(feature->rect[k].r.width)*feature->rect[k].r.height;
-const float orig_norm_size = (float)(_cascade->orig_window_size.width)*(_cascade->orig_window_size.height);
-const float feature_size = float(tr.width*tr.height);
-//const float normSize = float(equRect.width*equRect.height);
-float target_ratio = orig_feature_size / orig_norm_size;
-//float isRatio = featureSize / normSize;
-//correctionRatio = targetRatio / isRatio / normSize;
-correction_ratio = target_ratio / feature_size;
-// RAINER END
-}
-#else
-correction_ratio = weight_scale * (!feature->tilted ? 1 : 0.5);
-#endif
-
-if( !feature->tilted )
-{
-hidfeature->rect[k].p0 = tr.y * rows + tr.x;
-hidfeature->rect[k].p1 = tr.y * rows + tr.x + tr.width;
-hidfeature->rect[k].p2 = (tr.y + tr.height) * rows + tr.x;
-hidfeature->rect[k].p3 = (tr.y + tr.height) * rows + tr.x + tr.width;
-
-}
-else
-{
-hidfeature->rect[k].p2 = (tr.y + tr.width) * rows + tr.x + tr.width;
-hidfeature->rect[k].p3 = (tr.y + tr.width + tr.height) * rows + tr.x + tr.width - tr.height;
-hidfeature->rect[k].p0 = tr.y*rows + tr.x;
-hidfeature->rect[k].p1 = (tr.y + tr.height) * rows + tr.x - tr.height;
-
-}
-
-//hidfeature->rect[k].weight = (float)(feature->rect[k].weight * correction_ratio);
-
-if( k == 0 )
-area0 = tr.width * tr.height;
-else
-;// sum0 += hidfeature->rect[k].weight * tr.width * tr.height;
-}
-
-//hidfeature->rect[0].weight = (float)(-sum0/area0);*/
-// } /* l */
-// } /* j */
-// }
-//}
-/*
-CV_INLINE
-double gpuEvalHidHaarClassifier( GpuHidHaarClassifier *classifier,
-double variance_norm_factor,
-size_t p_offset )
-{
-
- int idx = 0;
- do
- {
- GpuHidHaarTreeNode* node = classifier->node + idx;
- double t = node->threshold * variance_norm_factor;
-
- double sum = calc_sum(node->feature.rect[0],p_offset) * node->feature.rect[0].weight;
- sum += calc_sum(node->feature.rect[1],p_offset) * node->feature.rect[1].weight;
-
- if( node->feature.rect[2].p0 )
- sum += calc_sum(node->feature.rect[2],p_offset) * node->feature.rect[2].weight;
-
- idx = sum < t ? node->left : node->right;
- }
- while( idx > 0 );
- return classifier->alpha[-idx];
-
- return 0.;
-}
-
-
-*/
-static int gpuRunHaarClassifierCascade( /*const CvHaarClassifierCascade *_cascade,
-CvPoint pt, int start_stage */)
-{
- /*
- int result = -1;
-
- int p_offset, pq_offset;
- int i, j;
- double mean, variance_norm_factor;
- GpuHidHaarClassifierCascade* cascade;
-
- if( !CV_IS_HAAR_CLASSIFIER(_cascade) )
- CV_Error( !_cascade ? CV_StsNullPtr : CV_StsBadArg, "Invalid cascade pointer" );
-
- cascade = (GpuHidHaarClassifierCascade*) _cascade->hid_cascade;
- if( !cascade )
- CV_Error( CV_StsNullPtr, "Hidden cascade has not been created.\n"
- "Use gpuSetImagesForHaarClassifierCascade" );
-
- if( pt.x < 0 || pt.y < 0 ||
- pt.x + _cascade->real_window_size.width >= cascade->sum.width-2 ||
- pt.y + _cascade->real_window_size.height >= cascade->sum.height-2 )
- return -1;
-
- p_offset = pt.y * (cascade->sum.step/sizeof(sumtype)) + pt.x;
- pq_offset = pt.y * (cascade->sqsum.step/sizeof(sqsumtype)) + pt.x;
- mean = calc_sum(*cascade,p_offset)*cascade->inv_window_area;
- variance_norm_factor = cascade->pq0[pq_offset] - cascade->pq1[pq_offset] -
- cascade->pq2[pq_offset] + cascade->pq3[pq_offset];
- variance_norm_factor = variance_norm_factor*cascade->inv_window_area - mean*mean;
- if( variance_norm_factor >= 0. )
- variance_norm_factor = sqrt(variance_norm_factor);
- else
- variance_norm_factor = 1.;
-
-
- if( cascade->is_stump_based )
- {
- for( i = start_stage; i < cascade->count; i++ )
- {
- double stage_sum = 0;
-
- if( cascade->stage_classifier[i].two_rects )
- {
- for( j = 0; j < cascade->stage_classifier[i].count; j++ )
- {
- GpuHidHaarClassifier* classifier = cascade->stage_classifier[i].classifier + j;
- GpuHidHaarTreeNode* node = classifier->node;
- double t = node->threshold*variance_norm_factor;
- double sum = calc_sum(node->feature.rect[0],p_offset) * node->feature.rect[0].weight;
- sum += calc_sum(node->feature.rect[1],p_offset) * node->feature.rect[1].weight;
- stage_sum += classifier->alpha[sum >= t];
- }
- }
- else
- {
- for( j = 0; j < cascade->stage_classifier[i].count; j++ )
- {
- GpuHidHaarClassifier* classifier = cascade->stage_classifier[i].classifier + j;
- GpuHidHaarTreeNode* node = classifier->node;
- double t = node->threshold*variance_norm_factor;
- double sum = calc_sum(node->feature.rect[0],p_offset) * node->feature.rect[0].weight;
- sum += calc_sum(node->feature.rect[1],p_offset) * node->feature.rect[1].weight;
- if( node->feature.rect[2].p0 )
- sum += calc_sum(node->feature.rect[2],p_offset) * node->feature.rect[2].weight;
-
- stage_sum += classifier->alpha[sum >= t];
- }
- }
-
- if( stage_sum < cascade->stage_classifier[i].threshold )
- return -i;
- }
- }
- */
return 1;
}
-
namespace cv
{
namespace ocl
}
}
-
-/*
-typedef struct _ALIGNED_ON(128) GpuHidHaarFeature
-{
-struct _ALIGNED_ON(32)
-{
-int p0 _ALIGNED_ON(4);
-int p1 _ALIGNED_ON(4);
-int p2 _ALIGNED_ON(4);
-int p3 _ALIGNED_ON(4);
-float weight _ALIGNED_ON(4);
-}
-rect[CV_HAAR_FEATURE_MAX] _ALIGNED_ON(32);
-}
-GpuHidHaarFeature;
-
-
-typedef struct _ALIGNED_ON(128) GpuHidHaarTreeNode
-{
-int left _ALIGNED_ON(4);
-int right _ALIGNED_ON(4);
-float threshold _ALIGNED_ON(4);
-int p0[CV_HAAR_FEATURE_MAX] _ALIGNED_ON(16);
-int p1[CV_HAAR_FEATURE_MAX] _ALIGNED_ON(16);
-int p2[CV_HAAR_FEATURE_MAX] _ALIGNED_ON(16);
-int p3[CV_HAAR_FEATURE_MAX] _ALIGNED_ON(16);
-float weight[CV_HAAR_FEATURE_MAX] _ALIGNED_ON(16);
-float alpha[2] _ALIGNED_ON(8);
-// GpuHidHaarFeature feature __attribute__((aligned (128)));
-}
-GpuHidHaarTreeNode;
-
-
-typedef struct _ALIGNED_ON(32) GpuHidHaarClassifier
-{
-int count _ALIGNED_ON(4);
-//CvHaarFeature* orig_feature;
-GpuHidHaarTreeNode* node _ALIGNED_ON(8);
-float* alpha _ALIGNED_ON(8);
-}
-GpuHidHaarClassifier;
-
-
-typedef struct _ALIGNED_ON(64) __attribute__((aligned (64))) GpuHidHaarStageClassifier
-{
-int count _ALIGNED_ON(4);
-float threshold _ALIGNED_ON(4);
-int two_rects _ALIGNED_ON(4);
-GpuHidHaarClassifier* classifier _ALIGNED_ON(8);
-struct GpuHidHaarStageClassifier* next _ALIGNED_ON(8);
-struct GpuHidHaarStageClassifier* child _ALIGNED_ON(8);
-struct GpuHidHaarStageClassifier* parent _ALIGNED_ON(8);
-}
-GpuHidHaarStageClassifier;
-
-
-typedef struct _ALIGNED_ON(64) GpuHidHaarClassifierCascade
-{
-int count _ALIGNED_ON(4);
-int is_stump_based _ALIGNED_ON(4);
-int has_tilted_features _ALIGNED_ON(4);
-int is_tree _ALIGNED_ON(4);
-int pq0 _ALIGNED_ON(4);
-int pq1 _ALIGNED_ON(4);
-int pq2 _ALIGNED_ON(4);
-int pq3 _ALIGNED_ON(4);
-int p0 _ALIGNED_ON(4);
-int p1 _ALIGNED_ON(4);
-int p2 _ALIGNED_ON(4);
-int p3 _ALIGNED_ON(4);
-float inv_window_area _ALIGNED_ON(4);
-// GpuHidHaarStageClassifier* stage_classifier __attribute__((aligned (8)));
-}GpuHidHaarClassifierCascade;
-*/
-/* End of file. */
projects / platform / upstream / opencv.git / commitdiff