#include "precomp.hpp"

#include "opencl_kernels.hpp"

using namespace cv;

using namespace cv::ocl;

#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;

struct CvHidHaarClassifierCascade

};

typedef struct

{

int width_height;

int grpnumperline_totalgrp;

int imgoff;

float factor;

} detect_piramid_info;

#ifdef _MSC_VER

#define _ALIGNED_ON(_ALIGNMENT) __declspec(align(_ALIGNMENT))

typedef _ALIGNED_ON(128) struct GpuHidHaarTreeNode

}

GpuHidHaarTreeNode;

typedef _ALIGNED_ON(32) struct GpuHidHaarClassifier

}

GpuHidHaarClassifier;

typedef _ALIGNED_ON(64) struct GpuHidHaarStageClassifier

}

GpuHidHaarStageClassifier;

typedef _ALIGNED_ON(64) struct GpuHidHaarClassifierCascade

} GpuHidHaarClassifierCascade;

#else

#define _ALIGNED_ON(_ALIGNMENT) __attribute__((aligned(_ALIGNMENT) ))

typedef struct _ALIGNED_ON(128) GpuHidHaarTreeNode

{

int p[CV_HAAR_FEATURE_MAX][4] _ALIGNED_ON(64);

float weight[CV_HAAR_FEATURE_MAX];// _ALIGNED_ON(16);

float threshold;// _ALIGNED_ON(4);

float alpha[3] _ALIGNED_ON(16);

int left _ALIGNED_ON(4);

int right _ALIGNED_ON(4);

}

GpuHidHaarTreeNode;

typedef struct _ALIGNED_ON(32) GpuHidHaarClassifier

{

int count _ALIGNED_ON(4);

GpuHidHaarTreeNode *node _ALIGNED_ON(8);

float *alpha _ALIGNED_ON(8);

}

GpuHidHaarClassifier;

typedef struct _ALIGNED_ON(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);

} GpuHidHaarClassifierCascade;

#endif

const float icv_stage_threshold_bias = 0.0001f;

double globaltime = 0;

static GpuHidHaarClassifierCascade * gpuCreateHidHaarClassifierCascade( CvHaarClassifierCascade *cascade, int *size, int *totalclassifier)

{

GpuHidHaarClassifierCascade *out = 0;

int i, j, k, l;

int datasize;

int total_classifiers = 0;

int total_nodes = 0;

char errorstr[256];

GpuHidHaarStageClassifier *stage_classifier_ptr;

GpuHidHaarClassifier *haar_classifier_ptr;

GpuHidHaarTreeNode *haar_node_ptr;

CvSize orig_window_size;

int has_tilted_features = 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 );

}

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(GpuHidHaarClassifierCascade) +

sizeof(GpuHidHaarStageClassifier) * cascade->count +

sizeof(GpuHidHaarClassifier) * total_classifiers +

sizeof(GpuHidHaarTreeNode) * total_nodes;

*totalclassifier = total_classifiers;

*size = datasize;

out = (GpuHidHaarClassifierCascade *)cvAlloc( datasize );

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

/* init header */

out->count = cascade->count;

stage_classifier_ptr = (GpuHidHaarStageClassifier *)(out + 1);

haar_classifier_ptr = (GpuHidHaarClassifier *)(stage_classifier_ptr + cascade->count);

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

out->is_stump_based = 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;

GpuHidHaarStageClassifier *hid_stage_classifier = stage_classifier_ptr + 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;

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

{

CvHaarClassifier *classifier = stage_classifier->classifier + j;

GpuHidHaarClassifier *hid_classifier = hid_stage_classifier->classifier + j;

int node_count = classifier->count;

float *alpha_ptr = &haar_node_ptr->alpha[0];

hid_classifier->count = node_count;

hid_classifier->node = haar_node_ptr;

hid_classifier->alpha = alpha_ptr;

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

{

GpuHidHaarTreeNode *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 )

{

node->p[2][0] = 0;

node->p[2][1] = 0;

node->p[2][2] = 0;

node->p[2][3] = 0;

node->weight[2] = 0;

}

else

hid_stage_classifier->two_rects = 0;

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

haar_node_ptr = haar_node_ptr + 1;

}

out->is_stump_based &= node_count == 1;

}

}

cascade->hid_cascade = (CvHidHaarClassifierCascade *)out;

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

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])

static void gpuSetImagesForHaarClassifierCascade( CvHaarClassifierCascade *_cascade,

}

