diff --git a/modules/imgproc/src/contours.cpp b/modules/imgproc/src/contours.cpp index 01f0393779..9078d7075b 100644 --- a/modules/imgproc/src/contours.cpp +++ b/modules/imgproc/src/contours.cpp @@ -1813,77 +1813,6 @@ double cv::matchShapes( InputArray _contour1, } -void cv::convexHull( InputArray _points, OutputArray _hull, bool clockwise, bool returnPoints ) -{ - Mat points = _points.getMat(); - int nelems = points.checkVector(2), depth = points.depth(); - CV_Assert(nelems >= 0 && (depth == CV_32F || depth == CV_32S)); - - if( nelems == 0 ) - { - _hull.release(); - return; - } - - returnPoints = !_hull.fixedType() ? returnPoints : _hull.type() != CV_32S; - Mat hull(nelems, 1, returnPoints ? CV_MAKETYPE(depth, 2) : CV_32S); - CvMat _cpoints = points, _chull = hull; - cvConvexHull2(&_cpoints, &_chull, clockwise ? CV_CLOCKWISE : CV_COUNTER_CLOCKWISE, returnPoints); - _hull.create(_chull.rows, 1, hull.type(), -1, true); - Mat dhull = _hull.getMat(), shull(dhull.size(), dhull.type(), hull.data); - shull.copyTo(dhull); -} - - -void cv::convexityDefects( InputArray _points, InputArray _hull, OutputArray _defects ) -{ - Mat points = _points.getMat(); - int ptnum = points.checkVector(2, CV_32S); - CV_Assert( ptnum > 3 ); - Mat hull = _hull.getMat(); - CV_Assert( hull.checkVector(1, CV_32S) > 2 ); - Ptr storage = cvCreateMemStorage(); - - CvMat c_points = points, c_hull = hull; - CvSeq* seq = cvConvexityDefects(&c_points, &c_hull, storage); - int i, n = seq->total; - - if( n == 0 ) - { - _defects.release(); - return; - } - - _defects.create(n, 1, CV_32SC4); - Mat defects = _defects.getMat(); - - SeqIterator it = Seq(seq).begin(); - CvPoint* ptorg = (CvPoint*)points.data; - - for( i = 0; i < n; i++, ++it ) - { - CvConvexityDefect& d = *it; - int idx0 = (int)(d.start - ptorg); - int idx1 = (int)(d.end - ptorg); - int idx2 = (int)(d.depth_point - ptorg); - CV_Assert( 0 <= idx0 && idx0 < ptnum ); - CV_Assert( 0 <= idx1 && idx1 < ptnum ); - CV_Assert( 0 <= idx2 && idx2 < ptnum ); - CV_Assert( d.depth >= 0 ); - int idepth = cvRound(d.depth*256); - defects.at(i) = Vec4i(idx0, idx1, idx2, idepth); - } -} - - -bool cv::isContourConvex( InputArray _contour ) -{ - Mat contour = _contour.getMat(); - CV_Assert(contour.checkVector(2) >= 0 && - (contour.depth() == CV_32F || contour.depth() == CV_32S)); - CvMat c = Mat(contour); - return cvCheckContourConvexity(&c) > 0; -} cv::RotatedRect cv::fitEllipse( InputArray _points ) { diff --git a/modules/imgproc/src/convhull.cpp b/modules/imgproc/src/convhull.cpp index 145c55e053..a06763861b 100644 --- a/modules/imgproc/src/convhull.cpp +++ b/modules/imgproc/src/convhull.cpp @@ -40,7 +40,9 @@ //M*/ #include "precomp.hpp" +#include +#if 0 static int icvSklansky_32s( CvPoint** array, int start, int end, int* stack, int nsign, int sign2 ) { @@ -113,7 +115,6 @@ icvSklansky_32s( CvPoint** array, int start, int end, int* stack, int nsign, int return --stacksize; } - static int icvSklansky_32f( CvPoint2D32f** array, int start, int end, int* stack, int nsign, int sign2 ) { @@ -751,7 +752,7 @@ cvCheckContourConvexity( const CvArr* array ) dydx0 = dy * dx0; /* find orientation */ - /*orient = -dy0 * dx + dx0 * dy; + /* orient = -dy0 * dx + dx0 * dy; orientation |= (orient > 0) ? 1 : 2; */ orientation |= (dydx0 > dxdy0) ? 1 : ((dydx0 < dxdy0) ? 2 : 3); @@ -792,7 +793,7 @@ cvCheckContourConvexity( const CvArr* array ) dydx0 = dy * dx0; /* find orientation */ - /*orient = -dy0 * dx + dx0 * dy; + /* orient = -dy0 * dx + dx0 * dy; orientation |= (orient > 0) ? 1 : 2; */ orientation |= (dydx0 > dxdy0) ? 1 : ((dydx0 < dxdy0) ? 2 : 3); @@ -811,5 +812,737 @@ cvCheckContourConvexity( const CvArr* array ) return flag; } +void cv::convexHull( InputArray _points, OutputArray _hull, bool clockwise, bool returnPoints ) +{ + Mat points = _points.getMat(); + int nelems = points.checkVector(2), depth = points.depth(); + CV_Assert(nelems >= 0 && (depth == CV_32F || depth == CV_32S)); + + if( nelems == 0 ) + { + _hull.release(); + return; + } + + returnPoints = !_hull.fixedType() ? returnPoints : _hull.type() != CV_32S; + Mat hull(nelems, 1, returnPoints ? CV_MAKETYPE(depth, 2) : CV_32S); + CvMat _cpoints = points, _chull = hull; + cvConvexHull2(&_cpoints, &_chull, clockwise ? CV_CLOCKWISE : CV_COUNTER_CLOCKWISE, returnPoints); + _hull.create(_chull.rows, 1, hull.type(), -1, true); + Mat dhull = _hull.getMat(), shull(dhull.size(), dhull.type(), hull.data); + shull.copyTo(dhull); + std::cout << "convex hull: " << dhull; +} + +#else + +namespace cv +{ + +template +static int Sklansky_( Point_<_Tp>** array, int start, int end, int* stack, int nsign, int sign2 ) +{ + int incr = end > start ? 1 : -1; + // prepare first triangle + int pprev = start, pcur = pprev + incr, pnext = pcur + incr; + int stacksize = 3; + + if( start == end || + (array[start]->x == array[end]->x && + array[start]->y == array[end]->y) ) + { + stack[0] = start; + return 1; + } + + stack[0] = pprev; + stack[1] = pcur; + stack[2] = pnext; + + end += incr; // make end = afterend + + while( pnext != end ) + { + // check the angle p1,p2,p3 + _Tp cury = array[pcur]->y; + _Tp nexty = array[pnext]->y; + _Tp by = nexty - cury; + + if( CV_SIGN( by ) != nsign ) + { + _Tp ax = array[pcur]->x - array[pprev]->x; + _Tp bx = array[pnext]->x - array[pcur]->x; + _Tp ay = cury - array[pprev]->y; + _Tp convexity = ay*bx - ax*by; // if >0 then convex angle + + if( CV_SIGN( convexity ) == sign2 && (ax != 0 || ay != 0) ) + { + pprev = pcur; + pcur = pnext; + pnext += incr; + stack[stacksize] = pnext; + stacksize++; + } + else + { + if( pprev == start ) + { + pcur = pnext; + stack[1] = pcur; + pnext += incr; + stack[2] = pnext; + } + else + { + stack[stacksize-2] = pnext; + pcur = pprev; + pprev = stack[stacksize-4]; + stacksize--; + } + } + } + else + { + pnext += incr; + stack[stacksize-1] = pnext; + } + } + + return --stacksize; +} + + +template +struct CHullCmpPoints +{ + bool operator()(const Point_<_Tp>* p1, const Point_<_Tp>* p2) const + { return p1->x < p2->x || (p1->x == p2->x && p1->y < p2->y); } +}; + + +void convexityDefects( InputArray _points, InputArray _hull, OutputArray _defects ) +{ + Mat points = _points.getMat(); + int ptnum = points.checkVector(2, CV_32S); + CV_Assert( ptnum > 3 ); + Mat hull = _hull.getMat(); + CV_Assert( hull.checkVector(1, CV_32S) > 2 ); + Ptr storage = cvCreateMemStorage(); + + CvMat c_points = points, c_hull = hull; + CvSeq* seq = cvConvexityDefects(&c_points, &c_hull, storage); + int i, n = seq->total; + + if( n == 0 ) + { + _defects.release(); + return; + } + + _defects.create(n, 1, CV_32SC4); + Mat defects = _defects.getMat(); + + SeqIterator it = Seq(seq).begin(); + CvPoint* ptorg = (CvPoint*)points.data; + + for( i = 0; i < n; i++, ++it ) + { + CvConvexityDefect& d = *it; + int idx0 = (int)(d.start - ptorg); + int idx1 = (int)(d.end - ptorg); + int idx2 = (int)(d.depth_point - ptorg); + CV_Assert( 0 <= idx0 && idx0 < ptnum ); + CV_Assert( 0 <= idx1 && idx1 < ptnum ); + CV_Assert( 0 <= idx2 && idx2 < ptnum ); + CV_Assert( d.depth >= 0 ); + int idepth = cvRound(d.depth*256); + defects.at(i) = Vec4i(idx0, idx1, idx2, idepth); + } +} + + +bool isContourConvex( InputArray _contour ) +{ + Mat contour = _contour.getMat(); + CV_Assert(contour.checkVector(2) >= 0 && + (contour.depth() == CV_32F || contour.depth() == CV_32S)); + CvMat c = Mat(contour); + return cvCheckContourConvexity(&c) > 0; +} + + +void convexHull( InputArray _points, OutputArray _hull, bool clockwise, bool returnPoints ) +{ + Mat points = _points.getMat(); + int i, total = points.checkVector(2), depth = points.depth(), nout = 0; + int miny_ind = 0, maxy_ind = 0; + CV_Assert(total >= 0 && (depth == CV_32F || depth == CV_32S)); + + if( total == 0 ) + { + _hull.release(); + return; + } + + returnPoints = !_hull.fixedType() ? returnPoints : _hull.type() != CV_32S; + + bool is_float = depth == CV_32F; + AutoBuffer _pointer(total); + AutoBuffer _stack(total + 2), _hullbuf(total); + Point** pointer = _pointer; + Point2f** pointerf = (Point2f**)pointer; + Point* data0 = (Point*)points.data; + int* stack = _stack; + int* hullbuf = _hullbuf; + + CV_Assert(points.isContinuous()); + + for( i = 0; i < total; i++ ) + pointer[i] = &data0[i]; + + // sort the point set by x-coordinate, find min and max y + if( !is_float ) + { + std::sort(pointer, pointer + total, CHullCmpPoints()); + for( i = 1; i < total; i++ ) + { + int y = pointer[i]->y; + if( pointer[miny_ind]->y > y ) + miny_ind = i; + if( pointer[maxy_ind]->y < y ) + maxy_ind = i; + } + } + else + { + std::sort(pointerf, pointerf + total, CHullCmpPoints()); + for( i = 1; i < total; i++ ) + { + float y = pointerf[i]->y; + if( pointerf[miny_ind]->y > y ) + miny_ind = i; + if( pointerf[maxy_ind]->y < y ) + maxy_ind = i; + } + } + + if( pointer[0]->x == pointer[total-1]->x && + pointer[0]->y == pointer[total-1]->y ) + { + hullbuf[nout++] = 0; + } + else + { + // upper half + int *tl_stack = stack; + int tl_count = !is_float ? + Sklansky_( pointer, 0, maxy_ind, tl_stack, -1, 1) : + Sklansky_( pointerf, 0, maxy_ind, tl_stack, -1, 1); + int *tr_stack = stack + tl_count; + int tr_count = !is_float ? + Sklansky_( pointer, total-1, maxy_ind, tr_stack, -1, -1) : + Sklansky_( pointerf, total-1, maxy_ind, tr_stack, -1, -1); + + // gather upper part of convex hull to output + if( !clockwise ) + { + std::swap( tl_stack, tr_stack ); + std::swap( tl_count, tr_count ); + } + + for( i = 0; i < tl_count-1; i++ ) + hullbuf[nout++] = pointer[tl_stack[i]] - data0; + for( i = tr_count - 1; i > 0; i-- ) + hullbuf[nout++] = pointer[tr_stack[i]] - data0; + int stop_idx = tr_count > 2 ? tr_stack[1] : tl_count > 2 ? tl_stack[tl_count - 2] : -1; + + // lower half + int *bl_stack = stack; + int bl_count = !is_float ? + Sklansky_( pointer, 0, miny_ind, bl_stack, 1, -1) : + Sklansky_( pointerf, 0, miny_ind, bl_stack, 1, -1); + int *br_stack = stack + bl_count; + int br_count = !is_float ? + Sklansky_( pointer, total-1, miny_ind, br_stack, 1, 1) : + Sklansky_( pointerf, total-1, miny_ind, br_stack, 1, 1); + + if( clockwise ) + { + std::swap( bl_stack, br_stack ); + std::swap( bl_count, br_count ); + } + + if( stop_idx >= 0 ) + { + int check_idx = bl_count > 2 ? bl_stack[1] : + bl_count + br_count > 2 ? br_stack[2-bl_count] : -1; + if( check_idx == stop_idx || (check_idx >= 0 && + pointer[check_idx]->x == pointer[stop_idx]->x && + pointer[check_idx]->y == pointer[stop_idx]->y) ) + { + // if all the points lie on the same line, then + // the bottom part of the convex hull is the mirrored top part + // (except the exteme points). + bl_count = MIN( bl_count, 2 ); + br_count = MIN( br_count, 2 ); + } + } + + for( i = 0; i < bl_count-1; i++ ) + hullbuf[nout++] = pointer[bl_stack[i]] - data0; + for( i = br_count-1; i > 0; i-- ) + hullbuf[nout++] = pointer[br_stack[i]] - data0; + } + + if( !returnPoints ) + Mat(nout, 1, CV_32S, hullbuf).copyTo(_hull); + else + { + _hull.create(nout, 1, CV_MAKETYPE(depth, 2)); + Mat hull = _hull.getMat(); + size_t step = !hull.isContinuous() ? hull.step[0] : sizeof(Point); + for( i = 0; i < nout; i++ ) + *(Point*)(hull.data + i*step) = data0[hullbuf[i]]; + } +} + +} + +CV_IMPL CvSeq* +cvConvexHull2( const CvArr* array, void* hull_storage, + int orientation, int return_points ) +{ + union { CvContour* c; CvSeq* s; } hull; + hull.s = 0; + + CvMat* mat = 0; + CvContour contour_header; + union { CvContour c; CvSeq s; } hull_header; + CvSeqBlock block, hullblock; + CvSeq* ptseq = 0; + CvSeq* hullseq = 0; + + if( CV_IS_SEQ( array )) + { + ptseq = (CvSeq*)array; + if( !CV_IS_SEQ_POINT_SET( ptseq )) + CV_Error( CV_StsBadArg, "Unsupported sequence type" ); + if( hull_storage == 0 ) + hull_storage = ptseq->storage; + } + else + { + ptseq = cvPointSeqFromMat( CV_SEQ_KIND_GENERIC, array, &contour_header, &block ); + } + + if( CV_IS_STORAGE( hull_storage )) + { + if( return_points ) + { + hullseq = cvCreateSeq(CV_SEQ_KIND_CURVE|CV_SEQ_ELTYPE(ptseq)| + CV_SEQ_FLAG_CLOSED|CV_SEQ_FLAG_CONVEX, + sizeof(CvContour), sizeof(CvPoint),(CvMemStorage*)hull_storage ); + } + else + { + hullseq = cvCreateSeq( + CV_SEQ_KIND_CURVE|CV_SEQ_ELTYPE_PPOINT| + CV_SEQ_FLAG_CLOSED|CV_SEQ_FLAG_CONVEX, + sizeof(CvContour), sizeof(CvPoint*), (CvMemStorage*)hull_storage ); + } + } + else + { + if( !CV_IS_MAT( hull_storage )) + CV_Error(CV_StsBadArg, "Destination must be valid memory storage or matrix"); + + mat = (CvMat*)hull_storage; + + if( (mat->cols != 1 && mat->rows != 1) || !CV_IS_MAT_CONT(mat->type)) + CV_Error( CV_StsBadArg, + "The hull matrix should be continuous and have a single row or a single column" ); + + if( mat->cols + mat->rows - 1 < ptseq->total ) + CV_Error( CV_StsBadSize, "The hull matrix size might be not enough to fit the hull" ); + + if( CV_MAT_TYPE(mat->type) != CV_SEQ_ELTYPE(ptseq) && + CV_MAT_TYPE(mat->type) != CV_32SC1 ) + CV_Error( CV_StsUnsupportedFormat, + "The hull matrix must have the same type as input or 32sC1 (integers)" ); + + hullseq = cvMakeSeqHeaderForArray( + CV_SEQ_KIND_CURVE|CV_MAT_TYPE(mat->type)|CV_SEQ_FLAG_CLOSED, + sizeof(contour_header), CV_ELEM_SIZE(mat->type), mat->data.ptr, + mat->cols + mat->rows - 1, &hull_header.s, &hullblock ); + cvClearSeq( hullseq ); + } + + int hulltype = CV_SEQ_ELTYPE(hullseq); + int total = ptseq->total; + if( total == 0 ) + { + if( mat ) + CV_Error( CV_StsBadSize, + "Point sequence can not be empty if the output is matrix" ); + return hull.s; + } + + cv::AutoBuffer _ptbuf(total); + cv::Point* ptbuf = _ptbuf; + cv::Mat h0; + + cvCvtSeqToArray(ptseq, ptbuf); + cv::convexHull(cv::Mat(total, 1, CV_SEQ_ELTYPE(ptseq), ptbuf), h0, + orientation == CV_CLOCKWISE, CV_MAT_CN(hulltype) == 2); + + if( hulltype == CV_SEQ_ELTYPE_PPOINT ) + { + const int* idx = h0.ptr(); + int ctotal = (int)h0.total(); + for( int i = 0; i < ctotal; i++ ) + { + void* ptr = cvGetSeqElem(ptseq, idx[i]); + cvSeqPush( hullseq, &ptr ); + } + } + else + cvSeqPushMulti(hullseq, h0.data, (int)h0.total()); + + if( mat ) + { + if( mat->rows > mat->cols ) + mat->rows = hullseq->total; + else + mat->cols = hullseq->total; + } + else + { + hull.s = hullseq; + hull.c->rect = cvBoundingRect( ptseq, + ptseq->header_size < (int)sizeof(CvContour) || + &ptseq->flags == &contour_header.flags ); + } + + return hull.s; +} + + +/* contour must be a simple polygon */ +/* it must have more than 3 points */ +CV_IMPL CvSeq* cvConvexityDefects( const CvArr* array, + const CvArr* hullarray, + CvMemStorage* storage ) +{ + CvSeq* defects = 0; + + int i, index; + CvPoint* hull_cur; + + /* is orientation of hull different from contour one */ + int rev_orientation; + + CvContour contour_header; + union { CvContour c; CvSeq s; } hull_header; + CvSeqBlock block, hullblock; + CvSeq *ptseq = (CvSeq*)array, *hull = (CvSeq*)hullarray; + + CvSeqReader hull_reader; + CvSeqReader ptseq_reader; + CvSeqWriter writer; + int is_index; + + if( CV_IS_SEQ( ptseq )) + { + if( !CV_IS_SEQ_POINT_SET( ptseq )) + CV_Error( CV_StsUnsupportedFormat, + "Input sequence is not a sequence of points" ); + if( !storage ) + storage = ptseq->storage; + } + else + { + ptseq = cvPointSeqFromMat( CV_SEQ_KIND_GENERIC, array, &contour_header, &block ); + } + + if( CV_SEQ_ELTYPE( ptseq ) != CV_32SC2 ) + CV_Error( CV_StsUnsupportedFormat, "Floating-point coordinates are not supported here" ); + + if( CV_IS_SEQ( hull )) + { + int hulltype = CV_SEQ_ELTYPE( hull ); + if( hulltype != CV_SEQ_ELTYPE_PPOINT && hulltype != CV_SEQ_ELTYPE_INDEX ) + CV_Error( CV_StsUnsupportedFormat, + "Convex hull must represented as a sequence " + "of indices or sequence of pointers" ); + if( !storage ) + storage = hull->storage; + } + else + { + CvMat* mat = (CvMat*)hull; + + if( !CV_IS_MAT( hull )) + CV_Error(CV_StsBadArg, "Convex hull is neither sequence nor matrix"); + + if( (mat->cols != 1 && mat->rows != 1) || + !CV_IS_MAT_CONT(mat->type) || CV_MAT_TYPE(mat->type) != CV_32SC1 ) + CV_Error( CV_StsBadArg, + "The matrix should be 1-dimensional and continuous array of int's" ); + + if( mat->cols + mat->rows - 1 > ptseq->total ) + CV_Error( CV_StsBadSize, "Convex hull is larger than the point sequence" ); + + hull = cvMakeSeqHeaderForArray( + CV_SEQ_KIND_CURVE|CV_MAT_TYPE(mat->type)|CV_SEQ_FLAG_CLOSED, + sizeof(CvContour), CV_ELEM_SIZE(mat->type), mat->data.ptr, + mat->cols + mat->rows - 1, &hull_header.s, &hullblock ); + } + + is_index = CV_SEQ_ELTYPE(hull) == CV_SEQ_ELTYPE_INDEX; + + if( !storage ) + CV_Error( CV_StsNullPtr, "NULL storage pointer" ); + + defects = cvCreateSeq( CV_SEQ_KIND_GENERIC, sizeof(CvSeq), sizeof(CvConvexityDefect), storage ); + + if( ptseq->total < 4 || hull->total < 3) + { + //CV_ERROR( CV_StsBadSize, + // "point seq size must be >= 4, convex hull size must be >= 3" ); + return defects; + } + + /* recognize co-orientation of ptseq and its hull */ + { + int sign = 0; + int index1, index2, index3; + + if( !is_index ) + { + CvPoint* pos = *CV_SEQ_ELEM( hull, CvPoint*, 0 ); + index1 = cvSeqElemIdx( ptseq, pos ); + + pos = *CV_SEQ_ELEM( hull, CvPoint*, 1 ); + index2 = cvSeqElemIdx( ptseq, pos ); + + pos = *CV_SEQ_ELEM( hull, CvPoint*, 2 ); + index3 = cvSeqElemIdx( ptseq, pos ); + } + else + { + index1 = *CV_SEQ_ELEM( hull, int, 0 ); + index2 = *CV_SEQ_ELEM( hull, int, 1 ); + index3 = *CV_SEQ_ELEM( hull, int, 2 ); + } + + sign += (index2 > index1) ? 1 : 0; + sign += (index3 > index2) ? 1 : 0; + sign += (index1 > index3) ? 1 : 0; + + rev_orientation = (sign == 2) ? 0 : 1; + } + + cvStartReadSeq( ptseq, &ptseq_reader, 0 ); + cvStartReadSeq( hull, &hull_reader, rev_orientation ); + + if( !is_index ) + { + hull_cur = *(CvPoint**)hull_reader.prev_elem; + index = cvSeqElemIdx( ptseq, (char*)hull_cur, 0 ); + } + else + { + index = *(int*)hull_reader.prev_elem; + hull_cur = CV_GET_SEQ_ELEM( CvPoint, ptseq, index ); + } + cvSetSeqReaderPos( &ptseq_reader, index ); + cvStartAppendToSeq( defects, &writer ); + + /* cycle through ptseq and hull with computing defects */ + for( i = 0; i < hull->total; i++ ) + { + CvConvexityDefect defect; + int is_defect = 0; + double dx0, dy0; + double depth = 0, scale; + CvPoint* hull_next; + + if( !is_index ) + hull_next = *(CvPoint**)hull_reader.ptr; + else + { + int t = *(int*)hull_reader.ptr; + hull_next = CV_GET_SEQ_ELEM( CvPoint, ptseq, t ); + } + + dx0 = (double)hull_next->x - (double)hull_cur->x; + dy0 = (double)hull_next->y - (double)hull_cur->y; + assert( dx0 != 0 || dy0 != 0 ); + scale = 1./sqrt(dx0*dx0 + dy0*dy0); + + defect.start = hull_cur; + defect.end = hull_next; + + for(;;) + { + /* go through ptseq to achieve next hull point */ + CV_NEXT_SEQ_ELEM( sizeof(CvPoint), ptseq_reader ); + + if( ptseq_reader.ptr == (schar*)hull_next ) + break; + else + { + CvPoint* cur = (CvPoint*)ptseq_reader.ptr; + + /* compute distance from current point to hull edge */ + double dx = (double)cur->x - (double)hull_cur->x; + double dy = (double)cur->y - (double)hull_cur->y; + + /* compute depth */ + double dist = fabs(-dy0*dx + dx0*dy) * scale; + + if( dist > depth ) + { + depth = dist; + defect.depth_point = cur; + defect.depth = (float)depth; + is_defect = 1; + } + } + } + if( is_defect ) + { + CV_WRITE_SEQ_ELEM( defect, writer ); + } + + hull_cur = hull_next; + if( rev_orientation ) + { + CV_PREV_SEQ_ELEM( hull->elem_size, hull_reader ); + } + else + { + CV_NEXT_SEQ_ELEM( hull->elem_size, hull_reader ); + } + } + + return cvEndWriteSeq( &writer ); +} + + +CV_IMPL int +cvCheckContourConvexity( const CvArr* array ) +{ + int flag = -1; + + int i; + int orientation = 0; + CvSeqReader reader; + CvContour contour_header; + CvSeqBlock block; + CvSeq* contour = (CvSeq*)array; + + if( CV_IS_SEQ(contour) ) + { + if( !CV_IS_SEQ_POINT_SET(contour)) + CV_Error( CV_StsUnsupportedFormat, + "Input sequence must be polygon (closed 2d curve)" ); + } + else + { + contour = cvPointSeqFromMat(CV_SEQ_KIND_CURVE|CV_SEQ_FLAG_CLOSED, array, &contour_header, &block ); + } + + if( contour->total == 0 ) + return -1; + + cvStartReadSeq( contour, &reader, 0 ); + flag = 1; + + if( CV_SEQ_ELTYPE( contour ) == CV_32SC2 ) + { + CvPoint *prev_pt = (CvPoint*)reader.prev_elem; + CvPoint *cur_pt = (CvPoint*)reader.ptr; + + int dx0 = cur_pt->x - prev_pt->x; + int dy0 = cur_pt->y - prev_pt->y; + + for( i = 0; i < contour->total; i++ ) + { + int dxdy0, dydx0; + int dx, dy; + + /*int orient; */ + CV_NEXT_SEQ_ELEM( sizeof(CvPoint), reader ); + prev_pt = cur_pt; + cur_pt = (CvPoint *) reader.ptr; + + dx = cur_pt->x - prev_pt->x; + dy = cur_pt->y - prev_pt->y; + dxdy0 = dx * dy0; + dydx0 = dy * dx0; + + /* find orientation */ + /* orient = -dy0 * dx + dx0 * dy; + orientation |= (orient > 0) ? 1 : 2; + */ + orientation |= (dydx0 > dxdy0) ? 1 : ((dydx0 < dxdy0) ? 2 : 3); + + if( orientation == 3 ) + { + flag = 0; + break; + } + + dx0 = dx; + dy0 = dy; + } + } + else + { + CV_Assert( CV_SEQ_ELTYPE(contour) == CV_32FC2 ); + + CvPoint2D32f *prev_pt = (CvPoint2D32f*)reader.prev_elem; + CvPoint2D32f *cur_pt = (CvPoint2D32f*)reader.ptr; + + float dx0 = cur_pt->x - prev_pt->x; + float dy0 = cur_pt->y - prev_pt->y; + + for( i = 0; i < contour->total; i++ ) + { + float dxdy0, dydx0; + float dx, dy; + + /*int orient; */ + CV_NEXT_SEQ_ELEM( sizeof(CvPoint2D32f), reader ); + prev_pt = cur_pt; + cur_pt = (CvPoint2D32f*) reader.ptr; + + dx = cur_pt->x - prev_pt->x; + dy = cur_pt->y - prev_pt->y; + dxdy0 = dx * dy0; + dydx0 = dy * dx0; + + /* find orientation */ + /* orient = -dy0 * dx + dx0 * dy; + orientation |= (orient > 0) ? 1 : 2; + */ + orientation |= (dydx0 > dxdy0) ? 1 : ((dydx0 < dxdy0) ? 2 : 3); + + if( orientation == 3 ) + { + flag = 0; + break; + } + + dx0 = dx; + dy0 = dy; + } + } + + return flag; +} + +#endif /* End of file. */