micress-micpy 0.2.17b0__py3-none-any.whl → 0.3.1b0__py3-none-any.whl

micpy/bin.py

@@ -1,12 +1,11 @@
 """The `micpy.bin` module provides methods to read and write binary files."""
 
 from dataclasses import dataclass
-from typing import Callable, IO, List, Tuple, Generator
+from typing import Callable, Generator, IO, List, Optional, Tuple, Union
 
 import gzip
 import os
 import sys
-import warnings
 import zlib
 
 import numpy as np
@@ -16,7 +15,7 @@ from micpy import utils
 from micpy.matplotlib import matplotlib, pyplot
 
 
-__all__ = ["File"]
+__all__ = ["File", "Field", "Series", "plot", "PlotArgs"]
 
 
 @dataclass
@@ -263,9 +262,9 @@ class Index(List[Position]):
 class Field(np.ndarray):
     """A field."""
 
-    def __new__(cls, data, time: float, spacing: float = None):
+    def __new__(cls, data, time: float, spacing: Tuple[float, float, float]):
         obj = np.asarray(data).view(cls)
-        obj.time = round(float(time), 7)
+        obj.time = time
         obj.spacing = spacing
         return obj
 
@@ -353,223 +352,102 @@ class Field(np.ndarray):
 
         return Field.from_bytes(field_data, shape=shape, spacing=spacing)
 
-    def write(self, file: IO[bytes]):
-        """Write the field to a binary file."""
-        file.write(self.to_bytes())
+    def to_file(self, file: IO[bytes], geometry: bool = True):
+        """Write the field to a binary file.
 
-    def get_slice(self, plane: str, slice_id: int):
-        """Get a slice of the field."""
+        Args:
+            file (IO[bytes]): Binary file.
+            geometry (bool, optional): `True` if geometry should be written, `False`
+                otherwise. Defaults to `True`.
+        """
 
-        if plane not in ["xy", "xz", "yz", "zy", "zx", "yx"]:
-            raise ValueError("Invalid plane")
+        file.write(self.to_bytes())
 
-        dimensions = Field.dimensions(self.shape)
+        if geometry:
+            geo_filename, geo_data = geo.build(file.name, self.shape, self.spacing)
+            geo.write(geo_filename, geo_data, geo.Type.BASIC)
 
