prefab 1.0.1__py3-none-any.whl → 1.0.3__py3-none-any.whl

prefab/__init__.py

@@ -5,7 +5,9 @@ Usage:
     import prefab as pf
 """
 
-from . import compare, geometry, read
+__version__ = "1.0.3"
+
+from . import compare, geometry, read, shapes
 from .device import BufferSpec, Device
 from .models import models
 
@@ -14,6 +16,8 @@ __all__ = [
     "BufferSpec",
     "geometry",
     "read",
+    "shapes",
     "compare",
     "models",
+    "__version__",
 ]

prefab/compare.py

@@ -7,40 +7,40 @@ from .device import Device
 
 def mean_squared_error(device_a: Device, device_b: Device) -> float:
     """
-    Calculate the mean squared error (MSE) between two non-binarized devices.
+    Calculate the mean squared error (MSE) between two non-binarized devices. A lower
+    value indicates more similarity.
 
     Parameters
     ----------
     device_a : Device
-        The first device.
+        The first device (non-binarized).
     device_b : Device
-        The second device.
+        The second device (non-binarized).
 
     Returns
     -------
     float
-        The mean squared error between two devices. A lower value indicates more
-        similarity.
+        The mean squared error between two devices.
     """
     return np.mean((device_a.device_array - device_b.device_array) ** 2)
 
 
 def intersection_over_union(device_a: Device, device_b: Device) -> float:
     """
-    Calculates the Intersection over Union (IoU) between two binary devices.
+    Calculates the Intersection over Union (IoU) between two binary devices. A value
+    closer to 1 indicates more similarity (more overlap).
 
     Parameters
     ----------
     device_a : Device
-        The first device.
+        The first device (binarized).
     device_b : Device
-        The second device.
+        The second device (binarized).
 
     Returns
     -------
     float
-        The Intersection over Union between two devices. A value closer to 1 indicates
-        more similarity (more overlap).
+        The Intersection over Union between two devices.
     """
     return np.sum(
         np.logical_and(device_a.device_array, device_b.device_array)
@@ -49,40 +49,42 @@ def intersection_over_union(device_a: Device, device_b: Device) -> float:
 
 def hamming_distance(device_a: Device, device_b: Device) -> int:
     """
-    Calculates the Hamming distance between two binary devices.
+    Calculates the Hamming distance between two binary devices. A lower value indicates
+    more similarity. The Hamming distance is calculated as the number of positions at
+    which the corresponding pixels are different.
 
     Parameters
     ----------
     device_a : Device
-        The first device.
+        The first device (binarized).
     device_b : Device
-        The second device.
+        The second device (binarized).
 
     Returns
     -------
     int
-        The Hamming distance between two devices. A lower value indicates more
-        similarity.
+        The Hamming distance between two devices.
     """
     return np.sum(device_a.device_array != device_b.device_array)
 
 
 def dice_coefficient(device_a: Device, device_b: Device) -> float:
     """
-    Calculates the Dice coefficient between two binary devices.
+    Calculates the Dice coefficient between two binary devices. A value closer to 1
+    indicates more similarity. The Dice coefficient is calculated as twice the number of
+    pixels in common divided by the total number of pixels in the two devices.
 
     Parameters
     ----------
     device_a : Device
-        The first device.
+        The first device (binarized).
     device_b : Device
-        The second device.
+        The second device (binarized).
 
     Returns
     -------
     float
-        The Dice coefficient between two devices. A value closer to 1 indicates more
-        similarity.
+        The Dice coefficient between two devices.
     """
     intersection = 2.0 * np.sum(
         np.logical_and(device_a.device_array, device_b.device_array)

prefab/device.py

@@ -21,6 +21,8 @@ from tqdm import tqdm
 from . import geometry
 from .models import Model
 
+Image.MAX_IMAGE_PIXELS = None
+
 
 class BufferSpec(BaseModel):
     """
@@ -38,14 +40,16 @@ class BufferSpec(BaseModel):
         ('top', 'bottom', 'left', 'right'), where 'constant' is used for isolated
         structures and 'edge' is utilized for preserving the edge, such as for waveguide
         connections.
-    thickness : conint(gt=0)
-        The thickness of the buffer zone around the device. Must be greater than 0.
+    thickness : dict[str, conint(gt=0)]
+        A dictionary that defines the thickness of the buffer zone for each side of the
+        device ('top', 'bottom', 'left', 'right'). Each value must be greater than 0.
 
     Raises
     ------
     ValueError
         If any of the modes specified in the 'mode' dictionary are not one of the
