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

micpy/bin.py

@@ -1,61 +1,79 @@
 """The `micpy.bin` module provides methods to read and write binary files."""
 
-from dataclasses import dataclass
-from typing import Callable, Generator, IO, List, Optional, Tuple, Union
+import builtins
+from collections.abc import Iterator
+from pathlib import Path
+from time import time as t
+from typing import IO, List, Optional, Tuple, Union, overload
+import os
 
 import gzip
-import os
-import sys
-import zlib
+import rapidgzip
 
 import numpy as np
 
-from micpy import geo
-from micpy import utils
-from micpy.matplotlib import matplotlib, pyplot
-
-
-__all__ = ["File", "Field", "Series", "plot", "PlotArgs"]
-
-
-@dataclass
-class Chunk:
-    """A chunk of uncompressed binary data."""
-
-    DEFAULT_SIZE = 8388608
-
-    data: bytes
-    decompressobj: zlib.decompressobj = None
-
-    @staticmethod
-    def iterate(
-        file: IO[bytes],
-        chunk_size: int,
-        compressed: bool = True,
-        offset: int = 0,
-        decompressobj: zlib.decompressobj = None,
-    ) -> Generator["Chunk", None, None]:
-        """Yield chunks of uncompressed binary data."""
-        file.seek(offset)
+try:
+    import matplotlib
+    from matplotlib.axes import Axes
+    from matplotlib.figure import Figure
+    from matplotlib.colorbar import Colorbar
+    from matplotlib import pyplot
+
+    HAS_MATPLOTLIB = True
+
+    def register_colormaps():
+        colors = [
+            "#1102d8",
+            "#3007ba",
+            "#500b9d",
+            "#6f0e81",
+            "#8d1364",
+            "#ac1748",
+            "#cb1b2b",
+            "#ea1e0f",
+            "#f83605",
+            "#fa600f",
+            "#fb8817",
+            "#fdb120",
+            "#ffda29",
+            "#ffed4d",
+            "#fff380",
+            "#fffbb4",
+        ]
+
+        create = matplotlib.colors.LinearSegmentedColormap.from_list
+
+        colormap = create(name="micpy", colors=colors, N=1024)
+        colormap_r = create(name="micpy_r", colors=colors[::-1], N=1024)
+
+        register = matplotlib.colormaps.register
+        register(colormap)
+        register(colormap_r)
+
+    if not HAS_MATPLOTLIB:
+        raise ImportError("Matplotlib is not installed.")
+
+    try:
+        register_colormaps()
+    except ValueError:
+        pass
+
+except ImportError:
+    HAS_MATPLOTLIB = False
+
+try:
+    from vtk import vtkImageData, vtkXMLImageDataWriter
+    from vtkmodules.util.numpy_support import numpy_to_vtk
+    HAS_VTK = True
+except ImportError:
+    HAS_VTK = False
 
-        if decompressobj:
-            decompressobj = decompressobj.copy()
-        else:
-            decompressobj = (
-                zlib.decompressobj(zlib.MAX_WBITS | 32) if compressed else None
-            )
 
-        while True:
-            data = file.read(chunk_size)
-            if data == b"":
-                break
+from micpy import geo
+from micpy import utils
 
-            if compressed:
-                prev_decompressobj = decompressobj
-                decompressobj = prev_decompressobj.copy()
-                data = decompressobj.decompress(data)
 
-            yield Chunk(data, prev_decompressobj if compressed else None)
+__all__ = ["open", "read", "Field", "Series", "File"]
 
 
 class Footer:
@@ -102,161 +120,24 @@ class Header:
         ).tobytes()
 
     @staticmethod
-    def read(filename: str, compressed: bool = True) -> "Header":
+    def read(file: IO[bytes]) -> "Header":
         """Read the header of a binary file."""
-        file_open = gzip.open if compressed else open
-
-        with file_open(filename, "rb") as file:
-            file.seek(0)
-            data = file.read(Header.SIZE)
-            return Header.from_bytes(data)
-
-
-@dataclass
-class Position:
-    """A field position in a binary file."""
-
-    id: int
-    time: float
-    chunk_id: int
-    chunk_offset: int
-    decompressobj: zlib.decompressobj
-    chunk_size: int
-    field_size: int
-    file: IO[bytes]
-
+        file.seek(0)
+        data = file.read(Header.SIZE)
+        return Header.from_bytes(data)
+    
     @staticmethod
