#include "precomp.hpp"
#include <iostream>
-#if 0
-/* 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
-
namespace cv
{
/*M///////////////////////////////////////////////////////////////////////////////////////
- //
- // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
- //
- // By downloading, copying, installing or using the software you agree to this license.
- // If you do not agree to this license, do not download, install,
- // copy or use the software.
- //
- //
- // License Agreement
- // For Open Source Computer Vision Library
- //
- // Copyright (C) 2000, Intel Corporation, all rights reserved.
- // Third party copyrights are property of their respective owners.
- //
- // Redistribution and use in source and binary forms, with or without modification,
- // are permitted provided that the following conditions are met:
- //
- // * Redistribution's of source code must retain the above copyright notice,
- // this list of conditions and the following disclaimer.
- //
- // * Redistribution's in binary form must reproduce the above copyright notice,
- // this list of conditions and the following disclaimer in the documentation
- // and/or other materials provided with the distribution.
- //
- // * The name of OpenCV Foundation may not be used to endorse or promote products
- // derived from this software without specific prior written permission.
- //
- // This software is provided by the copyright holders and contributors "as is" and
- // any express or implied warranties, including, but not limited to, the implied
- // warranties of merchantability and fitness for a particular purpose are disclaimed.
- // In no event shall the OpenCV Foundation or contributors be liable for any direct,
- // indirect, incidental, special, exemplary, or consequential damages
- // (including, but not limited to, procurement of substitute goods or services;
- // loss of use, data, or profits; or business interruption) however caused
- // and on any theory of liability, whether in contract, strict liability,
- // or tort (including negligence or otherwise) arising in any way out of
- // the use of this software, even if advised of the possibility of such damage.
- //
- //M*/
+//
+// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+// By downloading, copying, installing or using the software you agree to this license.
+// If you do not agree to this license, do not download, install,
+// copy or use the software.
+//
+//
+// License Agreement
+// For Open Source Computer Vision Library
+//
+// Copyright (C) 2000, Intel Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+// * Redistribution's of source code must retain the above copyright notice,
+// this list of conditions and the following disclaimer.
+//
+// * Redistribution's in binary form must reproduce the above copyright notice,
+// this list of conditions and the following disclaimer in the documentation
+// and/or other materials provided with the distribution.
+//
+// * The name of OpenCV Foundation may not be used to endorse or promote products
+// derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the OpenCV Foundation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
#include "precomp.hpp"
namespace cv
{
- struct MinAreaState
- {
- int bottom;
- int left;
- float height;
- float width;
- float base_a;
- float base_b;
- };
-
- enum { CALIPERS_MAXHEIGHT=0, CALIPERS_MINAREARECT=1, CALIPERS_MAXDIST=2 };
-
- /*F///////////////////////////////////////////////////////////////////////////////////////
- // Name: rotatingCalipers
- // Purpose:
- // Rotating calipers algorithm with some applications
- //
- // Context:
- // Parameters:
- // points - convex hull vertices ( any orientation )
- // n - number of vertices
- // mode - concrete application of algorithm
- // can be CV_CALIPERS_MAXDIST or
- // CV_CALIPERS_MINAREARECT
- // left, bottom, right, top - indexes of extremal points
- // out - output info.
- // In case CV_CALIPERS_MAXDIST it points to float value -
- // maximal height of polygon.
- // In case CV_CALIPERS_MINAREARECT
- // ((CvPoint2D32f*)out)[0] - corner
- // ((CvPoint2D32f*)out)[1] - vector1
- // ((CvPoint2D32f*)out)[0] - corner2
- //
- // ^
- // |
- // vector2 |
- // |
- // |____________\
- // corner /
- // vector1
- //
- // Returns:
- // Notes:
- //F*/
-
- /* we will use usual cartesian coordinates */
- static void rotatingCalipers( const Point2f* points, int n, int mode, float* out )
+struct MinAreaState
+{
+ int bottom;
+ int left;
+ float height;
+ float width;
+ float base_a;
+ float base_b;
+};
+
+enum { CALIPERS_MAXHEIGHT=0, CALIPERS_MINAREARECT=1, CALIPERS_MAXDIST=2 };
+
+/*F///////////////////////////////////////////////////////////////////////////////////////
+ // Name: rotatingCalipers
+ // Purpose:
+ // Rotating calipers algorithm with some applications
+ //
+ // Context:
+ // Parameters:
+ // points - convex hull vertices ( any orientation )
+ // n - number of vertices
+ // mode - concrete application of algorithm
+ // can be CV_CALIPERS_MAXDIST or
+ // CV_CALIPERS_MINAREARECT
+ // left, bottom, right, top - indexes of extremal points
+ // out - output info.
+ // In case CV_CALIPERS_MAXDIST it points to float value -
+ // maximal height of polygon.
+ // In case CV_CALIPERS_MINAREARECT
+ // ((CvPoint2D32f*)out)[0] - corner
+ // ((CvPoint2D32f*)out)[1] - vector1
+ // ((CvPoint2D32f*)out)[0] - corner2
+ //
+ // ^
+ // |
+ // vector2 |
+ // |
+ // |____________\
+ // corner /
+ // vector1
+ //
+ // Returns:
+ // Notes:
+ //F*/
+
+/* we will use usual cartesian coordinates */
+static void rotatingCalipers( const Point2f* points, int n, int mode, float* out )
+{
+ float minarea = FLT_MAX;
+ float max_dist = 0;
+ char buffer[32] = {};
+ int i, k;
+ AutoBuffer<float> abuf(n*3);
+ float* inv_vect_length = abuf;
+ Point2f* vect = (Point2f*)(inv_vect_length + n);
+ int left = 0, bottom = 0, right = 0, top = 0;
+ int seq[4] = { -1, -1, -1, -1 };
+
+ /* rotating calipers sides will always have coordinates
+ (a,b) (-b,a) (-a,-b) (b, -a)
+ */
+ /* this is a first base bector (a,b) initialized by (1,0) */
+ float orientation = 0;
+ float base_a;
+ float base_b = 0;
+
+ float left_x, right_x, top_y, bottom_y;
+ Point2f pt0 = points[0];
+
+ left_x = right_x = pt0.x;
+ top_y = bottom_y = pt0.y;
+
+ for( i = 0; i < n; i++ )
{
- float minarea = FLT_MAX;
- float max_dist = 0;
- char buffer[32] = {};
- int i, k;
- AutoBuffer<float> buf(n*3);
- float* inv_vect_length = buf;
- Point2f* vect = (Point2f*)(inv_vect_length + n);
- int left = 0, bottom = 0, right = 0, top = 0;
- int seq[4] = { -1, -1, -1, -1 };
-
- /* rotating calipers sides will always have coordinates
- (a,b) (-b,a) (-a,-b) (b, -a)
- */
- /* this is a first base bector (a,b) initialized by (1,0) */
- float orientation = 0;
- float base_a;
- float base_b = 0;
-
- float left_x, right_x, top_y, bottom_y;
- Point2f pt0 = points[0];
-
- left_x = right_x = pt0.x;
- top_y = bottom_y = pt0.y;
+ double dx, dy;
- for( i = 0; i < n; i++ )
- {
- double dx, dy;
+ if( pt0.x < left_x )
+ left_x = pt0.x, left = i;
- if( pt0.x < left_x )
- left_x = pt0.x, left = i;
+ if( pt0.x > right_x )
+ right_x = pt0.x, right = i;
- if( pt0.x > right_x )
- right_x = pt0.x, right = i;
+ if( pt0.y > top_y )
+ top_y = pt0.y, top = i;
- if( pt0.y > top_y )
- top_y = pt0.y, top = i;
+ if( pt0.y < bottom_y )
+ bottom_y = pt0.y, bottom = i;
- if( pt0.y < bottom_y )
- bottom_y = pt0.y, bottom = i;
+ Point2f pt = points[(i+1) & (i+1 < n ? -1 : 0)];
- Point2f pt = points[(i+1) & (i+1 < n ? -1 : 0)];
+ dx = pt.x - pt0.x;
+ dy = pt.y - pt0.y;
- dx = pt.x - pt0.x;
- dy = pt.y - pt0.y;
+ vect[i].x = (float)dx;
+ vect[i].y = (float)dy;
+ inv_vect_length[i] = (float)(1./sqrt(dx*dx + dy*dy));
- vect[i].x = (float)dx;
- vect[i].y = (float)dy;
- inv_vect_length[i] = (float)(1./sqrt(dx*dx + dy*dy));
+ pt0 = pt;
+ }
- pt0 = pt;
- }
+ // find convex hull orientation
+ {
+ double ax = vect[n-1].x;
+ double ay = vect[n-1].y;
- // find convex hull orientation
+ for( i = 0; i < n; i++ )
{
- double ax = vect[n-1].x;
- double ay = vect[n-1].y;
+ double bx = vect[i].x;
+ double by = vect[i].y;
+
+ double convexity = ax * by - ay * bx;
- for( i = 0; i < n; i++ )
+ if( convexity != 0 )
{
- double bx = vect[i].x;
- double by = vect[i].y;
-
- double convexity = ax * by - ay * bx;
-
- if( convexity != 0 )
- {
- orientation = (convexity > 0) ? 1.f : (-1.f);
- break;
- }
- ax = bx;
- ay = by;
+ orientation = (convexity > 0) ? 1.f : (-1.f);
+ break;
}
- CV_Assert( orientation != 0 );
+ ax = bx;
+ ay = by;
}
- base_a = orientation;
-
- /*****************************************************************************************/
- /* init calipers position */
- seq[0] = bottom;
- seq[1] = right;
- seq[2] = top;
- seq[3] = left;
- /*****************************************************************************************/
- /* Main loop - evaluate angles and rotate calipers */
-
- /* all of edges will be checked while rotating calipers by 90 degrees */
- for( k = 0; k < n; k++ )
+ CV_Assert( orientation != 0 );
+ }
+ base_a = orientation;
+
+ /*****************************************************************************************/
+ /* init calipers position */
+ seq[0] = bottom;
+ seq[1] = right;
+ seq[2] = top;
+ seq[3] = left;
+ /*****************************************************************************************/
+ /* Main loop - evaluate angles and rotate calipers */
+
+ /* all of edges will be checked while rotating calipers by 90 degrees */
+ for( k = 0; k < n; k++ )
+ {
+ /* sinus of minimal angle */
+ /*float sinus;*/
+
+ /* compute cosine of angle between calipers side and polygon edge */
+ /* dp - dot product */
+ float dp0 = base_a * vect[seq[0]].x + base_b * vect[seq[0]].y;
+ float dp1 = -base_b * vect[seq[1]].x + base_a * vect[seq[1]].y;
+ float dp2 = -base_a * vect[seq[2]].x - base_b * vect[seq[2]].y;
+ float dp3 = base_b * vect[seq[3]].x - base_a * vect[seq[3]].y;
+
+ float cosalpha = dp0 * inv_vect_length[seq[0]];
+ float maxcos = cosalpha;
+
+ /* number of calipers edges, that has minimal angle with edge */
+ int main_element = 0;
+
+ /* choose minimal angle */
+ cosalpha = dp1 * inv_vect_length[seq[1]];
+ maxcos = (cosalpha > maxcos) ? (main_element = 1, cosalpha) : maxcos;
+ cosalpha = dp2 * inv_vect_length[seq[2]];
+ maxcos = (cosalpha > maxcos) ? (main_element = 2, cosalpha) : maxcos;
+ cosalpha = dp3 * inv_vect_length[seq[3]];
+ maxcos = (cosalpha > maxcos) ? (main_element = 3, cosalpha) : maxcos;
+
+ /*rotate calipers*/
{
- /* sinus of minimal angle */
- /*float sinus;*/
-
- /* compute cosine of angle between calipers side and polygon edge */
- /* dp - dot product */
- float dp0 = base_a * vect[seq[0]].x + base_b * vect[seq[0]].y;
- float dp1 = -base_b * vect[seq[1]].x + base_a * vect[seq[1]].y;
- float dp2 = -base_a * vect[seq[2]].x - base_b * vect[seq[2]].y;
- float dp3 = base_b * vect[seq[3]].x - base_a * vect[seq[3]].y;
-
- float cosalpha = dp0 * inv_vect_length[seq[0]];
- float maxcos = cosalpha;
-
- /* number of calipers edges, that has minimal angle with edge */
- int main_element = 0;
-
- /* choose minimal angle */
- cosalpha = dp1 * inv_vect_length[seq[1]];
- maxcos = (cosalpha > maxcos) ? (main_element = 1, cosalpha) : maxcos;
- cosalpha = dp2 * inv_vect_length[seq[2]];
- maxcos = (cosalpha > maxcos) ? (main_element = 2, cosalpha) : maxcos;
- cosalpha = dp3 * inv_vect_length[seq[3]];
- maxcos = (cosalpha > maxcos) ? (main_element = 3, cosalpha) : maxcos;
-
- /*rotate calipers*/
+ //get next base
+ int pindex = seq[main_element];
+ float lead_x = vect[pindex].x*inv_vect_length[pindex];
+ float lead_y = vect[pindex].y*inv_vect_length[pindex];
+ switch( main_element )
{
- //get next base
- int pindex = seq[main_element];
- float lead_x = vect[pindex].x*inv_vect_length[pindex];
- float lead_y = vect[pindex].y*inv_vect_length[pindex];
- switch( main_element )
- {
- case 0:
- base_a = lead_x;
- base_b = lead_y;
- break;
- case 1:
- base_a = lead_y;
- base_b = -lead_x;
- break;
- case 2:
- base_a = -lead_x;
- base_b = -lead_y;
- break;
- case 3:
- base_a = -lead_y;
- base_b = lead_x;
- break;
- default:
- CV_Error(CV_StsError, "main_element should be 0, 1, 2 or 3");
- }
+ case 0:
+ base_a = lead_x;
+ base_b = lead_y;
+ break;
+ case 1:
+ base_a = lead_y;
+ base_b = -lead_x;
+ break;
+ case 2:
+ base_a = -lead_x;
+ base_b = -lead_y;
+ break;
+ case 3:
+ base_a = -lead_y;
+ base_b = lead_x;
+ break;
+ default:
+ CV_Error(CV_StsError, "main_element should be 0, 1, 2 or 3");
}
- /* change base point of main edge */
- seq[main_element] += 1;
- seq[main_element] = (seq[main_element] == n) ? 0 : seq[main_element];
-
- switch (mode)
- {
- case CALIPERS_MAXHEIGHT:
- {
- /* now main element lies on edge alligned to calipers side */
-
- /* find opposite element i.e. transform */
- /* 0->2, 1->3, 2->0, 3->1 */
- int opposite_el = main_element ^ 2;
-
- float dx = points[seq[opposite_el]].x - points[seq[main_element]].x;
- float dy = points[seq[opposite_el]].y - points[seq[main_element]].y;
- float dist;
-
- if( main_element & 1 )
- dist = (float)fabs(dx * base_a + dy * base_b);
- else
- dist = (float)fabs(dx * (-base_b) + dy * base_a);
-
- if( dist > max_dist )
- max_dist = dist;
-
- break;
- }
- case CALIPERS_MINAREARECT:
- /* find area of rectangle */
- {
- float height;
- float area;
-
- /* find vector left-right */
- float dx = points[seq[1]].x - points[seq[3]].x;
- float dy = points[seq[1]].y - points[seq[3]].y;
-
- /* dotproduct */
- float width = dx * base_a + dy * base_b;
-
- /* find vector left-right */
- dx = points[seq[2]].x - points[seq[0]].x;
- dy = points[seq[2]].y - points[seq[0]].y;
-
- /* dotproduct */
- height = -dx * base_b + dy * base_a;
-
- area = width * height;
- if( area <= minarea )
- {
- float *buf = (float *) buffer;
-
- minarea = area;
- /* leftist point */
- ((int *) buf)[0] = seq[3];
- buf[1] = base_a;
- buf[2] = width;
- buf[3] = base_b;
- buf[4] = height;
- /* bottom point */
- ((int *) buf)[5] = seq[0];
- buf[6] = area;
- }
- break;
- }
- } /*switch */
- } /* for */
+ }
+ /* change base point of main edge */
+ seq[main_element] += 1;
+ seq[main_element] = (seq[main_element] == n) ? 0 : seq[main_element];
switch (mode)
{
- case CALIPERS_MINAREARECT:
+ case CALIPERS_MAXHEIGHT:
{
- float *buf = (float *) buffer;
+ /* now main element lies on edge alligned to calipers side */
- float A1 = buf[1];
- float B1 = buf[3];
+ /* find opposite element i.e. transform */
+ /* 0->2, 1->3, 2->0, 3->1 */
+ int opposite_el = main_element ^ 2;
- float A2 = -buf[3];
- float B2 = buf[1];
+ float dx = points[seq[opposite_el]].x - points[seq[main_element]].x;
+ float dy = points[seq[opposite_el]].y - points[seq[main_element]].y;
+ float dist;
- float C1 = A1 * points[((int *) buf)[0]].x + points[((int *) buf)[0]].y * B1;
- float C2 = A2 * points[((int *) buf)[5]].x + points[((int *) buf)[5]].y * B2;
+ if( main_element & 1 )
+ dist = (float)fabs(dx * base_a + dy * base_b);
+ else
+ dist = (float)fabs(dx * (-base_b) + dy * base_a);
- float idet = 1.f / (A1 * B2 - A2 * B1);
+ if( dist > max_dist )
+ max_dist = dist;
+ }
+ break;
+ case CALIPERS_MINAREARECT:
+ /* find area of rectangle */
+ {
+ float height;
+ float area;
- float px = (C1 * B2 - C2 * B1) * idet;
- float py = (A1 * C2 - A2 * C1) * idet;
+ /* find vector left-right */
+ float dx = points[seq[1]].x - points[seq[3]].x;
+ float dy = points[seq[1]].y - points[seq[3]].y;
- out[0] = px;
- out[1] = py;
-
- out[2] = A1 * buf[2];
- out[3] = B1 * buf[2];
-
- out[4] = A2 * buf[4];
- out[5] = B2 * buf[4];
- }
- break;
- case CALIPERS_MAXHEIGHT:
+ /* dotproduct */
+ float width = dx * base_a + dy * base_b;
+
+ /* find vector left-right */
+ dx = points[seq[2]].x - points[seq[0]].x;
+ dy = points[seq[2]].y - points[seq[0]].y;
+
+ /* dotproduct */
+ height = -dx * base_b + dy * base_a;
+
+ area = width * height;
+ if( area <= minarea )
{
- out[0] = max_dist;
+ float *buf = (float *) buffer;
+
+ minarea = area;
+ /* leftist point */
+ ((int *) buf)[0] = seq[3];
+ buf[1] = base_a;
+ buf[2] = width;
+ buf[3] = base_b;
+ buf[4] = height;
+ /* bottom point */
+ ((int *) buf)[5] = seq[0];
+ buf[6] = area;
}
- break;
+ }
+ break;
+ } /*switch */
+ } /* for */
+
+ switch (mode)
+ {
+ case CALIPERS_MINAREARECT:
+ {
+ float *buf = (float *) buffer;
+
+ float A1 = buf[1];
+ float B1 = buf[3];
+
+ float A2 = -buf[3];
+ float B2 = buf[1];
+
+ float C1 = A1 * points[((int *) buf)[0]].x + points[((int *) buf)[0]].y * B1;
+ float C2 = A2 * points[((int *) buf)[5]].x + points[((int *) buf)[5]].y * B2;
+
+ float idet = 1.f / (A1 * B2 - A2 * B1);
+
+ float px = (C1 * B2 - C2 * B1) * idet;
+ float py = (A1 * C2 - A2 * C1) * idet;
+
+ out[0] = px;
+ out[1] = py;
+
+ out[2] = A1 * buf[2];
+ out[3] = B1 * buf[2];
+
+ out[4] = A2 * buf[4];
+ out[5] = B2 * buf[4];
}
+ break;
+ case CALIPERS_MAXHEIGHT:
+ {
+ out[0] = max_dist;
+ }
+ break;
}
+}
}
CV_IMPL CvBox2D
-cvMinAreaRect2( const CvArr* array, CvMemStorage* storage )
+cvMinAreaRect2( const CvArr* array, CvMemStorage* /*storage*/ )
{
cv::AutoBuffer<double> abuf;
cv::Mat points = cv::cvarrToMat(array, false, false, 0, &abuf);
projects / platform / upstream / opencv.git / commitdiff