static void icvSeqElemsClearMask( CvSeq* seq, int offset, int clear_mask )
{
CV_FUNCNAME("icvStartScanGraph");
__BEGIN__;
CvSeqReader reader;
int i, total, elem_size;
if( !seq )
CV_ERROR_FROM_STATUS( CV_NULLPTR_ERR );
elem_size = seq->elem_size;
total = seq->total;
if( (unsigned)offset > (unsigned)elem_size )
CV_ERROR_FROM_STATUS( CV_BADARG_ERR );
CV_CALL( cvStartReadSeq( seq, &reader ));
for( i = 0; i < total; i++ )
{
int* flag_ptr = (int*)(reader.ptr + offset);
*flag_ptr &= ~clear_mask;
CV_NEXT_SEQ_ELEM( elem_size, reader );
}
__END__;
}
CV_IMPL CvSeq*
cvContourConvexHullApprox( CvSeq * sequence, int bandwidth,
int orientation, CvMemStorage * storage )
{
CvSeq *hull = 0;
CV_FUNCNAME( "cvContourConvexHullApprox" );
__BEGIN__;
/* check arguments */
if( !sequence || !storage )
CV_ERROR_FROM_STATUS( CV_NULLPTR_ERR );
if( bandwidth < 1 )
CV_ERROR_FROM_STATUS( CV_BADSIZE_ERR );
if( orientation != CV_CLOCKWISE && orientation != CV_COUNTER_CLOCKWISE )
CV_ERROR_FROM_STATUS( CV_BADFLAG_ERR );
IPPI_CALL( icvConvexHull_Approx_Contour( sequence, bandwidth,
orientation, storage, &hull ));
__CLEANUP__;
__END__;
return hull;
}
CV_IMPL void
cvConvexHullApprox( CvPoint * points,
int num_points,
CvRect * bound_rect,
int bandwidth, int orientation, int *hullpoints, int *hullsize )
{
CV_FUNCNAME( "cvConvexHullApprox" );
__BEGIN__;
if( !points || !hullpoints || !hullsize )
CV_ERROR_FROM_STATUS( CV_NULLPTR_ERR );
if( bandwidth < 1 )
CV_ERROR_FROM_STATUS( CV_BADSIZE_ERR );
IPPI_CALL( icvConvexHull_Approx( points,
num_points,
bound_rect,
bandwidth, orientation, hullpoints, hullsize ));
__CLEANUP__;
__END__;
}
CV_IMPL double cvContourPerimeter( CvSeq *contour, CvSlice slice )
{
double perimeter = 0;
int i, j = 0, count;
const int N = 16;
float buffer[N];
CvSeqReader reader;
CV_FUNCNAME("cvCalcContourPerimeter");
__BEGIN__;
if( !contour )
CV_ERROR_FROM_STATUS( CV_NULLPTR_ERR );
if( !CV_IS_SEQ_POLYLINE( contour ))
CV_ERROR_FROM_STATUS( CV_BADFLAG_ERR );
if( contour->total > 1 )
{
CvPoint pt1, pt2;
cvStartReadSeq( contour, &reader, 0 );
cvSetSeqReaderPos( &reader, slice.startIndex );
count = icvSliceLength( slice, contour );
CV_ADJUST_EDGE_COUNT( count, contour );
/* scroll the reader by 1 point */
CV_READ_EDGE( pt1, pt2, reader );
for( i = 0; i < count; i++ )
{
int dx, dy;
int edge_length;
CV_READ_EDGE( pt1, pt2, reader );
dx = pt2.x - pt1.x;
dy = pt2.y - pt1.y;
edge_length = dx * dx + dy * dy;
buffer[j] = (float)edge_length;
if( ++j == N || i == count - 1 )
{
cvbSqrt( buffer, buffer, j );
for( ; j > 0; j-- )
perimeter += buffer[j-1];
}
}
}
__CLEANUP__
__END__
return perimeter;
}
static char* icvSeqFindNextElem( CvSeq* seq, int offset, int mask,
int value, int* start_index )
{
char* elem_ptr = 0;
CV_FUNCNAME("icvStartScanGraph");
__BEGIN__;
CvSeqReader reader;
int total, elem_size, index;
if( !seq || !start_index )
CV_ERROR_FROM_STATUS( CV_NULLPTR_ERR );
elem_size = seq->elem_size;
total = seq->total;
index = *start_index;
if( (unsigned)offset > (unsigned)elem_size )
CV_ERROR_FROM_STATUS( CV_BADARG_ERR );
if( total == 0 )
EXIT;
if( (unsigned)index >= (unsigned)total )
{
index %= total;
index += index < 0 ? total : 0;
}
CV_CALL( cvStartReadSeq( seq, &reader ));
if( index != 0 )
{
CV_CALL( cvSetSeqReaderPos( &reader, index ));
}
for( index = 0; index < total; index++ )
{
int* flag_ptr = (int*)(reader.ptr + offset);
if( (*flag_ptr & mask) == value )
break;
CV_NEXT_SEQ_ELEM( elem_size, reader );
}
if( index < total )
{
elem_ptr = reader.ptr;
*start_index = index;
}
__END__;
return elem_ptr;
}
CV_IMPL IplConvKernel *
cvCreateStructuringElementEx( int cols, int rows,
int anchorX, int anchorY,
int shape, int *values )
{
IplConvKernel *element = 0;
int i, size = rows * cols;
int element_size = sizeof(*element) + size*sizeof(element->values[0]);
CV_FUNCNAME( "cvCreateStructuringElementEx" );
__BEGIN__;
if( !values && shape == CV_SHAPE_CUSTOM )
CV_ERROR_FROM_STATUS( CV_NULLPTR_ERR );
if( cols <= 0 || rows <= 0 ||
(unsigned) anchorX >= (unsigned) cols ||
(unsigned) anchorY >= (unsigned) rows )
CV_ERROR_FROM_STATUS( CV_BADSIZE_ERR );
CV_CALL( element = (IplConvKernel *)cvAlloc(element_size + 32));
if( !element )
CV_ERROR_FROM_STATUS( CV_OUTOFMEM_ERR );
element->nCols = cols;
element->nRows = rows;
element->anchorX = anchorX;
element->anchorY = anchorY;
element->nShiftR = shape < CV_SHAPE_ELLIPSE ? shape : CV_SHAPE_CUSTOM;
element->values = (int*)(element + 1);
if( shape == CV_SHAPE_CUSTOM )
{
if( !values )
CV_ERROR( CV_StsNullPtr, "Null pointer to the custom element mask" );
for( i = 0; i < size; i++ )
element->values[i] = values[i];
}
else
{
CvMat el_hdr = cvMat( rows, cols, CV_32SC1, element->values );
CV_CALL( CvMorphology::init_binary_element(&el_hdr,
shape, cvPoint(anchorX,anchorY)));
}
__END__;
if( cvGetErrStatus() < 0 )
cvReleaseStructuringElement( &element );
return element;
}
CV_IMPL void
cvStartReadChainPoints( CvChain * chain, CvChainPtReader * reader )
{
int i;
CV_FUNCNAME( "cvStartReadChainPoints" );
__BEGIN__;
if( !chain || !reader )
CV_ERROR( CV_StsNullPtr, "" );
if( chain->elem_size != 1 || chain->header_size < (int)sizeof(CvChain))
CV_ERROR_FROM_STATUS( CV_BADSIZE_ERR );
cvStartReadSeq( (CvSeq *) chain, (CvSeqReader *) reader, 0 );
CV_CHECK();
reader->pt = chain->origin;
for( i = 0; i < 8; i++ )
{
reader->deltas[i][0] = (char) icvCodeDeltas[i].x;
reader->deltas[i][1] = (char) icvCodeDeltas[i].y;
}
__END__;
}
CV_IMPL CvSubdiv2D *
cvCreateSubdiv2D( int subdiv_type, int header_size,
int vtx_size, int quadedge_size, CvMemStorage * storage )
{
CvSubdiv2D *subdiv = 0;
CV_FUNCNAME( "cvCleateSubdiv2D" );
__BEGIN__;
if( !storage )
CV_ERROR( CV_StsNullPtr, "" );
if( header_size < (int)sizeof( *subdiv ) ||
quadedge_size < (int)sizeof( CvQuadEdge2D ) ||
vtx_size < (int)sizeof( CvSubdiv2DPoint ))
CV_ERROR_FROM_STATUS( CV_BADSIZE_ERR );
subdiv = (CvSubdiv2D *) cvCreateGraph( subdiv_type, header_size,
vtx_size, quadedge_size, storage );
__END__;
return subdiv;
}
CV_IMPL void
cvDeInterlace( IplImage* frame, IplImage* fieldEven, IplImage* fieldOdd )
{
CV_FUNCNAME("icvDeInterlace");
__BEGIN__;
uchar *framedata, *f0data, *f1data;
int framestep = 0, f0step = 0, f1step = 0;
CvSize framesize, f0size, f1size;
int y;
if( !frame || !fieldEven || !fieldOdd )
CV_ERROR_FROM_STATUS( CV_NULLPTR_ERR );
cvGetImageRawData( frame, &framedata, &framestep, &framesize );
cvGetImageRawData( fieldEven, &f0data, &f0step, &f0size );
cvGetImageRawData( fieldOdd, &f1data, &f1step, &f1size );
if( f0size.width != f1size.width ||
f0size.height != f1size.height ||
f0size.width != framesize.width ||
f0size.height != framesize.height/2 )
CV_ERROR( IPL_StsBadArg,
"source image and destination image have incorrect combination of sizes" );
if( frame->depth != fieldEven->depth ||
frame->depth != fieldOdd->depth )
CV_ERROR_FROM_STATUS( CV_UNMATCHED_FORMATS_ERR );
if( frame->nChannels != fieldEven->nChannels ||
frame->nChannels != fieldOdd->nChannels )
CV_ERROR_FROM_STATUS( CV_UNMATCHED_FORMATS_ERR );
f0size.width *= icvGetBtPix( frame );
for( y = 0; y < f0size.height; y++, framedata += frame->widthStep*2,
f0data += f0step, f1data += f1step )
{
memcpy( f0data, framedata, f0size.width );
memcpy( f1data, framedata + frame->widthStep, f0size.width );
}
__CLEANUP__;
__END__;
}
CV_IMPL int
icvSubdiv2DCheck( CvSubdiv2D* subdiv )
{
int i, j, total = subdiv->edges->total;
int check_result = 0;
CV_FUNCNAME("icvSubdiv2DCheck");
__BEGIN__;
if( !subdiv )
CV_ERROR_FROM_STATUS( CV_NULLPTR_ERR );
for( i = 0; i < total; i++ )
{
CvQuadEdge2D* edge = (CvQuadEdge2D*)cvGetSetElem(subdiv->edges,i);
if( edge && CV_IS_SET_ELEM( edge ))
{
for( j = 0; j < 4; j++ )
{
CvSubdiv2DEdge e = (CvSubdiv2DEdge)edge + j;
CvSubdiv2DEdge o_next = cvSubdiv2DNextEdge(e);
CvSubdiv2DEdge o_prev = cvSubdiv2DGetEdge(e, CV_PREV_AROUND_ORG );
CvSubdiv2DEdge d_prev = cvSubdiv2DGetEdge(e, CV_PREV_AROUND_DST );
CvSubdiv2DEdge d_next = cvSubdiv2DGetEdge(e, CV_NEXT_AROUND_DST );
// check points
if( cvSubdiv2DEdgeOrg(e) != cvSubdiv2DEdgeOrg(o_next))
EXIT;
if( cvSubdiv2DEdgeOrg(e) != cvSubdiv2DEdgeOrg(o_prev))
EXIT;
if( cvSubdiv2DEdgeDst(e) != cvSubdiv2DEdgeDst(d_next))
EXIT;
if( cvSubdiv2DEdgeDst(e) != cvSubdiv2DEdgeDst(d_prev))
EXIT;
if( j % 2 == 0 )
{
if( cvSubdiv2DEdgeDst(o_next) != cvSubdiv2DEdgeOrg(d_prev))
EXIT;
if( cvSubdiv2DEdgeDst(o_prev) != cvSubdiv2DEdgeOrg(d_next))
EXIT;
if( cvSubdiv2DGetEdge(cvSubdiv2DGetEdge(cvSubdiv2DGetEdge(
e,CV_NEXT_AROUND_LEFT),CV_NEXT_AROUND_LEFT),CV_NEXT_AROUND_LEFT) != e )
EXIT;
if( cvSubdiv2DGetEdge(cvSubdiv2DGetEdge(cvSubdiv2DGetEdge(
e,CV_NEXT_AROUND_RIGHT),CV_NEXT_AROUND_RIGHT),CV_NEXT_AROUND_RIGHT) != e)
EXIT;
}
}
}
}
check_result = 1;
__END__;
return check_result;
}
CV_IMPL void
icvStartScanGraph( CvGraph* graph, CvGraphScanner* scanner,
CvGraphVtx* vtx, int mask )
{
CvMemStorage* child_storage = 0;
CV_FUNCNAME("icvStartScanGraph");
__BEGIN__;
if( !graph || !scanner )
CV_ERROR_FROM_STATUS( CV_NULLPTR_ERR );
if( !(graph->storage ))
CV_ERROR_FROM_STATUS( CV_NULLPTR_ERR );
memset( scanner, 0, sizeof(*scanner));
scanner->graph = graph;
scanner->mask = mask;
scanner->vtx = vtx;
scanner->index = vtx == 0 ? 0 : -1;
CV_CALL( child_storage = cvCreateChildMemStorage( graph->storage ));
CV_CALL( scanner->stack = cvCreateSeq( 0, sizeof(CvSet),
sizeof(CvGraphItem), child_storage ));
CV_CALL( icvSeqElemsClearMask( (CvSeq*)graph,
CV_FIELD_OFFSET( flags, CvGraphVtx ),
CV_GRAPH_ITEM_VISITED_FLAG|
CV_GRAPH_SEARCH_TREE_NODE_FLAG ));
CV_CALL( icvSeqElemsClearMask( (CvSeq*)(graph->edges),
CV_FIELD_OFFSET( flags, CvGraphEdge ),
CV_GRAPH_ITEM_VISITED_FLAG ));
__END__;
if( cvGetErrStatus() < 0 )
cvReleaseMemStorage( &child_storage );
}
CV_IMPL void
icvEndScanGraph( CvGraphScanner* scanner )
{
CV_FUNCNAME("icvEndScanGraph");
__BEGIN__;
if( !scanner )
CV_ERROR_FROM_STATUS( CV_NULLPTR_ERR );
if( scanner->stack )
CV_CALL( cvReleaseMemStorage( &(scanner->stack->storage)));
__END__;
}
/*F///////////////////////////////////////////////////////////////////////////////////////
// Name: icvFindDominantPoints
// Purpose:
// Applies some algorithm to find dominant points ( corners ) of contour
//
// Context:
// Parameters:
// contours - pointer to input contour object.
// out_numbers - array of dominant points indices
// count - length of out_numbers array on input
// and numbers of founded dominant points on output
//
// method - only CV_DOMINANT_IPAN now
// parameters - array of parameters
// for IPAN algorithm
// [0] - minimal distance
// [1] - maximal distance
// [2] - neighborhood distance (must be not greater than dmaximal distance)
// [3] - maximal possible angle of curvature
// Returns:
// CV_OK or error code
// Notes:
// User must allocate out_numbers array. If it is small - function fills array
// with part of points and returns error
//F*/
CV_IMPL CvSeq*
cvFindDominantPoints( CvSeq * contour, CvMemStorage * storage, int method,
double parameter1, double parameter2, double parameter3, double parameter4 )
{
CvSeq* corners = 0;
CV_FUNCNAME( "cvFindDominantPoints" );
__BEGIN__;
if( !contour )
CV_ERROR( CV_StsNullPtr, "" );
if( !storage )
storage = contour->storage;
if( !storage )
CV_ERROR( CV_StsNullPtr, "" );
switch (method)
{
case CV_DOMINANT_IPAN:
{
int dmin = cvRound(parameter1);
int dmax = cvRound(parameter2);
int dneigh = cvRound(parameter3);
int amax = cvRound(parameter4);
if( amax == 0 )
amax = 150;
if( dmin == 0 )
dmin = 7;
if( dmax == 0 )
dmax = dmin + 2;
if( dneigh == 0 )
dneigh = dmin;
IPPI_CALL( icvFindDominantPointsIPAN( contour, storage, &corners,
dmin*dmin, dmax*dmax, dneigh*dneigh, (float)amax ));
}
break;
default:
CV_ERROR_FROM_STATUS( CV_BADFLAG_ERR );
}
__END__;
return corners;
}
/*F///////////////////////////////////////////////////////////////////////////////////////
// Name: cvAdaptiveThreshold
// Purpose: Adaptive Thresholding the source image
// Context:
// Parameters:
// srcIm - source image
// dstIm - result thresholding image
// maxValue - the maximum value of the image pixel
// method - method for the adaptive threshold calculation
// (now CV_STDDEF_ADAPTIVE_THRESH only)
// type - thresholding type, must be one of
// CV_THRESH_BINARY - val = (val > Thresh ? MAX : 0)
// CV_THRESH_BINARY_INV - val = (val > Thresh ? 0 : MAX)
// CV_THRESH_TOZERO - val = (val > Thresh ? val : 0)
// CV_THRESH_TOZERO_INV - val = (val > Thresh ? 0 : val)
// parameters - pointer to the input parameters (for the
// CV_STDDEF_ADAPTIVE_THRESH method parameters[0] is size of
// the neighborhood thresholding, (one of the 1-(3x3),2-(5x5),or
// 3-(7x7)), parameters[1] is the value of the minimum variance
// Returns:
// Notes:
//F*/
CV_IMPL void
cvAdaptiveThreshold( const void *srcIm, void *dstIm,
double maxValue, CvAdaptiveThreshMethod method,
CvThreshType type, double *parameters )
{
///////////////// Some variables /////////////////
CvMat src_stub, dst_stub;
CvMat *src = 0, *dst = 0;
CV_FUNCNAME( "cvAdaptiveThreshold" );
__BEGIN__;
///////////////// Checking /////////////////
CV_CALL( src = cvGetMat( srcIm, &src_stub ));
CV_CALL( dst = cvGetMat( dstIm, &dst_stub ));
if( !CV_ARE_TYPES_EQ( src, dst ))
CV_ERROR( CV_StsUnmatchedFormats, "" );
if( CV_ARR_TYPE(src->type) != CV_8UC1 )
CV_ERROR( CV_StsUnsupportedFormat, "" );
if( !CV_ARE_SIZES_EQ( src, dst ) )
CV_ERROR( CV_StsUnmatchedSizes, "" );
switch (method)
{
case CV_STDDEV_ADAPTIVE_THRESH:
icvAdaptiveThreshold_StdDev( src, dst, cvRound(maxValue),
type, cvRound( parameters[0] ),
cvRound( parameters[1] ));
break;
default:
CV_ERROR_FROM_STATUS( CV_BADCOEF_ERR );
}
__END__;
}
CV_IMPL int
cvCheckContourConvexity( CvSeq *contour )
{
int flag = 0;
CV_FUNCNAME( "cvCheckContourConvexity" );
__BEGIN__;
if( !contour )
CV_ERROR( IPL_BadDataPtr, "invalid input pointer " );
flag = icvCheckContourConvexity( contour );
if( flag < 0 ) //CvStatus
CV_ERROR_FROM_STATUS( (CvStatus)flag );
__CLEANUP__;
__END__;
return flag;
}
CV_IMPL int
icvNextGraphItem( CvGraphScanner* scanner )
{
int code = -1;
CV_FUNCNAME("icvNextGraphItem");
__BEGIN__;
CvGraphVtx* vtx;
CvGraphVtx* dst;
CvGraphEdge* edge;
CvGraphItem item;
if( !scanner || !(scanner->stack))
CV_ERROR_FROM_STATUS( CV_NULLPTR_ERR );
dst = scanner->dst;
vtx = scanner->vtx;
edge = scanner->edge;
for(;;)
{
for(;;)
{
if( dst && !CV_IS_GRAPH_VERTEX_VISITED(dst) )
{
scanner->vtx = vtx = dst;
edge = vtx->first;
dst->flags |= CV_GRAPH_ITEM_VISITED_FLAG;
if((scanner->mask & CV_GRAPH_VERTEX))
{
scanner->vtx = vtx;
scanner->edge = vtx->first;
scanner->dst = 0;
code = CV_GRAPH_VERTEX;
EXIT;
}
}
while( edge )
{
dst = edge->vtx[vtx == edge->vtx[0]];
if( !CV_IS_GRAPH_EDGE_VISITED(edge) )
{
// check that the edge is outcoming
if( !CV_IS_GRAPH_ORIENTED( scanner->graph ) || dst != edge->vtx[0] )
{
edge->flags |= CV_GRAPH_ITEM_VISITED_FLAG;
code = CV_GRAPH_BACK_EDGE;
if( !CV_IS_GRAPH_VERTEX_VISITED(dst) )
{
item.vtx = vtx;
item.edge = edge;
vtx->flags |= CV_GRAPH_SEARCH_TREE_NODE_FLAG;
cvSeqPush( scanner->stack, &item );
if( scanner->mask & CV_GRAPH_TREE_EDGE )
{
code = CV_GRAPH_TREE_EDGE;
scanner->dst = dst;
scanner->edge = edge;
EXIT;
}
break;
}
else
{
if( scanner->mask & (CV_GRAPH_BACK_EDGE|
CV_GRAPH_CROSS_EDGE|
CV_GRAPH_FORWARD_EDGE) )
{
code = (dst->flags & CV_GRAPH_SEARCH_TREE_NODE_FLAG) ?
CV_GRAPH_BACK_EDGE :
(edge->flags & CV_GRAPH_FORWARD_EDGE_FLAG) ?
CV_GRAPH_FORWARD_EDGE : CV_GRAPH_CROSS_EDGE;
edge->flags &= ~CV_GRAPH_FORWARD_EDGE_FLAG;
if( scanner->mask & code )
{
scanner->vtx = vtx;
scanner->dst = dst;
scanner->edge = edge;
EXIT;
}
}
}
}
else if( (dst->flags & (CV_GRAPH_ITEM_VISITED_FLAG|
CV_GRAPH_SEARCH_TREE_NODE_FLAG)) ==
(CV_GRAPH_ITEM_VISITED_FLAG|
CV_GRAPH_SEARCH_TREE_NODE_FLAG))
{
edge->flags |= CV_GRAPH_FORWARD_EDGE_FLAG;
}
}
edge = CV_NEXT_GRAPH_EDGE( edge, vtx );
}
if( !edge ) // need to backtrack
{
if( scanner->stack->total == 0 )
{
if( scanner->index >= 0 )
vtx = 0;
else
scanner->index = 0;
break;
}
cvSeqPop( scanner->stack, &item );
vtx = item.vtx;
vtx->flags &= ~CV_GRAPH_SEARCH_TREE_NODE_FLAG;
edge = item.edge;
dst = 0;
if( scanner->mask & CV_GRAPH_BACKTRACKING )
{
scanner->vtx = vtx;
scanner->edge = edge;
scanner->dst = edge->vtx[vtx == edge->vtx[0]];
code = CV_GRAPH_BACKTRACKING;
EXIT;
}
}
}
if( !vtx )
{
vtx = (CvGraphVtx*)icvSeqFindNextElem( (CvSeq*)(scanner->graph),
CV_FIELD_OFFSET( flags, CvGraphVtx ), CV_GRAPH_ITEM_VISITED_FLAG|1,
0, &(scanner->index) );
if( !vtx )
{
code = CV_GRAPH_OVER;
icvEndScanGraph( scanner );
scanner->stack = 0;
break;
}
}
dst = vtx;
if( scanner->mask & CV_GRAPH_NEW_TREE )
{
scanner->dst = dst;
scanner->edge = 0;
scanner->vtx = 0;
code = CV_GRAPH_NEW_TREE;
break;
}
}
__END__;
return code;
}
CV_IMPL void
cvMinEnclosingCircle( CvSeq * sequence, CvPoint2D32f * _center, float *_radius )
{
const int max_iters = 20;
CvSeqReader reader;
int i, k, count;
CvPoint *pt_left, *pt_right, *pt_top, *pt_bottom;
CvPoint pt;
CvPoint2D32f center = { 0, 0 };
CvPoint2D32f pts[8];
float radius = 0;
if( _center )
_center->x = _center->y = 0.f;
if( _radius )
*_radius = 0;
CV_FUNCNAME( "cvMinEnclosingCircle" );
__BEGIN__;
if( !sequence || !_center || !_radius )
CV_ERROR_FROM_STATUS( CV_NULLPTR_ERR );
if( sequence->total <= 0 )
CV_ERROR_FROM_STATUS( CV_BADSIZE_ERR );
if( !CV_IS_SEQ_POINT_SET( sequence ))
CV_ERROR_FROM_STATUS( CV_BADFLAG_ERR );
CV_CALL( cvStartReadSeq( sequence, &reader, 0 ));
pt_left = pt_right = pt_top = pt_bottom = (CvPoint *) (reader.ptr);
CV_READ_SEQ_ELEM( pt, reader );
count = sequence->total;
for( i = 1; i < count; i++ )
{
CvPoint *pt_ptr = (CvPoint *) (reader.ptr);
CvPoint pt;
CV_READ_SEQ_ELEM( pt, reader );
if( pt.x < pt_left->x )
pt_left = pt_ptr;
if( pt.x > pt_right->x )
pt_right = pt_ptr;
if( pt.y < pt_top->y )
pt_top = pt_ptr;
if( pt.y > pt_bottom->y )
pt_bottom = pt_ptr;
}
pts[0] = icvCvtPoint32s_32f( *pt_left );
pts[1] = icvCvtPoint32s_32f( *pt_right );
pts[2] = icvCvtPoint32s_32f( *pt_top );
pts[3] = icvCvtPoint32s_32f( *pt_bottom );
for( k = 0; k < max_iters; k++ )
{
icvFindEnslosingCicle4pts_32f( pts, ¢er, &radius );
cvStartReadSeq( sequence, &reader, 0 );
for( i = 0; i < count; i++ )
{
CvPoint pt;
CvPoint2D32f ptfl;
CV_READ_SEQ_ELEM( pt, reader );
ptfl = icvCvtPoint32s_32f( pt );
if( !icvIsPtInCircle( ptfl, center, radius ))
{
pts[3] = ptfl;
break;
}
}
if( i == count )
break;
}
__CLEANUP__;
__END__;
*_center = center;
*_radius = radius;
}
CV_IMPL CvSubdiv2DPoint *
cvSubdivDelaunay2DInsert( CvSubdiv2D * subdiv, CvPoint2D32f pt )
{
CvSubdiv2DPoint *point = 0;
CvSubdiv2DPointLocation location = CV_PTLOC_ERROR;
CvSubdiv2DPoint *curr_point = 0, *first_point = 0;
CvSubdiv2DEdge curr_edge = 0, deleted_edge = 0, base_edge = 0;
int i, max_edges;
CV_FUNCNAME( "cvSubdivDelaunay2DInsert" );
__BEGIN__;
if( !subdiv )
CV_ERROR( CV_StsNullPtr, "" );
if( !CV_IS_SUBDIV2D(subdiv) )
CV_ERROR_FROM_STATUS( CV_BADFLAG_ERR );
location = cvSubdiv2DLocate( subdiv, pt, &curr_edge, &curr_point );
switch (location)
{
case CV_PTLOC_ERROR:
CV_ERROR_FROM_STATUS( CV_BADSIZE_ERR );
case CV_PTLOC_OUTSIDE_RECT:
CV_ERROR_FROM_STATUS( CV_BADRANGE_ERR );
case CV_PTLOC_VERTEX:
point = curr_point;
break;
case CV_PTLOC_ON_EDGE:
deleted_edge = curr_edge;
subdiv->recent_edge = curr_edge = cvSubdiv2DGetEdge( curr_edge, CV_PREV_AROUND_ORG );
cvSubdiv2DDeleteEdge( subdiv, deleted_edge );
/* no break */
case CV_PTLOC_INSIDE:
assert( curr_edge != 0 );
subdiv->is_geometry_valid = 0;
curr_point = cvSubdiv2DAddPoint( subdiv, pt, 0 );
CV_CHECK();
base_edge = cvSubdiv2DMakeEdge( subdiv );
first_point = cvSubdiv2DEdgeOrg( curr_edge );
cvSubdiv2DSetEdgePoints( base_edge, first_point, curr_point );
cvSubdiv2DSplice( base_edge, curr_edge );
do
{
base_edge = cvSubdiv2DConnectEdges( subdiv, curr_edge,
cvSubdiv2DSymEdge( base_edge ));
curr_edge = cvSubdiv2DGetEdge( base_edge, CV_PREV_AROUND_ORG );
}
while( cvSubdiv2DEdgeDst( curr_edge ) != first_point );
curr_edge = cvSubdiv2DGetEdge( base_edge, CV_PREV_AROUND_ORG );
max_edges = subdiv->quad_edges * 4;
for( i = 0; i < max_edges; i++ )
{
CvSubdiv2DPoint *temp_dst = 0, *curr_org = 0, *curr_dst = 0;
CvSubdiv2DEdge temp_edge = cvSubdiv2DGetEdge( curr_edge, CV_PREV_AROUND_ORG );
temp_dst = cvSubdiv2DEdgeDst( temp_edge );
curr_org = cvSubdiv2DEdgeOrg( curr_edge );
curr_dst = cvSubdiv2DEdgeDst( curr_edge );
if( icvIsRightOf( temp_dst->pt, curr_edge ) > 0 &&
icvIsPtInCircle3( curr_org->pt, temp_dst->pt,
curr_dst->pt, curr_point->pt ) < 0 )
{
cvSubdiv2DSwapEdges( curr_edge );
curr_edge = cvSubdiv2DGetEdge( curr_edge, CV_PREV_AROUND_ORG );
}
else if( curr_org == first_point )
{
break;
}
else
{
curr_edge = cvSubdiv2DGetEdge( cvSubdiv2DNextEdge( curr_edge ),
CV_PREV_AROUND_LEFT );
}
}
break;
default:
assert( 0 );
CV_ERROR_FROM_STATUS( CV_NOTDEFINED_ERR );
}
point = curr_point;
__END__;
//icvSubdiv2DCheck( subdiv );
return point;
}
CV_IMPL CvSubdiv2DPointLocation
cvSubdiv2DLocate( CvSubdiv2D * subdiv, CvPoint2D32f pt,
CvSubdiv2DEdge * _edge, CvSubdiv2DPoint ** _point )
{
CvSubdiv2DEdge edge = 0;
CvSubdiv2DPoint *point = 0;
CvSubdiv2DPointLocation location = CV_PTLOC_ERROR;
int i, max_edges;
int right_of_curr = 0;
CV_FUNCNAME( "cvSubdiv2DLocate" );
__BEGIN__;
if( !subdiv )
CV_ERROR( CV_StsNullPtr, "" );
if( !CV_IS_SUBDIV2D(subdiv) )
CV_ERROR_FROM_STATUS( CV_BADFLAG_ERR );
max_edges = subdiv->quad_edges * 4;
edge = subdiv->recent_edge;
if( max_edges == 0 )
CV_ERROR_FROM_STATUS( CV_BADSIZE_ERR );
if( !edge )
CV_ERROR_FROM_STATUS( CV_NOTDEFINED_ERR );
location = CV_PTLOC_OUTSIDE_RECT;
if( pt.x < subdiv->topleft.x || pt.y < subdiv->topleft.y ||
pt.x >= subdiv->bottomright.x || pt.y >= subdiv->bottomright.y )
CV_ERROR_FROM_STATUS( CV_BADRANGE_ERR );
location = CV_PTLOC_ERROR;
right_of_curr = icvIsRightOf( pt, edge );
if( right_of_curr > 0 )
{
edge = cvSubdiv2DSymEdge( edge );
right_of_curr = -right_of_curr;
}
for( i = 0; i < max_edges; i++ )
{
CvSubdiv2DEdge onext_edge = cvSubdiv2DNextEdge( edge );
CvSubdiv2DEdge dprev_edge = cvSubdiv2DGetEdge( edge, CV_PREV_AROUND_DST );
int right_of_onext = icvIsRightOf( pt, onext_edge );
int right_of_dprev = icvIsRightOf( pt, dprev_edge );
if( right_of_dprev > 0 )
{
if( right_of_onext > 0 || right_of_onext == 0 && right_of_curr == 0 )
{
location = CV_PTLOC_INSIDE;
EXIT;
}
else
{
right_of_curr = right_of_onext;
edge = onext_edge;
}
}
else
{
if( right_of_onext > 0 )
{
if( right_of_dprev == 0 && right_of_curr == 0 )
{
location = CV_PTLOC_INSIDE;
EXIT;
}
else
{
right_of_curr = right_of_dprev;
edge = dprev_edge;
}
}
else if( right_of_curr == 0 &&
icvIsRightOf( cvSubdiv2DEdgeDst( onext_edge )->pt, edge ) >= 0 )
{
edge = cvSubdiv2DSymEdge( edge );
}
else
{
right_of_curr = right_of_onext;
edge = onext_edge;
}
}
}
__END__;
subdiv->recent_edge = edge;
if( location == CV_PTLOC_INSIDE )
{
double t1, t2, t3;
CvPoint2D32f org_pt = cvSubdiv2DEdgeOrg( edge )->pt;
CvPoint2D32f dst_pt = cvSubdiv2DEdgeDst( edge )->pt;
t1 = fabs( pt.x - org_pt.x );
t1 += fabs( pt.y - org_pt.y );
t2 = fabs( pt.x - dst_pt.x );
t2 += fabs( pt.y - dst_pt.y );
t3 = fabs( org_pt.x - dst_pt.x );
t3 += fabs( org_pt.y - dst_pt.y );
if( t1 < FLT_EPSILON )
{
location = CV_PTLOC_VERTEX;
point = cvSubdiv2DEdgeOrg( edge );
edge = 0;
}
else if( t2 < FLT_EPSILON )
{
location = CV_PTLOC_VERTEX;
point = cvSubdiv2DEdgeDst( edge );
edge = 0;
}
else if( (t1 < t3 || t2 < t3) &&
fabs( cvTriangleArea( pt, org_pt, dst_pt )) < FLT_EPSILON )
{
location = CV_PTLOC_ON_EDGE;
point = 0;
}
}
if( location == CV_PTLOC_ERROR )
{
edge = 0;
point = 0;
}
if( _edge )
*_edge = edge;
if( _point )
*_point = point;
return location;
}
CV_IMPL int
cvMinEnclosingCircle( const void* array, CvPoint2D32f * _center, float *_radius )
{
const int max_iters = 100;
const float eps = FLT_EPSILON*2;
CvPoint2D32f center = { 0, 0 };
float radius = 0;
int result = 0;
if( _center )
_center->x = _center->y = 0.f;
if( _radius )
*_radius = 0;
CV_FUNCNAME( "cvMinEnclosingCircle" );
__BEGIN__;
CvSeqReader reader;
int i, k, count;
CvPoint2D32f pts[8];
CvContour contour_header;
CvSeqBlock block;
CvSeq* sequence = 0;
int is_float;
if( !_center || !_radius )
CV_ERROR( CV_StsNullPtr, "Null center or radius pointers" );
if( CV_IS_SEQ(array) )
{
sequence = (CvSeq*)array;
if( !CV_IS_SEQ_POINT_SET( sequence ))
CV_ERROR( CV_StsBadArg, "The passed sequence is not a valid contour" );
}
else
{
CV_CALL( sequence = cvPointSeqFromMat(
CV_SEQ_KIND_GENERIC, array, &contour_header, &block ));
}
if( sequence->total <= 0 )
CV_ERROR_FROM_STATUS( CV_BADSIZE_ERR );
CV_CALL( cvStartReadSeq( sequence, &reader, 0 ));
count = sequence->total;
is_float = CV_SEQ_ELTYPE(sequence) == CV_32FC2;
if( !is_float )
{
CvPoint *pt_left, *pt_right, *pt_top, *pt_bottom;
CvPoint pt;
pt_left = pt_right = pt_top = pt_bottom = (CvPoint *)(reader.ptr);
CV_READ_SEQ_ELEM( pt, reader );
for( i = 1; i < count; i++ )
{
CvPoint* pt_ptr = (CvPoint*)reader.ptr;
CV_READ_SEQ_ELEM( pt, reader );
if( pt.x < pt_left->x )
pt_left = pt_ptr;
if( pt.x > pt_right->x )
pt_right = pt_ptr;
if( pt.y < pt_top->y )
pt_top = pt_ptr;
if( pt.y > pt_bottom->y )
pt_bottom = pt_ptr;
}
pts[0] = cvPointTo32f( *pt_left );
pts[1] = cvPointTo32f( *pt_right );
pts[2] = cvPointTo32f( *pt_top );
pts[3] = cvPointTo32f( *pt_bottom );
}
else
{
CvPoint2D32f *pt_left, *pt_right, *pt_top, *pt_bottom;
CvPoint2D32f pt;
pt_left = pt_right = pt_top = pt_bottom = (CvPoint2D32f *) (reader.ptr);
CV_READ_SEQ_ELEM( pt, reader );
for( i = 1; i < count; i++ )
{
CvPoint2D32f* pt_ptr = (CvPoint2D32f*)reader.ptr;
CV_READ_SEQ_ELEM( pt, reader );
if( pt.x < pt_left->x )
pt_left = pt_ptr;
if( pt.x > pt_right->x )
pt_right = pt_ptr;
if( pt.y < pt_top->y )
pt_top = pt_ptr;
if( pt.y > pt_bottom->y )
pt_bottom = pt_ptr;
}
pts[0] = *pt_left;
pts[1] = *pt_right;
pts[2] = *pt_top;
pts[3] = *pt_bottom;
}
for( k = 0; k < max_iters; k++ )
{
double min_delta = 0, delta;
CvPoint2D32f ptfl;
icvFindEnslosingCicle4pts_32f( pts, ¢er, &radius );
cvStartReadSeq( sequence, &reader, 0 );
for( i = 0; i < count; i++ )
{
if( !is_float )
{
ptfl.x = (float)((CvPoint*)reader.ptr)->x;
ptfl.y = (float)((CvPoint*)reader.ptr)->y;
}
else
{
ptfl = *(CvPoint2D32f*)reader.ptr;
}
CV_NEXT_SEQ_ELEM( sequence->elem_size, reader );
delta = icvIsPtInCircle( ptfl, center, radius );
if( delta < min_delta )
{
min_delta = delta;
pts[3] = ptfl;
}
}
result = min_delta >= 0;
if( result )
break;
}
if( !result )
{
cvStartReadSeq( sequence, &reader, 0 );
radius = 0.f;
for( i = 0; i < count; i++ )
{
CvPoint2D32f ptfl;
float t, dx, dy;
if( !is_float )
{
ptfl.x = (float)((CvPoint*)reader.ptr)->x;
ptfl.y = (float)((CvPoint*)reader.ptr)->y;
}
else
{
ptfl = *(CvPoint2D32f*)reader.ptr;
}
CV_NEXT_SEQ_ELEM( sequence->elem_size, reader );
dx = center.x - ptfl.x;
dy = center.y - ptfl.y;
t = dx*dx + dy*dy;
radius = MAX(radius,t);
}
radius = (float)(sqrt(radius)*(1 + eps));
result = 1;
}
__END__;
*_center = center;
*_radius = radius;
return result;
}
/*
Initializes scanner structure.
Prepare image for scanning ( clear borders and convert all pixels to 0-1.
*/
CV_IMPL CvContourScanner
cvStartFindContours( void* _img, CvMemStorage* storage,
int header_size, int mode,
int method, CvPoint offset )
{
int y;
int step;
CvSize size;
uchar *img = 0;
CvContourScanner scanner = 0;
CvMat stub, *mat = (CvMat*)_img;
CV_FUNCNAME( "cvStartFindContours" );
__BEGIN__;
if( !storage )
CV_ERROR( CV_StsNullPtr, "" );
CV_CALL( mat = cvGetMat( mat, &stub ));
if( !CV_IS_MASK_ARR( mat ))
CV_ERROR( CV_StsUnsupportedFormat, "[Start]FindContours support only 8uC1 images" );
size = cvSize( mat->width, mat->height );
step = mat->step;
img = (uchar*)(mat->data.ptr);
if( method < 0 || method > CV_CHAIN_APPROX_TC89_KCOS )
CV_ERROR_FROM_STATUS( CV_BADRANGE_ERR );
if( header_size < (int) (method == CV_CHAIN_CODE ? sizeof( CvChain ) : sizeof( CvContour )))
CV_ERROR_FROM_STATUS( CV_BADSIZE_ERR );
scanner = (CvContourScanner)cvAlloc( sizeof( *scanner ));
if( !scanner )
CV_ERROR_FROM_STATUS( CV_OUTOFMEM_ERR );
memset( scanner, 0, sizeof( *scanner ));
scanner->storage1 = scanner->storage2 = storage;
scanner->img0 = (char *) img;
scanner->img = (char *) (img + step);
scanner->img_step = step;
scanner->img_size.width = size.width - 1; /* exclude rightest column */
scanner->img_size.height = size.height - 1; /* exclude bottomost row */
scanner->mode = mode;
scanner->offset = offset;
scanner->pt.x = scanner->pt.y = 1;
scanner->lnbd.x = 0;
scanner->lnbd.y = 1;
scanner->nbd = 2;
scanner->mode = (int) mode;
scanner->frame_info.contour = &(scanner->frame);
scanner->frame_info.is_hole = 1;
scanner->frame_info.next = 0;
scanner->frame_info.parent = 0;
scanner->frame_info.rect = cvRect( 0, 0, size.width, size.height );
scanner->l_cinfo = 0;
scanner->subst_flag = 0;
scanner->frame.flags = CV_SEQ_FLAG_HOLE;
scanner->approx_method2 = scanner->approx_method1 = method;
if( method == CV_CHAIN_APPROX_TC89_L1 || method == CV_CHAIN_APPROX_TC89_KCOS )
scanner->approx_method1 = CV_CHAIN_CODE;
if( scanner->approx_method1 == CV_CHAIN_CODE )
{
scanner->seq_type1 = CV_SEQ_CHAIN_CONTOUR;
scanner->header_size1 = scanner->approx_method1 == scanner->approx_method2 ?
header_size : sizeof( CvChain );
scanner->elem_size1 = sizeof( char );
}
else
{
scanner->seq_type1 = CV_SEQ_POLYGON;
scanner->header_size1 = scanner->approx_method1 == scanner->approx_method2 ?
header_size : sizeof( CvContour );
scanner->elem_size1 = sizeof( CvPoint );
}
scanner->header_size2 = header_size;
if( scanner->approx_method2 == CV_CHAIN_CODE )
{
scanner->seq_type2 = scanner->seq_type1;
scanner->elem_size2 = scanner->elem_size1;
}
else
{
scanner->seq_type2 = CV_SEQ_POLYGON;
scanner->elem_size2 = sizeof( CvPoint );
}
scanner->seq_type1 = scanner->approx_method1 == CV_CHAIN_CODE ?
CV_SEQ_CHAIN_CONTOUR : CV_SEQ_POLYGON;
scanner->seq_type2 = scanner->approx_method2 == CV_CHAIN_CODE ?
CV_SEQ_CHAIN_CONTOUR : CV_SEQ_POLYGON;
cvSaveMemStoragePos( storage, &(scanner->initial_pos) );
if( method > CV_CHAIN_APPROX_SIMPLE )
{
scanner->storage1 = cvCreateChildMemStorage( scanner->storage2 );
}
if( mode > CV_RETR_LIST )
{
scanner->cinfo_storage = cvCreateChildMemStorage( scanner->storage2 );
scanner->cinfo_set = cvCreateSet( 0, sizeof( CvSet ), sizeof( _CvContourInfo ),
scanner->cinfo_storage );
if( scanner->cinfo_storage == 0 || scanner->cinfo_set == 0 )
CV_ERROR_FROM_STATUS( CV_OUTOFMEM_ERR );
}
/* make zero borders */
memset( img, 0, size.width );
memset( img + step * (size.height - 1), 0, size.width );
for( y = 1, img += step; y < size.height - 1; y++, img += step )
{
img[0] = img[size.width - 1] = 0;
}
/* converts all pixels to 0 or 1 */
cvThreshold( mat, mat, 0, 1, CV_THRESH_BINARY );
CV_CHECK();
__END__;
if( cvGetErrStatus() < 0 )
cvFree( &scanner );
return scanner;
}
/*F///////////////////////////////////////////////////////////////////////////////////////
// Name: icvContourFromContourTree
// Purpose:
// reconstracts contour from binary tree representation
// Context:
// Parameters:
// tree - pointer to the input binary tree representation
// storage - pointer to the current storage block
// contour - pointer to output contour object.
// criteria - criteria for the definition threshold value
// for the contour reconstracting (level or precision)
//F*/
CV_IMPL CvSeq*
cvContourFromContourTree( const CvContourTree* tree,
CvMemStorage* storage,
CvTermCriteria criteria )
{
CvSeq* contour = 0;
_CvTrianAttr **ptr_buf = 0; /* pointer to the pointer's buffer */
int *level_buf = 0;
int i_buf;
int lpt;
double area_all;
double threshold;
int cur_level;
int level;
int seq_flags;
char log_iter, log_eps;
int out_hearder_size;
_CvTrianAttr *tree_one = 0, tree_root; /* current vertex */
CvSeqReader reader;
CvSeqWriter writer;
CV_FUNCNAME("cvContourFromContourTree");
__BEGIN__;
if( !tree )
CV_ERROR( CV_StsNullPtr, "" );
if( !CV_IS_SEQ_POLYGON_TREE( tree ))
CV_ERROR_FROM_STATUS( CV_BADFLAG_ERR );
criteria = cvCheckTermCriteria( criteria, 0., 100 );
lpt = tree->total;
ptr_buf = NULL;
level_buf = NULL;
i_buf = 0;
cur_level = 0;
log_iter = (char) (criteria.type == CV_TERMCRIT_ITER ||
(criteria.type == CV_TERMCRIT_ITER + CV_TERMCRIT_EPS));
log_eps = (char) (criteria.type == CV_TERMCRIT_EPS ||
(criteria.type == CV_TERMCRIT_ITER + CV_TERMCRIT_EPS));
cvStartReadSeq( (CvSeq *) tree, &reader, 0 );
out_hearder_size = sizeof( CvContour );
seq_flags = CV_SEQ_POLYGON;
cvStartWriteSeq( seq_flags, out_hearder_size, sizeof( CvPoint ), storage, &writer );
ptr_buf = (_CvTrianAttr **) cvAlloc( lpt * sizeof( _CvTrianAttr * ));
if( ptr_buf == NULL )
CV_ERROR_FROM_STATUS( CV_OUTOFMEM_ERR );
if( log_iter )
{
level_buf = (int *) cvAlloc( lpt * (sizeof( int )));
if( level_buf == NULL )
CV_ERROR_FROM_STATUS( CV_OUTOFMEM_ERR );
}
memset( ptr_buf, 0, lpt * sizeof( _CvTrianAttr * ));
/* write the first tree root's point as a start point of the result contour */
CV_WRITE_SEQ_ELEM( tree->p1, writer );
/* write the second tree root"s point into buffer */
/* read the root of the tree */
CV_READ_SEQ_ELEM( tree_root, reader );
tree_one = &tree_root;
area_all = tree_one->area;
if( log_eps )
threshold = criteria.epsilon * area_all;
else
threshold = 10 * area_all;
if( log_iter )
level = criteria.max_iter;
else
level = -1;
/* contour from binary tree constraction */
while( i_buf >= 0 )
{
if( tree_one != NULL && (cur_level <= level || tree_one->area >= threshold) )
/* go to left sub tree for the vertex and save pointer to the right vertex */
/* into the buffer */
{
ptr_buf[i_buf] = tree_one;
if( log_iter )
{
level_buf[i_buf] = cur_level;
cur_level++;
}
i_buf++;
tree_one = tree_one->next_v1;
}
else
{
i_buf--;
if( i_buf >= 0 )
{
CvPoint pt = ptr_buf[i_buf]->pt;
CV_WRITE_SEQ_ELEM( pt, writer );
tree_one = ptr_buf[i_buf]->next_v2;
if( log_iter )
{
cur_level = level_buf[i_buf] + 1;
}
}
}
}
contour = cvEndWriteSeq( &writer );
cvBoundingRect( contour, 1 );
__CLEANUP__;
__END__;
cvFree( &level_buf );
cvFree( &ptr_buf );
return contour;
}
CvSeq *
cvFindNextContour( CvContourScanner scanner )
{
char *img0;
char *img;
int step;
int width, height;
int x, y;
int prev;
CvPoint lnbd;
CvSeq *contour = 0;
int nbd;
int mode;
CvStatus result = (CvStatus) 1;
CV_FUNCNAME( "cvFindNextContour" );
__BEGIN__;
if( !scanner )
CV_ERROR( CV_StsNullPtr, "" );
icvEndProcessContour( scanner );
/* initialize local state */
img0 = scanner->img0;
img = scanner->img;
step = scanner->img_step;
x = scanner->pt.x;
y = scanner->pt.y;
width = scanner->img_size.width;
height = scanner->img_size.height;
mode = scanner->mode;
lnbd = scanner->lnbd;
nbd = scanner->nbd;
prev = img[x - 1];
for( ; y < height; y++, img += step )
{
for( ; x < width; x++ )
{
int p = img[x];
if( p != prev )
{
_CvContourInfo *par_info = 0;
_CvContourInfo *l_cinfo = 0;
CvSeq *seq = 0;
int is_hole = 0;
CvPoint origin;
if( !(prev == 0 && p == 1) ) /* if not external contour */
{
/* check hole */
if( p != 0 || prev < 1 )
goto resume_scan;
if( prev & -2 )
{
lnbd.x = x - 1;
}
is_hole = 1;
}
if( mode == 0 && (is_hole || img0[lnbd.y * step + lnbd.x] > 0) )
goto resume_scan;
origin.y = y;
origin.x = x - is_hole;
/* find contour parent */
if( mode <= 1 || (!is_hole && mode == 2) || lnbd.x <= 0 )
{
par_info = &(scanner->frame_info);
}
else
{
int lval = img0[lnbd.y * step + lnbd.x] & 0x7f;
_CvContourInfo *cur = scanner->cinfo_table[lval - 2];
assert( lval >= 2 );
/* find the first bounding contour */
while( cur )
{
if( (unsigned) (lnbd.x - cur->rect.x) < (unsigned) cur->rect.width &&
(unsigned) (lnbd.y - cur->rect.y) < (unsigned) cur->rect.height )
{
if( par_info )
{
if( icvTraceContour( scanner->img0 +
par_info->origin.y * step +
par_info->origin.x, step, img + lnbd.x,
par_info->is_hole ) > 0 )
break;
}
par_info = cur;
}
cur = cur->next;
}
assert( par_info != 0 );
/* if current contour is a hole and previous contour is a hole or
current contour is external and previous contour is external then
the parent of the contour is the parent of the previous contour else
the parent is the previous contour itself. */
if( par_info->is_hole == is_hole )
{
par_info = par_info->parent;
/* every contour must have a parent
(at least, the frame of the image) */
if( !par_info )
par_info = &(scanner->frame_info);
}
/* hole flag of the parent must differ from the flag of the contour */
assert( par_info->is_hole != is_hole );
if( par_info->contour == 0 ) /* removed contour */
goto resume_scan;
}
lnbd.x = x - is_hole;
cvSaveMemStoragePos( scanner->storage2, &(scanner->backup_pos) );
seq = cvCreateSeq( scanner->seq_type1, scanner->header_size1,
scanner->elem_size1, scanner->storage1 );
if( !seq )
{
result = CV_OUTOFMEM_ERR;
goto exit_func;
}
seq->flags |= is_hole ? CV_SEQ_FLAG_HOLE : 0;
/* initialize header */
if( mode <= 1 )
{
l_cinfo = &(scanner->cinfo_temp);
result = icvFetchContour( img + x - is_hole, step,
cvPoint( origin.x + scanner->offset.x,
origin.y + scanner->offset.y),
seq, scanner->approx_method1 );
if( result < 0 )
goto exit_func;
}
else
{
union { _CvContourInfo* ci; CvSetElem* se; } v;
v.ci = l_cinfo;
cvSetAdd( scanner->cinfo_set, 0, &v.se );
l_cinfo = v.ci;
result = icvFetchContourEx( img + x - is_hole, step,
cvPoint( origin.x + scanner->offset.x,
origin.y + scanner->offset.y),
seq, scanner->approx_method1,
nbd, &(l_cinfo->rect) );
if( result < 0 )
goto exit_func;
l_cinfo->rect.x -= scanner->offset.x;
l_cinfo->rect.y -= scanner->offset.y;
l_cinfo->next = scanner->cinfo_table[nbd - 2];
scanner->cinfo_table[nbd - 2] = l_cinfo;
/* change nbd */
nbd = (nbd + 1) & 127;
nbd += nbd == 0 ? 3 : 0;
}
l_cinfo->is_hole = is_hole;
l_cinfo->contour = seq;
l_cinfo->origin = origin;
l_cinfo->parent = par_info;
if( scanner->approx_method1 != scanner->approx_method2 )
{
result = icvApproximateChainTC89( (CvChain *) seq,
scanner->header_size2,
scanner->storage2,
&(l_cinfo->contour),
scanner->approx_method2 );
if( result < 0 )
goto exit_func;
cvClearMemStorage( scanner->storage1 );
}
l_cinfo->contour->v_prev = l_cinfo->parent->contour;
if( par_info->contour == 0 )
{
l_cinfo->contour = 0;
if( scanner->storage1 == scanner->storage2 )
{
cvRestoreMemStoragePos( scanner->storage1, &(scanner->backup_pos) );
}
else
{
cvClearMemStorage( scanner->storage1 );
}
p = img[x];
goto resume_scan;
}
cvSaveMemStoragePos( scanner->storage2, &(scanner->backup_pos2) );
scanner->l_cinfo = l_cinfo;
scanner->pt.x = x + 1;
scanner->pt.y = y;
scanner->lnbd = lnbd;
scanner->img = (char *) img;
scanner->nbd = nbd;
contour = l_cinfo->contour;
result = CV_OK;
goto exit_func;
resume_scan:
prev = p;
/* update lnbd */
if( prev & -2 )
{
lnbd.x = x;
}
} /* end of prev != p */
} /* end of loop on x */
lnbd.x = 0;
lnbd.y = y + 1;
x = 1;
prev = 0;
} /* end of loop on y */
exit_func:
if( result != 0 )
contour = 0;
if( result < 0 )
CV_ERROR_FROM_STATUS( result );
__END__;
return contour;
}