static void gpuSetHaarClassifierCascade( CvHaarClassifierCascade *_cascade)

}

CvSeq *cv::ocl::OclCascadeClassifier::oclHaarDetectObjects( oclMat &gimg, CvMemStorage *storage, double scaleFactor,

int minNeighbors, int flags, CvSize minSize, CvSize maxSize)

{

CvHaarClassifierCascade *cascade = oldCascade;

const double GROUP_EPS = 0.2;

CvSeq *result_seq = 0;

cv::ConcurrentRectVector allCandidates;

std::vector<cv::Rect> rectList;

std::vector<int> rweights;

double factor;

int datasize=0;

int totalclassifier=0;

GpuHidHaarClassifierCascade *gcascade;

GpuHidHaarStageClassifier *stage;

GpuHidHaarClassifier *classifier;

GpuHidHaarTreeNode *node;

int *candidate;

cl_int status;

bool findBiggestObject = (flags & CV_HAAR_FIND_BIGGEST_OBJECT) != 0;

if( maxSize.height == 0 || maxSize.width == 0 )

{

maxSize.height = gimg.rows;

maxSize.width = gimg.cols;

}

if( !CV_IS_HAAR_CLASSIFIER(cascade) )

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

if( !storage )

CV_Error( CV_StsNullPtr, "Null storage pointer" );

if( CV_MAT_DEPTH(gimg.type()) != CV_8U )

CV_Error( CV_StsUnsupportedFormat, "Only 8-bit images are supported" );

if( scaleFactor <= 1 )

CV_Error( CV_StsOutOfRange, "scale factor must be > 1" );

if( findBiggestObject )

flags &= ~CV_HAAR_SCALE_IMAGE;

if( !cascade->hid_cascade )

gpuCreateHidHaarClassifierCascade(cascade, &datasize, &totalclassifier);

result_seq = cvCreateSeq( 0, sizeof(CvSeq), sizeof(CvAvgComp), storage );

if( CV_MAT_CN(gimg.type()) > 1 )

{

oclMat gtemp;

cvtColor( gimg, gtemp, CV_BGR2GRAY );

gimg = gtemp;

}

if( findBiggestObject )

flags &= ~(CV_HAAR_SCALE_IMAGE | CV_HAAR_DO_CANNY_PRUNING);

if( gimg.cols < minSize.width || gimg.rows < minSize.height )

CV_Error(CV_StsError, "Image too small");

cl_command_queue qu = getClCommandQueue(Context::getContext());

if( (flags & CV_HAAR_SCALE_IMAGE) )

{

CvSize winSize0 = cascade->orig_window_size;

int totalheight = 0;

int indexy = 0;

CvSize sz;

vector<CvSize> sizev;

vector<float> scalev;

for(factor = 1.f;; factor *= scaleFactor)

{

CvSize winSize = { cvRound(winSize0.width * factor), cvRound(winSize0.height * factor) };

sz.width = cvRound( gimg.cols / factor ) + 1;

sz.height = cvRound( gimg.rows / factor ) + 1;

CvSize sz1 = { sz.width - winSize0.width - 1, sz.height - winSize0.height - 1 };

if( sz1.width <= 0 || sz1.height <= 0 )

break;

if( winSize.width > maxSize.width || winSize.height > maxSize.height )

break;

if( winSize.width < minSize.width || winSize.height < minSize.height )

continue;

totalheight += sz.height;

sizev.push_back(sz);

scalev.push_back(factor);

}

oclMat gimg1(gimg.rows, gimg.cols, CV_8UC1);

oclMat gsum(totalheight + 4, gimg.cols + 1, CV_32SC1);

oclMat gsqsum(totalheight + 4, gimg.cols + 1, CV_32FC1);

cl_mem stagebuffer;

cl_mem nodebuffer;

cl_mem candidatebuffer;

cl_mem scaleinfobuffer;

cv::Rect roi, roi2;

cv::Mat imgroi, imgroisq;

cv::ocl::oclMat resizeroi, gimgroi, gimgroisq;

int grp_per_CU = 12;

size_t blocksize = 8;

size_t localThreads[3] = { blocksize, blocksize , 1 };

size_t globalThreads[3] = { grp_per_CU *(gsum.clCxt->getDeviceInfo().maxComputeUnits) *localThreads[0],

localThreads[1], 1

};

int outputsz = 256 * globalThreads[0] / localThreads[0];

int loopcount = sizev.size();

detect_piramid_info *scaleinfo = (detect_piramid_info *)malloc(sizeof(detect_piramid_info) * loopcount);

for( int i = 0; i < loopcount; i++ )

{

sz = sizev[i];

factor = scalev[i];

roi = Rect(0, indexy, sz.width, sz.height);

roi2 = Rect(0, 0, sz.width - 1, sz.height - 1);

resizeroi = gimg1(roi2);

gimgroi = gsum(roi);

gimgroisq = gsqsum(roi);

int width = gimgroi.cols - 1 - cascade->orig_window_size.width;

int height = gimgroi.rows - 1 - cascade->orig_window_size.height;

scaleinfo[i].width_height = (width << 16) | height;

int grpnumperline = (width + localThreads[0] - 1) / localThreads[0];

int totalgrp = ((height + localThreads[1] - 1) / localThreads[1]) * grpnumperline;

scaleinfo[i].grpnumperline_totalgrp = (grpnumperline << 16) | totalgrp;

scaleinfo[i].imgoff = gimgroi.offset >> 2;

scaleinfo[i].factor = factor;

cv::ocl::resize(gimg, resizeroi, Size(sz.width - 1, sz.height - 1), 0, 0, INTER_LINEAR);

cv::ocl::integral(resizeroi, gimgroi, gimgroisq);

indexy += sz.height;

}

gcascade = (GpuHidHaarClassifierCascade *)cascade->hid_cascade;

stage = (GpuHidHaarStageClassifier *)(gcascade + 1);

classifier = (GpuHidHaarClassifier *)(stage + gcascade->count);

node = (GpuHidHaarTreeNode *)(classifier->node);

int nodenum = (datasize - sizeof(GpuHidHaarClassifierCascade) -

sizeof(GpuHidHaarStageClassifier) * gcascade->count - sizeof(GpuHidHaarClassifier) * totalclassifier) / sizeof(GpuHidHaarTreeNode);

candidate = (int *)malloc(4 * sizeof(int) * outputsz);

gpuSetImagesForHaarClassifierCascade( cascade, 1., gsum.step / 4 );

stagebuffer = openCLCreateBuffer(gsum.clCxt, CL_MEM_READ_ONLY, sizeof(GpuHidHaarStageClassifier) * gcascade->count);

openCLSafeCall(clEnqueueWriteBuffer(qu, stagebuffer, 1, 0, sizeof(GpuHidHaarStageClassifier)*gcascade->count, stage, 0, NULL, NULL));

nodebuffer = openCLCreateBuffer(gsum.clCxt, CL_MEM_READ_ONLY, nodenum * sizeof(GpuHidHaarTreeNode));

openCLSafeCall(clEnqueueWriteBuffer(qu, nodebuffer, 1, 0, nodenum * sizeof(GpuHidHaarTreeNode),

node, 0, NULL, NULL));

candidatebuffer = openCLCreateBuffer(gsum.clCxt, CL_MEM_WRITE_ONLY, 4 * sizeof(int) * outputsz);

scaleinfobuffer = openCLCreateBuffer(gsum.clCxt, CL_MEM_READ_ONLY, sizeof(detect_piramid_info) * loopcount);

openCLSafeCall(clEnqueueWriteBuffer(qu, scaleinfobuffer, 1, 0, sizeof(detect_piramid_info)*loopcount, scaleinfo, 0, NULL, NULL));

int startstage = 0;

int endstage = gcascade->count;

int startnode = 0;

int pixelstep = gsum.step / 4;

int splitstage = 3;

int splitnode = stage[0].count + stage[1].count + stage[2].count;

cl_int4 p, pq;

p.s[0] = gcascade->p0;

p.s[1] = gcascade->p1;

p.s[2] = gcascade->p2;

p.s[3] = gcascade->p3;

pq.s[0] = gcascade->pq0;

pq.s[1] = gcascade->pq1;

pq.s[2] = gcascade->pq2;

pq.s[3] = gcascade->pq3;

float correction = gcascade->inv_window_area;

vector<pair<size_t, const void *> > args;

args.push_back ( make_pair(sizeof(cl_mem) , (void *)&stagebuffer ));

args.push_back ( make_pair(sizeof(cl_mem) , (void *)&scaleinfobuffer ));

args.push_back ( make_pair(sizeof(cl_mem) , (void *)&nodebuffer ));

args.push_back ( make_pair(sizeof(cl_mem) , (void *)&gsum.data ));

args.push_back ( make_pair(sizeof(cl_mem) , (void *)&gsqsum.data ));

args.push_back ( make_pair(sizeof(cl_mem) , (void *)&candidatebuffer ));

args.push_back ( make_pair(sizeof(cl_int) , (void *)&pixelstep ));

args.push_back ( make_pair(sizeof(cl_int) , (void *)&loopcount ));

args.push_back ( make_pair(sizeof(cl_int) , (void *)&startstage ));

args.push_back ( make_pair(sizeof(cl_int) , (void *)&splitstage ));

args.push_back ( make_pair(sizeof(cl_int) , (void *)&endstage ));

args.push_back ( make_pair(sizeof(cl_int) , (void *)&startnode ));

args.push_back ( make_pair(sizeof(cl_int) , (void *)&splitnode ));

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 ));

