def read_output(self):
self.painter.drawDisplay.ClearCanvas()
filename, _ = QtWidgets.QFileDialog.getOpenFileName()
if filename:
f = open(filename, 'r')
lines = f.readlines()
points = []
_points = []
for l in lines:
t = l.split()
if t[0] == 'P':
#need to create new attribute to save original point set which include duplicates
t1 = int(t[1])
t2 = int(t[2])
p = Point(t1, t2)
_points.append(p)
if p not in self.painter.points:
points.append(p)
self.painter.points.add((Point(t1, t2)))
elif t[0] == 'E':
self.painter.lines.append(
Line(Point(int(t[1]), int(t[2])),
Point(int(t[3]), int(t[4]))))
self.painter.points = points
self.painter._points = _points
for p in _points:
self.painter.drawDisplay.display_points(p)
self.painter.drawDisplay.display_output()
self.painter.update()
f.close()
class Pin:
""" Pins are the parts of Bodies (/symbols/components) that connect
to nets. Basically a line segment, with a null end and a connect end
"""
def __init__(self, pin_number, p1, p2, label=None):
self.label = label # is a Label
self.p1 = Point(p1) # null end
self.p2 = Point(p2) # connect end
self.pin_number = pin_number
def bounds(self):
""" Return the min and max points of a pin """
xs = [self.p1.x, self.p2.x]
ys = [self.p2.y, self.p2.y]
if self.label is not None:
xs += self.label.bounds()[0::2]
ys += self.label.bounds()[1::2]
return [Point(min(xs), min(ys)), Point(max(xs), max(ys))]
def json(self):
""" Return a pin as JSON """
d = {
"pin_number":self.pin_number,
"p1":self.p1.json(),
"p2":self.p2.json()
}
if self.label is not None:
d["label"] = self.label.json()
return d
def prepare(size, polygons_info, start, end):
'''
something neccesary such as construct the whole picture
'''
polygons = generate_polygons(*polygons_info)
for each in polygons:
add_polygon_to_plot(each)
start = Point(start)
end = Point(end)
points = [start]
for polygon in polygons:
points += polygon.vertices
points += [end]
#get successor_and_costs for every points
for i in xrange(len(points)-1):
# -1 for end point does not need to get successor
point_i = points[i]
siblings = [point_i]
belonging = check_belonging(point_i, polygons)
if belonging[0]:
for each in belonging[1]:
point_i.add_successor(each)
siblings = belonging[2].vertices
for other_point in points:
if other_point in siblings:
continue
flag = True
for polygon in polygons:
if polygon.whether_intersect_line(Line((point_i, other_point))):
flag = False
break
if flag:
point_i.add_successor(other_point)
return points
def test_intersection(self):
p1 = Point(0, 0)
p2 = Point(4, 0)
p3 = Point(0, 2)
p4 = Point(4, 2)
p5 = Point(2, 1)
self.assertEqual(Segment(p1, p4).intersection(Segment(p2, p3)), p5)
def bounds(self):
""" Return the min and max points of a pin """
xs = [self.p1.x, self.p2.x]
ys = [self.p2.y, self.p2.y]
if self.label is not None:
xs += self.label.bounds()[0::2]
ys += self.label.bounds()[1::2]
return [Point(min(xs), min(ys)), Point(max(xs), max(ys))]
def main() -> None:
c1x, c1y, c1r = [int(x) for x in input().split()]
c1 = Circle(Point(c1x, c1y), c1r)
c2x, c2y, c2r = [int(x) for x in input().split()]
c2 = Circle(Point(c2x, c2y), c2r)
left, right = c1.cross_point_circle(c2)
print("{:.8f} {:.8f} {:.8f} {:.8f}".format(left.x, left.y, right.x,
right.y))
def test_intersects(self):
p1 = Point(0, 0)
p2 = Point(4, 0)
p3 = Point(0, 2)
p4 = Point(4, 2)
p5 = Point(2, 0)
self.assertTrue(Segment(p1, p4).intersects(Segment(p2, p3)))
self.assertFalse(Segment(p1, p5).intersects(Segment(p2, p3)))
def main() -> None:
x0, y0, x1, y1 = [int(x) for x in input().split()]
s = Segment(Point(x0, y0), Point(x1, y1))
q = int(input())
for _ in range(q):
x2, y2 = [int(x) for x in input().split()]
print(Point(x2, y2).location(s).name)
def test_init_default(self):
s1 = Segment()
self.assertEqual(s1.p1, Point(0, 0))
self.assertEqual(s1.p2, Point(0, 0))
s2 = Segment()
s1.p1.x = 1
self.assertEqual(s2.p1, Point(0, 0))
self.assertEqual(s2.p2, Point(0, 0))
def test_init_default(self):
p1 = Point()
self.assertEqual(p1.x, 0)
self.assertEqual(p1.y, 0)
p2 = Point()
p1.x = 1
self.assertEqual(p2.x, 0)
self.assertEqual(p2.y, 0)
def main() -> None:
n = int(input())
for _ in range(n):
x1, y1, x2, y2, x3, y3, x4, y4 = [int(x) for x in input().split()]
s1 = Segment(Point(x1, y1), Point(x2, y2))
s2 = Segment(Point(x3, y3), Point(x4, y4))
print(s1.distance_with_segment(s2))
def test_cross_point_line(self):
self.assertEqual(
Circle(Point(2, 3),
2).cross_point_line(Line(Point(0, 3), Point(1, 3))),
[Point(0, 3), Point(4, 3)])
self.assertEqual(
Circle(Point(2, 3),
2).cross_point_line(Line(Point(4, 0), Point(4, 6))),
[Point(4, 3), Point(4, 3)])
def main() -> None:
q = int(input())
for _ in range(q):
x0, y0, x1, y1, x2, y2, x3, y3 = \
[int(x) for x in input().split()]
s1 = Segment(Point(x0, y0), Point(x1, y1))
s2 = Segment(Point(x2, y2), Point(x3, y3))
print(1 if s1.intersects(s2) else 0)
def test_in_width_of(self):
s1 = Segment(Point(0, -1), Point(0, 1))
self.assertFalse(Point(2, -2).in_width_of(s1))
self.assertTrue(Point(2, -1).in_width_of(s1))
self.assertTrue(Point(2, 0).in_width_of(s1))
self.assertTrue(Point(2, 1).in_width_of(s1))
self.assertFalse(Point(2, 2).in_width_of(s1))
s1 = Segment(Point(-1, 0), Point(1, 0))
self.assertFalse(Point(5, 3).in_width_of(s1))
def test_sides(self):
p = Polygon([Point(0, 0), Point(1, 0), Point(0, 1)])
self.assertEqual(list(p.sides()), [
Segment(Point(0, 0), Point(1, 0)),
Segment(Point(1, 0), Point(0, 1)),
Segment(Point(0, 1), Point(0, 0))
])
def main() -> None:
n = int(input())
points = []
for _ in range(n):
x, y = [int(x) for x in input().split()]
points.append(Point(x, y))
polygon = Polygon(points)
q = int(input())
for _ in range(q):
x, y = [int(x) for x in input().split()]
print(int(polygon.contains(Point(x, y))))
def main() -> None:
x1, y1, x2, y2 = [int(x) for x in input().split()]
p1 = Point(x1, y1)
p2 = Point(x2, y2)
l = Line(p1, p2)
q = int(input())
for _ in range(q):
x, y = [int(x) for x in input().split()]
p = Point(x, y)
a = l.reflection(p)
print(a.x, a.y)
def test_cross_point_circle(self):
self.assertTrue(
Circle(Point(0, 0), 2).cross_point_circle(Circle(Point(2, 0), 2))
== [Point(1.0, -1.7320508075),
Point(1.0, 1.7320508075)])
self.assertTrue(
Circle(Point(0, 0), 2).cross_point_circle(Circle(Point(0, 3), 1))
== [Point(0, 2), Point(0, 2)])
def mousePressEvent(self,event):
p = Point(event.x(),event.y())
self._points.append(p)
if p not in self.points:
self.points.append(p)
self.drawDisplay.display_points(p)
self.update()
def generate_struct(self):
for x in range(0, self.num_shapes[0]):
for y in range(0, self.num_shapes[1]):
coordinates = [
((x) * self.size_shapes[0], (y) * self.size_shapes[1]),
((x + 1) * self.size_shapes[0], (y) * self.size_shapes[1]),
((x + 1) * self.size_shapes[0],
(y + 1) * self.size_shapes[1]),
((x) * self.size_shapes[0], (y + 1) * self.size_shapes[1])
]
new_points = []
for coord in coordinates:
if coord in self.points:
new_points.append(self.points[coord])
else:
new_point = Point(coord)
self.points[coord] = new_point
new_points.append(new_point)
self.shapes.append(Shape(new_points))
for point in self.points.values():
if self.in_bounds(point):
point.evolve()
def bounds(self):
""" Return the min and max point of a design """
bounds = [net.bounds() for net in self.nets]
offset_bounds = lambda (x1, y1, x2, y2), (xo, yo): (x1 + xo, y1 + yo,
x2 + xo, y2 + yo)
for comp in self.component_instances:
offsets = [(att.x, att.y) for att in comp.symbol_attributes]
lib_comp = self.components.components[comp.library_id]
bbounds = [
b.bounds() for b in lib_comp.symbols[comp.symbol_index].bodies
]
bounds.extend(
[offset_bounds(b, o) for b, o in zip(bbounds, offsets)])
xs = sum([list(b[0::2]) for b in bounds], [])
ys = sum([list(b[1::2]) for b in bounds], [])
return [Point(min(xs), min(ys)), Point(max(xs), max(ys))]
def test_lt(self):
self.assertTrue(self.p1 < Point(2, 2))
self.assertFalse(self.p1 < Point(0, 2))
self.assertTrue(self.p1 < Point(1, 3))
self.assertTrue(self.p1 < Point(1.00000000001, 3))
self.assertFalse(self.p1 < Point(1, 1))
self.assertFalse(self.p1 < Point(1.00000000001, 1))
self.assertFalse(self.p1 < Point(1, 2))
def ReadFile(self, filename=None):
self.painter.drawDisplay.ClearCanvas()
filename, _ = QtWidgets.QFileDialog.getOpenFileName()
if filename:
f = open(filename, 'r')
self.readPoints = [[], 0]
self._readPoints = [[], 0]
self.painter.points = []
self.painter.parent.next_data.setEnabled(True)
while True:
num = f.readline()
if len(num) == 0:
continue
elif num[0] == '#' or num[0] == '\n':
continue
elif int(num) == 0:
break
s = set()
_data = []
num = int(num)
for i in range(0, num):
#to avoid the comment between input point
while True:
line = f.readline()
if len(line) == 0:
continue
elif line[0] == '#' or line[0] == '\n':
continue
else:
break
x, y = map(int, line.split())
p = Point(x, y)
_data.append(p)
if p not in s:
s.add(p)
data = []
for p in s:
data.append(p)
self.readPoints[0].append(data)
self._readPoints[0].append(_data)
t = self.readPoints[1]
self.painter.points.extend(self.readPoints[0][t])
#for duplicated input data
self.painter._points.extend(self._readPoints[0][t])
#need to show original data,not filterd data
for p in self.painter._points:
self.painter.drawDisplay.display_points(p)
self.readPoints[1] = self.readPoints[1] + 1
self._readPoints[1] = self._readPoints[1] + 1
f.close()
self.painter.update()
class Pin:
""" Pins are the parts of Bodies (/symbols/components) that connect
to nets. Basically a line segment, with a null end and a connect end
"""
def __init__(self, pin_number, p1, p2, label=None):
self.label = label # is a Label
self.p1 = Point(p1) # null end
self.p2 = Point(p2) # connect end
self.pin_number = pin_number
def json(self):
d = {
"pin_number":self.pin_number,
"p1":self.p1.json(),
"p2":self.p2.json()
}
if self.label is not None:
d["label"] = self.label.json()
return d
def test_eq(self):
self.assertTrue(self.p1 == Point(1, 2))
self.assertTrue(self.p1 == Point(1.00000000001, 2))
self.assertTrue(self.p1 == Point(1, 2.00000000001))
self.assertFalse(self.p1 == Point(1, 3))
self.assertFalse(self.p1 == Point(2, 2))
self.assertFalse(self.p1 == Point(2, 3))
self.assertFalse(self.p1 == 3)
def __init__(self, pin_number, p1, p2, label=None):
self.label = label # is a Label
self.p1 = Point(p1) # null end
self.p2 = Point(p2) # connect end
self.pin_number = pin_number
def merge(VDL, VDR, tangent):
clip_lines = []
#used to record ray which intersect with dividing chain
#using hash table
ray_list = set()
def discard_edges(ray, circumcenter, side, SG_bisector):
def recursive_discard_edge(ray, other_point, base_point, side):
#want to delete left remaining line
for candidate in ray.connected:
if candidate.avail == True and candidate not in ray_list:
next_base_point = None
next_other_point = None
#catch base point
if (candidate.p1 is base_point
or candidate.p2 is base_point):
if candidate.p1 is base_point:
next_base_point = candidate.p2
next_other_point = candidate.p1
else:
next_base_point = candidate.p1
next_other_point = candidate.p2
if side == 'right':
if ConvexHull.cross(base_point,
next_base_point,
other_point) > 0:
candidate.avail = False
recursive_discard_edge(
candidate, next_other_point,
next_base_point, 'right')
elif side == 'left':
if ConvexHull.cross(base_point,
next_base_point,
other_point) < 0:
candidate.avail = False
recursive_discard_edge(
candidate, next_other_point,
next_base_point, 'left')
if side == 'right':
#clear the edges extend to the left of HP
#Line(hole,ray.p1) or Line(hole,ray.p2) must cw to Line(hole,bisector.p1)
if ConvexHull.cross(circumcenter, ray.p1, SG_bisector.p1) > 0:
#this means p1 is left to circumcenter,so replace p1 with circumcenter
if ray.p1.iscircumcenter == True:
recursive_discard_edge(ray, circumcenter, ray.p1,
'right')
ray.p1 = circumcenter
else:
if ray.p2.iscircumcenter == True:
recursive_discard_edge(ray, circumcenter, ray.p2,
'right')
ray.p2 = circumcenter
elif side == "left":
#clear the edges extend to the right of HP
#Line(hole,ray.p1) or Line(hole,ray.p2) must ccw to Line(hole,bisector.p1)
if ConvexHull.cross(circumcenter, ray.p1, SG_bisector.p1) < 0:
#this means p1 is right to circumcenter,so replace p1 with circumcenter
if ray.p1.iscircumcenter == True:
recursive_discard_edge(ray, circumcenter, ray.p1,
'left')
ray.p1 = circumcenter
else:
if ray.p2.iscircumcenter == True:
recursive_discard_edge(ray, circumcenter, ray.p2,
'left')
ray.p2 = circumcenter
else:
#clear both side
#clear the edges extend to the right of HP
#Line(hole,ray.p1) or Line(hole,ray.p2) must ccw to Line(hole,bisector.p1)
if ConvexHull.cross(circumcenter, ray[0].p1,
SG_bisector.p1) < 0:
#this means p1 is right to circumcenter,so replace p1 with circumcenter
if ray[0].p1.iscircumcenter == True:
recursive_discard_edge(ray[0], circumcenter, ray[0].p1,
'left')
ray[0].p1 = circumcenter
else:
if ray[0].p2.iscircumcenter == True:
recursive_discard_edge(ray[0], circumcenter, ray[0].p2,
'left')
ray[0].p2 = circumcenter
#clear the edges extend to the left of HP
if ConvexHull.cross(circumcenter, ray[1].p1,
SG_bisector.p1) > 0:
#this means p1 is left to circumcenter,so replace p1 with circumcenter
if ray[1].p1.iscircumcenter == True:
recursive_discard_edge(ray[1], circumcenter, ray[1].p1,
'right')
ray[1].p1 = circumcenter
else:
if ray[1].p2.iscircumcenter == True:
recursive_discard_edge(ray[1], circumcenter, ray[1].p2,
'right')
ray[1].p2 = circumcenter
def nextPoint(pool, SG_bisector):
ans = None
first = True
for candidate in pool:
if candidate.line.avail == True and SG_bisector.p1 is not candidate.line.hole:
result = Line.intersect(candidate.line, SG_bisector)
if result is not None:
t = (result, candidate.point, candidate.line)
if first == True:
ans = t
first = False
else:
if t[0].y <= ans[0].y:
ans = t
return ans
upper_tangent, lower_tangent = VD.find_tangent(VDL, VDR)
ul = (upper_tangent, lower_tangent)
tangent[0].append(ul)
HP = []
SG = upper_tangent
px = SG.p1
py = SG.p2
#p1 of upper_tangent belongs to VDL, and p2 belongs to VDR
SG_bisector = Line.biSector(SG.p1, SG.p2)
SG_bisector._p1 = SG.p1
SG_bisector._p2 = SG.p2
HP.append(SG_bisector)
circumcenter = None
firsttime = True
newpl = defaultdict(list)
while not (SG == lower_tangent):
#step4 as textBook
#p1 of SG_bisector is fixed to upper position than p2
if SG_bisector.p1.y > SG_bisector.p2.y:
SG_bisector.p1, SG_bisector.p2 = SG_bisector.p2, SG_bisector.p1
elif abs((SG_bisector.p1.y) - (SG_bisector.p2.y)) <= 0.00005:
if SG_bisector.p1.x < SG_bisector.p2.x:
SG_bisector.p1, SG_bisector.p2 = SG_bisector.p2, SG_bisector.p1
newpl[SG.p1].append(pair(SG_bisector, SG.p2))
newpl[SG.p2].append(pair(SG_bisector, SG.p1))
#orginally p1 is very far from painter,so we need to fix p1 to previous circumcenter
if firsttime == False and circumcenter is not None:
SG_bisector.p1 = circumcenter
pll = px.related
prl = py.related
result_l = nextPoint(pll, SG_bisector)
result_r = nextPoint(prl, SG_bisector)
side = None
ray = None
#with biSector of pyz2 first,that is,VDR first
if result_l is not None and result_r is not None:
if abs(result_l[0].x - result_r[0].x) <= 0.05 and abs(
result_l[0].y - result_r[0].y) <= 0.05:
#VDL.parent.msg = VDL.parent.msg+'both cd'+'\n'
SG = Line(result_l[1], result_r[1])
circumcenter = result_l[0]
ray = (result_l[2], result_r[2])
side = 'both'
elif result_l[0].y > result_r[0].y:
#VDL.parent.msg = VDL.parent.msg+'cd VDR'+'\n'
SG = Line(px, result_r[1])
circumcenter = result_r[0]
ray = result_r[2]
side = 'right'
elif result_l[0].y < result_r[0].y:
#VDL.parent.msg = VDL.parent.msg+'cd VDL'+'\n'
SG = Line(result_l[1], py)
circumcenter = result_l[0]
ray = result_l[2]
side = 'left'
else:
print('confused...')
#print result_l,result_r
else:
if result_l is not None and result_r is None:
#VDL.parent.msg = VDL.parent.msg+'VDR is None,cd VDL'+'\n'
SG = Line(result_l[1], py)
circumcenter = result_l[0]
ray = result_l[2]
side = 'left'
elif result_r is not None and result_l is None:
#VDL.parent.msg = VDL.parent.msg+'VDL is None,cd VDR'+'\n'
SG = Line(px, result_r[1])
circumcenter = result_r[0]
#print 'circumcenter',(circumcenter.x,circumcenter.y)
ray = result_r[2]
side = 'right'
else:
#VDL.parent.msg = VDL.parent.msg+'both are None'+'\n'
#let SG be lower_tangent
SG = lower_tangent
SG_bisector = Line.biSector(SG.p1, SG.p2)
SG_bisector._p1 = SG.p1
SG_bisector._p2 = SG.p2
HP.append(SG_bisector)
continue
if ray is not None:
if not isinstance(ray, tuple):
ray.hole = circumcenter
t = (ray, SG_bisector, side, circumcenter)
if ray not in ray_list:
ray_list.add(ray)
clip_lines.append(t)
else:
for r in ray:
r.hole = circumcenter
ray_list.add(r)
t = (ray, SG_bisector, side, circumcenter)
clip_lines.append(t)
if circumcenter is not None:
circumcenter.iscircumcenter = True
#lower point is replaced by circumcenter
SG_bisector.p2 = circumcenter
#new SG
px = SG.p1
py = SG.p2
SG_bisector = Line.biSector(SG.p1, SG.p2)
SG_bisector._p1 = SG.p1
SG_bisector._p2 = SG.p2
HP.append(SG_bisector)
firsttime = False
#the end of while loop for HP
if SG_bisector.p1.y > SG_bisector.p2.y:
SG_bisector.p1, SG_bisector.p2 = SG_bisector.p2, SG_bisector.p1
elif abs((SG_bisector.p1.y) - (SG_bisector.p2.y)) <= 0.00005:
if SG_bisector.p1.x < SG_bisector.p2.x:
SG_bisector.p1, SG_bisector.p2 = SG_bisector.p2, SG_bisector.p1
newpl[SG.p1].append(pair(SG_bisector, SG.p2))
newpl[SG.p2].append(pair(SG_bisector, SG.p1))
for p in newpl.keys():
for t in newpl[p]:
p.related.append(t)
if circumcenter is not None:
SG_bisector.p1 = circumcenter
#clip the unwanted lines
VDL.parent.msg = VDL.parent.msg + 'clip lines' + '\n'
for t in clip_lines:
ray = t[0]
circumcenter = t[3]
SG_bisector = t[1]
side = t[2]
discard_edges(ray, circumcenter, side, SG_bisector)
#add new connected line
s = 0
for t in range(0, len(HP) - 1):
#need to add the intersected dividing chain
HP[t].connected.append(HP[t + 1])
HP[t + 1].connected.append(HP[t])
#need to add the intersected ray
if s != len(clip_lines):
if not isinstance(clip_lines[s][0], tuple):
HP[t].connected.append(clip_lines[s][0])
clip_lines[s][0].connected.append(HP[t])
HP[t + 1].connected.append(clip_lines[s][0])
clip_lines[s][0].connected.append(HP[t + 1])
else:
r = clip_lines[s][0]
HP[t].connected.append(r[0])
r[0].connected.append(HP[t])
HP[t + 1].connected.append(r[0])
r[0].connected.append(HP[t + 1])
HP[t].connected.append(r[1])
r[1].connected.append(HP[t])
HP[t + 1].connected.append(r[1])
r[1].connected.append(HP[t + 1])
r[1].connected.append(r[0])
r[0].connected.append(r[1])
s = s + 1
lines = []
#lines = VDR.lines+VDL.lines+HP
lines.append(VDR.lines)
lines.append(VDL.lines)
lines.append(HP)
if VDL.parent.isstep_by_step == True:
hp = []
for h in HP:
hp.append(Line(Point(h.p1.x, h.p1.y), Point(h.p2.x, h.p2.y)))
VDR.parent.hp[0].append(hp)
#VDR.parent.hp[0].append(copy.deepcopy(HP))
range_points = (VDL.range_points[0], VDR.range_points[1])
return VD(lines, range_points, VDR.parent)
def test_distance(self):
self.assertEqual(Point(1, 1).distance(Point(4, 5)), 5)
def test_projection(self):
self.assertEqual(
Segment(Point(0, 0), Point(4, 0)).projection(Point(2, 2)),
Point(2, 0))
class TestPoint(unittest.TestCase):
def setUp(self):
self.p1 = Point(1, 2)
self.p2 = Point(3, 5)
def test_float_equal(self):
self.assertTrue(float_equal(1, 1))
self.assertTrue(float_equal(1.00000000001, 1))
self.assertTrue(float_equal(1, 1.00000000001))
self.assertFalse(float_equal(1.000000001, 1))
self.assertFalse(float_equal(1, 1.000000001))
def test_init_default(self):
p1 = Point()
self.assertEqual(p1.x, 0)
self.assertEqual(p1.y, 0)
p2 = Point()
p1.x = 1
self.assertEqual(p2.x, 0)
self.assertEqual(p2.y, 0)
def test_init(self):
self.assertEqual(self.p1.x, 1)
self.assertEqual(self.p1.y, 2)
def test_repr(self):
self.assertEqual(self.p1.__repr__(), 'Point(1, 2)')
def test_eq(self):
self.assertTrue(self.p1 == Point(1, 2))
self.assertTrue(self.p1 == Point(1.00000000001, 2))
self.assertTrue(self.p1 == Point(1, 2.00000000001))
self.assertFalse(self.p1 == Point(1, 3))
self.assertFalse(self.p1 == Point(2, 2))
self.assertFalse(self.p1 == Point(2, 3))
self.assertFalse(self.p1 == 3)
def test_add(self):
self.assertEqual(self.p1 + self.p2, Point(4, 7))
def test_sub(self):
self.assertEqual(self.p1 - self.p2, Point(-2, -3))
def test_mul(self):
self.assertEqual(self.p1 * 2, Point(2, 4))
self.assertEqual(2 * self.p1, Point(2, 4))
def test_div(self):
self.assertEqual(self.p1 / 2, Point(0.5, 1))
def test_lt(self):
self.assertTrue(self.p1 < Point(2, 2))
self.assertFalse(self.p1 < Point(0, 2))
self.assertTrue(self.p1 < Point(1, 3))
self.assertTrue(self.p1 < Point(1.00000000001, 3))
self.assertFalse(self.p1 < Point(1, 1))
self.assertFalse(self.p1 < Point(1.00000000001, 1))
self.assertFalse(self.p1 < Point(1, 2))
def test_norm(self):
self.assertTrue(Point(3, 4).norm() == 25)
self.assertTrue(Vector(3, 4).norm() == 25)
def test_abs(self):
self.assertTrue(Point(3, 4).abs() == 5)
self.assertTrue(Vector(3, 4).abs() == 5)
def test_dot(self):
self.assertEqual(Point(1, 0).dot(Point(0, 1)), 0)
self.assertEqual(self.p1.dot(self.p2), 13)
def test_cross(self):
self.assertEqual(Point(1, 0).cross(Point(0, 1)), 1)
self.assertEqual(self.p1.cross(self.p2), -1)
def test_is_orthogonal(self):
self.assertTrue(Point(1, 0).is_orthogonal(Point(0, 1)))
self.assertFalse(Point(0, 1).is_orthogonal(Point(1, 1)))
def test_is_parallel(self):
self.assertFalse(Point(1, 0).is_parallel(Point(0, 1)))
self.assertTrue(Point(0, 1).is_parallel(Point(0, 1)))
def test_projection(self):
self.assertEqual(
Segment(Point(0, 0), Point(4, 0)).projection(Point(2, 2)),
Point(2, 0))
def test_distance(self):
self.assertEqual(Point(1, 1).distance(Point(4, 5)), 5)
def test_in_side_of(self):
s1 = Segment(Point(0, 0), Point(0, 1))
self.assertFalse(Point(2, -1).in_side_of(s1))
self.assertTrue(Point(2, 0).in_side_of(s1))
self.assertTrue(Point(2, 1).in_side_of(s1))
def test_in_width_of(self):
s1 = Segment(Point(0, -1), Point(0, 1))
self.assertFalse(Point(2, -2).in_width_of(s1))
self.assertTrue(Point(2, -1).in_width_of(s1))
self.assertTrue(Point(2, 0).in_width_of(s1))
self.assertTrue(Point(2, 1).in_width_of(s1))
self.assertFalse(Point(2, 2).in_width_of(s1))
s1 = Segment(Point(-1, 0), Point(1, 0))
self.assertFalse(Point(5, 3).in_width_of(s1))
def test_distance_to_line(self):
s1 = Segment(Point(-1, 0), Point(1, 0))
self.assertEqual(Point(0, 3).distance_to_line(s1), 3)
def test_distance_to_segment(self):
s1 = Segment(Point(-1, 0), Point(1, 0))
self.assertEqual(Point(-5, 3).distance_to_segment(s1), 5)
self.assertEqual(Point(0, 3).distance_to_segment(s1), 3)
self.assertEqual(Point(5, 3).distance_to_segment(s1), 5)
def test_is_parallel(self):
self.assertFalse(Point(1, 0).is_parallel(Point(0, 1)))
self.assertTrue(Point(0, 1).is_parallel(Point(0, 1)))
def test_is_orthogonal(self):
self.assertTrue(Point(1, 0).is_orthogonal(Point(0, 1)))
self.assertFalse(Point(0, 1).is_orthogonal(Point(1, 1)))
