prefab 1.2.0__py3-none-any.whl → 1.4.0__py3-none-any.whl

prefab/device.py

@@ -1,26 +1,31 @@
-"""Provides the Device class for representing photonic devices."""
+"""
+Core device representation and manipulation for photonic geometries.
 
-from typing import TYPE_CHECKING, Literal, Optional
+This module provides the Device class for representing planar photonic device
+geometries and performing operations on them. It includes buffer zone management,
+prediction and correction of nanofabrication outcomes, visualization capabilities,
+and export functions to various formats. The module also supports geometric
+transformations (rotation, dilation, erosion), image processing operations (blur,
+binarization), and comparison tools for analyzing fabrication deviations.
+"""
+
+from typing import Any, Literal
 
 import cv2
 import gdstk
 import matplotlib.pyplot as plt
 import numpy as np
+import numpy.typing as npt
 from matplotlib.axes import Axes
 from matplotlib.patches import Rectangle
 from PIL import Image
-from pydantic import BaseModel, Field, model_validator, validator
+from pydantic import BaseModel, Field, field_validator, model_validator
 from scipy.ndimage import distance_transform_edt
-from skimage import measure
 
-from . import compare, geometry
+from . import geometry
 from .models import Model
 from .predict import predict_array
 
-if TYPE_CHECKING:
-    import gdsfactory as gf
-    import tidy3d as td
-
 Image.MAX_IMAGE_PIXELS = None
 
 
@@ -33,7 +38,7 @@ class BufferSpec(BaseModel):
     providing extra space for device fabrication processes or for ensuring that the
     device is isolated from surrounding structures.
 
-    Parameters
+    Attributes
     ----------
     mode : dict[str, str]
         A dictionary that defines the buffer mode for each side of the device
@@ -53,8 +58,8 @@ class BufferSpec(BaseModel):
         allowed values ('constant', 'edge', 'none'). Or if any of the thickness values
         are negative.
 
-    Example
-    -------
+    Examples
+    --------
         import prefab as pf
 
         buffer_spec = pf.BufferSpec(
@@ -90,23 +95,25 @@ class BufferSpec(BaseModel):
         }
     )
 
-    @validator("mode", pre=True)
-    def check_mode(cls, v):
+    @field_validator("mode", mode="before")
+    @classmethod
+    def check_mode(cls, v: dict[str, str]) -> dict[str, str]:
         allowed_modes = ["constant", "edge", "none"]
         if not all(mode in allowed_modes for mode in v.values()):
             raise ValueError(f"Buffer mode must be one of {allowed_modes}, got '{v}'.")
         return v
 
-    @validator("thickness")
-    def check_thickness(cls, v):
+    @field_validator("thickness")
+    @classmethod
+    def check_thickness(cls, v: dict[str, int]) -> dict[str, int]:
         if not all(t >= 0 for t in v.values()):
             raise ValueError("All thickness values must be greater than or equal to 0.")
         return v
 
     @model_validator(mode="after")