-    def _iterate_params(
-        file: IO[bytes], position: int, compressed: bool, chunk_size: int
-    ):
-        if position:
-            return (
-                position.file,
-                position.decompressobj is not None,
-                position.chunk_size,
-                position.field_size,
-                position.id,
-                position.chunk_id[0],
-                position.chunk_offset[0],
-                position.decompressobj.copy() if position.decompressobj else None,
-                position.chunk_id[0] * position.chunk_size,
-            )
-
-        header = Header.read(file.name, compressed)
-        return (file, compressed, chunk_size, header.field_size, 0, 0, 0, None, 0)
-
-    @staticmethod
-    def _process_buffer(chunk_buffer: bytes, field_buffer: bytes, field_size: int):
-        required_size = field_size - len(field_buffer)
-        required_buffer = chunk_buffer[:required_size]
-        field_buffer += required_buffer
-        chunk_buffer = chunk_buffer[required_size:]
-        return field_buffer, chunk_buffer, len(required_buffer)
-
-    @staticmethod
-    def iterate(
-        file: IO[bytes] = None,
-        compressed: bool = True,
-        chunk_size: int = Chunk.DEFAULT_SIZE,
-        position: "Position" = None,
-    ) -> Generator["Position", None, None]:
-        """Yield positions of fields in a binary file."""
-
-        # File:   [0100110001110101011010110110000101110011]
-        # Chunks: [   0    |   1    |   2    |   3    | 4  ]
-        # Fields: [0  |1  |2  |3                   |4  |5  ]
-
-        (
-            file,
-            compressed,
-            chunk_size,
-            field_size,
-            field_id,
-            chunk_id,
-            chunk_offset,
-            decompressobj,
-            offset,
-        ) = Position._iterate_params(file, position, compressed, chunk_size)
-
-        field_buffer = b""
-        prev_chunk_id = chunk_id
-        prev_chunk_offset = chunk_offset
-
-        for chunk in Chunk.iterate(
-            file,
-            chunk_size=chunk_size,
-            compressed=compressed,
-            offset=offset,
-            decompressobj=decompressobj,
-        ):
-            chunk_buffer = chunk.data
-
-            if chunk_offset:
-                chunk_buffer = chunk_buffer[chunk_offset:]
-
-            while chunk_buffer:
-                if len(field_buffer) == 0:
-                    decompressobj = chunk.decompressobj
-                    prev_chunk_id = chunk_id
-                    prev_chunk_offset = chunk_offset
-
-                (field_buffer, chunk_buffer, consumed) = Position._process_buffer(
-                    chunk_buffer, field_buffer, field_size
-                )
-                chunk_offset += consumed
-
-                if len(field_buffer) == field_size:
-                    if not (position and position.id == field_id):
-                        yield Position(
-                            id=field_id,
-                            time=Header.from_bytes(field_buffer).time,
-                            chunk_id=(prev_chunk_id, chunk_id),
-                            chunk_offset=(prev_chunk_offset, chunk_offset),
-                            chunk_size=chunk_size,
-                            field_size=field_size,
-                            decompressobj=decompressobj,
-                            file=file,
-                        )
-                    field_id += 1
-                    field_buffer = b""
-
-            chunk_id += 1
-            chunk_offset = 0
-
-
-class Index(List[Position]):
-    """An index of fields in a binary file."""
-
-    @staticmethod
-    def from_file(
-        file: IO[bytes],
-        verbose: bool = True,
-        chunk_size: int = Chunk.DEFAULT_SIZE,
-        compressed: bool = True,
-        position: Position = None,
-    ):
-        """Build an index from a binary file."""
-        iterator = Position.iterate(
-            file, chunk_size=chunk_size, compressed=compressed, position=position
-        )
+    def read_at(file: IO[bytes], offset: int) -> "Header":
+        file.seek(offset)
+        data = file.read(Header.SIZE)
+        if len(data) < Header.SIZE:
+            raise EOFError("Unexpected end of file")
+        return Header.from_bytes(data)
 
-        if verbose:
-            iterator = utils.progress_indicator(
-                iterator, description="Indexing", unit="Field"
-            )
 
-        return Index(iterator)
-
-    @staticmethod
-    def from_filename(
-        filename: str,
-        verbose: bool = True,
-        chunk_size: int = Chunk.DEFAULT_SIZE,
-        compressed: bool = True,
-    ):
-        """Build an index from a binary file."""
-        file = open(filename, "rb")
-        return Index.from_file(file, verbose, chunk_size, compressed)
+    def get_field_count(self, file_size: int) -> int:
+        """Get the number of fields in the file."""
+        return file_size // self.field_size
 
 
 class Field(np.ndarray):
@@ -290,8 +171,6 @@ class Field(np.ndarray):
 
         data = data[start:end]
         data = np.frombuffer(data, count=count, dtype="float32")
-        if np.all(np.isclose(data, data.astype("int32"))):
-            data = data.astype("int32")
 
         if shape is not None:
             data = data.reshape(shape)
@@ -321,36 +200,42 @@ class Field(np.ndarray):
         return 3
 
     @staticmethod
-    def read(position: Position, shape=None, spacing=None) -> "Field":
+    def read(
+        file: IO[bytes],
+        field_index: int,
+        field_size: int,
+        shape=None,
+        spacing=None,
+    ) -> "Field":
         """Read a field from a binary file."""
-        file_offset = position.chunk_id[0] * position.chunk_size
-        position.file.seek(file_offset)
-
-        decompressobj = (
-            position.decompressobj.copy() if position.decompressobj else None
-        )
 
