void CvArrTest::get_timing_test_array_types_and_sizes( int /*test_case_idx*/, CvSize** sizes, int** types,
CvSize** whole_sizes, bool *are_images )
{
const CvFileNode* size_node = find_timing_param( "size" );
const CvFileNode* depth_node = find_timing_param( "depth" );
const CvFileNode* channels_node = find_timing_param( "channels" );
int i, j;
int depth = 0, channels = 1;
CvSize size = {1,1}, whole_size = size;
if( size_node && CV_NODE_IS_SEQ(size_node->tag) )
{
CvSeq* seq = size_node->data.seq;
size.width = cvReadInt((const CvFileNode*)cvGetSeqElem(seq,0), 1);
size.height = cvReadInt((const CvFileNode*)cvGetSeqElem(seq,1), 1);
whole_size = size;
if( seq->total > 2 )
{
whole_size.width = cvReadInt((const CvFileNode*)cvGetSeqElem(seq,2), 1);
whole_size.height = cvReadInt((const CvFileNode*)cvGetSeqElem(seq,3), 1);
whole_size.width = MAX( whole_size.width, size.width );
whole_size.height = MAX( whole_size.height, size.height );
}
}
if( depth_node && CV_NODE_IS_STRING(depth_node->tag) )
{
depth = cvTsTypeByName( depth_node->data.str.ptr );
if( depth < 0 || depth > CV_64F )
depth = 0;
}
if( channels_node && CV_NODE_IS_INT(channels_node->tag) )
{
channels = cvReadInt( channels_node, 1 );
if( channels < 0 || channels > CV_CN_MAX )
channels = 1;
}
for( i = 0; i < max_arr; i++ )
{
int count = test_array[i].size();
for( j = 0; j < count; j++ )
{
sizes[i][j] = size;
whole_sizes[i][j] = whole_size;
if( i != MASK )
types[i][j] = CV_MAKETYPE(depth,channels);
else
types[i][j] = CV_8UC1;
if( i == REF_OUTPUT || i == REF_INPUT_OUTPUT )
sizes[i][j] = cvSize(0,0);
}
}
if( are_images )
*are_images = false; // by default CvMat is used in performance tests
}
void CvGBTrees::read_params( CvFileStorage* fs, CvFileNode* fnode )
{
CV_FUNCNAME( "CvGBTrees::read_params" );
__BEGIN__;
CvFileNode* temp;
if( !fnode || !CV_NODE_IS_MAP(fnode->tag) )
return;
data = new CvDTreeTrainData();
CV_CALL( data->read_params(fs, fnode));
data->shared = true;
params.max_depth = data->params.max_depth;
params.min_sample_count = data->params.min_sample_count;
params.max_categories = data->params.max_categories;
params.priors = data->params.priors;
params.regression_accuracy = data->params.regression_accuracy;
params.use_surrogates = data->params.use_surrogates;
temp = cvGetFileNodeByName( fs, fnode, "loss_function" );
if( !temp )
EXIT;
if( temp && CV_NODE_IS_STRING(temp->tag) )
{
const char* loss_function_type_str = cvReadString( temp, "" );
params.loss_function_type = strcmp( loss_function_type_str, "SquaredLoss" ) == 0 ? SQUARED_LOSS :
strcmp( loss_function_type_str, "AbsoluteLoss" ) == 0 ? ABSOLUTE_LOSS :
strcmp( loss_function_type_str, "HuberLoss" ) == 0 ? HUBER_LOSS :
strcmp( loss_function_type_str, "DevianceLoss" ) == 0 ? DEVIANCE_LOSS : -1;
}
else
params.loss_function_type = cvReadInt( temp, -1 );
if( params.loss_function_type < SQUARED_LOSS || params.loss_function_type > DEVIANCE_LOSS || params.loss_function_type == 2)
CV_ERROR( CV_StsBadArg, "Unknown loss function" );
params.weak_count = cvReadIntByName( fs, fnode, "ensemble_length" );
params.shrinkage = (float)cvReadRealByName( fs, fnode, "shrinkage", 0.1 );
params.subsample_portion = (float)cvReadRealByName( fs, fnode, "subsample_portion", 1.0 );
if (data->is_classifier)
{
class_labels = (CvMat*)cvReadByName( fs, fnode, "class_labels" );
if( class_labels && !CV_IS_MAT(class_labels))
CV_ERROR( CV_StsParseError, "class_labels must stored as a matrix");
}
data->is_classifier = 0;
__END__;
}
static CvTestSeqElem* icvTestSeqReadElemOne(CvTestSeq_* pTS, CvFileStorage* fs, CvFileNode* node)
{
int noise_type = CV_NOISE_NONE;;
CvTestSeqElem* pElem = NULL;
const char* pVideoName = cvReadStringByName( fs, node,"Video", NULL);
const char* pVideoObjName = cvReadStringByName( fs, node,"VideoObj", NULL);
if(pVideoName)
{ /* Check to noise flag: */
if( cv_stricmp(pVideoName,"noise_gaussian") == 0 ||
cv_stricmp(pVideoName,"noise_normal") == 0) noise_type = CV_NOISE_GAUSSIAN;
if( cv_stricmp(pVideoName,"noise_uniform") == 0) noise_type = CV_NOISE_UNIFORM;
if( cv_stricmp(pVideoName,"noise_speckle") == 0) noise_type = CV_NOISE_SPECKLE;
if( cv_stricmp(pVideoName,"noise_salt_and_pepper") == 0) noise_type = CV_NOISE_SALT_AND_PEPPER;
}
if((pVideoName || pVideoObjName ) && noise_type == CV_NOISE_NONE)
{ /* Read other elements: */
if(pVideoName) pElem = icvTestSeqReadElemAll(pTS, fs, pVideoName);
if(pVideoObjName)
{
CvTestSeqElem* pE;
pElem = icvTestSeqReadElemAll(pTS, fs, pVideoObjName);
for(pE=pElem;pE;pE=pE->next)
{
pE->ObjID = pTS->ObjNum;
pE->pObjName = pVideoObjName;
}
pTS->ObjNum++;
}
} /* Read other elements. */
else
{ /* Create new element: */
CvFileNode* pPosNode = cvGetFileNodeByName( fs, node,"Pos");
CvFileNode* pSizeNode = cvGetFileNodeByName( fs, node,"Size");
int AutoSize = (pSizeNode && CV_NODE_IS_STRING(pSizeNode->tag) && cv_stricmp("auto",cvReadString(pSizeNode,""))==0);
int AutoPos = (pPosNode && CV_NODE_IS_STRING(pPosNode->tag) && cv_stricmp("auto",cvReadString(pPosNode,""))==0);
const char* pFileName = cvReadStringByName( fs, node,"File", NULL);
pElem = (CvTestSeqElem*)cvAlloc(sizeof(CvTestSeqElem));
memset(pElem,0,sizeof(CvTestSeqElem));
pElem->ObjID = -1;
pElem->noise_type = noise_type;
cvRandInit( &pElem->rnd_state, 1, 0, 0,CV_RAND_NORMAL);
if(pFileName && pElem->noise_type == CV_NOISE_NONE)
{ /* If AVI or BMP: */
size_t l = strlen(pFileName);
pElem->pFileName = pFileName;
pElem->type = SRC_TYPE_IMAGE;
if(cv_stricmp(".avi",pFileName+l-4) == 0)pElem->type = SRC_TYPE_AVI;
if(pElem->type == SRC_TYPE_IMAGE)
{
//pElem->pImg = cvLoadImage(pFileName);
if(pElem->pImg)
{
pElem->FrameNum = 1;
if(pElem->pImgMask)cvReleaseImage(&(pElem->pImgMask));
pElem->pImgMask = cvCreateImage(
cvSize(pElem->pImg->width,pElem->pImg->height),
IPL_DEPTH_8U,1);
icvTestSeqCreateMask(pElem->pImg,pElem->pImgMask,FG_BG_THRESHOLD);
}
}
if(pElem->type == SRC_TYPE_AVI && pFileName)
{
//pElem->pAVI = cvCaptureFromFile(pFileName);
if(pElem->pAVI)
{
IplImage* pImg = 0;//cvQueryFrame(pElem->pAVI);
pElem->pImg = cvCloneImage(pImg);
pElem->pImg->origin = 0;
//cvSetCaptureProperty(pElem->pAVI,CV_CAP_PROP_POS_FRAMES,0);
pElem->FrameBegin = 0;
pElem->AVILen = pElem->FrameNum = 0;//(int)cvGetCaptureProperty(pElem->pAVI, CV_CAP_PROP_FRAME_COUNT);
//cvReleaseCapture(&pElem->pAVI);
pElem->pAVI = NULL;
}
else
{
printf("WARNING!!! Cannot open avi file %s\n",pFileName);
}
}
} /* If AVI or BMP. */
if(pPosNode)
{ /* Read positions: */
if(CV_NODE_IS_SEQ(pPosNode->tag))
{
int num = pPosNode->data.seq->total;
pElem->pPos = (CvPoint2D32f*)cvAlloc(sizeof(float)*num);
cvReadRawData( fs, pPosNode, pElem->pPos, "f" );
pElem->PosNum = num/2;
if(pElem->FrameNum == 0) pElem->FrameNum = pElem->PosNum;
}
}
if(pSizeNode)
{ /* Read sizes: */
if(CV_NODE_IS_SEQ(pSizeNode->tag))
{
int num = pSizeNode->data.seq->total;
pElem->pSize = (CvPoint2D32f*)cvAlloc(sizeof(float)*num);
cvReadRawData( fs, pSizeNode, pElem->pSize, "f" );
pElem->SizeNum = num/2;
}
}
if(AutoPos || AutoSize)
{ /* Auto size and pos: */
int i;
int num = (pElem->type == SRC_TYPE_AVI)?pElem->AVILen:1;
if(AutoSize)
{
pElem->pSize = (CvPoint2D32f*)cvAlloc(sizeof(CvPoint2D32f)*num);
pElem->SizeNum = num;
}
if(AutoPos)
{
pElem->pPos = (CvPoint2D32f*)cvAlloc(sizeof(CvPoint2D32f)*num);
pElem->PosNum = num;
}
for(i=0; i<num; ++i)
{
IplImage* pFG = NULL;
CvPoint2D32f* pPos = AutoPos?(pElem->pPos + i):NULL;
CvPoint2D32f* pSize = AutoSize?(pElem->pSize + i):NULL;
icvTestSeqQureyFrameElem(pElem,i);
pFG = pElem->pImgMask;
if(pPos)
{
pPos->x = 0.5f;
pPos->y = 0.5f;
}
if(pSize)
{
pSize->x = 0;
pSize->y = 0;
}
if(pFG)
{
double M00;
CvMoments m;
cvMoments( pElem->pImgMask, &m, 0 );
M00 = cvGetSpatialMoment( &m, 0, 0 );
if(M00 > 0 && pSize )
{
double X = cvGetSpatialMoment( &m, 1, 0 )/M00;
double Y = cvGetSpatialMoment( &m, 0, 1 )/M00;
double XX = (cvGetSpatialMoment( &m, 2, 0 )/M00) - X*X;
double YY = (cvGetSpatialMoment( &m, 0, 2 )/M00) - Y*Y;
pSize->x = (float)(4*sqrt(XX))/(pElem->pImgMask->width-1);
pSize->y = (float)(4*sqrt(YY))/(pElem->pImgMask->height-1);
}
if(M00 > 0 && pPos)
{
pPos->x = (float)(cvGetSpatialMoment( &m, 1, 0 )/(M00*(pElem->pImgMask->width-1)));
pPos->y = (float)(cvGetSpatialMoment( &m, 0, 1 )/(M00*(pElem->pImgMask->height-1)));
}
if(pPos)
{ /* Another way to calculate y pos
* using object median:
*/
int y0=0, y1=pFG->height-1;
for(y0=0; y0<pFG->height; ++y0)
{
CvMat m;
CvScalar s = cvSum(cvGetRow(pFG, &m, y0));
if(s.val[0] > 255*7) break;
}
for(y1=pFG->height-1; y1>0; --y1)
{
CvMat m;
CvScalar s = cvSum(cvGetRow(pFG, &m, y1));
if(s.val[0] > 255*7) break;
}
pPos->y = (y0+y1)*0.5f/(pFG->height-1);
}
} /* pFG */
} /* Next frame. */
//if(pElem->pAVI) cvReleaseCapture(&pElem->pAVI);
pElem->pAVI = NULL;
} /* End auto position creation. */
} /* Create new element. */
if(pElem)
{ /* Read transforms and: */
int FirstFrame, LastFrame;
CvTestSeqElem* p=pElem;
CvFileNode* pTransNode = NULL;
CvFileNode* pS = NULL;
int ShiftByPos = 0;
int KeyFrames[1024];
CvSeq* pTransSeq = NULL;
int KeyFrameNum = 0;
pTransNode = cvGetFileNodeByName( fs, node,"Trans");
while( pTransNode &&
CV_NODE_IS_STRING(pTransNode->tag) &&
cv_stricmp("auto",cvReadString(pTransNode,""))!=0)
{ /* Trans is reference: */
pTransNode = cvGetFileNodeByName( fs, NULL,cvReadString(pTransNode,""));
}
pS = cvGetFileNodeByName( fs, node,"Shift");
ShiftByPos = 0;
pTransSeq = pTransNode?(CV_NODE_IS_SEQ(pTransNode->tag)?pTransNode->data.seq:NULL):NULL;
KeyFrameNum = pTransSeq?pTransSeq->total:1;
if( (pS && CV_NODE_IS_STRING(pS->tag) && cv_stricmp("auto",cvReadString(pS,""))==0)
||(pTransNode && CV_NODE_IS_STRING(pTransNode->tag) && cv_stricmp("auto",cvReadString(pTransNode,""))==0))
{
ShiftByPos = 1;
}
FirstFrame = pElem->FrameBegin;
LastFrame = pElem->FrameBegin+pElem->FrameNum-1;
/* Calculate length of video and reallocate
* transformation array:
*/
for(p=pElem; p; p=p->next)
{
int v;
v = cvReadIntByName( fs, node, "BG", -1 );
if(v!=-1)p->BG = v;
v = cvReadIntByName( fs, node, "Mask", -1 );
if(v!=-1)p->Mask = v;
p->FrameBegin += cvReadIntByName( fs, node, "FrameBegin", 0 );
p->FrameNum = cvReadIntByName( fs, node, "FrameNum", p->FrameNum );
p->FrameNum = cvReadIntByName( fs, node, "Dur", p->FrameNum );
{
int LastFrame = cvReadIntByName( fs, node, "LastFrame", p->FrameBegin+p->FrameNum-1 );
p->FrameNum = MIN(p->FrameNum,LastFrame - p->FrameBegin+1);
}
icvTestSeqAllocTrans(p);
{ /* New range estimation: */
int LF = p->FrameBegin+p->FrameNum-1;
if(p==pElem || FirstFrame > p->FrameBegin)FirstFrame = p->FrameBegin;
if(p==pElem || LastFrame < LF)LastFrame = LF;
} /* New range estimation. */
} /* End allocate new transfrom array. */
if(ShiftByPos)
{
for(p=pElem;p;p=p->next)
{ /* Modify transformation to make autoshift: */
int i;
int num = p->FrameNum;
assert(num <= p->TransNum);
p->TransNum = MAX(1,num);
for(i=0; i<num; ++i)
{
CvTSTrans* pT = p->pTrans+i;
//float t = (num>1)?((float)i/(num-1)):0.0f;
float newx = p->pPos[i%p->PosNum].x;
float newy = p->pPos[i%p->PosNum].y;
pT->Shift.x = -newx*pT->Scale.x;
pT->Shift.y = -newy*pT->Scale.y;
if(p->pImg)
{
newx *= p->pImg->width-1;
newy *= p->pImg->height-1;
}
pT->T[2] = -(pT->T[0]*newx+pT->T[1]*newy);
pT->T[5] = -(pT->T[3]*newx+pT->T[4]*newy);
}
} /* Modify transformation old. */
} /* Next record. */
/* Initialize frame number array: */
KeyFrames[0] = FirstFrame;
if(pTransSeq&&KeyFrameNum>1)
{
int i0,i1,i;
for(i=0; i<KeyFrameNum; ++i)
{
CvFileNode* pTN = (CvFileNode*)cvGetSeqElem(pTransSeq,i);
KeyFrames[i] = cvReadIntByName(fs,pTN,"frame",-1);
}
if(KeyFrames[0]<0)KeyFrames[0]=FirstFrame;
if(KeyFrames[KeyFrameNum-1]<0)KeyFrames[KeyFrameNum-1]=LastFrame;
for(i0=0, i1=1; i1<KeyFrameNum;)
{
int i;
for(i1=i0+1; i1<KeyFrameNum && KeyFrames[i1]<0; i1++);
assert(i1<KeyFrameNum);
assert(i1>i0);
for(i=i0+1; i<i1; ++i)
{
KeyFrames[i] = cvRound(KeyFrames[i0] + (float)(i-i0)*(float)(KeyFrames[i1] - KeyFrames[i0])/(float)(i1-i0));
}
i0 = i1;
i1++;
} /* Next key run. */
} /* Initialize frame number array. */
if(pTransNode || pTransSeq)
{ /* More complex transform. */
int param;
CvFileNode* pTN = pTransSeq?(CvFileNode*)cvGetSeqElem(pTransSeq,0):pTransNode;
for(p=pElem; p; p=p->next)
{
//int trans_num = p->TransNum;
for(param=0; param_name[param]; ++param)
{
const char* name = param_name[param];
float defv = param_defval[param];
if(KeyFrameNum==1)
{ /* Only one transform record: */
int i;
double val;
CvFileNode* node = cvGetFileNodeByName( fs, pTN,name);
if(node == NULL) continue;
val = cvReadReal(node,defv);
for(i=0; i<p->TransNum; ++i)
{
icvUpdateTrans(
p->pTrans+i, param, val,
p->pImg?(float)(p->pImg->width-1):1.0f,
p->pImg?(float)(p->pImg->height-1):1.0f);
}
} /* Next record. */
else
{ /* Several transforms: */
int i0,i1;
double v0;
double v1;
CvFileNode* pTN = (CvFileNode*)cvGetSeqElem(pTransSeq,0);
v0 = cvReadRealByName(fs, pTN,name,defv);
for(i1=1,i0=0; i1<KeyFrameNum; ++i1)
{
int f0,f1;
int i;
CvFileNode* pTN = (CvFileNode*)cvGetSeqElem(pTransSeq,i1);
CvFileNode* pVN = cvGetFileNodeByName(fs,pTN,name);
if(pVN)v1 = cvReadReal(pVN,defv);
else if(pVN == NULL && i1 == KeyFrameNum-1) v1 = defv;
else continue;
f0 = KeyFrames[i0];
f1 = KeyFrames[i1];
if(i1==(KeyFrameNum-1)) f1++;
for(i=f0; i<f1; ++i)
{
double val;
double t = (float)(i-f0);
int li = i - p->FrameBegin;
if(li<0) continue;
if(li>= p->TransNum) break;
if(KeyFrames[i1]>KeyFrames[i0]) t /=(float)(KeyFrames[i1]-KeyFrames[i0]);
val = t*(v1-v0)+v0;
icvUpdateTrans(
p->pTrans+li, param, val,
p->pImg?(float)(p->pImg->width-1):1.0f,
p->pImg?(float)(p->pImg->height-1):1.0f);
} /* Next transform. */
i0 = i1;
v0 = v1;
} /* Next value run. */
} /* Several transforms. */
} /* Next parameter. */
} /* Next record. */
} /* More complex transform. */
} /* Read transfroms. */
return pElem;
} /* icvTestSeqReadElemOne */
