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: GLTF2, batch_table: BatchTable | None = None, feature_table: B3dmFeatureTable | None = None) → B3dm

static from_numpy_arrays(points: ndarray[Any, dtype[float32]], triangles: ndarray[Any, dtype[uint8]] | None = None, batch_table: BatchTable | None = None, feature_table: B3dmFeatureTable | None = None, normal: ndarray[Any, dtype[float32]] | None = None, uvs: ndarray[Any, dtype[float32]] | None = None, batchids: ndarray[Any, dtype[uint32]] | None = None, transform: ndarray[Any, dtype[float32]] | None = None, texture_uri: str | None = None, material: 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.

static from_primitives(primitives: list[GltfPrimitive], batch_table: BatchTable | None = None, feature_table: B3dmFeatureTable | None = None, transform: ndarray[Any, dtype[float32]] | None = None) → B3dm

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_primitives(primitives: list[GltfPrimitive], transform: ndarray[Any, dtype[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, accessor_type, component_type, array)

Bases: NamedTuple

accessor_type: pygltflib.SCALAR | pygltflib.VEC2 | pygltflib.VEC3

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.GltfPrimitive(points: ndarray[Any, dtype[float32]], triangles: ndarray[Any, dtype[uint8 | uint16 | uint32]] | None = None, normals: ndarray[Any, dtype[float32]] | None = None, uvs: ndarray[Any, dtype[float32]] | None = None, batchids: ndarray[Any, dtype[uint32]] | None = None, additional_attributes: list[GltfAttribute] | None = None, texture_uri: str | None = None, material: Material | None = None)

Bases: object

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: ndarray[Any, dtype[float32 | uint16]], color_array: ndarray[Any, dtype[uint8 | uint16]] | None = None, normal_position: ndarray[Any, dtype[float32 | 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: ndarray[Any, dtype[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]]

to_hex_str() → str

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_component_from_primitive(primitive: GltfPrimitive, byte_offset: int = 0, attribute_counter: int = 0) → tuple[Primitive, list[Accessor], list[BufferView], bytes]

Build the GlTF structure that corresponds to a triangulated mesh.

The mesh is represented as numpy arrays as follows:

• a 3D-point array;

• a triangle array, where points are identified by their positional ID in the 3D-point array.

See https://gitlab.com/dodgyville/pygltflib/ (section “Create a mesh, convert to bytes, convert back to mesh”).

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_numpy_arrays()
    • B3dm.from_primitives()
    • B3dm.sync()
  • B3dmBody
    • B3dmBody.from_array()
    • B3dmBody.from_gltf()
    • B3dmBody.from_primitives()
    • 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.constants module
• 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
  • GltfPrimitive
  • get_component_type_from_dtype()
  • gltf_component_from_primitive()
  • 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()
    • TileContent.to_hex_str()
  • 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()