-        field_buffer = b""
-
-        while True:
-            chunk_data = position.file.read(position.chunk_size)
-
-            if not chunk_data:
-                break
-
-            data = decompressobj.decompress(chunk_data) if decompressobj else chunk_data
-
-            if field_buffer == b"":
-                field_buffer = data[position.chunk_offset[0] :]
-            else:
-                field_buffer += data
-
-            if len(field_buffer) >= position.field_size:
-                break
+        if field_index < 0:
+            start = t()
+            _debug("Indexing file...")
+            file.seek(0, 2)
+            file_size = file.tell()
+            field_count = file_size // field_size
+            field_index += field_count
+            _debug(f"Index completed in {t() - start:.2f} seconds.")
+
+        start = t()
+        _debug(f"Seeking to field index {field_index}...")
+        offset = field_size * field_index
+        file.seek(offset)
+        _debug(f"Seek completed in {t() - start:.2f} seconds.")
 
-        field_data = field_buffer[: position.field_size]
+        start = t()
+        _debug(f"Reading data for field index {field_index}...")
+        field_data = file.read(field_size)
+        if len(field_data) < field_size:
+            raise EOFError("Unexpected end of file")
+        _debug(f"Read completed in {t() - start:.2f} seconds.")
 
-        return Field.from_bytes(field_data, shape=shape, spacing=spacing)
+        start = t()
+        _debug(f"Creating Field object for field index {field_index}...")
+        field = Field.from_bytes(field_data, shape=shape, spacing=spacing)
+        _debug(f"Field object created in {t() - start:.2f} seconds.")
+        return field
 
     def to_file(self, file: IO[bytes], geometry: bool = True):
         """Write the field to a binary file.
@@ -387,6 +272,220 @@ class Field(np.ndarray):
         with file_open(filename, "wb") as file:
             self.to_file(file, geometry)
 
+    def plot(
+        self,
+        axis: str = "y",
+        index: int = 0,
+        title: Optional[str] = None,
+        xlabel: Optional[str] = None,
+        ylabel: Optional[str] = None,
+        figsize: Optional[Tuple[float, float]] = None,
+        dpi: Optional[int] = None,
+        aspect: str = "equal",
+        ax: "Axes" = None,
+        cax: "Axes" = None,
+        vmin: Optional[float] = None,
+        vmax: Optional[float] = None,
+        cmap: str = "micpy",
+        alpha: float = 1.0,
+        interpolation: str = "none",
+        extent: Optional[Tuple[float, float, float, float]] = None,
+    ) -> Tuple["Figure", "Axes", "Colorbar"]:
+        """Plot a slice of the field using Matplotlib.
+
+        Args:
+            axis (str, optional): Axis to plot. Possible values are `x`, `y`, and `z`.
+                Defaults to `y`.
+            index (int, optional): Index of the slice. Defaults to `0`.
+            title (str, optional): Title of the plot. Defaults to `None`.
+            xlabel (str, optional): Label of the x-axis. Defaults to `None`.
+            ylabel (str, optional): Label of the y-axis. Defaults to `None`.
+            figsize (Tuple[float, float], optional): Figure size. Defaults to `None`.
+            dpi (int, optional): Figure DPI. Defaults to `None`.
+            aspect (str, optional): Aspect ratio. Defaults to `equal`.
+            ax (Axes, optional): Axes of the plot. Defaults to `None`.
+            cax (Axes, optional): Axes of the color bar. Defaults to `None`.
+            vmin (float, optional): Minimum value of the color bar. Defaults to `None`.
+            vmax (float, optional): Maximum value of the color bar. Defaults to `None`.
+            cmap (str, optional): Colormap. Defaults to `micpy`.
+            alpha (float, optional): Transparency of the plot. Defaults to `1.0`.
+            interpolation (str, optional): Interpolation method. Defaults to `none`.
+            extent (Tuple[float, float, float, float], optional): Extent of the plot.
+
+        Returns:
+            Matplotlib figure, axes, and color bar.
+        """
+
+        if not HAS_MATPLOTLIB:
+            raise ImportError("Matplotlib is not installed.")
+
+        if self.ndim != 3:
+            raise ValueError("'field' must be a 3D array")
+
+        if axis == "z":
+            x, y = "x", "y"
+            slice_2d = self[index, :, :]
+        elif axis == "y":
+            x, y = "x", "z"
+            slice_2d = self[:, index, :]
+        elif axis == "x":
+            x, y = "y", "z"
+            slice_2d = self[:, :, index]
+        else:
+            raise ValueError("'axis' must be 'x', 'y', or 'z'")
+
+        fig, ax = (
+            pyplot.subplots(figsize=figsize, dpi=dpi)
+            if ax is None
+            else (ax.get_figure(), ax)
+        )
+
+        if title is not None:
+            ax.set_title(title)
+        else:
+            ax.set_title(f"t={np.round(self.time, 7)}s")
+        if xlabel is not None:
+            ax.set_xlabel(xlabel)
+        else:
+            ax.set_xlabel(x)
+        if ylabel is not None:
+            ax.set_ylabel(ylabel)
+        else:
+            ax.set_ylabel(y)
+        if aspect is not None:
+            ax.set_aspect(aspect)
+        ax.set_frame_on(False)
+
+        image = ax.imshow(
+            slice_2d,
+            cmap=cmap,
+            vmin=vmin,
+            vmax=vmax,
+            interpolation=interpolation,
+            alpha=alpha,
+            extent=extent,
+            origin="lower",
+        )
+
+        cbar = pyplot.colorbar(image, ax=ax, cax=cax)
+        cbar.locator = matplotlib.ticker.MaxNLocator(
+            integer=np.issubdtype(slice_2d.dtype, np.integer)
+        )
+        cbar.outline.set_visible(False)
+        cbar.update_ticks()
+
+        return fig, ax, cbar
+
+    def as_vti(
+        self,
+        name: str = "values",
+        point_data: bool = False,
+    ) -> "vtkImageData":
+        """Convert the field to a VTK ImageData object.
+
+        Args:
+            name (str, optional): Name of the data array. Defaults to `values`.
+            point_data (bool, optional): `True` if data should be stored as PointData,
+                `False` if data should be stored as CellData. Defaults to `False`.
+        Returns:
+            VTK ImageData object.
+        """
+
+        if not HAS_VTK:
+            raise ImportError("VTK is not installed.")
+
+        cells = np.asarray(self)
+        if cells.ndim != 3:
+            raise ValueError("field must be 3D (nz, ny, nx)")
+
+        nz, ny, nx = cells.shape
+        dz, dy, dx = self.spacing
+
+        def cell_to_point_average(c: np.ndarray) -> np.ndarray:
+            nz_, ny_, nx_ = c.shape
+            acc = np.zeros((nz_ + 1, ny_ + 1, nx_ + 1),
+                        dtype=np.result_type(c.dtype, np.float32))
+            w = np.zeros((nz_ + 1, ny_ + 1, nx_ + 1), dtype=np.float32)
+
+            acc[0:nz_,   0:ny_,   0:nx_  ] += c
+            acc[0:nz_,   0:ny_,   1:nx_+1] += c
+            acc[0:nz_,   1:ny_+1, 0:nx_  ] += c
+            acc[0:nz_,   1:ny_+1, 1:nx_+1] += c
+            acc[1:nz_+1, 0:ny_,   0:nx_  ] += c
+            acc[1:nz_+1, 0:ny_,   1:nx_+1] += c
+            acc[1:nz_+1, 1:ny_+1, 0:nx_  ] += c
+            acc[1:nz_+1, 1:ny_+1, 1:nx_+1] += c
+
+            w[0:nz_,   0:ny_,   0:nx_  ] += 1
+            w[0:nz_,   0:ny_,   1:nx_+1] += 1
+            w[0:nz_,   1:ny_+1, 0:nx_  ] += 1
+            w[0:nz_,   1:ny_+1, 1:nx_+1] += 1
+            w[1:nz_+1, 0:ny_,   0:nx_  ] += 1
+            w[1:nz_+1, 0:ny_,   1:nx_+1] += 1
+            w[1:nz_+1, 1:ny_+1, 0:nx_  ] += 1
+            w[1:nz_+1, 1:ny_+1, 1:nx_+1] += 1
+
+            return acc / w
+
+        if point_data:
+            data = cell_to_point_average(cells)
+        else:
+            data = cells
+
+        data_c = np.ascontiguousarray(data)
+        flat = data_c.ravel(order="C")
+
+        image = vtkImageData()
+        image.SetOrigin(0.0, 0.0, 0.0)
+        image.SetSpacing(float(dx), float(dy), float(dz))
+        image.SetDimensions(nx + 1, ny + 1, nz + 1)
+
+        vtk_arr = numpy_to_vtk(flat, deep=False)
+        vtk_arr.SetName(name)
+
+        if point_data:
+            image.GetPointData().SetScalars(vtk_arr)
+        else:
+            image.GetCellData().SetScalars(vtk_arr)
+
+        image._numpy_pin = data_c
+
+        return image
+
+
+    def save_vti(
+        self,
+        filename: str,
+        name: str = "values",
+        point_data: bool = False,
+    ) -> str:
+        """Save the field as a VTK ImageData file.
+
+        Args:
+            filename (str): Filename of the VTK ImageData file.
+            name (str, optional): Name of the data array. Defaults to `values`.
+            point_data (bool, optional): `True` if data should be stored as PointData
+                `False` if data should be stored as CellData. Defaults to `False`.
+        Returns: 
+            Filename of the VTK ImageData file.
+        """
+
+        image = self.as_vti(name=name, point_data=point_data)
+
+        filename = str(Path(filename).with_suffix(".vti"))
+
+        writer = vtkXMLImageDataWriter()
+        writer.SetFileName(filename)
+
+        writer.SetInputData(image)
+        writer.SetDataModeToAppended()
+        writer.EncodeAppendedDataOff()
+
+        ok = writer.Write()
+        if ok != 1:
+            raise OSError(f"Failed to write {filename}")
+
+        return filename
 
 class Series(np.ndarray):
     def __new__(cls, fields: List[Field]):
@@ -403,16 +502,7 @@ class Series(np.ndarray):
         self.times = getattr(obj, "times", None)
         self.spacings = getattr(obj, "spacings", None)
 
-    def iter_field(self):
-        """Iterate over fields in the series.
-
-        Yields:
-            Field.
-        """
-        for item, time, spacing in zip(self, self.times, self.spacings):
-            yield Field(item, time, spacing)
-
-    def get_field(self, index: int) -> Field:
+    def field(self, index: int) -> Field:
         """Get a field from the series.
 
         Args:
@@ -423,22 +513,22 @@ class Series(np.ndarray):
         """
         return Field(self[index], self.times[index], self.spacings[index])
 
-    def get_series(self, key: Union[int, slice, list]) -> "Series":
+    def series(self, key: Union[int, slice, list]) -> "Series":
         """Get a series of fields.
 
         Args:
-            key (Union[int, slice, list]): Key to list of field IDs, a slice object, or a
-                list of field IDs.
+            key (Union[int, slice, list]): Key to list of field indices, a slice object, or a
+                list of field indices.
 
         Returns:
             Series of fields.
         """
         if isinstance(key, int):
-            return Series([self.get_field(key)])
+            return Series([self.field(key)])
         if isinstance(key, slice):
-            return Series([self.get_field(i) for i in range(*key.indices(len(self)))])
+            return Series([self.field(i) for i in range(*key.indices(len(self)))])
         if isinstance(key, list):
-            return Series([self.get_field(i) for i in key])
+            return Series([self.field(i) for i in key])
         raise TypeError("Invalid argument type")
 
     def write(self, filename: str, compressed: bool = True, geometry: bool = True):
@@ -454,55 +544,84 @@ class Series(np.ndarray):
 
         file_open = gzip.open if compressed else open
         with file_open(filename, "wb") as file:
-            for field in self.iter_field():
-                field.to_file(file, geometry)
+            for item, time, spacing in zip(self, self.times, self.spacings):
+                Field(item, time, spacing).to_file(file, geometry)
                 geometry = False
 
 
+DEBUG = False
+WARN = True
+
+
+def _debug(*args):
+    # TODO: Use logging module
+    if DEBUG:
+        print("Debug:", *args)
+
+
+def _warn(*args):
+    # TODO: Use logging module
+    if WARN:
+        print("Warning:", *args)
+
+
+def _index_filename(filename: str) -> Path:
+    return Path(f"{filename}.idx")
+
+
+def _try_import_index(file, index: str):
+    path = Path(index)
+    if not path.is_file():
+        _debug("Index file not found.")
+        return
+    if not os.access(path, os.R_OK):
+        _debug("Index file is not readable.")
+        return
+    try:
+        file.import_index(str(path))
+        _debug("Index file imported.")
+    except ValueError:
+        _debug("Index file is invalid.")
+        return
+    except (PermissionError, FileNotFoundError, IsADirectoryError, OSError):
+        _debug("Failed to import index file.")
+        return
+
+
+def _try_export_index(file, index: str):
+    path = Path(index)
+
+    if path.exists() and not path.is_file():
+        _warn("Index path is not a file.")
+        return
+    if not os.access(path.parent, os.W_OK):
+        _warn("Index file is not writable.")
+        return
+    try:
+        file.export_index(str(path))
+        _debug("Index file exported.")
+    except (PermissionError, IsADirectoryError, FileNotFoundError, OSError):
+        _warn("Failed to export index file.")
+        return
+
+
 class File:
     """A binary file."""
 
     def __init__(
         self,
         filename: str,
-        chunk_size: int = Chunk.DEFAULT_SIZE,
-        verbose: bool = True,
+        threads: int = None,
     ):
-        """Initialize a binary file.
-
-        Args:
-            filename (str): File name.
-            chunk_size (int, optional): Chunk size in bytes. Defaults to `8388608`
-                (8 MiB).
-            verbose (bool, optional): Verbose output. Defaults to `True`.
-
-        Raises:
-            `FileNotFoundError`: If file is not found.
-        """
-        if not os.path.isfile(filename):
-            raise FileNotFoundError(f"File not found: {filename}")
-
-        self._filename: str = filename
-        self._chunk_size: int = chunk_size
-        self._verbose: bool = verbose
+        self.shape: Tuple[int, int, int] = None
+        self.spacing: Tuple[float, float, float] = None
 
+        self._filename = filename
+        self._threads = threads if threads is not None else min(4, os.cpu_count())
         self._file: IO[bytes] = None
         self._compressed: bool = None
-        self._created: float = None
-        self._modified: float = None
-        self._index: Index = None
-
-        self.shape: np.ndarray[(3,), np.int32] = None
-        self.spacing: np.ndarray[(3,), np.float32] = None
-
-        try:
-            self.find_geometry()
-        except (geo.GeometryFileNotFoundError, geo.MultipleGeometryFilesError):
-            if self._verbose:
-                self._warn("Caution: A geometry file was not found.")
-
-    def __getitem__(self, key: Union[int, slice, list, Callable[[Field], bool]]):
-        return self.read(key)
+        self._indexed: bool = False
+        self._header: Header = None
 
     def __enter__(self):
         return self.open()
@@ -510,328 +629,184 @@ class File:
     def __exit__(self, exc_type, exc_value, traceback):
         self.close()
 
-    def __iter__(self):
-        return self.iterate()
-
-    def _info(self, *args):
-        if self._verbose:
-            print(*args)
+    def __iter__(self) -> Iterator[Field]:
+        index = 0
+        while True:
+            try:
+                yield self._read_field(index)
+                index += 1
+            except (IndexError, EOFError):
+                break
 
-    def _warn(self, *args):
-        if self._verbose:
-            print(*args, file=sys.stderr)
+    def open(self) -> "File":
+        """Open the file.
 
