volsegtools 0.0.0__tar.gz

volsegtools-0.0.0/PKG-INFO

@@ -0,0 +1,22 @@
+Metadata-Version: 2.4
+Name: volsegtools
+Version: 0.0.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: dask
+Requires-Dist: dask_image
+Requires-Dist: zarr
+Requires-Dist: numpy
+Requires-Dist: mrcfile
+Requires-Dist: nibabel
+Requires-Dist: pydantic
+Requires-Dist: typer
+Requires-Dist: ciftools
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+
+# Volseg Tools
+
+A library used for preprocessing of volumes and segmentations for further usage.

volsegtools-0.0.0/README.md

@@ -0,0 +1,3 @@
+# Volseg Tools
+
+A library used for preprocessing of volumes and segmentations for further usage.

volsegtools-0.0.0/pyproject.toml

@@ -0,0 +1,48 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "volsegtools"
+version = "0.0.0"
+authors = [
+]
+description = ""
+readme = "README.md"
+requires-python = ">=3.9"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+dependencies = [
+    "dask",
+    "dask_image",
+    "zarr",
+    "numpy",
+    "mrcfile",
+    "nibabel",
+    "pydantic",
+    "typer",
+    "ciftools",
+]
+
+[tool.setuptools]
+packages = [
+    "volsegtools",
+    "volsegtools.core",
+    "volsegtools.model",
+    "volsegtools.downsampler",
+    "volsegtools.converter",
+    "volsegtools.abc",
+    "volsegtools.preprocessor",
+    "volsegtools.serialization",
+    "volsegtools._cli", # FIX: this shouldn't be exported
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest"
+]
+
+[project.scripts]
+molstar-preprocessor = 'volsegtools._cli:app'

volsegtools-0.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

volsegtools-0.0.0/tests/test_lazy_data_reference.py

@@ -0,0 +1,9 @@
+import numpy as np
+import pytest
+
+from volsegtools.model import LazyDataReference
+
+
+def test_lazy_ref_from_np_arr():
+    arr = np.arange(10)
+    ref = LazyDataReference(arr)

volsegtools-0.0.0/tests/test_vector.py

@@ -0,0 +1,8 @@
+import volsegtools.core as vst
+
+
+def test_vector():
+    vec = vst.Vector3()
+    assert hasattr(vec, 'x')
+    assert hasattr(vec, 'y')
+    assert hasattr(vec, 'z')

volsegtools-0.0.0/volsegtools/_cli/__init__.py

@@ -0,0 +1 @@
+from .molstar_preprocessor import app

volsegtools-0.0.0/volsegtools/_cli/molstar_preprocessor.py

@@ -0,0 +1,79 @@
+import logging
+import os
+import shutil
+import sys
+from pathlib import Path
+from typing import List
+
+import typer
+from typing_extensions import Annotated
+
+from volsegtools.converter import MapConverter
+from volsegtools.core import DownsamplingParameters, LatticeKind
+
+# TODO: parameters should (and can be) moved to the downsampler package
+from volsegtools.downsampler import HierarchyDownsampler
+from volsegtools.model.working_store import WorkingStore
+from volsegtools.preprocessor import Preprocessor, PreprocessorBuilder
+
+app = typer.Typer()
+
+
+@app.command()
+def run(
+    volume_source: Annotated[
+        List[Path], typer.Option(help="Specifies a path to volumetric data.")
+    ] = [],
+    segmentation_source: Annotated[
+        List[Path], typer.Option(help="Specifies a path to segmentation data.")
+    ] = [],
+    workdir: Annotated[
+        Path,
+        typer.Option(help="Remove temporal Zarr store created during downsampling."),
+    ] = Path.cwd(),
+    rm_tmp: Annotated[
+        bool,
+        typer.Option(help="Remove temporal Zarr store created during downsampling."),
+    ] = False,
+    overwrite_tmp: Annotated[
+        bool, typer.Option(help="Overwrite temporal Zarr store if present.")
+    ] = False,
+):
+    if len(sys.argv) < 2:
+        raise RuntimeError("Not enough arguments!")
+
+    logging.basicConfig(format="%(levelname)s:%(message)s", level=logging.INFO)
+
+    # TODO: this could be stored in the /tmp directory...
+    local_store_path = workdir / "volsegtools_workdir"
+    if overwrite_tmp and local_store_path.exists():
+        shutil.rmtree(local_store_path)
+
+    # Initialization of the singleton working store
+    # FIX: This shouldn't be necessarry
+    working_store = WorkingStore(local_store_path)
+
+    builder = PreprocessorBuilder()
+    builder.set_converter(MapConverter())
+    builder.set_downsampler(HierarchyDownsampler())
+
+    for file in volume_source:
+        logging.debug(f"Adding file: '{file}' as a volume source.")
+        builder.add_volume_src_file(file)
+
+    for file in segmentation_source:
+        logging.debug(f"Adding file: '{file}' as a segmentation source.")
+        builder.add_segmentation_src_file(file)
+
+    builder.set_output_dir(local_store_path)
+
+    try:
+        preprocessor: Preprocessor = builder.build()
+        preprocessor.sync_preprocess()
+    finally:
+        if rm_tmp and local_store_path.exists():
+            shutil.rmtree(local_store_path)
+
+
+if __name__ == "__main__":
+    app()

