subsurface-terra 2025.1.0rc15__py3-none-any.whl → 2025.1.0rc16__py3-none-any.whl

subsurface/modules/writer/to_rex/material_encoder.py

@@ -1,44 +1,44 @@
-from subsurface.writer.to_rex.common import write_data_block_header, encode
-from subsurface.writer.to_rex.data_struct import RexMaterial
-
-
-__all__ = ['material_encode', 'write_material_data']
-
-
-def material_encode(rex_material: RexMaterial, data_id: int):
-    # Write data block header for Material
-    data_header_bytes = write_data_block_header(
-        data_type=5,  # Material data type
-        version_data=1,  # Version. Probably useful for operation counter
-        size_data=68,  # Size of the block is FIXED
-        data_id=data_id  # self.data_id
-    )
-
-    # Write Material
-    material_bytes = write_material_data(rex_material)
-    rex_bytes = data_header_bytes + material_bytes
-    return rex_bytes
-
-
-def write_material_data(rex_material: RexMaterial):
-    """Writes a standard material definition block
-
-    Returns: bytes (size:68) representation of the material
-
-    """
-    input_ = [(rex_material.ka_red, 'float32'),
-              (rex_material.ka_green, 'float32'),
-              (rex_material.ka_blue, 'float32'),
-              (rex_material.ka_texture_ID, 'uint64'),
-              (rex_material.ks_red, 'float32'),
-              (rex_material.ks_green, 'float32'),
-              (rex_material.ks_blue, 'float32'),
-              (rex_material.ks_texture_ID, 'uint64'),
-              (rex_material.kd_red, 'float32'),
-              (rex_material.kd_green, 'float32'),
-              (rex_material.kd_blue, 'float32'),
-              (rex_material.kd_texture_ID, 'uint64'),
-              (rex_material.ns, 'float32'),
-              (rex_material.alpha, 'float32')]
-    block_bytes = encode(input_)
-    return block_bytes
+from subsurface.writer.to_rex.common import write_data_block_header, encode
+from subsurface.writer.to_rex.data_struct import RexMaterial
+
+
+__all__ = ['material_encode', 'write_material_data']
+
+
+def material_encode(rex_material: RexMaterial, data_id: int):
+    # Write data block header for Material
+    data_header_bytes = write_data_block_header(
+        data_type=5,  # Material data type
+        version_data=1,  # Version. Probably useful for operation counter
+        size_data=68,  # Size of the block is FIXED
+        data_id=data_id  # self.data_id
+    )
+
+    # Write Material
+    material_bytes = write_material_data(rex_material)
+    rex_bytes = data_header_bytes + material_bytes
+    return rex_bytes
+
+
+def write_material_data(rex_material: RexMaterial):
+    """Writes a standard material definition block
+
+    Returns: bytes (size:68) representation of the material
+
+    """
+    input_ = [(rex_material.ka_red, 'float32'),
+              (rex_material.ka_green, 'float32'),
+              (rex_material.ka_blue, 'float32'),
+              (rex_material.ka_texture_ID, 'uint64'),
+              (rex_material.ks_red, 'float32'),
+              (rex_material.ks_green, 'float32'),
+              (rex_material.ks_blue, 'float32'),
+              (rex_material.ks_texture_ID, 'uint64'),
+              (rex_material.kd_red, 'float32'),
+              (rex_material.kd_green, 'float32'),
+              (rex_material.kd_blue, 'float32'),
+              (rex_material.kd_texture_ID, 'uint64'),
+              (rex_material.ns, 'float32'),
+              (rex_material.alpha, 'float32')]
+    block_bytes = encode(input_)
+    return block_bytes

subsurface/modules/writer/to_rex/mesh_encoder.py