-    def _open_file(self):
-        self._file = open(self._filename, "rb")
+        Returns:
+            File: The opened binary file.
+        """
         self._compressed = utils.is_compressed(self._filename)
 
-    def _close_file(self):
-        if self._file:
-            self._file.close()
-        self._reset()
+        if self._compressed:
+            self._file = rapidgzip.open(self._filename, self._threads)
+            start = t()
+            _debug("Importing index file...")
+            _try_import_index(self._file, _index_filename(self._filename))
+            _debug(f"Index file imported in {t() - start:.2f} seconds.")
+        else:
+            self._file = builtins.open(self._filename, "rb")
 
-    def _reset(self):
-        self._file = None
-        self._compressed = None
-        self._created = None
-        self._modified = None
-        self._index = None
+        self._header = Header.read(self._file)
 
-    def _update_timestamps(self):
-        self._created = os.path.getctime(self._filename)
-        self._modified = os.path.getmtime(self._filename)
+        try:
+            geometry = geo.read(geo.find(self._filename), type=geo.Type.BASIC)
+            self.shape = self.shape or geometry["shape"][::-1]
+            self.spacing = self.spacing or geometry["spacing"][::-1]
+        except (geo.GeometryFileNotFoundError, geo.MultipleGeometryFilesError):
+            _warn("Caution: A geometry file was not found.")
 
-    def open(self):
-        """Open the file."""
-        if not self._file:
-            self.create_index()
         return self
-
-    def close(self):
-        """Close the file."""
-        self._close_file()
-
-    def index(self):
-        """Get the index of the file."""
-        if self._created != os.path.getctime(self._filename):
-            self.create_index()
-        elif self._modified != os.path.getmtime(self._filename):
-            self.update_index()
-        return self._index
-
-    def create_index(self):
-        """Create an index of the file."""
-        self._close_file()
-        self._open_file()
-        self._update_timestamps()
-        self._index = Index.from_file(
-            self._file,
-            verbose=self._verbose,
-            chunk_size=self._chunk_size,
-            compressed=self._compressed,
-        )
-
-    def update_index(self):
-        """Update the index of the file."""
-        self._update_timestamps()
-        index = Index.from_file(
-            self._file,
-            verbose=self._verbose,
-            chunk_size=self._chunk_size,
-            compressed=self._compressed,
-            position=self._index[-1],
-        )
-        self._index.extend(index)
-
-    def times(self) -> List[float]:
-        """Get the times of the fields in the file.
+    
+    def times(self) -> list[float]:
+        """Get the time steps from the binary file.
 
         Returns:
-            List of times.
+            list[float]: List of time steps.
         """