-    def check_none_thickness(cls, values):
-        mode = values.mode
-        thickness = values.thickness
+    def check_none_thickness(self) -> "BufferSpec":
+        mode = self.mode
+        thickness = self.thickness
         for side in mode:
             if mode[side] == "none" and thickness[side] != 0:
                 raise ValueError(
@@ -116,22 +123,22 @@ class BufferSpec(BaseModel):
                 raise ValueError(
                     f"Mode must be 'none' when thickness is 0 for {side} side"
                 )
-        return values
+        return self
 
 
 class Device(BaseModel):
-    device_array: np.ndarray = Field(...)
+    device_array: npt.NDArray[Any] = Field(...)
     buffer_spec: BufferSpec = Field(default_factory=BufferSpec)
 
     class Config:
-        arbitrary_types_allowed = True
+        arbitrary_types_allowed: bool = True
 
     @property
     def shape(self) -> tuple[int, ...]:
         return tuple(self.device_array.shape)
 
     def __init__(
-        self, device_array: np.ndarray, buffer_spec: Optional[BufferSpec] = None
+        self, device_array: npt.NDArray[Any], buffer_spec: BufferSpec | None = None
     ):
         """
         Represents the planar geometry of a photonic device design that will have its
@@ -174,10 +181,10 @@ class Device(BaseModel):
         )
         self._initial_processing()
 
-    def __call__(self, *args, **kwargs):
+    def __call__(self, *args: Any, **kwargs: Any) -> Axes:
         return self.plot(*args, **kwargs)
 
-    def _initial_processing(self):
+    def _initial_processing(self) -> None:
         buffer_thickness = self.buffer_spec.thickness
         buffer_mode = self.buffer_spec.mode
 
@@ -212,7 +219,8 @@ class Device(BaseModel):
         self.device_array = np.expand_dims(self.device_array, axis=-1)
 
     @model_validator(mode="before")
-    def check_device_array(cls, values):
+    @classmethod
+    def check_device_array(cls, values: dict[str, Any]) -> dict[str, Any]:
         device_array = values.get("device_array")
         if not isinstance(device_array, np.ndarray):
             raise ValueError("device_array must be a numpy ndarray.")
@@ -242,7 +250,6 @@ class Device(BaseModel):
         self,
         model: Model,
         binarize: bool = False,
-        gpu: bool = False,
     ) -> "Device":
         """
         Predict the nanofabrication outcome of the device using a specified model.
@@ -255,19 +262,14 @@ class Device(BaseModel):
         ----------
         model : Model
             The model to use for prediction, representing a specific fabrication process
-            and dataset. This model encapsulates details about the fabrication foundry,
-            process, material, technology, thickness, and sidewall presence, as defined
-            in `models.py`. Each model is associated with a version and dataset that
-            detail its creation and the data it was trained on, ensuring the prediction
-            is tailored to specific fabrication parameters.
+            and dataset. This model encapsulates details about the fabrication foundry
+            and process, as defined in `models.py`. Each model is associated with a
+            version and dataset that detail its creation and the data it was trained on,
+            ensuring the prediction is tailored to specific fabrication parameters.
         binarize : bool
             If True, the predicted device geometry will be binarized using a threshold
             method. This is useful for converting probabilistic predictions into binary
             geometries. Defaults to False.
-        gpu : bool
-            If True, the prediction will be performed on a GPU. Defaults to False.
-            Note: The GPU option has more overhead and will take longer for small
-            devices, but will be faster for larger devices.
 
         Returns
         -------
@@ -285,7 +287,6 @@ class Device(BaseModel):
             model=model,
             model_type="p",
             binarize=binarize,
-            gpu=gpu,
         )
         return self.model_copy(update={"device_array": prediction_array})
 
@@ -293,7 +294,6 @@ class Device(BaseModel):
         self,
         model: Model,
         binarize: bool = True,