@@ -1,152 +1,152 @@
-from subsurface.writer.to_rex.common import mesh_header_size, \
-    write_data_block_header, encode
-from subsurface.writer.to_rex.data_struct import RexMesh
-
-
-__all__ = ['mesh_encode', 'write_mesh_coordinates', 'write_mesh_header']
-
-
-def mesh_encode(rex_mesh: RexMesh, data_id: int):
-    material_id = rex_mesh.material_id
-    n_vtx_coord = rex_mesh.n_vtx
-    n_triangles = rex_mesh.n_triangles
-    n_vtx_colors = rex_mesh.n_color
-    surface_name = rex_mesh.name
-    ver_ravel = rex_mesh.ver_ravel
-    tri_ravel = rex_mesh.tri_ravel
-    c_r = rex_mesh.color_ravel
-
-    # Write Mesh block - header
-    mesh_header_bytes = write_mesh_header(
-        n_vtx_coord / 3, n_triangles / 3,
-        n_vtx_colors=n_vtx_colors / 3,
-        start_vtx_coord=mesh_header_size,
-        start_nor_coord=mesh_header_size + n_vtx_coord * 4,
-        start_tex_coord=mesh_header_size + n_vtx_coord * 4,
-        start_vtx_colors=mesh_header_size + n_vtx_coord * 4,
-        start_triangles=mesh_header_size +
-                        ((n_vtx_coord + n_vtx_colors) * 4),
-        name=surface_name,
-        material_id=material_id  # self.data_id + surface_df.shape[0]
-    )
-
-    # Write Mesh block - Vertex, triangles
-    mesh_block_bytes = write_mesh_coordinates(ver_ravel,
-                                              tri_ravel,
-                                              colors=c_r  # When using
-                                              # material we can avoid this
-                                              )
-
-    # Calculate the size of the mesh block
-    mesh_block_size_no_data_block_header = len(mesh_header_bytes) + \
-                                           len(mesh_block_bytes)  # This is cte 128
-
-    # Write data block header for Mesh 1
-    data_header_bytes = write_data_block_header(
-        size_data=mesh_block_size_no_data_block_header,
-        data_id=data_id,
-        data_type=3,  # 3 for mesh
-        version_data=1  # Probably useful for counting
-        # the operation number
-    )
-
-    rex_bytes = data_header_bytes + mesh_header_bytes + mesh_block_bytes
-    return rex_bytes
-
-
-def write_mesh_coordinates(vertex, triangles, normal=None, texture=None,
-                           colors=None):
-    """Block with the coordinates of a mesh. This has to go with a header!
-
-    Args:
-        vertex (numpy.ndarray[float32]): Array of vertex XYZXYZ...
-        triangles (numpy.ndarray[int32]): This is a list of integers which form
-         one triangle. Please make sure that normal and texture coordinates are inline with the
-         vertex coordinates. One index refers to the same normal and texture position. The
-         triangle orientation is required to be counter-clockwise (CCW)
-        normal (numpy.ndarray):
-        texture (numpy.ndarray):
-        colors (numpy.ndarray):
-
-    Returns:
-
-    """
-
-    # ver = vertex.ravel()
-    # tri = triangles.ravel()
-    if normal is None:
-        normal = []
-    if texture is None:
-        texture = []
-    if colors is None:
-        colors = []
-
-    input_ = [(vertex, 'float32'),
-              (normal, 'float32'),
-              (texture, 'float32'),
-              (colors, 'float32'),
-              (triangles, 'uint32')]
-
-    block_bytes = encode(input_)
-    return block_bytes
-
-
-def write_mesh_header(n_vtx_coord, n_triangles,
-                      start_vtx_coord, start_nor_coord, start_tex_coord,
-                      start_vtx_colors,
-                      start_triangles,
-                      name, material_id=1,  # material_id=9223372036854775807
-                      n_nor_coord=0, n_tex_coord=0, n_vtx_colors=0,
-                      lod=1, max_lod=1):
-    """Function to write MESH DATA BLOCK header. The header size is fixed at 128 bytes.
-
-    Args:
-        n_vtx_coord: number of vertex coordinates
-        n_triangles: number of triangles
-        start_vtx_coord: start vertex coordinate block (relative to mesh block start)
-        start_nor_coord: start vertex normals block (relative to mesh block start)
-        start_tex_coord: start of texture coordinate block (relative to mesh block start)
-        start_vtx_colors: start of colors block (relative to mesh block start)
-        start_triangles: start triangle block for vertices (relative to mesh block start)
-        name (str): Name of the mesh
-        material_id (int):  id which refers to the corresponding material block in this file
-        n_nor_coord:  number of normal coordinates (can be zero)
-        n_tex_coord:  number of texture coordinates (can be zero)
-        n_vtx_colors: number of vertex colors (can be zero)
-        lod (int): level of detail for the given geometry
-        max_lod (int): maximal level of detail for given geometry
-
-    Returns:
-        bytes: array of bytes
-    """
-
-    # Strings are immutable so there is no way to modify them in place
-    str_size = len(name)  # Size of the actual name of the mesh
-    rest_name = ' ' * (74 - str_size)  #
-    full_name = name + rest_name
-
-    input_ = [([lod, max_lod], 'uint16'),  # Level of detail
-              ([n_vtx_coord,  # number of vertex coordinates
-                n_nor_coord,  # number of normal coordinates (can be zero)
-                n_tex_coord,  # number of texture coordinates (can be zero)
-                n_vtx_colors,  # number of vertex colors (can be zero)
-                n_triangles,  # number of triangles
-                start_vtx_coord,
-                # start vertex coordinate block (relative to mesh block start)
-                start_nor_coord,
-                # start vertex normals block (relative to mesh block start)
-                start_tex_coord,
-                # start of texture coordinate block (relative to mesh block start)
-                start_vtx_colors,
-                # start of colors block (relative to mesh block start)
-                start_triangles
-                # start triangle block for vertices (relative to mesh block start)
-                ],
-               'uint32'),
-              (material_id, 'uint64'),
-              # id which refers to the corresponding material block in this file
-              (str_size, 'uint16'),  # size of the following string name
-              (full_name, 'bytes')]  # name of the mesh (this is user-readable)
-
-    block_bytes = encode(input_)
-    return block_bytes
+from subsurface.writer.to_rex.common import mesh_header_size, \
+    write_data_block_header, encode
+from subsurface.writer.to_rex.data_struct import RexMesh
+
+
+__all__ = ['mesh_encode', 'write_mesh_coordinates', 'write_mesh_header']
+
+
+def mesh_encode(rex_mesh: RexMesh, data_id: int):
+    material_id = rex_mesh.material_id
+    n_vtx_coord = rex_mesh.n_vtx
+    n_triangles = rex_mesh.n_triangles
+    n_vtx_colors = rex_mesh.n_color
+    surface_name = rex_mesh.name
+    ver_ravel = rex_mesh.ver_ravel
+    tri_ravel = rex_mesh.tri_ravel
+    c_r = rex_mesh.color_ravel
+
+    # Write Mesh block - header
+    mesh_header_bytes = write_mesh_header(
+        n_vtx_coord / 3, n_triangles / 3,
+        n_vtx_colors=n_vtx_colors / 3,
+        start_vtx_coord=mesh_header_size,
+        start_nor_coord=mesh_header_size + n_vtx_coord * 4,
+        start_tex_coord=mesh_header_size + n_vtx_coord * 4,
+        start_vtx_colors=mesh_header_size + n_vtx_coord * 4,
+        start_triangles=mesh_header_size +
+                        ((n_vtx_coord + n_vtx_colors) * 4),
+        name=surface_name,
+        material_id=material_id  # self.data_id + surface_df.shape[0]
+    )
+
+    # Write Mesh block - Vertex, triangles
+    mesh_block_bytes = write_mesh_coordinates(ver_ravel,
+                                              tri_ravel,
+                                              colors=c_r  # When using
+                                              # material we can avoid this
+                                              )
+
+    # Calculate the size of the mesh block
+    mesh_block_size_no_data_block_header = len(mesh_header_bytes) + \
+                                           len(mesh_block_bytes)  # This is cte 128
+
+    # Write data block header for Mesh 1
+    data_header_bytes = write_data_block_header(
+        size_data=mesh_block_size_no_data_block_header,
+        data_id=data_id,
+        data_type=3,  # 3 for mesh
+        version_data=1  # Probably useful for counting
+        # the operation number
+    )
+
+    rex_bytes = data_header_bytes + mesh_header_bytes + mesh_block_bytes
+    return rex_bytes
+
+
+def write_mesh_coordinates(vertex, triangles, normal=None, texture=None,
+                           colors=None):
+    """Block with the coordinates of a mesh. This has to go with a header!
+
+    Args:
+        vertex (numpy.ndarray[float32]): Array of vertex XYZXYZ...
+        triangles (numpy.ndarray[int32]): This is a list of integers which form
+         one triangle. Please make sure that normal and texture coordinates are inline with the
+         vertex coordinates. One index refers to the same normal and texture position. The
+         triangle orientation is required to be counter-clockwise (CCW)
+        normal (numpy.ndarray):
+        texture (numpy.ndarray):
+        colors (numpy.ndarray):
+
+    Returns:
+
+    """
+
+    # ver = vertex.ravel()
+    # tri = triangles.ravel()
+    if normal is None:
+        normal = []
+    if texture is None:
+        texture = []
+    if colors is None:
+        colors = []
+
+    input_ = [(vertex, 'float32'),
+              (normal, 'float32'),
+              (texture, 'float32'),
+              (colors, 'float32'),
+              (triangles, 'uint32')]
+
+    block_bytes = encode(input_)
+    return block_bytes
+
+
+def write_mesh_header(n_vtx_coord, n_triangles,
+                      start_vtx_coord, start_nor_coord, start_tex_coord,
+                      start_vtx_colors,
+                      start_triangles,
+                      name, material_id=1,  # material_id=9223372036854775807
+                      n_nor_coord=0, n_tex_coord=0, n_vtx_colors=0,
+                      lod=1, max_lod=1):
+    """Function to write MESH DATA BLOCK header. The header size is fixed at 128 bytes.
+
+    Args:
+        n_vtx_coord: number of vertex coordinates
+        n_triangles: number of triangles
+        start_vtx_coord: start vertex coordinate block (relative to mesh block start)
+        start_nor_coord: start vertex normals block (relative to mesh block start)
+        start_tex_coord: start of texture coordinate block (relative to mesh block start)
+        start_vtx_colors: start of colors block (relative to mesh block start)
+        start_triangles: start triangle block for vertices (relative to mesh block start)
+        name (str): Name of the mesh
+        material_id (int):  id which refers to the corresponding material block in this file
+        n_nor_coord:  number of normal coordinates (can be zero)
+        n_tex_coord:  number of texture coordinates (can be zero)
+        n_vtx_colors: number of vertex colors (can be zero)
+        lod (int): level of detail for the given geometry
+        max_lod (int): maximal level of detail for given geometry
+
+    Returns:
+        bytes: array of bytes
+    """
+
+    # Strings are immutable so there is no way to modify them in place
+    str_size = len(name)  # Size of the actual name of the mesh
+    rest_name = ' ' * (74 - str_size)  #
+    full_name = name + rest_name
+
+    input_ = [([lod, max_lod], 'uint16'),  # Level of detail
+              ([n_vtx_coord,  # number of vertex coordinates
+                n_nor_coord,  # number of normal coordinates (can be zero)
+                n_tex_coord,  # number of texture coordinates (can be zero)
+                n_vtx_colors,  # number of vertex colors (can be zero)
+                n_triangles,  # number of triangles
+                start_vtx_coord,
+                # start vertex coordinate block (relative to mesh block start)
+                start_nor_coord,
+                # start vertex normals block (relative to mesh block start)
+                start_tex_coord,
+                # start of texture coordinate block (relative to mesh block start)
+                start_vtx_colors,
+                # start of colors block (relative to mesh block start)
+                start_triangles
+                # start triangle block for vertices (relative to mesh block start)
+                ],
+               'uint32'),
+              (material_id, 'uint64'),
+              # id which refers to the corresponding material block in this file
+              (str_size, 'uint16'),  # size of the following string name
+              (full_name, 'bytes')]  # name of the mesh (this is user-readable)
+
+    block_bytes = encode(input_)
+    return block_bytes

