def test_circle(self):
# counter-clockwise
arc = Arc(Point(1, 0), 90, 1, 10)
self.assertAlmostEqual(arc.circle(), Circle(Point(0, 0), 1))
# clockwise
arc = Arc(Point(1, 0), 90, 1, -45)
self.assertAlmostEqual(arc.circle(), Circle(Point(2, 0), 1))
def points_at_linear_offset(self, reference_point, offset):
circle1 = Circle(self.center_point(), self.radius())
circle2 = Circle(reference_point, abs(offset))
intersections = circle1.intersection(circle2)
if circle1.almost_equal_to(circle2):
return [self]
return filter(lambda point: self.includes_point(point), intersections)
def test_from_points_in_circle(self):
# with start_point = end_point
circle = Circle(Point(0, 0), 1)
point = Point(1, 0)
arc = Arc.from_points_in_circle(point, point, circle)
self.assertEqual(arc, Arc(point, 90, 1, 0))
# with start point different to end point
circle = Circle(Point(5, 5), 1)
start_point = Point(6, 5)
end_point = Point(5, 6)
arc = Arc.from_points_in_circle(start_point, end_point, circle)
self.assertEqual(arc, Arc(start_point, 90, 1, 90))
# in the lower half-plane
circle = Circle(Point(0, 0), 1)
start_point = Point(0, -1)
end_point = Point(1, 0)
expected_arc = Arc(Point(0, -1), 0, 1, 90)
self.assertEqual(
Arc.from_points_in_circle(start_point, end_point, circle),
expected_arc)
# with angular length greater than 180
circle = Circle(Point(0, 0), 1)
start_point = Point(1, 0)
end_point = Point(0, -1)
arc = Arc.from_points_in_circle(start_point, end_point, circle)
self.assertEqual(arc, Arc(start_point, 90, 1, 270))
def test_instance_variables(self):
circleWithNoCoordinatesGiven = Circle(6)
self.assertEqual(circleWithNoCoordinatesGiven._radius, 6)
self.assertEqual(circleWithNoCoordinatesGiven._x, 0)
self.assertEqual(circleWithNoCoordinatesGiven._y, 0)
circleWithCoordinatesGiven = Circle(7, {'x': 11, 'y': 22})
self.assertEqual(circleWithCoordinatesGiven._radius, 7)
self.assertEqual(circleWithCoordinatesGiven._x, 11)
self.assertEqual(circleWithCoordinatesGiven._y, 22)
def test_intersection_at_one_point_with_not_nested_circles(self):
circle1 = Circle(Point(0, 0), 2)
circle2 = Circle(Point(3, 0), 1)
self.assertEqual(circle1.intersection(circle2), [Point(2, 0)])
circle1 = Circle(Point(0, 0), 2)
circle2 = Circle(Point(0, 3), 1)
self.assertEqual(circle1.intersection(circle2), [Point(0, 2)])
def test_intersection_at_one_point_in_nested_circles(self):
circle1 = Circle(Point(0, 0), 4)
circle2 = Circle(Point(2, 0), 2)
self.assertEqual(circle1.intersection(circle2), [Point(4, 0)])
circle1 = Circle(Point(0, 0), 4)
circle2 = Circle(Point(0, 2), 2)
self.assertEqual(circle1.intersection(circle2), [Point(0, 4)])
def test_intersection_with_circles_that_do_not_intersect(self):
# with not nested circles
circle1 = Circle(Point(0, 0), 2)
circle2 = Circle(Point(6, 6), 3)
self.assertEqual(circle1.intersection(circle2), [])
# with nested circles
circle3 = Circle(Point(0, 0), 4)
circle4 = Circle(Point(2, 0), 1)
self.assertEqual(circle3.intersection(circle4), [])
class TestCircle(TestCase):
def setUp(self):
"""Set up a new object to be tested"""
dia = 65.0
self.c = Circle(dia)
def tearDown(self):
"""Destroy the object after running tests"""
del self.c
def test_area(self):
area = math.pi * 65**2 / 4
self.assertEqual(self.c.area(), area)
def _create_lane_intersections(self, radius, lane_pairs, strict=True):
intersections = OrderedDict()
mapped_intersection_center = self.mapped_intersection_center()
intersection_center = self.intersection_center()
circle = Circle(intersection_center, radius)
node = self._road_node
for lane in self.lanes():
path = lane.path_for(self._geometry_class)
path_intersections = path.find_intersection(circle)
indexed_intersections = OrderedDict()
for intersection in path_intersections:
point = intersection.closest_point_to(
mapped_intersection_center)
rounded_point = point.rounded_to(7)
indexed_intersections[rounded_point] = point
path_intersections = indexed_intersections.values()
intersections[lane] = self._get_waypoints_for_intersections(
lane, path_intersections)
for (exit_lane, entry_lane) in lane_pairs.keys():
exit_waypoint = None
entry_waypoint = None
try:
exit_waypoint = self._get_exit_waypoint_from_intersections(
intersections[exit_lane])
entry_waypoint = self._get_entry_waypoint_from_intersections(
intersections[entry_lane])
# TODO: Improve this way of handling errors
except RuntimeError as error:
if strict:
raise JunctionNotSatisfied()
if exit_waypoint and entry_waypoint:
if exit_waypoint.center().almost_equal_to(
entry_waypoint.center(), 5):
raise JunctionNotSatisfied()
primitive = self._geometry_class.connect(
exit_waypoint, entry_waypoint)
if strict and (not primitive
or not primitive.is_valid_path_connection()):
raise JunctionNotSatisfied()
if primitive:
lane_pairs[(exit_lane, entry_lane)] = WaypointConnection(
exit_waypoint, entry_waypoint, primitive)
return lane_pairs
def _is_legal_segment(self, triangle, segment):
if segment in self._base_triangle.segments:
return True
point_i = segment.start
point_j = segment.end
point_l = triangle.last_points([point_i, point_j])[0]
near_triangle = triangle.get_near_triangle_by_segment(segment)
point_k = near_triangle.last_points([point_i, point_j])[0]
ind_i = self._point_index(point_i)
ind_j = self._point_index(point_j)
ind_l = self._point_index(point_l)
ind_k = self._point_index(point_k)
# circle = Circle(point_a=point_i, point_b=point_j, point_c=point_l)
# return point_k not in circle
if ind_i > 0 and ind_j > 0 and ind_k > 0 and ind_l > 0:
circle = Circle(point_a=point_i, point_b=point_j, point_c=point_l)
return point_k in circle
return min(ind_l, ind_k) < min(ind_i, ind_j)
def circleArea():
circArea = Circle(5)
result = circArea.circle_area()
return 'Luas lingkaran jika jari-jari = 5 adalah ' + str(result)
def test_x(self):
circle = Circle(1, {'x': 8, 'y': 4})
self.assertEqual(circle.x(), 8)
def test_intersection_at_two_points(self):
# with circles with centers at different x and different y
circle1 = Circle(Point(0, 0), 1)
circle2 = Circle(Point(1, 1), 1)
self.assertEqual(circle1.intersection(circle2),
[Point(1, 0), Point(0, 1)])
# with each center outside the other circle
circle1 = Circle(Point(-3, 0), 5)
circle2 = Circle(Point(3, 0), 5)
self.assertEqual(circle1.intersection(circle2),
[Point(0, 4), Point(0, -4)])
circle1 = Circle(Point(0, -3), 5)
circle2 = Circle(Point(0, 3), 5)
self.assertEqual(circle1.intersection(circle2),
[Point(4, 0), Point(-4, 0)])
# with each's center inside the other circle
circle1 = Circle(Point(0, 0), math.sqrt(65))
circle2 = Circle(Point(4, 0), 5)
self.assertAlmostEqual(
circle1.intersection(circle2),
[Point(7.0, 4.0, 0.0), Point(7.0, -4.0, 0.0)])
circle1 = Circle(Point(0, 0), math.sqrt(65))
circle2 = Circle(Point(0, 4), 5)
self.assertAlmostEqual(
circle1.intersection(circle2),
[Point(4.0, 7.0, 0.0), Point(-4.0, 7.0, 0.0)])
# with one center inside the other circle and the line that contains both intersection points containing one circle's center
circle1 = Circle(Point(0, 0), 5)
circle2 = Circle(Point(-4, 0), 3)
self.assertAlmostEqual(circle1.intersection(circle2),
[Point(-4, 3), Point(-4, -3)])
circle1 = Circle(Point(0, 0), 5)
circle2 = Circle(Point(0, -4), 3)
self.assertAlmostEqual(circle1.intersection(circle2),
[Point(3, -4), Point(-3, -4)])
# with each's center inside the other circle and the line that contains both intersection points separating both centers
circle1 = Circle(Point(0, 0), 3)
circle2 = Circle(Point(2, 0), 3)
self.assertAlmostEqual(
circle1.intersection(circle2),
[Point(1, math.sqrt(8)),
Point(1, -math.sqrt(8))])
# with one center in the perimeter of the other circle
circle1 = Circle(Point(0, 0), 1)
circle2 = Circle(Point(1, 0), 1)
self.assertAlmostEqual(circle1.intersection(circle2), [
Point(1.0 / 2, math.sqrt(3.0 / 4)),
Point(1.0 / 2, -math.sqrt(3.0 / 4))
])
circle1 = Circle(Point(0, 0), 1)
circle2 = Circle(Point(0, 1), 1)
self.assertAlmostEqual(circle1.intersection(circle2), [
Point(math.sqrt(3.0 / 4), 1.0 / 2),
Point(-math.sqrt(3.0 / 4), 1.0 / 2)
])
def test_y(self):
circle = Circle(1, {'x': 7, 'y': 3})
self.assertEqual(circle.y(), 3)
def test_diameter(self):
circle = Circle(13)
self.assertEqual(circle.diameter(), 26)
def test_intersection_with_concentric_circles(self):
circle1 = Circle(Point(3, 3), 6)
circle2 = Circle(Point(3, 3), 8)
self.assertEqual(circle1.intersection(circle2), [])
def test_intersection_between_equal_circles(self):
circle = Circle(Point(45, 7), 9)
self.assertEqual(circle.intersection(circle), [circle])
def circle(self):
return Circle(self.center_point(), self.radius())
def test_area(self):
circle = Circle(2)
# area = pi * (2 ** 2) = ~12.57
self.assertEqual(round(circle.area(), 2), 12.57)
# # square = Square(point, 3)
# # print (square.getArea())
#
# print (listOfQuadrangles)
#
# sum = 0
# for quadrangle in listOfQuadrangles:
# try:
# sum += quadrangle.getPerimetr()
# except NotImplementedError:
# print ("Broken Quadrangle")
# print (sum)
# quadranglesCollection = QuadranglesCollection([
# Rectangle(Point(0, 0), 6, 3),
# Rectangle(Point(1, 1), 3, 4),
# Rectangle(Point(2, 2), 4, 5)
# ])
#
# print (quadranglesCollection.getTheWidest().getPoint().getX())
# print (quadranglesCollection.getTheHighest().getPoint().getX())
circlesCollection = CirclesCollection(
[Circle(Point(0, 0), 6),
Circle(Point(1, 1), 3),
Circle(Point(2, 2), 4)])
print(circlesCollection.getTheWidest().getPoint().getX())
print(circlesCollection.getTheHighest().getPoint().getX())
def test_radius(self):
circle = Circle(2)
self.assertEqual(circle.radius(), 2)
def setUp(self):
"""Set up a new object to be tested"""
dia = 65.0
self.c = Circle(dia)
def test_perimeter(self):
circle = Circle(3)
# perimeter = 2 * pi * 3 = ~18.85
self.assertEqual(round(circle.perimeter(), 2), 18.85)
def test_init(self):
circle = Circle(5)
self.assertIsInstance(circle, Circle)
