CAD Data Access

Overview 

The CAD Access module (hoops_ai.cadaccess) is the entry point for working with CAD files in HOOPS AI. It provides a unified interface for loading CAD files and extracting geometric and topological data using the HOOPS Exchange CAD kernel from Tech Soft 3D.

What Problem Does It Solve?

CAD data comes in many formats (STEP, IGES, CATIA, SolidWorks, Parasolid, NX, Inventor, Creo, JT, 3D PDF, and 30+ others). Each format has different internal structures and requires specialized parsing logic. Without an abstraction layer, you would need to:

Write different parsing code for each CAD format

Learn the complex HOOPS Exchange API directly

Scatter CAD-specific code throughout your ML pipeline

Rewrite code when HOOPS Exchange API changes

How CAD Access Solves This:

The module defines abstract interfaces (Python ABC classes) that provide a clean, ML-friendly API. Your pipeline code works with these simple implementations: HOOPSBrep - HOOPSLoader - HOOPSTools - HOOPSModel while HOOPS Exchange handles the complex kernel operations behind the scenes.

Key Benefits:

Format Agnostic: Load STEP, IGES, CATIA V5, SolidWorks, etc. with the same code (HOOPS Exchange supports 100+ formats)

Simple API: Query faces, edges, topology without learning HOOPS Exchange internals

Consistent Interface: Same methods work for all CAD file formats

Testability: Mock implementations for unit testing without loading CAD files

Maintainability: Interface shields your code from HOOPS Exchange API changes

Architecture and Design

Understanding the Component Hierarchy

The CAD Access module follows a flow-based architecture :

        CAD Files
            ↓
        HOOPSLoader
            ↓ creates
        HOOPSModel
            ↓ provides access to
      ┌──────────┬──────────┐
      │          │          │
  HOOPSBrep   HOOPSMesh     │
      │          │          │
      └──────────┘          │
            |               │
        storage             │
                            │
                            │
HOOPSTools ←────────────────┘
(utilities for)

┌─────────────────────────────────────────────┐
│  Your ML Pipeline Code                      │
└──────────────┬──────────────────────────────┘
               │
┌──────────────▼──────────────────────────────┐
│  HOOPS Exchange Implementations             │
│  ├── HOOPSLoader    (file I/O)              │
│  ├── HOOPSModel     (model wrapper)         │
│  ├── HOOPSBrep      (B-rep implementation)  │
│  └── HOOPSTools     (utilities)             │
└──────────────┬──────────────────────────────┘
               │
┌──────────────▼──────────────────────────────┐
│  HOOPS Exchange SDK (C++ library)           │
│  - Supports 100+ CAD file formats           │
│  - Requires commercial license              │
└─────────────────────────────────────────────┘

Relationship Details:

HOOPSLoader() creates HOOPSModel() instances from CAD files

HOOPSModel() provides access to HOOPSBrep().

HOOPSTools() provides utilities for working with HOOPSModel() instances (adaptation, export, etc.)

HOOPSBrep() provides different views of the same CAD model geometry

See also

For detailed explanations of B-rep concepts (faces, edges, vertices, topology), see CAD Fundamentals

The HOOPSLoader interface is your entry point for working with CAD files in HOOPS AI. It handles the complex task of reading 100+ different CAD file formats and converting them into a unified HOOPSModel representation that your ML pipeline can work with.

What Problem Does It Solve?

Without HOOPSLoader, you would need to:

Learn different file I/O libraries for STEP, IGES, CATIA, SolidWorks, etc.

Handle format-specific quirks and data structures

Write different loading code for each CAD system

Manage memory and licensing for commercial CAD kernels

How HOOPSLoader Solves This:

The HOOPSLoader class implements a singleton pattern for efficient CAD file loading.

Here’s how to initialize the HOOPSLoader class:

from hoops_ai.cadaccess import HOOPSLoader

# Create or get the singleton HOOPSLoader instance
loader = HOOPSLoader()

HOOPSLoader provides a single, consistent API for loading any supported CAD file:

