def test_closest_distance_2(self):
l1 = svgcuts.Line(svgcuts.Point(1, 2), svgcuts.Point(1, 3))
l2 = svgcuts.Line(svgcuts.Point(3, 3.5), svgcuts.Point(5, 1.5))
self.assertAlmostEqual(l1.closest_distance(l2),
math.sqrt(4 + math.pow(0.5, 2)))
self.assertAlmostEqual(l2.closest_distance(l1),
math.sqrt(4 + math.pow(0.5, 2)))
def test_aligned_vert_nonintersect(self):
p1 = svgcuts.Point(0, 0)
p2 = svgcuts.Point(0, 1)
p3 = svgcuts.Point(0, 2)
p4 = svgcuts.Point(0, 3)
l1 = svgcuts.Line(p1, p2)
l2 = svgcuts.Line(p3, p4)
self.assertFalse(l1.intersects(l2))
self.assertFalse(l2.intersects(l1))
def test_aligned_hor_nonintersect(self):
p1 = svgcuts.Point(0, 0)
p2 = svgcuts.Point(1, 0)
p3 = svgcuts.Point(2, 0)
p4 = svgcuts.Point(3, 0)
l1 = svgcuts.Line(p1, p2)
l2 = svgcuts.Line(p3, p4)
self.assertFalse(l1.intersects(l2))
self.assertFalse(l2.intersects(l1))
def test_crosses2(self):
p1 = svgcuts.Point(1, 0)
p2 = svgcuts.Point(1, 2)
p3 = svgcuts.Point(0, 1)
p4 = svgcuts.Point(2, 1)
l1 = svgcuts.Line(p1, p2)
l2 = svgcuts.Line(p3, p4)
self.assertTrue(l1.intersects(l2))
self.assertTrue(l2.intersects(l1))
def test_crosses3(self):
p1 = svgcuts.Point(0, 0)
p2 = svgcuts.Point(2, 3)
p3 = svgcuts.Point(1, 1)
p4 = svgcuts.Point(3, 4)
l1 = svgcuts.Line(p1, p2)
l2 = svgcuts.Line(p3, p4)
self.assertFalse(l1.intersects(l2))
self.assertFalse(l2.intersects(l1))
def test_slope_offset(self):
s, i = svgcuts.Line(svgcuts.Point(1, 1), svgcuts.Point(2,
3)).slope_offset
self.assertAlmostEqual(s, 2.0)
self.assertAlmostEqual(i, -1.0)
s, i = svgcuts.Line(svgcuts.Point(1, 1), svgcuts.Point(3,
4)).slope_offset
self.assertAlmostEqual(s, 1.5)
self.assertAlmostEqual(i, -0.5)
def test_basic_render(self):
l = svgcuts.Layer(4, 6, unit='in')
l.add_line(svgcuts.Line(svgcuts.Point(1, 1), svgcuts.Point(2, 2)))
svg = l.render()
#print svg
self.assertTrue('height="6.000000in"' in svg)
for d in ['x', 'y']:
for n in [1, 2]:
self.assertTrue('%s%d=\'%d.00' % (d, n, n) in svg)
self.assertTrue('<line' in svg)
def test_crosses_intersection_point2(self):
p1 = svgcuts.Point(0, 0)
p2 = svgcuts.Point(3, 3)
p3 = svgcuts.Point(1, 0)
p4 = svgcuts.Point(1, 3)
l1 = svgcuts.Line(p1, p2)
l2 = svgcuts.Line(p3, p4)
for d in [False, True]:
if d:
l1, l2 = l2, l1
pinter = l1.intersects(l2, return_intersection_point=True)
self.assertTrue(bool(pinter))
self.assertAlmostEqual(pinter.x, 1.0)
self.assertAlmostEqual(pinter.y, 1.0)
def test_slices_layer(self):
p1 = svgcuts.Point(0, 0)
p2 = svgcuts.Point(3, 3)
p3 = svgcuts.Point(1, 0)
p4 = svgcuts.Point(1, 3)
l1 = svgcuts.Line(p1, p2)
l2 = svgcuts.Line(p3, p4)
layer = svgcuts.Layer(3, 3, unit='in')
layer.add_line(l1)
layer.add_line(l2)
self.assertEquals(len(layer.lines), 2)
new_layer = layer.slice_lines()
self.assertEquals(len(new_layer.lines), 4)
def project_point(self, a):
print 'projecting a point: %s' % a.pf
# this goes from a stereololography point to an svgcuts point.
# all stl points are already in millimeters.
# math taken from the wikipedia page on 3d perspective projection
dx = math.cos(self.t[1]) * (math.sin(self.t[2]) *
(a.y - self.c.y) + math.cos(self.t[2]) *
(a.x - self.c.x)) - math.sin(
self.t[1]) * (a.z - self.c.z)
dy = math.sin(self.t[0]) * (math.cos(self.t[1]) *
(a.z - self.c.z) + math.sin(self.t[1]) *
(math.sin(self.t[2]) *
(a.y - self.c.y) + math.cos(self.t[2]) *
(a.x - self.c.x))) + math.cos(
self.t[0]) * (math.cos(self.t[2]) *
(a.y - self.c.y) -
math.sin(self.t[2]) *
(a.x - self.c.x))
dz = math.cos(self.t[0]) * (math.cos(self.t[1]) *
(a.z - self.c.z) + math.sin(self.t[1]) *
(math.sin(self.t[2]) *
(a.y - self.c.y) + math.cos(self.t[2]) *
(a.x - self.c.x))) - math.sin(
self.t[0]) * (math.cos(self.t[2]) *
(a.y - self.c.y) -
math.sin(self.t[2]) *
(a.x - self.c.x))
print 'd: <%f, %f, %f>' % (dx, dy, dz)
ex = self.e[0]
ey = self.e[1]
ez = self.e[2]
bx = (dx - ex) * (ez / dz)
by = (dy - ey) * (ez / dz)
print 'b: <%f, %f>' % (bx, by)
return svgcuts.Point(bx, by)
def test_angle(self):
self.assertAlmostEqual(
svgcuts.Line(svgcuts.Point(0, 0), svgcuts.Point(1, 1)).angle,
math.pi / 4.0)
self.assertAlmostEqual(
svgcuts.Line(svgcuts.Point(0, 0), svgcuts.Point(0, 1)).angle,
math.pi / 2.0)
self.assertAlmostEqual(
svgcuts.Line(svgcuts.Point(0, 0), svgcuts.Point(0, -1)).angle,
math.pi / -2.0)
self.assertAlmostEqual(
svgcuts.Line(svgcuts.Point(0, 0.5), svgcuts.Point(1, 1)).angle,
0.46364760900080609)
self.assertAlmostEqual(
svgcuts.Line(svgcuts.Point(0, 0), svgcuts.Point(-1, 1)).angle,
math.pi * 3.0 / 4.0)
self.assertAlmostEqual(
svgcuts.Line(svgcuts.Point(0, 0), svgcuts.Point(-1, -1)).angle,
math.pi * -3.0 / 4.0)
self.assertAlmostEqual(
svgcuts.Line(svgcuts.Point(0, 0), svgcuts.Point(1, 0)).angle, 0.0)
self.assertAlmostEqual(
svgcuts.Line(svgcuts.Point(0, 0), svgcuts.Point(1, -1)).angle,
math.pi * -1.0 / 4.0)
value = 0
return {'x': x, 'y': y, 'main': main, 'rev': rev, 'value': value}
pattern = svgcuts.Layer(24, 12, unit=unit)
a = svgcuts.Layer(24, 12, unit=unit)
b = svgcuts.Layer(24, 12, unit=unit)
# make pattern
xd = pad * 2 + edge * cols
yd = pad * 2 + edge * rows
ps = [
svgcuts.Point(pad, pad),
svgcuts.Point(pad, pad + yd),
svgcuts.Point(pad + xd, pad + yd),
svgcuts.Point(pad + xd, pad)
]
for n in range(4):
pattern.add_line(svgcuts.Line(ps[n], ps[(n + 1) % 4], unit=unit))
# make squares
# position an identity corner (upper left corner of a square)
def xy2p(x, y, xadg=0.0, yadg=0.0):
_x = pad + x * edge + xadg
def test_linelen(self):
p1 = svgcuts.Point(0, 0)
p2 = svgcuts.Point(2, 3)
l = svgcuts.Line(p1, p2)
self.assertAlmostEqual(l.length, 3.60555127546398929312)
def test_incidental_angle_with_common_points(self):
l1 = svgcuts.Line(svgcuts.Point(1, 1), svgcuts.Point(2, 2))
l2 = svgcuts.Line(svgcuts.Point(1, 1), svgcuts.Point(0, 2))
self.assertAlmostEqual(l1.incident_angle(l2), math.pi / 2.0)
l1 = svgcuts.Line(svgcuts.Point(1, 1), svgcuts.Point(2, 2))
self.assertAlmostEqual(l1.incident_angle(l1), 0.0)
l1 = svgcuts.Line(svgcuts.Point(2, 2), svgcuts.Point(1, 1))
l2 = svgcuts.Line(svgcuts.Point(2, 2), svgcuts.Point(3, 2))
self.assertAlmostEqual(l1.incident_angle(l2), math.pi * 3.0 / 4.0)
l1 = svgcuts.Line(svgcuts.Point(1, 1), svgcuts.Point(2, 2))
self.assertAlmostEqual(l1.incident_angle(l2), math.pi * 3.0 / 4.0)
def test_incidental_angle_without_common_points(self):
l1 = svgcuts.Line(svgcuts.Point(0, 2), svgcuts.Point(2, 4))
l2 = svgcuts.Line(svgcuts.Point(4, 5), svgcuts.Point(5, 5))
l3a = svgcuts.Line(svgcuts.Point(3, 3.999), svgcuts.Point(4, 3.999))
l3b = svgcuts.Line(svgcuts.Point(3, 4), svgcuts.Point(4, 4))
l3c = svgcuts.Line(svgcuts.Point(3, 4.001), svgcuts.Point(4, 4.001))
l4 = svgcuts.Line(svgcuts.Point(3, 3), svgcuts.Point(4, 3))
l5 = svgcuts.Line(svgcuts.Point(1, 2), svgcuts.Point(3, 4))
self.assertAlmostEqual(l1.incident_angle(l2), math.pi * 3.0 / 4.0)
# TODO add ones for l3*
self.assertAlmostEqual(l1.incident_angle(l4), math.pi * 1.0 / 4.0)
# incident angle should be pi, even if they never touch..?
self.assertAlmostEqual(l1.incident_angle(l5), math.pi)
def test_closest_distance_1(self):
l1 = svgcuts.Line(svgcuts.Point(0, 2), svgcuts.Point(2, 4))
l2 = svgcuts.Line(svgcuts.Point(4, 5), svgcuts.Point(5, 5))
self.assertAlmostEqual(l1.closest_distance(l2), math.sqrt(5))
self.assertAlmostEqual(l2.closest_distance(l1), math.sqrt(5))
def xy2p(x, y, xadg=0.0, yadg=0.0):
_x = pad + x * edge + xadg
_y = pad + y * edge + yadg
return svgcuts.Point(_x, _y)
def test_closest_distance_4(self):
l1 = svgcuts.Line(svgcuts.Point(0, 1), svgcuts.Point(1, 2))
l2 = svgcuts.Line(svgcuts.Point(1, 4), svgcuts.Point(3, 2))
self.assertAlmostEqual(l2.closest_distance(l1), math.sqrt(2))
def test_closest_distance_3(self):
l1 = svgcuts.Line(svgcuts.Point(1, 1), svgcuts.Point(1, 3))
l2 = svgcuts.Line(svgcuts.Point(4, 3), svgcuts.Point(2, 1.5))
self.assertAlmostEqual(l1.closest_distance(l2), 1.0)
self.assertAlmostEqual(l2.closest_distance(l1), 1.0)