volsegtools-0.0.0/volsegtools/abc/__init__.py

@@ -0,0 +1,6 @@
+from .converter import Converter
+from .data_handle import DataHandle
+from .downsampler import Downsampler
+from .kernel import ConvolutionKernel
+from .preprocessor import Preprocessor
+from .serializer import Serializer

volsegtools-0.0.0/volsegtools/abc/converter.py

@@ -0,0 +1,69 @@
+import abc
+from pathlib import Path
+from typing import Any
+
+from volsegtools.abc import DataHandle
+
+
+class Converter(abc.ABC):
+    """Converts the contents of some file format into the internal data
+    structure that is then going to be used further in the processing.
+    """
+
+    @staticmethod
+    @abc.abstractmethod
+    async def transform_volume(input_path: Path) -> DataHandle:
+        """Transforms volumetric data into a zarr array.
+
+        Parameters
+        ----------
+        input_path: Path
+            Path to the transformation target.
+
+        Returns
+        -------
+        Lazy reference to the binary blob data.
+        """
+        ...
+
+    @staticmethod
+    @abc.abstractmethod
+    async def transform_segmentation(input_path: Path) -> DataHandle:
+        """Transforms the segmentation data into a zarr array.
+
+        Parameters
+        ----------
+        input_path: Path
+            Path to the transformation target.
+        """
+        ...
+
+    @staticmethod
+    @abc.abstractmethod
+    async def collect_metadata(input_path) -> Any:
+        """Collects metadata from a file.
+
+        Parameters
+        ----------
+        input_path: Path
+            Path to the transformation target.
+        internal_data: Data
+            Reference to the internal representation of the output. It is
+            going to be changed by this method.
+        """
+        pass
+
+    @staticmethod
+    @abc.abstractmethod
+    async def collect_annotations(input_path) -> Any:
+        """Collects annotations from a file.
+
+        Parameters
+        ----------
+        input_path: Path
+            Path to the transformation target.
+        internal_data: Data
+            Reference to the internal representation of the output. It is
+            going to be changed by this method.
+        """
+        pass

volsegtools-0.0.0/volsegtools/abc/data_handle.py

@@ -0,0 +1,24 @@
+import abc
+from typing import Any
+
+from numpy.typing import ArrayLike
+
+
+class DataHandle(abc.ABC):
+    @abc.abstractmethod
+    def access(self) -> ArrayLike:
+        raise NotImplementedError()
+
+    @abc.abstractmethod
+    def unwrap(self, target: str) -> ArrayLike:
+        raise NotImplementedError()
+
+    @property
+    @abc.abstractmethod
+    def metadata(self) -> Any:
+        raise NotImplementedError()
+
+    @metadata.setter
+    @abc.abstractmethod
+    def metadata(self, new_metadata: Any) -> None:
+        raise NotImplementedError()