-        x, _, z = self.shape
-
-        reshape_operations = {
-            1: lambda data: data.reshape((z, 1)),
-            2: lambda data: data.reshape((z, x)),
-            3: lambda data: data,
-        }
-
-        data = reshape_operations[dimensions](self)
-
-        slice_operations = {
-            1: {
-                "xz": lambda data: data,
-                "zx": lambda data: data.T,
-                "xy": lambda data: data[slice_id : slice_id + 1],
-                "yx": lambda data: data[slice_id : slice_id + 1],
-                "zy": lambda data: data.T,
-                "yz": lambda data: data,
-            },
-            2: {
-                "xz": lambda data: data,
-                "zx": lambda data: data.T,
-                "xy": lambda data: data[slice_id : slice_id + 1],
-                "yx": lambda data: data[slice_id : slice_id + 1].T,
-                "zy": lambda data: data.T[slice_id : slice_id + 1],
-                "yz": lambda data: data.T[slice_id : slice_id + 1].T,
-            },
-            3: {
-                "xy": lambda data: data[slice_id, :, :],
-                "yx": lambda data: data[slice_id, :, :].T,
-                "xz": lambda data: data[:, slice_id, :],
-                "zx": lambda data: data[:, slice_id, :].T,
-                "yz": lambda data: data[:, :, slice_id],
-                "zy": lambda data: data[:, :, slice_id].T,
-            },
-        }
-
-        return slice_operations[dimensions][plane](data)
-
-    # pylint: disable=too-many-arguments
-    def plot(
+    def write(
         self,
-        plane: str = "xz",
-        slice_id: int = 0,
-        title: str = None,
-        xlabel: str = None,
-        ylabel: str = None,
-        figsize: Tuple[float, float] = None,
-        dpi: int = None,
-        aspect: str = "equal",
-        ax: "matplotlib.Axes" = None,
-        cax: "matplotlib.Axes" = None,
-        vmin: float = None,
-        vmax: float = None,
-        cmap: str = "micpy",
-    ) -> Tuple["matplotlib.Figure", "matplotlib.Axes"]:
-        """Plot a slice of the field.
+        filename: str,
+        compressed: bool = True,
+        geometry: bool = True,
+    ):
+        """Write the field to a binary file.
 
         Args:
-            plane (str, optional): Plane of the slice. Defaults to `xz`.
-            slice_id (int, optional): Slice ID. Defaults to `0`.
-            title (str, optional): Title of the plot. Defaults to `None`.
-            xlabel (str, optional): Label of the x-axis. Defaults to `None` (auto).
-            ylabel (str, optional): Label of the y-axis. Defaults to `None` (auto).
-            figsize (Tuple[float, float], optional): Figure size. Defaults to `None` 
-                (auto).
-            dpi (int, optional): Figure DPI. Defaults to `None` (auto).
-            aspect (str, optional): Aspect ratio. Defaults to `equal`.
-            ax (Axes, optional): Axes to plot on. Defaults to `None`.
-            cax (Axes, optional): Axes to plot color bar on. 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): Color map. Defaults to `micpy`.
-
-        Returns:
-            Figure and axes of the plot.
+            filename (str): Filename of the binary file.
+            compressed (bool, optional): `True` if file should be compressed, `False`
+                otherwise. Defaults to `True`.
+            geometry (bool, optional): `True` if geometry should be written, `False`
+                otherwise. Defaults to `True`.
         """
-        if matplotlib is None:
-            raise ImportError("matplotlib is not installed")
-
-        slice = self.get_slice(plane, slice_id) if self.ndim == 3 else self
-
-        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(plane[0])
-        if ylabel is not None:
-            ax.set_ylabel(ylabel)
-        else:
-            ax.set_ylabel(plane[1])
-        if aspect is not None:
-            ax.set_aspect(aspect)
-        ax.set_frame_on(False)
-
-        mesh = ax.pcolormesh(slice, cmap=cmap, vmin=vmin, vmax=vmax)
-
-        bar = pyplot.colorbar(mesh, ax=ax, cax=cax)
-        bar.locator = matplotlib.ticker.MaxNLocator(
-            integer=np.issubdtype(slice.dtype, np.integer)
-        )
-        bar.outline.set_visible(False)
-        bar.update_ticks()
-
-        return fig, ax
-
-
-class FieldList(List[Field]):
-    """A list of fields."""
 
-    def __init__(self, fields: List[Field] = None):
-        super().__init__(fields if fields else [])
+        file_open = gzip.open if compressed else open
+        with file_open(filename, "wb") as file:
+            self.to_file(file, geometry)
 
-    def append(self, field: Field):
-        """Append a field to the list."""
-        super().append(field)
 
-    def extend(self, fields: List[Field]):
-        """Extend the list with fields."""
-        super().extend(fields)
+class Series(np.ndarray):
+    def __new__(cls, fields: List[Field]):
+        obj = np.asarray(fields).view(cls)
+        obj.times = [field.time for field in fields]
+        obj.spacings = [field.spacing for field in fields]
+        return obj
+    
+    def __array_finalize__(self, obj):
+        if obj is None:
+            return
 
-    def write(self, filename: str, compressed: bool = True, write_geo: bool = True):
-        """Write the fields to a binary file."""
-        file_open = gzip.open if compressed else open
-        with file_open(filename, "wb") as file:
-            for field in self:
-                field.write(file)
+        # pylint: disable=attribute-defined-outside-init
+        self.times = getattr(obj, "times", None)
+        self.spacings = getattr(obj, "spacings", None)
 
-        if write_geo:
-            geo_filename, geo_data, geo_type = geo.get_basic(
-                filename, self[0].shape, self[0].spacing
-            )
-            geo.write(geo_filename, geo_data, geo_type, compressed=compressed)
+    def __iter__(self):
+        for item, time, spacing in zip(self, self.times, self.spacings):
+            yield Field(item, time, spacing)
 
-    # pylint: disable=too-many-arguments
-    def plot(
-        self,
-        cols: int = None,
-        normalize: bool = False,
-        sharex: bool = False,
-        sharey: bool = False,
-        figsize: Tuple[float, float] = None,
-        dpi: int = None,
-        **kwargs,
-    ) -> Tuple["matplotlib.Figure", "matplotlib.Axes"]:
-        """Plot the fields in a grid.
+    def get(self, index: Union[int, list, slice]) -> Field:
+        """Get one or more fields from the series.
 
         Args:
-            cols (int, optional): Number of columns. Defaults to `None` (auto).
-            normalize (bool, optional): Normalize the color bar. Defaults to `False`.
-            sharex (bool, optional): Share x-axis. Defaults to `False`.
-            sharey (bool, optional): Share y-axis. Defaults to `False`.
-            figsize (Tuple[float, float], optional): Figure size. Defaults to `None` 
-                (auto).
-            dpi (int, optional): Figure DPI. Defaults to `None` (auto).
-            **kwargs: Keyword arguments passed to `Field.plot()`.
+            index (Union[int, list, slice]): Index of the field.
 
         Returns:
-            Figure and axes of the plot.
+            Field.
         """