-        return [position.time for position in self.index()]
-
-    def set_geometry(
-        self, shape: Tuple[int, int, int], spacing: Tuple[float, float, float]
-    ):
-        """Set the geometry.
+        if not self._file:
+            self.open()
 
-        Args:
-            shape (Tuple[int, int, int]): Shape of the geometry (z, y, x).
-            spacing (Tuple[float, float, float]): Spacing of the geometry (dz, dy, dx) in μm.
-        """
+        field_size = self._header.field_size
 
-        self.shape = np.array(shape)
-        self.spacing = np.array(spacing)
+        cur = self._file.tell()
+        self._file.seek(0, 2)
+        file_size = self._file.tell()
+        field_count = file_size // field_size
+        self._file.seek(cur)
 
-        self.print_geometry()
+        times: list[float] = []
 
-    def read_geometry(self, filename: str, compressed: Optional[bool] = None):
-        """Read geometry from a file.
+        for i in range(int(field_count)):
+            hdr = Header.read_at(self._file, i * field_size)
+            times.append(hdr.time)
 
-        Args:
-            filename (str): Filename of a geometry file.
-            compressed (bool, optional): `True` if file is compressed, `False`
-                otherwise. Defaults to `None` (auto).
-        """
-        if compressed is None:
-            compressed = utils.is_compressed(filename)
+        return times
 
-        geometry = geo.read(filename, type=geo.Type.BASIC, compressed=compressed)
+    def _read_field(self, key: int) -> Field:
+        if not self._file:
+            self.open()
+        if isinstance(key, int):
+            return Field.read(
+                file=self._file,
+                field_index=key,
+                field_size=Header.read(self._file).field_size,
+                shape=self.shape,
+                spacing=self.spacing,
+            )
+        raise TypeError("Invalid argument type")
 
-        shape = geometry["shape"][::-1]
-        spacing = geometry["spacing"][::-1]
+    def _read_series(self, key: list[int] = None) -> Series:
+        if key is None:
+            fields: list[Field] = list(self)
+            return Series(fields)
+        if isinstance(key, list):
+            return Series([self._read_field(i) for i in key])
+        raise TypeError("Invalid argument type")
 