volsegtools-0.0.0/volsegtools/abc/downsampler.py

@@ -0,0 +1,26 @@
+import abc
+from typing import Any, List
+
+from volsegtools.abc import DataHandle
+
+
+class Downsampler(abc.ABC):
+    @property
+    def parameters(self) -> Any: ...
+
+    @abc.abstractmethod
+    async def downsample_lattice(self, data: DataHandle) -> List[DataHandle]:
+        """Downsamples the provided lattice.
+
+        The lattice is changed in place and only a reference to the same data
+        array is returned.
+
+        Parameters
+        ----------
+        name: str
+            Name of the lattice that should be previously stored in the lattice
+
+        Returns
+        -------
+        """
+        ...

volsegtools-0.0.0/volsegtools/abc/kernel.py

@@ -0,0 +1,8 @@
+import abc
+
+import numpy as np
+
+
+class ConvolutionKernel(abc.ABC):
+    @abc.abstractmethod
+    def as_ndarray(self) -> np.ndarray: ...

volsegtools-0.0.0/volsegtools/abc/preprocessor.py

@@ -0,0 +1,38 @@
+import abc
+from typing import Any
+
+
+class Preprocessor(abc.ABC):
+    """Processes"""
+
+    @abc.abstractmethod
+    async def transform_volume(self):
+        pass
+
+    @abc.abstractmethod
+    async def transform_segmentation(self):
+        pass
+
+    @abc.abstractmethod
+    async def collect_metadata(self):
+        pass
+
+    @abc.abstractmethod
+    async def collect_annotation(self):
+        pass
+
+    @abc.abstractmethod
+    async def downsample(self):
+        pass
+
+    @abc.abstractmethod
+    async def get_results(self) -> Any:
+        pass
+
+    @abc.abstractmethod
+    async def preprocess(self):
+        pass
+
+    @abc.abstractmethod
+    def sync_preprocess(self):
+        pass

volsegtools-0.0.0/volsegtools/abc/serializer.py

@@ -0,0 +1,12 @@
+import abc
+from pathlib import Path
+
+from volsegtools.abc.data_handle import DataHandle
+
+
+class Serializer(abc.ABC):
+    """Serializes the provided array-like data into some data format."""
+
+    @staticmethod
+    @abc.abstractmethod
+    async def serialize(data: DataHandle, output_path: Path) -> None: ...

volsegtools-0.0.0/volsegtools/converter/__init__.py

@@ -0,0 +1 @@
+from .map_converter import MapConverter

volsegtools-0.0.0/volsegtools/converter/map_converter.py

