nova_rerun_bridge.hull_visualizer

  1from typing import Any
  2
  3import numpy as np
  4import trimesh
  5from scipy.spatial import ConvexHull
  6
  7
  8class HullVisualizer:
  9    @staticmethod
 10    def compute_hull_mesh(
 11        polygons: list[np.ndarray],
 12    ) -> tuple[list[list[float]], list[list[int]], list[list[float]]]:
 13        """Convert polygons to mesh with optimized hull generation."""
 14        vertices = np.vstack(polygons)
 15
 16        # Custom qhull options for better quality
 17        qhull_opts = trimesh.convex.QhullOptions(
 18            Qt=True,  # Triangulated output
 19            QJ=True,  # Joggled input for precision
 20            Qc=True,  # Keep coplanar points
 21            Qx=True,  # Exact pre-merges
 22            QbB=True,  # Scale to unit cube
 23            Pp=True,  # Remove precision warnings
 24        )
 25
 26        mesh = trimesh.convex.convex_hull(vertices, qhull_options=qhull_opts, repair=True)
 27
 28        return (mesh.vertices.tolist(), mesh.faces.tolist(), mesh.vertex_normals.tolist())
 29
 30    @staticmethod
 31    def plane_from_triangle(p0, p1, p2, normal_epsilon=1e-6):
 32        # Compute normal
 33        v1 = p1 - p0
 34        v2 = p2 - p0
 35        n = np.cross(v1, v2)
 36        norm = np.linalg.norm(n)
 37        if norm < normal_epsilon:
 38            return None, None
 39        n = n / norm
 40        # Plane: n·x = d
 41        d = np.dot(n, p0)
 42        return n, d
 43
 44    @staticmethod
 45    def group_coplanar_triangles(points, hull, angle_epsilon=1e-6, dist_epsilon=1e-6):
 46        # Group triangles by their plane (normal and distance)
 47        plane_map = {}
 48        for simplex in hull.simplices:
 49            p0, p1, p2 = points[simplex]
 50            n, d = HullVisualizer.plane_from_triangle(p0, p1, p2)
 51            if n is None:
 52                continue
 53
 54            # Ensure a canonical representation of the plane normal
 55            for i_comp in range(3):
 56                if abs(n[i_comp]) > angle_epsilon:
 57                    if n[i_comp] < 0:
 58                        n = -n
 59                        d = -d
 60                    break
 61
 62            # Round normal and distance for stable hashing
 63            n_rounded = tuple(np.round(n, 6))
 64            d_rounded = round(d, 3)
 65
 66            key = (n_rounded, d_rounded)
 67            if key not in plane_map:
 68                plane_map[key] = []
 69            plane_map[key].append(simplex)
 70
 71        return plane_map
 72
 73    @staticmethod
 74    def merge_coplanar_triangles_to_polygon(points, simplices):
 75        # Extract polygon outline from coplanar triangles
 76        edges = {}
 77        for tri in simplices:
 78            for i in range(3):
 79                a = tri[i]
 80                b = tri[(i + 1) % 3]
 81                e = (min(a, b), max(a, b))
 82                edges[e] = edges.get(e, 0) + 1
 83
 84        # Keep only outer edges (appear once)
 85        boundary_edges = [e for e, count in edges.items() if count == 1]
 86        if not boundary_edges:
 87            return []
 88
 89        # Build adjacency
 90        adj = {}
 91        for a, b in boundary_edges:
 92            adj.setdefault(a, []).append(b)
 93            adj.setdefault(b, []).append(a)
 94
 95        # Walk along the boundary edges to form a closed loop
 96        start = boundary_edges[0][0]
 97        loop = [start]
 98        current = start
 99        prev = None
100        while True:
101            neighbors = adj[current]
102            next_vertex = None
103            for n in neighbors:
104                if n != prev:
105                    next_vertex = n
106                    break
107            if next_vertex is None:
108                break
109            loop.append(next_vertex)
110            prev, current = current, next_vertex
111            if next_vertex == start:
112                break
113
114        polygon_points = points[loop]
115        return polygon_points
116
117    @staticmethod
118    def compute_hull_outlines_from_geometries(child_geometries: list[Any]) -> list[np.ndarray]:
119        """Compute polygon outlines from geometry child objects.
120
121        Args:
122            child_geometries: List of geometry objects containing convex hulls
123
124        Returns:
125            List of closed polygons as Nx3 numpy arrays
126        """
127        all_points = []
128        for child in child_geometries:
129            if child.convex_hull is not None:
130                for v in child.convex_hull.vertices:
131                    all_points.append([v.x, v.y, v.z])
132
133        if len(all_points) < 4:
134            return []
135
136        return HullVisualizer._compute_hull_from_points(np.array(all_points))
137
138    @staticmethod
139    def compute_hull_outlines_from_points(points: list[list[float]]) -> list[np.ndarray]:
140        """Compute polygon outlines directly from point coordinates.
141
142        Args:
143            points: List of [x,y,z] coordinates
144
145        Returns:
146            List of closed polygons as Nx3 numpy arrays
147        """
148        if len(points) < 4:
149            return []
150
151        return HullVisualizer._compute_hull_from_points(np.array(points))
152
153    @staticmethod
154    def _compute_hull_from_points(points: np.ndarray) -> list[np.ndarray]:
155        """Internal helper to compute hull from numpy points array."""
156        try:
157            hull = ConvexHull(points)
158            plane_map = HullVisualizer.group_coplanar_triangles(points, hull)
159
160            polygons = []
161            for simplices in plane_map.values():
162                polygon_points = HullVisualizer.merge_coplanar_triangles_to_polygon(
163                    points, simplices
164                )
165                if len(polygon_points) > 2:
166                    closed_loop = np.vstack([polygon_points, polygon_points[0]])
167                    polygons.append(closed_loop)
168            return polygons
169
170        except Exception:
171            return []