def test_centroid():
p = Polygon((0, 0), (10, 0), (10, 10))
q = p.translate(0, 20)
assert centroid(p, q) == Point(20, 40) / 3
p = Segment((0, 0), (2, 0))
q = Segment((0, 0), (2, 2))
assert centroid(p, q) == Point(1, -sqrt(2) + 2)
assert centroid(Point(0, 0), Point(2, 0)) == Point(2, 0) / 2
assert centroid(Point(0, 0), Point(0, 0), Point(2, 0)) == Point(2, 0) / 3
def test_perpendicular_bisector():
s1 = Segment(Point(0, 0), Point(1, 1))
aline = Line(Point(S.Half, S.Half), Point(Rational(3, 2), Rational(-1, 2)))
on_line = Segment(Point(S.Half, S.Half),
Point(Rational(3, 2), Rational(-1, 2))).midpoint
assert s1.perpendicular_bisector().equals(aline)
assert s1.perpendicular_bisector(on_line).equals(
Segment(s1.midpoint, on_line))
assert s1.perpendicular_bisector(on_line + (1, 0)).equals(aline)
def test_perpendicular_bisector():
s1 = Segment(Point(0, 0), Point(1, 1))
aline = Line(Point(S(1) / 2, S(1) / 2), Point(S(3) / 2, -S(1) / 2))
on_line = Segment(Point(S(1) / 2,
S(1) / 2), Point(S(3) / 2, -S(1) / 2)).midpoint
assert s1.perpendicular_bisector().equals(aline)
assert s1.perpendicular_bisector(on_line).equals(
Segment(s1.midpoint, on_line))
assert s1.perpendicular_bisector(on_line + (1, 0)).equals(aline)
def test_is_similar():
p1 = Point(2000, 2000)
p2 = p1.scale(2, 2)
r1 = Ray3D(Point3D(1, 1, 1), Point3D(1, 0, 0))
r2 = Ray(Point(0, 0), Point(0, 1))
s1 = Segment(Point(0, 0), p1)
assert s1.is_similar(Segment(p1, p2))
assert s1.is_similar(r2) is False
assert r1.is_similar(Line3D(Point3D(1, 1, 1), Point3D(1, 0, 0))) is True
assert r1.is_similar(Line3D(Point3D(0, 0, 0), Point3D(0, 1, 0))) is False
def test_projection():
p1 = Point(0, 0)
p2 = Point3D(0, 0, 0)
p3 = Point(-x1, x1)
l1 = Line(p1, Point(1, 1))
l2 = Line3D(Point3D(0, 0, 0), Point3D(1, 0, 0))
l3 = Line3D(p2, Point3D(1, 1, 1))
r1 = Ray(Point(1, 1), Point(2, 2))
assert Line(Point(x1, x1),
Point(y1, y1)).projection(Point(y1, y1)) == Point(y1, y1)
assert Line(Point(x1, x1),
Point(x1, 1 + x1)).projection(Point(1, 1)) == Point(x1, 1)
assert Segment(Point(-2, 2),
Point(0,
4)).projection(r1) == Segment(Point(-1, 3),
Point(0, 4))
assert Segment(Point(0, 4),
Point(-2,
2)).projection(r1) == Segment(Point(0, 4),
Point(-1, 3))
assert l1.projection(p3) == p1
assert l1.projection(Ray(p1, Point(-1, 5))) == Ray(Point(0, 0),
Point(2, 2))
assert l1.projection(Ray(p1, Point(-1, 1))) == p1
assert r1.projection(Ray(Point(1, 1), Point(-1, -1))) == Point(1, 1)
assert r1.projection(Ray(Point(0, 4),
Point(-1,
-5))) == Segment(Point(1, 1), Point(2, 2))
assert r1.projection(Segment(Point(-1, 5), Point(-5, -10))) == Segment(
Point(1, 1), Point(2, 2))
assert r1.projection(Ray(Point(1, 1), Point(-1, -1))) == Point(1, 1)
assert r1.projection(Ray(Point(0, 4),
Point(-1,
-5))) == Segment(Point(1, 1), Point(2, 2))
assert r1.projection(Segment(Point(-1, 5), Point(-5, -10))) == Segment(
Point(1, 1), Point(2, 2))
assert l3.projection(Ray3D(p2, Point3D(-1, 5, 0))) == Ray3D(
Point3D(0, 0, 0), Point3D(S(4) / 3,
S(4) / 3,
S(4) / 3))
assert l3.projection(Ray3D(p2, Point3D(-1, 1, 1))) == Ray3D(
Point3D(0, 0, 0), Point3D(S(1) / 3,
S(1) / 3,
S(1) / 3))
assert l2.projection(Point3D(5, 5, 0)) == Point3D(5, 0)
assert l2.projection(Line3D(Point3D(0, 1, 0), Point3D(1, 1, 0))).equals(l2)
def test_convex_hull():
p = [Point(-5,-1), Point(-2,1), Point(-2,-1), Point(-1,-3), Point(0,0),
Point(1,1), Point(2,2), Point(2,-1), Point(3,1), Point(4,-1), Point(6,2)]
ch = Polygon(p[0], p[3], p[9], p[10], p[6], p[1])
#test handling of duplicate points
p.append(p[3])
#more than 3 collinear points
another_p = [Point(-45, -85), Point(-45, 85), Point(-45,26),Point(-45,-24)]
ch2 = Segment(another_p[0],another_p[1])
assert convex_hull(another_p) == ch2
assert convex_hull(p) == ch
assert convex_hull(p[0]) == p[0]
assert convex_hull(p[0], p[1]) == Segment(p[0], p[1])
def point_is_on_boundary(self, point, tolerance=None):
"""Return the polygon on whose boundary the given point lies,
within tolerance.
Args:
point: an list [x, y] defining a point, or
a Point object from a GradeableFunction grader
tolerance: a pixel distance tolerance
Returns:
list:
The first polygon, defined as a list of points, that contains
the given point, or None.
"""
if tolerance is None:
tolerance = self.tolerance['point_distance'] / self.xscale
if isinstance(point, SR_Point):
point = [point.x, point.y]
for polygon in self.polygons:
for i, pt in enumerate(polygon.points):
if i < len(polygon.points) - 1:
pt2 = polygon.points[i + 1]
else:
pt2 = polygon.points[0]
poly_seg = Segment(pt, pt2)
distance = poly_seg.distance(Point(*point))
if distance < tolerance:
return polygon
return None
def test_booleans():
""" test basic unions and intersections """
assert Union(l1, l2).equals(l1)
assert Intersection(l1, l2).equals(l1)
assert Intersection(l1, l4) == FiniteSet(Point(1, 1))
assert Intersection(Union(l1, l4),
l3) == FiniteSet(Point(-1 / 3, -1 / 3), Point(5, 1))
assert Intersection(l1, FiniteSet(Point(7, -7))) == EmptySet()
assert Intersection(Circle(Point(0, 0), 3),
Line(p1, p2)) == FiniteSet(Point(-3, 0), Point(3, 0))
fs = FiniteSet(Point(1 / 3, 1), Point(2 / 3, 0), Point(9 / 5, 1 / 5),
Point(7 / 3, 1))
# test the intersection of polygons
assert Intersection(poly1, poly2) == fs
# make sure if we union polygons with subsets, the subsets go away
assert Union(poly1, poly2, fs) == Union(poly1, poly2)
# make sure that if we union with a FiniteSet that isn't a subset,
# that the points in the intersection stop being listed
assert Union(poly1, FiniteSet(Point(0, 0),
Point(3,
5))) == Union(poly1,
FiniteSet(Point(3, 5)))
# intersect two polygons that share an edge
assert Intersection(poly1, poly3) == Union(
FiniteSet(Point(3 / 2, 1), Point(2, 1)),
Segment(Point(0, 0), Point(1, 0)))
def test_router_corridor_close(tmp_path, env, router_id):
"""
:param tmp_path: working directory of test execution
:param env: global environment object
"""
input_location = (env.systemtest_path / "router_tests" /
"test_corridor_close")
template_path = input_location / "inifile.template"
inifile_path = tmp_path / "inifile.xml"
instanciate_tempalte(
src=template_path,
args={"router_id": router_id},
dest=inifile_path,
)
copy_files(
sources=[input_location / "geometry.xml"],
dest=tmp_path,
)
jpscore_driver = JpsCoreDriver(jpscore_path=env.jpscore_path,
working_directory=tmp_path)
jpscore_driver.run()
trajectories = load_trajectory(jpscore_driver.traj_file)
agent_path = trajectories.path(2)
assert get_intersetions_path_segment(
agent_path, Segment(Point(9.5, -5), Point(9.5, 5)))
def test_svg():
a = Line(Point(1, 1),Point(1, 2))
assert a._svg() == '<path fill-rule="evenodd" fill="#66cc99" stroke="#555555" stroke-width="2.0" opacity="0.6" d="M 1.00000000000000,1.00000000000000 L 1.00000000000000,2.00000000000000" marker-start="url(#markerReverseArrow)" marker-end="url(#markerArrow)"/>'
a = Segment(Point(1, 0),Point(1, 1))
assert a._svg() == '<path fill-rule="evenodd" fill="#66cc99" stroke="#555555" stroke-width="2.0" opacity="0.6" d="M 1.00000000000000,0 L 1.00000000000000,1.00000000000000" />'
a = Ray(Point(2, 3), Point(3, 5))
assert a._svg() == '<path fill-rule="evenodd" fill="#66cc99" stroke="#555555" stroke-width="2.0" opacity="0.6" d="M 2.00000000000000,3.00000000000000 L 3.00000000000000,5.00000000000000" marker-start="url(#markerCircle)" marker-end="url(#markerArrow)"/>'
def rotate_segment(segment: Segment, angle: int) -> Segment:
a = [segment.p1.x, segment.p1.y]
b = [segment.p2.x, segment.p2.y]
angle = angle * pi / 180
midpoint = [(a[0] + b[0]) / 2, (a[1] + b[1]) / 2]
a_mid = [a[0] - midpoint[0], a[1] - midpoint[1]]
b_mid = [b[0] - midpoint[0], b[1] - midpoint[1]]
a_rotated = [
cos(angle) * a_mid[0] - sin(angle) * a_mid[1],
sin(angle) * a_mid[0] + cos(angle) * a_mid[1]
]
b_rotated = [
cos(angle) * b_mid[0] - sin(angle) * b_mid[1],
sin(angle) * b_mid[0] + cos(angle) * b_mid[1]
]
a_rotated[0] = (a_rotated[0] + midpoint[0])
a_rotated[1] = (a_rotated[1] + midpoint[1])
b_rotated[0] = (b_rotated[0] + midpoint[0])
b_rotated[1] = (b_rotated[1] + midpoint[1])
rotated_segment = Segment(Point(int(a_rotated[0]), int(a_rotated[1])),
Point(int(b_rotated[0]), int(b_rotated[1])))
return rotated_segment
def recalc(inter, centro,circ):
a= inter[0]
b= inter[1]
seg= Segment(a,b)
c= seg.midpoint
line= Ray(centro,c)
return intersection(line,circ);
def test_subs():
x = Symbol('x', real=True)
y = Symbol('y', real=True)
p = Point(x, 2)
q = Point(1, 1)
r = Point(3, 4)
for o in [
p,
Segment(p, q),
Ray(p, q),
Line(p, q),
Triangle(p, q, r),
RegularPolygon(p, 3, 6),
Polygon(p, q, r, Point(5, 4)),
Circle(p, 3),
Ellipse(p, 3, 4)
]:
assert 'y' in str(o.subs(x, y))
assert p.subs({x: 1}) == Point(1, 2)
assert Point(1, 2).subs(Point(1, 2), Point(3, 4)) == Point(3, 4)
assert Point(1, 2).subs((1, 2), Point(3, 4)) == Point(3, 4)
assert Point(1, 2).subs(Point(1, 2), Point(3, 4)) == Point(3, 4)
assert Point(1, 2).subs(set([(1, 2)])) == Point(2, 2)
raises(ValueError, lambda: Point(1, 2).subs(1))
raises(ValueError, lambda: Point(1, 1).subs(
(Point(1, 1), Point(1, 2)), 1, 2))
def change_size_segment(segment: Segment, coefficient: float) -> Segment:
"""
Change size of a segment according to give coefficient
:param segment: Reflective segment
:param coefficient: Coefficient for resizing
:return: Resized segment
"""
a = [segment.p1.x, segment.p1.y]
b = [segment.p2.x, segment.p2.y]
midpoint = [(a[0] + b[0]) / 2, (a[1] + b[1]) / 2]
x_diff_half = (b[0] - a[0]) / 2
y_diff_half = (b[1] - a[1]) / 2
a_changed = [
midpoint[0] - coefficient * x_diff_half,
midpoint[1] - coefficient * y_diff_half
]
b_changed = [
midpoint[0] + coefficient * x_diff_half,
midpoint[1] + coefficient * y_diff_half
]
changed_segment = Segment(Point(int(a_changed[0]), int(a_changed[1])),
Point(int(b_changed[0]), int(b_changed[1])))
return changed_segment
def rotate_segment(segment: Segment, angle: int) -> Segment:
"""
Rotate segment clockwise or counterclockwise according to given angle
:param segment: Reflective segment
:param angle: Angle for rotation (in degrees)
:return: Rotated segment
"""
a = [segment.p1.x, segment.p1.y]
b = [segment.p2.x, segment.p2.y]
angle = angle * pi / 180
midpoint = [(a[0] + b[0]) / 2, (a[1] + b[1]) / 2]
a_mid = [a[0] - midpoint[0], a[1] - midpoint[1]]
b_mid = [b[0] - midpoint[0], b[1] - midpoint[1]]
a_rotated = [
cos(angle) * a_mid[0] - sin(angle) * a_mid[1],
sin(angle) * a_mid[0] + cos(angle) * a_mid[1]
]
b_rotated = [
cos(angle) * b_mid[0] - sin(angle) * b_mid[1],
sin(angle) * b_mid[0] + cos(angle) * b_mid[1]
]
a_rotated[0] = (a_rotated[0] + midpoint[0])
a_rotated[1] = (a_rotated[1] + midpoint[1])
b_rotated[0] = (b_rotated[0] + midpoint[0])
b_rotated[1] = (b_rotated[1] + midpoint[1])
rotated_segment = Segment(Point(int(a_rotated[0]), int(a_rotated[1])),
Point(int(b_rotated[0]), int(b_rotated[1])))
return rotated_segment
def test_line_intersection():
assert asa(120, 8, 52) == \
Triangle(
Point(0, 0),
Point(8, 0),
Point(-4 * cos(19 * pi / 90) / sin(2 * pi / 45),
4 * sqrt(3) * cos(19 * pi / 90) / sin(2 * pi / 45)))
assert Line((0, 0), (1, 1)).intersection(Ray((1, 0), (1, 2))) == [Point(1, 1)]
assert Line((0, 0), (1, 1)).intersection(Segment((1, 0), (1, 2))) == [Point(1, 1)]
assert Ray((0, 0), (1, 1)).intersection(Ray((1, 0), (1, 2))) == [Point(1, 1)]
assert Ray((0, 0), (1, 1)).intersection(Segment((1, 0), (1, 2))) == [Point(1, 1)]
assert Ray((0, 0), (10, 10)).contains(Segment((1, 1), (2, 2))) is True
assert Segment((1, 1), (2, 2)) in Line((0, 0), (10, 10))
x = 8 * tan(13 * pi / 45) / (tan(13 * pi / 45) + sqrt(3))
y = (-8 * sqrt(3) * tan(13 * pi / 45) ** 2 + 24 * tan(13 * pi / 45)) / (-3 + tan(13 * pi / 45) ** 2)
assert Line(Point(0, 0), Point(1, -sqrt(3))).contains(Point(x, y)) is True
def get_intersections_with_polygon_boundary(self,
polygon,
line_segment,
tolerance=None):
"""Return a list of intersection points of the given line segment
with the given polygon.
Args:
polygon: a list of points [[x1,y1], ..., [xn,yn]] defining a polygon,
or a Polygon object
line_segment: an list of two points [[x1, y1], [x2,y2]], or
a LineSegment object from a LineSegment grader
tolerance: a pixel distance tolerance
Returns:
list:
A list of intersection points [x,y].
"""
intersections = []
if isinstance(line_segment, LineSegment):
point1 = line_segment.getStartPoint()
point2 = line_segment.getEndPoint()
else:
point1 = line_segment[0]
point2 = line_segment[1]
if isinstance(polygon, Polygon):
polygon = polygon.points
in_seg = Segment(Point(*point1), Point(*point2))
for i, pt in enumerate(polygon):
if i < len(polygon) - 1:
pt2 = polygon[i + 1]
else:
pt2 = polygon[0]
poly_seg = Segment(pt, pt2)
intersection_points = intersection(in_seg, poly_seg)
for ip in intersection_points:
intersections.append([ip.x, ip.y])
intersections = self.filter_intersections_for_endpoints(
intersections, point1, point2, tolerance=tolerance)
return intersections
def adjust_out_of_bounds_points(vert1, vert2, boundaries):
line_seg = None
if vert1[0] < 0 or vert1[1] < 0 or vert2[0] < 0 or vert2[1] < 0 or vert1[
0] > width or vert1[1] > height or vert2[0] > width or vert2[
1] > height:
line_seg = Segment(Point(vert1), Point(vert2))
if vert1[0] < 0:
intrscts = line_seg.intersection(boundaries[3])
if len(intrscts) == 0:
return None, None
intrsct = intrscts[0]
vert1 = intrsct.x, intrsct.y
if vert1[1] < 0:
intrscts = line_seg.intersection(boundaries[0])
if len(intrscts) == 0:
return None, None
intrsct = intrscts[0]
vert1 = intrsct.x, intrsct.y
if vert2[0] < 0:
intrscts = line_seg.intersection(boundaries[3])
if len(intrscts) == 0:
return None, None
intrsct = intrscts[0]
vert2 = intrsct.x, intrsct.y
if vert2[1] < 0:
intrscts = line_seg.intersection(boundaries[0])
if len(intrscts) == 0:
return None, None
intrsct = intrscts[0]
vert2 = intrsct.x, intrsct.y
if vert1[0] > width:
intrscts = line_seg.intersection(boundaries[1])
if len(intrscts) == 0:
return None, None
intrsct = intrscts[0]
vert1 = intrsct.x, intrsct.y
if vert1[1] > height:
intrscts = line_seg.intersection(boundaries[2])
if len(intrscts) == 0:
return None, None
intrsct = intrscts[0]
vert1 = intrsct.x, intrsct.y
if vert2[0] > width:
intrscts = line_seg.intersection(boundaries[1])
if len(intrscts) == 0:
return None, None
intrsct = intrscts[0]
vert2 = intrsct.x, intrsct.y
if vert2[1] > height:
intrscts = line_seg.intersection(boundaries[2])
if len(intrscts) == 0:
return None, None
intrsct = intrscts[0]
vert2 = intrsct.x, intrsct.y
return vert1, vert2
def test_contains():
p1 = Point(0, 0)
r = Ray(p1, Point(4, 4))
r1 = Ray3D(p1, Point3D(0, 0, -1))
r2 = Ray3D(p1, Point3D(0, 1, 0))
r3 = Ray3D(p1, Point3D(0, 0, 1))
l = Line(Point(0, 1), Point(3, 4))
# Segment contains
assert Point(0, (a + b) / 2) in Segment((0, a), (0, b))
assert Point((a + b) / 2, 0) in Segment((a, 0), (b, 0))
assert Point3D(0, 1, 0) in Segment3D((0, 1, 0), (0, 1, 0))
assert Point3D(1, 0, 0) in Segment3D((1, 0, 0), (1, 0, 0))
assert Segment3D(Point3D(0, 0, 0), Point3D(1, 0, 0)).contains([]) is True
assert Segment3D(Point3D(0, 0, 0), Point3D(1, 0, 0)).contains(
Segment3D(Point3D(2, 2, 2), Point3D(3, 2, 2))) is False
# Line contains
assert l.contains(Point(0, 1)) is True
assert l.contains((0, 1)) is True
assert l.contains((0, 0)) is False
# Ray contains
assert r.contains(p1) is True
assert r.contains((1, 1)) is True
assert r.contains((1, 3)) is False
assert r.contains(Segment((1, 1), (2, 2))) is True
assert r.contains(Segment((1, 2), (2, 5))) is False
assert r.contains(Ray((2, 2), (3, 3))) is True
assert r.contains(Ray((2, 2), (3, 5))) is False
assert r1.contains(Segment3D(p1, Point3D(0, 0, -10))) is True
assert r1.contains(Segment3D(Point3D(1, 1, 1), Point3D(2, 2, 2))) is False
assert r2.contains(Point3D(0, 0, 0)) is True
assert r3.contains(Point3D(0, 0, 0)) is True
assert Ray3D(Point3D(1, 1, 1), Point3D(1, 0, 0)).contains([]) is False
assert Line3D((0, 0, 0), (x, y, z)).contains((2 * x, 2 * y, 2 * z))
with warnings.catch_warnings(record=True) as w:
assert Line3D(p1, Point3D(0, 1, 0)).contains(Point(1.0, 1.0)) is False
assert len(w) == 1
with warnings.catch_warnings(record=True) as w:
assert r3.contains(Point(1.0, 1.0)) is False
assert len(w) == 1
def test_vector_integrate():
halfdisc = ParametricRegion((r * cos(theta), r * sin(theta)), (r, -2, 2),
(theta, 0, pi))
assert vector_integrate(C.x**2, halfdisc) == 4 * pi
vector_integrate(C.x, ParametricRegion(
(t, t**2), (t, 2, 3))) == -17 * sqrt(17) / 12 + 37 * sqrt(37) / 12
assert vector_integrate(C.y**3 * C.z, (C.x, 0, 3),
(C.y, -1, 4)) == 765 * C.z / 4
s1 = Segment(Point(0, 0), Point(0, 1))
assert vector_integrate(-15 * C.y, s1) == S(-15) / 2
s2 = Segment(Point(4, 3, 9), Point(1, 1, 7))
assert vector_integrate(C.y * C.i, s2) == -6
curve = Curve((sin(t), cos(t)), (t, 0, 2))
assert vector_integrate(5 * C.z, curve) == 10 * C.z
c1 = Circle(Point(2, 3), 6)
assert vector_integrate(C.x * C.y, c1) == 72 * pi
c2 = Circle(Point(0, 0), Point(1, 1), Point(1, 0))
assert vector_integrate(1, c2) == c2.circumference
triangle = Polygon((0, 0), (1, 0), (1, 1))
assert vector_integrate(C.x * C.i - 14 * C.y * C.j, triangle) == 0
p1, p2, p3, p4 = [(0, 0), (1, 0), (5, 1), (0, 1)]
poly = Polygon(p1, p2, p3, p4)
assert vector_integrate(-23 * C.z,
poly) == -161 * C.z - 23 * sqrt(17) * C.z
point = Point(2, 3)
assert vector_integrate(C.i * C.y - C.z, point) == ParametricIntegral(
C.y * C.i, ParametricRegion((2, 3)))
c3 = ImplicitRegion((x, y), x**2 + y**2 - 4)
assert vector_integrate(45, c3) == 360 * pi
c4 = ImplicitRegion((x, y), (x - 3)**2 + (y - 4)**2 - 9)
assert vector_integrate(1, c4) == 12 * pi
pl = Plane(Point(1, 1, 1), Point(2, 3, 4), Point(2, 2, 2))
raises(ValueError, lambda: vector_integrate(C.x * C.z * C.i + C.k, pl))
def reducer(self, key, values):
lines = []
for value in values:
lines.append(Segment(Point(value[0], evaluate=False), Point(value[1], evaluate=False)))
for i in range(len(lines)):
for j in range(len(lines)):
if j > i:
heat = lines[i].intersection(lines[j])
if len(heat) >0:
if isinstance(heat[0], Point):
yield str(heat[0].x), str(heat[0].y)
def test_convex_hull():
p = [
Point(-5, -1),
Point(-2, 1),
Point(-2, -1),
Point(-1, -3),
Point(0, 0),
Point(1, 1),
Point(2, 2),
Point(2, -1),
Point(3, 1),
Point(4, -1),
Point(6, 2)
]
ch = Polygon(p[0], p[3], p[9], p[10], p[6], p[1])
#test handling of duplicate points
p.append(p[3])
#more than 3 collinear points
another_p = [
Point(-45, -85),
Point(-45, 85),
Point(-45, 26),
Point(-45, -24)
]
ch2 = Segment(another_p[0], another_p[1])
assert convex_hull(*another_p) == ch2
assert convex_hull(*p) == ch
assert convex_hull(p[0]) == p[0]
assert convex_hull(p[0], p[1]) == Segment(p[0], p[1])
# no unique points
assert convex_hull(*[p[-1]] * 3) == p[-1]
# collection of items
assert convex_hull(*[Point(0,0),
Segment(Point(1, 0), Point(1, 1)),
RegularPolygon(Point(2, 0), 2, 4)]) == \
Polygon(Point(0, 0), Point(2, -2), Point(4, 0), Point(2, 2))
def test_intersection():
assert intersection(Point(0, 0)) == []
raises(TypeError, lambda: intersection(Point(0, 0), 3))
assert intersection(
Segment((0, 0), (2, 0)),
Segment((-1, 0), (1, 0)),
Line((0, 0), (0, 1)), pairwise=True) == [
Point(0, 0), Segment((0, 0), (1, 0))]
assert intersection(
Line((0, 0), (0, 1)),
Segment((0, 0), (2, 0)),
Segment((-1, 0), (1, 0)), pairwise=True) == [
Point(0, 0), Segment((0, 0), (1, 0))]
assert intersection(
Line((0, 0), (0, 1)),
Segment((0, 0), (2, 0)),
Segment((-1, 0), (1, 0)),
Line((0, 0), slope=1), pairwise=True) == [
Point(0, 0), Segment((0, 0), (1, 0))]
def test_raises():
d, e = symbols('a,b', real=True)
s = Segment((d, 0), (e, 0))
raises(TypeError, lambda: Line((1, 1), 1))
raises(ValueError, lambda: Line(Point(0, 0), Point(0, 0)))
raises(Undecidable, lambda: Point(2 * d, 0) in s)
raises(ValueError, lambda: Ray3D(Point(1.0, 1.0)))
raises(ValueError, lambda: Line3D(Point3D(0, 0, 0), Point3D(0, 0, 0)))
raises(TypeError, lambda: Line3D((1, 1), 1))
raises(ValueError, lambda: Line3D(Point3D(0, 0, 0)))
raises(TypeError, lambda: Ray((1, 1), 1))
raises(GeometryError, lambda: Line(Point(0, 0), Point(1, 0))
.projection(Circle(Point(0, 0), 1)))
def test_subs():
p = Point(x, 2)
q = Point(1, 1)
r = Point(3, 4)
for o in [p,
Segment(p, q),
Ray(p, q),
Line(p, q),
Triangle(p, q, r),
RegularPolygon(p, 3, 6),
Polygon(p, q, r, Point(5,4)),
Circle(p, 3),
Ellipse(p, 3, 4)]:
assert 'y' in str(o.subs(x, y))
def checkSimple(A, r):
"""
This function checks if the given polygon with coordinates is simple.
:param A: Coordinate matrices of the polygon.
:param r: Side lengths as a vector.
:return: True or False
"""
n = len(r)
An = np.vstack((A, A[0, :], A[1, :]))
flag = 0
for k in range(n):
if (k < n - 1):
for l in range(max(0, k - 2)):
a = Segment(tuple(An[l, :]), tuple(An[l + 1, :]))
b = Segment(tuple(An[k, :]), tuple(An[k + 1, :]))
pts = a.intersect(b)
if (len(pts) == 1):
flag = 1
break
if (flag == 1):
break
else:
for l in range(1, max(0, k - 2)):
a = Segment(tuple(An[l, :]), tuple(An[l + 1, :]))
b = Segment(tuple(An[k, :]), tuple(An[k + 1, :]))
pts = a.intersect(b)
if (len(pts) == 1):
flag = 1
break
if (flag == 1):
break
if (flag == 1):
print('The polygon is not simple!')
return False
else:
return True
def test_parametric_region_list():
point = Point(-5, 12)
assert parametric_region_list(point) == [ParametricRegion((-5, 12))]
e = Ellipse(Point(2, 8), 2, 6)
assert parametric_region_list(e, t) == [
ParametricRegion((2 * cos(t) + 2, 6 * sin(t) + 8), (t, 0, 2 * pi))
]
c = Curve((t, t**3), (t, 5, 3))
assert parametric_region_list(c) == [
ParametricRegion((t, t**3), (t, 5, 3))
]
s = Segment(Point(2, 11, -6), Point(0, 2, 5))
assert parametric_region_list(s, t) == [
ParametricRegion((2 - 2 * t, 11 - 9 * t, 11 * t - 6), (t, 0, 1))
]
s1 = Segment(Point(0, 0), (1, 0))
assert parametric_region_list(s1,
t) == [ParametricRegion((t, 0), (t, 0, 1))]
s2 = Segment(Point(1, 2, 3), Point(1, 2, 5))
assert parametric_region_list(
s2, t) == [ParametricRegion((1, 2, 2 * t + 3), (t, 0, 1))]
s3 = Segment(Point(12, 56), Point(12, 56))
assert parametric_region_list(s3) == [ParametricRegion((12, 56))]
poly = Polygon((1, 3), (-3, 8), (2, 4))
assert parametric_region_list(poly, t) == [
ParametricRegion((1 - 4 * t, 5 * t + 3), (t, 0, 1)),
ParametricRegion((5 * t - 3, 8 - 4 * t), (t, 0, 1)),
ParametricRegion((2 - t, 4 - t), (t, 0, 1))
]
p1 = Parabola(Point(0, 0), Line(Point(5, 8), Point(7, 8)))
raises(ValueError, lambda: parametric_region_list(p1))
def test_arbitrary_point():
l1 = Line3D(Point3D(0, 0, 0), Point3D(1, 1, 1))
l2 = Line(Point(x1, x1), Point(y1, y1))
assert l2.arbitrary_point() in l2
assert Ray((1, 1), angle=pi / 4).arbitrary_point() == \
Point(t + 1, t + 1)
assert Segment((1, 1), (2, 3)).arbitrary_point() == Point(1 + t, 1 + 2 * t)
assert l1.perpendicular_segment(l1.arbitrary_point()) == l1.arbitrary_point()
assert Ray3D((1, 1, 1), direction_ratio=[1, 2, 3]).arbitrary_point() == \
Point3D(t + 1, 2 * t + 1, 3 * t + 1)
assert Segment3D(Point3D(0, 0, 0), Point3D(1, 1, 1)).midpoint == \
Point3D(Rational(1, 2), Rational(1, 2), Rational(1, 2))
assert Segment3D(Point3D(x1, x1, x1), Point3D(y1, y1, y1)).length == sqrt(3) * sqrt((x1 - y1) ** 2)
assert Segment3D((1, 1, 1), (2, 3, 4)).arbitrary_point() == \
Point3D(t + 1, 2 * t + 1, 3 * t + 1)
def test_bisectors():
p1, p2, p3 = Point(0, 0), Point(1, 0), Point(0, 1)
p = Polygon(Point(0, 0), Point(2, 0), Point(1, 1), Point(0, 3))
q = Polygon(Point(1, 0), Point(2, 0), Point(3, 3), Point(-1, 5))
poly = Polygon(Point(3, 4), Point(0, 0), Point(8, 7), Point(-1, 1), Point(19, -19))
t = Triangle(p1, p2, p3)
assert t.bisectors()[p2] == Segment(Point(1, 0), Point(0, sqrt(2) - 1))
assert p.bisectors()[Point2D(0, 3)] == Ray2D(Point2D(0, 3), \
Point2D(sin(acos(2*sqrt(5)/5)/2), 3 - cos(acos(2*sqrt(5)/5)/2)))
assert q.bisectors()[Point2D(-1, 5)] == \
Ray2D(Point2D(-1, 5), Point2D(-1 + sqrt(29)*(5*sin(acos(9*sqrt(145)/145)/2) + \
2*cos(acos(9*sqrt(145)/145)/2))/29, sqrt(29)*(-5*cos(acos(9*sqrt(145)/145)/2) + \
2*sin(acos(9*sqrt(145)/145)/2))/29 + 5))
assert poly.bisectors()[Point2D(-1, 1)] == Ray2D(Point2D(-1, 1), \
Point2D(-1 + sin(acos(sqrt(26)/26)/2 + pi/4), 1 - sin(-acos(sqrt(26)/26)/2 + pi/4)))
def findcells(x0, x1, z0, z1, lines):
clusCells = []
clusPos = []
nonClusCells = []
stop = True
vertices = findPointsofRect(x0, x1, z0, z1)
segment1 = Segment(vertices[0], vertices[1])
segment2 = Segment(vertices[1], vertices[3])
segment3 = Segment(vertices[3], vertices[2])
segment4 = Segment(vertices[2], vertices[0])
for i in range(len(lines)):
line = lines[i]
if (line[0][0] == 0 and line[0][1] == 0):
nonClusCells.append([(0, 0)])
continue
x1, x2, y1, y2 = findLine(line[0][0], line[0][1])
lineF = Line((x1, y1), (x2, y2))
# I don't think finding intersection is reqd
i1 = lineF.intersection(segment1)
i2 = lineF.intersection(segment2)
i3 = lineF.intersection(segment3)
i4 = lineF.intersection(segment4)
if (not (len(i1) == 0 and len(i2) == 0 and len(i3) == 0
and len(i4) == 0)):
clusCells.append(line)
clusPos.append(i)
nonClusCells.append([(0, 0)])
stop = False
else:
nonClusCells.append(line)
return clusCells, clusPos, np.array(nonClusCells), stop, vertices