# Same code works for STEP, IGES, CATIA, SolidWorks, etc.
loader = HOOPSLoader()
model = loader.create_from_file("part.step")  # or .iges, .catpart, .sldprt, etc.

The loader abstracts away all the complexity of format detection, parsing, and data extraction.

The HOOPSLoader class is responsible for Initializing HOOPS Exchange with license management, maintaining a single Exchange instance across the application, and loading CAD files to create model representations.

HOOPSLoader methods

`create_from_file(filename: str) -> HOOPSModel`

Loads a CAD file and returns a HOOPSModel instance.

Parameters:

filename (str): Absolute path to the CAD file

Returns:

HOOPSModel: A model object containing the loaded CAD data

`get_general_options() -> Dict[str, Any]`

Returns current loading options.

Returns:

Dictionary with keys:
read_feature: Whether to read feature information read_solid: Whether to read solid geometry

`set_general_options(general_options: Dict[str, Any]) -> None`

Configures CAD file loading behavior.

Parameters:

general_options: Dictionary with loading configuration

Loading Your First CAD File

Here’s the simplest way to load a CAD file:

from hoops_ai.cadaccess import HOOPSLoader

# Create a loader instance
loader = HOOPSLoader()

# Load a CAD file (format detected automatically)
model = loader.create_from_file("bracket.step")

What Happens Behind the Scenes:

Format Detection: HOOPS Exchange examines the file and detects it’s a STEP file

File Parsing: The STEP file is parsed into an internal data structure

Model Construction: A HOOPSModel object wraps the loaded data

Return: You get a HOOPSModel interface you can query

Understanding the Loader Lifecycle

The HOOPSLoader maintains state and follows this lifecycle:

[Create Loader] → [Configure Options] → [Load File] → [Access Model] → [Load Another File]
      ↓                  ↓                   ↓              ↓                  ↓
HOOPSLoader()   set_general_options()  create_from_file()  get_model()   create_from_file()

Key Points:

Singleton Pattern: HOOPSLoader uses a singleton pattern - creating multiple instances returns the same underlying loader

Stateful: The loader remembers the last loaded model and options you’ve set

Reusable: You can load multiple files with the same loader instance

loader = HOOPSLoader()

# Load first file
model1 = loader.create_from_file("part1.step")

# Load second file (replaces the first)
model2 = loader.create_from_file("part2.iges")

# Get currently loaded model (returns model2)
current = loader.get_model()

Configuring Loading Options

Understanding Loading Options

Loading options control what data is extracted from the CAD file and how it’s processed. These options affect:

Whether feature information is extracted (for machining feature recognition)

Whether solid geometry is loaded (vs. just surfaces)

Memory usage and loading performance

Availability of certain geometric queries

Available Options:

Option	Description	Default
`read_feature`	Extract machining features (holes, pockets, etc.) if available in the source CAD file	`False`
`read_solid`	Load solid B-rep geometry (faces, edges, topology). Set to `False` to load only visualization mesh.	`True`

Setting Options Before Loading

You should configure options before calling create_from_file():

from hoops_ai.cadaccess import HOOPSLoader

loader = HOOPSLoader()

# Get current options (returns a dict)
options = loader.get_general_options()
print(options)
# Output: {'read_feature': False, 'read_solid': True}

# Modify options
options['read_feature'] = True  # Enable feature extraction
options['read_solid'] = True    # Keep solid geometry

# Apply modified options
loader.set_general_options(options)

# Now load the file with these options
model = loader.create_from_file("part.step")

When to Enable Feature Extraction (read_feature=True):

You’re building a machining feature recognition model

You need to extract holes, pockets, slots from Parasolid or other feature-aware formats

When to Disable Solid Loading (read_solid=False):

You only need visualization mesh (for rendering, not ML feature extraction)

You want faster loading for very large assemblies (when you don’t need B-rep data)

You’re only exporting to mesh formats like OBJ

Note

Options Persist: Once set, options apply to all subsequent create_from_file() calls until you change them again.

Supported File Formats