@@ -0,0 +1,148 @@
+from pathlib import Path
+
+import dask.array as da
+import mrcfile
+import numpy as np
+
+from volsegtools.abc import Converter
+from volsegtools.core import LatticeKind, Vector3
+from volsegtools.model import StoringParameters, TimeFrameMetadata
+from volsegtools.model.opaque_data_handle import OpaqueDataHandle
+from volsegtools.model.working_store import WorkingStore
+
+
+class MapConverter(Converter):
+    @staticmethod
+    def _normalize_axis_order(data: da.Array, header: np.recarray) -> da.Array:
+        """Normalizes the order of axes in the data to (x, y, z).
+
+        Due to the fact that we use column order we have to transpose
+        the array in the end.
+
+        Parameters
+        ----------
+        data: da.Array
+            MCR file data with any order of axes.
+        header: np.recarray
+            The of the file from which comes the data.
+
+        Returns
+        -------
+        da.Array
+            Array with normalized order of axes. It is the view to the input
+            array.
+        """
+        CORRECT_ORDER = (0, 1, 2)
+
+        current_order = tuple(
+            int(axis) - 1 for axis in [header.mapc, header.mapr, header.maps]
+        )
+
+        if tuple(current_order) != CORRECT_ORDER:
+            da.moveaxis(data, current_order, CORRECT_ORDER)
+
+        data.transpose()
+
+        return data
+
+    @staticmethod
+    async def transform_volume(input_path: Path) -> OpaqueDataHandle:
+        with mrcfile.mmap(input_path, "r+") as mrc:
+            if mrc.data is None or mrc.header is None:
+                raise RuntimeError("Failed to read data from MAP file")
+
+            array = da.from_array(mrc.data)
+            array = MapConverter._normalize_axis_order(array, mrc.header)
+            internal_data = WorkingStore.instance
+            internal_data.volume_dtype = mrc.data.dtype
+            internal_data.is_volume_dtype_set = True
+            volume_id: str = input_path.stem
+            return internal_data.store_lattice_time_frame(
+                StoringParameters(), array, volume_id
+            )
+
+    @staticmethod
+    async def transform_segmentation(input_path: Path) -> OpaqueDataHandle:
+        with mrcfile.open(input_path, "r+") as mrc:
+            if mrc.data is None or mrc.header is None:
+                raise RuntimeError("Failed to read data from MAP file")
+
+            data = da.from_array(mrc.data)
+            data = MapConverter._normalize_axis_order(data, mrc.header)
+
+            if isinstance(data.dtype, np.floating):
+                data = data.astype(np.byte)
+
+            internal_data = WorkingStore.instance
+
+            internal_data.volume_dtype = data.dtype
+            internal_data.is_volume_dtype_set = True
+
+            segmentation_id: str = input_path.stem
+
+            storing_params = StoringParameters()
+            storing_params.storage_dtype = data.dtype
+            storing_params.lattice_kind = LatticeKind.SEGMENTATION
+            return internal_data.store_lattice_time_frame(
+                storing_params, data, segmentation_id
+            )
+
+    @staticmethod
+    async def collect_annotations(input_path) -> None:
+        pass
+
+    @staticmethod
+    async def collect_metadata(input_path) -> TimeFrameMetadata:
+        with mrcfile.open(input_path, "r+") as mrc:
+            if mrc.data is None or mrc.header is None:
+                raise RuntimeError("Failed to read data from MAP file")
+            lattice_shape = Vector3(
+                int(mrc.header.nx),
+                int(mrc.header.ny),
+                int(mrc.header.nz),
+            )
+            header = mrc.header
+
+        axis_order_map = {
+            header.mapc - 1: 0,
+            header.mapr - 1: 1,
+            header.maps - 1: 2,
+        }
+
+        axis_order = Vector3(0, 1, 2)
+
+        start = (header.nxstart, header.nystart, header.nzstart)
+        start = Vector3(
+            start[axis_order_map[0]],
+            start[axis_order_map[1]],
+            start[axis_order_map[2]],
+        )
+
+        original_voxel_size = Vector3(
+            header.cella.x,
+            header.cella.y,
+            header.cella.z,
+        )
+
+        origin = Vector3(
+            start.x * original_voxel_size.x,
+            start.y * original_voxel_size.y,
+            start.z * original_voxel_size.z,
+        )
+
+        original_time_frame_metadata = TimeFrameMetadata(
+            axis_order=axis_order,
+            lattice_id=input_path.stem,
+            id=0,
+            resolution=0,
+            origin=origin,
+            lattice_dimensions=lattice_shape,
+            voxel_size=original_voxel_size,
+            # As we are not converting the first resolution to BCIF, this can
+            # be left empty.
+            channels=[],
+        )
+
+        print("Original Metadata:", original_time_frame_metadata)
+
+        return original_time_frame_metadata

volsegtools-0.0.0/volsegtools/core/__init__.py

@@ -0,0 +1,5 @@
+from .bounds import Bounds
+from .downsampling_parameters import DownsamplingParameters, to_bytes
+from .gaussian_kernel_3D import Gaussian3DKernel
+from .lattice_kind import LatticeKind
+from .vector import Vector3