-        gpu: bool = False,
     ) -> "Device":
         """
         Correct the nanofabrication outcome of the device using a specified model.
@@ -308,19 +308,14 @@ class Device(BaseModel):
         ----------
         model : Model
             The model to use for correction, representing a specific fabrication process
-            and dataset. This model encapsulates details about the fabrication foundry,
-            process, material, technology, thickness, and sidewall presence, as defined
-            in `models.py`. Each model is associated with a version and dataset that
-            detail its creation and the data it was trained on, ensuring the correction
-            is tailored to specific fabrication parameters.
+            and dataset. This model encapsulates details about the fabrication foundry
+            and process, as defined in `models.py`. Each model is associated with a
+            version and dataset that detail its creation and the data it was trained on,
+            ensuring the correction is tailored to specific fabrication parameters.
         binarize : bool
             If True, the corrected device geometry will be binarized using a threshold
             method. This is useful for converting probabilistic corrections into binary
             geometries. Defaults to True.
-        gpu : bool
-            If True, the prediction will be performed on a GPU. Defaults to False.
-            Note: The GPU option has more overhead and will take longer for small
-            devices, but will be faster for larger devices.
 
         Returns
         -------
@@ -338,114 +333,10 @@ class Device(BaseModel):
             model=model,
             model_type="c",
             binarize=binarize,
-            gpu=gpu,
         )
         return self.model_copy(update={"device_array": correction_array})
 
-    def semulate(
-        self,
-        model: Model,
-        gpu: bool = False,
-    ) -> "Device":
-        """
-        Simulate the appearance of the device as if viewed under a scanning electron
-        microscope (SEM).
-
-        This method applies a specified machine learning model to transform the device
-        geometry into a style that resembles an SEM image. This can be useful for
-        visualizing how the device might appear under an SEM, which is often used for
-        inspecting the surface and composition of materials at high magnification.
-
-        Parameters
-        ----------
-        model : Model
-            The model to use for SEMulation, representing a specific fabrication process
-            and dataset. This model encapsulates details about the fabrication foundry,
-            process, material, technology, thickness, and sidewall presence, as defined
-            in `models.py`. Each model is associated with a version and dataset that
-            detail its creation and the data it was trained on, ensuring the SEMulation
-            is tailored to specific fabrication parameters.
-        gpu : bool
-            If True, the prediction will be performed on a GPU. Defaults to False.
-            Note: The GPU option has more overhead and will take longer for small
-            devices, but will be faster for larger devices.
-
-        Notes
-        -----
-        The salt-and-pepper noise is added manually until the model is trained to
-        generate this noise (not a big priority).
-
-        Returns
-        -------
-        Device
-            A new instance of the Device class with its geometry transformed to simulate
-            an SEM image style.
-
-        Raises
-        ------
-        RuntimeError
-            If the prediction service returns an error or if the response from the
-            service cannot be processed correctly.
-        """
-        semulated_array = predict_array(
-            device_array=self.device_array,
-            model=model,
-            model_type="s",
-            binarize=False,
-            gpu=gpu,
-        )
-        semulated_array += np.random.normal(0, 0.03, semulated_array.shape)
-        return self.model_copy(update={"device_array": semulated_array})
-
-    def segment(
-        self,
-        model: Model,
-        gpu: bool = False,
-    ) -> "Device":
-        """
-        Segment a scanning electron microscope (SEM) image into a binary mask.
-
-        This method applies a specified machine learning model to transform a grayscale
-        SEM image into a binary mask, where 1 represents the device structure and 0
-        represents the background. This is useful for extracting the device geometry
-        from experimental SEM images for analysis or comparison with design intent.
-
-        Parameters
-        ----------
-        model : Model
-            The model to use for segmentation, representing a specific fabrication
-            process and dataset. This model encapsulates details about the fabrication
-            foundry, process, material, technology, thickness, and sidewall presence, as
-            defined in `models.py`. Each model is associated with a version and dataset
-            that detail its creation and the data it was trained on, ensuring the
-            segmentation is tailored to specific fabrication parameters.
-        gpu : bool
-            If True, the prediction will be performed on a GPU. Defaults to False.
-            Note: The GPU option has more overhead and will take longer for small
-            devices, but will be faster for larger devices.
-
-        Returns
-        -------
-        Device
-            A new instance of the Device class with its geometry transformed into a
-            binary mask.
-
-        Raises
-        ------
-        RuntimeError
-            If the prediction service returns an error or if the response from the
-            service cannot be processed correctly.
-        """
-        segmented_array = predict_array(
-            device_array=self.normalize().device_array,
-            model=model,
-            model_type="b",
-            binarize=False,
-            gpu=gpu,
-        )
-        return self.model_copy(update={"device_array": segmented_array})
-
-    def to_ndarray(self) -> np.ndarray:
+    def to_ndarray(self) -> npt.NDArray[Any]:
         """
         Converts the device geometry to an ndarray.
 
@@ -473,7 +364,11 @@ class Device(BaseModel):
         ]
         return ndarray
 
