micress-micpy 0.3.2b0__py3-none-any.whl → 0.4.0a1__py3-none-any.whl

micpy/MicressBinaryReader copy.py

@@ -0,0 +1,130 @@
+from __future__ import annotations
+from typing import Optional
+
+import vtk
+from vtkmodules.vtkCommonExecutionModel import vtkStreamingDemandDrivenPipeline
+from vtkmodules.util.vtkAlgorithm import VTKPythonAlgorithmBase
+
+from micpy import bin as micpy_bin
+from micpy import vtk as micpy_vtk
+
+
+CONVERT_CELL_TO_POINT = False  # keep it identical to your .vti baseline for now
+
+
+class MicressBinaryReaderLastOnly(VTKPythonAlgorithmBase):
+    def __init__(self):
+        super().__init__(nInputPorts=0, nOutputPorts=1, outputType="vtkImageData")
+        self._filename: Optional[str] = None
+        self._file: Optional[micpy_bin.File] = None
+        self._array_name = "values"
+        self._cached_meta = None  # (extent6, spacing3, origin3)
+
+    def SetFileName(self, filename: str) -> None:
+        filename = str(filename)
+        if filename == self._filename:
+            return
+        self._filename = filename
+        self._close()
+        self._cached_meta = None
+        self.Modified()
+
+    def _close(self):
+        if self._file is not None:
+            try:
+                self._file.close()
+            except Exception:
+                pass
+        self._file = None
+
+    def _open(self):
+        if self._file is None:
+            if not self._filename:
+                raise RuntimeError("No filename set.")
+            self._file = micpy_bin.File(self._filename).open()
+
+    def _get_image_and_meta(self):
+        """Read last field and return (vtkImageData, meta)."""
+        self._open()
+        field = self._file._read_field(-1)
+        image = micpy_vtk.to_image(field, name=self._array_name)
+
+        if CONVERT_CELL_TO_POINT:
+            c2p = vtk.vtkCellDataToPointData()
+            c2p.SetInputData(image)
+            c2p.PassCellDataOn()
+            c2p.Update()
+            image = c2p.GetOutput()
+
+        extent = image.GetExtent()  # 6-tuple
+        spacing = image.GetSpacing()  # 3-tuple
+        origin = image.GetOrigin()  # 3-tuple
+        meta = (
+            tuple(int(x) for x in extent),
+            tuple(float(x) for x in spacing),
+            tuple(float(x) for x in origin),
+        )
+        return image, meta
+
+    def RequestInformation(self, request, inInfo, outInfo):
+        if not self._filename:
+            return 1
+
+        # Cache metadata once so ParaView knows bounds/extents BEFORE RequestData renders.
+        if self._cached_meta is None:
+            _, self._cached_meta = self._get_image_and_meta()
+
+        extent, spacing, origin = self._cached_meta
+        info = outInfo.GetInformationObject(0)
+
+        # This is the critical piece for vtkImageData visibility in ParaView.
+        info.Set(vtkStreamingDemandDrivenPipeline.WHOLE_EXTENT(), extent, 6)
+
+        # These help ParaView compute bounds correctly.
+        info.Set(vtk.vtkDataObject.SPACING(), spacing, 3)
+        info.Set(vtk.vtkDataObject.ORIGIN(), origin, 3)
+
+        return 1
+
+    def RequestData(self, request, inInfo, outInfo):
+        image, meta = self._get_image_and_meta()
+        extent, spacing, origin = meta
+
+        output = vtk.vtkImageData.GetData(outInfo, 0)
+
+        # Copy structure & arrays explicitly (ParaView-friendly)
+        output.SetExtent(extent)
+        output.SetSpacing(spacing)
+        output.SetOrigin(origin)
+        output.AllocateScalars(image.GetScalarType(), 0)  # no default scalars
+
+        output.GetPointData().ShallowCopy(image.GetPointData())
+        output.GetCellData().ShallowCopy(image.GetCellData())
+        output.Modified()
+        return 1
+
+
+# --- ParaView registration ---
+try:
+    from paraview.util.vtkAlgorithm import smproxy, smproperty, smdomain
+except Exception:
+    smproxy = smproperty = smdomain = None
+
+if smproxy is not None:
+
+    @smproxy.reader(
+        name="MicressBinaryReaderLastOnly",
+        label="Micress Binary Reader (last only)",
+        extensions="mcr mcr.gz conc1",
+        file_description="MICRESS binary files",
+    )
+    class _R(MicressBinaryReaderLastOnly):
+        @smproperty.stringvector(
+            name="FileName",
+            command="SetFileName",
+            number_of_elements=1,
+            panel_visibility="default",
+        )
+        @smdomain.filelist()
+        def FileName(self):
+            return [self._filename or ""]