HOOPS Exchange (the underlying CAD kernel) supports 100+ CAD file formats. Here are the most common:

Industry Standard Formats

Format	File Extensions	Description
STEP	`.step`, `.stp`	ISO 10303 standard for product data exchange. Most widely used neutral format.
IGES	`.iges`, `.igs`	Older neutral format, still common in automotive/aerospace.
JT	`.jt`	Lightweight 3D format from Siemens, popular in automotive visualization.
3D PDF	`.pdf`	PDF with embedded 3D CAD data.

Native CAD System Formats

CAD System	File Extensions	Notes
CATIA V4	`.model`, `.dlv`, `.exp`, `.session`	Aerospace/automotive industry standard
CATIA V5	`.CATPart`, `.CATProduct`	Widely used in automotive/aerospace
CATIA V6	`.3dxml`	Modern CATIA format
SolidWorks	`.sldprt`, `.sldasm`	Popular in mechanical engineering
Autodesk Inventor	`.ipt`, `.iam`	Common in machinery/manufacturing
PTC Creo (Pro/ENGINEER)	`.prt`, `.asm`	Aerospace/defense applications
Siemens NX (UG)	`.prt`	High-end CAD system
Parasolid	`.x_t`, `.x_b`	Kernel format used by many CAD systems

Format Detection is Automatic:

You don’t need to specify the format - HOOPS Exchange detects it from file content and extension:

# All of these work the same way
model1 = loader.create_from_file("part.step")
model2 = loader.create_from_file("part.CATPart")
model3 = loader.create_from_file("part.sldprt")
model4 = loader.create_from_file("part.prt")

See also

For the complete list of supported formats, see HOOPS Exchange Supported Formats

HOOPSModel Interface 

The HOOPSModel class represents a loaded CAD file in memory. It’s the container object returned by HOOPSLoader.create_from_file() that holds all the geometric and topological data extracted from the CAD file.

What is a HOOPSModel?

Think of HOOPSModel as a wrapper around the raw CAD data that provides:

Multiple Views: Access the same geometry as B-rep (boundary representation) or mesh (triangulated)

Metadata: Track the source file path and internal model structure

Body Navigation: Access individual solid bodies within the model

Abstraction: Shield your code from the underlying CAD kernel (HOOPS Exchange) implementation details

Usage Example:

model = loader.create_from_file("part.step")
brep = model.get_brep()

Lifecycle in Your Workflow:

Load File → HOOPSModel → Get Representation → Extract Features → Build ML Model
    ↓           ↓              ↓                    ↓                  ↓
loader.     Returns       get_brep()          BrepEncoder()        Train GNN
create()    HOOPSModel                                              Classify

HOOPSModel methods

Methods Required for BrepEncoder

`get_brep(body_index: int = 0) -> BrepAccess`

Extracts the Boundary Representation (BREP) from the CAD model.

Parameters:

body_index (int): Index of the body to extract (default: 0)

Returns:

HOOPSBrep: A BREP access object for geometry/topology extraction

Working with B-rep Representation

Getting HOOPSBrep

The most common operation is getting the B-rep representation:

from hoops_ai.cadaccess import HOOPSLoader

# Load model
loader = HOOPSLoader()
model = loader.create_from_file("bracket.step")

# Get B-rep interface (default body_index=0)
brep = model.get_brep()

What Happens Behind the Scenes:

model.get_brep() finds the first solid body in the model

Creates a HOOPSBrep instance wrapping that body

Initializes internal topology maps (faces, edges, vertices)

Pre-computes face centroids for quick access

Returns the BrepAccess interface you can query

What is a Body?

In CAD terminology, a body is a single solid piece of material. A CAD file might contain:

Single Body: One part (e.g., bracket.step)

Multiple Bodies: Assembly of parts (e.g., engine_assembly.step)

Multi-Body Part: One part file with multiple disconnected solids

Typical Workflow with B-rep

Here’s a complete example of working with B-rep data:

from hoops_ai.cadaccess import HOOPSLoader, HOOPSTools

# 1. Load the model
loader = HOOPSLoader()
model = loader.create_from_file("part.step")