-    def to_img(self, img_path: str = "prefab_device.png"):
+    def to_img(
+        self,
+        img_path: str = "prefab_device.png",
+        bounds: tuple[tuple[int, int], tuple[int, int]] | None = None,
+    ) -> None:
         """
         Exports the device geometry as an image file.
 
@@ -486,8 +381,49 @@ class Device(BaseModel):
         img_path : str
             The path where the image file will be saved. If not specified, the image is
             saved as "prefab_device.png" in the current directory.
-        """
-        cv2.imwrite(img_path, 255 * self.flatten().to_ndarray())
+        bounds : Optional[tuple[tuple[int, int], tuple[int, int]]]
+            Specifies the bounds for cropping the device geometry, formatted as
+            ((min_x, min_y), (max_x, max_y)). Negative values count from the end
+            (e.g., -50 means 50 pixels from the edge). If 'max_x' or 'max_y' is set
+            to "end", it will be replaced with the corresponding dimension size of the
+            device array. If None, the entire device geometry is exported.
+        """
+        device_array = self.flatten().to_ndarray()
+
+        if bounds is not None:
+            min_x, min_y = bounds[0]
+            max_x, max_y = bounds[1]
+
+            # Handle negative indices (count from end)
+            if min_x < 0:
+                min_x = device_array.shape[1] + min_x
+            if min_y < 0:
+                min_y = device_array.shape[0] + min_y
+            if max_x != "end" and max_x < 0:
+                max_x = device_array.shape[1] + max_x
+            if max_y != "end" and max_y < 0:
+                max_y = device_array.shape[0] + max_y
+
+            # Clamp to valid range
+            min_x = max(min_x, 0)
+            min_y = max(min_y, 0)
+            max_x = "end" if max_x == "end" else min(max_x, device_array.shape[1])
+            max_y = "end" if max_y == "end" else min(max_y, device_array.shape[0])
+            max_x = device_array.shape[1] if max_x == "end" else max_x
+            max_y = device_array.shape[0] if max_y == "end" else max_y
+
+            if min_x >= max_x or min_y >= max_y:
+                raise ValueError(
+                    "Invalid bounds: min values must be less than max values. "
+                    + f"Got min_x={min_x}, max_x={max_x}, min_y={min_y}, max_y={max_y}"
+                )
+
+            device_array = device_array[
+                device_array.shape[0] - max_y : device_array.shape[0] - min_y,
+                min_x:max_x,
+            ]
+
+        _ = cv2.imwrite(img_path, (255 * device_array).astype(np.uint8))
         print(f"Saved Device image to '{img_path}'")
 
     def to_gds(
@@ -497,7 +433,7 @@ class Device(BaseModel):
         gds_layer: tuple[int, int] = (1, 0),
         contour_approx_mode: int = 2,
         origin: tuple[float, float] = (0.0, 0.0),
-    ):
+    ) -> None:
         """
         Exports the device geometry as a GDSII file.
 
@@ -531,7 +467,7 @@ class Device(BaseModel):
         )
         print(f"Saving GDS to '{gds_path}'...")
         gdstk_library = gdstk.Library()
-        gdstk_library.add(gdstk_cell)
+        _ = gdstk_library.add(gdstk_cell)
         gdstk_library.write_gds(outfile=gds_path, max_points=8190)
 
     def to_gdstk(
@@ -540,7 +476,7 @@ class Device(BaseModel):
         gds_layer: tuple[int, int] = (1, 0),
         contour_approx_mode: int = 2,
         origin: tuple[float, float] = (0.0, 0.0),
-    ):
+    ) -> gdstk.Cell:
         """
         Converts the device geometry to a GDSTK cell object.
 
@@ -652,85 +588,11 @@ class Device(BaseModel):
                     datatype=gds_layer[1],
                 )
         for polygon in processed_polygons:
-            cell.add(polygon)
+            _ = cell.add(polygon)
 
         return cell
 
-    def to_gdsfactory(self) -> "gf.Component":
-        """
-        Convert the device geometry to a gdsfactory Component.
-
-        Returns
-        -------
-        gf.Component
-            A gdsfactory Component object representing the device geometry.
-
-        Raises
-        ------
-        ImportError
-            If the gdsfactory package is not installed.
-        """
-        try:
-            import gdsfactory as gf
-        except ImportError:
-            raise ImportError(
-                "The gdsfactory package is required to use this function; "
-                "try `pip install gdsfactory`."
-            ) from None
-
-        device_array = np.rot90(self.to_ndarray(), k=-1)
-        return gf.read.from_np(device_array, nm_per_pixel=1)
-
-    def to_tidy3d(
-        self,
-        eps0: float,
-        thickness: float,
-    ) -> "td.Structure":
-        """
-        Convert the device geometry to a Tidy3D Structure.
-
-        Parameters
-        ----------
-        eps0 : float
-            The permittivity value to assign to the device array.
-        thickness : float
-            The thickness of the device in the z-direction.
-
-        Returns
-        -------
-        td.Structure
-            A Tidy3D Structure object representing the device geometry.
-
-        Raises
-        ------
-        ImportError
-            If the tidy3d package is not installed.
-        """
-        try:
-            from tidy3d import Box, CustomMedium, SpatialDataArray, Structure, inf
-        except ImportError:
-            raise ImportError(
-                "The tidy3d package is required to use this function; "
-                "try `pip install tidy3d`."
-            ) from None
-
-        X = np.linspace(-self.shape[1] / 2000, self.shape[1] / 2000, self.shape[1])
-        Y = np.linspace(-self.shape[0] / 2000, self.shape[0] / 2000, self.shape[0])
-        Z = np.array([0])
-
-        device_array = np.rot90(np.fliplr(self.device_array), k=1)
-        eps_array = np.where(device_array >= 1.0, eps0, device_array)
-        eps_array = np.where(eps_array < 1.0, 1.0, eps_array)
-        eps_dataset = SpatialDataArray(eps_array, coords=dict(x=X, y=Y, z=Z))
-        medium = CustomMedium.from_eps_raw(eps_dataset)
-        return Structure(
-            geometry=Box(center=(0, 0, 0), size=(inf, inf, thickness), attrs={}),
-            medium=medium,
-            name="device",
-            attrs={},
-        )
-
-    def to_3d(self, thickness_nm: int) -> np.ndarray:
+    def to_3d(self, thickness_nm: int) -> npt.NDArray[Any]:
         """
         Convert the 2D device geometry into a 3D representation.
 