subsurface/modules/writer/to_rex/to_rex.py

@@ -1,115 +1,115 @@
-from typing import List
-
-from subsurface.writer.to_rex.common import file_header_size, encode
-from subsurface.writer.to_rex.data_struct import RexLineSet, RexMesh, RexMaterial
-from subsurface.writer.to_rex.material_encoder import material_encode
-from subsurface.writer.to_rex.mesh_encoder import mesh_encode
-
-
-__all__ = ['numpy_to_rex', 'w_data_blocks', 'w_block_data_type',
-           'w_file_header_and_coord_system_block',
-           'w_file_header_and_coord_system_block', 'write_rex_file',
-           'read_rex_file']
-
-
-def numpy_to_rex(
-        rex_line_set: List[RexLineSet] = None,
-        rex_meshes: List[RexMesh] = None,
-        rex_material: List[RexMaterial] = None
-):
-    if rex_line_set is None:
-        rex_line_set = list()
-    if rex_meshes is None:
-        rex_meshes = list()
-    if rex_material is None:
-        rex_material = list()
-
-    data_block_bytes = bytearray()
-    byte_size = 0
-
-    data_block_bytes, data_id = w_data_blocks(rex_meshes, rex_material)
-
-    n_data_blocks = data_id
-    header_and_coord_block_bytes = w_file_header_and_coord_system_block(
-        n_data_blocks=n_data_blocks,
-        size_data_blocks=len(data_block_bytes),
-        start_data=file_header_size
-    )
-
-    return header_and_coord_block_bytes + data_block_bytes
-
-
-def w_data_blocks(rex_meshes: List[RexMesh], rex_material: List[RexMaterial]):
-    data_id = 0
-
-    rmesh_bytes, data_id = w_block_data_type(mesh_encode, rex_meshes, data_id)
-    rmaterial_bytes, data_id = w_block_data_type(material_encode, rex_material,
-                                                 data_id)
-
-    blocks_bytes = rmesh_bytes + rmaterial_bytes
-    return blocks_bytes, data_id
-
-
-def w_block_data_type(encoder, rex_objects: List, data_id: int):
-    data_block_bytes = bytearray()
-    for rex_obj in rex_objects:
-        data_block_bytes += encoder(rex_obj, data_id=data_id)
-        data_id += 1
-
-    return data_block_bytes, data_id
-
-
-def w_file_header_and_coord_system_block():
-    return
-
-
-def w_file_header_and_coord_system_block(n_data_blocks, size_data_blocks, version=1,
-                                         start_data=86, srid=3876, offsets=None):
-    """
-    Function that writes the header block of a rexfile:
-
-    Args:
-        n_data_blocks:
-        size_data_blocks:
-        version (int): Version of the file
-        start_data (int): Position where data start. This is after the header
-         and coordinate system. If everything works fine it should be 86
-        srid (int): Spatial reference system identifier (srid)
-        offsets:
-
-    Returns:
-
-    """
-    reserved = '0' * 42
-    if offsets is None:
-        offsets = [0, 0, 0]
-
-    input_ = [('REX1', 'bytes'),  # REX1
-              (version, 'uint16'),  # file version
-              (0, 'uint32'),  # CRC32
-              (n_data_blocks, 'uint16'),  # Number of DATA BLOCKS
-              (start_data, 'uint16'),  # StartData
-              (size_data_blocks, 'uint64'),  # Size of all data blocks
-              (reserved, 'bytes'),  # Reserved
-              # Coordinate system block
-              (srid, 'uint32'),  # Spatial reference system identifier (srid)
-              (4, 'uint16'),  # Size of the name of the used system.
-              ('EPSG', 'bytes'),  # name of the used system.
-              (offsets, 'float32')]  # Global x, y, z offset
-
-    block_bytes = encode(input_)
-    return block_bytes
-
-
-def write_rex_file(bytes, path: str):
-    """Write to disk a rexfile from its binary format"""
-
-    new_file = open(path + ".rex", "wb")
-    new_file.write(bytes)
-    return True
-
-
-def read_rex_file(path: str) -> bytes:
-    with open(path, "rb") as f:
-        bytes_read = f.read()
-    return bytes_read
+from typing import List
+
+from subsurface.writer.to_rex.common import file_header_size, encode
+from subsurface.writer.to_rex.data_struct import RexLineSet, RexMesh, RexMaterial
+from subsurface.writer.to_rex.material_encoder import material_encode
+from subsurface.writer.to_rex.mesh_encoder import mesh_encode
+
+
+__all__ = ['numpy_to_rex', 'w_data_blocks', 'w_block_data_type',
+           'w_file_header_and_coord_system_block',
+           'w_file_header_and_coord_system_block', 'write_rex_file',
+           'read_rex_file']
+
+
+def numpy_to_rex(
+        rex_line_set: List[RexLineSet] = None,
+        rex_meshes: List[RexMesh] = None,
+        rex_material: List[RexMaterial] = None
+):
+    if rex_line_set is None:
+        rex_line_set = list()
+    if rex_meshes is None:
+        rex_meshes = list()
+    if rex_material is None:
+        rex_material = list()
+
+    data_block_bytes = bytearray()
+    byte_size = 0
+
+    data_block_bytes, data_id = w_data_blocks(rex_meshes, rex_material)
+
+    n_data_blocks = data_id
+    header_and_coord_block_bytes = w_file_header_and_coord_system_block(
+        n_data_blocks=n_data_blocks,
+        size_data_blocks=len(data_block_bytes),
+        start_data=file_header_size
+    )
+
+    return header_and_coord_block_bytes + data_block_bytes
+
+
+def w_data_blocks(rex_meshes: List[RexMesh], rex_material: List[RexMaterial]):
+    data_id = 0
+
+    rmesh_bytes, data_id = w_block_data_type(mesh_encode, rex_meshes, data_id)
+    rmaterial_bytes, data_id = w_block_data_type(material_encode, rex_material,
+                                                 data_id)
+
+    blocks_bytes = rmesh_bytes + rmaterial_bytes
+    return blocks_bytes, data_id
+
+
+def w_block_data_type(encoder, rex_objects: List, data_id: int):
+    data_block_bytes = bytearray()
+    for rex_obj in rex_objects:
+        data_block_bytes += encoder(rex_obj, data_id=data_id)
+        data_id += 1
+
+    return data_block_bytes, data_id
+
+
+def w_file_header_and_coord_system_block():
+    return
+
+
+def w_file_header_and_coord_system_block(n_data_blocks, size_data_blocks, version=1,
+                                         start_data=86, srid=3876, offsets=None):
+    """
+    Function that writes the header block of a rexfile:
+
+    Args:
+        n_data_blocks:
+        size_data_blocks:
+        version (int): Version of the file
+        start_data (int): Position where data start. This is after the header
+         and coordinate system. If everything works fine it should be 86
+        srid (int): Spatial reference system identifier (srid)
+        offsets:
+
+    Returns:
+
+    """
+    reserved = '0' * 42
+    if offsets is None:
+        offsets = [0, 0, 0]
+
+    input_ = [('REX1', 'bytes'),  # REX1
+              (version, 'uint16'),  # file version
+              (0, 'uint32'),  # CRC32
+              (n_data_blocks, 'uint16'),  # Number of DATA BLOCKS
+              (start_data, 'uint16'),  # StartData
+              (size_data_blocks, 'uint64'),  # Size of all data blocks
+              (reserved, 'bytes'),  # Reserved
+              # Coordinate system block
+              (srid, 'uint32'),  # Spatial reference system identifier (srid)
+              (4, 'uint16'),  # Size of the name of the used system.
+              ('EPSG', 'bytes'),  # name of the used system.
+              (offsets, 'float32')]  # Global x, y, z offset
+
+    block_bytes = encode(input_)
+    return block_bytes
+
+
+def write_rex_file(bytes, path: str):
+    """Write to disk a rexfile from its binary format"""
+
+    new_file = open(path + ".rex", "wb")
+    new_file.write(bytes)
+    return True
+
+
+def read_rex_file(path: str) -> bytes:
+    with open(path, "rb") as f:
+        bytes_read = f.read()
+    return bytes_read

subsurface/modules/writer/to_rex/utils.py

@@ -1,15 +1,15 @@
-import numpy as np
-
-
-__all__ = ['hex_to_rgb', ]
-
-
-def hex_to_rgb(hex: str, normalize: bool = True) -> np.ndarray:
-    """Transform colors from hex to rgb"""
-    hex = hex.lstrip('#')
-    hlen = len(hex)
-    rgb = np.array(
-        [int(hex[i:i + hlen // 3], 16) for i in range(0, hlen, hlen // 3)])
-    if normalize is True:
-        rgb = rgb / 255
-    return rgb
+import numpy as np
+
+
+__all__ = ['hex_to_rgb', ]
+
+
+def hex_to_rgb(hex: str, normalize: bool = True) -> np.ndarray:
+    """Transform colors from hex to rgb"""
+    hex = hex.lstrip('#')
+    hlen = len(hex)
+    rgb = np.array(
+        [int(hex[i:i + hlen // 3], 16) for i in range(0, hlen, hlen // 3)])
+    if normalize is True:
+        rgb = rgb / 255
+    return rgb