-        if matplotlib is None:
-            raise ImportError("matplotlib is not installed")
 
-        if cols is None:
-            cols = int(np.ceil(np.sqrt(len(self))))
+        if isinstance(index, int):
+            return Field(self[index], self.times[index], self.spacings[index])
+        elif isinstance(index, slice):
+            series = self[index]
+            series.times = self.times[index]
+            series.spacings = self.spacings[index]
+            return series
+        elif isinstance(index, list):
+            series = self[index]
+            series.times = [self.times[i] for i in index]
+            series.spacings = [self.spacings[i] for i in index]
+            return series
+        raise TypeError("Invalid argument type")
 
-        rows = (len(self) + cols - 1) // cols
 
-        fig, ax = pyplot.subplots(
-            rows, cols, figsize=figsize, dpi=dpi, sharex=sharex, sharey=sharey
-        )
+    def write(self, filename: str, compressed: bool = True, geometry: bool = True):
+        """Write the series to a binary file.
 
-        vmin = (
-            min(field.min() for field in self)
-            if normalize
-            else kwargs.pop("vmin", None)
-        )
-        vmax = (
-            max(field.max() for field in self)
-            if normalize
-            else kwargs.pop("vmax", None)
-        )
-
-        flat_ax = ax.flatten() if isinstance(ax, np.ndarray) else [ax]
-
-        for i, field in enumerate(self):
-            field.plot(ax=flat_ax[i], vmin=vmin, vmax=vmax, **kwargs)
-
-        for i in range(len(self), len(flat_ax)):
-            fig.delaxes(flat_ax[i])
-
-        with warnings.catch_warnings():
-            warnings.simplefilter("ignore")
-            fig.tight_layout()
+        Args:
+            filename (str): Filename of the binary file.
+            compressed (bool, optional): `True` if file should be compressed, `False`
+                otherwise. Defaults to `True`.
+            geometry (bool, optional): `True` if geometry should be written, `False`
+                otherwise. Defaults to `True`.
+        """
 
-        return fig, ax
+        file_open = gzip.open if compressed else open
+        with file_open(filename, "wb") as file:
+            for field in self:
+                field.to_file(file, geometry)
+                geometry = False
 
 
 class File:
@@ -609,12 +487,12 @@ class File:
         self.spacing: np.ndarray[(3,), np.float32] = None
 
         try:
-            self.find_geo()
+            self.find_geometry()
         except (geo.GeometryFileNotFoundError, geo.MultipleGeometryFilesError):
             if self._verbose:
                 self._warn("Caution: A geometry file was not found.")
 
-    def __getitem__(self, key: int or slice or list or Callable[[Field], bool]):
+    def __getitem__(self, key: Union[int, slice, list, Callable[[Field], bool]]):
         return self.read(key)
 
     def __enter__(self):
@@ -704,42 +582,43 @@ class File:
         """
         return [position.time for position in self.index()]
 
-    def set_geo(self, shape: Tuple[int, int, int], spacing: Tuple[float, float, float]):
+    def set_geometry(
+        self, shape: Tuple[int, int, int], spacing: Tuple[float, float, float]
+    ):
         """Set the geometry.
 
         Args:
             shape (Tuple[int, int, int]): Shape of the geometry.
