suzanne.soy/FreeCAD
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Updated libarea with changes from Heeks/libarea

Browse Source
This commit is contained in:
sliptonic 2016-06-09 10:02:42 -05:00
parent dff173cd1f
commit a02d704d0a
22 changed files with 2028 additions and 543 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

31
src/Mod/Path/libarea/Arc.cpp
View File

@ -1,32 +1,7 @@
// Arc.cpp // Arc.cpp
/*============================== // Copyright 2011, Dan Heeks
Copyright (c) 2011-2015 Dan Heeks // This program is released under the BSD license. See the file COPYING for details.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions 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.
3. The name of the author may not be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
==============================*/
#include "Arc.h" #include "Arc.h"
#include "Curve.h" #include "Curve.h"
@ -91,7 +66,7 @@ Point CArc::MidParam(double param)const {
//segments - number of segments per full revolution! //segments - number of segments per full revolution!
//d_angle - determines the direction and the ammount of the arc to draw //d_angle - determines the direction and the ammount of the arc to draw
void CArc::GetSegments(void(*callbackfunc)(const double *p), double pixels_per_mm, bool want_start_point)const void CArc::GetSegments(void(*callbackfunc)(const double *p), double pixels_per_mm)const
{ {
if(m_s == m_e) if(m_s == m_e)
return; return;

29
src/Mod/Path/libarea/Arc.h
View File

@ -1,29 +1,6 @@
// Arc.h // Arc.h
/*============================== // Copyright 2011, Dan Heeks
Copyright (c) 2011-2015 Dan Heeks // This program is released under the BSD license. See the file COPYING for details.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions 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.
3. The name of the author may not be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
==============================*/
#pragma once #pragma once
@ -44,5 +21,5 @@ public:
double IncludedAngle()const; // always > 0 double IncludedAngle()const; // always > 0
bool AlmostALine()const; bool AlmostALine()const;
Point MidParam(double param)const; Point MidParam(double param)const;
void GetSegments(void(*callbackfunc)(const double *p), double pixels_per_mm, bool want_start_point = true)const; void GetSegments(void(*callbackfunc)(const double *p), double pixels_per_mm)const;
}; };

34
src/Mod/Path/libarea/Area.cpp
View File

@ -1,31 +1,7 @@
// Area.cpp // Area.cpp
/*============================== // Copyright 2011, Dan Heeks
Copyright (c) 2011-2015 Dan Heeks // This program is released under the BSD license. See the file COPYING for details.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions 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.
3. The name of the author may not be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
==============================*/
#include "Area.h" #include "Area.h"
#include "AreaOrderer.h" #include "AreaOrderer.h"
@ -219,13 +195,13 @@ static void make_zig_curve(const CCurve& input_curve, double y0, double y)
// find a high point to start looking from // find a high point to start looking from
Point top_left; Point top_left;
int top_left_index; int top_left_index = 0;
bool top_left_found = false; bool top_left_found = false;
Point top_right; Point top_right;
int top_right_index; int top_right_index = 0;
bool top_right_found = false; bool top_right_found = false;
Point bottom_left; Point bottom_left;
int bottom_left_index; int bottom_left_index = 0;
bool bottom_left_found = false; bool bottom_left_found = false;
int i =0; int i =0;

32
src/Mod/Path/libarea/Area.h
View File

@ -1,30 +1,7 @@
// Area.h // Area.h
/*============================== // Copyright 2011, Dan Heeks
Copyright (c) 2011-2015 Dan Heeks // This program is released under the BSD license. See the file COPYING for details.
// repository now moved to github
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions 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.
3. The name of the author may not be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
==============================*/
#ifndef AREA_HEADER #ifndef AREA_HEADER
#define AREA_HEADER #define AREA_HEADER
@ -78,11 +55,12 @@ public:
void Subtract(const CArea& a2); void Subtract(const CArea& a2);
void Intersect(const CArea& a2); void Intersect(const CArea& a2);
void Union(const CArea& a2); void Union(const CArea& a2);
static CArea UniteCurves(std::list<CCurve> &curves);
void Xor(const CArea& a2); void Xor(const CArea& a2);
void Offset(double inwards_value); void Offset(double inwards_value);
void Thicken(double value); void Thicken(double value);
void FitArcs(); void FitArcs();
unsigned int num_curves(){return static_cast<unsigned int>(m_curves.size());} unsigned int num_curves(){return m_curves.size();}
Point NearestPoint(const Point& p)const; Point NearestPoint(const Point& p)const;
void GetBox(CBox2D &box); void GetBox(CBox2D &box);
void Reorder(); void Reorder();

107
src/Mod/Path/libarea/AreaClipper.cpp
View File

@ -1,32 +1,7 @@
// AreaClipper.cpp // AreaClipper.cpp
// implements CArea methods using Angus Johnson's "Clipper" // implements CArea methods using Angus Johnson's "Clipper"
/*==============================
Copyright (c) 2011-2015 Dan Heeks
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions 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.
3. The name of the author may not be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
==============================*/
#include "Area.h" #include "Area.h"
#include "clipper.hpp" #include "clipper.hpp"
using namespace ClipperLib; using namespace ClipperLib;
@ -134,34 +109,6 @@ static void AddVertex(const CVertex& vertex, const CVertex* prev_vertex)
} }
} }
#if 0
static bool IsPolygonClockwise(const TPolygon& p)
{
#if 1
double area = 0.0;
std::size_t s = p.size();
for(std::size_t i = 0; i<s; i++)
{
std::size_t im1;
if (i == 0)
im1 = s - 1;
else
im1 = i - 1;
DoubleAreaPoint pt0(p[im1]);
DoubleAreaPoint pt1(p[i]);
area += 0.5 * (pt1.X - pt0.X) * (pt0.Y + pt1.Y);
}
return area > 0.0;
#else
return IsClockwise(p);
#endif
}
#endif
static void MakeLoop(const DoubleAreaPoint &pt0, const DoubleAreaPoint &pt1, const DoubleAreaPoint &pt2, double radius) static void MakeLoop(const DoubleAreaPoint &pt0, const DoubleAreaPoint &pt1, const DoubleAreaPoint &pt2, double radius)
{ {
Point p0(pt0.X, pt0.Y); Point p0(pt0.X, pt0.Y);
@ -222,7 +169,7 @@ static void OffsetWithLoops(const TPolyPolygon &pp, TPolyPolygon &pp_new, double
{ {
if(reverse) if(reverse)
{ {
for(std::size_t j = p.size()-1; j > 1; j--)MakeLoop(p[j], p[j-1], p[j-2], radius); for(unsigned int j = p.size()-1; j > 1; j--)MakeLoop(p[j], p[j-1], p[j-2], radius);
MakeLoop(p[1], p[0], p[p.size()-1], radius); MakeLoop(p[1], p[0], p[p.size()-1], radius);
MakeLoop(p[0], p[p.size()-1], p[p.size()-2], radius); MakeLoop(p[0], p[p.size()-1], p[p.size()-2], radius);
} }
@ -266,7 +213,7 @@ static void OffsetWithLoops(const TPolyPolygon &pp, TPolyPolygon &pp_new, double
const TPolygon& p = copy[i]; const TPolygon& p = copy[i];
TPolygon p_new; TPolygon p_new;
p_new.resize(p.size()); p_new.resize(p.size());
std::size_t size_minus_one = p.size() - 1; int size_minus_one = p.size() - 1;
for(unsigned int j = 0; j < p.size(); j++)p_new[j] = p[size_minus_one - j]; for(unsigned int j = 0; j < p.size(); j++)p_new[j] = p[size_minus_one - j];
pp_new[i] = p_new; pp_new[i] = p_new;
} }
@ -343,7 +290,7 @@ static void OffsetSpansWithObrounds(const CArea& area, TPolyPolygon &pp_new, dou
const TPolygon& p = copy[i]; const TPolygon& p = copy[i];
TPolygon p_new; TPolygon p_new;
p_new.resize(p.size()); p_new.resize(p.size());
std::size_t size_minus_one = p.size() - 1; int size_minus_one = p.size() - 1;
for(unsigned int j = 0; j < p.size(); j++)p_new[j] = p[size_minus_one - j]; for(unsigned int j = 0; j < p.size(); j++)p_new[j] = p[size_minus_one - j];
pp_new[i] = p_new; pp_new[i] = p_new;
} }
@ -368,7 +315,7 @@ static void MakePolyPoly( const CArea& area, TPolyPolygon &pp, bool reverse = tr
p.resize(pts_for_AddVertex.size()); p.resize(pts_for_AddVertex.size());
if(reverse) if(reverse)
{ {
std::size_t i = pts_for_AddVertex.size() - 1;// clipper wants them the opposite way to CArea unsigned int i = pts_for_AddVertex.size() - 1;// clipper wants them the opposite way to CArea
for(std::list<DoubleAreaPoint>::iterator It = pts_for_AddVertex.begin(); It != pts_for_AddVertex.end(); It++, i--) for(std::list<DoubleAreaPoint>::iterator It = pts_for_AddVertex.begin(); It != pts_for_AddVertex.end(); It++, i--)
{ {
p[i] = It->int_point(); p[i] = It->int_point();
@ -387,6 +334,27 @@ static void MakePolyPoly( const CArea& area, TPolyPolygon &pp, bool reverse = tr
} }
} }
static void MakePoly(const CCurve& curve, TPolygon &p)
{
pts_for_AddVertex.clear();
const CVertex* prev_vertex = NULL;
for (std::list<CVertex>::const_iterator It2 = curve.m_vertices.begin(); It2 != curve.m_vertices.end(); It2++)
{
const CVertex& vertex = *It2;
if (prev_vertex)AddVertex(vertex, prev_vertex);
prev_vertex = &vertex;
}
p.resize(pts_for_AddVertex.size());
{
unsigned int i = 0;
for (std::list<DoubleAreaPoint>::iterator It = pts_for_AddVertex.begin(); It != pts_for_AddVertex.end(); It++, i++)
{
p[i] = It->int_point();
}
}
}
static void SetFromResult( CCurve& curve, const TPolygon& p, bool reverse = true ) static void SetFromResult( CCurve& curve, const TPolygon& p, bool reverse = true )
{ {
for(unsigned int j = 0; j < p.size(); j++) for(unsigned int j = 0; j < p.size(); j++)
@ -458,6 +426,29 @@ void CArea::Union(const CArea& a2)
SetFromResult(*this, solution); SetFromResult(*this, solution);
} }
// static
CArea CArea::UniteCurves(std::list<CCurve> &curves)
{
Clipper c;
TPolyPolygon pp;
for (std::list<CCurve>::iterator It = curves.begin(); It != curves.end(); It++)
{
CCurve &curve = *It;
TPolygon p;
MakePoly(curve, p);
pp.push_back(p);
}
c.AddPaths(pp, ptSubject, true);
TPolyPolygon solution;
c.Execute(ctUnion, solution, pftNonZero, pftNonZero);
CArea area;
SetFromResult(area, solution);
return area;
}
void CArea::Xor(const CArea& a2) void CArea::Xor(const CArea& a2)
{ {
Clipper c; Clipper c;

31
src/Mod/Path/libarea/AreaDxf.cpp Normal file
View File

@ -0,0 +1,31 @@
// AreaDxf.cpp
// Copyright (c) 2011, Dan Heeks
// This program is released under the BSD license. See the file COPYING for details.
#include "AreaDxf.h"
#include "Area.h"
AreaDxfRead::AreaDxfRead(CArea* area, const char* filepath):CDxfRead(filepath), m_area(area){}
void AreaDxfRead::StartCurveIfNecessary(const double* s)
{
Point ps(s);
if((m_area->m_curves.size() == 0) || (m_area->m_curves.back().m_vertices.size() == 0) || (m_area->m_curves.back().m_vertices.back().m_p != ps))
{
// start a new curve
m_area->m_curves.push_back(CCurve());
m_area->m_curves.back().m_vertices.push_back(ps);
}
}
void AreaDxfRead::OnReadLine(const double* s, const double* e)
{
StartCurveIfNecessary(s);
m_area->m_curves.back().m_vertices.push_back(Point(e));
}
void AreaDxfRead::OnReadArc(const double* s, const double* e, const double* c, bool dir)
{
StartCurveIfNecessary(s);
m_area->m_curves.back().m_vertices.push_back(CVertex(dir?1:0, Point(e), Point(c)));
}

23
src/Mod/Path/libarea/AreaDxf.h Normal file
View File

@ -0,0 +1,23 @@
// AreaDxf.h
// Copyright (c) 2011, Dan Heeks
// This program is released under the BSD license. See the file COPYING for details.
#pragma once
#include "dxf.h"
class CSketch;
class CArea;
class CCurve;
class AreaDxfRead : public CDxfRead{
void StartCurveIfNecessary(const double* s);
public:
CArea* m_area;
AreaDxfRead(CArea* area, const char* filepath);
// AreaDxfRead's virtual functions
void OnReadLine(const double* s, const double* e);
void OnReadArc(const double* s, const double* e, const double* c, bool dir);
};

62
src/Mod/Path/libarea/AreaPocket.cpp
View File

@ -1,33 +1,9 @@
// AreaPocket.cpp // AreaPocket.cpp
// Copyright 2011, Dan Heeks
// This program is released under the BSD license. See the file COPYING for details.
// implements CArea::MakeOnePocketCurve // implements CArea::MakeOnePocketCurve
/*==============================
Copyright (c) 2011-2015 Dan Heeks
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions 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.
3. The name of the author may not be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
==============================*/
#include "Area.h" #include "Area.h"
#include <map> #include <map>
@ -425,38 +401,6 @@ void recur(std::list<CArea> &arealist, const CArea& a1, const CAreaPocketParams
} }
} }
#if 0
static CArea make_obround(const Point& p0, const Point& p1, double radius)
{
Point dir = p1 - p0;
dir.normalize();
Point right(dir.y, -dir.x);
CArea obround;
CCurve c;
if(fabs(radius) < 0.0000001)radius = (radius > 0.0) ? 0.002 : (-0.002);
Point vt0 = p0 + right * radius;
Point vt1 = p1 + right * radius;
Point vt2 = p1 - right * radius;
Point vt3 = p0 - right * radius;
c.append(vt0);
c.append(vt1);
c.append(CVertex(1, vt2, p1));
c.append(vt3);
c.append(CVertex(1, vt0, p0));
obround.append(c);
return obround;
}
#endif
#if 0
static bool feed_possible(const CArea &area_for_feed_possible, const Point& p0, const Point& p1, double tool_radius)
{
CArea obround = make_obround(p0, p1, tool_radius);
obround.Subtract(area_for_feed_possible);
return obround.m_curves.empty();
}
#endif
void MarkOverlappingOffsetIslands(std::list<IslandAndOffset> &offset_islands) void MarkOverlappingOffsetIslands(std::list<IslandAndOffset> &offset_islands)
{ {
for(std::list<IslandAndOffset>::iterator It1 = offset_islands.begin(); It1 != offset_islands.end(); It1++) for(std::list<IslandAndOffset>::iterator It1 = offset_islands.begin(); It1 != offset_islands.end(); It1++)

2
src/Mod/Path/libarea/CMakeLists.txt
View File

@ -25,10 +25,12 @@ endif()
set(AREA_SRC_COMMON set(AREA_SRC_COMMON
Arc.cpp Arc.cpp
Area.cpp Area.cpp
AreaDxf.cpp
AreaOrderer.cpp AreaOrderer.cpp
AreaPocket.cpp AreaPocket.cpp
Circle.cpp Circle.cpp
Curve.cpp Curve.cpp
dxf.cpp
kurve/Construction.cpp kurve/Construction.cpp
kurve/Finite.cpp kurve/Finite.cpp
kurve/kurve.cpp kurve/kurve.cpp

44
src/Mod/Path/libarea/Curve.cpp
View File

@ -1,30 +1,6 @@
// Curve.cpp // Curve.cpp
// Copyright 2011, Dan Heeks
/*============================== // This program is released under the BSD license. See the file COPYING for details.
Copyright (c) 2011-2015 Dan Heeks
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions 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.
3. The name of the author may not be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
==============================*/
#include "Curve.h" #include "Curve.h"
#include "Circle.h" #include "Circle.h"
@ -86,7 +62,7 @@ bool CCurve::CheckForArc(const CVertex& prev_vt, std::list<const CVertex*>& migh
if(might_be_an_arc.size() < 2)return false; if(might_be_an_arc.size() < 2)return false;
// find middle point // find middle point
int num = static_cast<int>(might_be_an_arc.size()); int num = might_be_an_arc.size();
int i = 0; int i = 0;
const CVertex* mid_vt = NULL; const CVertex* mid_vt = NULL;
int mid_i = (num-1)/2; int mid_i = (num-1)/2;
@ -217,7 +193,13 @@ void CCurve::FitArcs()
{ {
CVertex& vt = *It; CVertex& vt = *It;
if(vt.m_type || i == 0) 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); new_vertices.push_back(vt);
}
else else
{ {
might_be_an_arc.push_back(&vt); might_be_an_arc.push_back(&vt);
@ -720,13 +702,6 @@ 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)); 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));
} }
#if 0
static Span MakeCSpan(const geoff_geometry::Span &sp)
{
return Span(Point(sp.p0.x, sp.p0.y), CVertex(sp.dir, Point(sp.p1.x, sp.p1.y), Point(sp.pc.x, sp.pc.y)));
}
#endif
bool CCurve::Offset(double leftwards_value) bool CCurve::Offset(double leftwards_value)
{ {
// use the kurve code donated by Geoff Hawkesford, to offset the curve as an open curve // use the kurve code donated by Geoff Hawkesford, to offset the curve as an open curve
@ -913,6 +888,7 @@ double CCurve::PointToPerim(const Point& p)const
{ {
double best_dist = 0.0; double best_dist = 0.0;
double perim_at_best_dist = 0.0; double perim_at_best_dist = 0.0;
Point best_point = Point(0, 0);
bool best_dist_found = false; bool best_dist_found = false;
double perim = 0.0; double perim = 0.0;

58
src/Mod/Path/libarea/PythonStuff.cpp
View File

@ -1,45 +1,14 @@
// PythonStuff.cpp // PythonStuff.cpp
// Copyright 2011, Dan Heeks
/*============================== // This program is released under the BSD license. See the file COPYING for details.
Copyright (c) 2011-2015 Dan Heeks
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions 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.
3. The name of the author may not be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
==============================*/
#include "PythonStuff.h" #include "PythonStuff.h"
#include "Area.h" #include "Area.h"
#include "Point.h" #include "Point.h"
#include "AreaDxf.h"
#include "kurve/geometry.h" #include "kurve/geometry.h"
#if defined (_POSIX_C_SOURCE)
# undef _POSIX_C_SOURCE
#endif
#if defined (_XOPEN_SOURCE)
# undef _XOPEN_SOURCE
#endif
#if _DEBUG #if _DEBUG
#undef _DEBUG #undef _DEBUG
#include <Python.h> #include <Python.h>
@ -51,9 +20,6 @@ THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#ifdef __GNUG__ #ifdef __GNUG__
#pragma implementation #pragma implementation
#endif #endif
#ifdef _MSC_VER
#pragma warning(disable : 4244)
#endif
#include <boost/progress.hpp> #include <boost/progress.hpp>
#include <boost/timer.hpp> #include <boost/timer.hpp>
@ -96,8 +62,8 @@ boost::python::tuple transformed_point(const geoff_geometry::Matrix &matrix, dou
static void print_curve(const CCurve& c) static void print_curve(const CCurve& c)
{ {
std::size_t nvertices = c.m_vertices.size(); unsigned int nvertices = c.m_vertices.size();
printf("number of vertices = %lu\n", nvertices); printf("number of vertices = %d\n", nvertices);
int i = 0; int i = 0;
for(std::list<CVertex>::const_iterator It = c.m_vertices.begin(); It != c.m_vertices.end(); It++, i++) for(std::list<CVertex>::const_iterator It = c.m_vertices.begin(); It != c.m_vertices.end(); It++, i++)
{ {
@ -119,7 +85,7 @@ static void print_area(const CArea &a)
static unsigned int num_vertices(const CCurve& curve) static unsigned int num_vertices(const CCurve& curve)
{ {
return static_cast<int>(curve.m_vertices.size()); return curve.m_vertices.size();
} }
static CVertex FirstVertex(const CCurve& curve) static CVertex FirstVertex(const CCurve& curve)
@ -147,6 +113,13 @@ static bool holes_linked()
return CArea::HolesLinked(); return CArea::HolesLinked();
} }
static CArea AreaFromDxf(const char* filepath)
{
CArea area;
AreaDxfRead dxf(&area, filepath);
dxf.DoRead();
return area;
}
static void append_point(CCurve& c, const Point& p) static void append_point(CCurve& c, const Point& p)
{ {
@ -187,6 +160,10 @@ boost::python::list SplitArea(const CArea& a)
return alist; return alist;
} }
void dxfArea(CArea& area, const char* str)
{
area = CArea();
}
boost::python::list getCurveSpans(const CCurve& c) boost::python::list getCurveSpans(const CCurve& c)
{ {
@ -427,5 +404,6 @@ BOOST_PYTHON_MODULE(area) {
bp::def("set_units", set_units); bp::def("set_units", set_units);
bp::def("get_units", get_units); bp::def("get_units", get_units);
bp::def("holes_linked", holes_linked); bp::def("holes_linked", holes_linked);
bp::def("AreaFromDxf", AreaFromDxf);
bp::def("TangentialArc", TangentialArc); bp::def("TangentialArc", TangentialArc);
} }

28
src/Mod/Path/libarea/PythonStuff.h
View File

@ -1,31 +1,7 @@
// PythonStuff.h // PythonStuff.h
/*============================== // Copyright 2011, Dan Heeks
Copyright (c) 2011-2015 Dan Heeks // This program is released under the BSD license. See the file COPYING for details.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions 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.
3. The name of the author may not be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
==============================*/
extern void Message(const char*); extern void Message(const char*);

16
src/Mod/Path/libarea/clipper.cpp
View File

@ -1440,7 +1440,7 @@ bool Clipper::ExecuteInternal()
ProcessHorizontals(false); ProcessHorizontals(false);
if (m_Scanbeam.empty()) break; if (m_Scanbeam.empty()) break;
cInt topY = PopScanbeam(); cInt topY = PopScanbeam();
succeeded = ProcessIntersections(botY, topY); succeeded = ProcessIntersections(topY);
if (!succeeded) break; if (!succeeded) break;
ProcessEdgesAtTopOfScanbeam(topY); ProcessEdgesAtTopOfScanbeam(topY);
botY = topY; botY = topY;
@ -2705,11 +2705,11 @@ void Clipper::UpdateEdgeIntoAEL(TEdge *&e)
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
bool Clipper::ProcessIntersections(const cInt botY, const cInt topY) bool Clipper::ProcessIntersections(const cInt topY)
{ {
if( !m_ActiveEdges ) return true; if( !m_ActiveEdges ) return true;
try { try {
BuildIntersectList(botY, topY); BuildIntersectList(topY);
size_t IlSize = m_IntersectList.size(); size_t IlSize = m_IntersectList.size();
if (IlSize == 0) return true; if (IlSize == 0) return true;
if (IlSize == 1 || FixupIntersectionOrder()) ProcessIntersectList(); if (IlSize == 1 || FixupIntersectionOrder()) ProcessIntersectList();
@ -2734,7 +2734,7 @@ void Clipper::DisposeIntersectNodes()
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void Clipper::BuildIntersectList(const cInt botY, const cInt topY) void Clipper::BuildIntersectList(const cInt topY)
{ {
if ( !m_ActiveEdges ) return; if ( !m_ActiveEdges ) return;
@ -4161,10 +4161,10 @@ double DistanceFromLineSqrd(
const IntPoint& pt, const IntPoint& ln1, const IntPoint& ln2) const IntPoint& pt, const IntPoint& ln1, const IntPoint& ln2)
{ {
//The equation of a line in general form (Ax + By + C = 0) //The equation of a line in general form (Ax + By + C = 0)
//given 2 points (x¹,y¹) & (x²,y²) is ... //given 2 points (x¹,y¹) & (x²,y²) is ...
//(y¹ - y²)x + (x² - x¹)y + (y² - y¹)x¹ - (x² - x¹)y¹ = 0 //(y¹ - y²)x + (x² - x¹)y + (y² - y¹)x¹ - (x² - x¹)y¹ = 0
//A = (y¹ - y²); B = (x² - x¹); C = (y² - y¹)x¹ - (x² - x¹)y¹ //A = (y¹ - y²); B = (x² - x¹); C = (y² - y¹)x¹ - (x² - x¹)y¹
//perpendicular distance of point (x³,y³) = (Ax³ + By³ + C)/Sqrt(A² + B²) //perpendicular distance of point (x³,y³) = (Ax³ + By³ + C)/Sqrt(A² + B²)
//see http://en.wikipedia.org/wiki/Perpendicular_distance //see http://en.wikipedia.org/wiki/Perpendicular_distance
double A = double(ln1.Y - ln2.Y); double A = double(ln1.Y - ln2.Y);
double B = double(ln2.X - ln1.X); double B = double(ln2.X - ln1.X);

4
src/Mod/Path/libarea/clipper.hpp
View File

@ -318,8 +318,8 @@ private:
OutPt* AddOutPt(TEdge *e, const IntPoint &pt); OutPt* AddOutPt(TEdge *e, const IntPoint &pt);
void DisposeAllOutRecs(); void DisposeAllOutRecs();
void DisposeOutRec(PolyOutList::size_type index); void DisposeOutRec(PolyOutList::size_type index);
bool ProcessIntersections(const cInt botY, const cInt topY); bool ProcessIntersections(const cInt topY);
void BuildIntersectList(const cInt botY, const cInt topY); void BuildIntersectList(const cInt topY);
void ProcessIntersectList(); void ProcessIntersectList();
void ProcessEdgesAtTopOfScanbeam(const cInt topY); void ProcessEdgesAtTopOfScanbeam(const cInt topY);
void BuildResult(Paths& polys); void BuildResult(Paths& polys);

1634
src/Mod/Path/libarea/dxf.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

158
src/Mod/Path/libarea/dxf.h Normal file
View File

@ -0,0 +1,158 @@
// dxf.h
// Copyright (c) 2009, Dan Heeks
// This program is released under the BSD license. See the file COPYING for details.
#pragma once
#include <algorithm>
#include <list>
#include <vector>
#include <map>
#include <set>
#include <fstream>
#include <sstream>
#include <iostream>
#include <stdio.h>
#include <string.h>
#include <math.h>
//Following is required to be defined on Ubuntu with OCC 6.3.1
#ifndef HAVE_IOSTREAM
#define HAVE_IOSTREAM
#endif
typedef int Aci_t; // AutoCAD color index
typedef enum
{
eUnspecified = 0, // Unspecified (No units)
eInches,
eFeet,
eMiles,
eMillimeters,
eCentimeters,
eMeters,
eKilometers,
eMicroinches,
eMils,
eYards,
eAngstroms,
eNanometers,
eMicrons,
eDecimeters,
eDekameters,
eHectometers,
eGigameters,
eAstronomicalUnits,
eLightYears,
eParsecs
} eDxfUnits_t;
struct SplineData
{
double norm[3];
int degree;
int knots;
int control_points;
int fit_points;
int flag;
std::list<double> starttanx;
std::list<double> starttany;
std::list<double> starttanz;
std::list<double> endtanx;
std::list<double> endtany;
std::list<double> endtanz;
std::list<double> knot;
std::list<double> weight;
std::list<double> controlx;
std::list<double> controly;
std::list<double> controlz;
std::list<double> fitx;
std::list<double> fity;
std::list<double> fitz;
};
class CDxfWrite{
private:
std::ofstream* m_ofs;
bool m_fail;
public:
CDxfWrite(const char* filepath);
~CDxfWrite();
bool Failed(){return m_fail;}
void WriteLine(const double* s, const double* e, const char* layer_name );
void WritePoint(const double*, const char*);
void WriteArc(const double* s, const double* e, const double* c, bool dir, const char* layer_name );
void WriteEllipse(const double* c, double major_radius, double minor_radius, double rotation, double start_angle, double end_angle, bool dir, const char* layer_name );
void WriteCircle(const double* c, double radius, const char* layer_name );
};
// derive a class from this and implement it's virtual functions
class CDxfRead{
private:
std::ifstream* m_ifs;
bool m_fail;
char m_str[1024];
char m_unused_line[1024];
eDxfUnits_t m_eUnits;
char m_layer_name[1024];
char m_section_name[1024];
char m_block_name[1024];
bool m_ignore_errors;
typedef std::map< std::string,Aci_t > LayerAciMap_t;
LayerAciMap_t m_layer_aci; // layer names -> layer color aci map
bool ReadUnits();
bool ReadLayer();
bool ReadLine();
bool ReadText();
bool ReadArc();
bool ReadCircle();
bool ReadEllipse();
bool ReadPoint();
bool ReadSpline();
bool ReadLwPolyLine();
bool ReadPolyLine();
bool ReadVertex(double *pVertex, bool *bulge_found, double *bulge);
void OnReadArc(double start_angle, double end_angle, double radius, const double* c);
void OnReadCircle(const double* c, double radius);
void OnReadEllipse(const double* c, const double* m, double ratio, double start_angle, double end_angle);
bool ReadInsert();
void get_line();
void put_line(const char *value);
void DerefACI();
protected:
Aci_t m_aci; // manifest color name or 256 for layer color
public:
CDxfRead(const char* filepath); // this opens the file
~CDxfRead(); // this closes the file
bool Failed(){return m_fail;}
void DoRead(const bool ignore_errors = false); // this reads the file and calls the following functions
double mm( const double & value ) const;
bool IgnoreErrors() const { return(m_ignore_errors); }
virtual void OnReadLine(const double* s, const double* e){}
virtual void OnReadPoint(const double* s){}
virtual void OnReadText(const double* point, const double height, const char* text){}
virtual void OnReadArc(const double* s, const double* e, const double* c, bool dir){}
virtual void OnReadCircle(const double* s, const double* c, bool dir){}
virtual void OnReadEllipse(const double* c, double major_radius, double minor_radius, double rotation, double start_angle, double end_angle, bool dir){}
virtual void OnReadSpline(struct SplineData& sd){}
virtual void OnReadInsert(const double* point, const double* scale, const char* name, double rotation){}
virtual void AddGraphics() const { }
std::string LayerName() const;
};

44
src/Mod/Path/libarea/kurve/Construction.cpp
View File

@ -1,35 +1,11 @@
// *************************************************************************************************************************************** // ***************************************************************************************************************************************
// Point, CLine & Circle classes part of geometry.lib // Point, CLine & Circle classes part of geometry.lib
// g.j.hawkesford August 2006 for Camtek Gmbh
//
// This program is released under the BSD license. See the file COPYING for details.
//
// *************************************************************************************************************************************** // ***************************************************************************************************************************************
/*==============================
Copyright (c) 2006 g.j.hawkesford
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions 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.
3. The name of the author may not be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
==============================*/
#include "geometry.h" #include "geometry.h"
using namespace geoff_geometry; using namespace geoff_geometry;
@ -42,7 +18,6 @@ namespace geoff_geometry {
double RESOLUTION = 1.0e-06; double RESOLUTION = 1.0e-06;
// dummy functions // dummy functions
const wchar_t* getMessage(const wchar_t* original, int messageGroup, int stringID){return original;}
const wchar_t* getMessage(const wchar_t* original){return original;} const wchar_t* getMessage(const wchar_t* original){return original;}
void FAILURE(const wchar_t* str){throw(str);} void FAILURE(const wchar_t* str){throw(str);}
void FAILURE(const std::wstring& str){throw(str);} void FAILURE(const std::wstring& str){throw(str);}
@ -382,7 +357,7 @@ namespace geoff_geometry {
// circle methods // circle methods
// *************************************************************************************************************************************** // ***************************************************************************************************************************************
Circle::Circle(const Point& p, double rad, bool okay){ Circle::Circle(const Point& p, double rad){
// Circle // Circle
pc = p; pc = p;
radius = rad; radius = rad;
@ -410,7 +385,7 @@ namespace geoff_geometry {
Circle Circle::Transform(Matrix& m) { // transform Circle Circle::Transform(Matrix& m) { // transform
Point p0 = this->pc; Point p0 = this->pc;
double scale; double scale;
if(m.GetScale(scale) == false) FAILURE(getMessage(L"Differential Scale not allowed for this method", GEOMETRY_ERROR_MESSAGES, MES_DIFFSCALE)); if(m.GetScale(scale) == false) FAILURE(getMessage(L"Differential Scale not allowed for this method"));
return Circle(p0.Transform(m), radius * scale); return Circle(p0.Transform(m), radius * scale);
} }
@ -485,7 +460,7 @@ namespace geoff_geometry {
Point On(const Circle& c, const Point& p) { Point On(const Circle& c, const Point& p) {
// returns point that is nearest to c from p // returns point that is nearest to c from p
double r = p.Dist(c.pc); double r = p.Dist(c.pc);
if(r < TOLERANCE) FAILURE(getMessage(L",Point on Circle centre - On(Circle& c, Point& p)", GEOMETRY_ERROR_MESSAGES, MES_POINTONCENTRE)); if(r < TOLERANCE) FAILURE(getMessage(L",Point on Circle centre - On(Circle& c, Point& p)"));
return(Mid(p, c.pc, (r - c.radius) / r)); return(Mid(p, c.pc, (r - c.radius) / r));
} }
@ -665,7 +640,7 @@ namespace geoff_geometry {
if(!s2.ok) return Thro(p0, p2); // p1 & p2 coincident if(!s2.ok) return Thro(p0, p2); // p1 & p2 coincident
Point p = Intof(Normal(s0, Mid(p0, p1)), Normal(s1, Mid(p0, p2))); Point p = Intof(Normal(s0, Mid(p0, p1)), Normal(s1, Mid(p0, p2)));
return (p.ok)? Circle(p, p0.Dist(p), true) : INVALID_CIRCLE; return (p.ok)? Circle(p, p0.Dist(p)) : INVALID_CIRCLE;
} }
Circle Tanto(int NF, int AT0, const CLine& s0, int AT1, const Circle &c1, double rad) { Circle Tanto(int NF, int AT0, const CLine& s0, int AT1, const Circle &c1, double rad) {
// circle tanto cline & circle with radius // circle tanto cline & circle with radius
@ -810,7 +785,8 @@ namespace geoff_geometry {
Plane::Plane(double dist, const Vector3d& n) { Plane::Plane(double dist, const Vector3d& n) {
normal = n; normal = n;
double mag = normal.normalise(); double mag = normal.normalise();
if((ok = (normal != NULL_VECTOR))) d = dist / mag; ok = (normal != NULL_VECTOR);
if(ok) d = dist / mag;
} }
double Plane::Dist(const Point3d& p)const{ double Plane::Dist(const Point3d& p)const{

43
src/Mod/Path/libarea/kurve/Finite.cpp
View File

@ -1,36 +1,13 @@
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // written by g.j.hawkesford 2006 for Camtek Gmbh
// finite intersections //
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // This program is released under the BSD license. See the file COPYING for details.
//
/*==============================
Copyright (c) 2006 g.j.hawkesford
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions 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.
3. The name of the author may not be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
==============================*/
#include "geometry.h" #include "geometry.h"
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// finite intersections
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#ifndef WIN32 #ifndef WIN32
#define __min(a,b) ((a<b)?a:b) #define __min(a,b) ((a<b)?a:b)
@ -59,7 +36,7 @@ namespace geoff_geometry {
} }
else { else {
// arc arc // arc arc
return ArcArcIntof(sp0, sp1, p0, p1, t); return ArcArcIntof(sp0, sp1, p0, p1);
} }
} }
} }
@ -125,7 +102,7 @@ namespace geoff_geometry {
return nRoots; return nRoots;
} }
int ArcArcIntof(const Span& arc0, const Span& arc1, Point& pLeft, Point& pRight, double t[4]) { int ArcArcIntof(const Span& arc0, const Span& arc1, Point& pLeft, Point& pRight) {
// Intof 2 arcs // Intof 2 arcs
int numInts = Intof(Circle(arc0.pc, arc0.radius), Circle(arc1.pc, arc1.radius), pLeft, pRight); int numInts = Intof(Circle(arc0.pc, arc0.radius), Circle(arc1.pc, arc1.radius), pLeft, pRight);
@ -273,7 +250,7 @@ namespace geoff_geometry {
two lines P1P2 and P3P4. Calculate also the values of mua and mub where two lines P1P2 and P3P4. Calculate also the values of mua and mub where
Pa = P1 + t1 (P2 - P1) Pa = P1 + t1 (P2 - P1)
Pb = P3 + t2 (P4 - P3) Pb = P3 + t2 (P4 - P3)
Return false if no solution exists. P Bourke method. Return FALSE if no solution exists. P Bourke method.
Input this 1st line Input this 1st line
Input l2 2nd line Input l2 2nd line
Output lshort shortest line between lines (if lshort.ok == false, the line intersect at a point lshort.p0) Output lshort shortest line between lines (if lshort.ok == false, the line intersect at a point lshort.p0)

34
src/Mod/Path/libarea/kurve/Matrix.cpp
View File

@ -1,36 +1,12 @@
//////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////
// 3d geometry classes - implements some 3d stuff // 3d geometry classes - implements some 3d stuff
// //
// g.j.hawkesford August 2003
//
// This program is released under the BSD license. See the file COPYING for details.
// //
//////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////
/*==============================
Copyright (c) 2006 g.j.hawkesford
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions 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.
3. The name of the author may not be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
==============================*/
#include "geometry.h" #include "geometry.h"
using namespace geoff_geometry; using namespace geoff_geometry;
@ -418,7 +394,7 @@ namespace geoff_geometry {
} }
// divide columns by minus pivot (value of pivot element is contained in biga) // divide columns by minus pivot (value of pivot element is contained in biga)
if ( fabs ( biga ) < 1.0e-10 )FAILURE(getMessage(L"Singular Matrix - Inversion failure",GEOMETRY_ERROR_MESSAGES, -1)); // singular matrix if ( fabs ( biga ) < 1.0e-10 )FAILURE(getMessage(L"Singular Matrix - Inversion failure")); // singular matrix
for ( i = 0 ; i < n ; i++ ) { for ( i = 0 ; i < n ; i++ ) {
if ( i != k ) { if ( i != k ) {
@ -622,7 +598,7 @@ namespace geoff_geometry {
void Plane::Mirrored(Matrix* tmMirrored) { void Plane::Mirrored(Matrix* tmMirrored) {
// calculates a mirror transformation that mirrors 2d about plane // 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(); if(tmMirrored->m_unit == false) tmMirrored->Unit();
double nx = this->normal.getx(); double nx = this->normal.getx();

49
src/Mod/Path/libarea/kurve/geometry.h
View File

@ -1,34 +1,14 @@
///////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////
// geometry.lib header // geometry.lib header
// modified with 2d & 3d vector methods 2006
// g.j.hawkesford August 2003
// modified with 2d & 3d vector methods 2006
//
// This program is released under the BSD license. See the file COPYING for details.
//
///////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////
/*==============================
Copyright (c) 2006 g.j.hawkesford
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions 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.
3. The name of the author may not be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
==============================*/
#pragma once #pragma once
#ifdef WIN32 #ifdef WIN32
#pragma warning( disable : 4996 ) #pragma warning( disable : 4996 )
@ -130,7 +110,6 @@ inline bool FNEZ(double a, double tolerance = TIGHT_TOLERANCE) {return fabs(a) >
#define ACW 1 // anti-clockwise #define ACW 1 // anti-clockwise
#define CW -1 // clockwise #define CW -1 // clockwise
const wchar_t* getMessage(const wchar_t* original, int messageGroup, int stringID);
const wchar_t* getMessage(const wchar_t* original); // dummy const wchar_t* getMessage(const wchar_t* original); // dummy
void FAILURE(const wchar_t* str); void FAILURE(const wchar_t* str);
void FAILURE(const std::wstring& str); void FAILURE(const std::wstring& str);
@ -262,7 +241,7 @@ inline bool FNEZ(double a, double tolerance = TIGHT_TOLERANCE) {return fabs(a) >
#define INVALID_POINT Point(9.9999999e50, 0, false) #define INVALID_POINT Point(9.9999999e50, 0, false)
#define INVALID_POINT3D Point3d(9.9999999e50, 0, 0, false) #define INVALID_POINT3D Point3d(9.9999999e50, 0, 0, false)
#define INVALID_CLINE CLine(INVALID_POINT, 1, 0, false) #define INVALID_CLINE CLine(INVALID_POINT, 1, 0, false)
#define INVALID_CIRCLE Circle(INVALID_POINT, 0, false) #define INVALID_CIRCLE Circle(INVALID_POINT, 0)
// 3d point class // 3d point class
class Point3d { class Point3d {
@ -335,7 +314,7 @@ inline bool FNEZ(double a, double tolerance = TIGHT_TOLERANCE) {return fabs(a) >
inline const Vector2d& operator+=(const Vector2d &v){dx += v.dx; dy += v.dy; return *this;} // v1 += v0; inline const Vector2d& operator+=(const Vector2d &v){dx += v.dx; dy += v.dy; return *this;} // v1 += v0;
inline Vector2d operator-(const Vector2d &v)const{return Vector2d( dx - v.dx, dy - v.dy);} // v2 = v0 - v1; inline Vector2d operator-(const Vector2d &v)const{return Vector2d( dx - v.dx, dy - v.dy);} // v2 = v0 - v1;
inline const Vector2d& operator-=(const Vector2d &v){dx -= v.dx; dy -= v.dy; return *this;} // v1 -= v0; inline const Vector2d& operator-=(const Vector2d &v){dx -= v.dx; dy =- v.dy; return *this;} // v1 -= v0;
inline Vector2d operator-(const double d){ return Vector2d(dx - d, dy - d); }; inline Vector2d operator-(const double d){ return Vector2d(dx - d, dy - d); };
inline const Vector2d operator-(void)const{return Vector2d(-dx, -dy);} // v1 = -v0; (unary minus) inline const Vector2d operator-(void)const{return Vector2d(-dx, -dy);} // v1 = -v0; (unary minus)
@ -404,7 +383,7 @@ inline bool FNEZ(double a, double tolerance = TIGHT_TOLERANCE) {return fabs(a) >
const Vector3d& operator+=(const Vector3d &v){dx += v.dx; dy += v.dy; dz += v.dz; return *this;} // v1 += v0; const Vector3d& operator+=(const Vector3d &v){dx += v.dx; dy += v.dy; dz += v.dz; return *this;} // v1 += v0;
Vector3d operator-(const Vector3d &v)const{return Vector3d( dx - v.dx, dy - v.dy, dz - v.dz);} // v2 = v0 - v1; Vector3d operator-(const Vector3d &v)const{return Vector3d( dx - v.dx, dy - v.dy, dz - v.dz);} // v2 = v0 - v1;
const Vector3d& operator-=(const Vector3d &v){ const Vector3d& operator-=(const Vector3d &v){
dx -= v.dx; dy -= v.dy; dz -= v.dz; return *this;} // v1 -= v0; dx -= v.dx; dy =- v.dy; dz = -v.dz; return *this;} // v1 -= v0;
const Vector3d operator-(void)const{return Vector3d(-dx, -dy, -dz);} // v1 = -v0; (unary minus) const Vector3d operator-(void)const{return Vector3d(-dx, -dy, -dz);} // v1 = -v0; (unary minus)
@ -499,8 +478,8 @@ inline bool FNEZ(double a, double tolerance = TIGHT_TOLERANCE) {return fabs(a) >
// constructors etc... // constructors etc...
inline Circle() {ok = false;}; inline Circle() {ok = false;};
Circle( const Point& p, double r, bool okay = true); // Circle c1(Point(10,30), 20); Circle( const Point& p, double r); // Circle c1(Point(10,30), 20);
Circle( const Point& p, const Point& pc); // Circle c1(p[222], p[223]); Circle( const Point& p, const Point& pc); // Circle c1(p[222], p[223]);
Circle( const Circle& c ){*this = c;} // copy constructor Circle c1(c2); Circle( const Circle& c ){*this = c;} // copy constructor Circle c1(c2);
Circle( const Span& sp); // constructor Circle( const Span& sp); // constructor
@ -952,7 +931,7 @@ inline bool FNEZ(double a, double tolerance = TIGHT_TOLERANCE) {return fabs(a) >
int Intof(const Span& sp0 , const Span& sp1, Point& p0, Point& p1, double t[4]); int Intof(const Span& sp0 , const Span& sp1, Point& p0, Point& p1, double t[4]);
int LineLineIntof(const Span& L0 , const Span& L1, Point& p, double t[2]); int LineLineIntof(const Span& L0 , const Span& L1, Point& p, double t[2]);
int LineArcIntof(const Span& line, const Span& arc, Point& p0, Point& p1, double t[4]); int LineArcIntof(const Span& line, const Span& arc, Point& p0, Point& p1, double t[4]);
int ArcArcIntof(const Span& arc0, const Span& arc1, Point& pLeft, Point& pRight, double t[4]); int ArcArcIntof(const Span& arc0, const Span& arc1, Point& pLeft, Point& pRight);
bool OnSpan(const Span& sp, const Point& p); bool OnSpan(const Span& sp, const Point& p);
bool OnSpan(const Span& sp, const Point& p, bool nearPoints, Point& pNear, Point& pOnSpan); // function returns true if pNear == pOnSpan bool OnSpan(const Span& sp, const Point& p, bool nearPoints, Point& pNear, Point& pOnSpan); // function returns true if pNear == pOnSpan

75
src/Mod/Path/libarea/kurve/kurve.cpp
View File

@ -1,32 +1,7 @@
//////////////////////////////////////////////////////////////////////////////////////////////// // written by g.j.hawkesford 2006 for Camtek Gmbh
// kurve //
//////////////////////////////////////////////////////////////////////////////////////////////// // This program is released under the BSD license. See the file COPYING for details.
//
/*==============================
Copyright (c) 2006 g.j.hawkesford
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions 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.
3. The name of the author may not be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
==============================*/
#include "geometry.h" #include "geometry.h"
using namespace geoff_geometry; using namespace geoff_geometry;
@ -35,6 +10,11 @@ using namespace geoff_geometry;
#include "postoutput.h" #include "postoutput.h"
#endif #endif
////////////////////////////////////////////////////////////////////////////////////////////////
// kurve
////////////////////////////////////////////////////////////////////////////////////////////////
namespace geoff_geometry { namespace geoff_geometry {
SpanVertex::SpanVertex() { SpanVertex::SpanVertex() {
@ -696,7 +676,7 @@ return;
void Kurve::Replace(int vertexnumber, int type, const Point& p0, const Point& pc, int ID) { void Kurve::Replace(int vertexnumber, int type, const Point& p0, const Point& pc, int ID) {
// replace a span // replace a span
#ifdef _DEBUG #ifdef _DEBUG
if(this == NULL || vertexnumber > m_nVertices) FAILURE(getMessage(L"Kurve::Replace - vertexNumber out of range", GEOMETRY_ERROR_MESSAGES, MES_BAD_VERTEX_NUMBER)); if(this == NULL || vertexnumber > m_nVertices) FAILURE(getMessage(L"Kurve::Replace - vertexNumber out of range"));
#endif #endif
SpanVertex* p = (SpanVertex*) m_spans[vertexnumber / SPANSTORAGE]; SpanVertex* p = (SpanVertex*) m_spans[vertexnumber / SPANSTORAGE];
p->Add(vertexnumber % SPANSTORAGE, type, p0, pc, ID); p->Add(vertexnumber % SPANSTORAGE, type, p0, pc, ID);
@ -706,7 +686,7 @@ return;
void Kurve::ModifyIndex(int vertexnumber, WireExtraData* i) { void Kurve::ModifyIndex(int vertexnumber, WireExtraData* i) {
// replace an index // replace an index
#ifdef _DEBUG #ifdef _DEBUG
if(this == NULL || vertexnumber > m_nVertices) FAILURE(getMessage(L"Kurve::ModifyIndex - vertexNumber out of range", GEOMETRY_ERROR_MESSAGES, MES_BAD_VERTEX_NUMBER)); if(this == NULL || vertexnumber > m_nVertices) FAILURE(getMessage(L"Kurve::ModifyIndex - vertexNumber out of range"));
#endif #endif
SpanVertex* p = (SpanVertex*) m_spans[vertexnumber / SPANSTORAGE]; SpanVertex* p = (SpanVertex*) m_spans[vertexnumber / SPANSTORAGE];
p->Add(vertexnumber % SPANSTORAGE, i); p->Add(vertexnumber % SPANSTORAGE, i);
@ -743,7 +723,7 @@ return;
int Kurve::Get(int vertexnumber, Point& pe, Point& pc) const { int Kurve::Get(int vertexnumber, Point& pe, Point& pc) const {
// returns spantype with end / centre by reference // returns spantype with end / centre by reference
if(vertexnumber < 0 || vertexnumber >= m_nVertices) FAILURE(getMessage(L"Kurve::Get - vertexNumber out of range", GEOMETRY_ERROR_MESSAGES, MES_BAD_VERTEX_NUMBER)); if(vertexnumber < 0 || vertexnumber >= m_nVertices) FAILURE(getMessage(L"Kurve::Get - vertexNumber out of range"));
if(m_isReversed == true) { if(m_isReversed == true) {
int revVertexnumber = m_nVertices - 1 - vertexnumber; int revVertexnumber = m_nVertices - 1 - vertexnumber;
SpanVertex* p = (SpanVertex*)m_spans[revVertexnumber / SPANSTORAGE]; SpanVertex* p = (SpanVertex*)m_spans[revVertexnumber / SPANSTORAGE];
@ -765,14 +745,14 @@ return;
} }
int Kurve::GetSpanID(int vertexnumber) const { int Kurve::GetSpanID(int vertexnumber) const {
// for spanID (wire offset) // for spanID (wire offset)
if(vertexnumber < 0 || vertexnumber >= m_nVertices) FAILURE(getMessage(L"Kurve::Get - vertexNumber out of range", GEOMETRY_ERROR_MESSAGES, MES_BAD_VERTEX_NUMBER)); if(vertexnumber < 0 || vertexnumber >= m_nVertices) FAILURE(getMessage(L"Kurve::Get - vertexNumber out of range"));
if(m_isReversed == true) vertexnumber = m_nVertices - 1 - vertexnumber; if(m_isReversed == true) vertexnumber = m_nVertices - 1 - vertexnumber;
SpanVertex* p = (SpanVertex*)m_spans[vertexnumber / SPANSTORAGE]; SpanVertex* p = (SpanVertex*)m_spans[vertexnumber / SPANSTORAGE];
return p->GetSpanID(vertexnumber % SPANSTORAGE); return p->GetSpanID(vertexnumber % SPANSTORAGE);
} }
int Kurve::Get(int spannumber, Span& sp, bool returnSpanProperties, bool transform) const { int Kurve::Get(int spannumber, Span& sp, bool returnSpanProperties, bool transform) const {
// returns span data and optional properties - the function returns as the span type // returns span data and optional properties - the function returns as the span type
if(spannumber < 1 || spannumber > m_nVertices) FAILURE(getMessage(L"Kurve::Get - vertexNumber out of range", GEOMETRY_ERROR_MESSAGES, MES_BAD_VERTEX_NUMBER)); if(spannumber < 1 || spannumber > m_nVertices) FAILURE(getMessage(L"Kurve::Get - vertexNumber out of range"));
if(m_nVertices < 2) return -99; if(m_nVertices < 2) return -99;
int spanVertexNumber = spannumber - 1; int spanVertexNumber = spannumber - 1;
@ -798,7 +778,7 @@ return;
#if 0 #if 0
int Kurve::Get(int spannumber, Span3d& sp, bool returnSpanProperties, bool transform) const { int Kurve::Get(int spannumber, Span3d& sp, bool returnSpanProperties, bool transform) const {
// returns span data and optional properties - the function returns as the span type // returns span data and optional properties - the function returns as the span type
if(spannumber < 1 || spannumber > m_nVertices) FAILURE(getMessage(L"Kurve::Get - vertexNumber out of range", GEOMETRY_ERROR_MESSAGES, MES_BAD_VERTEX_NUMBER)); if(spannumber < 1 || spannumber > m_nVertices) FAILURE(getMessage(L"Kurve::Get - vertexNumber out of range"));
if(m_nVertices < 2) return -99; if(m_nVertices < 2) return -99;
int spanVertexNumber = spannumber - 1; int spanVertexNumber = spannumber - 1;
@ -832,7 +812,8 @@ return;
} }
void Span::SetProperties(bool returnProperties) { void Span::SetProperties(bool returnProperties) {
if((returnSpanProperties = returnProperties)) { returnSpanProperties = returnProperties;
if(returnSpanProperties) {
// return span properties // return span properties
if(dir) { if(dir) {
// arc properties // arc properties
@ -847,7 +828,7 @@ return;
double radCheck = ve.normalise(); double radCheck = ve.normalise();
// if(FNE(radius, radCheck, geoff_geometry::TOLERANCE * 0.5)){ // if(FNE(radius, radCheck, geoff_geometry::TOLERANCE * 0.5)){
if(FNE(radius, radCheck, geoff_geometry::TOLERANCE)){ if(FNE(radius, radCheck, geoff_geometry::TOLERANCE)){
FAILURE(getMessage(L"Invalid Geometry - Radii mismatch - SetProperties", GEOMETRY_ERROR_MESSAGES, MES_INVALIDARC)); FAILURE(getMessage(L"Invalid Geometry - Radii mismatch - SetProperties"));
} }
length = 0.0; length = 0.0;
@ -998,10 +979,10 @@ return;
Kurve temp; Kurve temp;
bool wrapped = false; bool wrapped = false;
int nSpans = 0;
int spanno = startSpanno; int spanno = startSpanno;
Span sp; Span sp;
while(1) { for(int nSpans = 0; nSpans <= this->nSpans(); nSpans++)
{
this->Get(spanno, sp, false, true); this->Get(spanno, sp, false, true);
if(spanno == startSpanno && wrapped == false) { if(spanno == startSpanno && wrapped == false) {
temp.Start(*pNewStart); temp.Start(*pNewStart);
@ -1015,8 +996,7 @@ return;
} }
spanno++; spanno++;
nSpans++;
if(nSpans > this->nSpans()) break;
if(spanno > this->nSpans()) { if(spanno > this->nSpans()) {
if(this->Closed() == false) break; if(this->Closed() == false) break;
spanno = 1; spanno = 1;
@ -1042,9 +1022,10 @@ return;
} }
Kurve temp; Kurve temp;
int spanno = 1;
Span sp; Span sp;
while(1) {
for(int spanno = 1; spanno != (endSpanno + 1); spanno++)
{
this->Get(spanno, sp, false, true); this->Get(spanno, sp, false, true);
if(spanno == 1) { if(spanno == 1) {
temp.Start(sp.p0); temp.Start(sp.p0);
@ -1067,7 +1048,7 @@ return;
min = Point(1.0e61, 1.0e61); min = Point(1.0e61, 1.0e61);
max = Point(-1.0e61, -1.0e61); max = Point(-1.0e61, -1.0e61);
if(!GetScale(xscale)) FAILURE(getMessage(L"Differential Scale not allowed for this method", GEOMETRY_ERROR_MESSAGES, MES_DIFFSCALE)); // differential scale if(!GetScale(xscale)) FAILURE(getMessage(L"Differential Scale not allowed for this method")); // differential scale
Span sp; Span sp;
for(int i = 1; i < m_nVertices; i++) { for(int i = 1; i < m_nVertices; i++) {
Get(i, sp, true, true); Get(i, sp, true, true);
@ -1118,7 +1099,7 @@ return;
double perim = 0; double perim = 0;
Span sp; Span sp;
double xscale = 1.0; double xscale = 1.0;
if(!GetScale(xscale)) FAILURE(getMessage(L"Differential Scale not allowed for this method", GEOMETRY_ERROR_MESSAGES, MES_DIFFSCALE)); // differential scale if(!GetScale(xscale)) FAILURE(getMessage(L"Differential Scale not allowed for this method")); // differential scale
if(m_nVertices > 1) { if(m_nVertices > 1) {
for(int i = 1; i < m_nVertices; i++) for(int i = 1; i < m_nVertices; i++)
@ -1133,7 +1114,7 @@ return;
Span sp; Span sp;
if(Closed()) { if(Closed()) {
if(!GetScale(xscale)) FAILURE(getMessage(L"Differential Scale not allowed for this method", GEOMETRY_ERROR_MESSAGES, MES_DIFFSCALE)); // differential scale if(!GetScale(xscale)) FAILURE(getMessage(L"Differential Scale not allowed for this method")); // differential scale
for(int i = 1; i < m_nVertices; i++) { for(int i = 1; i < m_nVertices; i++) {
if(Get(i, sp, true)) if(Get(i, sp, true))
area += ( 0.5 * ((sp.pc.x - sp.p0.x) * (sp.pc.y + sp.p0.y) - (sp.pc.x - sp.p1.x) * (sp.pc.y + sp.p1.y) - sp.angle * sp.radius * sp.radius)); area += ( 0.5 * ((sp.pc.x - sp.p0.x) * (sp.pc.y + sp.p0.y) - (sp.pc.x - sp.p1.x) * (sp.pc.y + sp.p1.y) - sp.angle * sp.radius * sp.radius));
@ -1345,7 +1326,7 @@ return;
return m_nVertices - kReduced.m_nVertices; return m_nVertices - kReduced.m_nVertices;
#else #else
int dir1 = 0, dir2 = 0; int dir1, dir2 = 0;
Point p0, p1, p2, pc0, pc1, pc2; Point p0, p1, p2, pc0, pc1, pc2;
int vertex = 0; int vertex = 0;
int dir0 = Get(vertex++, p0, pc0); // first vertex int dir0 = Get(vertex++, p0, pc0); // first vertex

31
src/Mod/Path/libarea/kurve/offset.cpp
View File

@ -1,34 +1,11 @@
//////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////
// 2d geometry classes - implements 2d kurve offset for use in dll // 2d geometry classes - implements 2d kurve offset for use in dll
// //
// g.j.hawkesford August 2003
//
// This program is released under the BSD license. See the file COPYING for details.
//
//////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////
/*==============================
Copyright (c) 2003 g.j.hawkesford
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions 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.
3. The name of the author may not be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
==============================*/
#include "geometry.h" #include "geometry.h"
using namespace geoff_geometry; using namespace geoff_geometry;