-        allowed values ('constant', 'edge'). Or if the thickness is not greater than 0.
+        allowed values ('constant', 'edge'). Or if any of the thickness values are not
+        greater than 0.
 
     Example
     -------
@@ -58,7 +62,12 @@ class BufferSpec(BaseModel):
                 "left": "constant",
                 "right": "edge",
             },
-            thickness=150,
+            thickness={
+                "top": 150,
+                "bottom": 100,
+                "left": 200,
+                "right": 250,
+            },
         )
     """
 
@@ -70,7 +79,14 @@ class BufferSpec(BaseModel):
             "right": "constant",
         }
     )
-    thickness: conint(gt=0) = 128
+    thickness: dict[str, conint(gt=0)] = Field(
+        default_factory=lambda: {
+            "top": 128,
+            "bottom": 128,
+            "left": 128,
+            "right": 128,
+        }
+    )
 
     @validator("mode", pre=True)
     def check_mode(cls, v):
@@ -144,28 +160,26 @@ class Device(BaseModel):
 
         self.device_array = np.pad(
             self.device_array,
-            pad_width=((buffer_thickness, 0), (0, 0)),
+            pad_width=((buffer_thickness["top"], 0), (0, 0)),
             mode=buffer_mode["top"],
         )
         self.device_array = np.pad(
             self.device_array,
-            pad_width=((0, buffer_thickness), (0, 0)),
+            pad_width=((0, buffer_thickness["bottom"]), (0, 0)),
             mode=buffer_mode["bottom"],
         )
         self.device_array = np.pad(
             self.device_array,
-            pad_width=((0, 0), (buffer_thickness, 0)),
+            pad_width=((0, 0), (buffer_thickness["left"], 0)),
             mode=buffer_mode["left"],
         )
         self.device_array = np.pad(
             self.device_array,
-            pad_width=((0, 0), (0, buffer_thickness)),
+            pad_width=((0, 0), (0, buffer_thickness["right"])),
             mode=buffer_mode["right"],
         )
 
-        self.device_array = np.expand_dims(
-            self.device_array.astype(np.float32), axis=-1
-        )
+        self.device_array = np.expand_dims(self.device_array, axis=-1)
 
     @root_validator(pre=True)
     def check_device_array(cls, values):
@@ -462,10 +476,12 @@ class Device(BaseModel):
         buffer_thickness = self.buffer_spec.thickness
         buffer_mode = self.buffer_spec.mode
 
-        crop_top = buffer_thickness if buffer_mode["top"] == "edge" else 0
-        crop_bottom = buffer_thickness if buffer_mode["bottom"] == "edge" else 0
-        crop_left = buffer_thickness if buffer_mode["left"] == "edge" else 0
-        crop_right = buffer_thickness if buffer_mode["right"] == "edge" else 0
+        crop_top = buffer_thickness["top"] if buffer_mode["top"] == "edge" else 0
+        crop_bottom = (
+            buffer_thickness["bottom"] if buffer_mode["bottom"] == "edge" else 0
+        )
+        crop_left = buffer_thickness["left"] if buffer_mode["left"] == "edge" else 0
+        crop_right = buffer_thickness["right"] if buffer_mode["right"] == "edge" else 0
 
         ndarray = device_array[
             crop_top : device_array.shape[0] - crop_bottom,
@@ -627,7 +643,7 @@ class Device(BaseModel):
         bounds: Optional[tuple[tuple[int, int], tuple[int, int]]],
         ax: Optional[Axes],
         **kwargs,
-    ) -> Axes:
+    ) -> tuple[plt.cm.ScalarMappable, Axes]:
         if ax is None:
             _, ax = plt.subplots()
         ax.set_ylabel("y (nm)")
@@ -671,6 +687,13 @@ class Device(BaseModel):
         if show_buffer:
             self._add_buffer_visualization(ax)
 
+        # # Adjust colorbar font size if a colorbar is added
+        # if "cmap" in kwargs:
+        #     cbar = plt.colorbar(mappable, ax=ax)
+        #     cbar.ax.tick_params(labelsize=14)
+        #     if "label" in kwargs:
+        #         cbar.set_label(kwargs["label"], fontsize=16)
+
         return mappable, ax
 
     def plot(
@@ -935,9 +958,9 @@ class Device(BaseModel):
         buffer_hatch = "/"
 
         mid_rect = Rectangle(
-            (buffer_thickness, buffer_thickness),
-            plot_array.shape[1] - 2 * buffer_thickness,
-            plot_array.shape[0] - 2 * buffer_thickness,
+            (buffer_thickness["left"], buffer_thickness["top"]),
+            plot_array.shape[1] - buffer_thickness["left"] - buffer_thickness["right"],
+            plot_array.shape[0] - buffer_thickness["top"] - buffer_thickness["bottom"],
             facecolor="none",
             edgecolor="black",
             linewidth=1,
@@ -947,25 +970,25 @@ class Device(BaseModel):
         top_rect = Rectangle(
             (0, 0),
             plot_array.shape[1],
-            buffer_thickness,
+            buffer_thickness["top"],
             facecolor=buffer_fill,
             hatch=buffer_hatch,
         )
         ax.add_patch(top_rect)
 
         bottom_rect = Rectangle(
-            (0, plot_array.shape[0] - buffer_thickness),
+            (0, plot_array.shape[0] - buffer_thickness["bottom"]),
             plot_array.shape[1],
-            buffer_thickness,
+            buffer_thickness["bottom"],
             facecolor=buffer_fill,
             hatch=buffer_hatch,
         )
         ax.add_patch(bottom_rect)
 
         left_rect = Rectangle(
-            (0, buffer_thickness),
-            buffer_thickness,
-            plot_array.shape[0] - 2 * buffer_thickness,
+            (0, buffer_thickness["top"]),
+            buffer_thickness["left"],
+            plot_array.shape[0] - buffer_thickness["top"] - buffer_thickness["bottom"],
             facecolor=buffer_fill,
             hatch=buffer_hatch,
         )
@@ -973,11 +996,11 @@ class Device(BaseModel):
 
         right_rect = Rectangle(
             (
-                plot_array.shape[1] - buffer_thickness,
-                buffer_thickness,
+                plot_array.shape[1] - buffer_thickness["right"],
+                buffer_thickness["top"],
             ),
-            buffer_thickness,
-            plot_array.shape[0] - 2 * buffer_thickness,
+            buffer_thickness["right"],
+            plot_array.shape[0] - buffer_thickness["top"] - buffer_thickness["bottom"],
             facecolor=buffer_fill,
             hatch=buffer_hatch,
         )
@@ -1015,7 +1038,9 @@ class Device(BaseModel):
         binarized_device_array = geometry.binarize(
             device_array=self.device_array, eta=eta, beta=beta
         )
-        return self.model_copy(update={"device_array": binarized_device_array})
+        return self.model_copy(
+            update={"device_array": binarized_device_array.astype(np.uint8)}
+        )
 
     def binarize_hard(self, eta: float = 0.5) -> "Device":
         """