-            spacing (Tuple[float, float, float]): Spacing of the geometry in μm³.
+            spacing (Tuple[float, float, float]): Spacing of the geometry in μm.
         """
 
         self.shape = np.array(shape)
         self.spacing = np.array(spacing)
 
-        self.print_geo()
+        self.print_geometry()
 
-    def read_geo(
-        self, filename: str, type: geo.Type = geo.Type.EXTENDED, compressed: bool = True
-    ):
+    def read_geometry(self, filename: str, compressed: Optional[bool] = None):
         """Read geometry from a file.
 
         Args:
             filename (str): Filename of a geometry file.
-            type (Type, optional): Data type to be read. Defaults to `Type.EXTENDED`.
-            compressed (bool, optional): `True` if file is compressed, `False` 
-                otherwise. Defaults to True.
+            compressed (bool, optional): `True` if file is compressed, `False`
+                otherwise. Defaults to `None` (auto).
         """
-        geo_dict = geo.read(filename, type=type, compressed=compressed)
+        if compressed is None:
+            compressed = utils.is_compressed(filename)
 
-        shape = geo_dict["shape"]
-        spacing = utils.convert_si(geo_dict["spacing"], "cm", "μm")
+        geometry = geo.read(filename, type=geo.Type.BASIC, compressed=compressed)
 
-        self.set_geo(shape, spacing)
+        shape = geometry["shape"]
+        spacing = geometry["spacing"]
 
-    def find_geo(self, type: geo.Type = geo.Type.EXTENDED, compressed: bool = None):
+        self.set_geometry(shape, spacing)
+
+    def find_geometry(self, compressed: Optional[bool] = None):
         """Find geometry file and read it.
 
         Args:
-            type (Type, optional): Data type to be read. Defaults to `Type.EXTENDED`.
             compressed (bool, optional): True if file is compressed, False otherwise.
                 Defaults to `None` (auto).
 
@@ -749,12 +628,9 @@ class File:
         """
         filename = geo.find(self._filename)
 
-        if compressed is None:
-            compressed = utils.is_compressed(filename)
-
-        self.read_geo(filename, type=type, compressed=compressed)
+        self.read_geometry(filename, compressed=compressed)
 
-    def print_geo(self):
+    def print_geometry(self):
         """Get a string representation of the geometry."""
 
         if self.shape is None or self.spacing is None:
@@ -763,36 +639,38 @@ class File:
 
         dimensions = Field.dimensions(self.shape)
         cells = self.shape
-        spacing = np.round(self.spacing, 7)
+        spacing = 1e4 * np.round(self.spacing.astype(float), 7)
         size = cells * spacing
 
         self._info(f"Geometry: {dimensions}-Dimensional Grid")
-        self._info(f"Grid Size: {tuple(size)}μm³")
+        self._info(f"Grid Size [μm]: {tuple(size)}")
         self._info(f"Grid Shape (Cell Count): {tuple(cells)}")
-        self._info(f"Grid Spacing (Cell Size): {tuple(spacing)}μm³")
+        self._info(f"Grid Spacing (Cell Size) [μm]: {tuple(spacing)}")
 
     def iterate(self) -> Generator[Field, None, None]:
         """Iterate over fields in the file.
 
         Returns:
-            Field data.
+            A generator of fields.
         """
         for position in self.index():
             yield Field.read(position, shape=self.shape, spacing=self.spacing)
 
-    def read(self, key: int or slice or list or Callable[[Field], bool] = None) -> FieldList:
-        """Read a field from the file.
+    def read(
+        self, key: Optional[Union[int, slice, list, Callable[[Field], bool]]] = None
+    ) -> Series:
+        """Read field data from the file.
 
         Args:
-            key (int or list or slice or Callable[[Field], bool], optional): Field ID,
+            key (Union[int, slice, list, Callable[[Field], bool], optional): Key to
                 list of field IDs, a slice object, or a condition function.
                 Defaults to `None`.
 
         Returns:
-            List of fields.
+            A series of fields.
         """
 