# 2. Prepare B-rep for feature extraction (force UV computation)
tools = HOOPSTools()
brep_opts = tools.brep_options()
brep_opts['force_compute_uv'] = True  # Needed for uvgrid()
tools.adapt_brep(model, brep_opts)

# 3. Get B-rep access
brep = model.get_brep()

# 4. Extract geometric features
face_indices = brep.get_face_indices()

for face_id in face_indices:
    # Get face attributes
    surface_type, surface_desc, area, centroid, num_loops = brep.get_face_attributes(face_id, {})

    # Sample the face with UV grid (for CNN features)
    points = brep.uvgrid(face_id, num_u=32, num_v=32, method='point')
    normals = brep.uvgrid(face_id, num_u=32, num_v=32, method='normal')

    print(f"Face {face_id}: {surface_desc}, Area={area:.2f}")

# 5. Build topology graph (for GNN features)
graph = brep.build_face_adjacency_graph()
print(f"Face adjacency graph: {graph.number_of_nodes()} nodes, {graph.number_of_edges()} edges")

See also

For detailed B-rep query methods, see /programming_guide/brep-access-interface

HOOPSBrep Interface 

The HOOPSBrep() interface is the primary way to extract ML features from CAD data. It provides methods to query B-rep topology (face adjacency, edge connectivity) and geometry (areas, lengths, bounding boxes, UV grids, surface samples).

Available Query Types:

Entity Lists: Get face/edge/vertex indices

Topology: Build face adjacency graphs for GNNs

Geometry: Compute areas, lengths, bounding boxes

Surface Sampling: Generate UV grids or point clouds

Relationships: Query dihedral angles, convexity

See also

For detailed explanations of B-rep concepts (faces, edges, vertices, topology vs geometry), see CAD Fundamentals

Entity Queries - Discovering the Part Structure 

Get Lists of Entities:

Use get_face_indices() to retrieve the list of face identifiers, and get_edge_indices() to retrieve the list of edge identifiers.

from hoops_ai.cadaccess import HOOPSLoader, HOOPSModel, HOOPSBrep

# Load model
loader = HOOPSLoader()
model = loader.create_from_file("bracket.step")
brep = model.get_brep()

# Get all face indices
face_indices = brep.get_face_indices()
print(f"Number of faces: {len(face_indices)}")
# Output: Number of faces: 42

# Get all edge indices
edge_indices = brep.get_edge_indices()
print(f"Number of edges: {len(edge_indices)}")

# Iterate through faces
for face_id in face_indices:
    print(f"Processing face {face_id}")

Geometric Queries 

Bounding Box:

The get_bounding_box() method computes the axis-aligned bounding box of the entire B-rep model.

# Get overall bounding box
bbox = brep.get_bounding_box()
# Returns: (xmin, ymin, zmin, xmax, ymax, zmax)

xmin, ymin, zmin, xmax, ymax, zmax = bbox

# Compute dimensions
length = xmax - xmin
width = ymax - ymin
height = zmax - zmin

print(f"Part dimensions: {length:.2f} × {width:.2f} × {height:.2f}")

Face-Level Geometry:

The recommended way to get face properties is through get_face_attributes(), which provides a comprehensive set of geometric properties for each face.:

# For each face, extract geometric properties using get_face_attributes
for face_id in face_indices:
    # get_face_attributes returns a tuple:
    # (surface_type, surface_description, face_area, centroid, loops_count)
    attributes_spec = {}  # Currently unused, for future extensibility
    surface_type, surface_desc, area, centroid, num_loops = brep.get_face_attributes(face_id, attributes_spec)

    print(f"Face {face_id}:")
    print(f"  Type: {surface_type} ({surface_desc})")
    print(f"  Area: {area:.4f}")
    print(f"  Centroid: {centroid}")
    print(f"  Loops: {num_loops}")

Edge-Level Geometry:

Similarly, use get_edge_attributes() for edge properties:

for edge_id in edge_indices:
    # get_edge_attributes returns a tuple:
    # (curve_type, curve_description, edge_length, dihedral_angle, convexity)
    attributes_spec = {}  # Currently unused, for future extensibility
    curve_type, curve_desc, length, dihedral, convexity = brep.get_edge_attributes(edge_id, attributes_spec)

    print(f"Edge {edge_id}: {curve_type} ({curve_desc})")
    print(f"  Length: {length:.4f}")
    print(f"  Dihedral angle: {dihedral:.2f}°")
    print(f"  Convexity: {convexity:.2f}")

Topological Queries 

Face Adjacency Graph:

The build_face_adjacency_graph() method Creates NetworkX graph of face connectivity.

# Access the raw topology graph from HOOPS Exchange
graph = brep.build_face_adjacency_graph()

Grid Sampling 

CAD surfaces are parametric - defined by equations mapping 2D parameter space (u, v) to 3D space (x, y, z). The uvgrid() method samples surfaces at regular intervals to create structured grids of 3D points, normals, or visibility flags.

Why UV grids are useful for ML: They convert continuous mathematical surfaces into fixed-size numeric arrays suitable for neural networks (point clouds for PointNet, structured grids for CNNs, curvature estimation, surface quality analysis).

See also

For detailed explanations of UV parameterization, surface types, and how UV grids map to 3D geometry, see CAD Fundamentals - UV Grids: Sampling Face Geometry section.

Using UV Grids in HOOPS AI to sample points/normals on faces:

# Sample a 10×10 grid on face 5
# The uvgrid() method returns different data based on the 'method' parameter

# Get 3D points on the surface
points = brep.uvgrid(face_index=5, num_u=10, num_v=10, method='point')
# Returns: numpy array of shape (10, 10, 3) - XYZ coordinates

# Get surface normals
normals = brep.uvgrid(face_index=5, num_u=10, num_v=10, method='normal')
# Returns: numpy array of shape (10, 10, 3) - Normal vectors

Using U Grids in HOOPS AI to sample points along edges:

# Sample 20 points along edge 12
edge_points = brep.uvgrid(edge_index=12, num_u=20)
# Returns: numpy array of shape (20, 3) - XYZ coordinates along the edge

HOOPSTools Interface 

The HOOPSTools interface provides preprocessing and utility operations for CAD models. Think of it as the “toolbox” for preparing CAD data before ML feature extraction.

What Problems Does HOOPSTools Solve?

Raw CAD files often have issues that prevent effective ML feature extraction:

Missing UV Parameterization: Many CAD files don’t include UV parameters needed for surface sampling
Format Conversion: Need to export models to different formats (OBJ for visualization, STEP for exchange)
Feature Extraction: Manufacturing features (holes, pockets) need specialized extraction
Data Quality: B-rep data may need healing, normalization, or filtering

How HOOPSTools Solves This:

from hoops_ai.cadaccess import HOOPSLoader, HOOPSTools

# Load model
loader = HOOPSLoader()
model = loader.create_from_file("part.step")

# Create tools instance
tools = HOOPSTools()

# Prepare model for ML (force UV computation)
brep_opts = tools.brep_options()
brep_opts['force_compute_uv'] = True
tools.adapt_brep(model, brep_opts)

# Now uvgrid() will work on all faces
brep = model.get_brep()
uv_data = brep.uvgrid(face_index=0, num_u=32, num_v=32, method='point')

HOOPSTools Capabilities:

B-rep Adaptation: Force UV computation, handle surface seams, filter unsupported types
Format Export: Convert to OBJ (visualization), STEP (exchange), StreamCache (web viewer)
Feature Extraction: Extract manufacturing features like holes (Parasolid files)
Quality Control: Validate and prepare geometry for ML pipelines

B-rep Adaptation - Preparing for ML

Why B-rep Adaptation is Necessary

CAD files come from many sources (SolidWorks, CATIA, STEP exports) and often have incomplete or inconsistent data:

Common Issues:

Missing UV Parameters: Faces lack 2D parameterization needed for uvgrid() sampling