@@ -1036,12 +1061,14 @@ class Device(BaseModel):
         binarized_device_array = geometry.binarize_hard(
             device_array=self.device_array, eta=eta
         )
-        return self.model_copy(update={"device_array": binarized_device_array})
+        return self.model_copy(
+            update={"device_array": binarized_device_array.astype(np.uint8)}
+        )
 
     def binarize_monte_carlo(
         self,
         threshold_noise_std: float = 2.0,
-        threshold_blur_std: float = 9.0,
+        threshold_blur_std: float = 8.0,
     ) -> "Device":
         """
         Binarize the device geometry using a Monte Carlo approach with Gaussian
@@ -1104,9 +1131,10 @@ class Device(BaseModel):
 
         Parameters
         ----------
-        buffer_thickness : int, optional
-            The thickness of the buffer to leave around the empty space. Defaults to 0,
-            which means no buffer is added.
+        buffer_thickness : dict, optional
+            A dictionary specifying the thickness of the buffer to leave around the
+            non-zero elements of the array. Should contain keys 'top', 'bottom', 'left',
+            'right'. Defaults to None, which means no buffer is added.
 
         Returns
         -------

prefab/geometry.py

@@ -124,7 +124,7 @@ def binarize_monte_carlo(
         generated threshold.
     """
     device_array = np.squeeze(device_array)
-    base_threshold = np.clip(np.random.normal(loc=0.5, scale=0.5 / 2), 0.4, 0.6)
+    base_threshold = np.random.normal(loc=0.5, scale=0.1)
     threshold_noise = np.random.normal(
         loc=0, scale=threshold_noise_std, size=device_array.shape
     )