@@ -764,62 +626,33 @@ class Device(BaseModel):
             layered_array[:, :, i] = dt_interp >= 0
         return layered_array
 
-    def to_stl(self, thickness_nm: int, filename: str = "prefab_device.stl"):
-        """
-        Export the device geometry as an STL file.
-
-        Parameters
-        ----------
-        thickness_nm : int
-            The thickness of the 3D representation in nanometers.
-        filename : str
-            The name of the STL file to save. Defaults to "prefab_device.stl".
-
-        Raises
-        ------
-        ValueError
-            If the thickness is not a positive integer.
-        ImportError
-            If the numpy-stl package is not installed.
-        """
-        try:
-            from stl import mesh  # type: ignore
-        except ImportError:
-            raise ImportError(
-                "The stl package is required to use this function; "
-                "try `pip install numpy-stl`."
-            ) from None
-
-        if thickness_nm <= 0:
-            raise ValueError("Thickness must be a positive integer.")
-
-        layered_array = self.to_3d(thickness_nm)
-        layered_array = np.pad(
-            layered_array, ((0, 0), (0, 0), (10, 10)), mode="constant"
-        )
-        verts, faces, _, _ = measure.marching_cubes(layered_array, level=0.5)
-        cube = mesh.Mesh(np.zeros(faces.shape[0], dtype=mesh.Mesh.dtype))
-        for i, f in enumerate(faces):
-            for j in range(3):
-                cube.vectors[i][j] = verts[f[j], :]
-        cube.save(filename)
-        print(f"Saved Device to '{filename}'")
-
     def _plot_base(
         self,
-        plot_array: np.ndarray,
+        plot_array: npt.NDArray[Any],
         show_buffer: bool,
-        bounds: Optional[tuple[tuple[int, int], tuple[int, int]]],
-        ax: Optional[Axes],
-        **kwargs,
+        bounds: tuple[tuple[int, int], tuple[int, int]] | None,
+        ax: Axes | None,
+        **kwargs: Any,
     ) -> tuple[plt.cm.ScalarMappable, Axes]:
         if ax is None:
             _, ax = plt.subplots()
-        ax.set_ylabel("y (nm)")
-        ax.set_xlabel("x (nm)")
+        _ = ax.set_ylabel("y (nm)")
+        _ = ax.set_xlabel("x (nm)")
 
         min_x, min_y = (0, 0) if bounds is None else bounds[0]
         max_x, max_y = plot_array.shape[::-1] if bounds is None else bounds[1]
+
+        # Handle negative indices (count from end)
+        if min_x < 0:
+            min_x = plot_array.shape[1] + min_x
+        if min_y < 0:
+            min_y = plot_array.shape[0] + min_y
+        if max_x != "end" and max_x < 0:
+            max_x = plot_array.shape[1] + max_x
+        if max_y != "end" and max_y < 0:
+            max_y = plot_array.shape[0] + max_y
+
+        # Clamp to valid range
         min_x = max(min_x, 0)
         min_y = max(min_y, 0)
         max_x = "end" if max_x == "end" else min(max_x, plot_array.shape[1])