if(gcascade->is_stump_based && gsum.clCxt->supportsFeature(FEATURE_CL_INTEL_DEVICE))

{

//setup local group size for "pixel step" = 1

localThreads[0] = 16;

localThreads[1] = 32;

localThreads[2] = 1;

//calc maximal number of workgroups

int WGNumX = 1+(sizev[0].width /(localThreads[0]));

int WGNumY = 1+(sizev[0].height/(localThreads[1]));

int WGNumZ = loopcount;

int WGNumTotal = 0; //accurate number of non-empty workgroups

int WGNumSampled = 0; //accurate number of workgroups processed only 1/4 part of all pixels. it is made for large images with scale <= 2

oclMat oclWGInfo(1,sizeof(cl_int4) * WGNumX*WGNumY*WGNumZ,CV_8U);

{

cl_int4* pWGInfo = (cl_int4*)clEnqueueMapBuffer(getClCommandQueue(oclWGInfo.clCxt),(cl_mem)oclWGInfo.datastart,true,CL_MAP_WRITE, 0, oclWGInfo.step, 0,0,0,&status);

openCLVerifyCall(status);

for(int z=0;z<WGNumZ;++z)

{

int Width = (scaleinfo[z].width_height >> 16)&0xFFFF;

int Height = (scaleinfo[z].width_height >> 0 )& 0xFFFF;

for(int y=0;y<WGNumY;++y)

{

int gy = y*localThreads[1];

if(gy>=Height)

continue; // no data to process

for(int x=0;x<WGNumX;++x)

{

int gx = x*localThreads[0];

if(gx>=Width)

continue; // no data to process

if(scaleinfo[z].factor<=2)

{

WGNumSampled++;

}

// save no-empty workgroup info into array

pWGInfo[WGNumTotal].s[0] = scaleinfo[z].width_height;

pWGInfo[WGNumTotal].s[1] = (gx << 16) | gy;

pWGInfo[WGNumTotal].s[2] = scaleinfo[z].imgoff;

memcpy(&(pWGInfo[WGNumTotal].s[3]),&(scaleinfo[z].factor),sizeof(float));

WGNumTotal++;

}

}

}

openCLSafeCall(clEnqueueUnmapMemObject(getClCommandQueue(oclWGInfo.clCxt),(cl_mem)oclWGInfo.datastart,pWGInfo,0,0,0));

pWGInfo = NULL;

}

#define NODE_SIZE 12

// pack node info to have less memory loads on the device side

oclMat oclNodesPK(1,sizeof(cl_int) * NODE_SIZE * nodenum,CV_8U);

{

cl_int localStatus;

cl_int* pNodesPK = (cl_int*)clEnqueueMapBuffer(getClCommandQueue(oclNodesPK.clCxt),(cl_mem)oclNodesPK.datastart,true,CL_MAP_WRITE, 0, oclNodesPK.step, 0,0,0,&localStatus);

openCLVerifyCall(localStatus);

//use known local data stride to precalulate indexes

int DATA_SIZE_X = (localThreads[0]+cascade->orig_window_size.width);

// check that maximal value is less than maximal unsigned short

assert(DATA_SIZE_X*cascade->orig_window_size.height+cascade->orig_window_size.width < (int)USHRT_MAX);

for(int i = 0;i<nodenum;++i)

{//process each node from classifier

struct NodePK

};

struct NodePK * pOut = (struct NodePK *)(pNodesPK + NODE_SIZE*i);

for(int k=0;k<3;++k)

{// calc 4 short indexes in shared local mem for each rectangle instead of 2 (x,y) pair.

int* lp = &(node[i].p[k][0]);

pOut->slm_index[k][0] = (unsigned short)(lp[1]*DATA_SIZE_X+lp[0]);

pOut->slm_index[k][1] = (unsigned short)(lp[1]*DATA_SIZE_X+lp[2]);

pOut->slm_index[k][2] = (unsigned short)(lp[3]*DATA_SIZE_X+lp[0]);

pOut->slm_index[k][3] = (unsigned short)(lp[3]*DATA_SIZE_X+lp[2]);

}

//store used float point values for each node

pOut->weight[0] = node[i].weight[0];

pOut->weight[1] = node[i].weight[1];

pOut->weight[2] = node[i].weight[2];

pOut->threshold = node[i].threshold;

pOut->alpha[0] = node[i].alpha[0];

pOut->alpha[1] = node[i].alpha[1];

}

openCLSafeCall(clEnqueueUnmapMemObject(getClCommandQueue(oclNodesPK.clCxt),(cl_mem)oclNodesPK.datastart,pNodesPK,0,0,0));

pNodesPK = NULL;

}

