From b6753569a1a68b499a2a86dae5eb60deed9eb586 Mon Sep 17 00:00:00 2001 From: Panagiotis Tomer Karagiannis Date: Mon, 19 Dec 2022 22:39:25 +0100 Subject: [PATCH] wip --- .gitignore | 2 + drawing_to_fsd_layout/common.py | 5 + drawing_to_fsd_layout/cone_placement.py | 301 +++++++ drawing_to_fsd_layout/export.py | 250 ++++++ drawing_to_fsd_layout/image_processing.py | 244 ++++++ drawing_to_fsd_layout/math_utils.py | 638 +++++++++++++++ drawing_to_fsd_layout/spline_fit.py | 135 ++++ drawing_to_track.ipynb | 924 ++++++++++++++++++++++ requirements.txt | 6 + streamlit_app.py | 328 ++++++++ 10 files changed, 2833 insertions(+) create mode 100644 drawing_to_fsd_layout/common.py create mode 100644 drawing_to_fsd_layout/cone_placement.py create mode 100644 drawing_to_fsd_layout/export.py create mode 100644 drawing_to_fsd_layout/image_processing.py create mode 100644 drawing_to_fsd_layout/math_utils.py create mode 100644 drawing_to_fsd_layout/spline_fit.py create mode 100755 drawing_to_track.ipynb create mode 100644 requirements.txt create mode 100644 streamlit_app.py diff --git a/.gitignore b/.gitignore index b6e4761..f347387 100644 --- a/.gitignore +++ b/.gitignore @@ -127,3 +127,5 @@ dmypy.json # Pyre type checker .pyre/ + +.vscode/ \ No newline at end of file diff --git a/drawing_to_fsd_layout/common.py b/drawing_to_fsd_layout/common.py new file mode 100644 index 0000000..73b4614 --- /dev/null +++ b/drawing_to_fsd_layout/common.py @@ -0,0 +1,5 @@ +import numpy as np + +FloatArrayNx2 = np.typing.NDArray[np.float64] +IntArrayN = np.typing.NDArray[np.int64] +FloatArray2 = np.typing.NDArray[np.float64] diff --git a/drawing_to_fsd_layout/cone_placement.py b/drawing_to_fsd_layout/cone_placement.py new file mode 100644 index 0000000..46a2248 --- /dev/null +++ b/drawing_to_fsd_layout/cone_placement.py @@ -0,0 +1,301 @@ +import networkx as nx +import numpy as np +import streamlit as st +from scipy.ndimage import uniform_filter1d +from scipy.spatial.distance import cdist + +from drawing_to_fsd_layout.common import FloatArray2, FloatArrayNx2, IntArrayN + + +def circle_fit(coords: np.ndarray, max_iter: int = 99) -> np.ndarray: + """ + Function taken from: https://github.com/papalotis/ft-fsd-path-planning/blob/d82ba8f93c753a9d0fe0c77fa8c9af88aafad6ea/fsd_path_planning/utils/math_utils.py#L569 + + Fit a circle to a set of points. This function is adapted from the hyper_fit + function in the circle-fit package (https://pypi.org/project/circle-fit/). + The function is a njit version of the original function with some input validation + removed. Furthermore, the residuals are not calculated or returned. + Args: + coords: The coordinates of the points as an [N, 2] array. + max_iter: The maximum number of iterations. + Returns: + An array with 3 elements: + - center x + - center y + - radius + """ + + X = coords[:, 0] + Y = coords[:, 1] + + n = X.shape[0] + + Xi = X - X.mean() + Yi = Y - Y.mean() + Zi = Xi * Xi + Yi * Yi + + # compute moments + Mxy = (Xi * Yi).sum() / n + Mxx = (Xi * Xi).sum() / n + Myy = (Yi * Yi).sum() / n + Mxz = (Xi * Zi).sum() / n + Myz = (Yi * Zi).sum() / n + Mzz = (Zi * Zi).sum() / n + + # computing the coefficients of characteristic polynomial + Mz = Mxx + Myy + Cov_xy = Mxx * Myy - Mxy * Mxy + Var_z = Mzz - Mz * Mz + + A2 = 4 * Cov_xy - 3 * Mz * Mz - Mzz + A1 = Var_z * Mz + 4.0 * Cov_xy * Mz - Mxz * Mxz - Myz * Myz + A0 = Mxz * (Mxz * Myy - Myz * Mxy) + Myz * (Myz * Mxx - Mxz * Mxy) - Var_z * Cov_xy + A22 = A2 + A2 + + # finding the root of the characteristic polynomial + y = A0 + x = 0.0 + for _ in range(max_iter): + Dy = A1 + x * (A22 + 16.0 * x * x) + x_new = x - y / Dy + if x_new == x or not np.isfinite(x_new): + break + y_new = A0 + x_new * (A1 + x_new * (A2 + 4.0 * x_new * x_new)) + if abs(y_new) >= abs(y): + break + x, y = x_new, y_new + + det = x * x - x * Mz + Cov_xy + X_center = (Mxz * (Myy - x) - Myz * Mxy) / det / 2.0 + Y_center = (Myz * (Mxx - x) - Mxz * Mxy) / det / 2.0 + + x = X_center + X.mean() + y = Y_center + Y.mean() + r = np.sqrt(abs(X_center**2 + Y_center**2 + Mz)) + + return np.array([x, y, r]) + + +def create_cyclic_sliding_window_indices( + window_size: int, step_size: int, signal_length: int +) -> IntArrayN: + """ + Function taken from https://github.com/papalotis/ft-fsd-path-planning/blob/main/fsd_path_planning/calculate_path/path_parameterization.py + """ + if window_size % 2 == 0: + raise ValueError("Window size must be odd.") + half_window_size = window_size // 2 + + indexer = ( + np.arange(-half_window_size, half_window_size + 1) + + np.arange(0, signal_length, step_size).reshape(-1, 1) + ) % signal_length + return indexer + + +def calculate_path_curvature( + path: FloatArrayNx2, window_size: int, path_is_closed: bool +) -> FloatArrayNx2: + """ + Function taken from https://github.com/papalotis/ft-fsd-path-planning/blob/main/fsd_path_planning/calculate_path/path_parameterization.py + + Calculate the curvature of the path. + Args: + path: The path as a 2D array of points. + window_size: The size of the window to use for the curvature calculation. + path_is_closed: Whether the path is closed or not. + Returns: + The curvature of the path. + """ + windows = create_cyclic_sliding_window_indices( + window_size=window_size, step_size=1, signal_length=len(path) + ) + + path_curvature = np.zeros(len(path)) + for i, window in enumerate(windows): + if not path_is_closed: + diff = window[1:] - window[:-1] + if np.any(diff != 1): + idx_cutoff = int(np.argmax(diff != 1) + 1) + if i < window_size: + window = window[idx_cutoff:] + else: + window = window[:idx_cutoff] + + points_in_window = path[window] + + _, _, radius = circle_fit(points_in_window) + radius = min( + max(radius, 1.0), 3000.0 + ) # np.clip didn't work for some reason (numba bug?) + curvature = 1 / radius + three_idxs = np.array([0, int(len(points_in_window) / 2), -1]) + three_points = points_in_window[three_idxs] + hom_points = np.column_stack((np.ones(3), three_points)) + sign = np.linalg.det(hom_points) + + path_curvature[i] = curvature * np.sign(sign) + + mode = "wrap" if path_is_closed else "nearest" + + filtered_curvature = uniform_filter1d( + path_curvature, size=window_size // 10, mode=mode + ) + # filtered_curvature = path_curvature + + return filtered_curvature + + +def calculate_edge_curvature(edge: FloatArrayNx2) -> FloatArrayNx2: + window_size = len(edge) // 25 + if window_size % 2 == 0: + window_size += 1 + return calculate_path_curvature(edge, window_size=window_size, path_is_closed=True) + + +def place_cones_for_edge(edge: FloatArrayNx2) -> FloatArrayNx2: + """ + Place cones along an edge. + + Args: + edge: The edge to place cones on. Shape (n,2) + cone_spacing: The distance between cones. + + Returns: + The locations of the cones. Shape (m,2) + """ + raise NotImplementedError + + +def calculate_min_track_width_index( + edge_1: FloatArrayNx2, edge_2: FloatArrayNx2 +) -> tuple[int, int]: + distances = cdist(edge_1, edge_2) + idx_min_distance_to_1 = np.min(distances, axis=1).argmin() + idx_min_distance_to_2 = np.min(distances, axis=0).argmin() + + return idx_min_distance_to_1, idx_min_distance_to_2 + + +def calculate_min_track_width(edge_1: FloatArrayNx2, edge_2: FloatArrayNx2) -> float: + idx_min_distance_to_1, idx_min_distance_to_2 = calculate_min_track_width_index( + edge_1, edge_2 + ) + edge_1_closest_point = edge_1[idx_min_distance_to_1] + edge_2_closest_point = edge_2[idx_min_distance_to_2] + + return np.linalg.norm(edge_1_closest_point - edge_2_closest_point) + + +def estimate_centerline_from_edges( + edge_1: FloatArrayNx2, edge_2: FloatArrayNx2 +) -> FloatArrayNx2: + shorter, longer = sorted([edge_1, edge_2], key=len) + idx_shorter = cdist(shorter, longer).argmin(axis=0) + shorter_sampled = shorter[idx_shorter] + centerline = (longer + shorter_sampled) / 2 + + return centerline + + +def estimate_centerline_length(edge_1: FloatArrayNx2, edge_2: FloatArrayNx2) -> float: + edge_1_sampled = edge_1[::10] + edge_2_sampled = edge_2[::10] + centerline = estimate_centerline_from_edges(edge_1_sampled, edge_2_sampled) + return np.sum(np.linalg.norm(np.diff(centerline, axis=0), axis=1)) + + +def split_edge_to_straight_and_curve( + edge: FloatArrayNx2, + curvature_threshold_upper: float = 0.02, + curvature_threshold_lower: float = 0.01, +) -> IntArrayN: + """ + Split an edge into straight and curve sections. + """ + curvature_threshold_lower, curvature_threshold_upper = sorted( + (curvature_threshold_lower, curvature_threshold_upper) + ) + curvature = calculate_edge_curvature(edge) + start_index = np.argmin(curvature) # start from a straight + + # 0 is straight, 1 is left curve, -1 is right curve + out = np.zeros(len(curvature), dtype=int) + out[start_index] = 0 + for offset in range(1, len(curvature) + 1): + previous_index = (start_index + offset - 1) % len(curvature) + next_index = (start_index + offset) % len(curvature) + + state = out[previous_index] + if state == 0 and abs(curvature[next_index]) > curvature_threshold_upper: + state = np.sign(curvature[next_index]) + elif state != 0 and abs(curvature[next_index]) < curvature_threshold_lower: + state = 0 + + out[next_index] = state + + return out + + +def decide_start_finish_line_position_and_direction( + edge: FloatArrayNx2, +) -> tuple[FloatArray2, FloatArray2]: + track_point_types = split_edge_to_straight_and_curve(edge) + straights_indices: list[list[int]] = [[]] + for i, track_point_type in enumerate(track_point_types): + if track_point_type == 0: + straights_indices[-1].append(i) + else: + if len(straights_indices[-1]) > 0: + straights_indices.append([]) + + longest_straight_indices = max(straights_indices, key=len) + start_index = longest_straight_indices[len(longest_straight_indices) // 2] + direction_of_straight = np.diff(edge[longest_straight_indices], axis=0).mean(axis=0) + return edge[start_index], direction_of_straight / np.linalg.norm( + direction_of_straight + ) + + +def fix_edge_direction( + edge: FloatArrayNx2, start_position: FloatArray2, start_direction: FloatArray2 +) -> FloatArrayNx2: + idx_edge_start = np.linalg.norm(edge - start_position, axis=1).argmin() + edge_rolled = np.roll(edge, -idx_edge_start, axis=0) + + edge_direction = edge_rolled[2] - edge_rolled[0] + dot = np.dot(edge_direction, start_direction) + if dot < 0: + edge_rolled = edge_rolled[::-1] + + return edge_rolled + + +def place_cones( + trace: FloatArrayNx2, seed: int, mean: float, variance: float +) -> FloatArrayNx2: + rng = np.random.default_rng(seed) + + idxs_to_keep = [0] + next_distance = rng.normal(mean, variance) + next_idx = idxs_to_keep[0] + while next_idx < len(trace): + trace_from_last_in = trace[next_idx:] + dist_to_next = np.linalg.norm(np.diff(trace_from_last_in, axis=0), axis=1) + cum_dist = np.cumsum(dist_to_next) + + offset_next_idx = np.argmax(cum_dist > next_distance) + + if offset_next_idx == 0: + break + + next_idx = offset_next_idx + next_idx + idxs_to_keep.append(next_idx) + next_distance = rng.normal(mean, variance) + + randomly_placed_cones = trace[idxs_to_keep] + + st.write(np.linalg.norm(np.diff(randomly_placed_cones, axis=0), axis=1).mean()) + + + return randomly_placed_cones diff --git a/drawing_to_fsd_layout/export.py b/drawing_to_fsd_layout/export.py new file mode 100644 index 0000000..2f035c5 --- /dev/null +++ b/drawing_to_fsd_layout/export.py @@ -0,0 +1,250 @@ +import json +from enum import Enum +from struct import Struct +from typing import Dict, List, Literal, Tuple, cast + +import numpy as np + +from drawing_to_fsd_layout.common import FloatArrayNx2 + + +def export_json_string(edges_left: FloatArrayNx2, edges_right: FloatArrayNx2) -> str: + """ + Export the track edges to a JSON string that can be used in the FSD layout editor. + + Args: + edges_left: The left track edge. Shape (n,2) + edges_right: The right track edge. Shape (n,2) + + Returns: + The JSON string + """ + cones_x = np.concatenate((edges_left[:, 0], edges_right[:, 0])).tolist() + cones_y = np.concatenate((edges_left[:, 1], edges_right[:, 1])).tolist() + cones_color = ( + ["orange_big"] + + ["blue"] * (len(edges_left) - 1) + + ["orange_big"] + + ["yellow"] * (len(edges_right) - 1) + ) + obj = { + "x": cones_x, + "y": cones_y, + "color": cones_color, + } + + return json.dumps(obj) + + +# --- Export to LYT file --- + + +def angle_from_2d_vector(vecs: np.ndarray) -> np.ndarray: + if vecs.shape == (2,): + return np.arctan2(vecs[1], vecs[0]) + if vecs.ndim == 2 and vecs.shape[-1] == 2: + return np.arctan2(vecs[:, 1], vecs[:, 0]) + raise ValueError("vecs can either be a 2d vector or an array of 2d vectors") + + +class ConeTypes(int, Enum): + """ + Enum for all possible cone types + """ + + UNKNOWN = 0 + YELLOW = RIGHT = 1 + BLUE = LEFT = 2 + ORANGE_SMALL = START_FINISH_AREA = 3 + ORANGE_BIG = START_FINISH_LINE = 4 + + +HEADER_STRUCT = Struct("6sBBhBB") +BLOCK_STRUCT = Struct("2h4B") + + +ConeTypeToLytObjectIndex: Dict[ConeTypes, int] = { + ConeTypes.UNKNOWN: 25, + ConeTypes.YELLOW: 29, # 30 also possible + ConeTypes.BLUE: 23, # 24 also possible + ConeTypes.ORANGE_BIG: 27, + ConeTypes.ORANGE_SMALL: 20, # 20 is red, we use it to represent a small orange cone +} + +LytObjectIndexToConeType: Dict[int, ConeTypes] = { + 25: ConeTypes.UNKNOWN, + 29: ConeTypes.YELLOW, + 30: ConeTypes.YELLOW, + 23: ConeTypes.BLUE, + 24: ConeTypes.BLUE, + 27: ConeTypes.ORANGE_BIG, + 20: ConeTypes.ORANGE_SMALL, +} + + +def _to_lyt_heading(heading: np.ndarray, input_is_radians: bool) -> np.ndarray: + """ + Convert real world heading (direction) to lyt heading + + Args: + heading (np.ndarray): The heading in the real world + input_is_radians (bool, optional): If set to True the input will be converted to + degrees as required by LYT. + + Returns: + np.ndarray: The heading is required by LYT + """ + if input_is_radians: + heading = np.rad2deg(heading) + return ((heading + 180) * 256 // 360).astype(np.uint8) + + +def _create_lyt_block_for_cone( + x_pos: int, y_pos: int, heading: int, color_index: int +) -> bytes: + z_height = 240 # suggested by documentation (puts element on ground) + flags = 0 # these are simple cone objects no flags + block = BLOCK_STRUCT.pack(x_pos, y_pos, z_height, flags, color_index, heading) + return block + + +def _create_lyt_trace_bytes(trace: np.ndarray, color_idx: int) -> bytes: + if len(trace) > 0: + trace_looped = cast(np.ndarray, np.vstack((trace, trace[:1]))) + heading = angle_from_2d_vector(trace_looped[1:] - trace_looped[:-1]) + # NOTE 2 in format + heading = _to_lyt_heading(heading, input_is_radians=True) + all_blocks = b"".join( + _create_lyt_block_for_cone(x, y, h, color_idx) + for (x, y), h in zip(trace, heading) + ) + return all_blocks + return b"" + + +def _create_start_block(x_pos: int, y_pos: int, heading: float) -> bytes: + z_height = 240 + index = 0 + flags = 0 # start position has 0 width + heading = _to_lyt_heading(heading, input_is_radians=True) + block = BLOCK_STRUCT.pack(x_pos, y_pos, z_height, flags, index, heading) + return block + + +def _create_finish_block(x_pos: int, y_pos: int, heading: float, width: float) -> bytes: + block = bytearray(_create_start_block(x_pos, y_pos, heading)) + # width of finish object + block[5] |= int(width / 2) << 2 + return bytes(block) + + +def _create_checkpoint_block( + x_pos: int, + y_pos: int, + heading: float, + width: float, + checkpoint_index: Literal[1, 2, 3], +) -> bytes: + if checkpoint_index not in (1, 2, 3): + raise ValueError( + f"checkout_index must be either 1, 2 or 3. It is {checkpoint_index}" + ) + block = bytearray(_create_finish_block(x_pos, y_pos, heading, width)) + block[5] |= checkpoint_index + return bytes(block) + + +def _traces_to_lyt_bytes( + cones_per_type: List[np.ndarray], offset_in_meters: Tuple[float, float] +) -> bytes: + lfs_scale = 16 + offset = offset_in_meters * lfs_scale + + cones_in_map = [(c * lfs_scale + offset).astype(int) for c in cones_per_type] + + cones_bytes = [ + _create_lyt_trace_bytes(cones, ConeTypeToLytObjectIndex[cone_type]) + for cone_type, cones in zip(ConeTypes, cones_in_map) + ] + + right_in_map = cones_in_map[ConeTypes.RIGHT] + left_in_map = cones_in_map[ConeTypes.LEFT] + start_finish_in_map = cones_in_map[ConeTypes.START_FINISH_LINE] + + pos_x, pos_y = (left_in_map[-2] + right_in_map[-2]) // 2 + start_heading: float = ( + angle_from_2d_vector(left_in_map[-2] - left_in_map[-1]) + np.pi / 2 + ) + start_block = _create_start_block(pos_x, pos_y, start_heading) + + finish_pos_x, finish_pos_y = (start_finish_in_map[0] + start_finish_in_map[1]) // 2 + + # divide by lfs_scale because we need actual width + finish_width = 3 * ( + np.linalg.norm(start_finish_in_map[0] - start_finish_in_map[1]) / lfs_scale + ) + finish_heading = angle_from_2d_vector(left_in_map[-1] - left_in_map[0]) + np.pi / 2 + finish_block = _create_finish_block( + finish_pos_x, finish_pos_y, finish_heading, finish_width + ) + + # put checkpoint approximately in the middle + # this is so that lfs counts lap times + half_len = len(left_in_map) // 2 + left_point_half = left_in_map[half_len] + right_point_half_index = np.linalg.norm( + left_point_half - right_in_map, axis=1 + ).argmin(axis=0) + + right_point_half = right_in_map[right_point_half_index] + check_pos_x, check_pos_y = (left_point_half + right_point_half) // 2 + check_width = 5 * (np.linalg.norm(left_point_half - right_point_half) / lfs_scale) + check_heading = ( + angle_from_2d_vector(left_in_map[half_len - 1] - left_in_map[half_len]) + + np.pi / 2 + ) + + print(check_heading) + check_block = _create_checkpoint_block( + check_pos_x, check_pos_y, check_heading, check_width, 1 + ) + + final_object_blocks = b"".join( + (start_block, finish_block, check_block, *cones_bytes) + ) + + n_obj = len(final_object_blocks) // BLOCK_STRUCT.size + assert len(final_object_blocks) % BLOCK_STRUCT.size == 0 + header = HEADER_STRUCT.pack(b"LFSLYT", 0, 251, n_obj, 10, 8) + + final_bytes = b"".join((header, final_object_blocks)) + return final_bytes + + +def cones_to_lyt( + world_name: Literal["BL4", "AU1", "AU2", "AU3", "WE3", "LA2"], + cones_left: FloatArrayNx2, + cones_right: FloatArrayNx2, +) -> bytes: + offset = { + "BL4": (-261, 124), + "AU1": (-50, -1010), + "AU2": (-138, -696), + "AU3": (-66, -50), + "WE3": (64, -1200), + "LA2": (538, 548), + }[world_name] + + offset = np.array(offset) + + assert offset is not None + + cones_per_type = [np.empty((0, 2)) for _ in ConeTypes] + cones_per_type[ConeTypes.LEFT] = cones_left[1:] + cones_per_type[ConeTypes.RIGHT] = cones_right[1:] + cones_per_type[ConeTypes.START_FINISH_LINE] = np.row_stack( + (cones_left[0], cones_right[0]) + ) + + bytes_to_write = _traces_to_lyt_bytes(cones_per_type, offset) + return bytes_to_write diff --git a/drawing_to_fsd_layout/image_processing.py b/drawing_to_fsd_layout/image_processing.py new file mode 100644 index 0000000..8aa2e75 --- /dev/null +++ b/drawing_to_fsd_layout/image_processing.py @@ -0,0 +1,244 @@ +from pathlib import Path +from typing import Iterable + +import matplotlib.pyplot as plt +import networkx as nx +import numpy as np +import streamlit as st +from scipy.spatial.distance import cdist +from skimage import io +from skimage.color import rgb2gray +from skimage.feature import canny +from skimage.filters import unsharp_mask +from skimage.transform import rescale + +from drawing_to_fsd_layout.common import FloatArrayNx2 + +Image = np.typing.NDArray[np.float64] + + +def rotate(points: np.ndarray, theta: float) -> np.ndarray: + """ + Rotates the points in `points` by angle `theta` around the origin + + Args: + points: The points to rotate. Shape (n,2) + theta: The angle by which to rotate in radians + + Returns: + The points rotated + """ + cos_theta, sin_theta = np.cos(theta), np.sin(theta) + rotation_matrix = np.array(((cos_theta, -sin_theta), (sin_theta, cos_theta))).T + return np.dot(points, rotation_matrix) + + +def load_raw_image(image_path: Path | str) -> Image: + """ + Load an image. If input is a string, it is assumed to be a path to an image. If + input is a Path, it is assumed to be a path to an image. If input is an image, it is + returned as is. + """ + if isinstance(image_path, str): + image_path = Path(image_path) + + image = io.imread(image_path) if isinstance(image_path, Path) else image_path.copy() + + return image + + +def create_close_point_adjacency_matrix( + edge_1: FloatArrayNx2, edge_2: FloatArrayNx2, distance: float +) -> np.ndarray: + """ + Combine two edges into a single edge. + + Args: + edge_1: The first edge. Shape (n,2) + edge_2: The second edge. Shape (m,2) + + Returns: + The combined edge. + """ + dist = cdist(edge_1, edge_2) + + # find the closest point in edge_2 for each point in edge_1 + idxs_closest_in_edge_2 = dist.argmin(axis=1) + + # find the closest point in edge_1 for each point in edge_2 + idxs_closest_in_edge_1 = dist.argmin(axis=0) + + adj_edge_1_to_edge_2 = idxs_closest_in_edge_1 < distance + adj_edge_2_to_edge_1 = idxs_closest_in_edge_2 < distance + + combined_length = len(edge_1) + len(edge_2) + + adj = np.zeros((combined_length, combined_length), dtype=bool) + + adj[: len(edge_1), len(edge_1) :] = adj_edge_1_to_edge_2 + adj[len(edge_1) :, : len(edge_1)] = adj_edge_2_to_edge_1 + + return adj + + +def combine_edges(edge_1: FloatArrayNx2, edge_2: FloatArrayNx2) -> FloatArrayNx2: + """ + Combine two edges into a single edge. + + Args: + edge_1: The first edge. Shape (n,2) + edge_2: The second edge. Shape (m,2) + + Returns: + The combined edge. + """ + adj = create_close_point_adjacency_matrix(edge_1, edge_2, distance=2) + # remove one directional edges + adj = np.logical_and(adj, adj.T) + + # find the index of the closest point in edge_2 for each point in edge_1 + idx_edge_2_to_edge_1_pair = np.argmax(adj[: len(edge_1), len(edge_1) :], axis=1) + # if argmax returns 0, it means that there is no edge between the two points + filtered_idxs_mask = idx_edge_2_to_edge_1_pair != 0 + + edge_2_keep_idxs = idx_edge_2_to_edge_1_pair[filtered_idxs_mask] + edge_1_keep_idxs = np.arange(len(edge_1))[filtered_idxs_mask] + + # combine the edges by element-wise mean + edge_1_keep = edge_1[edge_1_keep_idxs] + edge_2_keep = edge_2[edge_2_keep_idxs] + combined_edge = (edge_1_keep + edge_2_keep) / 2 + + return combined_edge + + +@st.cache(show_spinner=False) +def load_image_and_preprocess( + image_path: Path | str | Image, target_size: tuple[int, int] = (1000, 1000) +) -> Image: + """Load an image and scale it to the correct size for FSD layout.""" + image = load_raw_image(image_path) + + if image.ndim == 3: + image = image[:, :, :3] + + image_resolution = np.prod(image.shape) + target_resolution = np.prod(target_size) + + rescale_ratio = target_resolution / image_resolution + # we need to take the root of the ratio to achieve the correct scaling + image_resized = rescale(image, rescale_ratio**0.5, channel_axis=-1) + + # convert to grayscale + image_gray = ( + rgb2gray(image_resized) if image_resized.ndim == 3 else image_resized.copy() + ) + image_one_channel = image_gray[:, :, 0] if image_gray.ndim == 3 else image_gray + + # apply unsharp mask + image_unsharp = unsharp_mask(image_one_channel, radius=5, amount=3) + + return image_unsharp + + +def reorder_track_edge( + g: nx.Graph, cc_idxs: Iterable[int], all_nodes_positions: FloatArrayNx2 +) -> FloatArrayNx2: + cc_idxs_list = list(cc_idxs) + start_index = cc_idxs_list[0] + + idxs_ordered = list(nx.depth_first_search.dfs_preorder_nodes(g, start_index)) + + cc_positions_ordered = all_nodes_positions[idxs_ordered] + + distances = np.linalg.norm(np.diff(cc_positions_ordered, axis=0), axis=1) + mask_remove = distances > 5 + + first_index_over_k = np.argmax(mask_remove) + cc_positions_ordered = cc_positions_ordered[:first_index_over_k] + + return cc_positions_ordered + + +def extract_track_edges( + image: Image, + show_steps: bool = False, +) -> tuple[FloatArrayNx2, FloatArrayNx2]: + # apply canny edge detection with increasing sigma until the number of pixels + # designated as edges is low enough + for s in np.linspace(2, 5, 20): + image_canny = canny(image, sigma=s).astype(float) + m = image_canny.mean() + if m < 0.03: # prior, found by trial and error + break + + if show_steps: + st.image(image_canny, caption="Canny edge detection") + + # treat each pixel as a node in a graph and connect nodes that are close to each + # other + edge_pixels = np.argwhere(image_canny > 0.01) + dist = cdist(edge_pixels, edge_pixels) + adj = dist < 2 + adj[np.eye(len(adj), len(adj), dtype=bool)] = 0 + g = nx.from_numpy_matrix(adj) + + # find the connected components of the graph + # we expect four connected components, two for the outer edge and two for the inner + # edge + cc = list(nx.connected_components(g)) + + best_ccs = sorted(cc, key=len, reverse=True)[:4] + + best_clusters = [edge_pixels[list(idxs_in_cc)] for idxs_in_cc in best_ccs] + # keep the longer version of each track edge + if len(best_clusters) == 2: + outer, inner = best_clusters + cc_outer, cc_inner = best_ccs + else: + outer, _, inner, _ = best_clusters + cc_outer, _, cc_inner, _ = best_ccs + + if show_steps: + plt.figure() + plt.plot(*outer.T, ".", markersize=1) + plt.plot(*inner.T, ".", markersize=1) + plt.axis("equal") + st.pyplot(plt.gcf()) + + outer_ordered = reorder_track_edge(g, cc_outer, edge_pixels) + inner_ordered = reorder_track_edge(g, cc_inner, edge_pixels) + + if show_steps: + plt.figure() + plt.plot(*outer_ordered[::3].T, "-") + plt.plot(*inner_ordered[::3].T, "-") + plt.axis("equal") + st.pyplot(plt.gcf()) + + return outer_ordered, inner_ordered + + +def fix_edges_orientation_and_scale_to_unit( + edge_a: FloatArrayNx2, edge_b: FloatArrayNx2 +) -> tuple[FloatArrayNx2, FloatArrayNx2]: + points = [edge_a, edge_b] + + all_points = np.concatenate(points) + + # peak to peak (max - min) + ptp = np.ptp(all_points) + min_value = np.min(all_points) + # min-max scaling + points_scaled = [(points - min_value) / ptp for points in points] + + points_center = np.row_stack(points_scaled).mean(axis=0) + + points_centered = [points - points_center for points in points_scaled] + + # orientation fix + points_rotated = [rotate(p, theta=-3.1415 / 2) for p in points_centered] + + return points_rotated[0], points_rotated[1] + return points_rotated[0], points_rotated[1] + return points_rotated[0], points_rotated[1] diff --git a/drawing_to_fsd_layout/math_utils.py b/drawing_to_fsd_layout/math_utils.py new file mode 100644 index 0000000..c1d0560 --- /dev/null +++ b/drawing_to_fsd_layout/math_utils.py @@ -0,0 +1,638 @@ +#!/usin_roll/bin/env python3 +# -*- coding:utf-8 -*- +""" +Description: A module with common mathematical functions + +Taken from ft-as-utils + +Project: FaSTTUBe Chabo Common +""" +from typing import Tuple, TypeVar, cast + +import numpy as np +from numba import jit + +T = TypeVar("T") + + +def my_njit(func: T) -> T: + """ + numba.njit is an untyped decorator. This wrapper helps type checkers keep the + type information after applying the decorator. Furthermore, it sets some performance + flags + + Args: + func (T): The function to jit + + Returns: + T: The jitted function + """ + jit_func: T = jit(nopython=True, cache=True, nogil=True, fastmath=True)(func) + + return jit_func + + +@my_njit +def vec_dot(vecs1: np.ndarray, vecs2: np.ndarray) -> np.ndarray: + """ + Mutliplies vectors in an array elementwise + + Args: + vecs1 (np.array): The first "list" of vectors + vecs2 (np.array): The second "list" of vectors + + Returns: + np.array: The results + """ + return np.sum(vecs1 * vecs2, axis=-1) + + +@my_njit +def norm_of_last_axis(arr: np.ndarray) -> np.ndarray: + + original_shape = arr.shape + arr_row_col = arr.flatten().reshape(-1, arr.shape[-1]) + result = np.empty(arr_row_col.shape[0]) + for i in range(arr_row_col.shape[0]): + vec = arr_row_col[i] + result[i] = np.sqrt(vec_dot(vec, vec)) + + result = result.reshape(original_shape[:-1]) + + return result + + +@my_njit +def vec_angle_between( + vecs1: np.ndarray, vecs2: np.ndarray, clip_cos_theta: bool = True +) -> np.ndarray: + """ + Calculates the angle between the vectors of the last dimension + + Args: + vecs1 (np.ndarray): An array of shape (...,2) + vecs2 (np.ndarray): An array of shape (...,2) + clip_cos_theta (bool): Clip the values of the dot products so that they are + between -1 and 1. Defaults to True. + + Returns: + np.ndarray: A vector, such that each element i contains the angle between + vectors vecs1[i] and vecs2[i] + """ + cos_theta = vec_dot(vecs1, vecs2) + + cos_theta /= norm_of_last_axis(vecs1) * norm_of_last_axis(vecs2) + + cos_theta = np.asarray(cos_theta) + + cos_theta_flat = cos_theta.ravel() + + if clip_cos_theta: + cos_theta_flat[cos_theta_flat < -1] = -1 + cos_theta_flat[cos_theta_flat > 1] = 1 + + return np.arccos(cos_theta) + + +def rotate(points: np.ndarray, theta: float) -> np.ndarray: + """ + Rotates the points in `points` by angle `theta` around the origin + + Args: + points (np.array): The points to rotate. Shape (n,2) + theta (float): The angle by which to rotate in radians + + Returns: + np.array: The points rotated + """ + cos_theta, sin_theta = np.cos(theta), np.sin(theta) + rotation_matrix = np.array(((cos_theta, -sin_theta), (sin_theta, cos_theta))).T + return np.dot(points, rotation_matrix) + + +@my_njit +def my_cdist_sq_euclidean(arr_a: np.ndarray, arr_b: np.ndarray) -> np.ndarray: + """ + Calculates the pairwise square euclidean distances from each point in `X` to each + point in `Y` + + Credit: + Uses https://stackoverflow.com/a/56084419 which in turn uses + https://github.com/droyed/eucl_dist + + Args: + arr_a (np.array): A 2d array of shape (m,k) + arr_b (np.array): A 2d array of shape (n,k) + + Returns: + np.array: A matrix of shape (m,n) containing the square euclidean distance + between all the points in `X` and `Y` + """ + n_x, dim = arr_a.shape + x_ext = np.empty((n_x, 3 * dim)) + x_ext[:, :dim] = 1 + x_ext[:, dim : 2 * dim] = arr_a + x_ext[:, 2 * dim :] = np.square(arr_a) + + n_y = arr_b.shape[0] + y_ext = np.empty((3 * dim, n_y)) + y_ext[:dim] = np.square(arr_b).T + y_ext[dim : 2 * dim] = -2 * arr_b.T + y_ext[2 * dim :] = 1 + + return np.dot(x_ext, y_ext) + + +@my_njit +def calc_pairwise_distances( + points: np.ndarray, dist_to_self: float = 0.0 +) -> np.ndarray: + """ + Given a set of points, creates a distance matrix from each point to every point + + Args: + points (np.ndarray): The points for which the distance matrix should be + calculated dist_to_self (np.ndarray, optional): The distance to set the + diagonal. Defaults to 0.0. + + Returns: + np.ndarray: The 2d distance matrix + """ + pairwise_distances = my_cdist_sq_euclidean(points, points) + + if dist_to_self != 0: + for i in range(len(points)): + pairwise_distances[i, i] = dist_to_self + return pairwise_distances + + +@my_njit +def my_in1d(test_values: np.ndarray, source_container: np.ndarray) -> np.ndarray: + """ + Calculate a boolean mask for a 1d array indicating if an element in `test_values` is + present in `source container` which is also 1d + + Args: + test_values (np.ndarray): The values to test if they are inside the container + source_container (np.ndarray): The container + + Returns: + np.ndarray: A boolean array with the same length as `test_values`. If + `return_value[i]` is `True` then `test_value[i]` is in `source_container` + """ + source_sorted = np.sort(source_container) + is_in = np.zeros(test_values.shape[0], dtype=np.bool_) + for i, test_val in enumerate(test_values): + for source_val in source_sorted: + + if test_val == source_val: + is_in[i] = True + break + + if source_val > test_val: + break + + return is_in + + +def trace_calculate_consecutive_radii(trace: np.ndarray) -> np.ndarray: + """ + Expects a (n,2) array and returns the radius of the circle that passes + between all consecutive point triples. The radius between index 0,1,2, then 1,2,3 + and so on + + Args: + trace (np.ndarray): The points for which the radii will be calculated + + Returns: + np.ndarray: The radii for each consecutive point triple + """ + + # TODO: Vectorize this function. Limit is the indexer + indexer = np.arange(3)[None, :] + 1 * np.arange(trace.shape[-2] - 2)[:, None] + + points = trace[indexer] + radii = calculate_radius_from_points(points) + return radii + + +def trace_distance_to_next(trace: np.ndarray) -> np.ndarray: + """ + Calculates the distance of one point in the trace to the next. Obviously the last + point doesn't have any distance associated + + Args: + trace (np.array): The points of the trace + + Returns: + np.array: A vector containing the distances from one point to the next + """ + return np.linalg.norm(np.diff(trace, axis=-2), axis=-1) + + +def trace_angles_between(trace: np.ndarray) -> np.ndarray: + """ + Calculates the angles in a trace from each point to its next + + Args: + trace (np.array): The trace containing a series of 2d vectors + + Returns: + np.array: The angle from each vector to its next, with `len(return_value) == + len(trace) - 1` + """ + all_to_next = np.diff(trace, axis=-2) + from_middle_to_next = all_to_next[..., 1:, :] + from_middle_to_prev = -all_to_next[..., :-1, :] + angles = vec_angle_between(from_middle_to_next, from_middle_to_prev) + return angles + + +@my_njit +def unit_2d_vector_from_angle(rad: np.ndarray) -> np.ndarray: + """ + Creates unit vectors for each value in the rad array + + Args: + rad (np.array): The angles (in radians) for which the vectors should be created + + Returns: + np.array: The created unit vectors + """ + rad = np.asarray(rad) + new_shape = rad.shape + (2,) + res = np.empty(new_shape, dtype=rad.dtype) + res[..., 0] = np.cos(rad) + res[..., 1] = np.sin(rad) + return res + + +# Calculates the angle of each vector in `vecs` +# TODO: Look into fixing return type when a single vector is provided (return float) +def angle_from_2d_vector(vecs: np.ndarray) -> np.ndarray: + """ + Calculates the angle of each vector in `vecs`. If `vecs` is just a single 2d vector + then one angle is calculated and a scalar is returned + + >>> import numpy as np + >>> x = np.array([[1, 0], [1, 1], [0, 1]]) + >>> angle_from_2d_vector(x) + >>> array([0. , 0.78539816, 1.57079633]) + + Args: + vecs (np.array): The vectors for which the angle is calculated + + Raises: + ValueError: If `vecs` has the wrong shape a ValueError is raised + + Returns: + np.array: The angle of each vector in `vecs` + """ + if vecs.shape == (2,): + return np.arctan2(vecs[1], vecs[0]) + if vecs.ndim == 2 and vecs.shape[-1] == 2: + return np.arctan2(vecs[:, 1], vecs[:, 0]) + raise ValueError("vecs can either be a 2d vector or an array of 2d vectors") + + +def normalize(vecs: np.ndarray, axis: int = -1) -> np.ndarray: + """ + Returns a normalized version of vecs + + Args: + vecs (np.ndarray): The vectors to normalize + axis (int, optional): The axis to use for lengths. Defaults to -1. + + Returns: + np.ndarray: The normalized vectors + """ + return vecs / np.linalg.norm(vecs, axis=axis, keepdims=True) + + +@my_njit +def lerp( + values_to_lerp: np.ndarray, + start1: np.ndarray, + stop1: np.ndarray, + start2: np.ndarray, + stop2: np.ndarray, +) -> np.ndarray: + """ + Linearly interpolates (lerps) from one sin_pitchace `[start1, stop1]` to another + `[start2, stop2]`. `start1 >= stop1` and `start2 >= stop2` are allowed. If ns is a + 2d array, then start1, stop1, start2, stop2 must be 1d vectors. This allows for + lerping in any n-dim sin_pitchace + + >>> import numpy as np + >>> x = np.array([1, 2, 3]) + >>> lerp(x, 0, 10, 30, 100) + >>> array([37., 44., 51.]) + + Args: + values_to_lerp (np.array): The points to interpolate + start1 (np.array): The beginning of the original sin_pitchace + stop1 (np.array): The end of the original sin_pitchace + start2 (np.array): The beginning of the target sin_pitchace + stop2 (np.array): The end of the target sin_pitchace + + Returns: + np.array: The interpolated points + """ + return (values_to_lerp - start1) / (stop1 - start1) * (stop2 - start2) + start2 + + +def calculate_radius_from_points(points: np.ndarray) -> np.ndarray: + """ + Given a three points this function calculates the radius of the circle that passes + through these points + + Based on: https://math.stackexchange.com/questions/133638/ + how-does-this-equation-to-find-the-radius-from-3-points-actually-work + + Args: + points (np.ndarray): The points for which should be used to calculate the radius + + Returns: + np.ndarray: The calculated radius + """ + # implements the equation discussed here: + # + # assert points.shape[-2:] == (3, 2) + # get side lengths + points_circular = points[..., [0, 1, 2, 0], :] + len_sides = trace_distance_to_next(points_circular) + + # calc prod of sides + prod_of_sides = np.prod(len_sides, axis=-1, keepdims=True) + + # calc area of triangle + # https://www.mathopenref.com/heronsformula.html + + # calc half of perimeter + perimeter = np.sum(len_sides, axis=-1, keepdims=True) + half_perimeter = perimeter / 2 + half_perimeter_minus_sides = half_perimeter - len_sides + area_sqr = ( + np.prod(half_perimeter_minus_sides, axis=-1, keepdims=True) * half_perimeter + ) + area = np.sqrt(area_sqr) + + radius = prod_of_sides / (area * 4) + + radius = radius[..., 0] + return radius + + +Numeric = TypeVar("Numeric", float, np.ndarray) + + +def linearly_combine_values_over_time( + tee: float, delta_time: float, previous_value: Numeric, new_value: Numeric +) -> Numeric: + """ + Linear combination of two values over time + (see https://de.wikipedia.org/wiki/PT1-Glied) + Args: + tee (float): The parameter selecting how much we keep from the previous value + and how much we update from the new + delta_time (float): The time difference between the previous and new value + previous_value (Numeric): The previous value + new_value (Numeric): The next value + + Returns: + Numeric: The combined value + """ + tee_star = 1 / (tee / delta_time + 1) + combined_value: Numeric = tee_star * (new_value - previous_value) + previous_value + return combined_value + + +def odd_square(values: Numeric) -> Numeric: + return cast(Numeric, np.sign(values) * np.square(values)) + + +def euler_angles_to_quaternion(euler_angles: np.ndarray) -> np.ndarray: + """ + Converts Euler angles to a quaternion representation. + + Args: + euler_angles (np.ndarray): Euler angles as an [...,3] array. Order is + [roll, pitch, yaw] + + Returns: + np.ndarray: The quaternion representation in [..., 4] [x, y, z, w] order + """ + roll_index, pitch_index, yaw_index = 0, 1, 2 + sin_values = np.sin(euler_angles * 0.5) + cos_values = np.cos(euler_angles * 0.5) + + cos_yaw = cos_values[..., yaw_index] + sin_yaw = sin_values[..., yaw_index] + cos_pitch = cos_values[..., pitch_index] + sin_pitch = sin_values[..., pitch_index] + cos_roll = cos_values[..., roll_index] + sin_roll = sin_values[..., roll_index] + + quaternion_x = sin_roll * cos_pitch * cos_yaw - cos_roll * sin_pitch * sin_yaw + quaternion_y = cos_roll * sin_pitch * cos_yaw + sin_roll * cos_pitch * sin_yaw + quaternion_z = cos_roll * cos_pitch * sin_yaw - sin_roll * sin_pitch * cos_yaw + quaternion_w = cos_roll * cos_pitch * cos_yaw + sin_roll * sin_pitch * sin_yaw + + return_value = np.stack( + [quaternion_x, quaternion_y, quaternion_z, quaternion_w], axis=-1 + ) + return return_value + + +def quaternion_to_euler_angles(quaternion: np.ndarray) -> np.ndarray: + """ + Converts a quaternion to Euler angles. Based on + https://stackoverflow.com/a/37560411. + + Args: + quaternion (np.ndarray): The quaternion as an [..., 4] array. Order is + [x, y, z, w] + + Returns: + np.ndarray: The Euler angles as an [..., 3] array. Order is [roll, pitch, yaw] + """ + x_index, y_index, z_index, w_index = 0, 1, 2, 3 + x_value = quaternion[..., x_index] + y_value = quaternion[..., y_index] + z_value = quaternion[..., z_index] + w_value = quaternion[..., w_index] + + y_square = y_value * y_value + temporary_0 = -2.0 * (y_square + z_value * z_value) + 1.0 + temporary_1 = +2.0 * (x_value * y_value + w_value * z_value) + temporary_2 = -2.0 * (x_value * z_value - w_value * y_value) + temporary_3 = +2.0 * (y_value * z_value + w_value * x_value) + temporary_4 = -2.0 * (x_value * x_value + y_square) + 1.0 + + temporary_2 = np.clip(temporary_2, -1.0, 1.0) + + roll = np.arctan2(temporary_3, temporary_4) + pitch = np.arcsin(temporary_2) + yaw = np.arctan2(temporary_1, temporary_0) + + return_value = np.stack([roll, pitch, yaw], axis=-1) + return return_value + + +def points_inside_ellipse( + points: np.ndarray, + center: np.ndarray, + major_direction: np.ndarray, + major_radius: float, + minor_radius: float, +) -> np.ndarray: + """ + Checks if a set of points are inside an ellipse. + + Args: + points: The points as an [..., 2] array. + center: The center of the ellipse as an [2] array. + major_direction: The major direction of the ellipse as an [2] array. + major_radius: The major radius of the ellipse. + minor_radius: The minor radius of the ellipse. + + Returns: + An [...] array of booleans. + """ + + # Center the points around the center + # [..., 2] + centered_points = points - center + # Calculate angle of the major direction with the x-axis + # [1] + major_direction_angle = float(angle_from_2d_vector(major_direction)) + # Rotate the points around the center of the ellipse + # [..., 2] + rotated_points = rotate(centered_points, -major_direction_angle) + # [2] + radii_square = np.array([major_radius, minor_radius]) ** 2 + # [...] [..., 2] [2] + criterion_value = (rotated_points**2 / radii_square).sum(axis=-1) + + mask_is_inside = criterion_value < 1 + return mask_is_inside + + +def center_of_circle_from_3_points( + point_1: np.ndarray, + point_2: np.ndarray, + point_3: np.ndarray, + atol: float = 1e-6, +) -> np.ndarray: + """ + Calculates the center of a circle from three points. + + Adapted from http://paulbourke.net/geometry/circlesphere/Circle.cpp (CalcCircle) + + Args: + point_1: The first point as an [2] array. + point_2: The second point as an [2] array. + point_3: The third point as an [2] array. + + Returns: + The center of the circle as an [2] array. + """ + y_delta_1 = point_2[1] - point_1[1] + x_delta_1 = point_2[0] - point_1[0] + y_delta_2 = point_3[1] - point_2[1] + x_delta_2 = point_3[0] - point_2[0] + + if np.isclose(x_delta_1, 0.0, atol=atol) and np.isclose(x_delta_2, 0.0, atol=atol): + center_x = (point_2[0] + point_3[0]) / 2 + center_y = (point_1[1] + point_2[1]) / 2 + return np.array([center_x, center_y]) # early return + + slope_1 = y_delta_1 / x_delta_1 + slope_2 = y_delta_2 / x_delta_2 + if np.isclose(slope_1, slope_2, atol=atol): + raise ValueError("Points are colinear") + + center_x = ( + slope_1 * slope_2 * (point_1[1] - point_3[1]) + + slope_2 * (point_1[0] + point_2[0]) + - slope_1 * (point_2[0] + point_3[0]) + ) / (2 * (slope_2 - slope_1)) + + center_y = ( + -(center_x - (point_1[0] + point_2[0]) / 2) / slope_1 + + (point_1[1] + point_2[1]) / 2 + ) + + center = np.array([center_x, center_y]) + return center + + +@my_njit +def circle_fit(coords: np.ndarray, max_iter: int = 99) -> np.ndarray: + """ + Fit a circle to a set of points. This function is adapted from the hyper_fit function + in the circle-fit package (https://pypi.org/project/circle-fit/). The function is + a njit version of the original function with some input validation removed. Furthermore, + the residuals are not calculated or returned. + + Args: + coords: The coordinates of the points as an [N, 2] array. + max_iter: The maximum number of iterations. + + Returns: + An array with 3 elements: + - center x + - center y + - radius + """ + + X = coords[:, 0] + Y = coords[:, 1] + + n = X.shape[0] + + Xi = X - X.mean() + Yi = Y - Y.mean() + Zi = Xi * Xi + Yi * Yi + + # compute moments + Mxy = (Xi * Yi).sum() / n + Mxx = (Xi * Xi).sum() / n + Myy = (Yi * Yi).sum() / n + Mxz = (Xi * Zi).sum() / n + Myz = (Yi * Zi).sum() / n + Mzz = (Zi * Zi).sum() / n + + # computing the coefficients of characteristic polynomial + Mz = Mxx + Myy + Cov_xy = Mxx * Myy - Mxy * Mxy + Var_z = Mzz - Mz * Mz + + A2 = 4 * Cov_xy - 3 * Mz * Mz - Mzz + A1 = Var_z * Mz + 4.0 * Cov_xy * Mz - Mxz * Mxz - Myz * Myz + A0 = Mxz * (Mxz * Myy - Myz * Mxy) + Myz * (Myz * Mxx - Mxz * Mxy) - Var_z * Cov_xy + A22 = A2 + A2 + + # finding the root of the characteristic polynomial + y = A0 + x = 0.0 + for _ in range(max_iter): + Dy = A1 + x * (A22 + 16.0 * x * x) + x_new = x - y / Dy + if x_new == x or not np.isfinite(x_new): + break + y_new = A0 + x_new * (A1 + x_new * (A2 + 4.0 * x_new * x_new)) + if abs(y_new) >= abs(y): + break + x, y = x_new, y_new + + det = x * x - x * Mz + Cov_xy + X_center = (Mxz * (Myy - x) - Myz * Mxy) / det / 2.0 + Y_center = (Myz * (Mxx - x) - Mxz * Mxy) / det / 2.0 + + x = X_center + X.mean() + y = Y_center + Y.mean() + r = np.sqrt(abs(X_center**2 + Y_center**2 + Mz)) + + return np.array([x, y, r]) + diff --git a/drawing_to_fsd_layout/spline_fit.py b/drawing_to_fsd_layout/spline_fit.py new file mode 100644 index 0000000..f6abfa3 --- /dev/null +++ b/drawing_to_fsd_layout/spline_fit.py @@ -0,0 +1,135 @@ +""" +Taken from https://github.com/papalotis/ft-fsd-path-planning/blob/main/fsd_path_planning/utils/math_utils.py +""" +from dataclasses import dataclass +from typing import Any, Optional, Tuple + +import numpy as np +from scipy.interpolate import splev, splprep + + +@dataclass +class SplineEvaluator: + """ + A class for evaluating a spline. + """ + + max_u: float + tck: Tuple[Any, Any, int] + predict_every: float + + def calculate_u_eval(self, max_u: Optional[float] = None) -> np.ndarray: + """ + Calculate the u_eval values for the spline. + Args: + max_u (Optional[float], optional): The maximum u value. Defaults to None. If + None, the maximum u value used during fitting is taken. + Returns: + np.ndarray: The values for which the spline should be evaluated. + """ + + if max_u is None: + max_u = self.max_u + return np.arange(0, max_u, self.predict_every) + + def predict(self, der: int, max_u: Optional[float] = None) -> np.ndarray: + """ + Predict the spline. If der is 0, the function returns the spline. If der is 1, + the function returns the first derivative of the spline and so on. + Args: + der (int): The derivative to predict. + max_u (Optional[float], optional): The maximum u value. Defaults to None. If + None, the maximum u value used during fitting is taken. + Returns: + np.ndarray: The predicted spline. + """ + + u_eval = self.calculate_u_eval(max_u) + values = np.array(splev(u_eval, tck=self.tck, der=der)).T + + return values + + +class NullSplineEvaluator(SplineEvaluator): + """ + A dummy spline evaluator used for when an empty list is attempted to be fitted + """ + + def predict(self, der: int, max_u: Optional[float] = None) -> np.ndarray: + points = np.zeros((0, 2)) + return points + + +class SplineFitterFactory: + """ + Wrapper class for `splev`, `splprep` functions + """ + + def __init__(self, smoothing: float, predict_every: float, max_deg: int): + """ + Constructor for SplineFitter class + Args: + smoothing (float): The smoothing factor. 0 means no smoothing + predict_every (float): The approximate distance along the fitted trace to + calculate a point for + max_deg (int): The maximum degree of the fitted splines + """ + self.smoothing = smoothing + self.predict_every = predict_every + self.max_deg = max_deg + + def fit(self, trace: np.ndarray, periodic: bool = False) -> SplineEvaluator: + """ + Fit a trace and returns a closure that can evaluate the fitted spline at + different positions. The maximal spline degree is 2. + Args: + trace (np.ndarray): The trace to fit + Returns: + Callable[[int, float]: A closure that when called evalues + the fitted spline on the provided positions. + """ + if len(trace) < 2: + return NullSplineEvaluator( + # dummy values + 0, + (0, 0, 0), + 0, + ) + k = np.clip(len(trace) - 1, 1, self.max_deg) + distance_to_next = np.linalg.norm(np.diff(trace, axis=0), axis=1) + u_fit = np.concatenate(([0], np.cumsum(distance_to_next))) + try: + tck, _ = splprep( # pylint: disable=unbalanced-tuple-unpacking + trace.T, s=self.smoothing, k=k, u=u_fit, per=periodic + ) + except ValueError: + with np.printoptions(threshold=100000): + print(self.smoothing, self.predict_every, self.max_deg, repr(trace)) + + raise + + max_u = float(u_fit[-1]) + + return SplineEvaluator(max_u, tck, self.predict_every) + + def fit_then_evaluate_trace_and_derivative( + self, trace: np.ndarray + ) -> Tuple[np.ndarray, np.ndarray]: + """ + Fit a provided trace, then evaluates it, and its derivative in `n_predict` + evenly spaced positions + Args: + trace (np.ndarray): The trace to fit + Returns: + Tuple[np.ndarray, np.ndarray]: A tuple containing the evaluated trace and + the evaluated derivative + """ + if len(trace) < 2: + return trace.copy(), trace.copy() + + fitted_func = self.fit(trace) + + evaluated_trace = fitted_func.predict(der=0) + evaluated_derivative = fitted_func.predict(der=1) + + return (evaluated_trace,) diff --git a/drawing_to_track.ipynb b/drawing_to_track.ipynb new file mode 100755 index 0000000..12157ec --- /dev/null +++ b/drawing_to_track.ipynb @@ -0,0 +1,924 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from itertools import count\n", + "from typing import Iterable\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import thinning\n", + "from drawing_to_fsd_layout.math_utils import (trace_distance_to_next,\n", + " unit_2d_vector_from_angle)\n", + "from drawing_to_fsd_layout.math_utils import normalize\n", + "from drawing_to_fsd_layout.math_utils import rotate as rotate_points\n", + "\n", + "from chabo_common.utils.spline_fit import SplineFitterFactory\n", + "from chabo_simulation.lfs.lyt_interface.io.write_lyt import write_traces_as_lyt\n", + "from scipy.sparse.csgraph import connected_components\n", + "from chabo_common.utils.math_utils import my_cdist_sq_euclidean\n", + "from skimage import io\n", + "from skimage.exposure import rescale_intensity\n", + "from skimage.feature import canny\n", + "from skimage.filters import gaussian\n", + "from skimage.transform import rescale\n", + "from skimage.transform import rotate as rotate_image\n", + "from sklearn.metrics.pairwise import pairwise_distances\n" + ] + }, + { + "cell_type": "code", + "execution_count": 119, + "metadata": {}, + "outputs": [], + "source": [ + "# !python -m pip install --user --upgrade pip" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Load image and basic transforms\n", + "\n", + "- Change the **path_to_image** variable to the path to the image you want to load.\n", + "- The image is loaded as grayscale.\n", + "- The image is resized to a (smaller) size to aid with computational speed.\n", + "- The image contrast is boosted to improve edge detection" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Rescaling image by factor 0.063\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "path_to_image = \"/mnt/c/Users/papal/Documents/fasttube/2022/experiments/drawing-to-track/images/image4.jpg\"\n", + "# path_to_image = \"images/image5.jpg\"\n", + "\n", + "\n", + "image_gray = io.imread(path_to_image, as_gray=True)\n", + "\n", + "image_resolution = np.prod(image_gray.shape[:2])\n", + "target_resolution = 1000 * 1000\n", + "\n", + "# rescale to desired resolution\n", + "rescale_ratio = round(target_resolution / image_resolution, 3)\n", + "print(f'Rescaling image by factor {rescale_ratio}')\n", + "# we square root because scale refers to each dimension separately\n", + "image_resized = rescale(image_gray, rescale_ratio**0.5)\n", + "# boost contrast\n", + "image_boost_contrast = image_resized.copy() if 1 else rescale_intensity(image_resized)\n", + "plt.imshow(image_boost_contrast, cmap=\"gray\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Extract track edges\n", + "\n", + "There are two methods to extract the track edges. If your input is already a binarized image of track edges then you should use the threshold method. If your input is an image of a \"handwritten\" track or your input has the track \"filled in\" (the track is coloured in), then you should use the canny method.\n", + "\n", + "## Canny\n", + "- We use canny edge detection to extract the track edges.\n", + "- The canny_sigma variable defines the sensitivity of the algorithm.\n", + "- Adjust it up until the edges of the track are clearly visible and connected, and other edges are mostly not present.\n", + "- If your input is a filled in track then the gaussian blur is not relevant (you can set it to zero).\n", + "- If your input are the track edges then the canny output needs to be blurred. This is because canny will produce a double edge for the track edges (the rise and fall of the edge). By blurring the image a little bit we can combine the double edges into a single one.\n", + "- The thickness of the edge will be addressed in the next step. In order to address the new thicker edges, we apply an algorithm to make the edges thinner. You don't have to worry in case your input does not need blurring, the algorithm will keep thin edges in place. \n", + "\n", + "## Simpler alternative\n", + "\n", + "If you already have a binarized image (because you used a digitizer instead of drawing on a physical paper), then you probably want to use a simple threshold value. Adjust the threshold variable so that the track edges are visible." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.6547339019539653 0.15887487259750388\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "method_canny = 1\n", + "\n", + "\n", + "if method_canny:\n", + " do_thinning = True\n", + " canny_sigma = 1.5\n", + " gaussian_sigma = 1.5\n", + " print(image_boost_contrast.max(), image_boost_contrast.min())\n", + " canny_edges = canny(image_boost_contrast, sigma=canny_sigma)\n", + " plt.figure(figsize=(10,10))\n", + " plt.imshow(canny_edges, cmap=\"gray\")\n", + " plt.title(f\"Canny edges with sigma={canny_sigma}\")\n", + " plt.show()\n", + " gaussian_edges = gaussian(canny_edges, gaussian_sigma)\n", + " plt.figure(figsize=(10,10))\n", + " plt.imshow(gaussian_edges, cmap=\"gray\")\n", + " plt.title(f\"Gaussian edges with sigma={gaussian_sigma}\")\n", + " plt.show()\n", + "\n", + " if do_thinning:\n", + " edges = thinning.guo_hall_thinning((gaussian_edges * 255).astype(np.uint8)) > 0\n", + " else:\n", + " edges = gaussian_edges\n", + " \n", + "\n", + "\n", + "else:\n", + " threshold = 0.5\n", + "\n", + " edges_raw = (image_boost_contrast < threshold).astype(float)\n", + " edges = thinning.guo_hall_thinning((edges_raw * 255).astype(np.uint8)) > 0\n", + " \n", + "\n", + "plt.figure(figsize=(20,20))\n", + "plt.title(f\"Thinning edges\")\n", + "plt.imshow(edges, cmap=\"gray\", interpolation=\"bicubic\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Split inside and outside track edges\n", + "\n", + "- We want to split the inside and outside track edges.\n", + "- For this we will create a graph of pixels that are connected to each other.\n", + "- Only pixels that are \"on\" after edge extraction are considered.\n", + "- The pixels are randomized to remove the effect of the order of the pixels.\n", + "- Pixels are connected to each other if they are close enough.\n", + "- The maximum distance between two pixels is defined by the **max_distance** variable.\n", + "- 'cityblock'/'manhattan' distance is used.\n", + "- After the graph has been constructed, the connected components are found.\n", + "- Only the two largest components are kept. All other components are discarded.\n", + "- The two largest components should contain a similar number of datapoints and any other components should contain a very small number of points. If that is not the case adjust the max_distance variable.\n", + "- If too many components with a small number of elements are present then the distance is too low. If only one large components is created then the distance is too high.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 122, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "9885\n", + "9885\n", + "(9885, 9885)\n", + "calulating connections\n", + "(9885, 9885)\n", + "(9885,)\n", + "2\n", + "[4986 4899]\n" + ] + } + ], + "source": [ + "maximum_distance = 4\n", + "\n", + "ratio_keep = 1\n", + "\n", + "# create distance matrix\n", + "points = np.argwhere(edges)\n", + "\n", + "points_keep = (points[:,0] > 1) * (points[:,0] < edges.shape[0] - 1) * (points[:,1] > 1) * (points[:,1] < edges.shape[1] - 1)\n", + "\n", + "points = points[points_keep]\n", + "\n", + "\n", + "\n", + "points_idxs = np.linspace(0, len(points)-1, int(len(points) * ratio_keep), dtype=int)\n", + "print(len(points))\n", + "points = points[points_idxs]\n", + "print(len(points))\n", + "\n", + "distances = pairwise_distances(points, points)\n", + "print(distances.shape)\n", + "# create graph\n", + "print('calulating connections')\n", + "connections = np.logical_and(distances > 0, distances <= maximum_distance)\n", + "print(connections.shape)\n", + "\n", + "# find connected components\n", + "number_of_components, labels = connected_components(connections)\n", + "print(labels.shape)\n", + "print(number_of_components)\n", + "# only keep two largest components\n", + "unique_labels, counts = np.unique(labels, return_counts=True)\n", + "print(counts)\n", + "unique_labels_sorted_by_count = unique_labels[np.argsort(counts)]\n", + "two_largest_components = unique_labels_sorted_by_count[-2:]\n", + "lines_points = [points[label == labels] for label in two_largest_components]" + ] + }, + { + "cell_type": "code", + "execution_count": 123, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(20,20))\n", + "for l in unique_labels:\n", + " plt.plot(*points[labels==l].T, '.', markersize=1)\n", + "plt.gca().set_aspect(\"equal\", adjustable=\"box\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Get order from track edges\n", + "\n", + "The edges that we have now are simple 2d point clouds. We need to extract direction from them. Ideally the algorithms described in [this paper](https://www.rechenraum.com/de/assets/publications/simon_floery_da.pdf) should be used. However, I have not attempted this. Initially alphashapes were used but they are limited in the shapes that the can model, before they fall back to multiple polygons.\n", + "\n", + "The algorithm that we use starts from the first node of the graph that was created before and visits the next node that keeps to the direction of the current node. This is done until the initial node is reached again. This is not a very stable algorithm. However it works better than the alphashape method. If the algorithm does not work then try to change the number of points that are bering extracted in the step above. This usually helps." + ] + }, + { + "cell_type": "code", + "execution_count": 124, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "def walk_through_track(connections: np.ndarray, positions: np.ndarray, start_index: int) -> Iterable[int]:\n", + " current_index = start_index\n", + " \n", + " yield current_index\n", + " neighbor = np.where(connections[current_index])[0][0]\n", + " yield neighbor\n", + "\n", + " seen = {current_index, neighbor}\n", + "\n", + "\n", + " min_steps = 50\n", + " for i in count():\n", + " neighbors = np.where(connections[neighbor])[0]\n", + " next_indices = list(set(neighbors) - seen)\n", + "\n", + " if len(next_indices) == 0:\n", + " print('stop')\n", + " break\n", + " \n", + "\n", + " v1 = positions[current_index] - positions[neighbor]\n", + " v2 = positions[neighbor] - positions[next_indices]\n", + "\n", + " \n", + " d = np.dot(v2, v1)\n", + " \n", + " next_index_index = np.argmax(d)\n", + " next_index = next_indices[next_index_index]\n", + "\n", + "\n", + " if i > min_steps:\n", + " dist = np.linalg.norm(positions[start_index] - positions[next_index])\n", + " \n", + " if dist < 20:\n", + " do_print = True\n", + " break\n", + "\n", + " yield next_index\n", + " seen.add(next_index)\n", + " current_index = neighbor\n", + " neighbor = next_index" + ] + }, + { + "cell_type": "code", + "execution_count": 125, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(1582, 2)\n", + "(1623, 2)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "\n", + "plt.figure(figsize=(20,20))\n", + "points_sorted = []\n", + "\n", + "\n", + "for component_id in two_largest_components:\n", + " start_index_for_component = np.where(labels == component_id)[0][100]\n", + " \n", + " idxs = list(walk_through_track(connections, points, start_index=start_index_for_component))\n", + " \n", + " points_walk = points[idxs]\n", + "\n", + " print(points_walk.shape)\n", + "\n", + "\n", + " points_sorted.append(points_walk)\n", + "\n", + " \n", + " plt.plot(*points_walk.T, '-')\n", + " plt.gca().set_aspect(\"equal\", adjustable=\"box\")\n", + "\n", + " do_half = True\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Fix points orientation and normalize scale\n", + "\n", + "- The orientation of the track has changed (because we have moved from pixel-space to world-space).\n", + "- Pixel-space has its origin on the top left corner.\n", + "- World-space has its origin on the bottom left corner.\n", + "- In the next cell we fix the orientation of the track.\n", + "- We also normalize the scale of the track. The points are now in a [0,1] range." + ] + }, + { + "cell_type": "code", + "execution_count": 126, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1582\n", + "1623\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "all_points = np.concatenate(points_sorted)\n", + "\n", + "# peak to peak (max - min)\n", + "ptp = np.ptp(all_points)\n", + "min_value = np.min(all_points)\n", + "# min-max scaling\n", + "lines_points_scaled = [(points - min_value) / ptp for points in points_sorted]\n", + "\n", + "# orientation fix\n", + "lines_points_fix_orientation = [\n", + " ((rotate_image(points, 180) * [1, -1]) + [0, 1]) for points in lines_points_scaled\n", + "]\n", + "\n", + "plt.figure(figsize=(10,10))\n", + "for p in lines_points_fix_orientation:\n", + " plt.plot(*p.T, '.', markersize=1)\n", + "\n", + " print(len(p))\n", + " \n", + "plt.gca().set_aspect(\"equal\", adjustable=\"box\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Fitting a spline to the track edge\n", + "\n", + "- Each track edge is represented by a list of points.\n", + "- We want to fit a spline to the track edge.\n", + "- The spline is a piecewise cubic parametric polynomial.\n", + "- We use the wrapper in `chabo_common` to fit the spline.\n", + "- The spline fits the track edge \"thrice\", then the middle fit is selected.\n", + "- This ensures that the spline is smooth at the start/finish area." + ] + }, + { + "cell_type": "code", + "execution_count": 127, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fitter_factory = SplineFitterFactory(smoothing=0.0001, predict_every=0.001, max_deg=5)\n", + "\n", + "splined_traces = []\n", + "\n", + "plt.figure(figsize=(10, 8))\n", + "for p in lines_points_fix_orientation:\n", + " # stack edge points thrice\n", + " alpha_points_tiled = np.tile(p[:-1], (3, 1))\n", + "\n", + " # create spline and evaluate it\n", + " spline_points = fitter_factory.fit(alpha_points_tiled[::3]).predict(der=0)\n", + " l = len(spline_points)\n", + " # get middle third of evaluated spline\n", + " spline_points = spline_points[l // 3 : 2 * l // 3]\n", + "\n", + " splined_traces.append(spline_points)\n", + " plt.plot(*spline_points[:].T, \"-\")\n", + "\n", + "\n", + "for p in lines_points_fix_orientation:\n", + " plt.plot(*p.T, '-', markersize=1, alpha=0.4)\n", + "\n", + "\n", + "plt.gca().set_aspect(\"equal\", adjustable=\"box\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Scale to real world units\n", + "\n", + "- The minimum track width is 3 meters.\n", + "- We calculate the distance between all points from one edge to the other.\n", + "- We pick the smallest distance.\n", + "- This value is used as an anchor point for the scaling.\n", + "- The scale is calculated as the minimum track width divided by the smallest distance.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 128, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1300 3174\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "minimum_track_width = 7\n", + "\n", + "# calculate minimum distance between track edges\n", + "distances = pairwise_distances(splined_traces[0], splined_traces[1])\n", + "\n", + "min_distance = distances.min()\n", + "index_min_distance_left, index_min_distance_right = np.argwhere(distances == min_distance)[0]\n", + "\n", + "\n", + "# calculate scale factor\n", + "scale = minimum_track_width / min_distance\n", + "\n", + "# scale points of track edges\n", + "spline_points_scaled = [scale * points for points in splined_traces]\n", + "\n", + "plt.figure(figsize=(10, 8))\n", + "\n", + "for p in spline_points_scaled:\n", + " plt.plot(*p[:].T)\n", + "print(index_min_distance_left, index_min_distance_right)\n", + "left_min_point = spline_points_scaled[0][index_min_distance_left]\n", + "right_min_point = spline_points_scaled[1][index_min_distance_right]\n", + "plt.plot([left_min_point[0], right_min_point[0]], [left_min_point[1], right_min_point[1]], 'x-', markersize=10)\n", + "\n", + "plt.gca().set_aspect(\"equal\", adjustable=\"box\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Algorithm to place cones on track edges\n", + "\n", + "- Algorithm taken from track_designer" + ] + }, + { + "cell_type": "code", + "execution_count": 129, + "metadata": {}, + "outputs": [], + "source": [ + "def place_cones(\n", + " trace: np.ndarray, seed: int, mean: float, variance: float\n", + ") -> np.ndarray:\n", + "\n", + " rng = np.random.default_rng(seed)\n", + "\n", + " idxs_to_keep = [0]\n", + " next_distance = rng.normal(mean, variance)\n", + " next_idx = idxs_to_keep[0]\n", + " while next_idx < len(trace):\n", + " \n", + " trace_from_last_in = trace[next_idx:]\n", + " cum_dist = np.cumsum(trace_distance_to_next(trace_from_last_in))\n", + "\n", + " offset_next_idx = np.argmax(cum_dist > next_distance)\n", + "\n", + " if offset_next_idx == 0:\n", + " break\n", + "\n", + " next_idx = offset_next_idx + next_idx\n", + " idxs_to_keep.append(next_idx)\n", + " next_distance = rng.normal(mean, variance)\n", + "\n", + " randomly_placed_cones = trace[idxs_to_keep]\n", + "\n", + " first_cone, last_cone = randomly_placed_cones[0], randomly_placed_cones[-1]\n", + " first_cone_distance = np.linalg.norm(first_cone - last_cone)\n", + " if first_cone_distance > 2 * mean:\n", + " new_last_cone = (first_cone + last_cone) / 2\n", + "\n", + " randomly_placed_cones = np.row_stack([randomly_placed_cones, new_last_cone])\n", + "\n", + " return randomly_placed_cones" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Cone placement on track edges\n", + "\n", + "- A start position and angle is needed.\n", + "- The start position is a point between the track edges. It defines the position of the start/finish line.\n", + "- The start angle defines the direction of the track\n", + "- The distance between cones is defines by a gaussian distribution.\n", + "- mean and variance are the parameters of this gaussian distribution.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 130, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.0\n", + "120\n", + "405\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "start_position = np.array([0.45, 0.85]) * scale\n", + "start_angle = np.deg2rad(0)\n", + "\n", + "mean = 4.5\n", + "variance = 0.2\n", + "print(start_angle)\n", + "start_direction = unit_2d_vector_from_angle(start_angle)\n", + "\n", + "cone_traces = []\n", + "\n", + "plt.figure(figsize=(10, 8))\n", + "\n", + "for trace in spline_points_scaled[:]:\n", + " # put cones on trace\n", + " cone_trace = place_cones(trace, seed=2, mean=mean, variance=variance)\n", + " # find the cone closest to the start position\n", + " # this is the first cone of the edge\n", + " start_cone_index = np.argmin(np.linalg.norm(cone_trace - start_position, axis=1))\n", + "\n", + " print(start_cone_index)\n", + "\n", + " # find the next cone (according to the track direction)\n", + " # for the cone immediately before and after the start cone\n", + " for next_cone_index in (start_cone_index - 1, start_cone_index + 1):\n", + " # get the vector that points from the start cone to the next cone\n", + " vec = normalize(cone_trace[next_cone_index] - cone_trace[start_cone_index])\n", + " # get the dot product to the start direction\n", + " # if the value is positive, then the cone is in the same direction as the start cone\n", + " sign = np.dot(start_direction, vec)\n", + " if sign > 0:\n", + " break\n", + "\n", + " # roll the cone trace so that the start cone is the first element\n", + " # if needed invert the order of the cones (if the second cone according to the start\n", + " # direction is behind the first)\n", + " sign = np.sign(next_cone_index - start_cone_index)\n", + " cone_trace = np.roll(cone_trace, -start_cone_index, axis=0)\n", + " if sign < 1:\n", + " cone_trace = np.roll(cone_trace[::-1], 1, axis=0)\n", + "\n", + " cone_traces.append(cone_trace)\n", + "\n", + " plt.plot(*cone_trace[:].T, \".-\")\n", + "\n", + "start = np.row_stack([start_position, start_position + start_direction * 5])\n", + "plt.plot(*start.T, \"o-\")\n", + "plt.gca().set_aspect(\"equal\", adjustable=\"box\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Determine cone color (blue, yellow)\n", + "\n", + "- The color of the cones is determined by the track direction.\n", + "- Cones on the left side of the track are blue.\n", + "- Cones on the right side of the track are yellow.\n", + "- The \"side-ness\" (if an edge represents the left or right side of the track) of each edge is determined by the start angle\n", + "- The track is translated and rotated to the start position and start angle.\n", + "- At the point the the start position is on [0,0] and the start angle is 0\n", + "- This means that the y component of the first cone of the left edge is positive.\n", + "- Consequently, the first cone of the right edge is negative.\n", + "- This way we determine the color of the cones for each edge." + ] + }, + { + "cell_type": "code", + "execution_count": 131, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "first is left\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "cone_traces_normalized = []\n", + "\n", + "middle = (cone_traces[0][0] + cone_traces[1][0]) / 2\n", + "\n", + "for cone_trace in cone_traces:\n", + " # normalize cone trace\n", + " cone_trace = cone_trace - middle\n", + " cone_trace = rotate_points(cone_trace[:1], -start_angle)\n", + " cone_traces_normalized.append(cone_trace)\n", + "\n", + "if cone_traces_normalized[0][0, 1] > 0:\n", + " print(\"first is left\")\n", + " left, right = cone_traces\n", + "else:\n", + " print(\"first is right\")\n", + " right, left = cone_traces\n", + "\n", + "\n", + "plt.figure(figsize=(10, 10))\n", + "plt.plot(*left.T, \".-\", color=\"blue\")\n", + "plt.plot(*right.T, \".-\", color=\"gold\")\n", + "\n", + "plt.gca().set_aspect(\"equal\", adjustable=\"box\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Export\n", + "\n", + "- We are done with the processing\n", + "- We need to pick a world an a layout name.\n", + "- `LA2` is recommended for world name.\n", + "- The layout name can be picked by the user." + ] + }, + { + "cell_type": "code", + "execution_count": 132, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "4.124386376837123\n", + "/mnt/c/LFS/data/layout/LA2_my_track_ext2.lyt\n" + ] + } + ], + "source": [ + "layout_name = \"my_track_ext2\"\n", + "\n", + "world_name = \"LA2\"\n", + "\n", + "empty = np.zeros((0, 2))\n", + "\n", + "all_cones_mean = np.row_stack([left, right]).mean(axis=0)\n", + "left = left - all_cones_mean\n", + "right = right - all_cones_mean\n", + "\n", + "\n", + "left_cones = left[1:]\n", + "right_cones = right[1:]\n", + "orange_big = np.row_stack([left[:1], right[:1]])\n", + "\n", + "traces = [empty, right_cones, left_cones, empty, orange_big]\n", + "\n", + "write_traces_as_lyt(world_name, layout_name, traces)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "interpreter": { + "hash": "667d18e076aa000d538005e76bad9c784894d3d5ea080972a6e2c4dc0fe43299" + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.12 (main, Apr 5 2022, 06:56:58) \n[GCC 7.5.0]" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000..61b8482 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,6 @@ +numpy +scipy +scikit-image +thinning_py3 +matplotlib +scikit-learn \ No newline at end of file diff --git a/streamlit_app.py b/streamlit_app.py new file mode 100644 index 0000000..118cdf3 --- /dev/null +++ b/streamlit_app.py @@ -0,0 +1,328 @@ +from enum import Enum + +import matplotlib.pyplot as plt +import numpy as np +import streamlit as st +from skimage import io + +from drawing_to_fsd_layout.common import FloatArrayNx2 +from drawing_to_fsd_layout.cone_placement import ( + calculate_min_track_width, calculate_min_track_width_index, + decide_start_finish_line_position_and_direction, + estimate_centerline_from_edges, estimate_centerline_length, + fix_edge_direction, place_cones, split_edge_to_straight_and_curve) +from drawing_to_fsd_layout.export import cones_to_lyt, export_json_string +from drawing_to_fsd_layout.image_processing import ( + extract_track_edges, fix_edges_orientation_and_scale_to_unit, + load_image_and_preprocess, rotate) +from drawing_to_fsd_layout.spline_fit import SplineFitterFactory + + +class UploadType(str, Enum): + FILE = "file" + URL = "url" + + +class ScalingMethod(str, Enum): + MIN_TRACK_WIDTH = "min_track_width" + CENTERLINE_LENGTH = "centerline_length" + + +class SFLineCalculationMethod(str, Enum): + AUTO = "auto" + MANUAL = "manual" + + +class SmoothingDegree(str, Enum): + NONE = "none" + LIGHT = "light" + MEDIUM = "medium" + HEAVY = "heavy" + + +SFLineHelpText = """ +The start/finish line is the line that the car crosses to start and finish a lap. +The start/finish line is calculated automatically by default. If you want to +manually specify the start/finish line, select "Manual" and enter the x/y coordinates +of the start/finish line as well as its direction. The closest point on the track +to your assigned start/finish line will be used. +""" + + +def image_upload_widget() -> np.ndarray: + upload_type = UploadType[st.radio("Upload type", [x.name for x in UploadType])] + + if upload_type == UploadType.FILE: + uploaded_file = st.file_uploader("Upload an image") + if uploaded_file is None: + st.info("Please upload an image") + st.stop() + + imread_input = uploaded_file.read() + kwargs_imageio = dict(plugin="imageio") + elif upload_type == UploadType.URL: + imread_input = st.text_input("URL to image") + if imread_input == "": + st.info("Please enter a URL") + st.stop() + + kwargs_imageio = dict() + else: + raise AssertionError("Unreachable code") + + image = io.imread(imread_input, **kwargs_imageio) + + return image + + +def plot_contours( + contour_a: FloatArrayNx2, contour_b: FloatArrayNx2, do_show: bool = True +) -> None: + import matplotlib.pyplot as plt + + plt.figure() + for con in (contour_a, contour_b): + plt.plot(*con.T, "-") + plt.axis("equal") + if do_show: + st.pyplot(plt.gcf()) + + +def main() -> None: + st.title("Upload image") + image = image_upload_widget() + st.image(image, caption="Uploaded image") + with st.spinner("Preprocessing image"): + preprocessed_image = load_image_and_preprocess(image) + + with st.spinner("Extracting track edges"): + ( + contour_a, + contour_b, + ) = extract_track_edges(preprocessed_image) + + contour_a_fixed, contour_b_fixed = fix_edges_orientation_and_scale_to_unit( + contour_a, contour_b + ) + + st.title("Scale to real-world units") + scaling_method = st.radio( + "Method to use to scale to real world units", + list(ScalingMethod), + format_func=lambda x: x.name.replace("_", " ").title(), + horizontal=True, + ) + col_left, col_right = st.columns(2) + with col_left: + desired_track_width = st.number_input( + "Min track width", + min_value=0.1, + value=3.0, + disabled=scaling_method != ScalingMethod.MIN_TRACK_WIDTH, + ) + with col_right: + desired_centerline_length = st.number_input( + "Centerline length", + min_value=1.0, + value=200.0, + disabled=scaling_method != ScalingMethod.CENTERLINE_LENGTH, + ) + + if scaling_method == ScalingMethod.MIN_TRACK_WIDTH: + unscaled_min_track_width = calculate_min_track_width( + contour_a_fixed, contour_b_fixed + ) + scale = desired_track_width / unscaled_min_track_width + elif scaling_method == ScalingMethod.CENTERLINE_LENGTH: + unscaled_centerline_length = estimate_centerline_length( + contour_a_fixed, contour_b_fixed + ) + scale = desired_centerline_length / unscaled_centerline_length + + else: + raise AssertionError("Unreachable code") + + contour_a_fixed_scaled = contour_a_fixed * scale + contour_b_fixed_scaled = contour_b_fixed * scale + + smoothing_degree = st.select_slider( + "Smoothing", + options=list(SmoothingDegree), + value=SmoothingDegree.LIGHT, + format_func=lambda x: x.name.replace("_", " ").title(), + help="For hand-drawn tracks it is useful to smooth the track edges.", + ) + st.write(scale) + smoothing = scale / 5 * list(SmoothingDegree).index(smoothing_degree) + st.write("before spline") + spline_factory = SplineFitterFactory( + smoothing=smoothing, predict_every=0.3, max_deg=3 + ) + + contour_a_splined = spline_factory.fit( + contour_a_fixed_scaled[::2], periodic=True + ).predict(der=0) + + st.write(len(contour_a_splined), len(contour_a_fixed_scaled)) + + contour_b_splined = spline_factory.fit( + contour_b_fixed_scaled[::2], periodic=True + ).predict(der=0) + + min_track_width = calculate_min_track_width(contour_a_splined, contour_b_splined) + st.write(min_track_width) + centerline_length = estimate_centerline_length(contour_a_splined, contour_b_splined) + st.write(centerline_length) + + st.markdown( + f"*Min track width: {min_track_width:.2f} m | Centerline length:" + f" {centerline_length:.2f} m*" + ) + + # centerline = estimate_centerline_from_edges(contour_a_splined, contour_b_splined) + + st.title("Place start/finish line") + st.write("hi") + sf_line_calculation_method = SFLineCalculationMethod( + st.radio( + "Method to use to place start/finish line", + list(SFLineCalculationMethod), + format_func=lambda x: x.name.replace("_", " ").title(), + horizontal=True, + help=SFLineHelpText, + ) + ) + ( + start_on_contour_a, + direction_start, + ) = decide_start_finish_line_position_and_direction(contour_a_splined) + st.write("after decide_start_finish_line_position_and_direction") + if sf_line_calculation_method == SFLineCalculationMethod.AUTO: + flip_direction = st.checkbox( + "Flip track direction", + value=False, + ) + if flip_direction: + direction_start = -direction_start + elif sf_line_calculation_method == SFLineCalculationMethod.MANUAL: + col_left, col_middle, col_right = st.columns(3) + with col_left: + start_finish_line_x = st.number_input( + "S/F line x position (x)", value=start_on_contour_a[0] + ) + + with col_middle: + start_finish_line_y = st.number_input( + "S/F line y position (m)", value=start_on_contour_a[1] + ) + + with col_right: + start_finish_line_angle = st.number_input( + "S/F line angle (deg)", + value=np.rad2deg(np.arctan2(*direction_start[::-1])), + ) + user_point = np.array([start_finish_line_x, start_finish_line_y]) + user_direction = np.array( + [ + np.cos(np.deg2rad(start_finish_line_angle)), + np.sin(np.deg2rad(start_finish_line_angle)), + ] + ) + from scipy.spatial.distance import cdist + + start_on_contour_a = contour_a_splined[ + cdist([user_point], contour_a_splined).argmin() + ] + direction_start = user_direction + from scipy.spatial.distance import cdist + + index_start_contour_b = cdist([start_on_contour_a], contour_b_fixed_scaled).argmin() + start_on_contour_b = contour_b_fixed_scaled[index_start_contour_b] + + direction_to_inside_of_track = start_on_contour_b - start_on_contour_a + direction_to_outside_of_track = -direction_to_inside_of_track / np.linalg.norm( + direction_to_inside_of_track + ) + direction_to_outside_of_track *= min_track_width * 2 + + start_finish_arrow_stem = start_on_contour_a + direction_to_outside_of_track + + contour_a_final = fix_edge_direction( + contour_a_splined, start_on_contour_a, direction_start + ) + contour_b_final = fix_edge_direction( + contour_b_splined, start_on_contour_b, direction_start + ) + + cones_a = place_cones(contour_a_final, 1, 4, 0.1) + cones_b = place_cones(contour_b_final, 1, 4, 0.1) + + start_middle = (cones_a[0] + cones_b[0]) / 2 + start_direction_a = cones_a[1] - cones_a[0] + start_direction_a /= np.linalg.norm(start_direction_a) + + start_direction_b = cones_b[1] - cones_b[0] + start_direction_b /= np.linalg.norm(start_direction_b) + + start_direction = (start_direction_a + start_direction_b) / 2 + + cones_a_trans = cones_a - start_middle + cones_a_trans_rot = rotate(cones_a_trans, -np.arctan2(*start_direction[::-1])) + if cones_a_trans_rot[0, 1] > 0: + left_cones = cones_a + right_cones = cones_b + else: + left_cones = cones_b + right_cones = cones_a + + plt.figure(figsize=(10, 10)) + + plt.arrow( + *start_finish_arrow_stem, + *direction_start * min_track_width * 2, + head_width=min_track_width, + ) + + plt.plot(*right_cones.T, ".", c="gold", label="Contour A", markersize=2) + plt.plot(*left_cones.T, ".", c="b", label="Contour B", markersize=2) + plt.plot( + [left_cones[0, 0], right_cones[0, 0]], + [left_cones[0, 1], right_cones[0, 1]], + "x", + c="orange", + ) + plt.axis("equal") + plt.title("Final track layout") + + st.pyplot(plt.gcf()) + + st.title("Export") + track_name = st.text_input("Track name", "Custom Track") + track_name_normalized = track_name.replace(" ", "_").lower() + + tab_json, tab_lfs = st.tabs(["JSON", "Live for Speed Layout"]) + + with tab_json: + json_string = export_json_string(left_cones, right_cones) + st.download_button( + "Download JSON", + json_string, + file_name=f"{track_name_normalized}.json", + mime="application/json", + ) + with tab_lfs: + world_name = "LA2" + lyt_bytes = cones_to_lyt(world_name, left_cones, right_cones) + + filename = f"{world_name}_{track_name_normalized}.lyt" + + st.download_button( + "Download LFS Layout", + lyt_bytes, + file_name=filename, + mime="application/octet-stream", + ) + + +if __name__ == "__main__": + main()