Skip to content

TechSoft3D

Home / External Tools & Partners / TechSoft3D

TechSoft3D develops SDKs for 3D data access, AI-based CAD analysis, and visualization. Their HOOPS product suite is embedded in 750+ commercial CAD/CAM/CAE applications worldwide — from Autodesk and Siemens to Xometry and Shapr3D. For Anvil, two products are directly relevant: HOOPS Exchange for CAD data ingestion and HOOPS AI for feature recognition.

References

Overview
Website techsoft3d.com
Type Commercial software vendor (ISV component supplier)
Domain CAD data exchange, AI for engineering data, 3D visualization
Headquarters Oregon, USA (engineering in Lyon, France)

Product Suite

  • HOOPS Exchange — Multi-format CAD data reader/writer (34+ formats) with access to B-Rep topology, PMI, and assembly structure. Includes PRC-based model sewing, comparison, and collision detection. The primary candidate for our Data Ingestion pipeline stage.
  • HOOPS AI — Python ML framework (PyTorch-based) for analyzing 3D CAD data. Converts B-Rep geometry into graph representations for feature recognition, part classification, and similarity search. Being evaluated alongside our academic model candidates.
  • HOOPS Visualize — Native and web-based 3D rendering engine. Also serves as the visualization backend within HOOPS AI's tooling.
  • Polygonica — Mesh processing library for STL/mesh cleanup, boolean operations, and mesh-to-CAD workflows. Particularly strong at geometry healing — a lightweight version is available specifically for healing as a backstop to Exchange's built-in repair.
  • Parasolid integration — Geometric kernel access via Siemens. Enables solid modeling operations (boolean, offset, filleting) on imported geometry. Only needed if we require solid modeling operations — Exchange's import, B-Rep access, and PMI extraction work without Parasolid.

Where HOOPS Fits in Our Pipeline

flowchart LR
    CAD["Customer CAD\n(STEP, IGES,\nSolidWorks, CATIA,\nNX, Creo, ...)"]
    DI["Data\nIngestion"]
    FR["Feature\nRecognition"]
    AC["AutoCAM"]
    SIM["Simulation"]
    EXEC["Execution"]

    CAD --> DI --> FR --> AC --> SIM --> EXEC

    HE["HOOPS\nExchange"]
    HAI["HOOPS AI"]

    HE -.->|"multi-format import\nB-Rep + PMI"| DI
    HAI -.->|"B-Rep → AAG\nfeature classification"| FR

    style HE fill:#4051b5,color:#fff
    style HAI fill:#4051b5,color:#fff

Data Ingestion (Stage 1) — HOOPS Exchange solves the multi-format import problem. Instead of building and maintaining individual importers for SolidWorks, CATIA, NX, Creo, and Inventor, Exchange provides a single SDK that reads 34+ formats and outputs unified B-Rep topology with PMI annotations. Every format maps to the same internal representation (PRC, an ISO standard), so downstream components see a consistent data model regardless of what the customer uploaded. This directly addresses the Data Ingestion component's core responsibilities: accept common B-Rep formats, convert to a standardized internal representation, and extract PMI.

Feature Recognition (Stage 2) — HOOPS AI provides a commercial path to feature recognition that complements our academic model candidates (BRepMFR, BRepFormer, AAGNet). Built on top of Exchange, it automatically converts B-Rep topology into face adjacency graphs (AAGs) with rich geometric features — the same graph representation our ML pipeline targets. The key advantage is that it handles the entire encoding pipeline (CAD file → graph-ready dataset) out of the box, for any format Exchange supports.

Partnership Model

  • ISV component supplier — TechSoft3D positions as a technology partner to software companies, not a competitor. They supply the SDK layer; we build the application logic and automation.
  • Data stays local — All data is managed on our infrastructure. TechSoft3D does not access or manage customer data.
  • Relevant customer examples — Xometry (on-demand manufacturing platform), Open Mind (hyperMILL CAM), Hexagon (metrology), High QA (inspection/quality), Shapr3D (cross-platform CAD).

HOOPS Exchange

HOOPS Exchange is a CAD data reading and writing SDK that provides format-independent access to B-Rep topology, PMI, assembly structure, and tessellation from 34+ CAD formats. It is the primary candidate for the Data Ingestion stage of our CAM pipeline.

References

Format Coverage

Exchange reads native CAD files directly — no source CAD system installation required.

Category Formats
Neutral standards STEP (AP203, AP214, AP242), IGES, JT, 3MF, STL, OBJ, VRML, glTF/GLB
Dassault Systèmes CATIA V4, CATIA V5/V6, SolidWorks (97–2026)
Siemens NX / Unigraphics, Solid Edge, Parasolid, JT
PTC Creo / Pro/ENGINEER (up to 12.4)
Autodesk Inventor, Revit, DWG/DXF
Other CAD Rhino (3DM), ACIS/SAT, VDA-FS, IFC
Visualization FBX, COLLADA, U3D, 3DS, USD

