518 lines
18 KiB
Python
518 lines
18 KiB
Python
"""
|
|
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_<sandbox_id>.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()
|