py3dtiles.tileset.content package

class py3dtiles.tileset.content.B3dm(header: B3dmHeader, body: B3dmBody)

Bases: TileContent

static from_array(array: ndarray[Any, dtype[uint8]]) → B3dm

static from_gltf(gltf: pygltflib.GLTF2, batch_table: BatchTable | None = None, feature_table: B3dmFeatureTable | None = None) → B3dm

Wrap a pygltflib.GLTF2 instance into a b3dm. This gives the most control on the scene creation, as pygltflib.GLTF2 instance are as near as possible to the gltf specification.

static from_meshes(meshes: list[GltfMesh], batch_table: BatchTable | None = None, feature_table: B3dmFeatureTable | None = None, transform: npt.NDArray[np.float32] | None = None) → B3dm

Create a b3dm from GltfMesh instances. This allows for finer control than from_numpy_arrays by allowing several meshes in one b3dm.

static from_numpy_arrays(points: npt.NDArray[np.float32], triangles: npt.NDArray[np.uint8] | None = None, batch_table: BatchTable | None = None, feature_table: B3dmFeatureTable | None = None, normal: npt.NDArray[np.float32] | None = None, uvs: npt.NDArray[np.float32] | None = None, batchids: npt.NDArray[np.uint32] | None = None, transform: npt.NDArray[np.float32] | None = None, texture_uri: str | None = None, material: pygltflib.Material | None = None) → B3dm

Creates a B3DM body from numpy arrays.

Parameters:

• points – array of vertex positions, must have a (n, 3) shape.

• triangles – array of triangle indices, must have a (n, 3) shape.

• batch_table – a batch table.

• feature_table – a feature table.

• normals – array of vertex normals, must have a (n, 3) shape.

• uvs – array of texture coordinates, must have a (n, 2) shape.

• batchids – array of batch table IDs, must have a (n) shape.

• texture_uri – the URI of the texture image if the primitive is textured.

• material – a glTF material. If not set, a default material is created.

sync() → None

Allow to synchronize headers with contents.

class py3dtiles.tileset.content.B3dmBody

Bases: TileContentBody

static from_array(b3dm_header: B3dmHeader, array: ndarray[Any, dtype[uint8]]) → B3dmBody

static from_gltf(gltf: GLTF2) → B3dmBody

static from_meshes(meshes: list[GltfMesh], transform: npt.NDArray[np.float32] | None = None) → B3dmBody

to_array() → ndarray[Any, dtype[uint8]]

class py3dtiles.tileset.content.B3dmHeader

Bases: TileContentHeader

BYTE_LENGTH = 28

static from_array(array: ndarray[Any, dtype[uint8]]) → B3dmHeader

to_array() → ndarray[Any, dtype[uint8]]

class py3dtiles.tileset.content.GltfAttribute(name: str, accessor_type: str, component_type: pygltflib.UNSIGNED_BYTE | pygltflib.UNSIGNED_INT | pygltflib.FLOAT, array: npt.NDArray[np.uint8 | np.uint16 | np.uint32 | np.float32])

Bases: NamedTuple

A high level representation of a gltf attribute

accessor_type can only take values autorized by the spec.

component_type should take these values.

accessor_type: str

Alias for field number 1

array: npt.NDArray[np.uint8 | np.uint16 | np.uint32 | np.float32]

Alias for field number 3

component_type: pygltflib.UNSIGNED_BYTE | pygltflib.UNSIGNED_INT | pygltflib.FLOAT

Alias for field number 2

name: str

Alias for field number 0

class py3dtiles.tileset.content.GltfMesh(points: npt.NDArray[np.float32], name: str | None = None, normals: npt.NDArray[np.float32] | None = None, primitives: list[GltfPrimitive] | None = None, batchids: npt.NDArray[np.uint32] | None = None, uvs: npt.NDArray[np.float32] | None = None, additional_attributes: list[GltfAttribute] | None = None, properties: dict[str, Any] | None = None)

Bases: object

A data structure representing a mesh.

This is intended for higher-level usage than pygltflib.Mesh, which are an exact translation of the specification.

This is intented to be easier to construct by keeping a more hierarchical and logical organization. GltfMesh are constructed with all the vertices, normals, uvs and additional attributes, and an optional list of GltfPrimitive that contains indices and material informations.

Use gltf_from_meshes or populate_gltf_from_mesh to convert it to GLTF format.

Parameters:

• points – array of vertex positions, must have a (n, 3) shape.

• primitives – array of GltfPrimitive

• normals – array of vertex normals for the whole mesh, must have a (n, 3) shape.

• batchids – array of batch table IDs, must have a (n) shape.

