Antoine/Atomizer
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
9534ba9ed92f879bd58d88009ea0f3af3fc8f56a
Atomizer/tools/adaptive-isogrid/src/nx/extract_sandbox.py

745 lines
26 KiB
Python
Raw Blame History

"""
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, lister: Any = None) -> List[Point3D]:
"""
Sample an NX edge as a polyline.
Uses Edge.GetVertices() which returns (start_point, end_point).
For curved edges (arcs), we subdivide using the edge length and
IBaseCurve evaluation if available.
NXOpen Python API on Edge:
- GetVertices() -> Tuple[Point3d, Point3d] (start, end)
- GetLength() -> float (inherited from IBaseCurve)
- SolidEdgeType -> Edge.EdgeType
"""
# Get start and end vertices
try:
v1, v2 = edge.GetVertices()
p1 = (float(v1.X), float(v1.Y), float(v1.Z))
p2 = (float(v2.X), float(v2.Y), float(v2.Z))
except Exception as exc:
raise RuntimeError(f"Edge.GetVertices() failed: {exc}")
# Check edge type
is_linear = False
is_circular = False
is_closed = (_norm(_sub(p1, p2)) < 0.001) # closed edge = start == end
try:
edge_type_str = str(edge.SolidEdgeType)
is_linear = "Linear" in edge_type_str
is_circular = "Circular" in edge_type_str
except Exception:
pass
if lister and (is_closed or is_circular):
lister.WriteLine(f"[edge] type={edge_type_str if 'edge_type_str' in dir() else '?'} closed={is_closed} circ={is_circular} p1={p1}")
if is_linear and not is_closed:
return [p1, p2]
# For curved/closed edges: try UF_EVAL for parametric evaluation
try:
import NXOpen
session = NXOpen.Session.GetSession()
uf = session.GetUFSession()
edge_tag = edge.Tag
# Get edge length for point density
try:
length = edge.GetLength()
except Exception:
length = _norm(_sub(p2, p1)) if not is_closed else 50.0 # estimate
n_pts = max(8, int(length / max(chord_tol_mm, 0.1)))
if is_closed:
n_pts = max(24, n_pts) # circles need enough points
# UF_EVAL approach
evaluator = uf.Eval.Initialize2(edge_tag)
limits = uf.Eval.AskLimits(evaluator)
t0 = limits[0]
t1 = limits[1]
pts: List[Point3D] = []
for i in range(n_pts + 1):
t = t0 + (t1 - t0) * (i / n_pts)
# UF_EVAL_evaluate returns (point[3], derivatives[3], ...)
# The output format depends on the derivative order requested
result = uf.Eval.Evaluate(evaluator, 0, t)
# Try different result formats
if isinstance(result, (list, tuple)):
if len(result) >= 3:
pts.append((float(result[0]), float(result[1]), float(result[2])))
elif len(result) == 1 and hasattr(result[0], '__len__'):
r = result[0]
pts.append((float(r[0]), float(r[1]), float(r[2])))
elif hasattr(result, 'X'):
pts.append((float(result.X), float(result.Y), float(result.Z)))
uf.Eval.Free(evaluator)
if len(pts) >= 2:
return pts
except Exception:
pass
# Fallback for circular closed edges: try to get arc data from UF
if is_circular and is_closed:
try:
import NXOpen
session = NXOpen.Session.GetSession()
uf = session.GetUFSession()
# UF_CURVE_ask_arc_data returns (arc_center, radius, angles...)
arc_data = uf.Curve.AskArcData(edge.Tag)
# arc_data typically: (matrix_tag, start_angle, end_angle, center[3], radius)
# or it could be structured differently
# Generate circle points manually if we can extract center + radius
except Exception:
pass
# Fallback for closed edges: generate a small circle around the vertex
# This is wrong geometrically but at least provides a visual marker
if is_closed:
try:
length = edge.GetLength()
radius = length / (2.0 * math.pi)
# Generate circle in XY plane around vertex
# (will be projected to 2D later, so orientation matters)
pts = []
n = 24
for i in range(n + 1):
angle = 2.0 * math.pi * i / n
px = p1[0] + radius * math.cos(angle)
py = p1[1] + radius * math.sin(angle)
pz = p1[2]
pts.append((px, py, pz))
return pts
except Exception:
pass
# Last resort: vertices only
return [p1, p2]
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 _chain_edges_into_loops(
edges: List[Any],
lister: Any = None,
tol: float = 0.01,
) -> List[Tuple[bool, List[Point3D]]]:
"""
Chain edges into closed loops by matching vertex endpoints.
Returns list of (is_outer, points_3d) tuples.
The largest loop (by area/perimeter) is assumed to be the outer loop.
"""
def _log(msg):
if lister:
lister.WriteLine(msg)
if not edges:
return []
# Build edge segments as (start_pt, end_pt, edge_ref)
segments = []
for edge in edges:
try:
v1, v2 = edge.GetVertices()
p1 = (float(v1.X), float(v1.Y), float(v1.Z))
p2 = (float(v2.X), float(v2.Y), float(v2.Z))
segments.append((p1, p2, edge))
except Exception as exc:
_log(f"[chain] Edge.GetVertices failed: {exc}")
continue
_log(f"[chain] {len(segments)} edge segments to chain")
# Chain into loops
used = [False] * len(segments)
loops_points: List[List[Point3D]] = []
loops_edges: List[List[Any]] = []
def pts_match(a: Point3D, b: Point3D) -> bool:
return _norm(_sub(a, b)) < tol
while True:
# Find first unused segment
start_idx = None
for i, u in enumerate(used):
if not u:
start_idx = i
break
if start_idx is None:
break
# Start a new loop
chain_pts: List[Point3D] = []
chain_edges: List[Any] = []
used[start_idx] = True
p_start, p_end, edge = segments[start_idx]
# Sample this edge
edge_pts = _sample_edge_polyline(edge, chord_tol_mm=0.5, lister=lister)
chain_pts.extend(edge_pts)
chain_edges.append(edge)
current_end = p_end
loop_start = p_start
# Follow the chain
max_iters = len(segments) + 1
for _ in range(max_iters):
if pts_match(current_end, loop_start) and len(chain_edges) > 1:
# Loop closed
break
# Find next segment connecting to current_end
found = False
for i, (s1, s2, e) in enumerate(segments):
if used[i]:
continue
if pts_match(current_end, s1):
used[i] = True
edge_pts = _sample_edge_polyline(e, chord_tol_mm=0.5, lister=lister)
chain_pts.extend(edge_pts[1:]) # skip duplicate junction point
chain_edges.append(e)
current_end = s2
found = True
break
elif pts_match(current_end, s2):
# Edge is reversed — traverse backward
used[i] = True
edge_pts = _sample_edge_polyline(e, chord_tol_mm=0.5, lister=lister)
edge_pts.reverse()
chain_pts.extend(edge_pts[1:])
chain_edges.append(e)
current_end = s1
found = True
break
if not found:
_log(f"[chain] Warning: could not continue chain at {current_end}")
break
loops_points.append(chain_pts)
loops_edges.append(chain_edges)
_log(f"[chain] Built {len(loops_points)} loop(s)")
if not loops_points:
return []
# Determine which loop is outer (largest perimeter)
def _perimeter(pts: List[Point3D]) -> float:
total = 0.0
for i in range(len(pts) - 1):
total += _norm(_sub(pts[i + 1], pts[i]))
return total
perimeters = [_perimeter(pts) for pts in loops_points]
outer_idx = perimeters.index(max(perimeters))
result: List[Tuple[bool, List[Point3D]]] = []
for i, pts in enumerate(loops_points):
is_outer = (i == outer_idx)
result.append((is_outer, pts))
_log(f"[chain] loop {i}: {len(pts)} pts, perimeter={perimeters[i]:.1f} mm {'(OUTER)' if is_outer else '(inner)'}")
return result
def _face_local_frame(face: Any, lister: Any = None) -> LocalFrame:
"""
Build a stable local frame on a planar face.
"""
# Get a sample point from the first edge vertex
edges = face.GetEdges()
first_edge = edges[0]
v1, v2 = first_edge.GetVertices()
sample = (float(v1.X), float(v1.Y), float(v1.Z))
# 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, lister)
outer_2d: List[List[float]] = []
inner_boundaries: List[Dict[str, Any]] = []
# Get all edges on the face and chain them into loops
all_edges = list(face.GetEdges())
lister.WriteLine(f"[extract_sandbox] {sandbox_id}: {len(all_edges)} edges on face")
loops = _chain_edges_into_loops(all_edges, lister)
lister.WriteLine(f"[extract_sandbox] {sandbox_id}: {len(loops)} loop(s) built")
for loop_index, (is_outer, loop_pts3d) in enumerate(loops):
loop_pts3d = _close_polyline(loop_pts3d)
loop_pts2d = project_to_2d(loop_pts3d, frame)
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} ---")
try:
# Debug: print face info
lister.WriteLine(f"[extract_sandbox] Face type: {type(face).__name__}")
try:
all_edges = face.GetEdges()
lister.WriteLine(f"[extract_sandbox] Total edges on face: {len(all_edges)}")
except Exception as exc:
lister.WriteLine(f"[extract_sandbox] GetEdges failed: {exc}")
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']}")
except Exception as exc:
import traceback
lister.WriteLine(f"[extract_sandbox] ERROR extracting {sandbox_id}: {exc}")
lister.WriteLine(traceback.format_exc())
lister.WriteLine("\n" + "=" * 60)
lister.WriteLine(f" Done — {len(sandbox_entries)} sandbox(es) exported")
lister.WriteLine(f" Output: {output_dir}")
lister.WriteLine("=" * 60)
main()
Reference in New Issue View Git Blame Copy Permalink