From 9dc6d7f8c022e5bc0e73650cd8eb9a8306142d6f Mon Sep 17 00:00:00 2001 From: wmayer Date: Thu, 16 Jun 2016 11:12:12 +0200 Subject: [PATCH] fix further warnings in libarea --- src/Mod/Path/libarea/Curve.cpp | 1368 ++++++++++++------------- src/Mod/Path/libarea/PythonStuff.cpp | 2 +- src/Mod/Path/libarea/kurve/Matrix.cpp | 2 +- 3 files changed, 686 insertions(+), 686 deletions(-) diff --git a/src/Mod/Path/libarea/Curve.cpp b/src/Mod/Path/libarea/Curve.cpp index 98fa00984100..456c546e313d 100644 --- a/src/Mod/Path/libarea/Curve.cpp +++ b/src/Mod/Path/libarea/Curve.cpp @@ -3,102 +3,102 @@ // This program is released under the BSD license. See the file COPYING for details. #include "Curve.h" -#include "Circle.h" -#include "Arc.h" -#include "Area.h" -#include "kurve/geometry.h" - -const Point operator*(const double &d, const Point &p){ return p * d;} -double Point::tolerance = 0.001; - -//static const double PI = 3.1415926535897932; duplicated in kurve/geometry.h - -double Point::length()const -{ - return sqrt( x*x + y*y ); -} - -double Point::normalize() -{ - double len = length(); - if(fabs(len)> 0.000000000000001) - *this = (*this) / len; - return len; -} - -Line::Line(const Point& P0, const Point& V):p0(P0), v(V) -{ -} - -double Line::Dist(const Point& p)const -{ - Point vn = v; - vn.normalize(); - double d1 = p0 * vn; - double d2 = p * vn; - Point pn = p0 + vn * (d2 - d1); - - return pn.dist(p); -} - -CVertex::CVertex(int type, const Point& p, const Point& c, int user_data):m_type(type), m_p(p), m_c(c), m_user_data(user_data) -{ -} - -CVertex::CVertex(const Point& p, int user_data):m_type(0), m_p(p), m_c(0.0, 0.0), m_user_data(user_data) -{ -} - -void CCurve::append(const CVertex& vertex) -{ - m_vertices.push_back(vertex); -} - -bool CCurve::CheckForArc(const CVertex& prev_vt, std::list& might_be_an_arc, CArc &arc_returned) -{ - // this examines the vertices in might_be_an_arc - // if they do fit an arc, set arc to be the arc that they fit and return true - // returns true, if arc added - if(might_be_an_arc.size() < 2)return false; - - // find middle point - std::size_t num = might_be_an_arc.size(); - std::size_t i = 0; - const CVertex* mid_vt = NULL; - std::size_t mid_i = (num-1)/2; - for(std::list::iterator It = might_be_an_arc.begin(); It != might_be_an_arc.end(); It++, i++) - { - if(i == mid_i) - { - mid_vt = *It; - break; - } - } - - // create a circle to test - Point p0(prev_vt.m_p); - Point p1(mid_vt->m_p); - Point p2(might_be_an_arc.back()->m_p); - Circle c(p0, p1, p2); - - const CVertex* current_vt = &prev_vt; - double accuracy = CArea::m_accuracy * 1.4 / CArea::m_units; - for(std::list::iterator It = might_be_an_arc.begin(); It != might_be_an_arc.end(); It++) - { - const CVertex* vt = *It; - - if(!c.LineIsOn(current_vt->m_p, vt->m_p, accuracy)) - return false; - current_vt = vt; - } - - CArc arc; - arc.m_c = c.m_c; - arc.m_s = prev_vt.m_p; - arc.m_e = might_be_an_arc.back()->m_p; - arc.SetDirWithPoint(might_be_an_arc.front()->m_p); - arc.m_user_data = might_be_an_arc.back()->m_user_data; - +#include "Circle.h" +#include "Arc.h" +#include "Area.h" +#include "kurve/geometry.h" + +const Point operator*(const double &d, const Point &p){ return p * d;} +double Point::tolerance = 0.001; + +//static const double PI = 3.1415926535897932; duplicated in kurve/geometry.h + +double Point::length()const +{ + return sqrt( x*x + y*y ); +} + +double Point::normalize() +{ + double len = length(); + if(fabs(len)> 0.000000000000001) + *this = (*this) / len; + return len; +} + +Line::Line(const Point& P0, const Point& V):p0(P0), v(V) +{ +} + +double Line::Dist(const Point& p)const +{ + Point vn = v; + vn.normalize(); + double d1 = p0 * vn; + double d2 = p * vn; + Point pn = p0 + vn * (d2 - d1); + + return pn.dist(p); +} + +CVertex::CVertex(int type, const Point& p, const Point& c, int user_data):m_type(type), m_p(p), m_c(c), m_user_data(user_data) +{ +} + +CVertex::CVertex(const Point& p, int user_data):m_type(0), m_p(p), m_c(0.0, 0.0), m_user_data(user_data) +{ +} + +void CCurve::append(const CVertex& vertex) +{ + m_vertices.push_back(vertex); +} + +bool CCurve::CheckForArc(const CVertex& prev_vt, std::list& might_be_an_arc, CArc &arc_returned) +{ + // this examines the vertices in might_be_an_arc + // if they do fit an arc, set arc to be the arc that they fit and return true + // returns true, if arc added + if(might_be_an_arc.size() < 2)return false; + + // find middle point + std::size_t num = might_be_an_arc.size(); + std::size_t i = 0; + const CVertex* mid_vt = NULL; + std::size_t mid_i = (num-1)/2; + for(std::list::iterator It = might_be_an_arc.begin(); It != might_be_an_arc.end(); It++, i++) + { + if(i == mid_i) + { + mid_vt = *It; + break; + } + } + + // create a circle to test + Point p0(prev_vt.m_p); + Point p1(mid_vt->m_p); + Point p2(might_be_an_arc.back()->m_p); + Circle c(p0, p1, p2); + + const CVertex* current_vt = &prev_vt; + double accuracy = CArea::m_accuracy * 1.4 / CArea::m_units; + for(std::list::iterator It = might_be_an_arc.begin(); It != might_be_an_arc.end(); It++) + { + const CVertex* vt = *It; + + if(!c.LineIsOn(current_vt->m_p, vt->m_p, accuracy)) + return false; + current_vt = vt; + } + + CArc arc; + arc.m_c = c.m_c; + arc.m_s = prev_vt.m_p; + arc.m_e = might_be_an_arc.back()->m_p; + arc.SetDirWithPoint(might_be_an_arc.front()->m_p); + arc.m_user_data = might_be_an_arc.back()->m_user_data; + double angs = atan2(arc.m_s.y - arc.m_c.y, arc.m_s.x - arc.m_c.x); double ange = atan2(arc.m_e.y - arc.m_c.y, arc.m_e.x - arc.m_c.x); if(arc.m_dir) @@ -111,12 +111,12 @@ bool CCurve::CheckForArc(const CVertex& prev_vt, std::list& migh // make sure angs > ange if(angs < ange)angs += 6.2831853071795864; } - - if(arc.IncludedAngle() >= 3.15)return false; // We don't want full arcs, so limit to about 180 degrees - - for(std::list::iterator It = might_be_an_arc.begin(); It != might_be_an_arc.end(); It++) - { - const CVertex* vt = *It; + + if(arc.IncludedAngle() >= 3.15)return false; // We don't want full arcs, so limit to about 180 degrees + + for(std::list::iterator It = might_be_an_arc.begin(); It != might_be_an_arc.end(); It++) + { + const CVertex* vt = *It; double angp = atan2(vt->m_p.y - arc.m_c.y, vt->m_p.x - arc.m_c.x); if(arc.m_dir) { @@ -130,268 +130,268 @@ bool CCurve::CheckForArc(const CVertex& prev_vt, std::list& migh if(angp < ange)angp += 6.2831853071795864; if(angp > angs)return false; } - } - - arc_returned = arc; - return true; -} - -void CCurve::AddArcOrLines(bool check_for_arc, std::list &new_vertices, std::list& might_be_an_arc, CArc &arc, bool &arc_found, bool &arc_added) -{ - if(check_for_arc && CheckForArc(new_vertices.back(), might_be_an_arc, arc)) - { - arc_found = true; - } - else - { - if(arc_found) - { - if(arc.AlmostALine()) - { - new_vertices.push_back(CVertex(arc.m_e, arc.m_user_data)); - } - else - { - new_vertices.push_back(CVertex(arc.m_dir ? 1:-1, arc.m_e, arc.m_c, arc.m_user_data)); - } - - arc_added = true; - arc_found = false; - const CVertex* back_vt = might_be_an_arc.back(); - might_be_an_arc.clear(); - if(check_for_arc)might_be_an_arc.push_back(back_vt); - } - else - { - const CVertex* back_vt = might_be_an_arc.back(); - if(check_for_arc)might_be_an_arc.pop_back(); - for(std::list::iterator It = might_be_an_arc.begin(); It != might_be_an_arc.end(); It++) - { - const CVertex* v = *It; - if(It != might_be_an_arc.begin() || (new_vertices.size() == 0) || (new_vertices.back().m_p != v->m_p)) - { - new_vertices.push_back(*v); - } - } - might_be_an_arc.clear(); - if(check_for_arc)might_be_an_arc.push_back(back_vt); - } - } -} - -void CCurve::FitArcs() -{ - std::list new_vertices; - - std::list might_be_an_arc; - CArc arc; - bool arc_found = false; - bool arc_added = false; - - int i = 0; - for(std::list::iterator It = m_vertices.begin(); It != m_vertices.end(); It++, i++) - { - CVertex& vt = *It; - if(vt.m_type || i == 0) - { + } + + arc_returned = arc; + return true; +} + +void CCurve::AddArcOrLines(bool check_for_arc, std::list &new_vertices, std::list& might_be_an_arc, CArc &arc, bool &arc_found, bool &arc_added) +{ + if(check_for_arc && CheckForArc(new_vertices.back(), might_be_an_arc, arc)) + { + arc_found = true; + } + else + { + if(arc_found) + { + if(arc.AlmostALine()) + { + new_vertices.push_back(CVertex(arc.m_e, arc.m_user_data)); + } + else + { + new_vertices.push_back(CVertex(arc.m_dir ? 1:-1, arc.m_e, arc.m_c, arc.m_user_data)); + } + + arc_added = true; + arc_found = false; + const CVertex* back_vt = might_be_an_arc.back(); + might_be_an_arc.clear(); + if(check_for_arc)might_be_an_arc.push_back(back_vt); + } + else + { + const CVertex* back_vt = might_be_an_arc.back(); + if(check_for_arc)might_be_an_arc.pop_back(); + for(std::list::iterator It = might_be_an_arc.begin(); It != might_be_an_arc.end(); It++) + { + const CVertex* v = *It; + if(It != might_be_an_arc.begin() || (new_vertices.size() == 0) || (new_vertices.back().m_p != v->m_p)) + { + new_vertices.push_back(*v); + } + } + might_be_an_arc.clear(); + if(check_for_arc)might_be_an_arc.push_back(back_vt); + } + } +} + +void CCurve::FitArcs() +{ + std::list new_vertices; + + std::list might_be_an_arc; + CArc arc; + bool arc_found = false; + bool arc_added = false; + + int i = 0; + for(std::list::iterator It = m_vertices.begin(); It != m_vertices.end(); It++, i++) + { + CVertex& vt = *It; + if(vt.m_type || i == 0) + { if (i != 0) { AddArcOrLines(false, new_vertices, might_be_an_arc, arc, arc_found, arc_added); } - new_vertices.push_back(vt); - } - else - { - might_be_an_arc.push_back(&vt); - - if(might_be_an_arc.size() == 1) - { - } - else - { - AddArcOrLines(true, new_vertices, might_be_an_arc, arc, arc_found, arc_added); - } - } - } - - if(might_be_an_arc.size() > 0)AddArcOrLines(false, new_vertices, might_be_an_arc, arc, arc_found, arc_added); - - if(arc_added) - { - m_vertices.clear(); - for(std::list::iterator It = new_vertices.begin(); It != new_vertices.end(); It++)m_vertices.push_back(*It); - for(std::list::iterator It = might_be_an_arc.begin(); It != might_be_an_arc.end(); It++)m_vertices.push_back(*(*It)); - } -} - -void CCurve::UnFitArcs() -{ + new_vertices.push_back(vt); + } + else + { + might_be_an_arc.push_back(&vt); + + if(might_be_an_arc.size() == 1) + { + } + else + { + AddArcOrLines(true, new_vertices, might_be_an_arc, arc, arc_found, arc_added); + } + } + } + + if(might_be_an_arc.size() > 0)AddArcOrLines(false, new_vertices, might_be_an_arc, arc, arc_found, arc_added); + + if(arc_added) + { + m_vertices.clear(); + for(std::list::iterator It = new_vertices.begin(); It != new_vertices.end(); It++)m_vertices.push_back(*It); + for(std::list::iterator It = might_be_an_arc.begin(); It != might_be_an_arc.end(); It++)m_vertices.push_back(*(*It)); + } +} + +void CCurve::UnFitArcs() +{ std::list new_pts; - - const CVertex* prev_vertex = NULL; - for(std::list::const_iterator It2 = m_vertices.begin(); It2 != m_vertices.end(); It2++) - { - const CVertex& vertex = *It2; - if(vertex.m_type == 0 || prev_vertex == NULL) - { - new_pts.push_back(vertex.m_p * CArea::m_units); - } - else - { - if(vertex.m_p != prev_vertex->m_p) - { - double phi,dphi,dx,dy; - int Segments; - int i; - double ang1,ang2,phit; - - dx = (prev_vertex->m_p.x - vertex.m_c.x) * CArea::m_units; - dy = (prev_vertex->m_p.y - vertex.m_c.y) * CArea::m_units; - - ang1=atan2(dy,dx); - if (ang1<0) ang1+=2.0*PI; - dx = (vertex.m_p.x - vertex.m_c.x) * CArea::m_units; - dy = (vertex.m_p.y - vertex.m_c.y) * CArea::m_units; - ang2=atan2(dy,dx); - if (ang2<0) ang2+=2.0*PI; - - if (vertex.m_type == -1) - { //clockwise - if (ang2 > ang1) - phit=2.0*PI-ang2+ ang1; - else - phit=ang1-ang2; - } - else - { //counter_clockwise - if (ang1 > ang2) - phit=-(2.0*PI-ang1+ ang2); - else - phit=-(ang2-ang1); - } - - //what is the delta phi to get an accurancy of aber - double radius = sqrt(dx*dx + dy*dy); - dphi=2*acos((radius-CArea::m_accuracy)/radius); - - //set the number of segments - if (phit > 0) - Segments=(int)ceil(phit/dphi); - else - Segments=(int)ceil(-phit/dphi); - - if (Segments < 1) - Segments=1; - if (Segments > 100) - Segments=100; - - dphi=phit/(Segments); - - double px = prev_vertex->m_p.x * CArea::m_units; - double py = prev_vertex->m_p.y * CArea::m_units; - - for (i=1; i<=Segments; i++) - { - dx = px - vertex.m_c.x * CArea::m_units; - dy = py - vertex.m_c.y * CArea::m_units; - phi=atan2(dy,dx); - - double nx = vertex.m_c.x * CArea::m_units + radius * cos(phi-dphi); - double ny = vertex.m_c.y * CArea::m_units + radius * sin(phi-dphi); - - new_pts.push_back(Point(nx, ny)); - - px = nx; - py = ny; - } - } - } - prev_vertex = &vertex; - } - - m_vertices.clear(); - - for(std::list::iterator It = new_pts.begin(); It != new_pts.end(); It++) - { - Point &pt = *It; - CVertex vertex(0, pt / CArea::m_units, Point(0.0, 0.0)); - m_vertices.push_back(vertex); - } -} - -Point CCurve::NearestPoint(const Point& p)const -{ - double best_dist = 0.0; - Point best_point = Point(0, 0); - bool best_point_valid = false; - Point prev_p = Point(0, 0); - bool prev_p_valid = false; - bool first_span = true; - for(std::list::const_iterator It = m_vertices.begin(); It != m_vertices.end(); It++) - { - const CVertex& vertex = *It; - if(prev_p_valid) - { - Point near_point = Span(prev_p, vertex, first_span).NearestPoint(p); - first_span = false; - double dist = near_point.dist(p); - if(!best_point_valid || dist < best_dist) - { - best_dist = dist; - best_point = near_point; - best_point_valid = true; - } - } - prev_p = vertex.m_p; - prev_p_valid = true; - } - return best_point; -} - -Point CCurve::NearestPoint(const CCurve& c, double *d)const -{ - double best_dist = 0.0; - Point best_point = Point(0, 0); - bool best_point_valid = false; - Point prev_p = Point(0, 0); - bool prev_p_valid = false; - bool first_span = true; - for(std::list::const_iterator It = c.m_vertices.begin(); It != c.m_vertices.end(); It++) - { - const CVertex& vertex = *It; - if(prev_p_valid) - { - double dist; - Point near_point = NearestPoint(Span(prev_p, vertex, first_span), &dist); - first_span = false; - if(!best_point_valid || dist < best_dist) - { - best_dist = dist; - best_point = near_point; - best_point_valid = true; - } - } - prev_p = vertex.m_p; - prev_p_valid = true; - } - if(d)*d = best_dist; - return best_point; -} - + + const CVertex* prev_vertex = NULL; + for(std::list::const_iterator It2 = m_vertices.begin(); It2 != m_vertices.end(); It2++) + { + const CVertex& vertex = *It2; + if(vertex.m_type == 0 || prev_vertex == NULL) + { + new_pts.push_back(vertex.m_p * CArea::m_units); + } + else + { + if(vertex.m_p != prev_vertex->m_p) + { + double phi,dphi,dx,dy; + int Segments; + int i; + double ang1,ang2,phit; + + dx = (prev_vertex->m_p.x - vertex.m_c.x) * CArea::m_units; + dy = (prev_vertex->m_p.y - vertex.m_c.y) * CArea::m_units; + + ang1=atan2(dy,dx); + if (ang1<0) ang1+=2.0*PI; + dx = (vertex.m_p.x - vertex.m_c.x) * CArea::m_units; + dy = (vertex.m_p.y - vertex.m_c.y) * CArea::m_units; + ang2=atan2(dy,dx); + if (ang2<0) ang2+=2.0*PI; + + if (vertex.m_type == -1) + { //clockwise + if (ang2 > ang1) + phit=2.0*PI-ang2+ ang1; + else + phit=ang1-ang2; + } + else + { //counter_clockwise + if (ang1 > ang2) + phit=-(2.0*PI-ang1+ ang2); + else + phit=-(ang2-ang1); + } + + //what is the delta phi to get an accurancy of aber + double radius = sqrt(dx*dx + dy*dy); + dphi=2*acos((radius-CArea::m_accuracy)/radius); + + //set the number of segments + if (phit > 0) + Segments=(int)ceil(phit/dphi); + else + Segments=(int)ceil(-phit/dphi); + + if (Segments < 1) + Segments=1; + if (Segments > 100) + Segments=100; + + dphi=phit/(Segments); + + double px = prev_vertex->m_p.x * CArea::m_units; + double py = prev_vertex->m_p.y * CArea::m_units; + + for (i=1; i<=Segments; i++) + { + dx = px - vertex.m_c.x * CArea::m_units; + dy = py - vertex.m_c.y * CArea::m_units; + phi=atan2(dy,dx); + + double nx = vertex.m_c.x * CArea::m_units + radius * cos(phi-dphi); + double ny = vertex.m_c.y * CArea::m_units + radius * sin(phi-dphi); + + new_pts.push_back(Point(nx, ny)); + + px = nx; + py = ny; + } + } + } + prev_vertex = &vertex; + } + + m_vertices.clear(); + + for(std::list::iterator It = new_pts.begin(); It != new_pts.end(); It++) + { + Point &pt = *It; + CVertex vertex(0, pt / CArea::m_units, Point(0.0, 0.0)); + m_vertices.push_back(vertex); + } +} + +Point CCurve::NearestPoint(const Point& p)const +{ + double best_dist = 0.0; + Point best_point = Point(0, 0); + bool best_point_valid = false; + Point prev_p = Point(0, 0); + bool prev_p_valid = false; + bool first_span = true; + for(std::list::const_iterator It = m_vertices.begin(); It != m_vertices.end(); It++) + { + const CVertex& vertex = *It; + if(prev_p_valid) + { + Point near_point = Span(prev_p, vertex, first_span).NearestPoint(p); + first_span = false; + double dist = near_point.dist(p); + if(!best_point_valid || dist < best_dist) + { + best_dist = dist; + best_point = near_point; + best_point_valid = true; + } + } + prev_p = vertex.m_p; + prev_p_valid = true; + } + return best_point; +} + +Point CCurve::NearestPoint(const CCurve& c, double *d)const +{ + double best_dist = 0.0; + Point best_point = Point(0, 0); + bool best_point_valid = false; + Point prev_p = Point(0, 0); + bool prev_p_valid = false; + bool first_span = true; + for(std::list::const_iterator It = c.m_vertices.begin(); It != c.m_vertices.end(); It++) + { + const CVertex& vertex = *It; + if(prev_p_valid) + { + double dist; + Point near_point = NearestPoint(Span(prev_p, vertex, first_span), &dist); + first_span = false; + if(!best_point_valid || dist < best_dist) + { + best_dist = dist; + best_point = near_point; + best_point_valid = true; + } + } + prev_p = vertex.m_p; + prev_p_valid = true; + } + if(d)*d = best_dist; + return best_point; +} + void CCurve::GetBox(CBox2D &box) { - Point prev_p = Point(0, 0); - bool prev_p_valid = false; - for(std::list::iterator It = m_vertices.begin(); It != m_vertices.end(); It++) - { - CVertex& vertex = *It; - if(prev_p_valid) - { - Span(prev_p, vertex).GetBox(box); - } - prev_p = vertex.m_p; - prev_p_valid = true; - } + Point prev_p = Point(0, 0); + bool prev_p_valid = false; + for(std::list::iterator It = m_vertices.begin(); It != m_vertices.end(); It++) + { + CVertex& vertex = *It; + if(prev_p_valid) + { + Span(prev_p, vertex).GetBox(box); + } + prev_p = vertex.m_p; + prev_p_valid = true; + } } void CCurve::Reverse() @@ -400,48 +400,48 @@ void CCurve::Reverse() CVertex* prev_v = NULL; - for(std::list::reverse_iterator It = m_vertices.rbegin(); It != m_vertices.rend(); It++) - { - CVertex &v = *It; - int type = 0; - Point cp(0.0, 0.0); - if(prev_v) - { - type = -prev_v->m_type; - cp = prev_v->m_c; - } - CVertex new_v(type, v.m_p, cp); - new_vertices.push_back(new_v); - prev_v = &v; - } - - m_vertices = new_vertices; + for(std::list::reverse_iterator It = m_vertices.rbegin(); It != m_vertices.rend(); It++) + { + CVertex &v = *It; + int type = 0; + Point cp(0.0, 0.0); + if(prev_v) + { + type = -prev_v->m_type; + cp = prev_v->m_c; + } + CVertex new_v(type, v.m_p, cp); + new_vertices.push_back(new_v); + prev_v = &v; + } + + m_vertices = new_vertices; } - + double CCurve::GetArea()const { - double area = 0.0; - Point prev_p = Point(0, 0); - bool prev_p_valid = false; - for(std::list::const_iterator It = m_vertices.begin(); It != m_vertices.end(); It++) - { - const CVertex& vertex = *It; - if(prev_p_valid) - { - area += Span(prev_p, vertex).GetArea(); - } - prev_p = vertex.m_p; - prev_p_valid = true; - } - return area; + double area = 0.0; + Point prev_p = Point(0, 0); + bool prev_p_valid = false; + for(std::list::const_iterator It = m_vertices.begin(); It != m_vertices.end(); It++) + { + const CVertex& vertex = *It; + if(prev_p_valid) + { + area += Span(prev_p, vertex).GetArea(); + } + prev_p = vertex.m_p; + prev_p_valid = true; + } + return area; } - -bool CCurve::IsClosed()const -{ - if(m_vertices.size() == 0)return false; - return m_vertices.front().m_p == m_vertices.back().m_p; -} - + +bool CCurve::IsClosed()const +{ + if(m_vertices.size() == 0)return false; + return m_vertices.front().m_p == m_vertices.back().m_p; +} + void CCurve::ChangeStart(const Point &p) { CCurve new_curve; @@ -645,142 +645,142 @@ void CCurve::ChangeEnd(const Point &p) { Point CCurve::NearestPoint(const Span& p, double *d)const { - double best_dist = 0.0; - Point best_point = Point(0, 0); - bool best_point_valid = false; - Point prev_p = Point(0, 0); - bool prev_p_valid = false; - bool first_span = true; - for(std::list::const_iterator It = m_vertices.begin(); It != m_vertices.end(); It++) - { - const CVertex& vertex = *It; - if(prev_p_valid) - { - double dist; - Point near_point = Span(prev_p, vertex, first_span).NearestPoint(p, &dist); - first_span = false; - if(!best_point_valid || dist < best_dist) - { - best_dist = dist; - best_point = near_point; - best_point_valid = true; - } - } - prev_p = vertex.m_p; - prev_p_valid = true; - } - if(d)*d = best_dist; - return best_point; + double best_dist = 0.0; + Point best_point = Point(0, 0); + bool best_point_valid = false; + Point prev_p = Point(0, 0); + bool prev_p_valid = false; + bool first_span = true; + for(std::list::const_iterator It = m_vertices.begin(); It != m_vertices.end(); It++) + { + const CVertex& vertex = *It; + if(prev_p_valid) + { + double dist; + Point near_point = Span(prev_p, vertex, first_span).NearestPoint(p, &dist); + first_span = false; + if(!best_point_valid || dist < best_dist) + { + best_dist = dist; + best_point = near_point; + best_point_valid = true; + } + } + prev_p = vertex.m_p; + prev_p_valid = true; + } + if(d)*d = best_dist; + return best_point; +} + +static geoff_geometry::Kurve MakeKurve(const CCurve& curve) +{ + geoff_geometry::Kurve k; + for(std::list::const_iterator It = curve.m_vertices.begin(); It != curve.m_vertices.end(); It++) + { + const CVertex& v = *It; + k.Add(geoff_geometry::spVertex(v.m_type, geoff_geometry::Point(v.m_p.x, v.m_p.y), geoff_geometry::Point(v.m_c.x, v.m_c.y))); + } + return k; } - -static geoff_geometry::Kurve MakeKurve(const CCurve& curve) -{ - geoff_geometry::Kurve k; - for(std::list::const_iterator It = curve.m_vertices.begin(); It != curve.m_vertices.end(); It++) - { - const CVertex& v = *It; - k.Add(geoff_geometry::spVertex(v.m_type, geoff_geometry::Point(v.m_p.x, v.m_p.y), geoff_geometry::Point(v.m_c.x, v.m_c.y))); - } - return k; -} - -static CCurve MakeCCurve(const geoff_geometry::Kurve& k) -{ - CCurve c; - int n = k.nSpans(); - for(int i = 0; i<= n; i++) - { - geoff_geometry::spVertex spv; - k.Get(i, spv); - c.append(CVertex(spv.type, Point(spv.p.x, spv.p.y), Point(spv.pc.x, spv.pc.y))); - } - return c; -} - -static geoff_geometry::Span MakeSpan(const Span& span) -{ - return geoff_geometry::Span(span.m_v.m_type, geoff_geometry::Point(span.m_p.x, span.m_p.y), geoff_geometry::Point(span.m_v.m_p.x, span.m_v.m_p.y), geoff_geometry::Point(span.m_v.m_c.x, span.m_v.m_c.y)); -} - -bool CCurve::Offset(double leftwards_value) -{ - // use the kurve code donated by Geoff Hawkesford, to offset the curve as an open curve - // returns true for success, false for failure - bool success = true; - - CCurve save_curve = *this; - - try - { - geoff_geometry::Kurve k = MakeKurve(*this); - geoff_geometry::Kurve kOffset; - int ret = 0; - k.OffsetMethod1(kOffset, fabs(leftwards_value), (leftwards_value > 0) ? 1:-1, 1, ret); - success = (ret == 0); - if(success)*this = MakeCCurve(kOffset); - } - catch(...) - { - success = false; - } - - if(success == false) - { - if(this->IsClosed()) - { - double inwards_offset = leftwards_value; - bool cw = false; - if(this->IsClockwise()) - { - inwards_offset = -inwards_offset; - cw = true; - } - CArea a; - a.append(*this); - a.Offset(inwards_offset); - if(a.m_curves.size() == 1) - { - Span* start_span = NULL; - if(this->m_vertices.size() > 1) - { - std::list::iterator It = m_vertices.begin(); - CVertex &v0 = *It; - It++; - CVertex &v1 = *It; - start_span = new Span(v0.m_p, v1, true); - } - *this = a.m_curves.front(); - if(this->IsClockwise() != cw)this->Reverse(); - if(start_span) - { - Point forward = start_span->GetVector(0.0); - Point left(-forward.y, forward.x); - Point offset_start = start_span->m_p + left * leftwards_value; - this->ChangeStart(this->NearestPoint(offset_start)); - delete start_span; - } - success = true; - } - } - } - - return success; -} - -void CCurve::GetSpans(std::list &spans)const -{ + +static CCurve MakeCCurve(const geoff_geometry::Kurve& k) +{ + CCurve c; + int n = k.nSpans(); + for(int i = 0; i<= n; i++) + { + geoff_geometry::spVertex spv; + k.Get(i, spv); + c.append(CVertex(spv.type, Point(spv.p.x, spv.p.y), Point(spv.pc.x, spv.pc.y))); + } + return c; +} + +static geoff_geometry::Span MakeSpan(const Span& span) +{ + return geoff_geometry::Span(span.m_v.m_type, geoff_geometry::Point(span.m_p.x, span.m_p.y), geoff_geometry::Point(span.m_v.m_p.x, span.m_v.m_p.y), geoff_geometry::Point(span.m_v.m_c.x, span.m_v.m_c.y)); +} + +bool CCurve::Offset(double leftwards_value) +{ + // use the kurve code donated by Geoff Hawkesford, to offset the curve as an open curve + // returns true for success, false for failure + bool success = true; + + CCurve save_curve = *this; + + try + { + geoff_geometry::Kurve k = MakeKurve(*this); + geoff_geometry::Kurve kOffset; + int ret = 0; + k.OffsetMethod1(kOffset, fabs(leftwards_value), (leftwards_value > 0) ? 1:-1, 1, ret); + success = (ret == 0); + if(success)*this = MakeCCurve(kOffset); + } + catch(...) + { + success = false; + } + + if(success == false) + { + if(this->IsClosed()) + { + double inwards_offset = leftwards_value; + bool cw = false; + if(this->IsClockwise()) + { + inwards_offset = -inwards_offset; + cw = true; + } + CArea a; + a.append(*this); + a.Offset(inwards_offset); + if(a.m_curves.size() == 1) + { + Span* start_span = NULL; + if(this->m_vertices.size() > 1) + { + std::list::iterator It = m_vertices.begin(); + CVertex &v0 = *It; + It++; + CVertex &v1 = *It; + start_span = new Span(v0.m_p, v1, true); + } + *this = a.m_curves.front(); + if(this->IsClockwise() != cw)this->Reverse(); + if(start_span) + { + Point forward = start_span->GetVector(0.0); + Point left(-forward.y, forward.x); + Point offset_start = start_span->m_p + left * leftwards_value; + this->ChangeStart(this->NearestPoint(offset_start)); + delete start_span; + } + success = true; + } + } + } + + return success; +} + +void CCurve::GetSpans(std::list &spans)const +{ const Point *prev_p = NULL; - for(std::list::const_iterator It = m_vertices.begin(); It != m_vertices.end(); It++) - { - const CVertex& vertex = *It; + for(std::list::const_iterator It = m_vertices.begin(); It != m_vertices.end(); It++) + { + const CVertex& vertex = *It; if(prev_p) { spans.push_back(Span(*prev_p, vertex)); - } + } prev_p = &(vertex.m_p); - } -} - + } +} + void CCurve::OffsetForward(double forwards_value, bool refit_arcs) { // for drag-knife compensation @@ -839,103 +839,103 @@ void CCurve::OffsetForward(double forwards_value, bool refit_arcs) else UnFitArcs(); // convert those little arcs added to lines } - -double CCurve::Perim()const -{ + +double CCurve::Perim()const +{ const Point *prev_p = NULL; - double perim = 0.0; - for(std::list::const_iterator It = m_vertices.begin(); It != m_vertices.end(); It++) - { - const CVertex& vertex = *It; + double perim = 0.0; + for(std::list::const_iterator It = m_vertices.begin(); It != m_vertices.end(); It++) + { + const CVertex& vertex = *It; if(prev_p) { Span span(*prev_p, vertex); perim += span.Length(); - } + } prev_p = &(vertex.m_p); - } - - return perim; -} - -Point CCurve::PerimToPoint(double perim)const -{ - if(m_vertices.size() == 0)return Point(0, 0); - + } + + return perim; +} + +Point CCurve::PerimToPoint(double perim)const +{ + if(m_vertices.size() == 0)return Point(0, 0); + const Point *prev_p = NULL; - double kperim = 0.0; - for(std::list::const_iterator It = m_vertices.begin(); It != m_vertices.end(); It++) - { - const CVertex& vertex = *It; + double kperim = 0.0; + for(std::list::const_iterator It = m_vertices.begin(); It != m_vertices.end(); It++) + { + const CVertex& vertex = *It; if(prev_p) { Span span(*prev_p, vertex); double length = span.Length(); - if(perim < kperim + length) - { - Point p = span.MidPerim(perim - kperim); - return p; - } - kperim += length; - } + if(perim < kperim + length) + { + Point p = span.MidPerim(perim - kperim); + return p; + } + kperim += length; + } prev_p = &(vertex.m_p); - } - - return m_vertices.back().m_p; -} - -double CCurve::PointToPerim(const Point& p)const -{ - double best_dist = 0.0; - double perim_at_best_dist = 0.0; - Point best_point = Point(0, 0); - bool best_dist_found = false; - - double perim = 0.0; - + } + + return m_vertices.back().m_p; +} + +double CCurve::PointToPerim(const Point& p)const +{ + double best_dist = 0.0; + double perim_at_best_dist = 0.0; + //Point best_point = Point(0, 0); + bool best_dist_found = false; + + double perim = 0.0; + const Point *prev_p = NULL; - bool first_span = true; - for(std::list::const_iterator It = m_vertices.begin(); It != m_vertices.end(); It++) - { - const CVertex& vertex = *It; + bool first_span = true; + for(std::list::const_iterator It = m_vertices.begin(); It != m_vertices.end(); It++) + { + const CVertex& vertex = *It; if(prev_p) { Span span(*prev_p, vertex, first_span); - Point near_point = span.NearestPoint(p); - first_span = false; - double dist = near_point.dist(p); - if(!best_dist_found || dist < best_dist) - { - best_dist = dist; - Span span_to_point(*prev_p, CVertex(span.m_v.m_type, near_point, span.m_v.m_c)); - perim_at_best_dist = perim + span_to_point.Length(); - best_dist_found = true; - } - perim += span.Length(); - } + Point near_point = span.NearestPoint(p); + first_span = false; + double dist = near_point.dist(p); + if(!best_dist_found || dist < best_dist) + { + best_dist = dist; + Span span_to_point(*prev_p, CVertex(span.m_v.m_type, near_point, span.m_v.m_c)); + perim_at_best_dist = perim + span_to_point.Length(); + best_dist_found = true; + } + perim += span.Length(); + } prev_p = &(vertex.m_p); - } - return perim_at_best_dist; -} - -void CCurve::operator+=(const CCurve& curve) -{ - for(std::list::const_iterator It = curve.m_vertices.begin(); It != curve.m_vertices.end(); It++) - { - const CVertex &vt = *It; - if(It == curve.m_vertices.begin()) - { - if((m_vertices.size() == 0) || (It->m_p != m_vertices.back().m_p)) - { - m_vertices.push_back(CVertex(It->m_p)); - } - } - else - { - m_vertices.push_back(vt); - } - } -} + } + return perim_at_best_dist; +} + +void CCurve::operator+=(const CCurve& curve) +{ + for(std::list::const_iterator It = curve.m_vertices.begin(); It != curve.m_vertices.end(); It++) + { + const CVertex &vt = *It; + if(It == curve.m_vertices.begin()) + { + if((m_vertices.size() == 0) || (It->m_p != m_vertices.back().m_p)) + { + m_vertices.push_back(CVertex(It->m_p)); + } + } + else + { + m_vertices.push_back(vt); + } + } +} void CCurve::CurveIntersections(const CCurve& c, std::list &pts)const { @@ -943,9 +943,9 @@ void CCurve::CurveIntersections(const CCurve& c, std::list &pts)const a.append(*this); a.CurveIntersections(c, pts); } - -void CCurve::SpanIntersections(const Span& s, std::list &pts)const -{ + +void CCurve::SpanIntersections(const Span& s, std::list &pts)const +{ std::list spans; GetSpans(spans); for(std::list::iterator It = spans.begin(); It != spans.end(); It++) @@ -966,44 +966,44 @@ void CCurve::SpanIntersections(const Span& s, std::list &pts)const } } } -} - -const Point Span::null_point = Point(0, 0); -const CVertex Span::null_vertex = CVertex(Point(0, 0)); - +} + +const Point Span::null_point = Point(0, 0); +const CVertex Span::null_vertex = CVertex(Point(0, 0)); + Span::Span():m_start_span(false), m_p(null_point), m_v(null_vertex){} - -Point Span::NearestPointNotOnSpan(const Point& p)const -{ - if(m_v.m_type == 0) - { - Point Vs = (m_v.m_p - m_p); - Vs.normalize(); - double dp = (p - m_p) * Vs; - return (Vs * dp) + m_p; - } - else - { - double radius = m_p.dist(m_v.m_c); - double r = p.dist(m_v.m_c); - if(r < Point::tolerance)return m_p; - Point vc = (m_v.m_c - p); - return p + vc * ((r - radius) / r); - } -} - -Point Span::NearestPoint(const Point& p)const -{ - Point np = NearestPointNotOnSpan(p); - double t = Parameter(np); - if(t >= 0.0 && t <= 1.0)return np; - - double d1 = p.dist(this->m_p); - double d2 = p.dist(this->m_v.m_p); - - if(d1 < d2)return this->m_p; - else return m_v.m_p; -} + +Point Span::NearestPointNotOnSpan(const Point& p)const +{ + if(m_v.m_type == 0) + { + Point Vs = (m_v.m_p - m_p); + Vs.normalize(); + double dp = (p - m_p) * Vs; + return (Vs * dp) + m_p; + } + else + { + double radius = m_p.dist(m_v.m_c); + double r = p.dist(m_v.m_c); + if(r < Point::tolerance)return m_p; + Point vc = (m_v.m_c - p); + return p + vc * ((r - radius) / r); + } +} + +Point Span::NearestPoint(const Point& p)const +{ + Point np = NearestPointNotOnSpan(p); + double t = Parameter(np); + if(t >= 0.0 && t <= 1.0)return np; + + double d1 = p.dist(this->m_p); + double d2 = p.dist(this->m_v.m_p); + + if(d1 < d2)return this->m_p; + else return m_v.m_p; +} Point Span::MidPerim(double d)const { /// returns a point which is 0-d along span @@ -1074,36 +1074,36 @@ Point Span::NearestPoint(const Span& p, double *d)const if(d)*d = best_dist; return best_point; } - -static int GetQuadrant(const Point& v){ - // 0 = [+,+], 1 = [-,+], 2 = [-,-], 3 = [+,-] - if(v.x > 0) - { - if(v.y > 0) - return 0; - return 3; - } - if(v.y > 0) - return 1; - return 2; -} - -static Point QuadrantEndPoint(int i) -{ - if(i >3)i-=4; - switch(i) - { - case 0: - return Point(0.0,1.0); - case 1: - return Point(-1.0,0.0); - case 2: - return Point(0.0,-1.0); - default: - return Point(1.0,0.0); - } -} - + +static int GetQuadrant(const Point& v){ + // 0 = [+,+], 1 = [-,+], 2 = [-,-], 3 = [+,-] + if(v.x > 0) + { + if(v.y > 0) + return 0; + return 3; + } + if(v.y > 0) + return 1; + return 2; +} + +static Point QuadrantEndPoint(int i) +{ + if(i >3)i-=4; + switch(i) + { + case 0: + return Point(0.0,1.0); + case 1: + return Point(-1.0,0.0); + case 2: + return Point(0.0,-1.0); + default: + return Point(1.0,0.0); + } +} + void Span::GetBox(CBox2D &box) { box.Insert(m_p); @@ -1133,8 +1133,8 @@ void Span::GetBox(CBox2D &box) box.Insert(m_v.m_c + QuadrantEndPoint(i) * rad); } } -} - +} + double IncludedAngle(const Point& v0, const Point& v1, int dir) { // returns the absolute included angle between 2 vectors in the direction of dir ( 1=acw -1=cw) double inc_ang = v0 * v1; @@ -1149,9 +1149,9 @@ double IncludedAngle(const Point& v0, const Point& v1, int dir) { } return dir * inc_ang; } - -double Span::IncludedAngle()const -{ + +double Span::IncludedAngle()const +{ if(m_v.m_type) { Point vs = ~(m_p - m_v.m_c); @@ -1168,14 +1168,14 @@ double Span::IncludedAngle()const } return 0.0; -} - +} + double Span::GetArea()const { if(m_v.m_type) { double angle = IncludedAngle(); - double radius = m_p.dist(m_v.m_c); + double radius = m_p.dist(m_v.m_c); return ( 0.5 * ((m_v.m_c.x - m_p.x) * (m_v.m_c.y + m_p.y) - (m_v.m_c.x - m_v.m_p.x) * (m_v.m_c.y + m_v.m_p.y) - angle * radius * radius)); } @@ -1268,4 +1268,4 @@ void tangential_arc(const Point &p0, const Point &p1, const Point &v0, Point &c, geoff_geometry::Point gc; geoff_geometry::tangential_arc(gp0, gp1, gv0, gc, dir); c = Point(gc.x, gc.y); -} +} diff --git a/src/Mod/Path/libarea/PythonStuff.cpp b/src/Mod/Path/libarea/PythonStuff.cpp index 12d99bec8c35..4a04c2187ec9 100644 --- a/src/Mod/Path/libarea/PythonStuff.cpp +++ b/src/Mod/Path/libarea/PythonStuff.cpp @@ -63,7 +63,7 @@ boost::python::tuple transformed_point(const geoff_geometry::Matrix &matrix, dou static void print_curve(const CCurve& c) { std::size_t nvertices = c.m_vertices.size(); - printf("number of vertices = %d\n", nvertices); + printf("number of vertices = %lu\n", nvertices); int i = 0; for(std::list::const_iterator It = c.m_vertices.begin(); It != c.m_vertices.end(); It++, i++) { diff --git a/src/Mod/Path/libarea/kurve/Matrix.cpp b/src/Mod/Path/libarea/kurve/Matrix.cpp index 0603d22882d0..ef033d2d4592 100644 --- a/src/Mod/Path/libarea/kurve/Matrix.cpp +++ b/src/Mod/Path/libarea/kurve/Matrix.cpp @@ -598,7 +598,7 @@ namespace geoff_geometry { void Plane::Mirrored(Matrix* tmMirrored) { // calculates a mirror transformation that mirrors 2d about plane - Point3d p1 = this->Near(Point3d(0.,0.,0.)); + //Point3d p1 = this->Near(Point3d(0.,0.,0.)); if(tmMirrored->m_unit == false) tmMirrored->Unit(); double nx = this->normal.getx();