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

Tests and fixes for triangular shaped tags.

Browse Source
This commit is contained in:
Markus Lampert 2016-11-21 21:53:35 -08:00
parent 1fd4c49fca
commit 3ce5ea6b35
3 changed files with 239 additions and 366 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
src/Mod/Path/PathScripts/PathDressupHoldingTags.py
View File

@ -149,6 +149,9 @@ class Tag:
def top(self):
return self.z + self.actualHeight
def centerLine(self):
return Part.Line(self.originAt(self.bottom()), self.originAt(self.top()))
def createSolidsAt(self, z):
self.z = z
r1 = self.width / 2
@ -210,30 +213,57 @@ class Tag:
#print("\nplateau= %s - %s" %(pt1, pt2))
return Part.Edge(Part.Line(pt1, pt2))
def intersectP0(self, edge):
def intersectP0Core(self, edge):
#print("----- P0 (%s - %s)" % (edge.Curve.StartPoint, edge.Curve.EndPoint))
i = self.tag.nextIntersectionClosestTo(edge, self.tag.core, edge.Curve.StartPoint)
if i:
if pointsCoincide(i, edge.Curve.StartPoint):
# if P0 and P1 are the same, we need to insert a segment for the rise
#print("------- insert vertical rise (%s)" % i)
self.edges.append(Part.Edge(Part.Line(i, FreeCAD.Vector(i.x, i.y, self.tag.top()))))
self.p1 = i
self.state = self.P1
return edge
if pointsCoincide(i, edge.Curve.EndPoint):
#print("------- consumed (%s)" % i)
e = edge
tail = None
else:
#print("------- split at (%s)" % i)
e, tail = self.tag.splitEdgeAt(edge, i)
self.p1 = e.Curve.EndPoint
self.edges.append(self.tag.mapEdgeToSolid(e))
self.state = self.P1
return tail
# no intersection, the entire edge fits between P0 and P1
#print("------- no intersection")
self.edges.append(self.tag.mapEdgeToSolid(edge))
return None
def intersectP0(self, edge):
if self.tag.core:
return self.intersectP0Core(edge)
# if we have no core the tip is the origin of the Tag
line = Part.Edge(self.tag.centerLine())
i = DraftGeomUtils.findIntersection(line, edge)
if i:
if pointsCoincide(i[0], edge.Curve.EndPoint):
e = edge
tail = None
else:
e, tail = self.tag.splitEdgeAt(edge, i[0])
self.state = self.P2 # P1 and P2 are identical for triangular tags
self.p1 = i[0]
self.p2 = i[0]
else:
e = edge
tail = None
self.edges.append(self.tag.mapEdgeToSolid(e))
return tail
def intersectP1(self, edge):
#print("----- P1 (%s - %s)" % (edge.Curve.StartPoint, edge.Curve.EndPoint))
i = self.tag.nextIntersectionClosestTo(edge, self.tag.core, edge.Curve.EndPoint)

570
src/Mod/Path/PathTests/TestPathDressupHoldingTags.py
View File