-        def read_field(self, field_id: int or slice or list):
+        def read_field(self, field_id: Union[int, slice, list]):
             position = self._index[field_id]
             return Field.read(position, shape=self.shape, spacing=self.spacing)
 
@@ -819,4 +697,113 @@ class File:
         else:
             raise TypeError("Invalid argument type")
 
-        return FieldList(fields)
+        return Series(fields)
+
+
+@dataclass
+class PlotArgs:
+    """Arguments for plotting a field.
+
+    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`.
+    """
+
+    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"
+
+
+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`.
+
+    Returns:
+        Matplotlib figure and axes of the plot.
+    """
+
+    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, :]
+        if Field.dimensions(field.shape) == 2:
+            slice_2d = slice_2d.reshape(slice_2d.shape[1], slice_2d.shape[0])
+    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)
+
+    mesh = ax.pcolormesh(slice_2d, cmap=args.cmap, vmin=args.vmin, vmax=args.vmax)
+
+    bar = pyplot.colorbar(mesh, 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

micpy/geo.py

@@ -5,6 +5,7 @@ import gzip
 
 from typing import Tuple
 from pathlib import Path
+from typing import Optional
 
 import numpy as np
 from numpy import ndarray
@@ -89,7 +90,7 @@ def read(filename: str, type: Type = Type.EXTENDED, compressed: bool = True) ->
 
     Args:
         filename (str): Filename of a geometry file.
-        type (Type, optional): Data type to be read.
+        type (Type, optional): Data type to be read. Defaults to `Type.EXTENDED`.
         compressed (bool, optional): True if file is compressed, False otherwise.
             Defaults to `True`.
 
@@ -131,7 +132,7 @@ def write(
         filename (str): Filename of a geometry file.
         data (dict): Dictionary representation of a geometry file.
         type (Type, optional): Data type to be written. Defaults to `Type.EXTENDED`.
-        compressed (bool, optional): `True` if file should be compressed, `False` 
+        compressed (bool, optional): `True` if file should be compressed, `False`
             otherwise. Defaults to `True`.
     """
     array_data = _dict_to_ndarray(data, type)
@@ -157,7 +158,7 @@ def write_ndarray(filename: str, data: ndarray, compressed: bool = True):
         f.write(data.tobytes())
 
 
-def get_basic(
+def build(
     filename: str, shape: Tuple[int, int, int], spacing: Tuple[float, float, float]
 ) -> Tuple[str, dict, Type]:
     """Create a basic geometry.
@@ -174,7 +175,7 @@ def get_basic(
         "spacing": spacing,
         "basic_footer": 24,
     }
-    return geo_filename, geo_data, Type.BASIC
+    return geo_filename, geo_data
 
 
 def _get_basename(path: Path) -> Path:
@@ -194,7 +195,7 @@ def _get_basename(path: Path) -> Path:
     return path.with_suffix("")
 
 
-def _validate_data_type(data: np.ndarray) -> bool:
+def _validate_data_type(data: Optional[np.ndarray]) -> bool:
     """Validate the data type."""
     if not isinstance(data, np.ndarray):
         return False

micpy/matplotlib.py

@@ -1,6 +1,4 @@
-import os
-from distutils.version import LooseVersion
-
+from packaging import version
 
 try:
     import matplotlib
@@ -13,31 +11,30 @@ except ImportError:
 
 def _register_colormaps():
     colors = [
-        "#1102d8",  # 17, 2, 216
-        "#3007ba",  # 48, 7, 186
-        "#500b9d",  # 80, 11, 157
-        "#6f0e81",  # 111, 14, 129
-        "#8d1364",  # 141, 19, 100
-        "#ac1748",  # 172, 23, 72
-        "#cb1b2b",  # 203, 27, 43
-        "#ea1e0f",  # 234, 30, 15
-        "#f83605",  # 248, 54, 5
-        "#fa600f",  # 250, 96, 15
-        "#fb8817",  # 251, 136, 23
-        "#fdb120",  # 253, 177, 32
-        "#ffda29",  # 255, 218, 41
-        "#ffed4d",  # 255, 237, 77
-        "#fff380",  # 255, 243, 128
-        "#fffbb4",  # 255, 251, 180
+        "#1102d8",
+        "#3007ba",
+        "#500b9d",
+        "#6f0e81",
+        "#8d1364",
+        "#ac1748",
+        "#cb1b2b",
+        "#ea1e0f",
+        "#f83605",
+        "#fa600f",
+        "#fb8817",
+        "#fdb120",
+        "#ffda29",
+        "#ffed4d",
+        "#fff380",
+        "#fffbb4",
     ]
-    version = LooseVersion(matplotlib.__version__) >= LooseVersion("3.7")
 
     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)
 
-    if version:
+    if version.parse(matplotlib.__version__) >= version.parse("3.7"):
         register = matplotlib.colormaps.register
         register(colormap)
         register(colormap_r)
@@ -47,28 +44,6 @@ def _register_colormaps():
         register("micpy_r", colormap_r)
 
 
-def _set_aixvipmap_font():
-    font = "IBM Plex Sans"
-    if font in matplotlib.font_manager.get_font_names():
-        pyplot.rcParams["font.family"] = font
-
-
-def _set_aixvipmap_colors():
-    colors = [
-        "#00549F",
-        "#F6A800",
-        "#57AB27",
-        "#CC071E",
-        "#612158",
-        "#006165",
-        "#E30066",
-        "#0098A1",
-        "#BDCD00",
-        "#0098A1",
-    ]
-    pyplot.rcParams["axes.prop_cycle"] = pyplot.cycler(color=colors)
-
-
 def configure():
     if not matplotlib:
         return
@@ -77,7 +52,3 @@ def configure():
         _register_colormaps()
     except ValueError:
         pass
-
-    if "AIXVIPMAP_HOME" in os.environ:
-        _set_aixvipmap_font()
-        _set_aixvipmap_colors()

micpy/utils.py

@@ -4,17 +4,6 @@ import sys
 import time
 
 
-def convert_si(value, unit_in, unit_out):
-    """Convert value from one SI unit to another SI unit."""
-    SI = {"μm": 0.000001, "mm": 0.001, "cm": 0.01, "m": 1.0}
-
-    if isinstance(value, (float, int)):
-        return value * SI[unit_in] / SI[unit_out]
-    elif isinstance(value, (tuple, list)):
-        return [v * SI[unit_in] / SI[unit_out] for v in value]
-    raise ValueError("Unsupported value type.")
-
-
 def progress_indicator(iterable, description="Progress", unit="Iteration", start=1):
     """Progress indicator for iterable."""
 

micpy/version.py

@@ -1 +1 @@
-__version__ = "0.2.17b0"
+__version__ = "0.3.1b0"

micress_micpy-0.3.1b0.dist-info/METADATA

@@ -0,0 +1,46 @@
+Metadata-Version: 2.1
+Name: micress-micpy
+Version: 0.3.1b0
+Summary: MicPy is a Python package to facilitate MICRESS workflows.
+Author: Lukas Koschmieder
+Author-email: l.koschmieder@access-technology.de
+License: BSD-3-Clause (Copyright (c) 2024 Access e.V.)
+Keywords: MICRESS
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.9
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: matplotlib
+Requires-Dist: pandas
+
+<center>
+
+![MicPy logo](https://docs.micress.de/micpy/images/micpy-logo.png)
+
+</center>
+
+# MicPy
+
+MicPy is a Python package to facilitate [MICRESS](https://www.micress.de) workflows. Whether you aim to visualize, convert, or manipulate MICRESS data, MicPy provides the necessary tools.
+
+## Installation
+
+```
+pip install micress-micpy
+```
+
+## Dependencies
+
+MicPy requires the following dependencies:
+
+- Python (>= 3.9)
+- Pandas (>= 1.1)
+- Matplotlib (>= 3) as an optional dependency for plotting
+
+## Documentation
+
+https://docs.micress.de/micpy

micress_micpy-0.3.1b0.dist-info/RECORD

@@ -0,0 +1,12 @@
+micpy/__init__.py,sha256=7wQUaseppjQYZW1iAVNm2WSDjvBLlqtY8tiHsfDaW5Q,148
+micpy/bin.py,sha256=3xclBJLbbBW9N8w9izFEgFh3S2yKgYzrdQKjJsXftSU,25831
+micpy/geo.py,sha256=lVRTtPnTEykkSXNyLm3wnxXOwz72PFu0Spv8ZGHyUHo,7417
+micpy/matplotlib.py,sha256=GF2ghyBORC5RRjW00DdsHu5aSkpMFdI9wqg6d_psPsI,1198
+micpy/tab.py,sha256=QCnfggxRWkKgS9-zGj8kyCjhfUw7QeTgGZWedHh4MTw,3548
+micpy/utils.py,sha256=Kt1AvhMvWer9uftbb88X7N27aXtQdJl26grHmmm2vOQ,859
+micpy/version.py,sha256=o80l_DIF5j_g0KFIiC8SP5DtyipTIK4_NRfkjHjz1Mk,25
+micress_micpy-0.3.1b0.dist-info/LICENSE,sha256=seHdCiArizUoWZ6bEFg6N3K2ZtfPK35wvOwg0kH-f6o,1488
+micress_micpy-0.3.1b0.dist-info/METADATA,sha256=UFUfB1rNxBQxj1OlMO9Qo3YX92weqibYc59tujF8lBo,1229
+micress_micpy-0.3.1b0.dist-info/WHEEL,sha256=yQN5g4mg4AybRjkgi-9yy4iQEFibGQmlz78Pik5Or-A,92
+micress_micpy-0.3.1b0.dist-info/top_level.txt,sha256=RiopkpW0AGNYdtOW2eQUWgm3yHGC13q9pWlHb2alhiE,6
+micress_micpy-0.3.1b0.dist-info/RECORD,,

micress_micpy-0.2.17b0.dist-info/METADATA

@@ -1,186 +0,0 @@
-Metadata-Version: 2.1
-Name: micress-micpy
-Version: 0.2.17b0
-Summary: MicPy is a Python package to facilitate MICRESS workflows.
-Author: Lukas Koschmieder
-Author-email: l.koschmieder@access-technology.de
-License: BSD-3-Clause (Copyright (c) 2024 Access e.V.)
-Keywords: MICRESS
-Classifier: Development Status :: 4 - Beta
-Classifier: Intended Audience :: Science/Research
-Classifier: Natural Language :: English
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3.9
-Requires-Python: >=3.9
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: matplotlib
-Requires-Dist: pandas
-
-<center>
-
-![MicPy logo](https://cloud.micress.de/index.php/apps/files_sharing/publicpreview/ggEnRBmQEoNFLri?file=/&fileId=8458&x=1920&y=1080&a=true&etag=65c4cbfc544ae)
-
-</center>
-
-# MicPy
-
-MicPy is a Python package to facilitate [MICRESS](https://www.micress.de) workflows. Whether you aim to visualize, convert, or manipulate MICRESS data, MicPy provides the necessary tools.
-
-## Installation
-
-```
-pip install micress-micpy
-```
-
-## Dependencies
-
-MicPy requires the following dependencies:
-
-- Python (>= 3.9)
-- Pandas (>= 1.1)
-- Matplotlib (>= 3) as an optional dependency for plotting
-
-## Examples
-
-Below are some examples demonstrating how to use MicPy.
-
-### `bin` module
-
-#### Read one field at a time
-
-```python
-from micpy import bin
-
-for field in bin.File("A001_Delta_Gamma.conc1"):
-    print(field)
-```
-
-#### Read all fields
-
-```python
-
-from micpy import bin
-
-with bin.File("A001_Delta_Gamma.conc1") as file:
-    fields = file.read()
-
-print(fields)
-```
-
-#### Read a subset of fields providing a list of indices
-
-```python
-from micpy import bin
-
-with bin.File("A001_Delta_Gamma.conc1") as file:
-    fields = file.read([0, 1, -2, -1])
-
-print(fields)
-```
-
-#### Read a subset of fields providing a condition function
-
-```python
-from micpy import bin
-
-with bin.File("A001_Delta_Gamma.conc1") as file:
-    fields = file.read(lambda field: field.time >= 10 and field.time <= 20)
-
-print(fields)
-```
-
-#### Read fields opening and closing the file manually
-
-```python
-from micpy import bin
-
-file = bin.File("A001_Delta_Gamma.conc1")
-
-file.open()
-
-first_field = file.read(0)
-second_field = file.read(1)
-
-file.close()
-
-print(first_field, second_field)
-```
-
-#### Plot a field
-
-```python
-from micpy import bin
-
-with bin.File("A001_Delta_Gamma.conc1") as file:
-    field = file[-1]
-
-fig, ax = field.plot()
-```
-
-#### Plot a list of fields normalizing the data
-
-```python
-from micpy import bin
-
-with bin.File("A001_Delta_Gamma.conc1") as file:
-    fields = file[[0, 1, -2, -1]]
-
-fig, ax = fields.plot(normalize=True, figsize=(8, 8))
-```
-
-#### Plot a specific plane of a field
-
-```python
-from micpy import bin
-
-with bin.File("A005_Grain_Growth_Misorientation_3D.korn") as file:
-    field = file[0]
-
-fig, ax = field.plot(plane="xy", slice=50)
-```
-
-### `tab` module
-
-#### Read a table
-
-```python
-from micpy import tab
-
-table = tab.read("A001_Delta_Gamma.TabF")
-```
-
-#### Plot a table
-
-```python
-from micpy import tab
-
-table = tab.read("A001_Delta_Gamma.TabF")
-
-fig, ax = table.plot(x=1, y=[2, 3, 4])
-```
-
-#### Extract a subset of a table
-
-```python
-from micpy import tab
-
-table = tab.read("A001_Delta_Gamma.TabF")
-
-table.loc[
-    table["Fraction Phase 2 FCC_A1"] > 0,
-    ["Temperature [K]", "Fraction Phase 1 BCC_A2", "Fraction Phase 2 FCC_A1"]
-]
-```
-
-#### Convert a table to different file formats
-
-```python
-from micpy import tab
-
-table = tab.read("A001_Delta_Gamma.TabF")
-
-table.to_csv("A001_Delta_Gamma.TabF.csv")
-table.to_excel("A001_Delta_Gamma.TabF.xlsx")
-table.to_json("A001_Delta_Gamma.TabF.json")
-```

micress_micpy-0.2.17b0.dist-info/RECORD

@@ -1,12 +0,0 @@
-micpy/__init__.py,sha256=7wQUaseppjQYZW1iAVNm2WSDjvBLlqtY8tiHsfDaW5Q,148
-micpy/bin.py,sha256=GzY0Gva3wp0n6vcKqv9yR3zzcg6ib1GtFzCKv8yXsR0,26777
-micpy/geo.py,sha256=pwMDSwG8i9XqmX2DWrSWuvtpni_Z7VLO586LNgEuORk,7366
-micpy/matplotlib.py,sha256=SLfk7H1v5L7H_L-a_FqobS0nKY3eSbFRF01h433SpVQ,2090
-micpy/tab.py,sha256=QCnfggxRWkKgS9-zGj8kyCjhfUw7QeTgGZWedHh4MTw,3548
-micpy/utils.py,sha256=-JS5SRqH4QMD6_pXBKPVw5zPNTbaqkcOUu9ej5Gi0QU,1282
-micpy/version.py,sha256=JOpzAb63fvBI_jPvlsPW3cGBI7CByIaM5IXZyr6SXOU,26
-micress_micpy-0.2.17b0.dist-info/LICENSE,sha256=seHdCiArizUoWZ6bEFg6N3K2ZtfPK35wvOwg0kH-f6o,1488
-micress_micpy-0.2.17b0.dist-info/METADATA,sha256=z2YjOYSHKOAtMtFk1NXS1bHkV31fKPHJcJZllNB1ZjQ,3824
-micress_micpy-0.2.17b0.dist-info/WHEEL,sha256=yQN5g4mg4AybRjkgi-9yy4iQEFibGQmlz78Pik5Or-A,92
-micress_micpy-0.2.17b0.dist-info/top_level.txt,sha256=RiopkpW0AGNYdtOW2eQUWgm3yHGC13q9pWlHb2alhiE,6
-micress_micpy-0.2.17b0.dist-info/RECORD,,