• additional_attributes – additional attributes to add to the primitive.

• uvs – array of texture coordinates, must have a (n, 2) shape.

class py3dtiles.tileset.content.GltfPrimitive(triangles: npt.NDArray[np.uint8 | np.uint16 | np.uint32] | None = None, material: pygltflib.Material | None = None, texture_uri: str | None = None)

Bases: object

A data structure storing all information to create a glTF mesh’s primitive.

This is intended for higher-level usage than pygltflib.Primitive.

The transformation will be done automatically while transforming a GltfMesh.

Parameters:

• triangles – array of triangle indices, must have a (n, 3) shape.

• material – a glTF material. If not set, a default material is created.

• texture_uri – the URI of the texture image if the primitive is textured.

class py3dtiles.tileset.content.Pnts(header: PntsHeader, body: PntsBody)

Bases: TileContent

static from_array(array: ndarray[Any, dtype[uint8]]) → Pnts

Creates a Pnts from an array

static from_features(feature_table_header: PntsFeatureTableHeader, position_array: npt.NDArray[np.float32 | np.uint16], color_array: npt.NDArray[np.uint8 | np.uint16] | None = None, normal_position: npt.NDArray[np.float32 | np.uint8] | None = None) → Pnts

Creates a Pnts from features defined by pd_type and cd_type.

static from_file(tile_path: Path) → Pnts

static from_points(points: Points) → Pnts

Create a pnts from data array:

• positions will be included as SemanticPoint.POSITION

• if rgb is not None, it will be included as SemanticPoint.RGB

• all the extra_fields are included in the batch table

Parameters:

• positions – the positions 1D array

• colors – the colors 1D array

• extra_fields – a dict of extra arrays to include in the batch_table. The dict keys are the name of the fields, the values are 1D np arrays containing values for each field.

sync() → None

Synchronizes headers with the Pnts body.

class py3dtiles.tileset.content.PntsBody

Bases: TileContentBody

static from_array(header: PntsHeader, array: ndarray[Any, dtype[uint8]]) → PntsBody

Creates a PntsBody from an array and the header

get_points(transform: npt.NDArray[np.float64] | None) → Points

to_array() → ndarray[Any, dtype[uint8]]

Returns the body as a numpy array.

class py3dtiles.tileset.content.PntsHeader

Bases: TileContentHeader

BYTE_LENGTH = 28

static from_array(array: ndarray[Any, dtype[uint8]]) → PntsHeader

Create a PntsHeader from an array

to_array() → ndarray[Any, dtype[uint8]]

Returns the header as a numpy array.

class py3dtiles.tileset.content.TileContent

Bases: ABC

body: TileContentBody

abstract static from_array(array: ndarray[Any, dtype[uint8]]) → TileContent

header: TileContentHeader

save_as(path: Path) → None

abstract sync() → None

Allow to synchronize headers with contents.

to_array() → ndarray[Any, dtype[uint8]]

class py3dtiles.tileset.content.TileContentBody

Bases: ABC

batch_table: BatchTable

feature_table: FeatureTable[Any, Any]

abstract to_array() → ndarray[Any, dtype[uint8]]

class py3dtiles.tileset.content.TileContentHeader

Bases: ABC

abstract static from_array(array: ndarray[Any, dtype[uint8]]) → TileContentHeader

magic_value: Literal[b'b3dm', b'pnts']

abstract to_array() → ndarray[Any, dtype[uint8]]

version: int

py3dtiles.tileset.content.gltf_from_meshes(meshes: list[GltfMesh], transform: npt.NDArray[np.float32] | None = None) → pygltflib.GLTF2

Builds a GLTF2 instance from a list of meshes.

py3dtiles.tileset.content.populate_gltf_from_mesh(gltf: GLTF2, mesh: GltfMesh) → None

Add a GltfMesh to a pygltflib.GLTF2

This method takes care of all the nitty-gritty work about setting buffer, bufferViews, accessors and primitives.

py3dtiles.tileset.content.read_binary_tile_content(tile_path: Path) → TileContent

Submodules

• py3dtiles.tileset.content.b3dm module
  • B3dm
    • B3dm.from_array()
    • B3dm.from_gltf()
    • B3dm.from_meshes()
    • B3dm.from_numpy_arrays()
    • B3dm.sync()
  • B3dmBody
    • B3dmBody.from_array()
    • B3dmBody.from_gltf()
    • B3dmBody.from_meshes()
    • B3dmBody.to_array()
  • B3dmHeader
    • B3dmHeader.BYTE_LENGTH
    • B3dmHeader.from_array()
    • B3dmHeader.magic_value
    • B3dmHeader.to_array()
    • B3dmHeader.version