@@ -872,10 +705,10 @@ class Device(BaseModel):
     def plot(
         self,
         show_buffer: bool = True,
-        bounds: Optional[tuple[tuple[int, int], tuple[int, int]]] = None,
-        level: Optional[int] = None,
-        ax: Optional[Axes] = None,
-        **kwargs,
+        bounds: tuple[tuple[int, int], tuple[int, int]] | None = None,
+        level: int | None = None,
+        ax: Axes | None = None,
+        **kwargs: Any,
     ) -> Axes:
         """
         Visualizes the device geometry.
@@ -891,9 +724,10 @@ class Device(BaseModel):
             If True, visualizes the buffer zones around the device. Defaults to True.
         bounds : Optional[tuple[tuple[int, int], tuple[int, int]]], optional
             Specifies the bounds for zooming into the device geometry, formatted as
-            ((min_x, min_y), (max_x, max_y)). If 'max_x' or 'max_y' is set to "end", it
-            will be replaced with the corresponding dimension size of the device array.
-            If None, the entire device geometry is visualized.
+            ((min_x, min_y), (max_x, max_y)). Negative values count from the end
+            (e.g., -50 means 50 pixels from the edge). If 'max_x' or 'max_y' is set
+            to "end", it will be replaced with the corresponding dimension size of the
+            device array. If None, the entire device geometry is visualized.
         level : int
             The vertical layer to plot. If None, the device geometry is flattened.
             Defaults to None.
@@ -924,14 +758,14 @@ class Device(BaseModel):
 
     def plot_contour(
         self,
-        linewidth: Optional[int] = None,
-        # label: Optional[str] = "Device contour",
+        linewidth: int | None = None,
+        # label: str | None = "Device contour",
         show_buffer: bool = True,
-        bounds: Optional[tuple[tuple[int, int], tuple[int, int]]] = None,
-        level: Optional[int] = None,
-        ax: Optional[Axes] = None,
-        **kwargs,
-    ):
+        bounds: tuple[tuple[int, int], tuple[int, int]] | None = None,
+        level: int | None = None,
+        ax: Axes | None = None,
+        **kwargs: Any,
+    ) -> Axes:
         """
         Visualizes the contour of the device geometry.
 
@@ -950,9 +784,10 @@ class Device(BaseModel):
             it is set to True.
         bounds : Optional[tuple[tuple[int, int], tuple[int, int]]]
             Specifies the bounds for zooming into the device geometry, formatted as
-            ((min_x, min_y), (max_x, max_y)). If 'max_x' or 'max_y' is set to "end", it
-            will be replaced with the corresponding dimension size of the device array.
-            If None, the entire device geometry is visualized.
+            ((min_x, min_y), (max_x, max_y)). Negative values count from the end
+            (e.g., -50 means 50 pixels from the edge). If 'max_x' or 'max_y' is set
+            to "end", it will be replaced with the corresponding dimension size of the
+            device array. If None, the entire device geometry is visualized.
         level : int
             The vertical layer to plot. If None, the device geometry is flattened.
             Defaults to None.
@@ -974,8 +809,9 @@ class Device(BaseModel):
             device_array = self.device_array[:, :, level]
 
         kwargs.setdefault("cmap", "spring")
-        if linewidth is None:
-            linewidth = device_array.shape[0] // 100
+        linewidth_value = (
+            linewidth if linewidth is not None else device_array.shape[0] // 100
+        )
 
         contours, _ = cv2.findContours(
             geometry.binarize_hard(device_array).astype(np.uint8),
@@ -983,7 +819,7 @@ class Device(BaseModel):
             cv2.CHAIN_APPROX_SIMPLE,
         )
         contour_array = np.zeros_like(device_array, dtype=np.uint8)