Export includes STEP, IGES, Parasolid, ACIS, JT, 3D PDF, glTF, STL, and more. Format readers are updated within 90 days of new CAD version releases.

Why this matters

Anvil currently accepts STEP and IGES. Exchange would immediately expand coverage to proprietary formats — SolidWorks, CATIA, NX, Creo, Inventor — without building individual importers for each. Customers upload their native files directly instead of exporting to STEP first, reducing friction and preserving data that can be lost in translation (PMI, feature history, assembly relationships).

Unified B-Rep Representation

All imported geometry converts to a single internal representation based on the PRC format (ISO 14739-1:2014). Regardless of whether the source file is a SolidWorks part or a CATIA assembly, the output data model is identical. This is the foundation for a format-independent pipeline.

Topology Hierarchy

Body
 └── Connex (connected region)
      └── Shell (collection of faces)
           └── Face (surface + boundary loops)
                └── Loop (closed boundary — outer or hole)
                     └── CoEdge (oriented edge within a loop)
                          └── Edge (shared geometric edge)
                               └── Vertex (point in 3D space)
  • Faces carry surface geometry: plane, cylinder, cone, sphere, torus, NURBS, extrusion, revolution, and offset surfaces.
  • Edges carry curve geometry: line, circle, ellipse, NURBS, composite curves, and intersection curves.
  • Loops define face boundaries — one outer loop and zero or more inner loops (holes).
  • CoEdges are directed edges that encode which face "owns" which side of a shared edge — critical for establishing adjacency relationships between faces.

Geometry Types

Surfaces Curves
Plane, Cylinder, Cone, Sphere, Torus Line, Circle, Ellipse
NURBS, Revolution, Ruled, Offset NURBS, Parametric, Composite, Intersection

Both exact geometry (NURBS) and tessellation are available. Tessellation quality is configurable (chord height tolerance, angle tolerance) for different use cases — coarser for visualization, finer for analysis.

Persistent Face and Edge IDs

Every topological entity in Exchange carries a persistent identifier via A3DRootBaseData:

  • String ID (m_pcPersistentId) — human-readable persistent identifier
  • Integer ID (m_uiPersistentId) — numeric persistent identifier

These IDs are stable across re-imports: if a customer uploads a revised version of a part, the same face receives the same identifier. Persistent IDs are supported for the major native formats: CATIA, Creo, NX, SolidWorks, Solid Edge, and Inventor. Neutral formats (STEP, IGES) have weaker or no persistent ID support.

Why persistent IDs matter for feature recognition

Persistent face IDs enable direct mapping between Exchange topology and the Attributed Adjacency Graph (AAG) used by feature recognition models. Each face becomes a node in the AAG, identified by its persistent ID. This means:

  • Feature labels from ML models can be traced back to specific B-Rep faces
  • Revised part versions preserve face-to-feature mappings
  • Training data annotations remain valid across file re-imports
  • The same ID scheme flows from Exchange through HOOPS AI into our downstream pipeline

PMI Extraction

Exchange provides two modes of access to Product Manufacturing Information:

Semantic PMI — Machine-parseable, structured data representing GD&T feature control frames, dimensional tolerances, datum references, surface finish callouts, and notes. Each annotation links to specific topological entities (faces, edges). This is what our pipeline needs for tolerance-aware CAM planning — the Data Ingestion component requires extraction of "GD&T, tolerances, surface finish callouts."

Visual PMI — Display-oriented graphical representation of annotations as they appeared in the source CAD system (leader lines, text placement, view associations). Useful for visualization and human review, but not directly actionable by automation.

Semantic PMI import is supported for CATIA V4/V5, Creo, NX, SolidWorks, and STEP AP242. Export is available to JT, PRC, and STEP AP242.

Additional Capabilities

  • Model sewing, comparison, and collision detection — PRC-level operations for joining open shells, comparing geometry versions, and detecting interferences.
  • Geometry healing and repair — Tolerance adjustment, gap closure, sliver face elimination, sewing of open shells into solids. Addresses the Data Ingestion requirement for geometry validation ("watertight solids, no degenerate faces"). For more stubborn geometry issues, Polygonica (a separate TechSoft3D product) offers stronger mesh-level healing as a backstop.
  • Assembly structure — Full access to product occurrence trees, component transforms, and instance/prototype relationships. Relevant for future multi-part job support.
  • 3D PDF publishing — Built-in 3D PDF generation (formerly the separate HOOPS Publish product). Potential use for customer-facing inspection reports and work instructions.
  • Cross-section and point projection — Geometry analysis operations without requiring a separate solid modeling kernel.
  • C++ and C# APIs — No CAD system installation required on the server.

