test(mesh-io): python read and write point set wasi tests

Author: thewtex

packages/core/python/itkwasm/itkwasm/__init__.py

@@ -4,7 +4,7 @@
 
 from .interface_types import InterfaceTypes
 from .image import Image, ImageType, ImageRegion
-from .pointset import PointSet, PointSetType
+from .point_set import PointSet, PointSetType
 from .mesh import Mesh, MeshType
 from .transform import Transform, TransformType, TransformParameterizations
 from .polydata import PolyData, PolyDataType

packages/core/python/itkwasm/itkwasm/interface_types.py

@@ -7,6 +7,7 @@ class InterfaceTypes(str, Enum):
     BinaryStream = "BinaryStream"
     Image = "Image"
     Mesh = "Mesh"
+    PointSet = "PointSet"
     PolyData = "PolyData"
     Transform = "Transform"
     JsonCompatible = "JsonCompatible"

packages/core/python/itkwasm/itkwasm/pipeline.py

@@ -22,6 +22,7 @@
 from .binary_file import BinaryFile
 from .image import Image
 from .mesh import Mesh
+from .point_set import PointSet
 from .polydata import PolyData
 from .json_compatible import JsonCompatible
 from .int_types import IntTypes
@@ -277,6 +278,27 @@ def run(
                     "cellData": f"data:application/vnd.itk.address,0:{cell_data_ptr}",
                 }
                 ri.set_input_json(mesh_json, index)
+            elif input_.type == InterfaceTypes.PointSet:
+                point_set = input_.data
+                if point_set.numberOfPoints:
+                    pv = array_like_to_bytes(point_set.points)
+                else:
+                    pv = bytes([])
+                points_ptr = ri.set_input_array(pv, index, 0)
+                if point_set.numberOfPointPixels:
+                    pdv = array_like_to_bytes(point_set.pointData)
+                else:
+                    pdv = bytes([])
+                point_data_ptr = ri.set_input_array(pdv, index, 1)
+                point_set_json = {
+                    "pointSetType": asdict(point_set.pointSetType),
+                    "name": point_set.name,
+                    "numberOfPoints": point_set.numberOfPoints,
+                    "points": f"data:application/vnd.itk.address,0:{points_ptr}",
+                    "numberOfPointPixels": point_set.numberOfPointPixels,
+                    "pointData": f"data:application/vnd.itk.address,0:{point_data_ptr}",
+                }
+                ri.set_input_json(point_set_json, index)
             elif input_.type == InterfaceTypes.PolyData:
                 polydata = input_.data
                 if polydata.numberOfPoints:
@@ -442,6 +464,31 @@ def run(
                         mesh.cellData = buffer_to_numpy_array(mesh.meshType.cellPixelComponentType, bytes([]))
 
                     output_data = PipelineOutput(InterfaceTypes.Mesh, mesh)
+                elif output.type == InterfaceTypes.PointSet:
+                    point_set_json = ri.get_output_json(index)
+                    point_set = PointSet(**point_set_json)
+
+                    if point_set.numberOfPoints > 0:
+                        data_ptr = ri.get_output_array_address(0, index, 0)
+                        data_size = ri.get_output_array_size(0, index, 0)
+                        point_set.points = buffer_to_numpy_array(
+                            point_set.pointSetType.pointComponentType,
+                            ri.wasmtime_lift(data_ptr, data_size),
+                        )
+                    else:
+                        point_set.points = buffer_to_numpy_array(point_set.pointSetType.pointComponentType, bytes([]))
+
+                    if point_set.numberOfPointPixels > 0:
+                        data_ptr = ri.get_output_array_address(0, index, 1)
+                        data_size = ri.get_output_array_size(0, index, 1)
+                        point_set.pointData = buffer_to_numpy_array(
+                            point_set.pointSetType.pointPixelComponentType,
+                            ri.wasmtime_lift(data_ptr, data_size),
+                        )
+                    else:
+                        point_set.pointData = buffer_to_numpy_array(point_set.pointSetType.pointPixelComponentType, bytes([]))
+
+                    output_data = PipelineOutput(InterfaceTypes.PointSet, point_set)
                 elif output.type == InterfaceTypes.PolyData:
                     polydata_json = ri.get_output_json(index)
                     polydata = PolyData(**polydata_json)

packages/core/python/itkwasm/itkwasm/pointset.py renamed to packages/core/python/itkwasm/itkwasm/point_set.py

@@ -2,7 +2,7 @@
 from typing import Optional
 
 from .image import Image, ImageType
-from .pointset import PointSet, PointSetType
+from .point_set import PointSet, PointSetType
 from .mesh import Mesh, MeshType
 from .polydata import PolyData, PolyDataType
 from .binary_file import BinaryFile

packages/core/python/itkwasm/itkwasm/pyodide.py

@@ -3,6 +3,9 @@
 from .read_mesh_async import read_mesh_async
 from .write_mesh_async import write_mesh_async
 
+from .read_point_set_async import read_point_set_async
+from .write_point_set_async import write_point_set_async
+
 from .byu_read_mesh_async import byu_read_mesh_async
 from .byu_write_mesh_async import byu_write_mesh_async
 from .free_surfer_ascii_read_mesh_async import free_surfer_ascii_read_mesh_async
@@ -24,4 +27,15 @@
 from .wasm_zstd_read_mesh_async import wasm_zstd_read_mesh_async
 from .wasm_zstd_write_mesh_async import wasm_zstd_write_mesh_async
 
+from .obj_read_mesh_async import obj_read_mesh_async
+from .obj_write_mesh_async import obj_write_mesh_async
+from .off_read_mesh_async import off_read_mesh_async
+from .off_write_mesh_async import off_write_mesh_async
+from .vtk_poly_data_read_mesh_async import vtk_poly_data_read_mesh_async
+from .vtk_poly_data_write_mesh_async import vtk_poly_data_write_mesh_async
+from .wasm_read_mesh_async import wasm_read_mesh_async
+from .wasm_write_mesh_async import wasm_write_mesh_async
+from .wasm_zstd_read_mesh_async import wasm_zstd_read_mesh_async
+from .wasm_zstd_write_mesh_async import wasm_zstd_write_mesh_async
+
 from ._version import __version__

packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/__init__.py

@@ -12,5 +12,4 @@
     ('.iwm', 'wasm'),
     ('.iwm.cbor', 'wasm'),
     ('.iwm.cbor.zst', 'wasmZstd'),
-    ('.bmp', 'bmp'),
 ])

packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/extension_to_mesh_io.py

@@ -0,0 +1,10 @@
+from collections import OrderedDict
+
+extension_to_point_set_io = OrderedDict([
+    ('.vtk', 'vtkPolyData'),
+    ('.obj', 'obj'),
+    ('.off', 'off'),
+    ('.iwm', 'wasm'),
+    ('.iwm.cbor', 'wasm'),
+    ('.iwm.cbor.zst', 'wasmZstd'),
+])

packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/extension_to_point_set_io.py

@@ -0,0 +1,8 @@
+point_set_io_index = [
+    'vtk_poly_data',
+    'obj',
+    'off',
+    'wasm',
+    'wasm_zstd',
+]
+

packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/point_set_io_index.py

@@ -0,0 +1,87 @@
+import os
+from typing import Optional, Union
+from pathlib import Path
+
+from itkwasm import (
+    PointSet,
+    BinaryFile,
+)
+
+from .js_package import js_package
+
+from itkwasm.pyodide import (
+    to_js,
+    to_py,
+    js_resources
+)
+
+from .extension_to_point_set_io import extension_to_point_set_io
+from .point_set_io_index import point_set_io_index
+
+async def read_point_set_async(
+    serialized_point_set: os.PathLike,
+    information_only: bool = False,
+) -> PointSet:
+    """Read an point set file format and convert it to the ITK-Wasm file format.
+
+    :param serialized_point_set: Input point set serialized in the file format
+    :type  serialized_point_set: os.PathLike
+
+    :param information_only: Only read point set metadata -- do not read pixel data.
+    :type  information_only: bool
+
+    :return: Output point set
+    :rtype:  PointSet
+    """
+    js_module = await js_package.js_module
+    web_worker = js_resources.web_worker
+
+    kwargs = {}
+    if information_only:
+        kwargs["informationOnly"] = to_js(information_only)
+
+    extension = ''.join(Path(serialized_point_set).suffixes)
+
+    io = None
+    if extension in extension_to_point_set_io:
+        func = f"{extension_to_point_set_io[extension]}ReadPointSet"
+        io = getattr(js_module, func)
+    else:
+        for ioname in point_set_io_index:
+            func = f"{ioname}ReadPointSet"
+            io = getattr(js_module, func)
+            outputs = await io(to_js(BinaryFile(serialized_point_set)), webWorker=web_worker, noCopy=True, **kwargs)
+            outputs_object_map = outputs.as_object_map()
+            web_worker = outputs_object_map['webWorker']
+            js_resources.web_worker = web_worker
+            could_read = to_py(outputs_object_map['couldRead'])
+            if could_read:
+                point_set = to_py(outputs_object_map['point_set'])
+                return point_set
+
+    if io is None:
+        raise RuntimeError(f"Could not find an point_set reader for {extension}")
+
+    outputs = await io(to_js(BinaryFile(serialized_point_set)), webWorker=web_worker, noCopy=True, **kwargs)
+    outputs_object_map = outputs.as_object_map()
+    web_worker = outputs_object_map['webWorker']
+    could_read = to_py(outputs_object_map['couldRead'])
+
+    if not could_read:
+        raise RuntimeError(f"Could not read {serialized_point_set}")
+
+    js_resources.web_worker = web_worker
+
+    point_set = to_py(outputs_object_map['point_set'])
+
+    return point_set
+
+async def pointsetread_async(
+    serialized_point_set: os.PathLike,
+    information_only: bool = False,
+) -> PointSet:
+    return await read_point_set_async(serialized_point_set, information_only=information_only)
+
+pointsetread_async.__doc__ = f"""{read_point_set_async.__doc__}
+    Alias for read_point_set_async.
+    """