// add 2 additional buffers (WGinfo and packed nodes) as 2 last args

args.push_back ( make_pair(sizeof(cl_mem) , (void *)&oclNodesPK.datastart ));

args.push_back ( make_pair(sizeof(cl_mem) , (void *)&oclWGInfo.datastart ));

//form build options for kernel

string options = "-D PACKED_CLASSIFIER";

options += format(" -D NODE_SIZE=%d",NODE_SIZE);

options += format(" -D WND_SIZE_X=%d",cascade->orig_window_size.width);

options += format(" -D WND_SIZE_Y=%d",cascade->orig_window_size.height);

options += format(" -D STUMP_BASED=%d",gcascade->is_stump_based);

options += format(" -D SPLITNODE=%d",splitnode);

options += format(" -D SPLITSTAGE=%d",splitstage);

options += format(" -D OUTPUTSZ=%d",outputsz);

// init candiate global count by 0

int pattern = 0;

openCLSafeCall(clEnqueueWriteBuffer(qu, candidatebuffer, 1, 0, 1 * sizeof(pattern),&pattern, 0, NULL, NULL));

if(WGNumTotal>WGNumSampled)

{// small images and each pixel is processed

// setup global sizes to have linear array of workgroups with WGNum size

int pstep = 1;

size_t LS[3]={localThreads[0]/pstep,localThreads[1]/pstep,1};

globalThreads[0] = LS[0]*(WGNumTotal-WGNumSampled);

globalThreads[1] = LS[1];

globalThreads[2] = 1;

string options1 = options;

options1 += format(" -D PIXEL_STEP=%d",pstep);

options1 += format(" -D WGSTART=%d",WGNumSampled);

options1 += format(" -D LSx=%d",LS[0]);

options1 += format(" -D LSy=%d",LS[1]);

// execute face detector

openCLExecuteKernel(gsum.clCxt, &haarobjectdetect, "gpuRunHaarClassifierCascadePacked", globalThreads, LS, args, -1, -1, options1.c_str());

}