@ -94,18 +94,15 @@ class TagTestCaseBase(unittest.TestCase):
if math.fabs(v1 - v2) > slack:
self.fail("%f != %f" % (v1, v2))
def assertTrapezoid(self, edgs, tail, points):
def assertLines(self, edgs, tail, points):
"""Check that there are 5 edges forming a trapezoid."""
edges = list(edgs)
if tail:
edges.append(tail)
self.assertEqual(len(edges), 5)
self.assertEqual(len(edges), len(points) - 1)
self.assertLine(edges[0], points[0], points[1])
self.assertLine(edges[1], points[1], points[2])
self.assertLine(edges[2], points[2], points[3])
self.assertLine(edges[3], points[3], points[4])
self.assertLine(edges[4], points[4], points[5])
for i in range(0, len(edges)):
self.assertLine(edges[i], points[i], points[i+1])
class TestTag00BasicHolding(TagTestCaseBase):
"""Some basid test cases."""
@ -157,7 +154,7 @@ class TestTag01BasicTag(TagTestCaseBase): # =============
self.assertCylinderAt(tag.core, Vector(100, 200, 17), 2, 5)
def test02(self):
"""Verify an angled tag has a cone shape with a lid, and cylinder core."""
"""Verify trapezoidal tag has a cone shape with a lid, and cylinder core."""
tag = Tag(0, 0, 18, 5, 45, True)
tag.createSolidsAt(0)
@ -185,7 +182,24 @@ class TestTag01BasicTag(TagTestCaseBase): # =============
self.assertIsNone(tag.core)
def test10(self):
class TestTag02SquareTag(TagTestCaseBase): # =============
"""Unit tests for square tags."""
def test00(self):
"""Verify no intersection."""
tag = Tag( 0, 0, 4, 7, 90, True, 0)
pt1 = Vector(+5, 5, 0)
pt2 = Vector(-5, 5, 0)
edge = Part.Edge(Part.Line(pt1, pt2))
i = tag.intersect(edge)
self.assertIsNotNone(i)
self.assertTrue(i.isComplete())
self.assertIsNotNone(i.edges)
self.assertFalse(i.edges)
self.assertLine(i.tail, pt1, pt2)
def test01(self):
"""Verify intersection of square tag with line ending at tag start."""
tag = Tag( 0, 0, 8, 3, 90, True, 0)
edge = Part.Edge(Part.Line(Vector(5, 0, 0), Vector(4, 0, 0)))
@ -196,7 +210,7 @@ class TestTag01BasicTag(TagTestCaseBase): # =============
self.assertLine(i.edges[0], edge.Curve.StartPoint, edge.Curve.EndPoint)
self.assertIsNone(i.tail)
def test11(self):
def test02(self):
"""Verify intersection of square tag with line ending between P1 and P2."""
tag = Tag( 0, 0, 8, 3, 90, True, 0)
edge = Part.Edge(Part.Line(Vector(5, 0, 0), Vector(1, 0, 0)))
@ -221,7 +235,7 @@ class TestTag01BasicTag(TagTestCaseBase): # =============
self.assertLine(i.edges[3], p3, p4)
self.assertIsNone(i.tail)
def test12(self):
def test03(self):
"""Verify intesection of square tag with line ending on P2."""
tag = Tag( 0, 0, 8, 3, 90, True, 0)
edge = Part.Edge(Part.Line(Vector(5, 0, 0), Vector(-4, 0, 0)))
@ -252,7 +266,7 @@ class TestTag01BasicTag(TagTestCaseBase): # =============
self.assertLine(i.edges[3], p2a, p3)
self.assertIsNone(i.tail)
def test13(self):
def test04(self):
"""Verify plunge down is inserted for square tag on exit."""
tag = Tag( 0, 0, 8, 3, 90, True, 0)
edge = Part.Edge(Part.Line(Vector(5, 0, 0), Vector(-5, 0, 0)))
@ -274,8 +288,78 @@ class TestTag01BasicTag(TagTestCaseBase): # =============
self.assertIsNotNone(i.tail)
self.assertLine(i.tail, p4, p5)
def test20(self):
"""Veify intersection of angled tag with line ending before P1."""
def test05(self):
"""Verify all lines between P0 and P3 are added."""
tag = Tag( 0, 0, 4, 7, 90, True, 0)
e0 = Part.Edge(Part.Line(Vector(5, 0, 0), Vector(+2, 0, 0)))
e1 = Part.Edge(Part.Line(e0.Curve.EndPoint, Vector(+1, 0, 0)))
e2 = Part.Edge(Part.Line(e1.Curve.EndPoint, Vector(+0.5, 0, 0)))
e3 = Part.Edge(Part.Line(e2.Curve.EndPoint, Vector(-0.5, 0, 0)))
e4 = Part.Edge(Part.Line(e3.Curve.EndPoint, Vector(-1, 0, 0)))
e5 = Part.Edge(Part.Line(e4.Curve.EndPoint, Vector(-2, 0, 0)))
e6 = Part.Edge(Part.Line(e5.Curve.EndPoint, Vector(-5, 0, 0)))
i = tag
for e in [e0, e1, e2, e3, e4, e5]:
i = i.intersect(e)
self.assertFalse(i.isComplete())
i = i.intersect(e6)
self.assertTrue(i.isComplete())
pt0 = Vector(2, 0, 0)
pt1 = Vector(2, 0, 7)
pt2 = Vector(1, 0, 7)
pt3 = Vector(0.5, 0, 7)
pt4 = Vector(-0.5, 0, 7)
pt5 = Vector(-1, 0, 7)
pt6 = Vector(-2, 0, 7)
self.assertEqual(len(i.edges), 8)
self.assertLines(i.edges, i.tail, [e0.Curve.StartPoint, pt0, pt1, pt2, pt3, pt4, pt5, pt6, e6.Curve.StartPoint, e6.Curve.EndPoint])
self.assertIsNotNone(i.tail)
def test06(self):
"""Verify intersection of different z levels."""
tag = Tag( 0, 0, 4, 7, 90, True, 0)
# for all lines below 7 we get the trapezoid
for i in range(0, 7):
p0 = Vector(5, 0, i)
p1 = Vector(2, 0, i)
p2 = Vector(2, 0, 7)
p3 = Vector(-2, 0, 7)
p4 = Vector(-2, 0, i)
p5 = Vector(-5, 0, i)
edge = Part.Edge(Part.Line(p0, p5))
s = tag.intersect(edge)
self.assertTrue(s.isComplete())
self.assertLines(s.edges, s.tail, [p0, p1, p2, p3, p4, p5])
# for all edges at height or above the original line is used
for i in range(7, 9):
edge = Part.Edge(Part.Line(Vector(5, 0, i), Vector(-5, 0, i)))
s = tag.intersect(edge)
self.assertTrue(s.isComplete())
self.assertLine(s.tail, edge.Curve.StartPoint, edge.Curve.EndPoint)
class TestTag03TrapezoidTag(TagTestCaseBase): # =============
"""Unit tests for trapezoid tags."""
def test00(self):
"""Verify no intersection."""
tag = Tag( 0, 0, 8, 3, 45, True, 0)
pt1 = Vector(+5, 5, 0)
pt2 = Vector(-5, 5, 0)
edge = Part.Edge(Part.Line(pt1, pt2))
i = tag.intersect(edge)
self.assertIsNotNone(i)
self.assertTrue(i.isComplete())
self.assertIsNotNone(i.edges)
self.assertFalse(i.edges)
self.assertLine(i.tail, pt1, pt2)
def test01(self):
"""Veify intersection of trapezoid tag with line ending before P1."""
tag = Tag( 0, 0, 8, 3, 45, True, 0)
edge = Part.Edge(Part.Line(Vector(5, 0, 0), Vector(4, 0, 0)))
@ -309,8 +393,8 @@ class TestTag01BasicTag(TagTestCaseBase): # =============
self.assertLine(i.edges[2], p2, p3)
self.assertIsNone(i.tail)
def test21(self):
"""Verify intersection of angled tag with line ending between P1 and P2"""
def test02(self):
"""Verify intersection of trapezoid tag with line ending between P1 and P2"""
tag = Tag( 0, 0, 8, 3, 45, True, 0)
edge = Part.Edge(Part.Line(Vector(5, 0, 0), Vector(1, 0, 0)))
@ -332,21 +416,18 @@ class TestTag01BasicTag(TagTestCaseBase): # =============
self.assertLine(i.edges[2], p2, p3)
self.assertIsNone(i.tail)
def test22(self):
"""Verify intersection of angled tag with edge ending on P2."""
def test03(self):
"""Verify intersection of trapezoid tag with edge ending on P2."""
tag = Tag( 0, 0, 8, 3, 45, True, 0)
edge = Part.Edge(Part.Line(Vector(5, 0, 0), Vector(-1, 0, 0)))
i = tag.intersect(edge)
self.assertEqual(i.state, Tag.Intersection.P2)
self.assertEqual(len(i.edges), 3)
p0 = Vector(edge.Curve.StartPoint)
p1 = Vector(4, 0, 0)
p2 = Vector(1, 0, 3)
p3 = Vector(-1, 0, 3)
self.assertLine(i.edges[0], p0, p1)
self.assertLine(i.edges[1], p1, p2)
self.assertLine(i.edges[2], p2, p3)
self.assertLines(i.edges, i.tail, [p0, p1, p2, p3])
self.assertIsNone(i.tail)
# make sure we get the same result if there's another edge
@ -355,10 +436,7 @@ class TestTag01BasicTag(TagTestCaseBase): # =============
edge = Part.Edge(Part.Line(edge.Curve.EndPoint, Vector(-1, 0, 0)))
i = i.intersect(edge)
self.assertEqual(i.state, Tag.Intersection.P2)
self.assertEqual(len(i.edges), 3)
self.assertLine(i.edges[0], p0, p1)
self.assertLine(i.edges[1], p1, p2)
self.assertLine(i.edges[2], p2, p3)
self.assertLines(i.edges, i.tail, [p0, p1, p2, p3])
self.assertIsNone(i.tail)
# and also if the last segment doesn't cross the entire plateau
@ -367,31 +445,23 @@ class TestTag01BasicTag(TagTestCaseBase): # =============
edge = Part.Edge(Part.Line(edge.Curve.EndPoint, Vector(-1, 0, 0)))
i = i.intersect(edge)
self.assertEqual(i.state, Tag.Intersection.P2)
self.assertEqual(len(i.edges), 4)
p2a = Vector(0.5, 0, 3)
self.assertLine(i.edges[0], p0, p1)
self.assertLine(i.edges[1], p1, p2)
self.assertLine(i.edges[2], p2, p2a)
self.assertLine(i.edges[3], p2a, p3)
self.assertLines(i.edges, i.tail, [p0, p1, p2, p2a, p3])
self.assertIsNone(i.tail)
def test23(self):
"""Verify proper down plunge on angled tag exit."""
def test04(self):
"""Verify proper down plunge on trapezoid tag exit."""
tag = Tag( 0, 0, 8, 3, 45, True, 0)
edge = Part.Edge(Part.Line(Vector(5, 0, 0), Vector(-2, 0, 0)))
i = tag.intersect(edge)
self.assertEqual(i.state, Tag.Intersection.P2)
self.assertEqual(len(i.edges), 4)
p0 = Vector(5, 0, 0)
p1 = Vector(4, 0, 0)
p2 = Vector(1, 0, 3)
p3 = Vector(-1, 0, 3)
p4 = Vector(-2, 0, 2)
self.assertLine(i.edges[0], p0, p1)
self.assertLine(i.edges[1], p1, p2)
self.assertLine(i.edges[2], p2, p3)
self.assertLine(i.edges[3], p3, p4)
self.assertLines(i.edges, i.tail, [p0, p1, p2, p3, p4])
self.assertIsNone(i.tail)
# make sure adding another segment doesn't change the state
@ -418,11 +488,7 @@ class TestTag01BasicTag(TagTestCaseBase): # =============
i = tag.intersect(edge)
self.assertEqual(i.state, Tag.Intersection.P3)
self.assertTrue(i.isComplete())
self.assertEqual(len(i.edges), 4)
self.assertLine(i.edges[0], p0, p1)
self.assertLine(i.edges[1], p1, p2)
self.assertLine(i.edges[2], p2, p3)
self.assertLine(i.edges[3], p3, p6)
self.assertLines(i.edges, i.tail, [p0, p1, p2, p3, p6])
self.assertIsNone(i.tail)
# verify tail is added as well
@ -430,307 +496,10 @@ class TestTag01BasicTag(TagTestCaseBase): # =============
i = tag.intersect(edge)
self.assertEqual(i.state, Tag.Intersection.P3)
self.assertTrue(i.isComplete())
self.assertEqual(len(i.edges), 4)
self.assertLine(i.edges[0], p0, p1)
self.assertLine(i.edges[1], p1, p2)
self.assertLine(i.edges[2], p2, p3)
self.assertLine(i.edges[3], p3, p6)
self.assertLines(i.edges, i.tail, [p0, p1, p2, p3, p6, edge.Curve.EndPoint])
self.assertIsNotNone(i.tail)
self.assertLine(i.tail, p6, edge.Curve.EndPoint)
class TestTag02SquareTag(TagTestCaseBase): # =============
"""Unit tests for square tags."""
def test00(self):
"""Verify no intersection."""
tag = Tag( 0, 0, 4, 7, 90, True, 0)
pt1 = Vector(+5, 5, 0)
pt2 = Vector(-5, 5, 0)
edge = Part.Edge(Part.Line(pt1, pt2))
i = tag.intersect(edge)
self.assertIsNotNone(i)
self.assertTrue(i.isComplete())
self.assertIsNotNone(i.edges)
self.assertFalse(i.edges)
self.assertLine(i.tail, pt1, pt2)
def test01(self):
"""Verify a straight line passing through tag is split up into 5 segments."""
tag = Tag( 0, 0, 4, 7, 90, True, 0)
pt1 = Vector(+5, 0, 0)
pt2 = Vector(-5, 0, 0)
edge = Part.Edge(Part.Line(pt1, pt2))
i = tag.intersect(edge)
self.assertIsNotNone(i)
self.assertTrue(i.isComplete())
pt0a = Vector(+2, 0, 0)
pt0b = Vector(+2, 0, 7)
pt0c = Vector(-2, 0, 7)
pt0d = Vector(-2, 0, 0)
self.assertEqual(len(i.edges), 4)
self.assertLine(i.edges[0], pt1, pt0a)
self.assertLine(i.edges[1], pt0a, pt0b)
self.assertLine(i.edges[2], pt0b, pt0c)
self.assertLine(i.edges[3], pt0c, pt0d)
self.assertLine(i.tail, pt0d, pt2)
def test02(self):
"""Verify line is accounted for if it reaches P0."""
tag = Tag( 0, 0, 4, 7, 90, True, 0)
edge = Part.Edge(Part.Line(Vector(5, 0, 0), Vector(2, 0, 0)))
i = tag.intersect(edge)
self.assertFalse(i.isComplete())
self.assertEqual(len(i.edges), 1)
self.assertLine(i.edges[0], edge.Curve.StartPoint, edge.Curve.EndPoint)
self.assertIsNone(i.tail)
def test03(self):
"""Verify line is accounted for if it reaches beyond P1."""
tag = Tag( 0, 0, 4, 7, 90, True, 0)
edge = Part.Edge(Part.Line(Vector(5, 0, 0), Vector(1, 0, 0)))
i = tag.intersect(edge)
self.assertFalse(i.isComplete())
pt0a = Vector(+2, 0, 0)
pt0b = Vector(+2, 0, 7)
pt1a = Vector(+1, 0, 7)
self.assertEqual(len(i.edges), 3)
self.assertLine(i.edges[0], edge.Curve.StartPoint, pt0a)
self.assertLine(i.edges[1], pt0a, pt0b)
self.assertLine(i.edges[2], pt0b, pt1a)
self.assertIsNone(i.tail)
def test04(self):
"""Verify line is accounted for if it reaches beyond P2."""
tag = Tag( 0, 0, 4, 7, 90, True, 0)
edge = Part.Edge(Part.Line(Vector(5, 0, 0), Vector(-1, 0, 0)))
i = tag.intersect(edge)
self.assertFalse(i.isComplete())
pt0a = Vector(+2, 0, 0)
pt0b = Vector(+2, 0, 7)
pt1a = Vector(-1, 0, 7)
self.assertEqual(len(i.edges), 3)
self.assertLine(i.edges[0], edge.Curve.StartPoint, pt0a)
self.assertLine(i.edges[1], pt0a, pt0b)
self.assertLine(i.edges[2], pt0b, pt1a)
self.assertIsNone(i.tail)
def test05(self):
"""Verify line is accounted for if it lies entirely between P1 and P2."""
tag = Tag( 0, 0, 4, 7, 90, True, 0)
e1 = Part.Edge(Part.Line(Vector(5, 0, 0), Vector(+1, 0, 0)))
i = tag.intersect(e1)
self.assertFalse(i.isComplete())
e2 = Part.Edge(Part.Line(e1.Curve.EndPoint, Vector(0,0,0)))
i = i.intersect(e2)
pt0a = Vector(+2, 0, 0)
pt0b = Vector(+2, 0, 7)
pt1a = Vector(+1, 0, 7)
pt1b = Vector( 0, 0, 7)
self.assertEqual(len(i.edges), 4)
self.assertLine(i.edges[0], e1.Curve.StartPoint, pt0a)
self.assertLine(i.edges[1], pt0a, pt0b)
self.assertLine(i.edges[2], pt0b, pt1a)
self.assertLine(i.edges[3], pt1a, pt1b)
self.assertIsNone(i.tail)
def test06(self):
"""Verify all lines between P0 and P3 are added."""
tag = Tag( 0, 0, 4, 7, 90, True, 0)
e0 = Part.Edge(Part.Line(Vector(5, 0, 0), Vector(+2, 0, 0)))
e1 = Part.Edge(Part.Line(e0.Curve.EndPoint, Vector(+1, 0, 0)))
e2 = Part.Edge(Part.Line(e1.Curve.EndPoint, Vector(+0.5, 0, 0)))
e3 = Part.Edge(Part.Line(e2.Curve.EndPoint, Vector(-0.5, 0, 0)))
e4 = Part.Edge(Part.Line(e3.Curve.EndPoint, Vector(-1, 0, 0)))
e5 = Part.Edge(Part.Line(e4.Curve.EndPoint, Vector(-2, 0, 0)))
e6 = Part.Edge(Part.Line(e5.Curve.EndPoint, Vector(-5, 0, 0)))
i = tag
for e in [e0, e1, e2, e3, e4, e5]:
i = i.intersect(e)
self.assertFalse(i.isComplete())
i = i.intersect(e6)
self.assertTrue(i.isComplete())
pt0 = Vector(2, 0, 0)
pt1 = Vector(2, 0, 7)
pt2 = Vector(1, 0, 7)
pt3 = Vector(0.5, 0, 7)
pt4 = Vector(-0.5, 0, 7)
pt5 = Vector(-1, 0, 7)
pt6 = Vector(-2, 0, 7)
self.assertEqual(len(i.edges), 8)
self.assertLine(i.edges[0], e0.Curve.StartPoint, pt0)
self.assertLine(i.edges[1], pt0, pt1)
self.assertLine(i.edges[2], pt1, pt2)
self.assertLine(i.edges[3], pt2, pt3)
self.assertLine(i.edges[4], pt3, pt4)
self.assertLine(i.edges[5], pt4, pt5)
self.assertLine(i.edges[6], pt5, pt6)
self.assertLine(i.edges[7], pt6, e5.Curve.EndPoint)
self.assertTrue(i.isComplete())
self.assertIsNotNone(i.tail)
self.assertLine(i.tail, e6.Curve.StartPoint, e6.Curve.EndPoint)
def test07(self):
"""Verify intersection of different z levels."""
tag = Tag( 0, 0, 4, 7, 90, True, 0)
# for all lines below 7 we get the trapezoid
for i in range(0, 7):
p0 = Vector(5, 0, i)
p1 = Vector(2, 0, i)
p2 = Vector(2, 0, 7)
p3 = Vector(-2, 0, 7)
p4 = Vector(-2, 0, i)
p5 = Vector(-5, 0, i)
edge = Part.Edge(Part.Line(p0, p5))
s = tag.intersect(edge)
self.assertTrue(s.isComplete())
self.assertTrapezoid(s.edges, s.tail, [p0, p1, p2, p3, p4, p5])
# for all edges at height or above the original line is used
for i in range(7, 9):
edge = Part.Edge(Part.Line(Vector(5, 0, i), Vector(-5, 0, i)))
s = tag.intersect(edge)
self.assertTrue(s.isComplete())
self.assertLine(s.tail, edge.Curve.StartPoint, edge.Curve.EndPoint)
class TestTag03AngledTag(TagTestCaseBase): # =============
"""Unit tests for trapezoid tags."""
def test00(self):
"""Verify no intersection."""
tag = Tag( 0, 0, 8, 3, 45, True, 0)
pt1 = Vector(+5, 5, 0)
pt2 = Vector(-5, 5, 0)
edge = Part.Edge(Part.Line(pt1, pt2))
i = tag.intersect(edge)
self.assertIsNotNone(i)
self.assertTrue(i.isComplete())
self.assertIsNotNone(i.edges)
self.assertFalse(i.edges)
self.assertLine(i.tail, pt1, pt2)
def test01(self):
"""Verify a straight line passing through tag is split into 5 segments."""
tag = Tag( 0, 0, 8, 3, 45, True, 0)
pt1 = Vector(+5, 0, 0)
pt2 = Vector(-5, 0, 0)
edge = Part.Edge(Part.Line(pt1, pt2))
i = tag.intersect(edge)
self.assertIsNotNone(i)
self.assertTrue(i.isComplete())
pt0a = Vector(+4, 0, 0)
pt0b = Vector(+1, 0, 3)
pt0c = Vector(-1, 0, 3)
pt0d = Vector(-4, 0, 0)
self.assertEqual(len(i.edges), 4)
self.assertLine(i.edges[0], pt1, pt0a)
self.assertLine(i.edges[1], pt0a, pt0b)
self.assertLine(i.edges[2], pt0b, pt0c)
self.assertLine(i.edges[3], pt0c, pt0d)
self.assertLine(i.tail, pt0d, pt2)
def test02(self):
"""Verify line is accounted for if it reaches P0."""
tag = Tag( 0, 0, 8, 3, 45, True, 0)
edge = Part.Edge(Part.Line(Vector(5, 0, 0), Vector(4, 0, 0)))
i = tag.intersect(edge)
self.assertFalse(i.isComplete())
self.assertEqual(len(i.edges), 1)
self.assertLine(i.edges[0], edge.Curve.StartPoint, edge.Curve.EndPoint)
self.assertIsNone(i.tail)
def test03(self):
"""Verify line is accounted for if it reaches beyond P1."""
tag = Tag( 0, 0, 8, 3, 45, True, 0)
edge = Part.Edge(Part.Line(Vector(5, 0, 0), Vector(0.5, 0, 0)))
i = tag.intersect(edge)
self.assertFalse(i.isComplete())
pt0a = Vector(+4, 0, 0)
pt0b = Vector(+1, 0, 3)
pt1a = Vector(+0.5, 0, 3)
self.assertEqual(len(i.edges), 3)
self.assertLine(i.edges[0], edge.Curve.StartPoint, pt0a)
self.assertLine(i.edges[1], pt0a, pt0b)
self.assertLine(i.edges[2], pt0b, pt1a)
self.assertIsNone(i.tail)
def test04(self):
"""Verify line is accounted for if it reaches beyond P2."""
tag = Tag( 0, 0, 8, 3, 45, True, 0)
edge = Part.Edge(Part.Line(Vector(5, 0, 0), Vector(-1, 0, 0)))
i = tag.intersect(edge)
self.assertFalse(i.isComplete())
pt0a = Vector(+4, 0, 0)
pt0b = Vector(+1, 0, 3)
pt1a = Vector(-1, 0, 3)
self.assertEqual(len(i.edges), 3)
self.assertLine(i.edges[0], edge.Curve.StartPoint, pt0a)
self.assertLine(i.edges[1], pt0a, pt0b)
self.assertLine(i.edges[2], pt0b, pt1a)
self.assertIsNone(i.tail)
def test05(self):
"""Verify a line is accounted for if it lies entirely between P1 and P2."""
tag = Tag( 0, 0, 8, 3, 45, True, 0)
e1 = Part.Edge(Part.Line(Vector(5, 0, 0), Vector(+0.5, 0, 0)))
i = tag.intersect(e1)
self.assertFalse(i.isComplete())
e2 = Part.Edge(Part.Line(e1.Curve.EndPoint, Vector(0,0,0)))
i = i.intersect(e2)
pt0a = Vector(+4, 0, 0)
pt0b = Vector(+1, 0, 3)
pt1a = Vector(+0.5, 0, 3)
pt1b = Vector( 0, 0, 3)
self.assertEqual(len(i.edges), 4)
self.assertLine(i.edges[0], e1.Curve.StartPoint, pt0a)
self.assertLine(i.edges[1], pt0a, pt0b)
self.assertLine(i.edges[2], pt0b, pt1a)
self.assertLine(i.edges[3], pt1a, pt1b)
self.assertIsNone(i.tail)
def test06(self):
"""Verify all lines between P0 and P3 are added."""
tag = Tag( 0, 0, 8, 3, 45, True, 0)
e0 = Part.Edge(Part.Line(Vector(5, 0, 0), Vector(+4, 0, 0)))
@ -748,31 +517,19 @@ class TestTag03AngledTag(TagTestCaseBase): # =============
i = i.intersect(e6)
self.assertTrue(i.isComplete())
pt0 = Vector(4, 0, 0)
pt1 = Vector(2, 0, 2)
pt2 = Vector(1, 0, 3)
pt3 = Vector(0.5, 0, 3)
pt4 = Vector(-0.5, 0, 3)
pt5 = Vector(-1, 0, 3)
pt6 = Vector(-2, 0, 2)
pt7 = Vector(-4, 0, 0)
#self.assertEqual(len(i.edges), 8)
self.assertLine(i.edges[0], e0.Curve.StartPoint, pt0)
self.assertLine(i.edges[1], pt0, pt1)
self.assertLine(i.edges[2], pt1, pt2)
self.assertLine(i.edges[3], pt2, pt3)
self.assertLine(i.edges[4], pt3, pt4)
self.assertLine(i.edges[5], pt4, pt5)
self.assertLine(i.edges[6], pt5, pt6)
self.assertLine(i.edges[7], pt6, pt7)
self.assertTrue(i.isComplete())
p0 = Vector(4, 0, 0)
p1 = Vector(2, 0, 2)
p2 = Vector(1, 0, 3)
p3 = Vector(0.5, 0, 3)
p4 = Vector(-0.5, 0, 3)
p5 = Vector(-1, 0, 3)
p6 = Vector(-2, 0, 2)
p7 = Vector(-4, 0, 0)
self.assertLines(i.edges, i.tail, [e0.Curve.StartPoint, p0, p1, p2, p3, p4, p5, p6, p7, e6.Curve.EndPoint])
self.assertIsNotNone(i.tail)
self.assertLine(i.tail, pt7, e6.Curve.EndPoint)
def test07(self):
def test06(self):
"""Verify intersection for different z levels."""
tag = Tag( 0, 0, 8, 3, 45, True, 0)
# for all lines below 3 we get the trapezoid
@ -786,7 +543,7 @@ class TestTag03AngledTag(TagTestCaseBase): # =============
edge = Part.Edge(Part.Line(p0, p5))
s = tag.intersect(edge)
self.assertTrue(s.isComplete())
self.assertTrapezoid(s.edges, s.tail, [p0, p1, p2, p3, p4, p5])
self.assertLines(s.edges, s.tail, [p0, p1, p2, p3, p4, p5])
# for all edges at height or above the original line is used
for i in range(3, 5):
@ -795,3 +552,88 @@ class TestTag03AngledTag(TagTestCaseBase): # =============
self.assertTrue(s.isComplete())
self.assertLine(s.tail, edge.Curve.StartPoint, edge.Curve.EndPoint)
class TestTag04TriangularTag(TagTestCaseBase): # ========================
"""Unit tests for tags that take on a triangular shape."""
def test00(self):
"""Verify intersection of triangular tag with line ending at tag start."""
tag = Tag( 0, 0, 8, 7, 45, True, 0)
edge = Part.Edge(Part.Line(Vector(5, 0, 0), Vector(4, 0, 0)))
i = tag.intersect(edge)
self.assertEqual(i.state, Tag.Intersection.P0)
self.assertEqual(len(i.edges), 1)
self.assertLine(i.edges[0], edge.Curve.StartPoint, edge.Curve.EndPoint)
self.assertIsNone(i.tail)
def test01(self):
"""Verify intersection of triangular tag with line ending between P0 and P1."""
tag = Tag( 0, 0, 8, 7, 45, True, 0)
edge = Part.Edge(Part.Line(Vector(5, 0, 0), Vector(3, 0, 0)))
i = tag.intersect(edge)
self.assertEqual(i.state, Tag.Intersection.P0)
p1 = Vector(4, 0, 0)
p2 = Vector(3, 0, 1)
self.assertLines(i.edges, i.tail, [edge.Curve.StartPoint, p1, p2])
self.assertIsNone(i.tail)
# verify we stay in P1 if we add another segment
edge = Part.Edge(Part.Line(edge.Curve.EndPoint, Vector(1, 0, 0)))
i = i.intersect(edge)
self.assertEqual(i.state, Tag.Intersection.P0)
self.assertEqual(len(i.edges), 3)
p3 = Vector(1, 0, 3)
self.assertLine(i.edges[2], p2, p3)
self.assertIsNone(i.tail)
def test02(self):
"""Verify proper down plunge on exit of triangular tag."""
tag = Tag( 0, 0, 8, 7, 45, True, 0)
p0 = Vector(5, 0, 0)
p1 = Vector(4, 0, 0)
p2 = Vector(0, 0, 4)
edge = Part.Edge(Part.Line(p0, FreeCAD.Vector(0,0,0)))
i = tag.intersect(edge)
self.assertEqual(i.state, Tag.Intersection.P2)
self.assertEqual(len(i.edges), 2)
self.assertLines(i.edges, i.tail, [p0, p1, p2])
# adding another segment doesn't make a difference
edge = Part.Edge(Part.Line(edge.Curve.EndPoint, FreeCAD.Vector(-3,0,0)))
i = i.intersect(edge)
self.assertEqual(i.state, Tag.Intersection.P2)
self.assertEqual(len(i.edges), 3)
p3 = Vector(-3, 0, 1)
self.assertLines(i.edges, i.tail, [p0, p1, p2, p3])
# same result if all is one line
edge = Part.Edge(Part.Line(p0, edge.Curve.EndPoint))
i = tag.intersect(edge)
self.assertEqual(i.state, Tag.Intersection.P2)
self.assertLines(i.edges, i.tail, [p0, p1, p2, p3])
def test03(self):
"""Verify triangular tag shap on intersection."""
tag = Tag( 0, 0, 8, 7, 45, True, 0)
p0 = Vector(5, 0, 0)
p1 = Vector(4, 0, 0)
p2 = Vector(0, 0, 4)
p3 = Vector(-4, 0, 0)
edge = Part.Edge(Part.Line(p0, p3))
i = tag.intersect(edge)
self.assertTrue(i.isComplete())
self.assertLines(i.edges, i.tail, [p0, p1, p2, p3])
self.assertIsNone(i.tail)
# this should also work if there is some excess, aka tail
p4 = Vector(-5, 0, 0)
edge = Part.Edge(Part.Line(p0, p4))
i = tag.intersect(edge)
self.assertTrue(i.isComplete())
self.assertLines(i.edges, i.tail, [p0, p1, p2, p3, p4])
self.assertIsNotNone(i.tail)

3
src/Mod/Path/TestPathApp.py
View File

@ -29,5 +29,6 @@ from PathTests.TestPathPost import PathPostTestCases
from PathTests.TestPathDressupHoldingTags import TestTag00BasicHolding
from PathTests.TestPathDressupHoldingTags import TestTag01BasicTag
from PathTests.TestPathDressupHoldingTags import TestTag02SquareTag
from PathTests.TestPathDressupHoldingTags import TestTag03AngledTag
from PathTests.TestPathDressupHoldingTags import TestTag03TrapezoidTag
from PathTests.TestPathDressupHoldingTags import TestTag04TriangularTag