-        self.set_geometry(shape, spacing)
+    @overload
+    def read(self, key: int, threads: int = None) -> Field: ...
+    @overload
+    def read(self, key: list[int], threads: int = None) -> Series: ...
+    @overload
+    def read(self, key: None = None, threads: int = None) -> Series: ...
 
-    def find_geometry(self, compressed: Optional[bool] = None):
-        """Find geometry file and read it.
+    def read(self, key: Union[int, list[int]] = None, threads: int = None) -> Union[Field, Series]:
+        """Read a field or series from a binary file.
 
         Args:
-            compressed (bool, optional): True if file is compressed, False otherwise.
-                Defaults to `None` (auto).
-
-        Raises:
-            `GeometryFileNotFoundError`: If no geometry file is found.
-            `MultipleGeometryFilesError`: If multiple geometry files are found.
-        """
-        filename = geo.find(self._filename)
-
-        self.read_geometry(filename, compressed=compressed)
-
-    def print_geometry(self):
-        """Get a string representation of the geometry."""
-
-        if self.shape is None or self.spacing is None:
-            self._info("Geometry: None")
-            return
-
-        dimensions = Field.dimensions(self.shape)
-        cells = self.shape
-        spacing = 1e4 * np.round(self.spacing.astype(float), 7)
-        size = cells * spacing
-
-        self._info(f"Geometry: {dimensions}-Dimensional Grid")
-        self._info(f"Grid Size [μm]: {tuple(size)}")
-        self._info(f"Grid Shape (Cell Count): {tuple(cells)}")
-        self._info(f"Grid Spacing (Cell Size) [μm]: {tuple(spacing)}")
-
-    def iterate(self) -> Generator[Field, None, None]:
-        """Iterate over fields in the file.
-
+            key (Union[int, list[int]], optional): Key to a field index or a list of field
+                indices. Defaults to `None`, which reads all fields.
+            threads (int, optional): Number of threads to use for reading compressed files.
+                Defaults to `None`, which uses up to 4 threads.
         Returns:
-            A generator of fields.
+            Union[Field, Series]: Field or series of fields.
         """
-        for position in self.index():
-            yield Field.read(position, shape=self.shape, spacing=self.spacing)
-
-    def read_field(self, field_id: int) -> Field:
-        """Read a field from the file.
+        if key is None:
+            return self._read_series()
+        if isinstance(key, int):
+            return self._read_field(key)
+        if isinstance(key, list):
+            return self._read_series(key)
+        raise TypeError("Invalid argument type")
 
-        Args:
-            field_id (int): Field ID.
+    def close(self):
+        """Close the file."""
+        if not self._file:
+            return
 
-        Returns:
-            Field.
-        """
-        self.index()
+        if self._compressed:
+            start = t()
+            _debug("Exporting index file...")
+            _try_export_index(self._file, _index_filename(self._filename))
+            _debug(f"Index file exported in {t() - start:.2f} seconds.")
 
-        position = self._index[field_id]
-        return Field.read(position, shape=self.shape, spacing=self.spacing)
+        self._file.close()
+        self._file = None
 
-    def read(
-        self, key: Optional[Union[int, slice, list, Callable[[Field], bool]]] = None
-    ) -> Series:
-        """Read a series of fields from the file.
 
-        Args:
-            key (Union[int, slice, list, Callable[[Field], bool]]): Key to list of
-            field IDs, a slice object, a list of field IDs, or a function that filters
-            fields. Defaults to `None`.
+def open(filename: str, threads: int = None) -> File:
+    """Open a binary file.
 
-        Returns:
-            Series of fields.
-        """
+    Args:
+        filename (str): Filename of the binary file.
+        threads (int, optional): Number of threads to use for reading compressed files.
+            Defaults to `None`, which uses up to 4 threads.
+    Returns:
+        File: Binary file.
+    """
+    return File(filename, threads).open()
 
-        def iterable(iterable):
-            if self._verbose:
-                return utils.progress_indicator(
-                    iterable, description="Reading", unit="Field"
-                )
-            return iterable
 
-        self.index()
+def times(filename: str, threads: int = None) -> list[float]:
+    """Get the time steps from a binary file.
+    
+    Args:
+        filename (str): Filename of the binary file.
+        threads (int, optional): Number of threads to use for reading compressed files.
+            Defaults to `None`, which uses up to 4 threads.
+    Returns:
+        list[float]: List of time steps.
+    """
 
-        if key is None:
-            fields = list(field for field in iterable(self.iterate()))
-        elif isinstance(key, int):
-            fields = [self.read_field(key)]
-        elif isinstance(key, slice):
-            indices = range(*key.indices(len(self._index)))
-            fields = [self.read_field(i) for i in iterable(indices)]
-        elif isinstance(key, list):
-            fields = [self.read_field(i) for i in iterable(key)]
-        elif isinstance(key, Callable):
-            fields = [field for field in iterable(self.iterate()) if key(field)]
-        else:
-            raise TypeError("Invalid argument type")
-        return Series(fields)
+    with open(filename, threads) as file:
+        return file.times()
 
+@overload
+def read(filename: str, key: int, threads: int = None) -> Field: ...
+@overload
+def read(filename: str, key: list[int], threads: int = None) -> Series: ...
+@overload
+def read(filename: str, key: None = None, threads: int = None) -> Series: ...
 
-@dataclass
-class PlotArgs:
-    """Arguments for plotting a field.
+def read(filename: str, key: Union[int, list[int]] = None, threads: int = None) -> Union[Field, Series]:
+    """Read a field or series from a binary file.
 
     Args:
-        title (str, optional): Title of the plot. Defaults to `None`.
-        xlabel (str, optional): Label of the x-axis. Defaults to `None`.
-        ylabel (str, optional): Label of the y-axis. Defaults to `None`.
-        figsize (Tuple[float, float], optional): Figure size. Defaults to `None`.
-        dpi (int, optional): Figure DPI. Defaults to `None`.
-        aspect (str, optional): Aspect ratio. Defaults to `equal`.
-        ax (matplotlib.Axes, optional): Axes of the plot. Defaults to `None`.
-        cax (matplotlib.Axes, optional): Axes of the color bar. Defaults to `None`.
-        vmin (float, optional): Minimum value of the color bar. Defaults to `None`.
-        vmax (float, optional): Maximum value of the color bar. Defaults to `None`.
-        cmap (str, optional): Colormap. Defaults to `micpy`.
-        alpha (float, optional): Transparency of the plot. Defaults to `1.0`.
-        interpolation (str, optional): Interpolation method. Defaults to `none`.
+        filename (str): Filename of the binary file.
+        key (Union[int, list[int]], optional): Key to a field index or a list of field
+            indices. Defaults to `None`, which reads all fields.
+        threads (int, optional): Number of threads to use for reading compressed files.
+            Defaults to `None`, which uses up to 4 threads.
+    Returns:
+        Union[Field, Series]: Field or series of fields.
     """
