如何使用pythonOCC读取GLB文件中的自定义扩展/用户数据？RWGltf_CafReader是否支持导入extras？

First, let's clarify the core issue: the default RWGltf_CafReader in OpenCASCADE (and thus PythonOCC) does NOT support importing GLB extras fields back into TDataStd_NamedData attributes. The export side maps TDataStd_NamedData to glTF extras as you've seen, but the reverse logic isn't implemented out of the box—since extras is an open, unstructured field in the glTF spec, the default reader doesn't assume how to map it back to OCC's CAF attributes.

Here are two practical solutions to read both the 3D geometry and your custom user data from the GLB file:

Solution 1: Extend RWGltf_CafReader with a custom attribute reader (Framework-native approach) #

This approach hooks into OCC's CAF reading pipeline to automatically parse extras and attach them to the corresponding shape labels as TDataStd_NamedData. Note that PythonOCC's SWIG bindings may require some extra work to override C++ virtual functions, but here's the conceptual implementation:

import OCC.Core.RWGltf as RWGltf
import OCC.Core.TDataStd as TDataStd
import OCC.Core.TDocStd as TDocStd

# Define a custom attribute reader to handle glTF extras
class ExtrasToNamedDataReader(RWGltf.RWGltf_CafAttributeReader):
    def Read(self, theNode, theLabel):
        # Access the extras from the glTF node/primitive
        extras = theNode.GetExtras()
        if extras.IsNull():
            return False
        
        # Create or retrieve the TDataStd_NamedData attribute for the label
        named_data = TDataStd.TDataStd_NamedData.Set(theLabel)
        
        # Iterate over extras key-value pairs (adjust based on your data structure)
        keys = extras.GetKeys()
        for key in keys:
            value = extras.GetString(key)
            named_data.SetString(key, value)
        
        return True

# Use the custom reader to load the GLB
doc = TDocStd.TDocStd_Document()
reader = RWGltf.RWGltf_CafReader()

# Register our custom attribute reader
reader.AddAttributeReader(ExtrasToNamedDataReader())

reader.SetDocument(doc)
reader.ReadFile("your_model.glb")

# Verify the data was loaded
shape_tool = doc.Main().ShapeTool()
labels = shape_tool.GetShapes()
for label in labels:
    named_data = TDataStd.TDataStd_NamedData()
    if label.FindAttribute(TDataStd.TDataStd_NamedData.GetID(), named_data):
        if named_data.HasStrings():
            print("Successfully loaded extras!")
            # Print the key-value pairs
            keys = named_data.GetStrings()
            for key in keys:
                print(f"{key}: {named_data.GetString(key)}")

If you run into issues with PythonOCC bindings not allowing you to override RWGltf_CafAttributeReader, you may need to wrap this logic in C++ and expose it to Python, but this is the intended way to extend the reader.

Solution 2: Manually parse GLB extras and link to OCC shapes (Simpler, Python-friendly) #

If extending the OCC reader feels too complex, you can use a dedicated glTF parsing library to extract extras first, then map that data to the shapes loaded by OCC. This avoids dealing with OCC's low-level reading extensions.

We'll use pygltflib (a lightweight glTF/GLB parser) for this:

from pygltflib import GLTF2
import OCC.Core.TDataStd as TDataStd
import OCC.Core.TDocStd as TDocStd
import OCC.Core.RWGltf as RWGltf
from OCC.Core.TopAbs import TopAbs_FACE
from OCC.Core.TopExp import TopExp_Explorer

# Step 1: Extract extras from the GLB file
gltf = GLTF2().load("your_model.glb")
extras_store = {}

# Map mesh/primitive indices to their extras (adjust based on your model's structure)
for mesh_idx, mesh in enumerate(gltf.meshes):
    for prim_idx, primitive in enumerate(mesh.primitives):
        if hasattr(primitive, "extras") and primitive.extras:
            # Use a unique key to identify this primitive (mesh + primitive index)
            key = f"mesh_{mesh_idx}_prim_{prim_idx}"
            extras_store[key] = primitive.extras

# Step 2: Load the 3D geometry with OCC
doc = TDocStd.TDocStd_Document()
reader = RWGltf.RWGltf_CafReader()
reader.SetDocument(doc)
reader.ReadFile("your_model.glb")

# Step 3: Link extras to OCC shapes/faces
shape_tool = doc.Main().ShapeTool()
root_label = doc.Main()
root_shape = shape_tool.GetShape(root_label)

# Traverse all faces in the model (adjust if you stored data on meshes instead of faces)
face_explorer = TopExp_Explorer(root_shape, TopAbs_FACE)
face_count = 0
while face_explorer.More():
    face = face_explorer.Current()
    # Get the label for this face
    face_label = shape_tool.FindShape(face, False)
    
    # Match the face to the corresponding primitive (you may need to adjust this matching logic)
    # For simplicity, we'll assume face order matches primitive order (test this with your model!)
    match_key = f"mesh_0_prim_{face_count}"
    if match_key in extras_store:
        # Attach the extras as TDataStd_NamedData
        named_data = TDataStd.TDataStd_NamedData.Set(face_label)
        for k, v in extras_store[match_key].items():
            named_data.SetString(k, str(v))
    
    face_count += 1
    face_explorer.Next()

# Verify the result
test_label = shape_tool.FindShape(face, False)
named_data = TDataStd.TDataStd_NamedData()
if test_label.FindAttribute(TDataStd.TDataStd_NamedData.GetID(), named_data):
    print("Extras loaded successfully!")
    print(named_data.GetString("some_variable"))

Notes on matching shapes to extras: #

The matching logic (face count ↔ primitive index) works for simple models, but for complex models you may need more robust identifiers—like storing a unique ID in extras during export, then checking shape properties (e.g., area, vertex count) to match faces to their primitive data.

Key Takeaway #

The default RWGltf_CafReader doesn't handle extras imports because glTF's extras are unstructured. You either need to extend the OCC reader to map extras back to TDataStd_NamedData, or manually parse the GLB and link the data to OCC shapes post-loading.

内容的提问来源于stack exchange，提问作者Sankalp Dhupar