""" NXOpen script — Extract sandbox face geometry for Adaptive Isogrid. Runs from the .sim file context. Navigates: SIM → FEM → Idealized Part → find bodies with ISOGRID_SANDBOX attribute For each sandbox body, exports `geometry_.json` containing: - outer_boundary: 2D polyline of the sandbox outline - inner_boundaries: 2D polylines of cutouts (reserved cylinder intersections, etc.) - transform: 3D <-> 2D mapping for reimporting geometry - thickness: from NX midsurface (if available) Inner loops are treated as boundary constraints (edges), NOT as holes to rib around, because hole reservations are handled by separate solid cylinders in the fixed geometry. Usage (NX Journal — just run it, no args needed): File > Execute > NX Journal > extract_sandbox.py Author: Atomizer / Adaptive Isogrid Created: 2026-02-16 """ from __future__ import annotations import json import math import os import sys from dataclasses import dataclass from pathlib import Path from typing import Any, Dict, List, Sequence, Tuple # --------------------------------------------------------------------------- # Geometry helpers (pure math, no NX dependency) # --------------------------------------------------------------------------- Point3D = Tuple[float, float, float] Point2D = Tuple[float, float] @dataclass class LocalFrame: origin: Point3D x_axis: Point3D y_axis: Point3D normal: Point3D def _norm(v: Sequence[float]) -> float: return math.sqrt(sum(c * c for c in v)) def _normalize(v: Sequence[float]) -> Tuple[float, float, float]: n = _norm(v) if n < 1e-12: return (0.0, 0.0, 1.0) return (v[0] / n, v[1] / n, v[2] / n) def _dot(a: Sequence[float], b: Sequence[float]) -> float: return a[0] * b[0] + a[1] * b[1] + a[2] * b[2] def _cross(a: Sequence[float], b: Sequence[float]) -> Tuple[float, float, float]: return ( a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0], ) def _sub(a: Sequence[float], b: Sequence[float]) -> Tuple[float, float, float]: return (a[0] - b[0], a[1] - b[1], a[2] - b[2]) def project_to_2d(points3d: Sequence[Point3D], frame: LocalFrame) -> List[Point2D]: out: List[Point2D] = [] for p in points3d: v = _sub(p, frame.origin) out.append((_dot(v, frame.x_axis), _dot(v, frame.y_axis))) return out def unproject_to_3d(points2d: Sequence[Point2D], frame: LocalFrame) -> List[Point3D]: """Inverse of project_to_2d — reconstruct 3D from local 2D coords.""" out: List[Point3D] = [] for x, y in points2d: px = frame.origin[0] + x * frame.x_axis[0] + y * frame.y_axis[0] py = frame.origin[1] + x * frame.x_axis[1] + y * frame.y_axis[1] pz = frame.origin[2] + x * frame.x_axis[2] + y * frame.y_axis[2] out.append((px, py, pz)) return out # --------------------------------------------------------------------------- # NX edge sampling # --------------------------------------------------------------------------- def _sample_edge_polyline(edge: Any, chord_tol_mm: float) -> List[Point3D]: """ Sample an NX edge as a polyline with adaptive point density. Falls back to vertex extraction if evaluator is unavailable. """ # Preferred: parametric evaluator try: evaluator = edge.CreateEvaluator() t0, t1 = evaluator.GetLimits() length = edge.GetLength() n = max(2, int(length / max(chord_tol_mm, 1e-3))) pts: List[Point3D] = [] for i in range(n + 1): t = t0 + (t1 - t0) * (i / n) p, _ = evaluator.Evaluate(t) pts.append((float(p.X), float(p.Y), float(p.Z))) return pts except Exception: pass # Fallback: edge vertices only try: verts = edge.GetVertices() return [(float(v.Coordinates.X), float(v.Coordinates.Y), float(v.Coordinates.Z)) for v in verts] except Exception as exc: raise RuntimeError(f"Could not sample edge polyline: {exc}") def _close_polyline(points: List[Point3D]) -> List[Point3D]: if not points: return points if _norm(_sub(points[0], points[-1])) > 1e-6: points.append(points[0]) return points # --------------------------------------------------------------------------- # Face local frame # --------------------------------------------------------------------------- def _face_local_frame(face: Any) -> LocalFrame: """ Build a stable local frame on a planar face. """ loops = face.GetLoops() first_edge = loops[0].GetEdges()[0] sample = _sample_edge_polyline(first_edge, chord_tol_mm=1.0)[0] # Get face normal normal = (0.0, 0.0, 1.0) try: import NXOpen pt = NXOpen.Point3d(sample[0], sample[1], sample[2]) n = face.GetFaceNormal(pt) normal = _normalize((float(n.X), float(n.Y), float(n.Z))) except Exception: try: n = face.GetFaceNormal(sample[0], sample[1], sample[2]) normal = _normalize((float(n.X), float(n.Y), float(n.Z))) except Exception: pass # Build orthonormal basis ref = (1.0, 0.0, 0.0) if abs(normal[0]) < 0.95 else (0.0, 1.0, 0.0) x_axis = _normalize(_cross(ref, normal)) y_axis = _normalize(_cross(normal, x_axis)) return LocalFrame(origin=sample, x_axis=x_axis, y_axis=y_axis, normal=normal) # --------------------------------------------------------------------------- # Attribute reading # --------------------------------------------------------------------------- def _get_string_attribute(obj: Any, title: str) -> str | None: """Try multiple NX API patterns to read a string attribute.""" for method_name in ("GetStringUserAttribute", "GetUserAttributeAsString"): try: method = getattr(obj, method_name) val = method(title, -1) if val: return str(val) except Exception: continue return None # --------------------------------------------------------------------------- # SIM -> Idealized Part navigation # --------------------------------------------------------------------------- def _navigate_sim_to_idealized(session: Any) -> Any: """ From the active .sim work part, navigate to the idealized part (_i.prt). Sets idealized part as work part and returns it. """ work_part = session.Parts.Work part_name = work_part.Name if hasattr(work_part, "Name") else "" lister = session.ListingWindow lister.Open() lister.WriteLine(f"[extract_sandbox] Starting from: {part_name}") # Check if already in idealized part if part_name.endswith("_i"): lister.WriteLine("[extract_sandbox] Already in idealized part.") return work_part # Search loaded parts for the idealized part idealized_part = None for part in session.Parts: pname = part.Name if hasattr(part, "Name") else "" if pname.endswith("_i"): idealized_part = part lister.WriteLine(f"[extract_sandbox] Found idealized part: {pname}") break if idealized_part is None: raise RuntimeError( "Could not find idealized part (*_i.prt). " "Ensure the SIM is open with FEM + idealized part loaded." ) # Set as work part try: session.Parts.SetWork(idealized_part) lister.WriteLine(f"[extract_sandbox] Set work part to: {idealized_part.Name}") except Exception as exc: lister.WriteLine(f"[extract_sandbox] Warning: SetWork failed: {exc}") return idealized_part # --------------------------------------------------------------------------- # Sandbox discovery # --------------------------------------------------------------------------- def find_sandbox_bodies( part: Any, lister: Any, attr_name: str = "ISOGRID_SANDBOX", ) -> List[Tuple[str, Any, Any]]: """ Find bodies tagged with ISOGRID_SANDBOX attribute. Search order: 1. Body-level attributes (part.Bodies) 2. Face-level attributes 3. Feature-level attributes (part history — Promote Body features) 4. Feature name matching (e.g. 'Sandbox_1' in feature name) 5. Body name matching Returns list of (sandbox_id, body, face) tuples. """ tagged: List[Tuple[str, Any, Any]] = [] found_ids: set = set() bodies = [] try: bodies = list(part.Bodies.ToArray()) if hasattr(part.Bodies, "ToArray") else list(part.Bodies) except Exception: bodies = list(part.Bodies) lister.WriteLine(f"[extract_sandbox] Scanning {len(bodies)} bodies...") # --- Pass 1: body-level and face-level attributes --- for body in bodies: body_name = "" try: body_name = body.Name if hasattr(body, "Name") else str(body) except Exception: pass sandbox_id = _get_string_attribute(body, attr_name) if sandbox_id and sandbox_id not in found_ids: faces = body.GetFaces() if faces: tagged.append((sandbox_id, body, faces[0])) found_ids.add(sandbox_id) lister.WriteLine(f"[extract_sandbox] Found: {sandbox_id} (body attr on '{body_name}')") continue for face in body.GetFaces(): sandbox_id = _get_string_attribute(face, attr_name) if sandbox_id and sandbox_id not in found_ids: tagged.append((sandbox_id, body, face)) found_ids.add(sandbox_id) lister.WriteLine(f"[extract_sandbox] Found: {sandbox_id} (face attr on '{body_name}')") if tagged: return tagged # --- Pass 2: feature-level attributes (Promote Body features) --- lister.WriteLine("[extract_sandbox] No body/face attrs found, scanning features...") try: features = part.Features.ToArray() if hasattr(part.Features, "ToArray") else list(part.Features) lister.WriteLine(f"[extract_sandbox] Found {len(features)} features") for feat in features: feat_name = "" try: feat_name = feat.Name if hasattr(feat, "Name") else str(feat) except Exception: pass # Check feature attribute sandbox_id = _get_string_attribute(feat, attr_name) if sandbox_id and sandbox_id not in found_ids: # Get the body produced by this feature try: feat_bodies = feat.GetBodies() if feat_bodies: body = feat_bodies[0] faces = body.GetFaces() if faces: tagged.append((sandbox_id, body, faces[0])) found_ids.add(sandbox_id) lister.WriteLine(f"[extract_sandbox] Found: {sandbox_id} (feature attr on '{feat_name}')") except Exception as exc: lister.WriteLine(f"[extract_sandbox] Feature '{feat_name}' has attr but GetBodies failed: {exc}") except Exception as exc: lister.WriteLine(f"[extract_sandbox] Feature scan error: {exc}") if tagged: return tagged # --- Pass 3: feature name matching (e.g. "Sandbox_1" in name) --- lister.WriteLine("[extract_sandbox] No feature attrs found, trying feature name matching...") try: features = part.Features.ToArray() if hasattr(part.Features, "ToArray") else list(part.Features) for feat in features: feat_name = "" try: feat_name = feat.Name if hasattr(feat, "Name") else str(feat) except Exception: continue if "sandbox" in feat_name.lower(): try: feat_bodies = feat.GetBodies() if feat_bodies: body = feat_bodies[0] faces = body.GetFaces() if faces: sid = feat_name.lower().replace(" ", "_") if sid not in found_ids: tagged.append((sid, body, faces[0])) found_ids.add(sid) lister.WriteLine(f"[extract_sandbox] Found by feature name: {sid} ('{feat_name}')") except Exception as exc: lister.WriteLine(f"[extract_sandbox] Feature '{feat_name}' name match but GetBodies failed: {exc}") except Exception: pass if tagged: return tagged # --- Pass 4: body name matching --- lister.WriteLine("[extract_sandbox] No features matched, trying body name matching...") for body in bodies: bname = "" try: bname = body.Name if hasattr(body, "Name") else str(body) except Exception: continue if "sandbox" in bname.lower(): faces = body.GetFaces() if faces: sid = bname.lower().replace(" ", "_") if sid not in found_ids: tagged.append((sid, body, faces[0])) found_ids.add(sid) lister.WriteLine(f"[extract_sandbox] Found by body name: {sid}") return tagged # --------------------------------------------------------------------------- # Core extraction # --------------------------------------------------------------------------- def extract_sandbox_geometry( face: Any, body: Any, sandbox_id: str, lister: Any, chord_tol_mm: float = 0.1, ) -> Dict[str, Any]: """ Extract a sandbox face into a JSON-serializable dict. Inner loops are boundary constraints (reserved geometry edges), not holes. """ frame = _face_local_frame(face) outer_2d: List[List[float]] = [] inner_boundaries: List[Dict[str, Any]] = [] loops = face.GetLoops() lister.WriteLine(f"[extract_sandbox] {sandbox_id}: {len(loops)} loop(s)") for loop_index, loop in enumerate(loops): loop_pts3d: List[Point3D] = [] edges = loop.GetEdges() for edge in edges: pts = _sample_edge_polyline(edge, chord_tol_mm) if loop_pts3d and pts: pts = pts[1:] loop_pts3d.extend(pts) loop_pts3d = _close_polyline(loop_pts3d) loop_pts2d = project_to_2d(loop_pts3d, frame) # Determine outer vs inner is_outer = False try: is_outer = loop.IsOuter() except Exception: is_outer = (loop_index == 0) if is_outer: outer_2d = [[round(x, 6), round(y, 6)] for x, y in loop_pts2d] lister.WriteLine(f"[extract_sandbox] outer loop: {len(outer_2d)} pts") else: boundary = [[round(x, 6), round(y, 6)] for x, y in loop_pts2d] inner_boundaries.append({ "index": len(inner_boundaries), "boundary": boundary, "num_points": len(boundary), }) lister.WriteLine(f"[extract_sandbox] inner loop {len(inner_boundaries)}: {len(boundary)} pts") # Try thickness thickness = None try: thickness = float(body.GetThickness()) except Exception: pass return { "schema_version": "1.0", "units": "mm", "sandbox_id": sandbox_id, "outer_boundary": outer_2d, "inner_boundaries": inner_boundaries, "num_inner_boundaries": len(inner_boundaries), "thickness": thickness, "transform": { "origin": [round(c, 6) for c in frame.origin], "x_axis": [round(c, 6) for c in frame.x_axis], "y_axis": [round(c, 6) for c in frame.y_axis], "normal": [round(c, 6) for c in frame.normal], }, } # --------------------------------------------------------------------------- # Main — NX Journal entry point # --------------------------------------------------------------------------- def main(): import NXOpen session = NXOpen.Session.GetSession() lister = session.ListingWindow lister.Open() lister.WriteLine("=" * 60) lister.WriteLine(" Adaptive Isogrid — Sandbox Geometry Extraction") lister.WriteLine("=" * 60) # Navigate to idealized part idealized_part = _navigate_sim_to_idealized(session) # Find sandboxes sandbox_entries = find_sandbox_bodies(idealized_part, lister) if not sandbox_entries: lister.WriteLine("[extract_sandbox] ERROR: No sandbox bodies found!") lister.WriteLine("Ensure bodies have ISOGRID_SANDBOX attribute set.") return lister.WriteLine(f"[extract_sandbox] Found {len(sandbox_entries)} sandbox(es)") # Output directory: next to the .sim file (or idealized part) try: part_dir = os.path.dirname(idealized_part.FullPath) except Exception: part_dir = os.getcwd() output_dir = os.path.join(part_dir, "adaptive_isogrid_data") os.makedirs(output_dir, exist_ok=True) lister.WriteLine(f"[extract_sandbox] Output dir: {output_dir}") # Extract each sandbox for sandbox_id, body, face in sandbox_entries: lister.WriteLine(f"\n--- Extracting {sandbox_id} ---") geom = extract_sandbox_geometry( face=face, body=body, sandbox_id=sandbox_id, lister=lister, chord_tol_mm=0.1, ) out_path = os.path.join(output_dir, f"geometry_{sandbox_id}.json") with open(out_path, "w") as f: json.dump(geom, f, indent=2) lister.WriteLine(f"[extract_sandbox] Wrote: {out_path}") # Summary lister.WriteLine(f" outer_boundary: {len(geom['outer_boundary'])} points") lister.WriteLine(f" inner_boundaries: {geom['num_inner_boundaries']}") lister.WriteLine(f" thickness: {geom['thickness']}") lister.WriteLine("\n" + "=" * 60) lister.WriteLine(f" Done — {len(sandbox_entries)} sandbox(es) exported") lister.WriteLine(f" Output: {output_dir}") lister.WriteLine("=" * 60) main()