mirror/opencv
1
0
Fork 0
mirror of https://github.com/opencv/opencv.git synced 2024-11-29 13:47:32 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

Added a namespace and prefixed global variables with "G_" in order to prevent variable shadowing problems.

Browse Source
This commit is contained in:
Ovidiu Parvu 2013-09-18 15:51:10 +01:00
parent 737c5fe781
commit 73f476bd4b
1 changed files with 113 additions and 95 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

208
modules/imgproc/src/min_enclosing_triangle.cpp
View File

@ -100,35 +100,41 @@
/////////////////////////////////// Global variables ///////////////////////////////////// /////////////////////////////////// Global variables /////////////////////////////////////
static unsigned int validationFlag; namespace minEnclosingTriangle {
static cv::Point2f vertexA; static unsigned int G_validationFlag;
static cv::Point2f vertexB;
static cv::Point2f vertexC;
static cv::Point2f sideAStartVertex; static cv::Point2f G_vertexA;
static cv::Point2f sideAEndVertex; static cv::Point2f G_vertexB;
static cv::Point2f G_vertexC;
static cv::Point2f sideBStartVertex; static cv::Point2f G_sideAStartVertex;
static cv::Point2f sideBEndVertex; static cv::Point2f G_sideAEndVertex;
static cv::Point2f sideCStartVertex; static cv::Point2f G_sideBStartVertex;
static cv::Point2f sideCEndVertex; static cv::Point2f G_sideBEndVertex;
static double triangleArea; static cv::Point2f G_sideCStartVertex;
static cv::Point2f G_sideCEndVertex;
static unsigned int a; static double G_triangleArea;
static unsigned int b;
static unsigned int c;
static unsigned int nrOfPoints; static unsigned int G_a;
static unsigned int G_b;
static unsigned int G_c;
static std::vector<cv::Point2f> polygon; static unsigned int G_nrOfPoints;
static std::vector<cv::Point2f> G_polygon;
};
////////////////////////////// Helper functions declarations ///////////////////////////// ////////////////////////////// Helper functions declarations /////////////////////////////
namespace minEnclosingTriangle {
static void advance(unsigned int &index); static void advance(unsigned int &index);
static void advanceBToRightChain(); static void advanceBToRightChain();
@ -257,6 +263,8 @@ static void updateSidesBA();
static void updateSidesCA(); static void updateSidesCA();
};
///////////////////////////////////// Main functions ///////////////////////////////////// ///////////////////////////////////// Main functions /////////////////////////////////////
@ -269,7 +277,7 @@ static void updateSidesCA();
*/ */
void cv::minEnclosingTriangle(cv::InputArray points, void cv::minEnclosingTriangle(cv::InputArray points,
CV_OUT cv::OutputArray triangle, CV_OUT double &area) { CV_OUT cv::OutputArray triangle, CV_OUT double &area) {
findMinEnclosingTriangle(points, triangle, area); minEnclosingTriangle::findMinEnclosingTriangle(points, triangle, area);
} }
//! Find the minimum enclosing triangle and its area for the given set of points //! Find the minimum enclosing triangle and its area for the given set of points
@ -281,13 +289,15 @@ void cv::minEnclosingTriangle(cv::InputArray points,
CV_OUT cv::OutputArray triangle) { CV_OUT cv::OutputArray triangle) {
double area; double area;
findMinEnclosingTriangle(points, triangle, area); minEnclosingTriangle::findMinEnclosingTriangle(points, triangle, area);
} }
/////////////////////////////// Helper functions definition ////////////////////////////// /////////////////////////////// Helper functions definition //////////////////////////////
namespace minEnclosingTriangle {
//! Find the minimum enclosing triangle and its area //! Find the minimum enclosing triangle and its area
/*! /*!
* @param points Set of points * @param points Set of points
@ -316,7 +326,7 @@ static void createConvexHull(cv::InputArray points) {
pointsMat.convertTo(pointsVector, CV_32F); pointsMat.convertTo(pointsVector, CV_32F);
convexHull(pointsVector, polygon, true, true); convexHull(pointsVector, G_polygon, true, true);
} }
//! Find the minimum enclosing triangle and its area //! Find the minimum enclosing triangle and its area
@ -327,10 +337,10 @@ static void createConvexHull(cv::InputArray points) {
* @param triangle Minimum area triangle enclosing the given polygon * @param triangle Minimum area triangle enclosing the given polygon
* @param area Area of the minimum area enclosing triangle * @param area Area of the minimum area enclosing triangle
*/ */
static void findMinEnclosingTriangle( std::vector<cv::Point2f> &triangle, double &area) { static void findMinEnclosingTriangle(std::vector<cv::Point2f> &triangle, double &area) {
initialise(triangle, area); initialise(triangle, area);
if (polygon.size() > 3) { if (G_polygon.size() > 3) {
findMinimumAreaEnclosingTriangle(triangle, area); findMinimumAreaEnclosingTriangle(triangle, area);
} else { } else {
returnMinimumAreaEnclosingTriangle(triangle, area); returnMinimumAreaEnclosingTriangle(triangle, area);
@ -353,16 +363,16 @@ static void copyResultingTriangle(const std::vector<cv::Point2f> &resultingTrian
* @param area Area of the minimum area enclosing triangle * @param area Area of the minimum area enclosing triangle
*/ */
static void initialise(std::vector<cv::Point2f> &triangle, double &area) { static void initialise(std::vector<cv::Point2f> &triangle, double &area) {
nrOfPoints = static_cast<unsigned int>(polygon.size()); G_nrOfPoints = static_cast<unsigned int>(G_polygon.size());
area = std::numeric_limits<double>::max(); area = std::numeric_limits<double>::max();
// Clear all points previously stored in the vector // Clear all points previously stored in the vector
triangle.clear(); triangle.clear();
// Initialise the values of the indices for the algorithm // Initialise the values of the indices for the algorithm
a = 1; G_a = 1;
b = 2; G_b = 2;
c = 0; G_c = 0;
} }
//! Find the minimum area enclosing triangle for the given polygon //! Find the minimum area enclosing triangle for the given polygon
@ -371,7 +381,7 @@ static void initialise(std::vector<cv::Point2f> &triangle, double &area) {
* @param area Area of the minimum area enclosing triangle * @param area Area of the minimum area enclosing triangle
*/ */
static void findMinimumAreaEnclosingTriangle(std::vector<cv::Point2f> &triangle, double &area) { static void findMinimumAreaEnclosingTriangle(std::vector<cv::Point2f> &triangle, double &area) {
for (c = 0; c < nrOfPoints; c++) { for (G_c = 0; G_c < G_nrOfPoints; G_c++) {
advanceBToRightChain(); advanceBToRightChain();
moveAIfLowAndBIfHigh(); moveAIfLowAndBIfHigh();
searchForBTangency(); searchForBTangency();
@ -397,7 +407,7 @@ static void findMinimumAreaEnclosingTriangle(std::vector<cv::Point2f> &triangle,
*/ */
static void returnMinimumAreaEnclosingTriangle(std::vector<cv::Point2f> &triangle, double &area) { static void returnMinimumAreaEnclosingTriangle(std::vector<cv::Point2f> &triangle, double &area) {
for (int i = 0; i < 3; i++) { for (int i = 0; i < 3; i++) {
triangle.push_back(polygon[i % nrOfPoints]); triangle.push_back(G_polygon[i % G_nrOfPoints]);
} }
area = areaOfTriangle(triangle[0], triangle[1], triangle[2]); area = areaOfTriangle(triangle[0], triangle[1], triangle[2]);
@ -408,8 +418,8 @@ static void returnMinimumAreaEnclosingTriangle(std::vector<cv::Point2f> &triangl
* See paper [2] for more details * See paper [2] for more details
*/ */
static void advanceBToRightChain() { static void advanceBToRightChain() {
while (greaterOrEqual(height(successor(b)), height(b))) { while (greaterOrEqual(height(successor(G_b)), height(G_b))) {
advance(b); advance(G_b);
} }
} }
@ -420,11 +430,11 @@ static void advanceBToRightChain() {
static void moveAIfLowAndBIfHigh() { static void moveAIfLowAndBIfHigh() {
cv::Point2f gammaOfA; cv::Point2f gammaOfA;
while(height(b) > height(a)) { while(height(G_b) > height(G_a)) {
if ((gamma(a, gammaOfA)) && (intersectsBelow(gammaOfA, b))) { if ((gamma(G_a, gammaOfA)) && (intersectsBelow(gammaOfA, G_b))) {
advance(b); advance(G_b);
} else { } else {
advance(a); advance(G_a);
} }
} }
} }
@ -436,9 +446,9 @@ static void moveAIfLowAndBIfHigh() {
static void searchForBTangency() { static void searchForBTangency() {
cv::Point2f gammaOfB; cv::Point2f gammaOfB;
while (((gamma(b, gammaOfB)) && (intersectsBelow(gammaOfB, b))) && while (((gamma(G_b, gammaOfB)) && (intersectsBelow(gammaOfB, G_b))) &&
(greaterOrEqual(height(b), height(predecessor(a))))) { (greaterOrEqual(height(G_b), height(predecessor(G_a))))) {
advance(b); advance(G_b);
} }
} }
@ -449,7 +459,8 @@ static void searchForBTangency() {
static bool isNotBTangency() { static bool isNotBTangency() {
cv::Point2f gammaOfB; cv::Point2f gammaOfB;
if (((gamma(b, gammaOfB)) && (intersectsAbove(gammaOfB, b))) || (height(b) < height(predecessor(a)))) { if (((gamma(G_b, gammaOfB)) && (intersectsAbove(gammaOfB, G_b))) ||
(height(G_b) < height(predecessor(G_a)))) {
return true; return true;
} }
@ -462,11 +473,11 @@ static bool isNotBTangency() {
* Side A will have as start and end vertices the polygon points "a" and "a-1" * Side A will have as start and end vertices the polygon points "a" and "a-1"
*/ */
static void updateSidesCA() { static void updateSidesCA() {
sideCStartVertex = polygon[predecessor(c)]; G_sideCStartVertex = G_polygon[predecessor(G_c)];
sideCEndVertex = polygon[c]; G_sideCEndVertex = G_polygon[G_c];
sideAStartVertex = polygon[predecessor(a)]; G_sideAStartVertex = G_polygon[predecessor(G_a)];
sideAEndVertex = polygon[a]; G_sideAEndVertex = G_polygon[G_a];
} }
//! Update sides B and possibly A if tangency for side B was not obtained //! Update sides B and possibly A if tangency for side B was not obtained
@ -475,20 +486,20 @@ static void updateSidesCA() {
*/ */
static void updateSidesBA() { static void updateSidesBA() {
// Side B is flush with edge [b, b-1] // Side B is flush with edge [b, b-1]
sideBStartVertex = polygon[predecessor(b)]; G_sideBStartVertex = G_polygon[predecessor(G_b)];
sideBEndVertex = polygon[b]; G_sideBEndVertex = G_polygon[G_b];
// Find middle point of side B // Find middle point of side B
cv::Point2f sideBMiddlePoint; cv::Point2f sideBMiddlePoint;
if ((middlePointOfSideB(sideBMiddlePoint)) && if ((middlePointOfSideB(sideBMiddlePoint)) &&
(height(sideBMiddlePoint) < height(predecessor(a)))) { (height(sideBMiddlePoint) < height(predecessor(G_a)))) {
sideAStartVertex = polygon[predecessor(a)]; G_sideAStartVertex = G_polygon[predecessor(G_a)];
sideAEndVertex = findVertexCOnSideB(); G_sideAEndVertex = findVertexCOnSideB();
validationFlag = VALIDATION_SIDE_A_TANGENT; G_validationFlag = VALIDATION_SIDE_A_TANGENT;
} else { } else {
validationFlag = VALIDATION_SIDES_FLUSH; G_validationFlag = VALIDATION_SIDES_FLUSH;
} }
} }
@ -497,13 +508,13 @@ static void updateSidesBA() {
* See paper [2] for more details * See paper [2] for more details
*/ */
static void updateSideB() { static void updateSideB() {
if (!gamma(b, sideBStartVertex)) { if (!gamma(G_b, G_sideBStartVertex)) {
CV_Error(cv::Error::StsInternal, ERR_SIDE_B_GAMMA); CV_Error(cv::Error::StsInternal, ERR_SIDE_B_GAMMA);
} }
sideBEndVertex = polygon[b]; G_sideBEndVertex = G_polygon[G_b];
validationFlag = VALIDATION_SIDE_B_TANGENT; G_validationFlag = VALIDATION_SIDE_B_TANGENT;
} }
//! Update the triangle vertices after all sides were set and check if a local minimal triangle was found or not //! Update the triangle vertices after all sides were set and check if a local minimal triangle was found or not
@ -511,9 +522,12 @@ static void updateSideB() {
* See paper [2] for more details * See paper [2] for more details
*/ */
static bool isLocalMinimalTriangle() { static bool isLocalMinimalTriangle() {
if ((!lineIntersection(sideAStartVertex, sideAEndVertex, sideBStartVertex, sideBEndVertex, vertexC)) || if ((!lineIntersection(G_sideAStartVertex, G_sideAEndVertex,
(!lineIntersection(sideAStartVertex, sideAEndVertex, sideCStartVertex, sideCEndVertex, vertexB)) || G_sideBStartVertex, G_sideBEndVertex, G_vertexC)) ||
(!lineIntersection(sideBStartVertex, sideBEndVertex, sideCStartVertex, sideCEndVertex, vertexA))) { (!lineIntersection(G_sideAStartVertex, G_sideAEndVertex,
G_sideCStartVertex, G_sideCEndVertex, G_vertexB)) ||
(!lineIntersection(G_sideBStartVertex, G_sideBEndVertex,
G_sideCStartVertex, G_sideCEndVertex, G_vertexA))) {
return false; return false;
} }
@ -527,19 +541,19 @@ static bool isLocalMinimalTriangle() {
* See paper [2] for more details * See paper [2] for more details
*/ */
static bool isValidMinimalTriangle() { static bool isValidMinimalTriangle() {
cv::Point2f midpointSideA = middlePoint(vertexB, vertexC); cv::Point2f midpointSideA = middlePoint(G_vertexB, G_vertexC);
cv::Point2f midpointSideB = middlePoint(vertexA, vertexC); cv::Point2f midpointSideB = middlePoint(G_vertexA, G_vertexC);
cv::Point2f midpointSideC = middlePoint(vertexA, vertexB); cv::Point2f midpointSideC = middlePoint(G_vertexA, G_vertexB);
bool sideAValid = (validationFlag == VALIDATION_SIDE_A_TANGENT) bool sideAValid = (G_validationFlag == VALIDATION_SIDE_A_TANGENT)
? (areEqualPoints(midpointSideA, polygon[predecessor(a)])) ? (areEqualPoints(midpointSideA, G_polygon[predecessor(G_a)]))
: (isPointOnLineSegment(midpointSideA, sideAStartVertex, sideAEndVertex)); : (isPointOnLineSegment(midpointSideA, G_sideAStartVertex, G_sideAEndVertex));
bool sideBValid = (validationFlag == VALIDATION_SIDE_B_TANGENT) bool sideBValid = (G_validationFlag == VALIDATION_SIDE_B_TANGENT)
? (areEqualPoints(midpointSideB, polygon[b])) ? (areEqualPoints(midpointSideB, G_polygon[G_b]))
: (isPointOnLineSegment(midpointSideB, sideBStartVertex, sideBEndVertex)); : (isPointOnLineSegment(midpointSideB, G_sideBStartVertex, G_sideBEndVertex));
bool sideCValid = isPointOnLineSegment(midpointSideC, sideCStartVertex, sideCEndVertex); bool sideCValid = isPointOnLineSegment(midpointSideC, G_sideCStartVertex, G_sideCEndVertex);
return (sideAValid && sideBValid && sideCValid); return (sideAValid && sideBValid && sideCValid);
} }
@ -550,16 +564,16 @@ static bool isValidMinimalTriangle() {
* @param area Area of the minimum area triangle enclosing the given polygon * @param area Area of the minimum area triangle enclosing the given polygon
*/ */
static void updateMinimumAreaEnclosingTriangle(std::vector<cv::Point2f> &triangle, double &area) { static void updateMinimumAreaEnclosingTriangle(std::vector<cv::Point2f> &triangle, double &area) {
triangleArea = areaOfTriangle(vertexA, vertexB, vertexC); G_triangleArea = areaOfTriangle(G_vertexA, G_vertexB, G_vertexC);
if (triangleArea < area) { if (G_triangleArea < area) {
triangle.clear(); triangle.clear();
triangle.push_back(vertexA); triangle.push_back(G_vertexA);
triangle.push_back(vertexB); triangle.push_back(G_vertexB);
triangle.push_back(vertexC); triangle.push_back(G_vertexC);
area = triangleArea; area = G_triangleArea;
} }
} }
@ -567,8 +581,8 @@ static void updateMinimumAreaEnclosingTriangle(std::vector<cv::Point2f> &triangl
static bool middlePointOfSideB(cv::Point2f& middlePointOfSideB) { static bool middlePointOfSideB(cv::Point2f& middlePointOfSideB) {
cv::Point2f vertexA, vertexC; cv::Point2f vertexA, vertexC;
if ((!lineIntersection(sideBStartVertex, sideBEndVertex, sideCStartVertex, sideCEndVertex, vertexA)) || if ((!lineIntersection(G_sideBStartVertex, G_sideBEndVertex, G_sideCStartVertex, G_sideCEndVertex, vertexA)) ||
(!lineIntersection(sideBStartVertex, sideBEndVertex, sideAStartVertex, sideAEndVertex, vertexC))) { (!lineIntersection(G_sideBStartVertex, G_sideBEndVertex, G_sideAStartVertex, G_sideAEndVertex, vertexC))) {
return false; return false;
} }
@ -586,7 +600,7 @@ static bool middlePointOfSideB(cv::Point2f& middlePointOfSideB) {
* @param polygonPointIndex Index of the polygon point which is considered when determining the line * @param polygonPointIndex Index of the polygon point which is considered when determining the line
*/ */
static bool intersectsBelow(const cv::Point2f &gammaPoint, unsigned int polygonPointIndex) { static bool intersectsBelow(const cv::Point2f &gammaPoint, unsigned int polygonPointIndex) {
double angleOfGammaAndPoint = angleOfLineWrtOxAxis(polygon[polygonPointIndex], gammaPoint); double angleOfGammaAndPoint = angleOfLineWrtOxAxis(G_polygon[polygonPointIndex], gammaPoint);
return (intersects(angleOfGammaAndPoint, polygonPointIndex) == INTERSECTS_BELOW); return (intersects(angleOfGammaAndPoint, polygonPointIndex) == INTERSECTS_BELOW);
} }
@ -600,7 +614,7 @@ static bool intersectsBelow(const cv::Point2f &gammaPoint, unsigned int polygonP
* @param polygonPointIndex Index of the polygon point which is considered when determining the line * @param polygonPointIndex Index of the polygon point which is considered when determining the line
*/ */
static bool intersectsAbove(const cv::Point2f &gammaPoint, unsigned int polygonPointIndex) { static bool intersectsAbove(const cv::Point2f &gammaPoint, unsigned int polygonPointIndex) {
double angleOfGammaAndPoint = angleOfLineWrtOxAxis(gammaPoint, polygon[polygonPointIndex]); double angleOfGammaAndPoint = angleOfLineWrtOxAxis(gammaPoint, G_polygon[polygonPointIndex]);
return (intersects(angleOfGammaAndPoint, polygonPointIndex) == INTERSECTS_ABOVE); return (intersects(angleOfGammaAndPoint, polygonPointIndex) == INTERSECTS_ABOVE);
} }
@ -611,12 +625,12 @@ static bool intersectsAbove(const cv::Point2f &gammaPoint, unsigned int polygonP
* @param polygonPointIndex Index of the polygon point which is considered when determining the line * @param polygonPointIndex Index of the polygon point which is considered when determining the line
*/ */
static unsigned int intersects(double angleGammaAndPoint, unsigned int polygonPointIndex) { static unsigned int intersects(double angleGammaAndPoint, unsigned int polygonPointIndex) {
double anglePointPredecessor = angleOfLineWrtOxAxis(polygon[predecessor(polygonPointIndex)], double anglePointPredecessor = angleOfLineWrtOxAxis(G_polygon[predecessor(polygonPointIndex)],
polygon[polygonPointIndex]); G_polygon[polygonPointIndex]);
double anglePointSuccessor = angleOfLineWrtOxAxis(polygon[successor(polygonPointIndex)], double anglePointSuccessor = angleOfLineWrtOxAxis(G_polygon[successor(polygonPointIndex)],
polygon[polygonPointIndex]); G_polygon[polygonPointIndex]);
double angleFlushEdge = angleOfLineWrtOxAxis(polygon[predecessor(c)], double angleFlushEdge = angleOfLineWrtOxAxis(G_polygon[predecessor(G_c)],
polygon[c]); G_polygon[G_c]);
if (isFlushAngleBtwPredAndSucc(angleFlushEdge, anglePointPredecessor, anglePointSuccessor)) { if (isFlushAngleBtwPredAndSucc(angleFlushEdge, anglePointPredecessor, anglePointSuccessor)) {
if ((isGammaAngleBtw(angleGammaAndPoint, anglePointPredecessor, angleFlushEdge)) || if ((isGammaAngleBtw(angleGammaAndPoint, anglePointPredecessor, angleFlushEdge)) ||
@ -678,14 +692,15 @@ static bool gamma(unsigned int polygonPointIndex, cv::Point2f &gammaPoint) {
cv::Point2f intersectionPoint1, intersectionPoint2; cv::Point2f intersectionPoint1, intersectionPoint2;
// Get intersection points if they exist // Get intersection points if they exist
if (!findGammaIntersectionPoints(polygonPointIndex, polygon[a], polygon[predecessor(a)], polygon[c], if (!findGammaIntersectionPoints(polygonPointIndex, G_polygon[G_a], G_polygon[predecessor(G_a)],
polygon[predecessor(c)], intersectionPoint1, intersectionPoint2)) { G_polygon[G_c], G_polygon[predecessor(G_c)],
intersectionPoint1, intersectionPoint2)) {
return false; return false;
} }
// Select the point which is on the same side of line C as the polygon // Select the point which is on the same side of line C as the polygon
if (areOnTheSameSideOfLine(intersectionPoint1, polygon[successor(c)], if (areOnTheSameSideOfLine(intersectionPoint1, G_polygon[successor(G_c)],
polygon[c], polygon[predecessor(c)])) { G_polygon[G_c], G_polygon[predecessor(G_c)])) {
gammaPoint = intersectionPoint1; gammaPoint = intersectionPoint1;
} else { } else {
gammaPoint = intersectionPoint2; gammaPoint = intersectionPoint2;
@ -810,14 +825,15 @@ static cv::Point2f findVertexCOnSideB() {
cv::Point2f intersectionPoint1, intersectionPoint2; cv::Point2f intersectionPoint1, intersectionPoint2;
// Get intersection points if they exist // Get intersection points if they exist
if (!findGammaIntersectionPoints(predecessor(a), sideBStartVertex, sideBEndVertex, sideCStartVertex, if (!findGammaIntersectionPoints(predecessor(G_a), G_sideBStartVertex, G_sideBEndVertex,
sideCEndVertex, intersectionPoint1, intersectionPoint2)) { G_sideCStartVertex, G_sideCEndVertex,
intersectionPoint1, intersectionPoint2)) {
CV_Error(cv::Error::StsInternal, ERR_VERTEX_C_ON_SIDE_B); CV_Error(cv::Error::StsInternal, ERR_VERTEX_C_ON_SIDE_B);
} }
// Select the point which is on the same side of line C as the polygon // Select the point which is on the same side of line C as the polygon
if (areOnTheSameSideOfLine(intersectionPoint1, polygon[successor(c)], if (areOnTheSameSideOfLine(intersectionPoint1, G_polygon[successor(G_c)],
polygon[c], polygon[predecessor(c)])) { G_polygon[G_c], G_polygon[predecessor(G_c)])) {
return intersectionPoint1; return intersectionPoint1;
} else { } else {
return intersectionPoint2; return intersectionPoint2;
@ -831,8 +847,8 @@ static cv::Point2f findVertexCOnSideB() {
* @param polygonPoint Polygon point * @param polygonPoint Polygon point
*/ */
static double height(const cv::Point2f &polygonPoint) { static double height(const cv::Point2f &polygonPoint) {
cv::Point2f pointC = polygon[c]; cv::Point2f pointC = G_polygon[G_c];
cv::Point2f pointCPredecessor = polygon[predecessor(c)]; cv::Point2f pointCPredecessor = G_polygon[predecessor(G_c)];
return distanceFromPointToLine(polygonPoint, pointC, pointCPredecessor); return distanceFromPointToLine(polygonPoint, pointC, pointCPredecessor);
} }
@ -844,10 +860,10 @@ static double height(const cv::Point2f &polygonPoint) {
* @param polygonPointIndex Index of the polygon point * @param polygonPointIndex Index of the polygon point
*/ */
static double height(unsigned int polygonPointIndex) { static double height(unsigned int polygonPointIndex) {
cv::Point2f pointC = polygon[c]; cv::Point2f pointC = G_polygon[G_c];
cv::Point2f pointCPredecessor = polygon[predecessor(c)]; cv::Point2f pointCPredecessor = G_polygon[predecessor(G_c)];
cv::Point2f polygonPoint = polygon[polygonPointIndex]; cv::Point2f polygonPoint = G_polygon[polygonPointIndex];
return distanceFromPointToLine(polygonPoint, pointC, pointCPredecessor); return distanceFromPointToLine(polygonPoint, pointC, pointCPredecessor);
} }
@ -868,7 +884,7 @@ static void advance(unsigned int &index) {
* @param index Index of the point * @param index Index of the point
*/ */
static unsigned int successor(unsigned int index) { static unsigned int successor(unsigned int index) {
return ((index + 1) % nrOfPoints); return ((index + 1) % G_nrOfPoints);
} }
//! Return the predecessor of the provided point index //! Return the predecessor of the provided point index
@ -879,7 +895,7 @@ static unsigned int successor(unsigned int index) {
* @param index Index of the point * @param index Index of the point
*/ */
static unsigned int predecessor(unsigned int index) { static unsigned int predecessor(unsigned int index) {
return (index == 0) ? (nrOfPoints - 1) return (index == 0) ? (G_nrOfPoints - 1)
: (index - 1); : (index - 1);
} }
@ -1294,6 +1310,8 @@ static bool lessOrEqual(double number1, double number2) {
return ((number1 < number2) || (almostEqual(number1, number2))); return ((number1 < number2) || (almostEqual(number1, number2)));
} }
};
////////////////////////////////////////////// C API /////////////////////////////////////////// ////////////////////////////////////////////// C API ///////////////////////////////////////////