Periodic Surfaces: Cylindrical/toroidal faces have seams where UV wraps around (u=0 = u=1)

Unsupported Surface Types: Some exotic surface types (blend surfaces, transforms) cause errors

Tolerance Issues: Geometric gaps between faces prevent proper topology extraction

What B-rep Adaptation Does:

The adapt_brep() method processes the model to:

Force UV Computation: Calculates missing UV parameterization for all faces
Handle Seams: Manages periodic surface boundaries properly
Filter Surfaces: Removes or converts unsupported surface types
Heal Topology: Fixes small gaps and inconsistencies

Warning

Modifies Model In-Place: adapt_brep() permanently changes the internal model structure. If you need the original, load the file twice or save a copy first.

Getting B-rep Options

The brep_options() method returns a dictionary of all available adaptation settings:

from hoops_ai.cadaccess import HOOPSTools

tools = HOOPSTools()

# Get default options
opts = tools.brep_options()

print(opts)
# Output:
# {
#     'use_same_parameters': False,
#     'tolerance': 0.001,
#     'delete_crossing_uv': False,
#     'allow_uv_crossing_seams': True,
#     'split_faces': False,
#     'split_closed_faces': False,
#     'force_compute_uv': True,     # ← KEY FOR ML!
#     'force_compute_3d': True,
#     'continue_on_error': True,
#     'acceptable_surfaces': [...],
#     'acceptable_curves': [...]
# }

Key Options Explained

Option	Description	Recommended Value
`force_compute_uv`	CRITICAL: Forces computation of UV parameterization for all faces. Required for `uvgrid()` to work.	`True` (always)
`force_compute_3d`	Ensures 3D curve data is available for all edges	`True`
`tolerance`	Geometric tolerance for adaptation (mm). Larger = more aggressive healing but less accurate.	`0.001` (1 micron)
`allow_uv_crossing_seams`	Allows UV grids to cross periodic seam boundaries (cylinders, tori)	`True`
`delete_crossing_uv`	Deletes faces with UV parameters that cross seams. More aggressive than `allow_uv_crossing_seams`.	`False`
`split_faces`	Splits faces at UV discontinuities into multiple faces	`False`
`split_closed_faces`	Splits closed faces (spheres, tori) at seams	`False`
`continue_on_error`	Continue processing if some faces fail (vs aborting entire model)	`True`
`acceptable_surfaces`	List of surface types to process. Unsupported types are filtered.	Default list (includes plane, cylinder, sphere, NURBS, etc.)
`acceptable_curves`	List of curve types to process for edges	Default list (includes line, circle, NURBS, etc.)

Tip

For Most ML Workflows: The default options from brep_options() work well. The key is ensuring force_compute_uv=True is set.

Applying B-rep Adaptation

Basic Usage (with defaults):

from hoops_ai.cadaccess import HOOPSLoader, HOOPSTools

# Load model
loader = HOOPSLoader()
model = loader.create_from_file("part.step")

# Apply adaptation with default options
tools = HOOPSTools()
brep_opts = tools.brep_options()  # Already has force_compute_uv=True
tools.adapt_brep(model, brep_opts)

# Now the model is ready for uvgrid() calls
brep = model.get_brep()

When to Call adapt_brep()

You MUST call adapt_brep() if:

You plan to use brep.uvgrid() for UV sampling (most ML workflows)

You encounter DataExtractError or None returns from uvgrid()

The CAD file is from an older format (IGES) or export with minimal data

You can SKIP adapt_brep() if:

You only need basic topology (face indices, edge indices, bounding box)

You only use mesh representation (model.get_mesh())

You’re just exporting to other formats without feature extraction

# Typical ML pipeline
loader = HOOPSLoader()
model = loader.create_from_file("part.step")

# ALWAYS adapt before UV operations
tools = HOOPSTools()
tools.adapt_brep(model, tools.brep_options())

# Now safe to extract features
brep = model.get_brep()
for face_id in brep.get_face_indices():
    uv_grid = brep.uvgrid(face_id, num_u=32, num_v=32, method='point')

Exporting to Different Formats

