diff --git a/core/nodeslicer/nodes/output.py b/core/nodeslicer/nodes/output.py index e086bfe..9bb3cef 100644 --- a/core/nodeslicer/nodes/output.py +++ b/core/nodeslicer/nodes/output.py @@ -357,6 +357,17 @@ class SLICENODE_WireframeToPdf(ExecSliceNode): bl_label = "Wireframe to PDF" button_label = "Generate PDF" + style: NfEnumProperty( + name="Style", + items=[ + ('WIREFRAME', "Wireframe", "All projected 3D wireframe edges"), + ('LINEART', "Lineart", "Silhouette, boundary, and crease edges above threshold angle"), + ('OUTER_CONTOUR', "Outer Contour", "Silhouette outline boundary"), + ], + default='WIREFRAME' + ) # pyright: ignore[reportInvalidTypeForm] + + crease_angle: NfFloatProperty(name="Crease Angle (°)", default=30.0, min=0.0, max=180.0) # pyright: ignore[reportInvalidTypeForm] line_width: NfFloatProperty(name="Line Width (mm)", default=0.5, min=.0) # pyright: ignore[reportInvalidTypeForm] margin: NfFloatProperty(name="Margin (mm)", default=10.0, min=.0) # pyright: ignore[reportInvalidTypeForm] @@ -385,6 +396,9 @@ class SLICENODE_WireframeToPdf(ExecSliceNode): def draw_buttons(self, context, layout): super().draw_buttons(context, layout) + layout.prop(self, "style") + if self.style == 'LINEART': + layout.prop(self, "crease_angle") layout.prop(self, "line_width") layout.prop(self, "margin") layout.prop(self, "bg_color") @@ -437,10 +451,13 @@ class SLICENODE_WireframeToPdf(ExecSliceNode): export_wireframe_to_pdf( edges_2d=edges_2d, filepath=filepath, + style=self.style, + crease_angle=self.crease_angle, margin_mm=self.margin, line_width_mm=self.line_width, stroke_color=(float(self.wire_color[0]), float(self.wire_color[1]), float(self.wire_color[2])), - bg_color=(float(self.bg_color[0]), float(self.bg_color[1]), float(self.bg_color[2])) + bg_color=(float(self.bg_color[0]), float(self.bg_color[1]), float(self.bg_color[2])), + raw_geometry=geom ) if operator: operator.report({'INFO'}, f"Wireframe PDF saved to {filepath}") except Exception as e: diff --git a/core/pdf_exporter.py b/core/pdf_exporter.py index a6a82fd..8ee5b85 100644 --- a/core/pdf_exporter.py +++ b/core/pdf_exporter.py @@ -4,6 +4,8 @@ import os import math import numpy as np from numpy.typing import NDArray +import shapely +from shapely.geometry import Polygon, MultiPolygon MM_TO_PT = 72.0 / 25.4 # 1 mm = 2.8346456692913386 PostScript points @@ -80,20 +82,290 @@ def extract_unique_top_view_edges(mesh_data: Any) -> NDArray[np.float64]: return ordered[unique_indices] +def extract_lineart_edges(mesh_data: Any, max_angle_deg: float = 30.0) -> NDArray[np.float64]: + """ + Fully vectorized NumPy Lineart edge extraction: + 1. Silhouette edge: shared between at least one CCW face and at least one CW face in 2D top view. + 2. Boundary edge: owned by only 1 face. + 3. Crease edge: owned by 2 or more faces where 3D dihedral angle between normals > max_angle_deg. + Returns 2D edge segments array of shape (N, 2, 2). + """ + from ..infra.blender.blender_mesh_capture import SlicingGroup, SlicingCollection, SlicingObject + + all_tris_3d = [] + all_normals = [] + + def process_item(item: Any): + if item is None: + return + elif isinstance(item, (list, tuple)): + for sub in item: + process_item(sub) + elif isinstance(item, SlicingGroup): + for coll in item.collections.values(): + process_item(coll) + elif isinstance(item, SlicingCollection): + for so in item.objects: + process_item(so) + elif isinstance(item, SlicingObject): + if item.mesh.size > 0: + verts_3d = item.mesh[:, :3, :3] # (N, 3, 3) + normals = item.mesh[:, 3, :] # (N, 3) + + norms_len = np.linalg.norm(normals, axis=1, keepdims=True) + norms_len = np.where(norms_len == 0, 1.0, norms_len) + normals_unit = normals / norms_len + + zero_norm_mask = (normals[:, 0] == 0) & (normals[:, 1] == 0) & (normals[:, 2] == 0) + if np.any(zero_norm_mask): + v0_3d = verts_3d[:, 0, :] + v1_3d = verts_3d[:, 1, :] + v2_3d = verts_3d[:, 2, :] + computed_normals = np.cross(v1_3d - v0_3d, v2_3d - v0_3d) + cn_len = np.linalg.norm(computed_normals, axis=1, keepdims=True) + cn_len = np.where(cn_len == 0, 1.0, cn_len) + normals_unit[zero_norm_mask] = (computed_normals / cn_len)[zero_norm_mask] + + all_tris_3d.append(verts_3d) + all_normals.append(normals_unit) + + process_item(mesh_data) + + if not all_tris_3d: + return np.empty((0, 2, 2), dtype=np.float64) + + tris_3d = np.concatenate(all_tris_3d, axis=0) # (N, 3, 3) + normals_unit = np.concatenate(all_normals, axis=0) # (N, 3) + num_tris = len(tris_3d) + + if num_tris == 0: + return np.empty((0, 2, 2), dtype=np.float64) + + # Top-view 2D vertices + verts_2d = tris_3d[:, :, :2] # (N, 3, 2) + + # 2D orientation per triangle + v0_2d = verts_2d[:, 0, :] + v1_2d = verts_2d[:, 1, :] + v2_2d = verts_2d[:, 2, :] + cross_2d = (v1_2d[:, 0] - v0_2d[:, 0]) * (v2_2d[:, 1] - v0_2d[:, 1]) - (v1_2d[:, 1] - v0_2d[:, 1]) * (v2_2d[:, 0] - v0_2d[:, 0]) + is_ccw = cross_2d > 0 + is_cw = cross_2d < 0 + + # Extract all 3 edges per triangle + e0_3d = tris_3d[:, [0, 1], :] + e1_3d = tris_3d[:, [1, 2], :] + e2_3d = tris_3d[:, [2, 0], :] + edges_3d = np.concatenate([e0_3d, e1_3d, e2_3d], axis=0) # (3N, 2, 3) + + e0_2d = verts_2d[:, [0, 1], :] + e1_2d = verts_2d[:, [1, 2], :] + e2_2d = verts_2d[:, [2, 0], :] + edges_2d = np.concatenate([e0_2d, e1_2d, e2_2d], axis=0) # (3N, 2, 2) + + edge_ccw = np.tile(is_ccw, 3) # (3N,) + edge_cw = np.tile(is_cw, 3) # (3N,) + edge_normals = np.tile(normals_unit, (3, 1)) # (3N, 3) + + # Filter out near zero-length 2D edges + dists_sq_2d = np.sum((edges_2d[:, 0, :] - edges_2d[:, 1, :]) ** 2, axis=1) + valid_len_mask = dists_sq_2d >= 1e-8 + + edges_3d = edges_3d[valid_len_mask] + edges_2d = edges_2d[valid_len_mask] + edge_ccw = edge_ccw[valid_len_mask] + edge_cw = edge_cw[valid_len_mask] + edge_normals = edge_normals[valid_len_mask] + + if len(edges_3d) == 0: + return np.empty((0, 2, 2), dtype=np.float64) + + # Canonical undirected edge sorting in 3D (rounded to 4 decimal places) + rounded_3d = np.round(edges_3d, decimals=4) + pA = rounded_3d[:, 0, :] + pB = rounded_3d[:, 1, :] + swap_mask = (pA[:, 0] > pB[:, 0]) | ( + (pA[:, 0] == pB[:, 0]) & (pA[:, 1] > pB[:, 1]) + ) | ( + (pA[:, 0] == pB[:, 0]) & (pA[:, 1] == pB[:, 1]) & (pA[:, 2] > pB[:, 2]) + ) + + canonical_3d = rounded_3d.copy() + canonical_3d[swap_mask] = canonical_3d[swap_mask][:, ::-1, :] + + canonical_2d = edges_2d.copy() + canonical_2d[swap_mask] = canonical_2d[swap_mask][:, ::-1, :] + + # Unique 3D edge identification using NumPy structured view + flat_3d = canonical_3d.reshape(len(canonical_3d), 6) + view_bytes = np.ascontiguousarray(flat_3d).view(np.dtype((np.void, 48))).ravel() + unique_keys, first_indices, inverse_indices, counts = np.unique( + view_bytes, return_index=True, return_inverse=True, return_counts=True + ) + + num_unique = len(unique_keys) + + # Rule 1: Silhouette edge (has CCW and CW face) + has_ccw = np.bincount(inverse_indices, weights=edge_ccw.astype(int), minlength=num_unique) > 0 + has_cw = np.bincount(inverse_indices, weights=edge_cw.astype(int), minlength=num_unique) > 0 + rule1_unique = has_ccw & has_cw + + # Rule 2: Boundary edge (owned by 1 face) + rule2_unique = counts == 1 + + # Rule 3: Crease edge (owned by 2+ faces with normal angle > max_angle_deg) + cos_threshold = math.cos(math.radians(max_angle_deg)) + rule3_unique = np.zeros(num_unique, dtype=bool) + + multi_edge_mask = counts >= 2 + if np.any(multi_edge_mask): + sort_by_edge = np.argsort(inverse_indices) + sorted_edge_ids = inverse_indices[sort_by_edge] + sorted_normals = edge_normals[sort_by_edge] + + splits = np.where(sorted_edge_ids[:-1] != sorted_edge_ids[1:])[0] + 1 + edge_groups = np.split(sorted_normals, splits) + unique_group_ids = np.split(sorted_edge_ids, splits) + + for grp_normals, grp_ids in zip(edge_groups, unique_group_ids): + edge_id = grp_ids[0] + if len(grp_normals) >= 2: + dots = grp_normals @ grp_normals.T + if np.any(dots < cos_threshold - 1e-6): + rule3_unique[edge_id] = True + + marked_unique_mask = rule1_unique | rule2_unique | rule3_unique + marked_first_indices = first_indices[marked_unique_mask] + + return canonical_2d[marked_first_indices] + + +def extract_outer_contour_edges(mesh_data: Any) -> NDArray[np.float64]: + """ + Extracts top-view outer boundary / silhouette contour line segments using Shapely 2D polygon union. + """ + from ..infra.blender.blender_mesh_capture import SlicingGroup, SlicingCollection, SlicingObject + + all_tris_2d = [] + + def process_item(item: Any): + if item is None: + return + elif isinstance(item, (list, tuple)): + for sub in item: + process_item(sub) + elif isinstance(item, SlicingGroup): + for coll in item.collections.values(): + process_item(coll) + elif isinstance(item, SlicingCollection): + for so in item.objects: + process_item(so) + elif isinstance(item, SlicingObject): + if item.mesh.size > 0: + verts_3d = item.mesh[:, :3, :3] # (N, 3, 3) + verts_2d = verts_3d[:, :, :2] # (N, 3, 2) + all_tris_2d.append(verts_2d) + + process_item(mesh_data) + + if not all_tris_2d: + return np.empty((0, 2, 2), dtype=np.float64) + + tris_2d = np.concatenate(all_tris_2d, axis=0) + if len(tris_2d) == 0: + return np.empty((0, 2, 2), dtype=np.float64) + + polys = [] + for tri in tris_2d: + p = Polygon(tri) + if p.is_valid and p.area > 1e-6: + polys.append(p) + + if not polys: + return np.empty((0, 2, 2), dtype=np.float64) + + try: + union_poly = shapely.union_all(polys) + except Exception: + return np.empty((0, 2, 2), dtype=np.float64) + + boundary_edges = [] + + def process_geom(geom): + if geom.is_empty: + return + if isinstance(geom, Polygon): + coords = np.array(geom.exterior.coords) + for i in range(len(coords) - 1): + boundary_edges.append([coords[i], coords[i + 1]]) + for interior in geom.interiors: + icoords = np.array(interior.coords) + for i in range(len(icoords) - 1): + boundary_edges.append([icoords[i], icoords[i + 1]]) + elif isinstance(geom, MultiPolygon): + for sub in geom.geoms: + process_geom(sub) + elif hasattr(geom, 'geoms'): + for sub in geom.geoms: + process_geom(sub) + + process_geom(union_poly) + if not boundary_edges: + return np.empty((0, 2, 2), dtype=np.float64) + + return np.array(boundary_edges, dtype=np.float64) + + +def _format_pdf_lines(lines_arr: NDArray[np.float64]) -> list[str]: + """ + Vectorized formatting of 2D line segments to PDF operator strings. + lines_arr shape: (N, 2, 2) + """ + if len(lines_arr) == 0: + return [] + flat = lines_arr.reshape(-1, 4) + return [f"{row[0]:.2f} {row[1]:.2f} m {row[2]:.2f} {row[3]:.2f} l" for row in flat] + + def export_wireframe_to_pdf( edges_2d: NDArray[np.float64], filepath: str, + style: str = 'WIREFRAME', + crease_angle: float = 30.0, margin_mm: float = 10.0, line_width_mm: float = 0.5, stroke_color: tuple[float, float, float] = (0.0, 0.0, 0.0), - bg_color: tuple[float, float, float] = (1.0, 1.0, 1.0) + bg_color: tuple[float, float, float] = (1.0, 1.0, 1.0), + raw_geometry: Any = None ) -> None: """ - Exports 2D wireframe line segments to a 1:1 true physical scale vector PDF file. - - PDF page dimensions automatically match the physical size of the geometry + grid + margin. - - line_width_mm is specified in physical millimeters and converted to PDF points (1 mm = 72/25.4 pt). + Exports 2D vector geometry to a 1:1 true physical scale vector PDF file. + Styles: + - WIREFRAME: All projected 3D wireframe edges + - LINEART: Silhouette, boundary, and crease edges above threshold angle + - OUTER_CONTOUR: Silhouette boundary contour outline """ - if len(edges_2d) > 0: + if style == 'LINEART' and raw_geometry is not None: + lineart_edges = extract_lineart_edges(raw_geometry, max_angle_deg=crease_angle) + if len(lineart_edges) > 0: + edges_to_draw = lineart_edges + else: + edges_to_draw = edges_2d + elif style == 'OUTER_CONTOUR' and raw_geometry is not None: + contour_edges = extract_outer_contour_edges(raw_geometry) + if len(contour_edges) > 0: + edges_to_draw = contour_edges + else: + edges_to_draw = edges_2d + else: + edges_to_draw = edges_2d + + if len(edges_to_draw) > 0: + min_x = float(edges_to_draw[:, :, 0].min()) + max_x = float(edges_to_draw[:, :, 0].max()) + min_y = float(edges_to_draw[:, :, 1].min()) + max_y = float(edges_to_draw[:, :, 1].max()) + elif len(edges_2d) > 0: min_x = float(edges_2d[:, :, 0].min()) max_x = float(edges_2d[:, :, 0].max()) min_y = float(edges_2d[:, :, 1].min()) @@ -114,7 +386,7 @@ def export_wireframe_to_pdf( minor_step = main_step / 10.0 - if len(edges_2d) > 0: + if len(edges_to_draw) > 0 or len(edges_2d) > 0: grid_min_x = math.floor(min_x / main_step) * main_step grid_max_x = math.ceil(max_x / main_step) * main_step grid_min_y = math.floor(min_y / main_step) * main_step @@ -137,87 +409,99 @@ def export_wireframe_to_pdf( page_w_pt = w_total_mm * MM_TO_PT page_h_pt = h_total_mm * MM_TO_PT - # Convert line width from millimeters to PostScript points line_width_pt = line_width_mm * MM_TO_PT def to_pdf_pt(pt_mm): - x_pt = (pt_mm[0] - grid_min_x + margin_mm) * MM_TO_PT - y_pt = (pt_mm[1] - grid_min_y + margin_mm) * MM_TO_PT - return x_pt, y_pt - - minor_lines: list[tuple[tuple[float, float], tuple[float, float]]] = [] - main_lines: list[tuple[tuple[float, float], tuple[float, float]]] = [] + x_pt = (pt_mm[:, 0] - grid_min_x + margin_mm) * MM_TO_PT + y_pt = (pt_mm[:, 1] - grid_min_y + margin_mm) * MM_TO_PT + return np.column_stack([x_pt, y_pt]) max_grid_steps = 2000 - # Vertical grid lines + # Vectorized vertical grid lines k_x_start = int(np.round(grid_min_x / minor_step)) k_x_end = int(np.round(grid_max_x / minor_step)) - if abs(k_x_end - k_x_start) <= max_grid_steps: - for k_x in range(k_x_start, k_x_end + 1): - gx = k_x * minor_step - p0 = to_pdf_pt((gx, grid_min_y)) - p1 = to_pdf_pt((gx, grid_max_y)) - if k_x % 10 == 0: - main_lines.append((p0, p1)) - else: - minor_lines.append((p0, p1)) + k_x = np.arange(k_x_start, k_x_end + 1) - # Horizontal grid lines + if len(k_x) <= max_grid_steps: + gx = k_x * minor_step + pts0_v = np.column_stack([gx, np.full_like(gx, grid_min_y)]) + pts1_v = np.column_stack([gx, np.full_like(gx, grid_max_y)]) + + p0_v = to_pdf_pt(pts0_v) + p1_v = to_pdf_pt(pts1_v) + is_main_x = (k_x % 10 == 0) + + main_v_lines = np.column_stack([p0_v[is_main_x], p1_v[is_main_x]]).reshape(-1, 2, 2) + minor_v_lines = np.column_stack([p0_v[~is_main_x], p1_v[~is_main_x]]).reshape(-1, 2, 2) + else: + main_v_lines = np.empty((0, 2, 2)) + minor_v_lines = np.empty((0, 2, 2)) + + # Vectorized horizontal grid lines k_y_start = int(np.round(grid_min_y / minor_step)) k_y_end = int(np.round(grid_max_y / minor_step)) - if abs(k_y_end - k_y_start) <= max_grid_steps: - for k_y in range(k_y_start, k_y_end + 1): - gy = k_y * minor_step - p0 = to_pdf_pt((grid_min_x, gy)) - p1 = to_pdf_pt((grid_max_x, gy)) - if k_y % 10 == 0: - main_lines.append((p0, p1)) - else: - minor_lines.append((p0, p1)) + k_y = np.arange(k_y_start, k_y_end + 1) + + if len(k_y) <= max_grid_steps: + gy = k_y * minor_step + pts0_h = np.column_stack([np.full_like(gy, grid_min_x), gy]) + pts1_h = np.column_stack([np.full_like(gy, grid_max_x), gy]) + + p0_h = to_pdf_pt(pts0_h) + p1_h = to_pdf_pt(pts1_h) + is_main_y = (k_y % 10 == 0) + + main_h_lines = np.column_stack([p0_h[is_main_y], p1_h[is_main_y]]).reshape(-1, 2, 2) + minor_h_lines = np.column_stack([p0_h[~is_main_y], p1_h[~is_main_y]]).reshape(-1, 2, 2) + else: + main_h_lines = np.empty((0, 2, 2)) + minor_h_lines = np.empty((0, 2, 2)) + + main_lines_arr = np.concatenate([main_v_lines, main_h_lines], axis=0) if len(main_v_lines) or len(main_h_lines) else np.empty((0, 2, 2)) + minor_lines_arr = np.concatenate([minor_v_lines, minor_h_lines], axis=0) if len(minor_v_lines) or len(minor_h_lines) else np.empty((0, 2, 2)) stream_cmds: list[str] = [] # 1. Solid background fill br, bg, bb = bg_color + sr, sg, sb = stroke_color stream_cmds.append(f"{br:.3f} {bg:.3f} {bb:.3f} rg") stream_cmds.append(f"0 0 {page_w_pt:.2f} {page_h_pt:.2f} re f") # 2. Wireframe stroke color - sr, sg, sb = stroke_color stream_cmds.append(f"{sr:.3f} {sg:.3f} {sb:.3f} RG") # 3. Minor Grid Lines (25% Opacity) - if minor_lines: + if len(minor_lines_arr) > 0: stream_cmds.append("/GS25 gs") minor_grid_pt = min(0.3 * MM_TO_PT, line_width_pt) stream_cmds.append(f"{minor_grid_pt:.2f} w") - lines_str = [f"{p0[0]:.2f} {p0[1]:.2f} m {p1[0]:.2f} {p1[1]:.2f} l" for p0, p1 in minor_lines] + lines_str = _format_pdf_lines(minor_lines_arr) for start_idx in range(0, len(lines_str), 5000): stream_cmds.extend(lines_str[start_idx:start_idx + 5000]) stream_cmds.append("S") # 4. Main Grid Lines (50% Opacity) - if main_lines: + if len(main_lines_arr) > 0: stream_cmds.append("/GS50 gs") main_grid_pt = min(0.4 * MM_TO_PT, line_width_pt) stream_cmds.append(f"{main_grid_pt:.2f} w") - lines_str = [f"{p0[0]:.2f} {p0[1]:.2f} m {p1[0]:.2f} {p1[1]:.2f} l" for p0, p1 in main_lines] + lines_str = _format_pdf_lines(main_lines_arr) for start_idx in range(0, len(lines_str), 5000): stream_cmds.extend(lines_str[start_idx:start_idx + 5000]) stream_cmds.append("S") - # 5. Object Wireframe (100% Opacity, exact physical line_width_mm) - if len(edges_2d) > 0: + # 5. Object Lines (100% Opacity) + if len(edges_to_draw) > 0: stream_cmds.append("/GS100 gs") stream_cmds.append(f"{line_width_pt:.2f} w") stream_cmds.append("1 j 1 J") # round join and cap - lines_str = [] - for i in range(len(edges_2d)): - p0 = to_pdf_pt(edges_2d[i, 0]) - p1 = to_pdf_pt(edges_2d[i, 1]) - lines_str.append(f"{p0[0]:.2f} {p0[1]:.2f} m {p1[0]:.2f} {p1[1]:.2f} l") + p0_pt = to_pdf_pt(edges_to_draw[:, 0, :]) + p1_pt = to_pdf_pt(edges_to_draw[:, 1, :]) + obj_lines_arr = np.column_stack([p0_pt, p1_pt]).reshape(-1, 2, 2) + lines_str = _format_pdf_lines(obj_lines_arr) for start_idx in range(0, len(lines_str), 5000): stream_cmds.extend(lines_str[start_idx:start_idx + 5000]) diff --git a/doc/NODES.md b/doc/NODES.md index cf96c91..6bc9c6c 100644 --- a/doc/NODES.md +++ b/doc/NODES.md @@ -115,10 +115,12 @@ All nodes are found in the **Add (Shift+A)** menu under the **SliceNodes** categ - **Load Gcode**: Reads a G-code file from disk. - **Gcode to File**: Writes G-code string to a file on disk. - **Automatic Binary Conversion**: If the G-code contains the comment `; binary_gcode = 1`, the node automatically converts the output to Prusa's binary G-code format (`.bgcode`) using MeatPack encoding and Heatshrink compression. -- **Wireframe to PDF**: Generates a 1:1 true-scale 2D top-view (+Z orthographic) wireframe PDF from a `SlicingGroup` or `SlicingCollection` with a custom grid and background color. +- **Wireframe to PDF**: Generates a 1:1 true-scale 2D top-view (+Z orthographic) vector PDF from a `SlicingGroup` or `SlicingCollection` with a custom grid and background color. - **Geometry**: Input socket accepting a `SlicingGroup`, `SlicingCollection`, or `SlicingObject`. - **Folder**: Target folder or PDF file path on disk. - - **Line Width (mm)**: Stroke width in millimeters for the wireframe lines. + - **Style**: Visualization style (Wireframe, Lineart, Outer Contour). + - **Crease Angle (°)**: Maximum dihedral angle threshold (default 30°) for marking feature crease lines when in Lineart mode. + - **Line Width (mm)**: Stroke width in millimeters for the exported lines. - **Margin (mm)**: Margin around the geometry grid in mm. - **Background**: Color picker for the canvas background. - **Wireframe**: Color picker for the wireframe lines and grid. diff --git a/tests/test_pdf_exporter.py b/tests/test_pdf_exporter.py index 065e960..99192b8 100644 --- a/tests/test_pdf_exporter.py +++ b/tests/test_pdf_exporter.py @@ -34,7 +34,12 @@ sys.modules['bpy.props'] = MagicMock() sys.modules['bpy.utils'] = MagicMock() from NodeSlicer.infra.blender.blender_mesh_capture import SlicingGroup, SlicingCollection, SlicingObject -from NodeSlicer.core.pdf_exporter import extract_unique_top_view_edges, export_wireframe_to_pdf, MM_TO_PT +from NodeSlicer.core.pdf_exporter import ( + extract_unique_top_view_edges, + extract_lineart_edges, + export_wireframe_to_pdf, + MM_TO_PT +) class TestPdfExporter(unittest.TestCase): @@ -89,8 +94,32 @@ class TestPdfExporter(unittest.TestCase): # Vertical edge (0,0,0)-(0,0,10) becomes 2D length 0 and should be filtered out self.assertTrue(len(edges) < 3) + def test_extract_lineart_edges(self): + so = SlicingObject() + # Create 2 triangles sharing an edge at 90 degree angle (crease) + tri1 = np.array([ + [0.0, 0.0, 0.0], + [10.0, 0.0, 0.0], + [0.0, 10.0, 0.0], + [0.0, 0.0, 1.0] # Normal up + ], dtype=np.float64) + tri2 = np.array([ + [10.0, 0.0, 0.0], + [10.0, 0.0, 10.0], + [0.0, 10.0, 0.0], + [1.0, 0.0, 0.0] # Normal right (90 deg to tri1) + ], dtype=np.float64) + so.mesh = np.array([tri1, tri2]) + + # At max_angle_deg=30, the 90 deg crease edge should be marked + lineart_30 = extract_lineart_edges(so, max_angle_deg=30.0) + self.assertTrue(len(lineart_30) > 0) + + # At max_angle_deg=100, crease edge (90 deg) is below threshold, but boundary edges remain + lineart_100 = extract_lineart_edges(so, max_angle_deg=100.0) + self.assertTrue(len(lineart_100) > 0) + def test_export_pdf_true_1_to_1_scale(self): - # Setup 100mm x 100mm 2D square edges_2d = np.array([ [[0.0, 0.0], [100.0, 0.0]], [[100.0, 0.0], [100.0, 100.0]], @@ -99,8 +128,6 @@ class TestPdfExporter(unittest.TestCase): ], dtype=np.float64) margin_mm = 10.0 - # Main grid step for 100mm is 10mm. Bounds: [0, 100], [0, 100]. - # Total width = 100 + 2*10 = 120mm. Expected pt = 120 * MM_TO_PT = 340.16 pt. with tempfile.TemporaryDirectory() as tmpdir: pdf_path = os.path.join(tmpdir, "test_true_scale.pdf") @@ -129,6 +156,34 @@ class TestPdfExporter(unittest.TestCase): self.assertIn(b"/GS100 gs", content) self.assertTrue(content.endswith(b"%%EOF\n")) + def test_export_pdf_visualization_styles(self): + so = SlicingObject() + tri = np.array([ + [0.0, 0.0, 0.0], + [100.0, 0.0, 0.0], + [0.0, 100.0, 0.0], + [0.0, 0.0, 1.0] + ], dtype=np.float64) + so.mesh = np.array([tri]) + + edges_2d = extract_unique_top_view_edges(so) + + for style in ['WIREFRAME', 'LINEART', 'OUTER_CONTOUR']: + with tempfile.TemporaryDirectory() as tmpdir: + pdf_path = os.path.join(tmpdir, f"test_{style}.pdf") + export_wireframe_to_pdf( + edges_2d, + pdf_path, + style=style, + crease_angle=30.0, + raw_geometry=so + ) + self.assertTrue(os.path.exists(pdf_path)) + with open(pdf_path, "rb") as f: + content = f.read() + self.assertTrue(content.startswith(b"%PDF-1.4")) + self.assertTrue(content.endswith(b"%%EOF\n")) + if __name__ == '__main__': unittest.main()