1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
|
import sys
if sys.path[0] != "../..":
sys.path.insert(0, "../..")
import unittest
from pyx import *
from pyx.path import *
from pyx.normpath import normpathparam
import math
set(epsilon=1e-7)
class NormpathTestCase(unittest.TestCase):
def assertAlmostEqualNormsubpathitem(self, nspi1, nspi2):
if isinstance(nspi1, normline_pt):
assert isinstance(nspi2, normline_pt), "%s != %s" % (nspi1, nspi2)
self.assertAlmostEqual(nspi1.x0_pt, nspi2.x0_pt)
self.assertAlmostEqual(nspi1.y0_pt, nspi2.y0_pt)
self.assertAlmostEqual(nspi1.x1_pt, nspi2.x1_pt)
self.assertAlmostEqual(nspi1.y1_pt, nspi2.y1_pt)
else:
assert isinstance(nspi1, normcurve_pt), "%s != %s" % (nspi1, nspi2)
assert isinstance(nspi2, normcurve_pt), "%s != %s" % (nspi1, nspi2)
self.assertAlmostEqual(nspi1.x0_pt, nspi2.x0_pt)
self.assertAlmostEqual(nspi1.y0_pt, nspi2.y0_pt)
self.assertAlmostEqual(nspi1.x1_pt, nspi2.x1_pt)
self.assertAlmostEqual(nspi1.y1_pt, nspi2.y1_pt)
self.assertAlmostEqual(nspi1.x2_pt, nspi2.x2_pt)
self.assertAlmostEqual(nspi1.y2_pt, nspi2.y2_pt)
self.assertAlmostEqual(nspi1.x3_pt, nspi2.x3_pt)
self.assertAlmostEqual(nspi1.y3_pt, nspi2.y3_pt)
def assertAlmostEqualNormsubpath(self, nsp1, nsp2):
assert len(nsp1) == len(nsp2), "%s != %s" % (nsp1, nsp2)
assert nsp1.closed == nsp2.closed, "%s != %s" % (nsp1, nsp2)
for nspi1, nspi2 in zip(nsp1, nsp2):
self.assertAlmostEqualNormsubpathitem(nspi1, nspi2)
def assertAlmostEqualNormpath(self, np1, np2):
assert len(np1) == len(np2), "%s != %s" % (np1, np2)
for nsp1, nsp2 in zip(np1, np2):
self.assertAlmostEqualNormsubpath(nsp1, nsp2)
def testparam(self):
p = ( normpath([normsubpath([normline_pt(0, 0, 10, 0),
normline_pt(10, 0, 10, 20),
normline_pt(10, 20, 0, 20),
normline_pt(0, 20, 0, 0)], closed=1)]) +
circle_pt(0, 0, 10) +
line_pt(0, 0, 2, 0))
param = normpathparam(p, 0, 1.5)
param = param + 0
self.assertEqual(param.normsubpathindex, 0)
self.assertAlmostEqual(param.normsubpathparam, 1.5)
param = param + 15 * unit.t_pt
self.assertEqual(param.normsubpathindex, 0)
self.assertAlmostEqual(param.normsubpathparam, 2.5)
param += 24.9 * unit.t_pt
self.assertEqual(param.normsubpathindex, 0)
self.assertAlmostEqual(param.normsubpathparam, 3.995)
param = 0.1 * unit.t_pt + param
self.assertEqual(param.normsubpathindex, 1)
self.assertAlmostEqual(param.normsubpathparam, 0)
param = param + 0.5*circle_pt(0, 0, 10).arclen()
circlerange = len(p.normsubpaths[1])
self.assertEqual(param.normsubpathindex, 1)
self.assertAlmostEqual(param.normsubpathparam, 0.5*circlerange, 4)
param = param + 0.5*circle_pt(0, 0, 10).arclen()
param = param + 2 * unit.t_pt
self.assertEqual(param.normsubpathindex, 2)
self.assertAlmostEqual(param.normsubpathparam, 1, 4)
param = param + 1 * unit.t_pt
self.assertEqual(param.normsubpathindex, 2)
self.assertAlmostEqual(param.normsubpathparam, 1.5, 4)
param = normpathparam(p, 0, 1.5)
param = param - 15 * unit.t_pt
self.assertEqual(param.normsubpathindex, 0)
self.assertAlmostEqual(param.normsubpathparam, 0.5)
param -= 10 * unit.t_pt
self.assertEqual(param.normsubpathindex, 0)
self.assertAlmostEqual(param.normsubpathparam, -0.5)
param = normpathparam(p, 0, 1.2)
param2 = 2*param
param += param
self.assertEqual(param.normsubpathindex, param2.normsubpathindex)
self.assertEqual(param.normsubpathparam, param2.normsubpathparam)
param = normpathparam(p, 0, 1.2)
self.assertTrue(param < 15 * unit.t_pt)
self.assertTrue(15 * unit.t_pt > param)
self.assertTrue(param > 12 * unit.t_pt)
self.assertTrue(12 * unit.t_pt < param)
self.assertTrue(param < 1)
self.assertTrue(1 > param)
def testat(self):
p = normpath([normsubpath([normline_pt(0, 0, 10, 0),
normline_pt(10, 0, 10, 20),
normline_pt(10, 20, 0, 20),
normline_pt(0, 20, 0, 0)], closed=1)])
params = [-5, 0, 5, 10, 20, 30, 35, 40, 50, 60, 70]
ats = (-5, 0), (0, 0), (5, 0), (10, 0), (10, 10), (10, 20), (5, 20), (0, 20), (0, 10), (0, 0), (0, -10)
for param, (at_x, at_y) in zip(params, ats):
self.assertAlmostEqual(p.at_pt(param)[0], at_x)
self.assertAlmostEqual(p.at_pt(param)[1], at_y)
for (at_x, at_y), (at2_x, at2_y) in zip(p.at_pt(params), ats):
self.assertAlmostEqual(at_x, at2_x)
self.assertAlmostEqual(at_y, at2_y)
p = normpath([normsubpath([normline_pt(0, 0, 3, 0),
normcurve_pt(3, 0, 3, 2, 3, 4, 3, 6),
normcurve_pt(3, 6, 2, 6, 1, 6, 0, 6),
normline_pt(0, 6, 0, 0)], closed=1)])
self.assertAlmostEqual(p.at_pt(6)[0], 3)
self.assertAlmostEqual(p.at_pt(6)[1], 3)
self.assertAlmostEqual(p.at_pt(4.5)[0], 3)
self.assertAlmostEqual(p.at_pt(4.5)[1], 1.5)
def testarclentoparam(self):
p = ( normpath([normsubpath([normline_pt(0, 0, 10, 0),
normline_pt(10, 0, 10, 20),
normline_pt(10, 20, 0, 20),
normline_pt(0, 20, 0, 0)], closed=1)]) +
circle_pt(0, 0, 10) +
line_pt(0, 0, 2, 0))
arclens_pt = [20, 30, -2, 61, 100, 200, -30, 1000]
for arclen_pt, arclen2_pt in zip(arclens_pt, p.paramtoarclen_pt(p.arclentoparam_pt(arclens_pt))):
self.assertAlmostEqual(arclen_pt, arclen2_pt, 4)
arclens = [x*unit.t_pt for x in [20, 30, -2, 61, 100, 200, -30, 1000]]
for arclen, arclen2 in zip(arclens, p.paramtoarclen(p.arclentoparam(arclens))):
self.assertAlmostEqual(unit.tom(arclen), unit.tom(arclen2), 4)
def testsplit(self):
p = normline_pt(0, 0, 10, 0)
self.assertRaises(ValueError, p.segments, [])
self.assertRaises(ValueError, p.segments, [0.2])
s = p.segments([0.2, 0.8])
self.assertEqual(len(s), 1)
self.assertAlmostEqualNormsubpathitem(s[0], normline_pt(2, 0, 8, 0))
s = p.segments([-0.2, 1.8])
self.assertEqual(len(s), 1)
self.assertAlmostEqualNormsubpathitem(s[0], normline_pt(-2, 0, 18, 0))
p = normcurve_pt(0, 0, 10, 0, 20, 0, 30, 0)
self.assertRaises(ValueError, p.segments, [])
self.assertRaises(ValueError, p.segments, [0.2])
s = p.segments([0.2, 0.8])
self.assertEqual(len(s), 1)
self.assertAlmostEqualNormsubpathitem(s[0], normcurve_pt(6, 0, 12, 0, 18, 0, 24, 0))
s = p.segments([-0.2, 1.8])
self.assertEqual(len(s), 1)
self.assertAlmostEqualNormsubpathitem(s[0], normcurve_pt(-6, 0, 14, 0, 34, 0, 54, 0))
p = normsubpath([normline_pt(0, 0, 1, 0),
normline_pt(1, 0, 1, 1),
normline_pt(1, 1, 0, 1),
normline_pt(0, 1, 0, 0)])
self.assertRaises(ValueError, p.segments, [])
self.assertRaises(ValueError, p.segments, [0.2])
s = p.segments([0.5, 2.5])
self.assertEqual(len(s), 1)
self.assertAlmostEqualNormsubpath(s[0], normsubpath([normline_pt(0.5, 0, 1, 0), normline_pt(1, 0, 1, 1), normline_pt(1, 1, 0.5, 1)]))
s = p.segments([4.5, -1])
self.assertEqual(len(s), 1)
self.assertAlmostEqualNormsubpath(s[0], normsubpath([normline_pt(0, -0.5, 0, 1), normline_pt(0, 1, 1, 1), normline_pt(1, 1, 1, 0), normline_pt(1, 0, -1, 0)]))
s = p.segments([0, 0.1, 1.2, 1.3, 3.4, 0.5, 4])
self.assertEqual(len(s), 6)
self.assertAlmostEqualNormsubpath(s[0], normsubpath([normline_pt(0, 0, 0.1, 0)]))
self.assertAlmostEqualNormsubpath(s[1], normsubpath([normline_pt(0.1, 0, 1, 0), normline_pt(1, 0, 1, 0.2)]))
self.assertAlmostEqualNormsubpath(s[2], normsubpath([normline_pt(1, 0.2, 1, 0.3)]))
self.assertAlmostEqualNormsubpath(s[3], normsubpath([normline_pt(1, 0.3, 1, 1), normline_pt(1, 1, 0, 1), normline_pt(0, 1, 0, 0.6)]))
self.assertAlmostEqualNormsubpath(s[4], normsubpath([normline_pt(0, 0.6, 0, 1), normline_pt(0, 1, 1, 1), normline_pt(1, 1, 1, 0), normline_pt(1, 0, 0.5, 0)]))
self.assertAlmostEqualNormsubpath(s[5], normsubpath([normline_pt(0.5, 0, 1, 0), normline_pt(1, 0, 1, 1), normline_pt(1, 1, 0, 1), normline_pt(0, 1, 0, 0)]))
p = normsubpath([normline_pt(0, 0, 1, 0),
normline_pt(1, 0, 1, 1),
normline_pt(1, 1, 0, 1)], closed=1)
self.assertRaises(ValueError, p.segments, [])
self.assertRaises(ValueError, p.segments, [0.5])
s = p.segments([0.5, 2.5])
self.assertEqual(len(s), 1)
self.assertAlmostEqualNormsubpath(s[0], normsubpath([normline_pt(0.5, 0, 1, 0), normline_pt(1, 0, 1, 1), normline_pt(1, 1, 0.5, 1)]))
s = p.segments([4.5, -1])
self.assertEqual(len(s), 1)
self.assertAlmostEqualNormsubpath(s[0], normsubpath([normline_pt(0, -0.5, 0, 1), normline_pt(0, 1, 1, 1), normline_pt(1, 1, 1, 0), normline_pt(1, 0, -1, 0)]))
s = p.segments([0, 0.1, 1.2, 1.3, 3.4, 0.5, 4])
self.assertEqual(len(s), 5)
self.assertAlmostEqualNormsubpath(s[0], normsubpath([normline_pt(0.5, 0, 1, 0), normline_pt(1, 0, 1, 1), normline_pt(1, 1, 0, 1), normline_pt(0, 1, 0, 0), normline_pt(0, 0, 0.1, 0)]))
self.assertAlmostEqualNormsubpath(s[1], normsubpath([normline_pt(0.1, 0, 1, 0), normline_pt(1, 0, 1, 0.2)]))
self.assertAlmostEqualNormsubpath(s[2], normsubpath([normline_pt(1, 0.2, 1, 0.3)]))
self.assertAlmostEqualNormsubpath(s[3], normsubpath([normline_pt(1, 0.3, 1, 1), normline_pt(1, 1, 0, 1), normline_pt(0, 1, 0, 0.6)]))
self.assertAlmostEqualNormsubpath(s[4], normsubpath([normline_pt(0, 0.6, 0, 1), normline_pt(0, 1, 1, 1), normline_pt(1, 1, 1, 0), normline_pt(1, 0, 0.5, 0)]))
s = p.segments([4, 0.1, 1.2, 1.3, 3.4, 0.5, 0])
self.assertEqual(len(s), 5)
self.assertAlmostEqualNormsubpath(s[0], normsubpath([normline_pt(0.5, 0, 0, 0), normline_pt(0, 0, 0, 1), normline_pt(0, 1, 1, 1), normline_pt(1, 1, 1, 0), normline_pt(1, 0, 0.1, 0)]))
self.assertAlmostEqualNormsubpath(s[1], normsubpath([normline_pt(0.1, 0, 1, 0), normline_pt(1, 0, 1, 0.2)]))
self.assertAlmostEqualNormsubpath(s[2], normsubpath([normline_pt(1, 0.2, 1, 0.3)]))
self.assertAlmostEqualNormsubpath(s[3], normsubpath([normline_pt(1, 0.3, 1, 1), normline_pt(1, 1, 0, 1), normline_pt(0, 1, 0, 0.6)]))
self.assertAlmostEqualNormsubpath(s[4], normsubpath([normline_pt(0, 0.6, 0, 1), normline_pt(0, 1, 1, 1), normline_pt(1, 1, 1, 0), normline_pt(1, 0, 0.5, 0)]))
p = normpath([normsubpath([normline_pt(0, 0, 1, 0), normline_pt(1, 0, 2, 0), normline_pt(2, 0, 3, 0), normline_pt(3, 0, 4, 0)]),
normsubpath([normline_pt(0, 1, 1, 1), normline_pt(1, 1, 2, 1), normline_pt(2, 1, 3, 1), normline_pt(3, 1, 4, 1)]),
normsubpath([normline_pt(0, 2, 1, 2), normline_pt(1, 2, 2, 2), normline_pt(2, 2, 3, 2), normline_pt(3, 2, 4, 2)]),
normsubpath([normline_pt(0, 3, 1, 3), normline_pt(1, 3, 2, 3), normline_pt(2, 3, 3, 3), normline_pt(3, 3, 4, 3)]),
normsubpath([normline_pt(0, 4, 1, 4), normline_pt(1, 4, 2, 4), normline_pt(2, 4, 3, 4), normline_pt(3, 4, 4, 4)])])
s = p.split([normpathparam(p, 3, 0.1),
normpathparam(p, 4, 1.2),
normpathparam(p, 2, 2.3),
normpathparam(p, 0, 3.4),
normpathparam(p, 1, 0.5)])
self.assertEqual(len(s), 6)
self.assertAlmostEqualNormpath(s[0], normpath([normsubpath([normline_pt(0, 0, 1, 0), normline_pt(1, 0, 2, 0), normline_pt(2, 0, 3, 0), normline_pt(3, 0, 4, 0)]),
normsubpath([normline_pt(0, 1, 1, 1), normline_pt(1, 1, 2, 1), normline_pt(2, 1, 3, 1), normline_pt(3, 1, 4, 1)]),
normsubpath([normline_pt(0, 2, 1, 2), normline_pt(1, 2, 2, 2), normline_pt(2, 2, 3, 2), normline_pt(3, 2, 4, 2)]),
normsubpath([normline_pt(0, 3, 0.1, 3)])]))
self.assertAlmostEqualNormpath(s[1], normpath([normsubpath([normline_pt(0.1, 3, 1, 3), normline_pt(1, 3, 2, 3), normline_pt(2, 3, 3, 3), normline_pt(3, 3, 4, 3)]),
normsubpath([normline_pt(0, 4, 1, 4), normline_pt(1, 4, 1.2, 4)])]))
self.assertAlmostEqualNormpath(s[2], normpath([normsubpath([normline_pt(1.2, 4, 1, 4), normline_pt(1, 4, 0, 4)]),
normsubpath([normline_pt(4, 3, 3, 3), normline_pt(3, 3, 2, 3), normline_pt(2, 3, 1, 3), normline_pt(1, 3, 0, 3)]),
normsubpath([normline_pt(4, 2, 3, 2), normline_pt(3, 2, 2.3, 2)])]))
self.assertAlmostEqualNormpath(s[3], normpath([normsubpath([normline_pt(2.3, 2, 2, 2), normline_pt(2, 2, 1, 2), normline_pt(1, 2, 0, 2)]),
normsubpath([normline_pt(4, 1, 3, 1), normline_pt(3, 1, 2, 1), normline_pt(2, 1, 1, 1), normline_pt(1, 1, 0, 1)]),
normsubpath([normline_pt(4, 0, 3.4, 0)])]))
self.assertAlmostEqualNormpath(s[4], normpath([normsubpath([normline_pt(3.4, 0, 4, 0)]),
normsubpath([normline_pt(0, 1, 0.5, 1)])]))
self.assertAlmostEqualNormpath(s[5], normpath([normsubpath([normline_pt(0.5, 1, 1, 1), normline_pt(1, 1, 2, 1), normline_pt(2, 1, 3, 1), normline_pt(3, 1, 4, 1)]),
normsubpath([normline_pt(0, 2, 1, 2), normline_pt(1, 2, 2, 2), normline_pt(2, 2, 3, 2), normline_pt(3, 2, 4, 2)]),
normsubpath([normline_pt(0, 3, 1, 3), normline_pt(1, 3, 2, 3), normline_pt(2, 3, 3, 3), normline_pt(3, 3, 4, 3)]),
normsubpath([normline_pt(0, 4, 1, 4), normline_pt(1, 4, 2, 4), normline_pt(2, 4, 3, 4), normline_pt(3, 4, 4, 4)])]))
p = normpath([normsubpath([normline_pt(0, -5, 1, -5)]),
normsubpath([normline_pt(0, 0, 1, 0), normline_pt(1, 0, 1, 1), normline_pt(1, 1, 0, 1)], closed=1),
normsubpath([normline_pt(0, 5, 1, 5)])])
s = p.split([normpathparam(p, 1, 3.5)])
self.assertEqual(len(s), 1)
self.assertAlmostEqualNormpath(s[0], normpath([normsubpath([normline_pt(0, -5, 1, -5)]),
normsubpath([normline_pt(0, 0.5, 0, 0), normline_pt(0, 0, 1, 0), normline_pt(1, 0, 1, 1), normline_pt(1, 1, 0, 1), normline_pt(0, 1, 0, 0.5)]),
normsubpath([normline_pt(0, 5, 1, 5)])]))
p = normpath([normsubpath([normline_pt(0, -5, 1, -5)]),
normsubpath([normline_pt(0, 0, 1, 0), normline_pt(1, 0, 1, 1), normline_pt(1, 1, 0, 1)], closed=1),
normsubpath([normline_pt(0, 5, 1, 5)])])
s = p.split([normpathparam(p, 0, 0.5),
normpathparam(p, 1, 3.5),
normpathparam(p, 0, 0.5),
normpathparam(p, 2, 0.5)])
self.assertEqual(len(s), 5)
self.assertAlmostEqualNormpath(s[0], normpath([normsubpath([normline_pt(0, -5, 0.5, -5)])]))
self.assertAlmostEqualNormpath(s[1], normpath([normsubpath([normline_pt(0.5, -5, 1, -5)]),
normsubpath([normline_pt(0, 0, 1, 0), normline_pt(1, 0, 1, 1), normline_pt(1, 1, 0, 1), normline_pt(0, 1, 0, 0.5)])]))
# XXX should we do ???: normsubpath([normline_pt(0, 0.5, 0, 0), normline_pt(0, 0, 1, 0), normline_pt(1, 0, 1, 1), normline_pt(1, 1, 0, 1), normline_pt(0, 1, 0, 0.5)])]))
# same question in the next line ...
self.assertAlmostEqualNormpath(s[2], normpath([normsubpath([normline_pt(0, 0.5, 0, 1), normline_pt(0, 1, 1, 1), normline_pt(1, 1, 1, 0), normline_pt(1, 0, 0, 0)]),
normsubpath([normline_pt(1, -5, 0.5, -5)])]))
self.assertAlmostEqualNormpath(s[3], normpath([normsubpath([normline_pt(0.5, -5, 1, -5)]),
normsubpath([normline_pt(0, 0, 1, 0), normline_pt(1, 0, 1, 1), normline_pt(1, 1, 0, 1), normline_pt(0, 1, 0, 0)], closed=1),
normsubpath([normline_pt(0, 5, 0.5, 5)])]))
self.assertAlmostEqualNormpath(s[4], normpath([normsubpath([normline_pt(0.5, 5, 1, 5)])]))
def testshortnormsubpath(self):
sp = normsubpath(epsilon=1)
sp.append(normline_pt(0, 0, 0.5, 0))
sp.append(normline_pt(0.5, 0, 1.5, 0))
sp.append(normline_pt(1.5, 0, 1.5, 0.3))
sp.append(normline_pt(1.5, 0.3, 1.5, 0.6))
sp.append(normline_pt(1.5, 0.6, 1.5, 0.9))
sp.append(normline_pt(1.5, 0.9, 1.5, 1.2))
sp.append(normline_pt(1.5, 1.2, 1.3, 1.6))
sp.append(normcurve_pt(1.3, 1.6, 1.4, 1.7, 1.3, 1.7, 1.3, 1.8))
sp.append(normcurve_pt(1.3, 1.8, 4.4, 2.7, 5.3, 5.7, 1.4, 1.8))
self.assertAlmostEqualNormsubpath(sp, normsubpath([normline_pt(0, 0, 1.5, 0), normline_pt(1.5, 0, 1.5, 1.2), normcurve_pt(1.5, 1.2, 4.4, 2.7, 5.3, 5.7, 1.4, 1.8)]))
def testcuspremoval(self):
self.assertAlmostEqualNormsubpath(normsubpath([normcurve_pt(0, 0, 5, 5, 0, 5, 5, 0)], epsilon=1),
normsubpath([normcurve_pt(0, 0, 2.5, 2.5, 2.5, 3.405172413793103, 2.5, 3.75), normcurve_pt(2.5, 3.75, 2.5, 3.405172413793103, 2.5, 2.5, 5, 0)], epsilon=None))
def testintersectnormsubpath(self):
smallposy = 0.09
smallnegy = -0.01
p1 = normsubpath([normline_pt(-1, 0, 1, 0)])
p2 = normsubpath([normline_pt(0, smallposy, 0, smallnegy),
normline_pt(0, smallnegy, 0, 1+smallnegy),
normline_pt(0, 1+smallnegy, 0, smallnegy),
normline_pt(0, smallnegy, 0, smallposy)], closed=0)
p1.epsilon = p2.epsilon = 0.05
intersect = p2.intersect(p1)
self.assertEqual(len(intersect[0]), 2)
self.assertAlmostEqual(intersect[0][0], 0.9)
self.assertAlmostEqual(intersect[0][1], 2.99)
smallposy = 0.09
smallnegy = -0.01
p1 = normsubpath([normline_pt(-1, 0, 1, 0)])
p2 = normsubpath([normline_pt(0, smallposy, 0, smallnegy),
normline_pt(0, smallnegy, 0, 1+smallnegy),
normline_pt(0, 1+smallnegy, 0, smallnegy),
normline_pt(0, smallnegy, 0, smallposy)], closed=1)
p1.epsilon = p2.epsilon = 0.05
intersect = p2.intersect(p1)
self.assertEqual(len(intersect[0]), 2)
self.assertAlmostEqual(intersect[0][0], 0.9)
self.assertAlmostEqual(intersect[0][1], 2.99)
smallposy = 0.01
smallnegy = -0.09
p1 = normsubpath([normline_pt(-1, 0, 1, 0)])
p2 = normsubpath([normline_pt(0, smallposy, 0, smallnegy),
normline_pt(0, smallnegy, 0, 1+smallnegy),
normline_pt(0, 1+smallnegy, 0, smallnegy),
normline_pt(0, smallnegy, 0, smallposy)], closed=0)
p1.epsilon = p2.epsilon = 0.05
intersect = p2.intersect(p1)
self.assertEqual(len(intersect[0]), 4)
self.assertAlmostEqual(intersect[0][0], 0.1)
self.assertAlmostEqual(intersect[0][1], 1.09)
self.assertAlmostEqual(intersect[0][2], 2.91)
self.assertAlmostEqual(intersect[0][3], 3.9)
smallposy = 0.01
smallnegy = -0.09
p1 = normsubpath([normline_pt(-1, 0, 1, 0)])
p2 = normsubpath([normline_pt(0, smallposy, 0, smallnegy),
normline_pt(0, smallnegy, 0, 1+smallnegy),
normline_pt(0, 1+smallnegy, 0, smallnegy),
normline_pt(0, smallnegy, 0, smallposy)], closed=1)
p1.epsilon = p2.epsilon = 0.05
intersect = p2.intersect(p1)
self.assertEqual(len(intersect[0]), 3)
self.assertAlmostEqual(intersect[0][0], 0.1)
self.assertAlmostEqual(intersect[0][1], 1.09)
self.assertAlmostEqual(intersect[0][2], 2.91)
smallposy = 0.01
smallnegy = -0.01
p1 = normsubpath([normline_pt(-1, 0, 1, 0)])
p2 = normsubpath([normline_pt(0, smallposy, 0, smallnegy),
normline_pt(0, smallnegy, 0, 1+smallnegy),
normline_pt(0, 1+smallnegy, 0, smallnegy),
normline_pt(0, smallnegy, 0, smallposy)], closed=0)
p1.epsilon = p2.epsilon = 0.05
intersect = p2.intersect(p1)
self.assertEqual(len(intersect[0]), 2)
self.assertAlmostEqual(intersect[0][0], 0.5)
self.assertAlmostEqual(intersect[0][1], 2.99)
smallposy = 0.01
smallnegy = -0.01
p1 = normsubpath([normline_pt(-1, 0, 1, 0)])
p2 = normsubpath([normline_pt(0, smallposy, 0, smallnegy),
normline_pt(0, smallnegy, 0, 1+smallnegy),
normline_pt(0, 1+smallnegy, 0, smallnegy),
normline_pt(0, smallnegy, 0, smallposy)], closed=1)
p1.epsilon = p2.epsilon = 0.05
intersect = p2.intersect(p1)
self.assertEqual(len(intersect[0]), 1)
self.assertAlmostEqual(intersect[0][0], 0.5)
smallposy = 0.1
smallnegy = -0.1
p1 = normsubpath([normline_pt(-1, 0, 1, 0)])
p2 = normsubpath([normline_pt(0, smallposy, 0, smallnegy),
normline_pt(0, smallnegy, 0, 1+smallnegy),
normline_pt(0, 1+smallnegy, 0, smallnegy),
normline_pt(0, smallnegy, 0, smallposy)], closed=0)
p1.epsilon = p2.epsilon = 0.05
intersect = p2.intersect(p1)
self.assertEqual(len(intersect[0]), 4)
self.assertAlmostEqual(intersect[0][0], 0.5)
self.assertAlmostEqual(intersect[0][1], 1.1)
self.assertAlmostEqual(intersect[0][2], 2.9)
self.assertAlmostEqual(intersect[0][3], 3.5)
if __name__ == "__main__":
unittest.main()
|