if(WGNumSampled>0)

{// large images each 4th pixel is processed

// setup global sizes to have linear array of workgroups with WGNum size

int pstep = 2;

size_t LS[3]={localThreads[0]/pstep,localThreads[1]/pstep,1};

globalThreads[0] = LS[0]*WGNumSampled;

globalThreads[1] = LS[1];

globalThreads[2] = 1;

string options2 = options;

options2 += format(" -D PIXEL_STEP=%d",pstep);

options2 += format(" -D WGSTART=%d",0);

options2 += format(" -D LSx=%d",LS[0]);

options2 += format(" -D LSy=%d",LS[1]);

// execute face detector

openCLExecuteKernel(gsum.clCxt, &haarobjectdetect, "gpuRunHaarClassifierCascadePacked", globalThreads, LS, args, -1, -1, options2.c_str());

}

//read candidate buffer back and put it into host list

openCLReadBuffer( gsum.clCxt, candidatebuffer, candidate, 4 * sizeof(int)*outputsz );

assert(candidate[0]<outputsz);

//printf("candidate[0]=%d\n",candidate[0]);

for(int i = 1; i <= candidate[0]; i++)

{

allCandidates.push_back(Rect(candidate[4 * i], candidate[4 * i + 1],candidate[4 * i + 2], candidate[4 * i + 3]));

}

}

else

{