float CvGBTrees::predict( const cv::Mat& sample, const cv::Mat& _missing,
const cv::Range& slice, int k ) const
{
CvMat _sample = sample, miss = _missing;
return predict(&_sample, _missing.empty() ? 0 : &miss, 0,
slice==cv::Range::all() ? CV_WHOLE_SEQ : cvSlice(slice.start, slice.end), k);
}
void CvCaptureAVI_VFW::init()
{
avifile = 0;
avistream = 0;
getframe = 0;
memset( &aviinfo, 0, sizeof(aviinfo) );
bmih = 0;
film_range = cvSlice(0,0);
fps = 0;
pos = 0;
frame = 0;
size = cvSize(0,0);
}
void CAviLoader::init()
{
avifile = 0;
avistream = 0;
getframe = 0;
memset( &aviinfo, 0, sizeof(aviinfo) );
bmih = 0;
film_range = cvSlice(0,0);
fps = 0;
pos = 0;
data_offset = 0;
frame = 0;
size = cvSize(0,0);
}
/****************************************************************************************\
triangle attributes calculations
\****************************************************************************************/
static CvStatus
icvCalcTriAttr( const CvSeq * contour, CvPoint t2, CvPoint t1, int n1,
CvPoint t3, int n3, double *s, double *s_c,
double *h, double *a, double *b )
{
double x13, y13, x12, y12, l_base, nx, ny, qq;
double eps = 1.e-5;
x13 = t3.x - t1.x;
y13 = t3.y - t1.y;
x12 = t2.x - t1.x;
y12 = t2.y - t1.y;
qq = x13 * x13 + y13 * y13;
l_base = cvSqrt( (float) (qq) );
if( l_base > eps )
{
nx = y13 / l_base;
ny = -x13 / l_base;
*h = nx * x12 + ny * y12;
*s = (*h) * l_base / 2.;
*b = nx * y12 - ny * x12;
*a = l_base;
/* calculate interceptive area */
*s_c = cvContourArea( contour, cvSlice(n1, n3+1));
}
else
{
*h = 0;
*s = 0;
*s_c = 0;
*b = 0;
*a = 0;
}
return CV_OK;
}
/*
* This Function segments a worm.
* It requires that certain information be present in the WormAnalysisData struct Worm
* It requires Worm->Boundary be full
* It requires that Params->NumSegments be greater than zero
*
*/
int SegmentWorm(WormAnalysisData* Worm, WormAnalysisParam* Params){
if (cvSeqExists(Worm->Boundary) == 0){
printf("Error! No boundary found in SegmentWorm()\n");
return -1;
}
Worm->Segmented->NumSegments=Params->NumSegments;
/***Clear Out any stale Segmented Information Already in the Worm Structure***/
ClearSegmentedInfo(Worm->Segmented);
Worm->Segmented->Head=Worm->Head;
Worm->Segmented->Tail=Worm->Tail;
/*** It would be nice to check that Worm->Boundary exists ***/
/*** Clear Out Scratch Storage ***/
cvClearMemStorage(Worm->MemScratchStorage);
/*** Slice the boundary into left and right components ***/
if (Worm->HeadIndex==Worm->TailIndex) printf("Error! Worm->HeadIndex==Worm->TailIndex in SegmentWorm()!\n");
CvSeq* OrigBoundA=cvSeqSlice(Worm->Boundary,cvSlice(Worm->HeadIndex,Worm->TailIndex),Worm->MemScratchStorage,1);
CvSeq* OrigBoundB=cvSeqSlice(Worm->Boundary,cvSlice(Worm->TailIndex,Worm->HeadIndex),Worm->MemScratchStorage,1);
if (OrigBoundA->total < Params->NumSegments || OrigBoundB->total < Params->NumSegments ){
printf("Error in SegmentWorm():\n\tWhen splitting the original boundary into two, one or the other has less than the number of desired segments!\n");
printf("OrigBoundA->total=%d\nOrigBoundB->total=%d\nParams->NumSegments=%d\n",OrigBoundA->total,OrigBoundB->total,Params->NumSegments);
printf("Worm->HeadIndex=%d\nWorm->TailIndex=%d\n",Worm->HeadIndex,Worm->TailIndex);
return -1; /** Andy make this return -1 **/
}
cvSeqInvert(OrigBoundB);
/*** Resample One of the Two Boundaries so that both are the same length ***/
//Create sequences to store the Normalized Boundaries
CvSeq* NBoundA= cvCreateSeq(CV_SEQ_ELTYPE_POINT,sizeof(CvSeq),sizeof(CvPoint),Worm->MemScratchStorage);
CvSeq* NBoundB=cvCreateSeq(CV_SEQ_ELTYPE_POINT,sizeof(CvSeq),sizeof(CvPoint),Worm->MemScratchStorage);
//Resample L&R boundary to have the same number of points as min(L,R)
if (OrigBoundA->total > OrigBoundB->total){
resampleSeq(OrigBoundA,NBoundA,OrigBoundB->total );
NBoundB=OrigBoundB;
}else{
resampleSeq(OrigBoundB,NBoundB,OrigBoundA->total );
NBoundA=OrigBoundA;
}
//Now both NBoundA and NBoundB are the same length.
/*
* Now Find the Centerline
*
*/
/*** Clear out Stale Centerline Information ***/
cvClearSeq(Worm->Centerline);
/*** Compute Centerline, from Head To Tail ***/
FindCenterline(NBoundA,NBoundB,Worm->Centerline);
/*** Smooth the Centerline***/
CvSeq* SmoothUnresampledCenterline = smoothPtSequence (Worm->Centerline, 0.5*Worm->Centerline->total/Params->NumSegments, Worm->MemScratchStorage);
/*** Note: If you wanted to you could smooth the centerline a second time here. ***/
/*** Resample the Centerline So it has the specified Number of Points ***/
//resampleSeq(SmoothUnresampledCenterline,Worm->Segmented->Centerline,Params->NumSegments);
resampleSeqConstPtsPerArcLength(SmoothUnresampledCenterline,Worm->Segmented->Centerline,Params->NumSegments);
/** Save the location of the centerOfWorm as the point halfway down the segmented centerline **/
Worm->Segmented->centerOfWorm= CV_GET_SEQ_ELEM( CvPoint , Worm->Segmented->Centerline, Worm->Segmented->NumSegments / 2 );
/*** Remove Repeat Points***/
//RemoveSequentialDuplicatePoints (Worm->Segmented->Centerline);
/*** Use Marc's Perpendicular Segmentation Algorithm
* To Segment the Left and Right Boundaries and store them
*/
SegmentSides(OrigBoundA,OrigBoundB,Worm->Segmented->Centerline,Worm->Segmented->LeftBound,Worm->Segmented->RightBound);
return 0;
}