micpy/MicressBinaryReader.py

@@ -0,0 +1,263 @@
+from __future__ import annotations
+
+from typing import Dict, List, Optional, Tuple
+
+import vtk
+from vtkmodules.vtkCommonExecutionModel import vtkStreamingDemandDrivenPipeline
+from vtkmodules.util.vtkAlgorithm import VTKPythonAlgorithmBase
+
+from micpy import bin as micpy_bin
+from micpy import vtk as micpy_vtk
+
+
+CONVERT_CELL_TO_POINT = False  # keep identical to your .vti behavior for now
+
+
+class MicressBinaryReader(VTKPythonAlgorithmBase):
+    """ParaView reader for MICRESS files via micpy with timestepping."""
+
+    def __init__(self):
+        super().__init__(nInputPorts=0, nOutputPorts=1, outputType="vtkImageData")
+
+        self._filename: Optional[str] = None
+        self._file: Optional[micpy_bin.File] = None
+
+        self._array_name: str = "values"
+
+        # Cached metadata for ParaView (critical for vtkImageData)
+        self._cached_meta: Optional[
+            Tuple[
+                Tuple[int, int, int, int, int, int],
+                Tuple[float, float, float],
+                Tuple[float, float, float],
+            ]
+        ] = None  # (extent6, spacing3, origin3)
+
+        # Time indexing
+        self._times: List[float] = []
+        self._time_to_index: Dict[float, int] = {}
+
+    # --- ParaView properties ---
+
+    def SetFileName(self, filename: str) -> None:
+        filename = str(filename)
+        if filename == self._filename:
+            return
+        self._filename = filename
+        self._reset()
+        self.Modified()
+
+    def SetArrayName(self, name: str) -> None:
+        name = str(name) if name else "values"
+        if name == self._array_name:
+            return
+        self._array_name = name
+        self.Modified()
+
+    # --- internal ---
+
+    def _reset(self) -> None:
+        if self._file is not None:
+            try:
+                self._file.close()
+            except Exception:
+                pass
+        self._file = None
+        self._cached_meta = None
+        self._times = []
+        self._time_to_index = {}
+
+    def _open(self) -> None:
+        if self._file is None:
+            if not self._filename:
+                raise RuntimeError("No filename set.")
+            self._file = micpy_bin.File(self._filename).open()
+
+    def _ensure_meta(self) -> None:
+        """Cache extent/spacing/origin once (needed by ParaView to render ImageData)."""
+        if self._cached_meta is not None:
+            return
+        self._open()
+
+        # Use a single field to compute the image geometry.
+        # (Assumes geometry is constant across timesteps, which is typical for MICRESS.)
+        field0 = self._file._read_field(0)
+        image0 = micpy_vtk.to_image(field0, name=self._array_name)
+
+        if CONVERT_CELL_TO_POINT:
+            c2p = vtk.vtkCellDataToPointData()
+            c2p.SetInputData(image0)
+            c2p.PassCellDataOn()
+            c2p.Update()
+            image0 = c2p.GetOutput()
+
+        extent = tuple(int(x) for x in image0.GetExtent())
+        spacing = tuple(float(x) for x in image0.GetSpacing())
+        origin = tuple(float(x) for x in image0.GetOrigin())
+
+        self._cached_meta = (extent, spacing, origin)
+
+    def _ensure_times(self) -> None:
+        if self._times:
+            return
+        self._open()
+
+        times: List[float] = []
+        time_to_index: Dict[float, int] = {}
+
+        i = 0
+        while True:
+            try:
+                fld = self._file._read_field(i)
+            except (IndexError, EOFError):
+                break
+
+            tt = float(fld.time)
+            times.append(tt)
+            if tt not in time_to_index:
+                time_to_index[tt] = i
+            i += 1
+
+        self._times = times
+        self._time_to_index = time_to_index
+
+        # Temporary debug (prints to ParaView output console)
+        print(
+            "MicressBinaryReader: discovered",
+            len(self._times),
+            "timesteps:",
+            self._times,
+        )
+
+    def _get_index_for_requested_time(
+        self, req_t: Optional[float]
+    ) -> Tuple[int, float]:
+        """Return (index, chosen_time) where chosen_time is exactly one of self._times."""
+        self._ensure_times()
+
+        if not self._times:
+            return 0, 0.0
+
+        if req_t is None:
+            chosen_t = self._times[0]
+            return 0, float(chosen_t)
+
+        # Choose nearest actual timestep
+        req_t = float(req_t)
+        chosen_t = min(self._times, key=lambda x: abs(x - req_t))
+        idx = self._time_to_index.get(chosen_t)
+        if idx is None:
+            # Fallback if mapping policy changed / duplicates: linear search
+            idx = self._times.index(chosen_t)
+        return int(idx), float(chosen_t)
+
+    def _read_image_at_index(self, idx: int) -> vtk.vtkImageData:
+        """Read field idx and convert to vtkImageData."""
+        self._open()
+        field = self._file._read_field(idx)
+        image = micpy_vtk.to_image(field, name=self._array_name)
+
+        if CONVERT_CELL_TO_POINT:
+            c2p = vtk.vtkCellDataToPointData()
+            c2p.SetInputData(image)
+            c2p.PassCellDataOn()
+            c2p.Update()
+            image = c2p.GetOutput()
+
+        return image
+
+    # --- VTK pipeline ---
+
+    def RequestInformation(self, request, inInfo, outInfo):
+        if not self._filename:
+            return 1
+
+        self._ensure_meta()
+        self._ensure_times()
+
+        info = outInfo.GetInformationObject(0)
+
+        # Required for ImageData to render correctly in ParaView
+        extent, spacing, origin = self._cached_meta
+        info.Set(vtkStreamingDemandDrivenPipeline.WHOLE_EXTENT(), extent, 6)
+        info.Set(vtk.vtkDataObject.SPACING(), spacing, 3)
+        info.Set(vtk.vtkDataObject.ORIGIN(), origin, 3)
+
+        # Timesteps
+        if self._times:
+            ts = [float(x) for x in self._times]
+            vtkStreamingDemandDrivenPipeline.TIME_STEPS().Set(info, ts, len(ts))
+
+            tr = [float(min(ts)), float(max(ts))]
+            vtkStreamingDemandDrivenPipeline.TIME_RANGE().Set(info, tr, 2)
+
+        return 1
+
+    def RequestData(self, request, inInfo, outInfo):
+        if not self._filename:
+            raise RuntimeError("No filename set.")
+
+        self._ensure_meta()
+
+        info = outInfo.GetInformationObject(0)
+        output = vtk.vtkImageData.GetData(outInfo, 0)
+
+        req_t = None
+        if info.Has(vtkStreamingDemandDrivenPipeline.UPDATE_TIME_STEP()):
+            req_t = float(info.Get(vtkStreamingDemandDrivenPipeline.UPDATE_TIME_STEP()))
+
+        idx, chosen_t = self._get_index_for_requested_time(req_t)
+        image = self._read_image_at_index(idx)
+
+        # Copy structure + arrays explicitly (ParaView-friendly)
+        extent, spacing, origin = self._cached_meta
+        output.SetExtent(extent)
+        output.SetSpacing(spacing)
+        output.SetOrigin(origin)
+        output.AllocateScalars(image.GetScalarType(), 0)  # no default scalars
+
+        output.GetPointData().ShallowCopy(image.GetPointData())
+        output.GetCellData().ShallowCopy(image.GetCellData())
+        output.Modified()
+
+        # Crucial: report the exact time step we produced (avoids "0.00 (?)")
+        output.GetInformation().Set(vtk.vtkDataObject.DATA_TIME_STEP(), float(chosen_t))
+
+        return 1
+
+
+# ---- ParaView registration ----
+try:
+    from paraview.util.vtkAlgorithm import smproxy, smproperty, smdomain
+except Exception:
+    smproxy = smproperty = smdomain = None
+
+if smproxy is not None:
+
+    @smproxy.reader(
+        name="MicressBinaryReader",
+        label="Micress Binary Reader (micpy)",
+        extensions="mcr mcr.gz conc1",
+        file_description="MICRESS binary files",
+    )
+    class _MicressBinaryReader(MicressBinaryReader):
+
+        @smproperty.stringvector(
+            name="FileName",
+            command="SetFileName",
+            number_of_elements=1,
+            panel_visibility="default",
+        )
+        @smdomain.filelist()
+        def FileName(self):
+            return [self._filename or ""]
+
+        # Optional; remove if you want it even more minimal
+        @smproperty.stringvector(
+            name="ArrayName",
+            command="SetArrayName",
+            number_of_elements=1,
+            default_values=["values"],
+        )
+        def ArrayName(self):
+            return [self._array_name]

micpy/__init__.py

@@ -1,6 +1,3 @@
 from .version import __version__
-from .matplotlib import configure as configure_matplotlib
 
 __all__ = ["__version__"]
-
-configure_matplotlib()