@@ -161,7 +161,7 @@ def ternarize(
     return np.where(device_array < eta1, 0.0, np.where(device_array >= eta2, 1.0, 0.5))
 
 
-def trim(device_array: np.ndarray, buffer_thickness: int = 0) -> np.ndarray:
+def trim(device_array: np.ndarray, buffer_thickness: dict = None) -> np.ndarray:
     """
     Trim the input ndarray by removing rows and columns that are completely zero.
 
@@ -169,25 +169,28 @@ def trim(device_array: np.ndarray, buffer_thickness: int = 0) -> np.ndarray:
     ----------
     device_array : np.ndarray
         The input array to be trimmed.
-    buffer_thickness : int, optional
-        The thickness of the buffer to leave around the non-zero elements of the array.
-        Defaults to 0, which means no buffer is added.
+    buffer_thickness : dict, optional
+        A dictionary specifying the thickness of the buffer to leave around the non-zero
+        elements of the array. Should contain keys 'top', 'bottom', 'left', 'right'.
+        Defaults to None, which means no buffer is added.
 
     Returns
     -------
     np.ndarray
         The trimmed array, potentially with a buffer around the non-zero elements.
     """
-    flattened_device_array = np.squeeze(flatten(device_array))
-    nonzero_rows, nonzero_cols = np.nonzero(flattened_device_array)
-    row_min = max(nonzero_rows.min() - buffer_thickness, 0)
+    if buffer_thickness is None:
+        buffer_thickness = {"top": 0, "bottom": 0, "left": 0, "right": 0}
+
+    nonzero_rows, nonzero_cols = np.nonzero(np.squeeze(device_array))
+    row_min = max(nonzero_rows.min() - buffer_thickness.get("top", 0), 0)
     row_max = min(
-        nonzero_rows.max() + buffer_thickness + 1,
+        nonzero_rows.max() + buffer_thickness.get("bottom", 0) + 1,
         device_array.shape[0],
     )
-    col_min = max(nonzero_cols.min() - buffer_thickness, 0)
+    col_min = max(nonzero_cols.min() - buffer_thickness.get("left", 0), 0)
     col_max = min(
-        nonzero_cols.max() + buffer_thickness + 1,
+        nonzero_cols.max() + buffer_thickness.get("right", 0) + 1,
         device_array.shape[1],
     )
     return device_array[
@@ -237,10 +240,13 @@ def rotate(device_array: np.ndarray, angle: float) -> np.ndarray:
     """
     center = (device_array.shape[1] / 2, device_array.shape[0] / 2)
     rotation_matrix = cv2.getRotationMatrix2D(center=center, angle=angle, scale=1)
-    rotated_device_array = cv2.warpAffine(
-        flatten(device_array),
-        M=rotation_matrix,
-        dsize=(device_array.shape[1], device_array.shape[0]),
+    return np.expand_dims(
+        cv2.warpAffine(
+            device_array,
+            M=rotation_matrix,
+            dsize=(device_array.shape[1], device_array.shape[0]),
+        ),
+        axis=-1,
     )
     return np.expand_dims(rotated_device_array, axis=-1)
 

prefab/models.py

@@ -88,6 +88,33 @@ ANT_SiN = Fab(
     has_sidewall=True,
 )
 
+generic_DUV_SOI = Fab(
+    foundry="generic",
+    process="DUV-SOI",
+    material="SOI",
+    technology="DUV",
+    thickness=220,
+    has_sidewall=True,
+)
+
+ANT_NanoSOI_ANF0_d8 = Model(
+    fab=ANT_NanoSOI,
+    version="ANF0",
+    version_date=date(2024, 1, 1),
+    dataset="d8",
+    dataset_date=date(2024, 1, 1),
+    tag="",
+)
+
+ANT_NanoSOI_ANF1_d8 = Model(
+    fab=ANT_NanoSOI,
+    version="ANF1",
+    version_date=date(2024, 5, 6),
+    dataset="d8",
+    dataset_date=date(2024, 1, 1),
+    tag="",
+)
+
 ANT_NanoSOI_ANF1_d9 = Model(
     fab=ANT_NanoSOI,
     version="ANF1",
@@ -97,6 +124,15 @@ ANT_NanoSOI_ANF1_d9 = Model(
     tag="",
 )
 
+ANT_NanoSOI_ANF1_d10 = Model(
+    fab=ANT_NanoSOI,
+    version="ANF1",
+    version_date=date(2024, 5, 6),
+    dataset="d10",
+    dataset_date=date(2024, 6, 8),
+    tag="",
+)
+
 ANT_SiN_ANF1_d1 = Model(
     fab=ANT_SiN,
     version="ANF1",
@@ -106,9 +142,23 @@ ANT_SiN_ANF1_d1 = Model(
     tag="",
 )
 
+generic_DUV_SOI_ANF1_d0 = Model(
+    fab=generic_DUV_SOI,
+    version="ANF1",
+    version_date=date(2024, 5, 6),
+    dataset="d0",
+    dataset_date=date(2024, 6, 30),
+    tag="",
+)
+
 models = dict(
-    ANT_NanoSOI=ANT_NanoSOI_ANF1_d9,
+    ANT_NanoSOI=ANT_NanoSOI_ANF1_d10,
+    ANT_NanoSOI_ANF0_d8=ANT_NanoSOI_ANF0_d8,
+    ANT_NanoSOI_ANF1_d8=ANT_NanoSOI_ANF1_d8,
     ANT_NanoSOI_ANF1_d9=ANT_NanoSOI_ANF1_d9,
+    ANT_NanoSOI_ANF1_d10=ANT_NanoSOI_ANF1_d10,
     ANT_SiN=ANT_SiN_ANF1_d1,
     ANT_SiN_ANF1_d1=ANT_SiN_ANF1_d1,
+    generic_DUV_SOI=generic_DUV_SOI_ANF1_d0,
+    generic_DUV_SOI_ANF1_d0=generic_DUV_SOI_ANF1_d0,
 )

prefab/read.py

@@ -1,4 +1,4 @@
-"""Provides functions to create Devices from various data sources."""
+"""Provides functions to create a Device from various data sources."""
 
 import re
 
@@ -11,7 +11,7 @@ from .device import Device
 
 
 def from_ndarray(
-    ndarray: np.ndarray, resolution: int = 1, binarize: bool = True, **kwargs
+    ndarray: np.ndarray, resolution: float = 1.0, binarize: bool = True, **kwargs
 ) -> Device:
     """
     Create a Device from an ndarray.
@@ -20,13 +20,13 @@ def from_ndarray(
     ----------
     ndarray : np.ndarray
         The input array representing the device layout.
-    resolution : int, optional
-        The resolution of the ndarray in nanometers per pixel, defaulting to 1 nm per
+    resolution : float, optional
+        The resolution of the ndarray in nanometers per pixel, defaulting to 1.0 nm per
         pixel. If specified, the input array will be resized based on this resolution to
         match the desired physical size.
     binarize : bool, optional
         If True, the input array will be binarized (converted to binary values) before
-        conversion to a Device object. This is useful for processing grayscale images
+        conversion to a Device object. This is useful for processing grayscale arrays
         into binary masks. Defaults to True.
     **kwargs
         Additional keyword arguments to be passed to the Device constructor.
@@ -38,7 +38,10 @@ def from_ndarray(
         binarization.
     """
     device_array = ndarray
-    device_array = cv2.resize(device_array, dsize=(0, 0), fx=resolution, fy=resolution)
+    if resolution != 1.0:
+        device_array = cv2.resize(
+            device_array, dsize=(0, 0), fx=resolution, fy=resolution
+        )
     if binarize:
         device_array = geometry.binarize_hard(device_array)
     return Device(device_array=device_array, **kwargs)
@@ -55,12 +58,11 @@ def from_img(
     img_path : str
         The path to the image file to be converted into a Device object.
     img_width_nm : int, optional
-        The desired width of the device in nanometers. If specified, the image will be
-        resized to this width while maintaining aspect ratio. If None, no resizing is
-        performed.
+        The width of the image in nanometers. If specified, the Device will be resized
+        to this width while maintaining aspect ratio. If None, no resizing is performed.
     binarize : bool, optional
         If True, the image will be binarized (converted to binary values) before
-        conversion to a Device object. This is useful for converting grayscale images
+        conversion to a Device object. This is useful for processing grayscale images
         into binary masks. Defaults to True.
     **kwargs
         Additional keyword arguments to be passed to the Device constructor.
@@ -73,8 +75,10 @@ def from_img(
     """
     device_array = cv2.imread(img_path, flags=cv2.IMREAD_GRAYSCALE) / 255
     if img_width_nm is not None:
-        scale = img_width_nm / device_array.shape[1]
-        device_array = cv2.resize(device_array, dsize=(0, 0), fx=scale, fy=scale)
+        resolution = img_width_nm / device_array.shape[1]
+        device_array = cv2.resize(
+            device_array, dsize=(0, 0), fx=resolution, fy=resolution
+        )
     if binarize:
         device_array = geometry.binarize_hard(device_array)
     return Device(device_array=device_array, **kwargs)
@@ -134,7 +138,8 @@ def from_gdstk(
     gdstk_cell : gdstk.Cell
         The gdstk.Cell object to be converted into a Device object.
     gds_layer : tuple[int, int], optional
-        A tuple specifying the layer and datatype to be used. Defaults to (1, 0).
+        A tuple specifying the layer and datatype to be used from the cell. Defaults to
+        (1, 0).
     bounds : tuple[tuple[int, int], tuple[int, int]], optional
         A tuple specifying the bounds for cropping the cell before conversion, formatted
         as ((min_x, min_y), (max_x, max_y)), in units of the GDS file. If None, the
@@ -159,6 +164,24 @@ def _gdstk_to_device_array(
     gds_layer: tuple[int, int] = (1, 0),
     bounds: tuple[tuple[int, int], tuple[int, int]] = None,
 ) -> np.ndarray:
+    """
+    Convert a gdstk.Cell to a device array.
+
+    Parameters
+    ----------
+    gdstk_cell : gdstk.Cell
+        The gdstk.Cell object to be converted.
+    gds_layer : tuple[int, int], optional
+        The layer and datatype to be used from the cell. Defaults to (1, 0).
+    bounds : tuple[tuple[int, int], tuple[int, int]], optional
+        Bounds for cropping the cell, formatted as ((min_x, min_y), (max_x, max_y)).
+        If None, the entire cell is used.
+
+    Returns
+    -------
+    np.ndarray
+        The resulting device array.
+    """
     polygons = gdstk_cell.get_polygons(layer=gds_layer[0], datatype=gds_layer[1])
     if bounds:
         polygons = gdstk.slice(
@@ -184,12 +207,12 @@ def _gdstk_to_device_array(
                 ]
                 for vertex in polygon.points
             ],
-            dtype=np.int32,
         )
         for polygon in polygons
     ]
     device_array = np.zeros(
-        (int(bounds[1][1] - bounds[0][1]), int(bounds[1][0] - bounds[0][0]))
+        (int(bounds[1][1] - bounds[0][1]), int(bounds[1][0] - bounds[0][0])),
+        dtype=np.uint8,
     )
     cv2.fillPoly(img=device_array, pts=contours, color=(1, 1, 1))
     device_array = np.flipud(device_array)
@@ -200,7 +223,7 @@ def from_sem(
     sem_path: str,
     sem_resolution: float = None,
     sem_resolution_key: str = None,
-    binarize: bool = True,
+    binarize: bool = False,
     bounds: tuple[tuple[int, int], tuple[int, int]] = None,
     **kwargs,
 ) -> Device:
@@ -220,7 +243,7 @@ def from_sem(
     binarize : bool, optional
         If True, the SEM image will be binarized (converted to binary values) before
         conversion to a Device object. This is needed for processing grayscale images
-        into binary masks. Defaults to True.
+        into binary masks. Defaults to False.
     bounds : tuple[tuple[int, int], tuple[int, int]], optional
         A tuple specifying the bounds for cropping the image before conversion,
         formatted as ((min_x, min_y), (max_x, max_y)). If None, the entire image is
@@ -244,13 +267,13 @@ def from_sem(
         raise ValueError("Either sem_resolution or resolution_key must be provided.")
 
     device_array = cv2.imread(sem_path, flags=cv2.IMREAD_GRAYSCALE)
-    if sem_resolution is not None:
-        device_array = cv2.resize(
-            device_array, dsize=(0, 0), fx=sem_resolution, fy=sem_resolution
-        )
+    device_array = cv2.resize(
+        device_array, dsize=(0, 0), fx=sem_resolution, fy=sem_resolution
+    )
     if bounds is not None:
         device_array = device_array[
-            -bounds[1][1] : -bounds[0][1], bounds[0][0] : bounds[1][0]
+            device_array.shape[0] - bounds[1][1] : device_array.shape[0] - bounds[0][1],
+            bounds[0][0] : bounds[1][0],
         ]
     if binarize:
         device_array = geometry.binarize_sem(device_array)