Limitations

  • No mesh-to-B-Rep conversion — Exchange cannot convert mesh/STL data back to parametrized B-Rep surfaces. If a customer provides only mesh data, it stays as mesh.
  • No implicit representation support — Exchange works with mesh, B-Rep, and PMI. Implicit/functional representations (signed distance fields, etc.) are not supported.
  • Parasolid is separate — Solid modeling operations (booleans, offset, filleting) require the Parasolid add-on. Exchange alone handles import, B-Rep access, PMI extraction, healing, and model operations listed above.

Relevance to Our Pipeline

Our Need Exchange Capability
Multi-format CAD import 34+ native format readers, no CAD install
Standardized internal representation PRC-based unified B-Rep (ISO 14739-1)
Face IDs for AAG construction Persistent topological identifiers
PMI for tolerance-aware CAM Semantic PMI extraction (GD&T, tolerances, finishes)
Geometry validation Healing, repair, sewing to watertight solids
Proprietary format expansion SolidWorks, CATIA, NX, Creo, Inventor — native
Future: inspection reports 3D PDF publishing

HOOPS AI

HOOPS AI is a Python ML framework built on PyTorch, purpose-built for analyzing 3D CAD data. It sits on top of HOOPS Exchange for CAD file access and provides tools for converting B-Rep geometry into graph representations suitable for machine learning — specifically, the Attributed Adjacency Graph (AAG) representation used by models like AAGNet, BRepMFR, and BRepFormer. It is being evaluated as a commercial complement to academic feature recognition models in our Feature Recognition pipeline.

References

Architecture

flowchart LR
    CAD["CAD File\n(any of 34+ formats)"]
    EX["HOOPS Exchange\n(import + B-Rep access)"]
    ENC["BrepEncoder\n(B-Rep → Graph)"]
    ML["ML Model\n(Graph Transformer,\nGCN, BrepMFR, ...)"]
    OUT["Feature Labels\n(per-face\nclassification)"]

    CAD --> EX --> ENC --> ML --> OUT

HOOPS AI does not replace Exchange — it depends on it. Exchange handles file I/O and provides the B-Rep data model; AI handles the ML-specific encoding (B-Rep to graph conversion) and model training/inference. Together they create a complete pipeline from any CAD file format to per-face feature predictions.

HOOPS AI has two main components:

  1. Data preparation — The BrepEncoder and dataset management tools that convert B-Rep geometry into graph-encoded datasets (stored locally on your infrastructure — TechSoft3D does not access or manage the data).
  2. ML models — Pre-built and customizable model architectures for feature recognition, part classification, and similarity search.

B-Rep to Graph Encoding

The BrepEncoder is the core technical component. It converts Exchange's B-Rep topology into a graph representation ready for graph neural networks — effectively automating the construction of the Attributed Adjacency Graph (AAG).

Graph Structure

  • Nodes = B-Rep faces. Each face in the part becomes a node in the graph.
  • Edges = shared B-Rep edges. Two faces that share a topological edge become connected in the graph. This produces the face adjacency graph — the AAG.

Node Features (per face)

Feature Description Dimensions
Surface type Plane, cylinder, cone, sphere, torus, NURBS, extrusion, revolution Categorical
Area Face area via surface integration 1
Loop count Number of boundary loops (outer + holes) 1
Neighbor count Number of adjacent faces 1
Face discretization 25 uniformly sampled points on the face surface 25 × 7 (xyz + normal + visibility)
D2 histogram Distance distribution between point pairs across faces 64 bins
A3 histogram Normal angle distribution across face pairs 64 bins

Edge Features (per shared edge)

Feature Description Dimensions
Curve type Line, circle, ellipse, NURBS Categorical
Arc length Integrated edge length 1
Dihedral angle Angle between adjacent face normals 1
Convexity Convex (+1), concave (−1), or smooth/tangent (0) Categorical
UV-grid sampling Curve samples in parametric space 10 × 6

Extended Adjacency

Beyond direct face adjacency, HOOPS AI computes extended adjacency using Floyd-Warshall shortest-path distances between all face pairs. This captures relationships between non-adjacent faces — for example, two pocket walls separated by a floor face. Edge path sequences along shortest paths are padded to a maximum of 16 edges.

Connection to our ML work

The AAG representation that HOOPS AI constructs is the same graph structure used by AAGNet and the other academic models we're evaluating (BRepMFR, BRepFormer). The difference is that HOOPS AI handles the full encoding pipeline automatically from any CAD format (via Exchange), whereas academic implementations typically require custom preprocessing scripts tied to specific input formats (usually STEP only). Using HOOPS AI's BrepEncoder — even with our own classification models — could significantly reduce the data preprocessing burden.

Feature Classes

HOOPS AI's feature recognition models identify 25 machining feature classes through per-face classification — each face in the B-Rep receives an individual prediction with confidence scores.