volsegtools-0.0.0/volsegtools/core/bounds.py

@@ -0,0 +1,12 @@
+from typing import Optional
+
+import pydantic
+
+
+# TODO: rather use base model...
+@pydantic.dataclasses.dataclass
+class Bounds:
+    # TODO: might be int
+    # TODO: this should be generic and accept any class that support some traits
+    min: Optional[pydantic.NonNegativeFloat] = 0.0
+    max: Optional[pydantic.NonNegativeFloat] = 0.0

volsegtools-0.0.0/volsegtools/core/downsampling_parameters.py

@@ -0,0 +1,28 @@
+from typing import Optional
+
+import pydantic
+from pydantic import ConfigDict
+from pydantic.dataclasses import dataclass
+
+from volsegtools.abc.kernel import ConvolutionKernel
+from volsegtools.core import Bounds, Gaussian3DKernel
+
+
+def _minimal_size_bounds_factory():
+    return Bounds(5.0, None)
+
+
+@dataclass(config=ConfigDict(arbitrary_types_allowed=True))
+class DownsamplingParameters:
+    downsampling_level_bounds: Optional[Bounds] = None
+    should_remove_original_resolution: bool = False
+    is_mask: bool = False
+    acceptance_threshold: Optional[pydantic.PositiveFloat] = None
+    kernel: ConvolutionKernel = Gaussian3DKernel(5, 1.0)
+    size_per_level_bounds_in_mb: Bounds = pydantic.Field(
+        default_factory=_minimal_size_bounds_factory
+    )
+
+
+def to_bytes(megabytes: int):
+    return megabytes * 10**6

volsegtools-0.0.0/volsegtools/core/gaussian_kernel_3D.py

@@ -0,0 +1,16 @@
+import numpy as np
+
+from volsegtools.abc import ConvolutionKernel
+
+
+class Gaussian3DKernel(ConvolutionKernel):
+    """Generate a 3D Gaussian kernel."""
+
+    def __init__(self, size: int, sigma: float):
+        ax = np.linspace(-(size // 2), size // 2, size)
+        xx, yy, zz = np.meshgrid(ax, ax, ax, indexing="ij")
+        kernel = np.exp(-(xx**2 + yy**2 + zz**2) / (2.0 * sigma**2))
+        self._kernel_lattice = kernel / np.sum(kernel)
+
+    def as_ndarray(self) -> np.ndarray:
+        return self._kernel_lattice

volsegtools-0.0.0/volsegtools/core/lattice_kind.py

@@ -0,0 +1,8 @@
+import enum
+
+
+class LatticeKind(enum.Enum):
+    """ """
+
+    VOLUME = 1
+    SEGMENTATION = 2

volsegtools-0.0.0/volsegtools/core/vector.py

@@ -0,0 +1,9 @@
+import dataclasses
+
+
+# TODO: rather use pydantic
+@dataclasses.dataclass
+class Vector3:
+    x: float = 0
+    y: float = 0
+    z: float = 0

volsegtools-0.0.0/volsegtools/downsampler/__init__.py

@@ -0,0 +1,2 @@
+from .base_downsampler import BaseDownsampler
+from .hierarchy_downsampler import HierarchyDownsampler

volsegtools-0.0.0/volsegtools/downsampler/base_downsampler.py

@@ -0,0 +1,20 @@
+from typing import List
+
+from volsegtools.abc.downsampler import Downsampler
+from volsegtools.core.downsampling_parameters import DownsamplingParameters
+from volsegtools.model.opaque_data_handle import OpaqueDataHandle
+
+
+class BaseDownsampler(Downsampler):
+    # TODO: There shouldn't be any of this, this is just interface...
+    def __init__(self, parameters: DownsamplingParameters):
+        self._parameters = parameters
+        self.data = None
+
+    @property
+    def parameters(self) -> DownsamplingParameters:
+        return self._parameters
+
+    async def downsample_lattice(
+        self, _: OpaqueDataHandle
+    ) -> List[OpaqueDataHandle]: ...