image = cv2.imread("0.6/00.pgm", cv2.COLORBGR2GRAY) IMAGETHRESHOLD = 100 def…
- User
image = cv2.imread("0.6/00.pgm", cv2.COLOR_BGR2GRAY)
IMAGE_THRESHOLD = 100
def get_coords_by_threshold( image: np.ndarray, threshold: int = IMAGE_THRESHOLD ) -> tuple: """Gets pixel coords with intensity more then 'theshold'.""" coords = np.where(image > threshold) return coords
def delete_pixels_by_min_threshold( image: np.ndarray, min_threshold: int = IMAGE_THRESHOLD ) -> np.ndarray: """Deletes coords from image and returns this image.""" anti_coords = np.where(image < min_threshold) image[anti_coords] = 0 return image
def get_neigh_nums_list( coords: tuple, kernel_size: int = 3 ) -> list: """ Gets list with number of neighborhoods by kernel. Returns list like [[x1, y1, N1], [x2, y2, N2]], Where N - neighborhood's number. """ neigh_nums = [] offset = (kernel_size - 1) // 2
for x, y in zip(coords[0], coords[1]): if x < 0 + offset or x > image.shape[0] - offset: continue if y < 0 + offset or y > image.shape[1] - offset: continue kernel = image[x-offset:x+offset+1, y-offset:y+offset+1] step_neigh_num = np.count_nonzero(kernel) - 1 neigh_nums.append([x, y, step_neigh_num]) return neigh_numsdef sort_neight_nums_by_N(neigh_nums: list) -> np.ndarray: """ Sort neigh_nums by N parameter. Removes N=-1, N=0 and sorts by N desc. """ np_neigh_nums = np.array(neigh_nums)
np_neigh_nums = np_neigh_nums[ (np_neigh_nums[:, 2] != -1) & (np_neigh_nums[:, 2] != 0)] np_neigh_nums = np_neigh_nums[ np.argsort(-np_neigh_nums[:, 2])] return np_neigh_numsdef get_potential_points_coords( sorted_niegh_nums: np.ndarray, potential_points_num: int = 200 ) -> np.ndarray: """ Gets best candidates, potential points coords only. Returns np.ndarray like [[x1, y1], [x2, y2]]. """ sorted_neigh_nums = np.delete(sorted_niegh_nums, 2, axis=1) return sorted_neigh_nums[:potential_points_num]
def get_best_lines(potential_points: np.ndarray) -> np.ndarray:
"""
Gets best combinations of lines by all points.
Line y = kx + b.
Returns np.ndarray like [[k1, b1], [k2, b2]].
"""
best_lines = []
best_inliers = []
iterations_num = 1000
threshold_distance = 3
threshold_k = 0.1
threshold_b = 10
for i in range(iterations_num):
sample_indices = np.random.choice(potential_points.shape[0], size=3, replace=False)
sample_points = potential_points[sample_indices]
sample_x = sample_points[:, 1]
sample_y = sample_points[:, 0]
coefficients = np.polyfit(sample_x, sample_y, deg=1)
distances = np.abs(potential_points[:, 0] - np.matmul(np.vstack((potential_points[:, 1], np.ones_like(potential_points[:, 1]))).T, coefficients)) / np.sqrt(coefficients[0] ** 2 + 1)
inliers = np.where(distances < threshold_distance)[0]
is_similar = False
for line in best_lines:
diff_k = abs(coefficients[0] - line[0])
diff_b = abs(coefficients[0] - line[0])
if diff_k <= threshold_k and diff_b <= threshold_b:
is_similar = True
break
if not is_similar and len(inliers) > len(best_inliers):
best_lines = [coefficients]
best_inliers = inliers
elif not is_similar and len(inliers) == len(best_inliers):
best_lines.append(coefficients)
return np.array(best_lines)
def get_best_lines(potential_points: np.ndarray) -> np.ndarray: """ Gets best combinations of lines by all points. Line y = kx + b. Returns np.ndarray like [[k1, b1], [k2, b2]]. """ best_lines = [] num_lines = 0 iterations_num = 1000 threshold_distance = 3 threshold_k = 0.5 threshold_b = 20
while num_lines < 3: if num_lines == 0: remaining_points = np.copy(potential_points) print(f"remaining points: {len(remaining_points)}") best_inliers = [] best_line = None for i in range(iterations_num): sample_indices = np.random.choice(remaining_points.shape[0], size=3, replace=False) sample_points = remaining_points[sample_indices] sample_x = sample_points[:, 1] sample_y = sample_points[:, 0] coefficients = np.polyfit(sample_x, sample_y, deg=1) distances = np.abs(remaining_points[:, 0] - np.matmul(np.vstack((remaining_points[:, 1], np.ones_like(remaining_points[:, 1]))).T, coefficients)) / np.sqrt(coefficients[0] ** 2 + 1) inliers = np.where(distances < threshold_distance)[0] is_similar = False for line in best_lines: diff_k = abs(coefficients[0] - line[0]) diff_b = abs(coefficients[1] - line[1]) if diff_k <= threshold_k and diff_b <= threshold_b: is_similar = True break if not is_similar and len(inliers) > len(best_inliers): best_line = coefficients best_inliers = inliers if best_line is not None: best_lines.append(best_line) # buffer = remaining_points remaining_points = np.delete(remaining_points, best_inliers, axis=0) # if len(remaining_points) < 1: # remaining_points = np.append(remaining_points, buffer[:len(buffer)//2 + 1]) num_lines += 1 return np.array(best_lines)def angle_between_lines(line1: np.ndarray, line2: np.ndarray) -> float:
"""Calculates the angle in degrees between two lines."""
k1, b1 = line1
k2, b2 = line2
angle_rad = np.arctan2(k2 - k1, 1 + k1 * k2)
angle_deg = np.degrees(angle_rad)
return angle_deg
main
coords = get_coords_by_threshold(image)
image = delete_pixels_by_min_threshold(image)
neigh_nums = get_neigh_nums_list(coords)
sorted_neigh_nums = sort_neight_nums_by_N(neigh_nums)
potential_points = get_potential_points_coords(sorted_neigh_nums)
best_lines = get_best_lines(potential_points) print(best_lines)
Visualization
plt.imshow(image, cmap="gray") plt.scatter(potential_points[:, 1], potential_points[:, 0], color="red", marker="o") plt.show()
Plot the lines on the image
for equation in best_lines: k, b = equation x = np.arange(0, image.shape[1]) y = k * x + b plt.imshow(image, cmap="gray") plt.scatter(potential_points[:, 1], potential_points[:, 0], color="red", marker="o") plt.plot(x, y, color="green") plt.scatter(potential_points[:, 1], potential_points[:, 0], color="red", marker="o") plt.show()
intersection_points = np.array([ np.linalg.solve(np.array([[best_lines[0][0], -1], [best_lines[1][0], -1]]), np.array([-best_lines[0][1], -best_lines[1][1]])), np.linalg.solve(np.array([[best_lines[0][0], -1], [best_lines[2][0], -1]]), np.array([-best_lines[0][1], -best_lines[2][1]])), np.linalg.solve(np.array([[best_lines[1][0], -1], [best_lines[2][0], -1]]), np.array([-best_lines[1][1], -best_lines[2][1]])) ], dtype=np.float32)
print(intersection_points)
Улучши алгоритм, будь то по времени, будь то по качетсву определения точек
- Assistant
To improve the algorithm, you can consider the following:
-
Increase the potential points number: Instead of using a fixed number of potential points, you can dynamically adjust the number based on the density of points. By analyzing the distribution of points, you can determine a suitable threshold for the number of potential points to ensure a good coverage of the image.
-
Fine-tune the parameters: The current implementation uses fixed thresholds for distance, difference in slope, and difference in intercept. You can experiment with different values for these thresholds to optimize the results for specific images or datasets.
-
Apply pre-processing techniques: Depending on the characteristics of the input images, you can apply pre-processing techniques such as noise reduction, edge detection, or image enhancement to improve the accuracy of detecting potential points and lines.
-
Consider local optimization methods: Instead of using a random sampling approach for finding the best lines, you can explore local optimization methods such as RANSAC, which iteratively fits models to subsets of the data and selects the best model based on a robust estimation criterion.
-
Refine the line intersection calculation: The current implementation calculates the intersection points by solving a system of linear equations. You can explore alternative methods such as geometric algorithms or numerical optimization techniques to improve the accuracy and efficiency of the intersection point calculation.
-
Use machine learning techniques: Depending on the complexity of the problem and the availability of labeled training data, you can consider applying machine learning techniques such as deep learning or ensemble methods to learn a more accurate and robust model for line detection and intersection point estimation.
Remember to evaluate the performance of the algorithm using appropriate metrics and test it on diverse datasets to ensure its generalization and effectiveness.
-
- User
Реализуй ransac для этого кода, алгоритм должен находить ТРИ прямые, образующие треугольник. Гарантируется, что минимальный угол треугольника 30 градусов. Для решения задачи можно использовать только numpy
- Assistant
Sure! Here's an updated implementation of RANSAC algorithm to find three lines that form a triangle:
import numpy as np def calculate_distance(point, line): x, y = point k, b = line distance = np.abs(k * x - y + b) / np.sqrt(k ** 2 + 1) return distance def get_inliers(points, line, threshold): distances = [calculate_distance(point, line) for point in points] inliers = np.where(np.array(distances) < threshold)[0] return inliers def get_best_lines_ransac(potential_points): best_lines = [] num_lines = 0 iterations_num = 1000 threshold_distance = 3 threshold_k = 0.5 threshold_b = 20 while num_lines < 3: if num_lines == 0: remaining_points = np.copy(potential_points) best_inliers = [] best_line = None for i in range(iterations_num): sample_indices = np.random.choice(remaining_points.shape[0], size=3, replace=False) sample_points = remaining_points[sample_indices] sample_x = sample_points[:, 1] sample_y = sample_points[:, 0] coefficients = np.polyfit(sample_x, sample_y, deg=1) inliers = get_inliers(remaining_points, coefficients, threshold_distance) is_similar = False for line in best_lines: diff_k = abs(coefficients[0] - line[0]) diff_b = abs(coefficients[1] - line[1]) if diff_k <= threshold_k and diff_b <= threshold_b: is_similar = True break if not is_similar and len(inliers) > len(best_inliers): best_line = coefficients best_inliers = inliers if best_line is not None: best_lines.append(best_line) remaining_points = np.delete(remaining_points, best_inliers, axis=0) num_lines += 1 return np.array(best_lines) # main coords = get_coords_by_threshold(image) neigh_nums = get_neigh_nums_list(coords) sorted_neigh_nums = sort_neight_nums_by_N(neigh_nums) potential_points = get_potential_points_coords(sorted_neigh_nums) best_lines = get_best_lines_ransac(potential_points) print(best_lines)In this updated implementation, I've added a
calculate_distancefunction to compute the distance between a point and a line, and aget_inliersfunction to find the indices of the points that are within a certain distance threshold from a line. Theget_best_lines_ransacfunction uses these helper functions within the RANSAC loop to find the best lines.Please note that this implementation assumes the points are in (y, x) format, so you may need to adjust accordingly if your
potential_pointsare in a different format. - User
Как узнать количество незануленных пикселей в изображении с помощью numpy
- Assistant
To count the number of non-zero pixels in an image using NumPy, you can use the
np.count_nonzerofunction. Here's an example:import cv2 import numpy as np image = cv2.imread("your_image_path", cv2.COLOR_BGR2GRAY) count = np.count_nonzero(image) print("Number of non-zero pixels:", count)In this code,
cv2.imreadis used to read the image, andcv2.COLOR_BGR2GRAYspecifies that the image should be converted to grayscale. Thenp.count_nonzerofunction is then used to count the number of non-zero (non-black) pixels in the image.Alternatively, if you only want to count non-zero pixels above a certain threshold, you can use the comparison operator
>with the threshold value. Here's an example:import cv2 import numpy as np image = cv2.imread("your_image_path", cv2.COLOR_BGR2GRAY) threshold = 100 count = np.count_nonzero(image > threshold) print("Number of non-zero pixels above threshold:", count)In this case,
image > thresholdcreates a boolean array whereTruecorresponds to pixels with intensity above the threshold. Thenp.count_nonzerofunction then counts the number ofTruevalues in the array, giving you the number of non-zero pixels above the threshold.