def test_get_segments_same_point(self):
t = Polyline()
points = [Point2D(0, 0), Point2D(0, 0), Point2D(2, 2)]
for point in points:
t.add(point)
self.assertRaises(ValueError, t.get_segments)
def test_find_polylines_one_point(self):
point = Point2D(1, 1)
polyline = Polyline()
polyline.add(point)
finder = PolylinesFinder(epsilon=0.5)
self.assertListEqual(finder.find_polylines([point]), [polyline])
def test_find_polylines_two_near_points(self):
point1 = Point2D(1, 1)
point2 = Point2D(1, 2)
polyline = Polyline()
polyline.add(point1)
polyline.add(point2)
finder = PolylinesFinder(epsilon=2)
self.assertListEqual(finder.find_polylines([point1, point2]), [polyline])
def test_get_segments_simple(self):
t = Polyline()
points = [Point2D(0, 0), Point2D(1, 1), Point2D(2, 2)]
for point in points:
t.add(point)
self.assertListEqual(
t.get_segments(),
[Segment(points[0], points[1]),
Segment(points[1], points[2])])
def test_find_polylines_two_distant_polylines(self):
points = [Point2D(1, 1), Point2D(1, 1.1), Point2D(2, 2), Point2D(2, 2.1)]
polylines = [Polyline(), Polyline()]
polylines[0].add(points[0])
polylines[0].add(points[1])
polylines[1].add(points[2])
polylines[1].add(points[3])
finder = PolylinesFinder(epsilon=0.5)
self.assertListEqual(finder.find_polylines(points), [polylines[0], polylines[1]])
def test_find_polyline_in_points_simple(self):
points = [Point2D(0, 0), Point2D(1, 1), Point2D(2, 2), Point2D(3, 3)]
polyline_reference = Polyline()
polyline_reference.add(points[0])
polyline_reference.add(points[3])
finder = RDPSegmentsFinder(epsilon=0.5)
polyline = finder.find_polyline_in_points(points)
self.assertEqual(polyline, polyline_reference)
def test_find_simple(self):
point = Point2D(1, 1)
polyline = Polyline()
polyline.add(point)
area = Area()
area.add_object(Point2D, point)
finder = PolylinesFinder(epsilon=0.5)
finder.find(area)
self.assertListEqual(area.get_objects(Polyline), [polyline])
def test_find_simple(self):
points = [Point2D(0, 0), Point2D(1, 1), Point2D(2, 2), Point2D(3, 3)]
area = Area()
polyline = Polyline()
for point in points:
polyline.add(point)
area.add_object(Polyline, polyline)
finder = RDPSegmentsFinder(epsilon=0.5)
finder.find(area)
self.assertListEqual(area.get_objects(Segment),
[Segment(points[0], points[-1])])
def test_find_polylines_two_distant_points(self):
point1 = Point2D(1, 1)
point2 = Point2D(1, 2)
polyline1 = Polyline()
polyline1.add(point1)
polyline2 = Polyline()
polyline2.add(point2)
finder = PolylinesFinder(epsilon=0.5)
self.assertListEqual(finder.find_polylines([point1, point2]), [polyline1, polyline2])
def find_polyline_in_points(self, points: List[Point2D]) -> Polyline:
"""
Finds polyline in given points list, using The Ramer-Douglas-Peucker algorithm
:param points: List of points
:return: Polyline
"""
points_lists = [[point.x, point.y] for point in points]
mask = rdp(points_lists,
return_mask=True,
epsilon=self._epsilon,
dist=self._dist_function)
main_points = [
point for point, is_main in zip(points, mask) if is_main
]
polyline = Polyline()
for point in main_points:
polyline.add(point)
return polyline
def test_find_segments_in_polylines_square(self):
top = [Point2D(x, 0) for x in range(0, 5)]
right = [Point2D(4, y) for y in range(1, 5)]
bottom = [Point2D(x, 4) for x in range(3, 0, -1)]
left = [Point2D(0, y) for y in range(4, 0, -1)]
square = top + right + bottom + left
polyline = Polyline()
for point in square:
polyline.add(point)
segments_reference = {
Segment(square[0], square[4]),
Segment(square[4], square[8]),
Segment(square[8], square[12]),
Segment(square[12], square[15])
}
finder = RDPSegmentsFinder(epsilon=0.5)
segments = finder.find_segments_in_polylines([polyline])
self.assertSetEqual(set(segments), segments_reference)
def find_polylines(self, points: List[Point2D]) -> List[Polyline]:
if len(points) == 0:
raise ValueError("There is no points")
found_polylines = []
current_polyline = Polyline()
previous_point = None
for current_point in points:
if previous_point is not None and not self._accept_point(current_point, previous_point):
found_polylines.append(current_polyline)
current_polyline = Polyline()
current_polyline.add(current_point)
previous_point = current_point
found_polylines.append(current_polyline)
return found_polylines