-        cv2.drawContours(contour_array, contours, -1, (255,), linewidth)
+        _ = cv2.drawContours(contour_array, contours, -1, (255,), linewidth_value)
         contour_array = np.ma.masked_equal(contour_array, 0)
 
         _, ax = self._plot_base(
@@ -1001,11 +837,11 @@ class Device(BaseModel):
     def plot_uncertainty(
         self,
         show_buffer: bool = True,
-        bounds: Optional[tuple[tuple[int, int], tuple[int, int]]] = None,
-        level: Optional[int] = None,
-        ax: Optional[Axes] = None,
-        **kwargs,
-    ):
+        bounds: tuple[tuple[int, int], tuple[int, int]] | None = None,
+        level: int | None = None,
+        ax: Axes | None = None,
+        **kwargs: Any,
+    ) -> Axes:
         """
         Visualizes the uncertainty in the edge positions of the predicted device.
 
@@ -1023,9 +859,10 @@ class Device(BaseModel):
             default, it is set to True.
         bounds : Optional[tuple[tuple[int, int], tuple[int, int]]]
             Specifies the bounds for zooming into the device geometry, formatted as
-            ((min_x, min_y), (max_x, max_y)). If 'max_x' or 'max_y' is set to "end", it
-            will be replaced with the corresponding dimension size of the device array.
-            If None, the entire device geometry is visualized.
+            ((min_x, min_y), (max_x, max_y)). Negative values count from the end
+            (e.g., -50 means 50 pixels from the edge). If 'max_x' or 'max_y' is set
+            to "end", it will be replaced with the corresponding dimension size of the
+            device array. If None, the entire device geometry is visualized.
         level : int
             The vertical layer to plot. If None, the device geometry is flattened.
             Defaults to None.
@@ -1064,10 +901,10 @@ class Device(BaseModel):
         self,
         ref_device: "Device",
         show_buffer: bool = True,
-        bounds: Optional[tuple[tuple[int, int], tuple[int, int]]] = None,
-        level: Optional[int] = None,
-        ax: Optional[Axes] = None,
-        **kwargs,
+        bounds: tuple[tuple[int, int], tuple[int, int]] | None = None,
+        level: int | None = None,
+        ax: Axes | None = None,
+        **kwargs: Any,
     ) -> Axes:
         """
         Visualizes the comparison between the current device geometry and a reference
@@ -1085,9 +922,10 @@ class Device(BaseModel):
             If True, visualizes the buffer zones around the device. Defaults to True.
         bounds : Optional[tuple[tuple[int, int], tuple[int, int]]]
             Specifies the bounds for zooming into the device geometry, formatted as
-            ((min_x, min_y), (max_x, max_y)). If 'max_x' or 'max_y' is set to "end", it
-            will be replaced with the corresponding dimension size of the device array.
-            If None, the entire device geometry is visualized.
+            ((min_x, min_y), (max_x, max_y)). Negative values count from the end
+            (e.g., -50 means 50 pixels from the edge). If 'max_x' or 'max_y' is set
+            to "end", it will be replaced with the corresponding dimension size of the
+            device array. If None, the entire device geometry is visualized.
         level : int
             The vertical layer to plot. If None, the device geometry is flattened.
             Defaults to None.
@@ -1123,7 +961,7 @@ class Device(BaseModel):
         cbar.set_label("Added (a.u.)                        Removed (a.u.)")
         return ax
 
-    def _add_buffer_visualization(self, ax: Axes):
+    def _add_buffer_visualization(self, ax: Axes) -> None:
         plot_array = self.device_array
 
         buffer_thickness = self.buffer_spec.thickness
@@ -1138,7 +976,7 @@ class Device(BaseModel):
             edgecolor="black",
             linewidth=1,
         )
-        ax.add_patch(mid_rect)
+        _ = ax.add_patch(mid_rect)
 
         top_rect = Rectangle(
             (0, 0),
@@ -1147,7 +985,7 @@ class Device(BaseModel):
             facecolor=buffer_fill,
             hatch=buffer_hatch,
         )
-        ax.add_patch(top_rect)
+        _ = ax.add_patch(top_rect)
 
         bottom_rect = Rectangle(
             (0, plot_array.shape[0] - buffer_thickness["bottom"]),
@@ -1156,7 +994,7 @@ class Device(BaseModel):
             facecolor=buffer_fill,
             hatch=buffer_hatch,
         )
-        ax.add_patch(bottom_rect)
+        _ = ax.add_patch(bottom_rect)
 
         left_rect = Rectangle(
             (0, buffer_thickness["top"]),
@@ -1165,7 +1003,7 @@ class Device(BaseModel):
             facecolor=buffer_fill,
             hatch=buffer_hatch,
         )
