Chiebot-Mirror
/
opencv
mirror of https://github.com/opencv/opencv.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

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

Browse Source
pull/1470/head
Ovidiu Parvu 11 years ago
parent 737c5fe781
commit 73f476bd4b
1 changed files with 113 additions and 95 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 208
      modules/imgproc/src/min_enclosing_triangle.cpp

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

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

Write Preview
Loading…
Cancel
Save