• py3dtiles.tileset.content.b3dm_feature_table module
  • B3dmFeatureTable
    • B3dmFeatureTable.add_property_as_binary()
    • B3dmFeatureTable.add_property_as_json()
    • B3dmFeatureTable.from_array()
    • B3dmFeatureTable.get_batch_length()
    • B3dmFeatureTable.get_binary_property()
    • B3dmFeatureTable.set_batch_length()
    • B3dmFeatureTable.to_array()
  • B3dmFeatureTableBody
    • B3dmFeatureTableBody.to_array()
  • B3dmFeatureTableHeader
    • B3dmFeatureTableHeader.to_array()
• py3dtiles.tileset.content.batch_table module
  • BatchTable
    • BatchTable.add_property_as_binary()
    • BatchTable.add_property_as_json()
    • BatchTable.from_array()
    • BatchTable.get_binary_property()
    • BatchTable.get_property_names()
    • BatchTable.to_array()
  • BatchTableBody
    • BatchTableBody.nbytes
    • BatchTableBody.to_array()
  • BatchTableHeader
    • BatchTableHeader.to_array()
• py3dtiles.tileset.content.feature_table module
  • FeatureTable
    • FeatureTable.body
    • FeatureTable.from_array()
    • FeatureTable.header
    • FeatureTable.to_array()
  • FeatureTableBody
    • FeatureTableBody.nbytes
    • FeatureTableBody.to_array()
  • FeatureTableHeader
    • FeatureTableHeader.to_array()
• py3dtiles.tileset.content.gltf_utils module
  • GltfAttribute
    • GltfAttribute.accessor_type
    • GltfAttribute.array
    • GltfAttribute.component_type
    • GltfAttribute.name
  • GltfMesh
  • GltfPrimitive
  • get_component_type_from_dtype()
  • gltf_from_meshes()
  • populate_gltf_from_mesh()
  • prepare_gltf_component()
• py3dtiles.tileset.content.pnts module
  • Pnts
    • Pnts.from_array()
    • Pnts.from_features()
    • Pnts.from_file()
    • Pnts.from_points()
    • Pnts.sync()
  • PntsBody
    • PntsBody.from_array()
    • PntsBody.get_points()
    • PntsBody.to_array()
  • PntsHeader
    • PntsHeader.BYTE_LENGTH
    • PntsHeader.from_array()
    • PntsHeader.magic_value
    • PntsHeader.to_array()
    • PntsHeader.version
  • get_color_semantic()
• py3dtiles.tileset.content.pnts_feature_table module
  • PntsFeatureTable
    • PntsFeatureTable.from_array()
    • PntsFeatureTable.from_features()
    • PntsFeatureTable.get_feature_at()
    • PntsFeatureTable.get_feature_color_at()
    • PntsFeatureTable.get_feature_normal_at()
    • PntsFeatureTable.get_feature_position_at()
    • PntsFeatureTable.nb_points()
    • PntsFeatureTable.to_array()
  • PntsFeatureTableBody
    • PntsFeatureTableBody.from_array()
    • PntsFeatureTableBody.to_array()
  • PntsFeatureTableHeader
    • PntsFeatureTableHeader.from_array()
    • PntsFeatureTableHeader.from_semantic()
    • PntsFeatureTableHeader.to_array()
    • PntsFeatureTableHeader.to_json()
  • SemanticCategory
    • SemanticCategory.BATCH
    • SemanticCategory.COLOR
    • SemanticCategory.NONE
    • SemanticCategory.NORMAL
    • SemanticCategory.POSITION
  • SemanticPoint
    • SemanticPoint.BATCH_ID
    • SemanticPoint.NONE
    • SemanticPoint.NORMAL
    • SemanticPoint.NORMAL_OCT16P
    • SemanticPoint.POSITION
    • SemanticPoint.POSITION_QUANTIZED
    • SemanticPoint.RGB
    • SemanticPoint.RGB565
    • SemanticPoint.RGBA
  • check_array_size()
  • check_semantic_type()
• py3dtiles.tileset.content.tile_content module
  • TileContent
    • TileContent.body
    • TileContent.from_array()
    • TileContent.header
    • TileContent.save_as()
    • TileContent.sync()
    • TileContent.to_array()
  • TileContentBody
    • TileContentBody.batch_table
    • TileContentBody.feature_table
    • TileContentBody.to_array()
  • TileContentHeader
    • TileContentHeader.from_array()
    • TileContentHeader.magic_value
    • TileContentHeader.to_array()
    • TileContentHeader.version
• py3dtiles.tileset.content.tile_content_reader module
  • read_binary_tile_content()