def near_far_corner_distance(self, cur_line_segment):
dis_lt_origin = distances.point_distance(self.__left_top_p,
self.__origin_p)
dis_rt_origin = distances.point_distance(self.__right_top_p,
self.__origin_p)
dis_rb_origin = distances.point_distance(self.__right_bottom_p,
self.__origin_p)
dis_lb_origin = distances.point_distance(self.__left_bottom_p,
self.__origin_p)
min_value = float('inf')
max_value = 0
min_index = 0
max_index = 0
four_dis = [dis_lt_origin, dis_rt_origin, dis_rb_origin, dis_lb_origin]
for i in range(len(four_dis)):
if four_dis[i] > max_value:
max_value = four_dis[i]
max_index = i
if four_dis[i] < min_value:
min_value = four_dis[i]
min_index = i
boxs = self.get_box()
start_point = cur_line_segment.get_start()
end_point = cur_line_segment.get_end()
nearest_dis = distances.perpendicular_distance(start_point,
boxs[min_index],
end_point)
farthest_dis = distances.perpendicular_distance(
start_point, boxs[max_index], end_point)
return [nearest_dis, farthest_dis]
def get_active_point(start_point, cur_active_point, cur_line_segment,
error_bound):
s = start_point.get_id()
a = cur_active_point.get_id()
i = a + 1
flag = True
if i < len(points):
R_i = LineSegment(start_point, points[i])
while (R_i.get_distance() -
cur_line_segment.get_distance()) <= error_bound / 4 and i < len(
points) and (i - s) < 4 * math.pow(10, 5):
dis_i_la = distances.perpendicular_distance(
cur_line_segment.get_start(), points[i],
cur_line_segment.get_end())
R_a = LineSegment(start_point, cur_active_point)
dis_i_ra = distances.perpendicular_distance(
R_a.get_start(), points[i], R_a.get_end())
if dis_i_la > error_bound / 2 or dis_i_ra > error_bound:
flag = False
break
i += 1
if i >= len(points):
break
R_i = LineSegment(start_point, points[i])
if i < len(points):
dis_i_la = distances.perpendicular_distance(
cur_line_segment.get_start(), points[i],
cur_line_segment.get_end())
if dis_i_la > error_bound / 2 and cur_line_segment.get_distance(
) > 0:
flag = False
if i == len(points):
i = -1
return i, flag
def get_intersection_distance(lower_boundingline, upper_boundingline,
cur_linesegment):
l1 = lower_boundingline[0]
l2 = lower_boundingline[1]
u1 = upper_boundingline[0]
u2 = upper_boundingline[1]
start_p = cur_linesegment.get_start()
end_p = cur_linesegment.get_end()
l1_ls_dis = distances.perpendicular_distance(start_p, l1, end_p)
l2_ls_dis = distances.perpendicular_distance(start_p, l2, end_p)
u1_ls_dis = distances.perpendicular_distance(start_p, u1, end_p)
u2_ls_dis = distances.perpendicular_distance(start_p, u2, end_p)
return [l1_ls_dis, l2_ls_dis, u1_ls_dis, u2_ls_dis]
def fit_function(s, cur_active_point, cur_line_segment, error_bound):
a = cur_active_point.get_id()
R_i = LineSegment(points[s], points[a])
next_line_segment = None
# 活跃点所处区域
j = math.ceil(R_i.get_distance() * (2 / error_bound) - 0.5)
if R_i.get_distance() - cur_line_segment.get_distance() <= error_bound / 4:
next_line_segment = cur_line_segment
elif R_i.get_distance(
) > error_bound / 4 and cur_line_segment.get_distance() == 0:
length = (j * error_bound / 2) / 1000
angle = calc_angle(R_i)
end_point = calc_endp(length, angle, s)
next_line_segment = LineSegment(points[s], end_point)
else:
length = (j * error_bound / 2) / 1000
dis = distances.perpendicular_distance(cur_line_segment.get_start(),
points[a],
cur_line_segment.get_end())
div = dis / (j * error_bound / 2)
if div > 1:
div = 1
angle = calc_angle(cur_line_segment) + assign(
R_i, cur_line_segment) * math.asin(div) / j
end_point = calc_endp(length, angle, s)
next_line_segment = LineSegment(points[s], end_point)
return next_line_segment
def corner_distance(self, cur_line_segment):
start_point = cur_line_segment.get_start()
end_point = cur_line_segment.get_end()
dis_lt_ls = distances.perpendicular_distance(start_point,
self.__left_top_p,
end_point)
dis_rt_ls = distances.perpendicular_distance(start_point,
self.__right_top_p,
end_point)
dis_rb_ls = distances.perpendicular_distance(start_point,
self.__right_bottom_p,
end_point)
dis_lb_ls = distances.perpendicular_distance(start_point,
self.__left_bottom_p,
end_point)
return [dis_lt_ls, dis_rt_ls, dis_rb_ls, dis_lb_ls]
def recalc_deviation(bqs, cur_linesegment):
max_distance = 0
start_p = cur_linesegment.get_start()
end_p = cur_linesegment.get_end()
for point in bqs:
dis = distances.perpendicular_distance(start_p, point, end_p)
if dis > max_distance:
max_distance = dis
return max_distance
def dp_compress(points, feature_points, max_value):
start_index = 0
end_index = len(points) - 1
if start_index < end_index:
index = start_index + 1
max_vertical_distance = 0
key_point_index = 0
while index < end_index:
curr_distance = distances.perpendicular_distance(
points[start_index], points[index], points[end_index])
if curr_distance >= max_vertical_distance:
max_vertical_distance = curr_distance
key_point_index = index
index = index + 1
if max_vertical_distance >= max_value:
feature_points.append(points[key_point_index])
dp_compress(points[start_index:key_point_index + 1],
feature_points, max_value)
dp_compress(points[key_point_index:end_index + 1], feature_points,
max_value)