-        ax.add_patch(left_rect)
+        _ = ax.add_patch(left_rect)
 
         right_rect = Rectangle(
             (
@@ -1177,7 +1015,7 @@ class Device(BaseModel):
             facecolor=buffer_fill,
             hatch=buffer_hatch,
         )
-        ax.add_patch(right_rect)
+        _ = ax.add_patch(right_rect)
 
     def normalize(self) -> "Device":
         """
@@ -1238,7 +1076,7 @@ class Device(BaseModel):
             update={"device_array": binarized_device_array.astype(np.uint8)}
         )
 
-    def binarize_monte_carlo(
+    def binarize_with_roughness(
         self,
         noise_magnitude: float = 2.0,
         blur_radius: float = 8.0,
@@ -1274,7 +1112,7 @@ class Device(BaseModel):
         Device
             A new instance of the Device with the binarized geometry.
         """
-        binarized_device_array = geometry.binarize_monte_carlo(
+        binarized_device_array = geometry.binarize_with_roughness(
             device_array=self.device_array,
             noise_magnitude=noise_magnitude,
             blur_radius=blur_radius,
@@ -1418,7 +1256,7 @@ class Device(BaseModel):
         flattened_device_array = geometry.flatten(device_array=self.device_array)
         return self.model_copy(update={"device_array": flattened_device_array})
 
-    def get_uncertainty(self) -> np.ndarray:
+    def get_uncertainty(self) -> npt.NDArray[Any]:
         """
         Calculate the uncertainty in the edge positions of the predicted device.
 
@@ -1434,96 +1272,3 @@ class Device(BaseModel):
             with higher values indicating greater uncertainty.
         """
         return 1 - 2 * np.abs(0.5 - self.device_array)
-
-    def enforce_feature_size(
-        self, min_feature_size: int, strel: str = "disk"
-    ) -> "Device":
-        """
-        Enforce a minimum feature size on the device geometry.
-
-        This method applies morphological operations to ensure that all features in the
-        device geometry are at least the specified minimum size. It uses either a disk
-        or square structuring element for the operations.
-
-        Notes
-        -----
-        This function does not guarantee that the minimum feature size is enforced in
-        all cases. A better process is needed.
-
-        Parameters
-        ----------
-        min_feature_size : int
-            The minimum feature size to enforce, in nanometers.
-        strel : str
-            The type of structuring element to use. Can be either "disk" or "square".
-            Defaults to "disk".
-
-        Returns
-        -------
-        Device
-            A new instance of the Device with the modified geometry.
-
-        Raises
-        ------
-        ValueError
-            If an invalid structuring element type is specified.
-        """
-        modified_geometry = geometry.enforce_feature_size(
-            device_array=self.device_array,
-            min_feature_size=min_feature_size,
-            strel=strel,
-        )
-        return self.model_copy(update={"device_array": modified_geometry})
-
-    def check_feature_size(self, min_feature_size: int, strel: str = "disk"):
-        """
-        Check and visualize the effect of enforcing a minimum feature size on the device
-        geometry.
-
-        This method enforces a minimum feature size on the device geometry using the
-        specified structuring element, compares the modified geometry with the original,
-        and plots the differences. It also calculates and prints the Hamming distance
-        between the original and modified geometries, providing a measure of the changes
-        introduced by the feature size enforcement.
-
-        Notes
-        -----
-        This is not a design-rule-checking function, but it can be useful for quick
-        checks.
-
-        Parameters
-        ----------
-        min_feature_size : int
-            The minimum feature size to enforce, in nanometers.
-        strel : str
-            The type of structuring element to use. Can be either "disk" or "square".
-            Defaults to "disk".
-
-        Raises
-        ------
-        ValueError
-            If an invalid structuring element type is specified or if min_feature_size
-            is not a positive integer.
-        """
-        if min_feature_size <= 0:
-            raise ValueError("min_feature_size must be a positive integer.")
-
-        enforced_device = self.enforce_feature_size(min_feature_size, strel)
-
-        difference = np.abs(
-            enforced_device.device_array[:, :, 0] - self.device_array[:, :, 0]
-        )
-        _, ax = self._plot_base(
-            plot_array=difference,
-            show_buffer=False,
-            ax=None,
-            bounds=None,
-            cmap="jet",
-        )
-
-        hamming_distance = compare.hamming_distance(self, enforced_device)
-        print(
-            f"Feature size check with minimum size {min_feature_size} "
-            f"using '{strel}' structuring element resulted in a Hamming "
-            f"distance of: {hamming_distance}"
-        )