HOOPSTools provides methods to export models to various formats for visualization, exchange, or downstream processing.

Exporting to OBJ (Wavefront)

Use Case: Visualization in 3D viewers (Blender, MeshLab), mesh-based ML models

from hoops_ai.cadaccess import HOOPSLoader, HOOPSTools

loader = HOOPSLoader()
model = loader.create_from_file("part.step")

tools = HOOPSTools()

# Export to OBJ format
tools.exportOBJ(model, filepath="output.obj")

# Creates: output.obj (mesh file)
print("Exported to OBJ for visualization")

What Gets Exported:

Tessellated mesh (triangles)

Vertex coordinates and normals

Material information (if available)

File Format: ASCII text file, widely supported, no topology information

Exporting to STEP (ISO 10303)

Use Case: Exchange with other CAD systems, archival, neutral format

# Export to STEP format
tools.exportSTEP(model, filepath="output.step")

# Creates: output.step (full B-rep data)
print("Exported to STEP format")

What Gets Exported:

Complete B-rep geometry (faces, edges, curves, surfaces)

Topology (adjacency relationships)

Product structure (if assembly)

Metadata (units, author, etc.)

File Format: ISO 10303 standard, preserves full design intent, widely supported

Exporting to StreamCache (HOOPS Visualize Web)

Use Case: Web-based 3D visualization using HOOPS Visualize Web viewer

# Export to StreamCache format (for web viewer)
png_path, scs_path = tools.exportStreamCache(
    model,
    filepath="output.scs",
    is_white_background=True,
    overwrite=False
)

print(f"Exported to StreamCache: {scs_path}")
print(f"Preview image: {png_path}")

What Gets Created:

.scs file: HOOPS StreamCache format (optimized for web streaming)

.png file: Preview thumbnail image

Common Options 

HOOPSTools B-rep Options

Options for B-rep processing and adaptation:

Option Key	Type	Description	Default Value
`tolerance`	float	Geometric tolerance for operations (mm)	0.001
`force_compute_uv`	bool	Force computation of UV parameters (required for UV grids)	True
`force_compute_3d`	bool	Force computation of 3D parameters	True
`delete_crossing_uv`	bool	Delete crossing UV parameters	False
`allow_uv_crossing_seams`	bool	Allow UV parameters to cross seam boundaries	True
`split_faces`	bool	Split faces into multiple patches	False
`split_closed_faces`	bool	Split periodic surfaces (cylinders, tori)	False
`continue_on_error`	bool	Process all faces even if some fail	True

Next Steps 

Read CAD Data Encoding to learn feature extraction
Study Storage for data persistence
Review CADAccess API Reference for detailed method signatures
Try Tutorials for hands-on examples

CAD Data Access

Architecture and Design

Understanding the Component Hierarchy

HOOPSLoader methods

create_from_file(filename: str) -> HOOPSModel

get_general_options() -> Dict[str, Any]

set_general_options(general_options: Dict[str, Any]) -> None

Loading Your First CAD File

Understanding the Loader Lifecycle

Configuring Loading Options

Understanding Loading Options

Setting Options Before Loading

Supported File Formats

Industry Standard Formats

Native CAD System Formats

HOOPSModel methods

get_brep(body_index: int = 0) -> BrepAccess

Working with B-rep Representation

Getting HOOPSBrep

Typical Workflow with B-rep

B-rep Adaptation - Preparing for ML

Why B-rep Adaptation is Necessary

Getting B-rep Options

Key Options Explained

Applying B-rep Adaptation

When to Call adapt_brep()

Exporting to Different Formats

Exporting to OBJ (Wavefront)

Exporting to STEP (ISO 10303)

Exporting to StreamCache (HOOPS Visualize Web)

HOOPSTools B-rep Options

Hello! I'm HOOPSY

`create_from_file(filename: str) -> HOOPSModel`

`get_general_options() -> Dict[str, Any]`

`set_general_options(general_options: Dict[str, Any]) -> None`

`get_brep(body_index: int = 0) -> BrepAccess`