def test_find_segments_in_polylines_two_lines(self):
top = [Point2D(x, 0) for x in range(0, 5)]
bottom = [Point2D(x, 4) for x in range(0, 5)]
points = top + bottom
originating_point = Point2D(0, 0)
points_rotated = []
for point in points:
points_rotated.append(point.rotate(pi / 4, originating_point))
segments_reference = {
Segment(points_rotated[0], points_rotated[4]),
Segment(points_rotated[5], points_rotated[9])
}
finder = RansacSegmentsFinder(0.001, 1.1)
segments = finder.find_segments_in_points(points_rotated)
for segment_real in segments:
found_similarities = 0
similar = None
for segment_reference in segments_reference:
if self.are_segments_close(segment_real, segment_reference):
similar = segment_reference
found_similarities += 1
self.assertEqual(1, found_similarities)
segments_reference.remove(similar)
def test_issue_13230():
c1 = Circle(Point2D(3, sqrt(5)), 5)
c2 = Circle(Point2D(4, sqrt(7)), 6)
assert intersection(c1, c2) == [Point2D(-1 + (-sqrt(7) + sqrt(5))*(-2*sqrt(7)/29
+ 9*sqrt(5)/29 + sqrt(196*sqrt(35) + 1941)/29), -2*sqrt(7)/29 + 9*sqrt(5)/29
+ sqrt(196*sqrt(35) + 1941)/29), Point2D(-1 + (-sqrt(7) + sqrt(5))*(-sqrt(196*sqrt(35)
+ 1941)/29 - 2*sqrt(7)/29 + 9*sqrt(5)/29), -sqrt(196*sqrt(35) + 1941)/29 - 2*sqrt(7)/29 + 9*sqrt(5)/29)]
def test_object_from_equation():
from sympy.abc import x, y, a, b
assert Circle(x**2 + y**2 + 3 * x + 4 * y - 8) == Circle(
Point2D(S(-3) / 2, -2),
sqrt(57) / 2)
assert Circle(x**2 + y**2 + 6 * x + 8 * y + 25) == Circle(
Point2D(-3, -4), 0)
assert Circle(a**2 + b**2 + 6 * a + 8 * b + 25, x="a",
y="b") == Circle(Point2D(-3, -4), 0)
assert Circle(x**2 + y**2 - 25) == Circle(Point2D(0, 0), 5)
assert Circle(x**2 + y**2) == Circle(Point2D(0, 0), 0)
assert Circle(a**2 + b**2, x="a", y="b") == Circle(Point2D(0, 0), 0)
assert Circle(x**2 + y**2 + 6 * x + 8) == Circle(Point2D(-3, 0), 1)
assert Circle(x**2 + y**2 + 6 * y + 8) == Circle(Point2D(0, -3), 1)
assert Circle(6 * (x**2) + 6 * (y**2) + 6 * x + 8 * y - 25) == Circle(
Point2D(Rational(-1, 2), Rational(-2, 3)), 5 * sqrt(37) / 6)
assert Circle(Eq(a**2 + b**2, 25), x="a", y=b) == Circle(Point2D(0, 0), 5)
raises(GeometryError, lambda: Circle(x**2 + y**2 + 3 * x + 4 * y + 26))
raises(GeometryError, lambda: Circle(x**2 + y**2 + 25))
raises(GeometryError, lambda: Circle(a**2 + b**2 + 25, x="a", y="b"))
raises(GeometryError, lambda: Circle(x**2 + 6 * y + 8))
raises(GeometryError, lambda: Circle(6 * (x**2) + 4 *
(y**2) + 6 * x + 8 * y + 25))
raises(ValueError, lambda: Circle(a**2 + b**2 + 3 * a + 4 * b - 8))
def check_smooth_data(new_point, old_point):
present_loc = Point2D(new_point)
old_loc = Point2D(old_point)
eucledian_dist = (present_loc.distance(old_loc)).evalf()
if eucledian_dist > 30:
return False
return True
def zadanie2():
print("Zadanie 2")
metoda_najmniejszych_kwadratow(1, Point2D(1, 18), Point2D(2, 16),
Point2D(3, 13), Point2D(4,
11), Point2D(5, 9),
Point2D(6, 7), Point2D(7, 5), Point2D(8, 4),
Point2D(9, 1), Point2D(10, 1))
def test(self):
point1 = Point2D(1, 1)
point2 = Point2D(2, 2)
normal = Neighbourhood(point1, [point2]).normal()
self.assertIn(normal, [Point2D(-1, 1), Point2D(1, -1)])
def test_init(self):
points = [Point2D(6, 5), Point2D(7, 4), Point2D(8, 7), Point2D(5, 6), Point2D(5, 4)]
entity = LinearRegressionEntity(points)
coordinator = LinearRegressionCoordinator(entity, 10)
self.assertEqual(first=entity, second=coordinator.entity)
self.assertEqual(first=coordinator.start_index, second=10)
def test_trivial_weighted_mean_entity(self):
points = [Point2D(2, 2), Point2D(2, 5), Point2D(6, 5), Point2D(7, 3), Point2D(4, 7)]
entity = LinearRegressionEntity(points)
weighted_entity = LinearRegressionEntity.weighted_mean_entity([entity])
self.assertAlmostEquals(first=entity.slope, second=weighted_entity.slope, delta=1e-6)
self.assertAlmostEquals(first=entity.offset, second=weighted_entity.offset, delta=1e-6)
def test_draw_onto_canvas_random_position(self):
# Arrange
symbol = HomusSymbol("",
[[Point2D(0, 0), Point2D(100, 100)]], "",
Rectangle(Point2D(0, 0), 100, 100))
export_path = ExportPath("", "", "bitmap_random", "png", 2)
bounding_boxes = dict()
# Act
symbol.draw_onto_canvas(export_path,
stroke_thickness=2,
margin=2,
destination_width=1000,
destination_height=1000,
random_position_on_canvas=True,
bounding_boxes=bounding_boxes)
# Assert
self.assertTrue(os.path.exists(export_path.get_full_path()))
bounding_box = bounding_boxes["bitmap_random_2.png"]
self.assertEqual(bounding_box.height, 100)
self.assertEqual(bounding_box.width, 100)
self.assertNotEqual(bounding_box.left, 450)
self.assertNotEqual(bounding_box.top, 450)
self.assertNotEqual(bounding_box.right, 550)
self.assertNotEqual(bounding_box.bottom, 550)
# Cleanup
os.remove(export_path.get_full_path())
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 __getIntersections(self, point):
center = Point2D(0, 0)
line = Line2D(center, point)
midpoint = Point2D(point.x / 2, point.y / 2)
self.minBorderDist = min(self.minBorderDist, distToZero(midpoint.x, midpoint.y))
self.perpendicular = line.perpendicular_line(midpoint)
sectionIntersections = []
vertexIntersections = []
for i in range(self.sizeOfShell - 1):
section = Segment2D(self.shell[i], self.shell[i+1])
intersection = self.perpendicular.intersection(section)
if intersection:
sectionIntersections.append((i, self.perpendicular.intersection(section))) #add number of previous vertex and intersection point
if self.shell[i] in self.perpendicular:
vertexIntersections.append(i)
section = Segment2D(self.shell[0], self.shell[self.sizeOfShell-1])
intersection = self.perpendicular.intersection(section)
if intersection:
sectionIntersections.append((self.sizeOfShell-1, self.perpendicular.intersection(section))) # add number of previous vertex and intersection point
if self.shell[self.sizeOfShell - 1] in self.perpendicular:
vertexIntersections.append(self.sizeOfShell - 1)
#print(sectionIntersections)
#print(vertexIntersections)
self.__sections = sectionIntersections
self.__vertex = vertexIntersections
def find_segments_in_points(self, points: List[Point2D]) -> List[Segment]:
np_points = np.ndarray((len(points), 2))
segments = []
for idx, point in enumerate(points):
np_points[idx, 0] = point.x
np_points[idx, 1] = point.y
is_density_valid = True
is_length_valid = True
while len(np_points) > 2 \
and (self.density_threshold is None or is_density_valid) \
and (self.length_threshold is None or is_length_valid):
model_robust, inliers_mask = ransac(
np_points,
LineModelND,
min_samples=2,
residual_threshold=self.residual_threshold,
max_trials=self.max_trials)
inliers = np_points[inliers_mask]
line_params = model_robust.params
origin = Point2D(line_params[0][0], line_params[0][1])
direction = Point2D(line_params[1][0], line_params[1][1])
line = Line(origin, origin + direction)
points = [Point2D(point[0], point[1]) for point in inliers]
found_segments = SegmentsInLineFinder.find_segments_with_density(
line, points, 150)
current_segments = []
densities = []
lengths = []
for found_segment in found_segments:
current_segments.append(found_segment.segment)
densities.append(found_segment.density)
lengths.append(found_segment.segment.length)
if len(densities) > 0:
avg_density = np.mean(densities)
avg_length = np.mean(lengths)
if self.density_threshold:
is_density_valid = avg_density > self.density_threshold
if self.length_threshold:
is_length_valid = avg_length > self.length_threshold
else:
is_density_valid = False
is_length_valid = False
segments += current_segments
np_points = np_points[~inliers_mask]
return segments
def test_get_objects_separate_lists(self):
a = Area()
point = Point2D(1, 1)
segment = Segment(Point2D(3, 3), Point2D(4, 4))
a.add_object(Point2D, point)
a.add_object(Segment, segment)
self.assertListEqual(a.get_objects(Point2D), [point])
self.assertListEqual(a.get_objects(Segment), [segment])
def test_linear_entity_init(self):
points = [Point2D(0, 0), Point2D(1, 1), Point2D(2, 2)]
entity = LinearRegressionEntity(points)
self.assertEqual(entity.points, points)
self.assertAlmostEqual(first=entity._slope, second=math.tan(math.pi/4.0), delta=1e-6)
self.assertAlmostEqual(first=entity._offset, second=0, delta=1e-6)
self.assertIsNotNone(entity.covariance)
def test_hard_mahalanobis_distance_sqr(self):
points1 = [Point2D(2, 2), Point2D(2, 5), Point2D(6, 5), Point2D(7, 3), Point2D(4, 7)]
points2 = [Point2D(6, 5), Point2D(7, 4), Point2D(8, 7), Point2D(5, 6), Point2D(5, 4)]
entity1 = LinearRegressionEntity(points1)
entity2 = LinearRegressionEntity(points2)
d = LinearRegressionEntity.mahalanobis_distance_sqr(entity1, entity2)
self.assertAlmostEqual(first=d, second=0.543724758, delta=1e-6)
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_convert_simple_points_inverse_correct(self):
points = [Point2D(-1, -1), Point2D(1, 1)]
converter = PointsToImageRoundBasedConverter()
image, inverse_converter = converter.convert(points)
self.assertEqual(inverse_converter.convert(Point2D(0, 0)), points[0])
self.assertEqual(inverse_converter.convert(Point2D(2, 2)), points[1])
def test_one_line(self):
file_path = path.join(self.test_dir, 'test1.txt')
with open(file_path, 'w') as f:
f.write("2372536:(-114.352;-201.86;0),(-113.112;-202.558;0),")
area = XYFileAreaReader.get_area(file_path)
assert area.get_objects(Point2D) == [
Point2D(-114.352, -201.86),
Point2D(-113.112, -202.558)
]
def test_can_merge_true(self):
points1 = [Point2D(6, 5), Point2D(7, 4), Point2D(8, 7), Point2D(5, 6), Point2D(5, 4)]
entity1 = LinearRegressionEntity(points1)
coordinator1 = LinearRegressionCoordinator(entity1, 2)
points2 = [Point2D(6, 5), Point2D(7, 4), Point2D(8, 7), Point2D(5, 6), Point2D(5, 4)]
entity2 = LinearRegressionEntity(points2)
coordinator2 = LinearRegressionCoordinator(entity2, 5)
self.assertTrue(coordinator2.can_merge(coordinator1))
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_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 test_convert_decimal_points_image(self):
points = [Point2D(10.4, 10.3), Point2D(11.3, 11.4)]
image_reference = np.zeros((2, 2), dtype=int)
image_reference[0, 0] = 1
image_reference[1, 1] = 1
converter = PointsToImageRoundBasedConverter()
image, inverse_converter = converter.convert(points)
self.assertTrue(np.array_equal(image, image_reference))
def test_convert_simple_points_image_correct(self):
points = [Point2D(-1, -1), Point2D(1, 1)]
image_reference = np.zeros((3, 3), dtype=int)
image_reference[0, 0] = 1
image_reference[2, 2] = 1
converter = PointsToImageRoundBasedConverter()
image, inverse_converter = converter.convert(points)
self.assertTrue(np.array_equal(image, image_reference))
def test_init_weighted_mean_entity(self):
points1 = [Point2D(2, 2), Point2D(2, 5), Point2D(6, 5), Point2D(7, 3), Point2D(4, 7)]
points2 = [Point2D(6, 5), Point2D(7, 4), Point2D(8, 7), Point2D(5, 6), Point2D(5, 4)]
entity1 = LinearRegressionEntity(points1)
entity2 = LinearRegressionEntity(points2)
weighted_mean_entity = LinearRegressionEntity.weighted_mean_entity([entity1, entity2])
self.assertIsNotNone(weighted_mean_entity.slope)
self.assertIsNotNone(weighted_mean_entity.offset)
self.assertIsNotNone(weighted_mean_entity.covariance)
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 get_square_area():
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
area = Area()
for point in square:
area.add_object(Point2D, point)
return area
def intersect(x1, y1, x2, y2, x3, y3, x4, y4):
p1 = Point2D(x1, y1)
p2 = Point2D(x2, y2)
p3 = Point2D(x3, y3)
p4 = Point2D(x4, y4)
s1 = Segment(p1, p2)
s2 = Segment(p3, p4)
if s1.intersection(s2):
return True
return False
def _dist_function(point, start, end):
"""
This is simple method to find the euclidean distance. It was implemented here, since rdp's internal one
does not work correctly on zero distances
:param point: Point, which distance is measured to
:param start: Start point of the segment
:param end: End point of the segment
:return: Euclidean distance
"""
start_point = Point2D(start[0], start[1])
end_point = Point2D(end[0], end[1])
point_point = Point2D(point[0], point[1])
return Segment(start_point, end_point).distance(point_point)
def test_merge_same(self):
points1 = [Point2D(6, 5), Point2D(7, 4), Point2D(8, 7), Point2D(5, 6), Point2D(5, 4)]
entity1 = LinearRegressionEntity(points1)
coordinator1 = LinearRegressionCoordinator(entity1, 2)
points2 = [Point2D(6, 5), Point2D(7, 4), Point2D(8, 7), Point2D(5, 6), Point2D(5, 4)]
entity2 = LinearRegressionEntity(points2)
coordinator2 = LinearRegressionCoordinator(entity2, 2)
coordinator = coordinator2.merge(coordinator1)
self.assertEqual(first=coordinator.start_index, second=2)
self.assertEqual(first=len(coordinator.entity.points), second=5)