+    with open(filename, threads) as file:
+        return file.read(key)
 
-    title: Optional[str] = None
-    xlabel: Optional[str] = None
-    ylabel: Optional[str] = None
-    figsize: Optional[Tuple[float, float]] = None
-    dpi: Optional[int] = None
-    aspect: str = "equal"
-    ax: "matplotlib.Axes" = None
-    cax: "matplotlib.Axes" = None
-    vmin: Optional[float] = None
-    vmax: Optional[float] = None
-    cmap: str = "micpy"
-    alpha: float = 1.0
-    interpolation: str = "none"
-
-
-def plot(
-    field: Field,
-    axis: str = "y",
-    index: int = 0,
-    args: Optional[PlotArgs] = None,
-) -> Tuple["matplotlib.Figure", "matplotlib.Axes"]:
-    """Plot a slice of the field.
 
-    Args:
-        field (Field): Field to plot.
-        axis (str, optional): Axis to plot. Possible values are `x`, `y`, and `z`.
-            Defaults to `y`.
-        index (int, optional): Index of the slice. Defaults to `0`.
-        args (PlotArgs, optional): Arguments for plotting. Defaults to `None`.
+def pv_plugin_path() -> str:
+    """Get the path to the ParaView plugin directory for MicPy.
 
     Returns:
-        Matplotlib figure, axes, and color bar.
+        str: Path to the ParaView plugin directory for MicPy.
     """
-
-    if matplotlib is None:
-        raise ImportError("matplotlib is not installed")
-
-    if axis not in ["x", "y", "z"]:
-        raise ValueError("Invalid axis")
-
-    if field.ndim != 3:
-        raise ValueError("Invalid field shape")
-
-    if args is None:
-        args = PlotArgs()
-
-    if axis == "z":
-        x, y = "x", "y"
-        slice_2d = field[index, :, :]
-    elif axis == "y":
-        x, y = "x", "z"
-        slice_2d = field[:, index, :]
-    elif axis == "x":
-        x, y = "y", "z"
-        slice_2d = field[:, :, index]
-
-    fig, ax = (
-        pyplot.subplots(figsize=args.figsize, dpi=args.dpi)
-        if args.ax is None
-        else (args.ax.get_figure(), args.ax)
-    )
-
-    if args.title is not None:
-        ax.set_title(args.title)
-    else:
-        if isinstance(field, Field):
-            ax.set_title(f"t={np.round(field.time, 7)}s")
-    if args.xlabel is not None:
-        ax.set_xlabel(args.xlabel)
-    else:
-        ax.set_xlabel(x)
-    if args.ylabel is not None:
-        ax.set_ylabel(args.ylabel)
-    else:
-        ax.set_ylabel(y)
-    if args.aspect is not None:
-        ax.set_aspect(args.aspect)
-    ax.set_frame_on(False)
-
-    image = ax.imshow(
-        slice_2d,
-        cmap=args.cmap,
-        vmin=args.vmin,
-        vmax=args.vmax,
-        interpolation=args.interpolation,
-        alpha=args.alpha,
-        origin="lower",
-    )
-
-    bar = pyplot.colorbar(image, ax=ax, cax=args.cax)
-    bar.locator = matplotlib.ticker.MaxNLocator(
-        integer=np.issubdtype(slice_2d.dtype, np.integer)
-    )
-    bar.outline.set_visible(False)
-    bar.update_ticks()
-
-    return fig, ax, bar
+    return str(Path(__file__).parent / "paraview")