def find_intersections(points, x, y, slope): intersection_set = [] line_segments = [] for i in range(0, len(points) - 1): if points[i].jump: continue suggested_point = intersection(LineSegment(points[i], points[i + 1]), stitchcode.Point(x, y), slope) if suggested_point is not None: if suggested_point == points[i]: index = get_surrounding_point_indexes(points, i) is_significant_corner = intersection( LineSegment(points[index[0]], points[index[1]]), stitchcode.Point(x, y), slope) if is_significant_corner is not None: intersection_set.append(suggested_point) else: intersection_set.append(suggested_point) intersection_set.append( stitchcode.Point(suggested_point.x, suggested_point.y)) elif suggested_point != points[i + 1]: intersection_set.append(suggested_point) #for n in range(0, len(intersection_set)-1, 2): # line_segments.append(LineSegment(intersection_set[n], intersection_set[n + 1])) while len(intersection_set) > 0: p1 = find_closest_points(intersection_set) line_segments.append( LineSegment(intersection_set[0], straight_stitch.copy(intersection_set[p1]))) if (p1 != 0): intersection_set.pop(p1) intersection_set.pop(0) return line_segments
def set_hight(self, line): self.hight = line if (hasattr(self.third_side, 'length') == True): self.third_side_sub1 = LineSegment(self.lineSegment1.point1, self.hight.point1) print("self.third_side_sub1.name: ", self.third_side_sub1.name) self.third_side_sub1.set_length(self.third_side.length / 2) print("self.third_side_sub1.length: ", self.third_side_sub1.length) self.third_side_sub2 = LineSegment(self.lineSegment2.point1, self.hight.point1) print("self.third_side_sub2.name: ", self.third_side_sub2.name) self.third_side_sub2.set_length(self.third_side.length / 2) print("self.third_side_sub2.length: ", self.third_side_sub2.length)
def MDL_cost(self, segments, characteristic_points=[]): if len(characteristic_points) is 0: #MDLnopar LH = 0.0 for segment in segments: LH += segment.length if LH != 0.0: return np.log2(LH) return 0.0 characteristic_segment = LineSegment(characteristic_points[0], characteristic_points[1]) if characteristic_segment.length > 0.0: LH = np.log2(characteristic_segment.length) else: LH = 0.0 perp_d = 0.0 ang_d = 0.0 for segment in segments: perp_d += segment.perpendicular_distance(characteristic_segment) ang_d += segment.angle_distance(characteristic_segment) if perp_d != 0.0: perp_d = np.log2(perp_d) if ang_d != 0.0: ang_d = np.log2(ang_d) return LH + perp_d + ang_d
def find_lines(self, rho=5, theta=np.pi / 180, threshold=15, min_line_len=10, max_line_gap=5): """ uses hough transforms to find lines in the image """ self.find_edges() #mask area self.mask_road_roi(self.edges_img) lines = cv2.HoughLinesP(self.edges_img, rho, theta, threshold, np.array([]), minLineLength=min_line_len, maxLineGap=max_line_gap) self.line_segments = LineSegment.create_lines(lines) self.lines_img = np.copy(self.image) self.draw_lines(self.lines_img, self.line_segments)
def findGlobalCorner(chamferLine, cubeLine, globalCubeLine, pose): intersectionPoint = LineSegment.intersectionPt(chamferLine, cubeLine) chamferLine = LineSegment(chamferLine.start_point, intersectionPoint) cubeLine = LineSegment(cubeLine.start_point, intersectionPoint) def lossFun(weight, intersectionPoint, line, pose): globalPoint = weight * line.start_point + (1 - weight) * line.end_point candidatePoint = pose.projectPointToImage(globalPoint) return pose.pointLoss(candidatePoint, intersectionPoint) weight = 0 finalPose = least_squares(lossFun, weight, args=(intersectionPoint, globalCubeLine, pose)) weight = finalPose.x return weight * globalCubeLine.start_point + ( 1 - weight) * globalCubeLine.end_point, intersectionPoint
def average_segments(self, clusters): for cluster in clusters: av_vector = np.array([0.0, 0.0]) av_start = np.array([0.0, 0.0]) for line in cluster: av_vector += line.vector av_start += line.a av_vector /= len(cluster) av_start /= len(cluster) self.cluster_info.append({"average": LineSegment(av_start, av_start + av_vector), "num": len(cluster)})
def build_line_segments(layout, edges, nodes): node_mapping = {node: index for index, node in enumerate(nodes)} lines = set() for node1 in edges.keys(): for node2 in edges[node1]: lines.add( LineSegment(layout[node_mapping[node1]], layout[node_mapping[node2]])) return lines
def representative_trajectory(self, cluster): # TODO: Fix this :/ rep_trajectory = [] #Average direction vector: av_vector = np.array([0.0, 0.0]) for line in cluster: av_vector += line.vector av_vector /= len(cluster) print(av_vector) unit_av = av_vector/np.linalg.norm(av_vector) print(unit_av) x = np.array([1.0, 0.0]) theta = np.arccos(x.dot(unit_av)) if unit_av[1] > 0.0: theta = -theta rotation_mat = np.array([[np.cos(theta), -np.sin(theta)], [np.sin(theta), np.cos(theta)]]) back_rotation_mat = np.array([[np.cos(-theta), np.sin(-theta)], [-np.sin(-theta), np.cos(-theta)]]) rotated_points = [] rotated_lines = [] for line in cluster: rot_v = rotation_mat.dot(line.vector) rot_b = line.a + line.length*rot_v rotated_points.append({"end": False, "point":line.a}) rotated_points.append({"end": True, "point": rot_b}) rotated_lines.append(LineSegment(line.a, rot_b)) rotated_points = sorted(rotated_points, key=lambda x: x["point"][0]) #Sort lines by starting x value line_start_lookup = SortedKeyList(rotated_lines, key=lambda x: x.a[0]) #Sort lines the sweep line crosses by ending x value intersecting_lines = SortedKeyList([], key=lambda x:x.b[0]) last_x = 0.0 for point_dict in rotated_points: if point_dict["end"]: try: intersecting_lines.pop(0) except Exception as e: print("Could not generate a representative trajectory. Examine your clustering parameters") break; else: intersecting_lines.add(line_start_lookup.pop(0)) if len(intersecting_lines) >= self.min_lns: # diff = point_dict["point"][0] - last_x # if diff >= self.gamma: average_y = 0.0 for line in intersecting_lines: slope = line.vector[1]/line.vector[0] average_y += (point_dict["point"][0]-line.a[0])*slope average_y /= len(intersecting_lines) rep_trajectory.append(np.array([point_dict["point"][0], average_y])) return rep_trajectory
def addSegment(self, point, turnRadius): point = np.array(point) if len(self.segments) is 0: self.segments.append(LineSegment(np.array([0,0]), point, 0, config.CONSTANT_VELOCITY, config.ACCEL)) else: prev = self.segments[-1] # We don't want to change velocity constraints on the first segment, but # any addition segments need to have velocity constraints adjusted because # they are added with a vf of 0 if len(self.segments) is not 1: prev.setVelocityConstraints(config.CONSTANT_VELOCITY, config.CONSTANT_VELOCITY, 0) vecB = point - prev.start # Arc to the goal point with a set turn radius # AB = The previous path vector segment # C = new goal point # Then the sign of AB (cross) AC determines the direction of the arc self.segments.append(ArcSegment(point, turnRadius, np.cross(prev.vector(), vecB) > 0)) # Add this segment assuming its the last one in the path self.segments.append(LineSegment(prev.stop, point, config.CONSTANT_VELOCITY, 0, config.ACCEL))
def __init__(self, points): assert isinstance(points, list) and all( isinstance(p, Point) for p in points) self.V = points # check if points assume general position # assert self.is_general_position, 'Input points must have distinct x-coordinates' # create edges and randomize self.E = [] for i, p in enumerate(points): self.E.append(LineSegment(p, points[(i + 1) % len(points)]))
class Isosceles_triangle: def __init__(self, lineSegment1, lineSegment2): self.lineSegment1 = lineSegment1 self.lineSegment2 = lineSegment2 def set_third_side(self, lineSegment3): self.third_side = lineSegment3 def set_hight(self, line): self.hight = line if (hasattr(self.third_side, 'length') == True): self.third_side_sub1 = LineSegment(self.lineSegment1.point1, self.hight.point1) print("self.third_side_sub1.name: ", self.third_side_sub1.name) self.third_side_sub1.set_length(self.third_side.length / 2) print("self.third_side_sub1.length: ", self.third_side_sub1.length) self.third_side_sub2 = LineSegment(self.lineSegment2.point1, self.hight.point1) print("self.third_side_sub2.name: ", self.third_side_sub2.name) self.third_side_sub2.set_length(self.third_side.length / 2) print("self.third_side_sub2.length: ", self.third_side_sub2.length)
def setPoint_on_circle(self, point): self.pointlist.append(point) if (len(self.pointlist) >= 2): self.line_segment = LineSegment( self.pointlist[len(self.pointlist) - 2], self.pointlist[len(self.pointlist) - 1]) print("The circle's arc line segment's name is: ", self.line_segment.name) self.isosceles_triangle = Isosceles_triangle( LineSegment(self.pointlist[len(self.pointlist) - 2], self.center), LineSegment(self.pointlist[len(self.pointlist) - 1], self.center)) self.isosceles_triangle.lineSegment1.set_length(self.radius) self.isosceles_triangle.lineSegment2.set_length(self.radius) self.isosceles_triangle.set_third_side(self.line_segment) print( "There is a isosceles_triangle in the circle: one equal side is:", self.isosceles_triangle.lineSegment1.name, " and the other equal side is", self.isosceles_triangle.lineSegment2.name) print("the isosceles_triangle's two equal side length is ", self.isosceles_triangle.lineSegment2.length)
def connect(points, start, stop): path = [] found_start = False found_stop = False found_start_first = False count = 0 while count < (len(points) * 2): i = count % (len(points) - 1) if is_along(LineSegment(points[i], points[i + 1]), start, 1): found_start = True if not found_stop: found_start_first = True if is_along(LineSegment(points[i], points[i + 1]), stop, 1): found_stop = True if found_start or found_stop: path.append(straight_stitch.copy(points[i])) if found_start and found_stop: break count = count + 1 if not found_start_first: path.reverse() if found_start and found_stop: return path return []
def calculate_right_lane(self, right_lines): if right_lines: m, b = self.calculate_average_line(right_lines) self.right_line = LineSegment.from_slope_equation( m, b, self.min_y, self.max_y)
def create_line_with_point(self, point): return LineSegment(self, point)
from Circle import Circle from Point import Point from LineSegment import LineSegment import math def prependicular(line1,line2): return True point_list = [] circle =Circle('O') circle.set_radius(5) point_list.append(Point('A')) point_list.append(Point('B')) circle.setPoint_on_circle(point_list[0]) circle.setPoint_on_circle(point_list[1]) for element in circle.pointlist: print("The point on the circle is: ", element.name) point_list.append(Point('C')) circle.line_segment.set_on_line_point(point_list[len(point_list)-1]) circle.line_segment.set_length(6) if(LineSegment(point_list[2],circle.center).name=='CO'): if(prependicular(LineSegment(point_list[2],circle.center),circle.line_segment)==True): if(hasattr(circle, 'isosceles_triangle')): circle.isosceles_triangle.set_hight(LineSegment(point_list[2],circle.center)) print("iso triangle's hight is: ",circle.isosceles_triangle.hight.name) print("the circle's line_segment's sublinesegment1 is: ",circle.line_segment.sublineSegment1.name) print("the circle's line_segment's sublinesegment2 is: ",circle.line_segment.sublineSegment2.name) print("CO's length is",math.sqrt((circle.isosceles_triangle.lineSegment1.length)**2-(circle.isosceles_triangle.third_side_sub1.length)**2))
print(image_name) file = np.load(image_name + '.npy', allow_pickle=True) points = [] detectedHoughLines = [] for num, line in enumerate(file): rho, theta = line[-3:-1] a = np.cos(theta) b = np.sin(theta) x0 = a * rho y0 = b * rho x1 = int(x0 + 10000 * (-b)) y1 = int(y0 + 10000 * (a)) x2 = int(x0 - 10000 * (-b)) y2 = int(y0 - 10000 * (a)) detectedHoughLines.append(LineSegment((x1, y1), (x2, y2))) file = np.load(image_name + '_chamfer.npy') points = [] chamferLines = [] for line in file: rho, theta = line[-3:-1] a = np.cos(theta) b = np.sin(theta) x0 = a * rho y0 = b * rho x1 = int(x0 + 10000 * (-b)) y1 = int(y0 + 10000 * (a)) x2 = int(x0 - 10000 * (-b)) y2 = int(y0 - 10000 * (a))
def calculate_left_lane(self, left_lines): if left_lines: m, b = self.calculate_average_line(left_lines) self.left_line = LineSegment.from_slope_equation( m, b, self.min_y, self.max_y)
def trajectory_partition(self, trajectory): """ Input: A trajectory T Ri = p1p2p3 · · · pj · · · pleni Output: A set CPi of characteristic points Algorithm: 01: Add p1 into the set CPi; /* the starting point */ 02: startIndex := 1, length := 1; 03: while (startIndex + length ≤ leni) do 04: currIndex := startIndex + length; 05: cost_par := MDL_par(pstartIndex, pcurrIndex); 06: cost_nopar := MDL_nopar(pstartIndex, pcurrIndex); /* check if partitioning at the current point makes the MDL cost larger than not partitioning */ 07: if (costpar > costnopar) then /* partition at the previous point */ 08: Add pcurrIndex−1 into the set CPi; 09: startIndex := currIndex − 1, length := 1; 10: else 11: length := length + 1; 12: Add pleni into the set CPi; /* the ending point */ (Lee, Han, & Whang, 2007) """ start_index = 0 length = 1 characteristic_points = [] segments = [] last_point = None for point in trajectory: if last_point is not None: segments.append(LineSegment(last_point, point)) last_point = point segments = np.array(segments) characteristic_points.append(trajectory[0]) while start_index + length < len(trajectory): curr_index = start_index + length """ MDL_par denotes the MDL Cost of a trajectory between p_i and p_j, when assuming that p_i and p_j are the only characteristic points. MDL_nopar denotes the MDL cost when assuming there is no characteristic point between the two, i.e preserving the original trajectory. """ cost_par = self.MDL_cost( segments[start_index:curr_index], [trajectory[start_index], trajectory[curr_index]]) cost_nopar = self.MDL_cost(segments[start_index:curr_index]) if cost_par > cost_nopar + 10: characteristic_points.append(trajectory[curr_index - 1]) start_index = curr_index - 1 length = 1 else: length += 1 characteristic_points.append(trajectory[len(trajectory) - 1]) char_segments = [] last_point = None for point in characteristic_points: if last_point is not None: char_segments.append(LineSegment(last_point, point)) last_point = point char_segments = np.array(char_segments) return (characteristic_points, char_segments)
def get_grays(filename): original = cv2.imread(filename, cv2.IMREAD_COLOR) filename = filename.split('//')[1] img = original.copy() height, width, depth = img.shape gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) th, bw = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY | cv2.THRESH_OTSU) edges = cv2.Canny(gray, th / 2, th) # edges = cv2.Canny(gray, 50, 150, apertureSize=3) lines = cv2.HoughLinesP(edges, 1, np.pi / 180, 100, minLineLength=80, maxLineGap=10) if lines is None: print(filename + ' No line detected.') return lss = [] black = np.zeros((height, width, depth), np.uint8) for line in lines: x1, y1, x2, y2 = line[0] cv2.line(img, (x1, y1), (x2, y2), green, 1) cv2.line(black, (x1, y1), (x2, y2), green, 1) ls = LineSegment(x1, y1, x2, y2) lss.append(ls) lines = sorted(lss, key=lambda x: x.theta) line_group = [] for ls in lines: if len(line_group) == 0: # first line group line_group.append([ls]) else: done = False for i in range(0, len(line_group)): if min(abs(line_group[i][0].theta - ls.theta), math.pi - abs(line_group[i][0].theta - ls.theta)) < theta_tolerance: # 比较斜率 line_group[i].append(ls) done = True break if not done: line_group.append([ls]) max_group = max(line_group, key=lambda x: len(x)) if all(abs(x.k < 1.0) for x in max_group): avg_k = sum([ls.k for ls in max_group]) / float(len(max_group)) avg_theta = math.atan(avg_k) else: avg_theta = sum([ls.theta for ls in max_group]) / float(len(max_group)) for ls in max_group: # 根据斜率找到的线段 ls.update(avg_theta) max_group.sort(key=lambda x: x.d) group_d = [] black2 = np.zeros((height, width, depth), np.uint8) for i in range(0, len(max_group)): ls = max_group[i] x1, x2, y1, y2 = ls.x1, ls.x2, ls.y1, ls.y2 cv2.line(black2, (x1, y1), (x2, y2), red, 3) j = len(group_d) - 1 if j < 0: new_g = LineSegmentGroup() new_g.insert(ls) group_d.append(new_g) else: if group_d[j].is_near(ls): group_d[j].insert(ls) else: new_g = LineSegmentGroup() new_g.insert(ls) group_d.append(new_g) cv2.putText(black, 'Group by d: ' + str(len(group_d)), (40, 200), font, 2, (255, 255, 255), 2) max_group = max(group_d, key=lambda x: len(x.lines)).lines for ls in max_group: x1, x2, y1, y2 = ls.x1, ls.x2, ls.y1, ls.y2 cv2.line(img, (x1, y1), (x2, y2), (0, 0, 255), 3) cv2.line(black, (x1, y1), (x2, y2), (0, 0, 255), 3) # 根据斜率 & x找到的线段 line_min = min(max_group, key=lambda x: x.d) line_max = max(max_group, key=lambda x: x.d) x_avgt = sum([ls.x for ls in max_group]) / (1.0 * len(max_group)) y_avgt = sum([ls.y for ls in max_group]) / (1.0 * len(max_group)) xx = x_avgt + 100 yy = y_avgt + 100 * math.tan(avg_theta) new_line = LineSegment(x_avgt, y_avgt, xx, yy) new_line.update(avg_theta) delta_d = (line_min.d + line_max.d) / 2.0 - new_line.d # cv2.circle(black, (int(x_avgt), int(y_avgt)), 20, (255, 0, 255), -1) xn = np.zeros((4, 2)) yn = np.zeros((4, 2)) dn = np.zeros(2) for i in range(0, 2): try: if i == 0: x_avg = x_avgt + delta_d * math.cos(avg_theta + math.pi / 2.0) y_avg = y_avgt + delta_d * math.sin(avg_theta + math.pi / 2.0) enlarge = (line_max.d - line_min.d) / 8.0 else: x_avg = x_avgt - delta_d * math.cos(avg_theta + math.pi / 2.0) y_avg = y_avgt - delta_d * math.sin(avg_theta + math.pi / 2.0) enlarge = (line_max.d - line_min.d) / 8.0 # print str(x_avg) + ' ' + str(y_avg) cv2.circle(black, (int(x_avg), int(y_avg)), 10, (255, 255, 255), -1) cv2.putText(black, 'theta: ' + str(avg_theta) + 'd: ' + str(delta_d), (80, 300), font, 1, (255, 255, 255), 2) cv2.imwrite(output_path + 'theta_' + filename, black) # continue enlarge = 0 x1, y1, x2, y2 = line_min.x1, line_min.y1, line_min.x2, line_min.y2 x1 -= enlarge * math.cos(avg_theta + math.pi / 2.0) x2 -= enlarge * math.cos(avg_theta + math.pi / 2.0) y1 -= enlarge * math.sin(avg_theta + math.pi / 2.0) y2 -= enlarge * math.sin(avg_theta + math.pi / 2.0) line_min_new = LineSegment(x1, y1, x2, y2) x1, y1, x2, y2 = line_max.x1, line_max.y1, line_max.x2, line_max.y2 x1 += enlarge * math.cos(avg_theta + math.pi / 2.0) x2 += enlarge * math.cos(avg_theta + math.pi / 2.0) y1 += enlarge * math.sin(avg_theta + math.pi / 2.0) y2 += enlarge * math.sin(avg_theta + math.pi / 2.0) line_max_new = LineSegment(x1, y1, x2, y2) w = line_max_new.distance(line_min_new.x, line_min_new.y) h = w / 3.0 * 2.1 r_2 = (w**2 + h**2) / 4.0 l = line_min_new x1, x2, y1, y2 = l.x1, l.x2, l.y1, l.y2 a = (y1 - y2)**2 + (x1 - x2)**2 b = 2.0 * ((y1 - y2) * (y1 - y_avg) + (x1 - x2) * (x1 - x_avg)) c = (y1 - y_avg)**2 + (x1 - x_avg)**2 - r_2 t1 = (-b - math.sqrt(b**2 - 4.0 * a * c)) / (2.0 * a) t2 = (-b + math.sqrt(b**2 - 4.0 * a * c)) / (2.0 * a) xn[0, i] = x1 + t1 * (x1 - x2) yn[0, i] = y1 + t1 * (y1 - y2) xn[1, i] = x1 + t2 * (x1 - x2) yn[1, i] = y1 + t2 * (y1 - y2) l = line_max_new x1, x2, y1, y2 = l.x1, l.x2, l.y1, l.y2 a = (y1 - y2)**2 + (x1 - x2)**2 b = 2.0 * ((y1 - y2) * (y1 - y_avg) + (x1 - x2) * (x1 - x_avg)) c = (y1 - y_avg)**2 + (x1 - x_avg)**2 - r_2 t1 = (-b - math.sqrt(b**2 - 4.0 * a * c)) / (2.0 * a) t2 = (-b + math.sqrt(b**2 - 4.0 * a * c)) / (2.0 * a) xn[2, i] = x1 + t1 * (x1 - x2) yn[2, i] = y1 + t1 * (y1 - y2) xn[3, i] = x1 + t2 * (x1 - x2) yn[3, i] = y1 + t2 * (y1 - y2) dn[i] = abs( math.sqrt((xn[0, i] - xn[1, i])**2 + (yn[0, i] - yn[1, i])**2) - math.sqrt((xn[2, i] - xn[3, i])**2 + (yn[2, i] - yn[3, i])**2)) except ValueError: dn[i] = float('inf') ni = 1 if dn[1] < dn[0] else 0 xn = xn[:, ni] yn = yn[:, ni] for i in range(0, 4): cv2.circle(black, (int(xn[i]), int(yn[i])), 30, (255, 255, 255), -1) # 4 3 # 2 1 pts1 = np.float32([[xn[1], yn[1]], [xn[3], yn[3]], [xn[0], yn[0]], [xn[2], yn[2]]]) pts2 = np.float32([[0, 0], [DST_WIDTH, 0], [0, DST_HEIGHT], [DST_WIDTH, DST_HEIGHT]]) M = cv2.getPerspectiveTransform(pts1, pts2) dst = cv2.warpPerspective(original, M, (DST_WIDTH, DST_HEIGHT)) xn = np.uint(xn) yn = np.uint(yn) cv2.line(img, (xn[0], yn[0]), (xn[1], yn[1]), yellow, thickness) cv2.line(img, (xn[1], yn[1]), (xn[3], yn[3]), yellow, thickness) cv2.line(img, (xn[3], yn[3]), (xn[2], yn[2]), yellow, thickness) cv2.line(img, (xn[2], yn[2]), (xn[0], yn[0]), yellow, thickness) cv2.line(black, (xn[0], yn[0]), (xn[1], yn[1]), yellow, thickness) cv2.line(black, (xn[1], yn[1]), (xn[3], yn[3]), yellow, thickness) cv2.line(black, (xn[3], yn[3]), (xn[2], yn[2]), yellow, thickness) cv2.line(black, (xn[2], yn[2]), (xn[0], yn[0]), yellow, thickness) cv2.imwrite(output_path + 'line_' + filename, img) cv2.imwrite(output_path + 'only_line_' + filename, black) black_small = np.zeros(dst.shape, np.uint8) gray_small = cv2.cvtColor(dst, cv2.COLOR_BGR2GRAY) # 检测数字位置 dst1 = cv2.cornerHarris(gray_small, 2, 3, 0.04) dst1 = cv2.dilate(dst1, None) t = dst1 > 0.01 * dst1.max() black_small[t] = [0, 0, 255] up = t[0:40, :] down = t[DST_HEIGHT - 41:DST_HEIGHT - 1, :] if sum(sum(up)) > sum(sum(down)): # 旋转180度 dst = cv2.flip(dst, -1) gray_small = cv2.flip(gray_small, -1) # cv2.imwrite(output_path + 's_only_line_' + filename, black_small) cv2.imwrite(output_path + 'dst_' + filename, dst) # 使用平均灰度值进行二值化 height, width = gray_small.shape avg_gray = sum(sum(1.0 * gray_small)) / (height * width) cv2.imwrite(output_path + "gray_" + filename, gray_small) std = np.std(gray_small) gray_small = (gray_small - avg_gray) / std return gray_small
from LineSegment import LineSegment ##Segmenti verticali su rette differenti S = LineSegment([3.0, 1.0], [3.0, 3.0]) O = LineSegment([4.0, 1.0], [4.0, 3.0]) assert not S.intersects(O), "Errore per segmenti verticali su rette differenti" assert not O.intersects(S), "Errore per segmenti verticali su rette differenti" ##Segmenti verticali su rette coincidenti S = LineSegment([3.0, 1.0], [3.0, 3.0]) O = LineSegment([3.0, 1.5], [3.0, 3.4]) assert S.intersects(O), "Errore per segmenti verticali sulla stessa retta" assert O.intersects(S), "Errore per segmenti verticali sulla stessa retta" ##Segmenti verticali su rette coincidenti S = LineSegment([3.0, 1.0], [3.0, 3.0]) O = LineSegment([3.0, 4.0], [3.0, 7.0]) assert not S.intersects(O), "Errore per segmenti paralleli su rette differenti" assert not O.intersects(S), "Errore per segmenti paralleli su rette differenti" ##Segmenti paralleli ma non verticali su rette coincidenti S = LineSegment([0.0, 0.0], [3.0, 3.0]) O = LineSegment([4.0, 4.0], [5.0, 5.0]) assert not S.intersects(O), "Errore per segmenti paralleli sulla stessa retta" assert not O.intersects(S), "Errore per segmenti paralleli sulla stessa retta" S = LineSegment([0.0, 0.0], [3.0, 3.0]) O = LineSegment([1.0, 1.0], [2.0, 2.0]) assert S.intersects(O), "Errore per segmenti paralleli sulla stessa retta" assert O.intersects(S), "Errore per segmenti paralleli sulla stessa retta"