Category Feature Types
Holes Through hole, blind hole, countersink, counterbore
Pockets Rectangular pocket, circular pocket, irregular pocket
Slots Through slot, blind slot
Chamfers Edge chamfer, face chamfer
Fillets Edge fillet, face fillet
Protrusions Boss, rib, step
Surfaces Planar face, cylindrical face, conical face, spherical face, toroidal face
Other Groove, passage

These classes align well with our feature recognition targets: "holes, pockets, faces, fillets, threads, slots, chamfers." Notably, thread features are not in the standard HOOPS AI taxonomy and would require custom model training.

Model Architectures

HOOPS AI provides multiple neural network architectures through its framework:

Architecture Type Notes
Graph Transformer Transformer + GNN Primary recommended architecture. 256-dim embeddings, 32 attention heads, 8 layers.
BrepMFR Transformer + GNN Same architecture as our academic candidate — enables direct comparison. Includes domain adaptation for cross-dataset transfer.
GCN Graph Convolution Classic graph learning with mean pooling aggregation.
GAT Graph Attention Learned attention weights over neighborhoods.
UV-Net CNN + GNN 2D convolutions on UV-parameterized surface grids combined with graph topology.
PointNet++ Point cloud Geometry sampling approach — operates on point clouds rather than B-Rep topology.

TechSoft3D also has a proprietary model (likely based on BrepMFR) that may offer improved performance over the open-source implementations.

The inclusion of BrepMFR is particularly relevant: we can benchmark HOOPS AI's implementation against the academic version we're independently evaluating, using the same architecture on the same test data, to assess whether the HOOPS AI encoding pipeline produces better or worse results than our custom preprocessing.

Flow Framework

HOOPS AI includes an experiment management framework ("Flow") for production ML workflows:

  • Dataset management — Batch preprocessing of CAD files into graph-encoded datasets. Compatible with CADSynth-AAG (162K synthetic models) and custom datasets. You need to bring your own data for real training and inference — TechSoft3D provides tutorial data and basic examples for getting started.
  • Flow manager — Configure different settings and parameters for different workflows and experiments.
  • Training orchestration — PyTorch Lightning integration for GPU/CPU management, logging, checkpointing, and learning rate scheduling. Primarily PyTorch-based — limited compatibility with other ML frameworks.
  • Experiment tracking — Versioning, lineage, and reproducibility for training runs. Metrics tracking (loss, per-node accuracy).
  • Batch inference — ParallelExecutor for dataset-scale predictions on new CAD files.
  • Visualization — Built-in CAD viewer (based on HOOPS Visualize) for inspecting per-face predictions on 3D models.
  • Notebooks — Easy to get started with Jupyter notebooks; tutorials and basic test data available on GitHub.

Relevance to Our Pipeline

Our Need HOOPS AI Capability
Feature recognition from B-Rep 25 machining feature classes, per-face classification with confidence scores
AAG construction from CAD files BrepEncoder: automatic B-Rep → face adjacency graph with rich features
Model evaluation and comparison Multiple architectures including BrepMFR (our academic candidate)
Training data pipeline Flow framework, CADSynth-AAG compatibility, batch encoding
Format-agnostic preprocessing Built on Exchange — any of 34+ CAD formats in, AAG out
Extended graph features Floyd-Warshall extended adjacency, D2/A3 shape descriptors

Roadmap

TechSoft3D maintains a public roadmap for HOOPS AI. Notable planned features:

  • Linux support — Currently requires specific platform setup; native Linux support is planned.
  • PMI support in AI — Currently only B-Rep data is used for encoding; PMI annotations (GD&T, tolerances) are planned as additional model inputs.
  • Unsupervised learning — Planned support for models that don't require labeled training data (clustering, anomaly detection).
  • Feature requests — TechSoft3D accepts feature requests from partners.

Training Data Requirements

Based on TechSoft3D's experience with customers:

  • ~5K example files may be sufficient for initial experimentation with synthetic or simulation data
  • 10–20K real-world examples are typically needed for production-quality feature recognition on real parts
  • TechSoft3D provides basic tutorial datasets for getting started, but production training requires bringing your own annotated data

Open Evaluation Questions

  • How does HOOPS AI accuracy compare to our own BRepMFR and BRepFormer implementations on the geometry classes we care about most (prismatic aluminum parts for 3-axis and 5-axis milling)?
  • Can we use HOOPS AI's BrepEncoder for graph construction while running our own models for classification? This would give us the encoding pipeline without locking into their model architectures.
  • How well does the 25-class taxonomy cover our specific machining needs? Thread features are absent from the standard set — custom feature classes are supported but require custom training data.
  • What is the minimum viable training dataset size for fine-tuning on our target geometry class, given the 10–20K guidance for general feature recognition?