prefab 1.1.0__py3-none-any.whl → 1.1.2__py3-none-any.whl

prefab/__init__.py

@@ -5,7 +5,7 @@ Usage:
     import prefab as pf
 """
 
-__version__ = "1.1.0"
+__version__ = "1.1.2"
 
 from . import compare, geometry, read, shapes
 from .device import BufferSpec, Device

prefab/compare.py

@@ -1,5 +1,7 @@
 """Provides functions to measure the similarity between devices."""
 
+import warnings
+
 import numpy as np
 
 from .device import Device
@@ -42,6 +44,11 @@ def intersection_over_union(device_a: Device, device_b: Device) -> float:
     float
         The Intersection over Union between two devices.
     """
+    if not device_a.is_binary or not device_b.is_binary:
+        warnings.warn(
+            "One or both devices are not binarized.", UserWarning, stacklevel=2
+        )
+
     return np.sum(
         np.logical_and(device_a.device_array, device_b.device_array)
     ) / np.sum(np.logical_or(device_a.device_array, device_b.device_array))
@@ -65,6 +72,11 @@ def hamming_distance(device_a: Device, device_b: Device) -> int:
     int
         The Hamming distance between two devices.
     """
+    if not device_a.is_binary or not device_b.is_binary:
+        warnings.warn(
+            "One or both devices are not binarized.", UserWarning, stacklevel=2
+        )
+
     return np.sum(device_a.device_array != device_b.device_array)
 
 
@@ -86,6 +98,11 @@ def dice_coefficient(device_a: Device, device_b: Device) -> float:
     float
         The Dice coefficient between two devices.
     """
+    if not device_a.is_binary or not device_b.is_binary:
+        warnings.warn(
+            "One or both devices are not binarized.", UserWarning, stacklevel=2
+        )
+
     intersection = 2.0 * np.sum(
         np.logical_and(device_a.device_array, device_b.device_array)
     )

prefab/device.py

@@ -18,7 +18,6 @@ from PIL import Image
 from pydantic import BaseModel, Field, conint, root_validator, validator
 from scipy.ndimage import distance_transform_edt
 from skimage import measure
-from skimage.morphology import closing, disk, opening, square
 from tqdm import tqdm
 
 from . import compare, geometry
@@ -193,6 +192,7 @@ class Device(BaseModel):
             raise ValueError("device_array must be a 2D array.")
         return values
 
+    @property
     def is_binary(self) -> bool:
         """
         Check if the device geometry is binary.
@@ -493,6 +493,7 @@ class Device(BaseModel):
             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 to_ndarray(self) -> np.ndarray:
@@ -695,8 +696,8 @@ class Device(BaseModel):
                 "try `pip install gdsfactory`."
             ) from None
 
-        device_array = np.rot90(self.device_array, k=-1)
-        return gf.read.from_np(device_array[:, :, 0], nm_per_pixel=1)
+        device_array = np.rot90(self.to_ndarray(), k=-1)
+        return gf.read.from_np(device_array, nm_per_pixel=1)
 
     def to_tidy3d(
         self,
@@ -808,6 +809,9 @@ class Device(BaseModel):
             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):
@@ -1468,16 +1472,11 @@ class Device(BaseModel):
         ValueError
             If an invalid structuring element type is specified.
         """
-        if strel == "disk":
-            structuring_element = disk(radius=min_feature_size / 2)
-        elif strel == "square":
-            structuring_element = square(width=min_feature_size)
-        else:
-            raise ValueError(f"Invalid structuring element: {strel}")
-
-        modified_geometry = closing(self.device_array[:, :, 0], structuring_element)
-        modified_geometry = opening(modified_geometry, structuring_element)
-        modified_geometry = np.expand_dims(modified_geometry, axis=-1)
+        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"):

prefab/geometry.py

@@ -2,6 +2,7 @@
 
 import cv2
 import numpy as np
+from skimage.morphology import closing, disk, opening, square
 
 
 def normalize(device_array: np.ndarray) -> np.ndarray:
@@ -248,7 +249,6 @@ def rotate(device_array: np.ndarray, angle: float) -> np.ndarray:
         ),
         axis=-1,
     )
-    return np.expand_dims(rotated_device_array, axis=-1)
 
 
 def erode(device_array: np.ndarray, kernel_size: int) -> np.ndarray:
@@ -306,3 +306,45 @@ def flatten(device_array: np.ndarray) -> np.ndarray:
         The flattened array with values scaled between 0 and 1.
     """
     return normalize(np.sum(device_array, axis=-1, keepdims=True))
+
+
+def enforce_feature_size(
+    device_array: np.ndarray, min_feature_size: int, strel: str = "disk"
+) -> np.ndarray:
+    """
+    Enforce a minimum feature size on the device geometry.
+
+    This function 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.
+
+    Parameters
+    ----------
+    device_array : np.ndarray
+        The input array representing the device geometry.
+    min_feature_size : int
+        The minimum feature size to enforce, in nanometers.
+    strel : str, optional
+        The type of structuring element to use. Can be either "disk" or "square".
+        Defaults to "disk".
+
+    Returns
+    -------
+    np.ndarray
+        The modified device array with enforced feature size.
+
+    Raises
+    ------
+    ValueError
+        If an invalid structuring element type is specified.
+    """
+    if strel == "disk":
+        structuring_element = disk(radius=min_feature_size / 2)
+    elif strel == "square":
+        structuring_element = square(width=min_feature_size)
+    else:
+        raise ValueError(f"Invalid structuring element: {strel}")
+
+    modified_geometry = closing(device_array[:, :, 0], structuring_element)
+    modified_geometry = opening(modified_geometry, structuring_element)
+    return np.expand_dims(modified_geometry, axis=-1)

prefab/read.py

@@ -244,7 +244,7 @@ def from_gdsfactory(
         If the gdsfactory package is not installed.
     """
     try:
-        import gdsfactory as gf
+        import gdsfactory as gf  # noqa: F401
     except ImportError:
         raise ImportError(
             "The gdsfactory package is required to use this function; "
@@ -352,6 +352,10 @@ def get_sem_resolution(sem_path: str, sem_resolution_key: str) -> float:
     Extracts the resolution of a scanning electron microscope (SEM) image from its
     metadata.
 
+    Note:
+    -----
+    This function is used internally and may not be useful for most users.
+
     Parameters
     ----------
     sem_path : str

prefab/shapes.py

@@ -6,7 +6,7 @@ from skimage.draw import polygon
 from .device import Device
 
 
-def rectangle(width: int = 200, height: int = 100, **kwargs) -> Device:
+def rectangle(width: int = 200, height: int = None, **kwargs) -> Device:
     """
     Create a Device object with a rectangular shape.
 
@@ -15,7 +15,7 @@ def rectangle(width: int = 200, height: int = 100, **kwargs) -> Device:
     width : int, optional
         The width of the rectangle. Defaults to 200.
     height : int, optional
-        The height of the rectangle. Defaults to 100.
+        The height of the rectangle. Defaults to the value of width.
     **kwargs : dict
         Additional keyword arguments to be passed to the Device constructor.
 
@@ -24,40 +24,57 @@ def rectangle(width: int = 200, height: int = 100, **kwargs) -> Device:
     Device
         A Device object containing the rectangular shape.
     """
+    if height is None:
+        height = width
     rectangle = np.zeros((height, width))
     rectangle[:, :] = 1
     return Device(device_array=rectangle, **kwargs)
 
 
-def box(width: int = 200, **kwargs) -> Device:
+def window(
+    width: int = 200, height: int = None, border_width: int = 60, **kwargs
+) -> Device:
     """
-    Create a Device object with a square box shape.
+    Create a Device object with a window shape (hollow square).
 
     Parameters
     ----------
     width : int, optional
-        The width and height of the square box. Defaults to 200.
+        The overall width of the window. Defaults to 200.
+    height : int, optional
+        The overall height of the window. Defaults to the value of width.
+    border_width : int, optional
+        The width of the window border. Defaults to 60.
     **kwargs : dict
         Additional keyword arguments to be passed to the Device constructor.
 
     Returns
     -------
     Device
-        A Device object containing the square box shape.
+        A Device object containing the window shape.
     """
-    box = np.zeros((width, width))
-    box[:, :] = 1
-    return Device(device_array=box, **kwargs)
+    if height is None:
+        height = width
+    window = np.zeros((height, width))
+    window[:border_width, :] = 1
+    window[-border_width:, :] = 1
+    window[:, :border_width] = 1
+    window[:, -border_width:] = 1
+    return Device(device_array=window, **kwargs)
 
 
-def cross(width: int = 200, arm_width: int = 60, **kwargs) -> Device:
+def cross(
+    width: int = 200, height: int = None, arm_width: int = 60, **kwargs
+) -> Device:
     """
     Create a Device object with a cross shape.
 
     Parameters
     ----------
     width : int, optional
-        The overall width and height of the cross. Defaults to 200.
+        The overall width of the cross. Defaults to 200.
+    height : int, optional
+        The overall height of the cross. Defaults to the value of width.
     arm_width : int, optional
         The width of the cross arms. Defaults to 60.
     **kwargs : dict
@@ -68,22 +85,29 @@ def cross(width: int = 200, arm_width: int = 60, **kwargs) -> Device:
     Device
         A Device object containing the cross shape.
     """
-    cross = np.zeros((width, width))
-    center = width // 2
+    if height is None:
+        height = width
+    cross = np.zeros((height, width))
+    center_x = width // 2
+    center_y = height // 2
     half_arm_width = arm_width // 2
-    cross[center - half_arm_width : center + half_arm_width + 1, :] = 1
-    cross[:, center - half_arm_width : center + half_arm_width + 1] = 1
+    cross[center_y - half_arm_width : center_y + half_arm_width + 1, :] = 1
+    cross[:, center_x - half_arm_width : center_x + half_arm_width + 1] = 1
     return Device(device_array=cross, **kwargs)
 
 
-def target(width: int = 200, arm_width: int = 60, **kwargs) -> Device:
+def target(
+    width: int = 200, height: int = None, arm_width: int = 60, **kwargs
+) -> Device:
     """
     Create a Device object with a target shape (cross with center removed).
 
     Parameters
     ----------
     width : int, optional
-        The overall width and height of the target. Defaults to 200.
+        The overall width of the target. Defaults to 200.
+    height : int, optional
+        The overall height of the target. Defaults to the value of width.
     arm_width : int, optional
         The width of the target arms. Defaults to 60.
     **kwargs : dict
@@ -94,45 +118,22 @@ def target(width: int = 200, arm_width: int = 60, **kwargs) -> Device:
     Device
         A Device object containing the target shape.
     """
-    target = np.zeros((width, width))
-    center = width // 2
+    if height is None:
+        height = width
+    target = np.zeros((height, width))
+    center_x = width // 2
+    center_y = height // 2
     half_arm_width = arm_width // 2
-    target[center - half_arm_width : center + half_arm_width + 1, :] = 1
-    target[:, center - half_arm_width : center + half_arm_width + 1] = 1
+    target[center_y - half_arm_width : center_y + half_arm_width + 1, :] = 1
+    target[:, center_x - half_arm_width : center_x + half_arm_width + 1] = 1
     target[
-        center - half_arm_width : center + half_arm_width + 1,
-        center - half_arm_width : center + half_arm_width + 1,
+        center_y - half_arm_width : center_y + half_arm_width + 1,
+        center_x - half_arm_width : center_x + half_arm_width + 1,
     ] = 0
     return Device(device_array=target, **kwargs)
 
 
-def window(width: int = 200, border_width: int = 60, **kwargs) -> Device:
-    """
-    Create a Device object with a window shape (hollow square).
-
-    Parameters
-    ----------
-    width : int, optional
-        The overall width and height of the window. Defaults to 200.
-    border_width : int, optional
-        The width of the window border. Defaults to 60.
-    **kwargs : dict
-        Additional keyword arguments to be passed to the Device constructor.
-
-    Returns
-    -------
-    Device
-        A Device object containing the window shape.
-    """
-    window = np.zeros((width, width))
-    window[:border_width, :] = 1
-    window[-border_width:, :] = 1
-    window[:, :border_width] = 1
-    window[:, -border_width:] = 1
-    return Device(device_array=window, **kwargs)
-
-
-def ellipse(width: int = 200, height: int = 100, **kwargs) -> Device:
+def disk(width: int = 200, height: int = None, **kwargs) -> Device:
     """
     Create a Device object with an elliptical shape.
 
@@ -141,7 +142,7 @@ def ellipse(width: int = 200, height: int = 100, **kwargs) -> Device:
     width : int, optional
         The width of the ellipse. Defaults to 200.
     height : int, optional
-        The height of the ellipse. Defaults to 100.
+        The height of the ellipse. Defaults to the value of width.
     **kwargs : dict
         Additional keyword arguments to be passed to the Device constructor.
 
@@ -150,38 +151,54 @@ def ellipse(width: int = 200, height: int = 100, **kwargs) -> Device:
     Device
         A Device object containing the elliptical shape.
     """
-    y, x = np.ogrid[-height // 2 : height // 2, -width // 2 : width // 2]
-    mask = (x**2 / (width // 2) ** 2) + (y**2 / (height // 2) ** 2) <= 1
+    if height is None:
+        height = width
+    radius_x = width // 2
+    radius_y = height // 2
+    y, x = np.ogrid[-radius_y:radius_y, -radius_x:radius_x]
+    mask = (x**2 / radius_x**2) + (y**2 / radius_y**2) <= 1
     ellipse = np.zeros((height, width))
     ellipse[mask] = 1
     return Device(device_array=ellipse, **kwargs)
 
 
-def circle(width: int = 200, **kwargs) -> Device:
+def ring(
+    width: int = 200, height: int = None, border_width: int = 60, **kwargs
+) -> Device:
     """
-    Create a Device object with a circular shape.
+    Create a Device object with a ring shape.
 
     Parameters
     ----------
     width : int, optional
-        The width and height of the circle. Defaults to 200.
+        The overall width of the ring. Defaults to 200.
+    height : int, optional
+        The overall height of the ring. Defaults to the value of width.
+    border_width : int, optional
+        The width of the ring border. Defaults to 60.
     **kwargs : dict
         Additional keyword arguments to be passed to the Device constructor.
 
     Returns
     -------
     Device
-        A Device object containing the circular shape.
+        A Device object containing the ring shape.
     """
-    radius = width // 2
-    y, x = np.ogrid[-radius:radius, -radius:radius]
-    mask = x**2 + y**2 <= radius**2
-    circle = np.zeros((width, width))
-    circle[mask] = 1
-    return Device(device_array=circle, **kwargs)
+    if height is None:
+        height = width
+    radius_x = width // 2
+    radius_y = height // 2
+    inner_radius_x = radius_x - border_width
+    inner_radius_y = radius_y - border_width
+    y, x = np.ogrid[-radius_y:radius_y, -radius_x:radius_x]
+    outer_mask = x**2 / radius_x**2 + y**2 / radius_y**2 <= 1
+    inner_mask = x**2 / inner_radius_x**2 + y**2 / inner_radius_y**2 <= 1
+    ring = np.zeros((height, width))
+    ring[outer_mask & ~inner_mask] = 1
+    return Device(device_array=ring, **kwargs)
 
 
-def circle_wavy(
+def disk_wavy(
     width: int = 200, wave_amplitude: float = 10, wave_frequency: float = 10, **kwargs
 ) -> Device:
     """
@@ -215,14 +232,18 @@ def circle_wavy(
     return Device(device_array=circle_wavy, **kwargs)
 
 
-def pie(width: int = 200, arc_angle: float = 270, **kwargs) -> Device:
+def pie(
+    width: int = 200, height: int = None, arc_angle: float = 270, **kwargs
+) -> Device:
     """
     Create a Device object with a pie shape.
 
     Parameters
     ----------
     width : int, optional
-        The width and height of the pie. Defaults to 200.
+        The width of the pie. Defaults to 200.
+    height : int, optional
+        The height of the pie. Defaults to the value of width.
     arc_angle : float, optional
         The angle of the pie slice in degrees. Defaults to 270.
     **kwargs : dict
@@ -233,12 +254,15 @@ def pie(width: int = 200, arc_angle: float = 270, **kwargs) -> Device:
     Device
         A Device object containing the pie shape.
     """
-    radius = width // 2
-    y, x = np.ogrid[-radius:radius, -radius:radius]
+    if height is None:
+        height = width
+    radius_x = width // 2
+    radius_y = height // 2
+    y, x = np.ogrid[-radius_y:radius_y, -radius_x:radius_x]
     angle = np.arctan2(y, x) * 180 / np.pi
     angle = (angle + 360) % 360
-    mask = (x**2 + y**2 <= radius**2) & (angle <= arc_angle)
-    pie = np.zeros((width, width))
+    mask = (x**2 / radius_x**2 + y**2 / radius_y**2 <= 1) & (angle <= arc_angle)
+    pie = np.zeros((height, width))
     pie[mask] = 1
     return Device(device_array=pie, **kwargs)
 
@@ -350,36 +374,6 @@ def poly(width: int = 200, num_points: int = 5, **kwargs) -> Device:
     return Device(device_array=poly, **kwargs)
 
 
-def ring(width: int = 200, border_width: int = 60, **kwargs) -> Device:
-    """
-    Create a Device object with a ring shape.
-
-    Parameters
-    ----------
-    width : int, optional
-        The overall width and height of the ring. Defaults to 200.
-    border_width : int, optional
-        The width of the ring border. Defaults to 60.
-    **kwargs : dict
-        Additional keyword arguments to be passed to the Device constructor.
-
-    Returns
-    -------
-    Device
-        A Device object containing the ring shape.
-    """
-    radius_outer = width // 2
-    radius_inner = radius_outer - border_width
-    y, x = np.ogrid[-radius_outer:radius_outer, -radius_outer:radius_outer]
-    distance_from_center = np.sqrt(x**2 + y**2)
-    mask = (distance_from_center <= radius_outer) & (
-        distance_from_center >= radius_inner
-    )
-    ring = np.zeros((width, width))
-    ring[mask] = 1
-    return Device(device_array=ring, **kwargs)
-
-
 def radial_grating(
     width: int = 200, grating_skew: int = 0, num_gratings: int = 6, **kwargs
 ) -> Device:
@@ -465,7 +459,8 @@ def offset_grating(
 
 
 def L_grating(
-    height: int = 200,
+    width: int = 200,
+    height: int = None,
     pitch: int = 100,
     duty_cycle: float = 0.5,
     **kwargs,
@@ -475,8 +470,10 @@ def L_grating(
 
     Parameters
     ----------
+    width : int, optional
+        The width of the L-grating. Defaults to 200.
     height : int, optional
-        The height and width of the L-grating. Defaults to 200.
+        The height of the L-grating. Defaults to the value of width.
     pitch : int, optional
         The pitch (period) of the L-shapes. Defaults to 100.
     duty_cycle : float, optional
@@ -489,8 +486,10 @@ def L_grating(
     Device
         A Device object containing the L-shaped grating pattern.
     """
-    L_grating = np.zeros((height, height))
-    num_L_shapes = height // pitch
+    if height is None:
+        height = width
+    L_grating = np.zeros((height, width))
+    num_L_shapes = min(height, width) // pitch
     L_width = int(pitch * duty_cycle)
     for i in range(num_L_shapes):
         start = i * pitch
@@ -499,11 +498,11 @@ def L_grating(
     return Device(device_array=L_grating, **kwargs)
 
 
-def circles(
-    rows: int = 5, cols: int = 5, radius: int = 30, spacing: int = 60, **kwargs
+def disks(
+    rows: int = 5, cols: int = 5, disk_radius: int = 30, spacing: int = 60, **kwargs
 ) -> Device:
     """
-    Create a Device object with a grid of uniform circles.
+    Create a Device object with a grid of uniform disks.
 
     Parameters
     ----------
@@ -511,39 +510,39 @@ def circles(
         The number of rows in the grid. Defaults to 5.
     cols : int, optional
         The number of columns in the grid. Defaults to 5.
-    radius : int, optional
-        The radius of each circle. Defaults to 30.
+    disk_radius : int, optional
+        The radius of each disk. Defaults to 30.
     spacing : int, optional
-        The spacing between circle centers. Defaults to 60.
+        The spacing between disk centers. Defaults to 60.
     **kwargs : dict
         Additional keyword arguments to be passed to the Device constructor.
 
     Returns
     -------
     Device
-        A Device object containing a grid of circles.
+        A Device object containing a grid of disks.
     """
-    grid_height = rows * (2 * radius + spacing) - spacing
-    grid_width = cols * (2 * radius + spacing) - spacing
-    circles = np.zeros((grid_height, grid_width))
-    y, x = np.ogrid[-radius:radius, -radius:radius]
-    mask = x**2 + y**2 <= radius**2
+    grid_height = rows * (2 * disk_radius + spacing) - spacing
+    grid_width = cols * (2 * disk_radius + spacing) - spacing
+    disks = np.zeros((grid_height, grid_width))
+    y, x = np.ogrid[-disk_radius:disk_radius, -disk_radius:disk_radius]
+    mask = x**2 + y**2 <= disk_radius**2
     for row in range(rows):
         for col in range(cols):
-            center_y = row * (2 * radius + spacing) + radius
-            center_x = col * (2 * radius + spacing) + radius
-            circles[
-                center_y - radius : center_y + radius,
-                center_x - radius : center_x + radius,
+            center_y = row * (2 * disk_radius + spacing) + disk_radius
+            center_x = col * (2 * disk_radius + spacing) + disk_radius
+            disks[
+                center_y - disk_radius : center_y + disk_radius,
+                center_x - disk_radius : center_x + disk_radius,
             ][mask] = 1
-    return Device(device_array=circles, **kwargs)
+    return Device(device_array=disks, **kwargs)
 
 
-def circles_offset(
-    rows: int = 5, cols: int = 5, radius: int = 30, spacing: int = 30, **kwargs
+def disks_offset(
+    rows: int = 5, cols: int = 5, disk_radius: int = 30, spacing: int = 30, **kwargs
 ) -> Device:
     """
-    Create a Device object with an offset grid of circles.
+    Create a Device object with an offset grid of disks.
 
     Parameters
     ----------
@@ -551,48 +550,50 @@ def circles_offset(
         The number of rows in the grid. Defaults to 5.
     cols : int, optional
         The number of columns in the grid. Defaults to 5.
-    radius : int, optional
-        The radius of each circle. Defaults to 30.
+    disk_radius : int, optional
+        The radius of each disk. Defaults to 30.
     spacing : int, optional
-        The spacing between circle centers. Defaults to 30.
+        The spacing between disk centers. Defaults to 30.
     **kwargs : dict
         Additional keyword arguments to be passed to the Device constructor.
 
     Returns
     -------
     Device
-        A Device object containing an offset grid of circles.
+        A Device object containing an offset grid of disks.
     """
-    grid_height = rows * (2 * radius + spacing) - spacing
-    grid_width = cols * (2 * radius + spacing) - spacing + (radius + spacing // 2)
-    circles_offset = np.zeros((grid_height, grid_width))
-    y, x = np.ogrid[-radius:radius, -radius:radius]
-    mask = x**2 + y**2 <= radius**2
+    grid_height = rows * (2 * disk_radius + spacing) - spacing
+    grid_width = (
+        cols * (2 * disk_radius + spacing) - spacing + (disk_radius + spacing // 2)
+    )
+    disks_offset = np.zeros((grid_height, grid_width))
+    y, x = np.ogrid[-disk_radius:disk_radius, -disk_radius:disk_radius]
+    mask = x**2 + y**2 <= disk_radius**2
     for row in range(rows):
         for col in range(cols):
-            center_y = row * (2 * radius + spacing) + radius
+            center_y = row * (2 * disk_radius + spacing) + disk_radius
             center_x = (
-                col * (2 * radius + spacing)
-                + radius
-                + (radius + spacing // 2 if row % 2 == 1 else 0)
+                col * (2 * disk_radius + spacing)
+                + disk_radius
+                + (disk_radius + spacing // 2 if row % 2 == 1 else 0)
             )
-            circles_offset[
-                center_y - radius : center_y + radius,
-                center_x - radius : center_x + radius,
+            disks_offset[
+                center_y - disk_radius : center_y + disk_radius,
+                center_x - disk_radius : center_x + disk_radius,
             ][mask] = 1
-    return Device(device_array=circles_offset, **kwargs)
+    return Device(device_array=disks_offset, **kwargs)
 
 
-def circles_varying(
+def disks_varying(
     rows: int = 5,
     cols: int = 5,
-    min_radius: int = 10,
-    max_radius: int = 30,
+    min_disk_radius: int = 10,
+    max_disk_radius: int = 30,
     spacing: int = 30,
     **kwargs,
 ) -> Device:
     """
-    Create a Device object with a grid of circles with varying radii.
+    Create a Device object with a grid of disks with varying radii.
 
     Parameters
     ----------
@@ -600,40 +601,42 @@ def circles_varying(
         The number of rows in the grid. Defaults to 5.
     cols : int, optional
         The number of columns in the grid. Defaults to 5.
-    min_radius : int, optional
-        The minimum radius of the circles. Defaults to 10.
-    max_radius : int, optional
-        The maximum radius of the circles. Defaults to 30.
+    min_disk_radius : int, optional
+        The minimum radius of the disks. Defaults to 10.
+    max_disk_radius : int, optional
+        The maximum radius of the disks. Defaults to 30.
     spacing : int, optional
-        The spacing between circle centers. Defaults to 30.
+        The spacing between disk centers. Defaults to 30.
     **kwargs : dict
         Additional keyword arguments to be passed to the Device constructor.
 
     Returns
     -------
     Device
-        A Device object containing a grid of circles with varying radii.
+        A Device object containing a grid of disks with varying radii.
     """
-    grid_height = rows * (2 * max_radius + spacing) - spacing
-    grid_width = cols * (2 * max_radius + spacing) - spacing
-    circles_varying = np.zeros((grid_height, grid_width))
-    radius_range = np.linspace(min_radius, max_radius, rows * cols).reshape(rows, cols)
+    grid_height = rows * (2 * max_disk_radius + spacing) - spacing
+    grid_width = cols * (2 * max_disk_radius + spacing) - spacing
+    disks_varying = np.zeros((grid_height, grid_width))
+    radius_range = np.linspace(min_disk_radius, max_disk_radius, rows * cols).reshape(
+        rows, cols
+    )
     for row in range(rows):
         for col in range(cols):
-            radius = int(radius_range[row, col])
-            y, x = np.ogrid[-radius:radius, -radius:radius]
-            mask = x**2 + y**2 <= radius**2
-            center_y = row * (2 * max_radius + spacing) + max_radius
-            center_x = col * (2 * max_radius + spacing) + max_radius
-            circles_varying[
-                center_y - radius : center_y + radius,
-                center_x - radius : center_x + radius,
+            disk_radius = int(radius_range[row, col])
+            y, x = np.ogrid[-disk_radius:disk_radius, -disk_radius:disk_radius]
+            mask = x**2 + y**2 <= disk_radius**2
+            center_y = row * (2 * max_disk_radius + spacing) + max_disk_radius
+            center_x = col * (2 * max_disk_radius + spacing) + max_disk_radius
+            disks_varying[
+                center_y - disk_radius : center_y + disk_radius,
+                center_x - disk_radius : center_x + disk_radius,
             ][mask] = 1
-    return Device(device_array=circles_varying, **kwargs)
+    return Device(device_array=disks_varying, **kwargs)
 
 
 def holes(
-    rows: int = 5, cols: int = 5, radius: int = 30, spacing: int = 30, **kwargs
+    rows: int = 5, cols: int = 5, hole_radius: int = 30, spacing: int = 30, **kwargs
 ) -> Device:
     """
     Create a Device object with a grid of uniform circular holes.
@@ -644,7 +647,7 @@ def holes(
         The number of rows in the grid. Defaults to 5.
     cols : int, optional
         The number of columns in the grid. Defaults to 5.
-    radius : int, optional
+    hole_radius : int, optional
         The radius of each hole. Defaults to 30.
     spacing : int, optional
         The spacing between hole centers. Defaults to 30.
@@ -656,24 +659,24 @@ def holes(
     Device
         A Device object containing a grid of circular holes.
     """
-    grid_height = rows * (2 * radius + spacing) - spacing
-    grid_width = cols * (2 * radius + spacing) - spacing
+    grid_height = rows * (2 * hole_radius + spacing) - spacing
+    grid_width = cols * (2 * hole_radius + spacing) - spacing
     holes = np.ones((grid_height, grid_width))
-    y, x = np.ogrid[-radius:radius, -radius:radius]
-    mask = x**2 + y**2 <= radius**2
+    y, x = np.ogrid[-hole_radius:hole_radius, -hole_radius:hole_radius]
+    mask = x**2 + y**2 <= hole_radius**2
     for row in range(rows):
         for col in range(cols):
-            center_y = row * (2 * radius + spacing) + radius
-            center_x = col * (2 * radius + spacing) + radius
+            center_y = row * (2 * hole_radius + spacing) + hole_radius
+            center_x = col * (2 * hole_radius + spacing) + hole_radius
             holes[
-                center_y - radius : center_y + radius,
-                center_x - radius : center_x + radius,
+                center_y - hole_radius : center_y + hole_radius,
+                center_x - hole_radius : center_x + hole_radius,
             ][mask] = 0
     return Device(device_array=holes, **kwargs)
 
 
 def holes_offset(
-    rows: int = 5, cols: int = 5, radius: int = 30, spacing: int = 30, **kwargs
+    rows: int = 5, cols: int = 5, hole_radius: int = 30, spacing: int = 30, **kwargs
 ) -> Device:
     """
     Create a Device object with an offset grid of circular holes.
@@ -684,7 +687,7 @@ def holes_offset(
         The number of rows in the grid. Defaults to 5.
     cols : int, optional
         The number of columns in the grid. Defaults to 5.
-    radius : int, optional
+    hole_radius : int, optional
         The radius of each hole. Defaults to 30.
     spacing : int, optional
         The spacing between hole centers. Defaults to 30.
@@ -696,22 +699,24 @@ def holes_offset(
     Device
         A Device object containing an offset grid of circular holes.
     """
-    grid_height = rows * (2 * radius + spacing) - spacing
-    grid_width = cols * (2 * radius + spacing) - spacing + (radius + spacing // 2)
+    grid_height = rows * (2 * hole_radius + spacing) - spacing
+    grid_width = (
+        cols * (2 * hole_radius + spacing) - spacing + (hole_radius + spacing // 2)
+    )
     holes_offset = np.ones((grid_height, grid_width))
-    y, x = np.ogrid[-radius:radius, -radius:radius]
-    mask = x**2 + y**2 <= radius**2
+    y, x = np.ogrid[-hole_radius:hole_radius, -hole_radius:hole_radius]
+    mask = x**2 + y**2 <= hole_radius**2
     for row in range(rows):
         for col in range(cols):
-            center_y = row * (2 * radius + spacing) + radius
+            center_y = row * (2 * hole_radius + spacing) + hole_radius
             center_x = (
-                col * (2 * radius + spacing)
-                + radius
-                + (radius + spacing // 2 if row % 2 == 1 else 0)
+                col * (2 * hole_radius + spacing)
+                + hole_radius
+                + (hole_radius + spacing // 2 if row % 2 == 1 else 0)
             )
             holes_offset[
-                center_y - radius : center_y + radius,
-                center_x - radius : center_x + radius,
+                center_y - hole_radius : center_y + hole_radius,
+                center_x - hole_radius : center_x + hole_radius,
             ][mask] = 0
     return Device(device_array=holes_offset, **kwargs)
 
@@ -719,8 +724,8 @@ def holes_offset(
 def holes_varying(
     rows: int = 5,
     cols: int = 5,
-    min_radius: int = 10,
-    max_radius: int = 30,
+    min_hole_radius: int = 10,
+    max_hole_radius: int = 30,
     spacing: int = 30,
     **kwargs,
 ) -> Device:
@@ -733,9 +738,9 @@ def holes_varying(
         The number of rows in the grid. Defaults to 5.
     cols : int, optional
         The number of columns in the grid. Defaults to 5.
-    min_radius : int, optional
+    min_hole_radius : int, optional
         The minimum radius of the holes. Defaults to 10.
-    max_radius : int, optional
+    max_hole_radius : int, optional
         The maximum radius of the holes. Defaults to 30.
     spacing : int, optional
         The spacing between hole centers. Defaults to 30.
@@ -747,19 +752,21 @@ def holes_varying(
     Device
         A Device object containing a grid of circular holes with varying radii.
     """
-    grid_height = rows * (2 * max_radius + spacing) - spacing
-    grid_width = cols * (2 * max_radius + spacing) - spacing
+    grid_height = rows * (2 * max_hole_radius + spacing) - spacing
+    grid_width = cols * (2 * max_hole_radius + spacing) - spacing
     holes_varying = np.ones((grid_height, grid_width))
-    radius_range = np.linspace(min_radius, max_radius, rows * cols).reshape(rows, cols)
+    radius_range = np.linspace(min_hole_radius, max_hole_radius, rows * cols).reshape(
+        rows, cols
+    )
     for row in range(rows):
         for col in range(cols):
-            radius = int(radius_range[row, col])
-            y, x = np.ogrid[-radius:radius, -radius:radius]
-            mask = x**2 + y**2 <= radius**2
-            center_y = row * (2 * max_radius + spacing) + max_radius
-            center_x = col * (2 * max_radius + spacing) + max_radius
+            hole_radius = int(radius_range[row, col])
+            y, x = np.ogrid[-hole_radius:hole_radius, -hole_radius:hole_radius]
+            mask = x**2 + y**2 <= hole_radius**2
+            center_y = row * (2 * max_hole_radius + spacing) + max_hole_radius
+            center_x = col * (2 * max_hole_radius + spacing) + max_hole_radius
             holes_varying[
-                center_y - radius : center_y + radius,
-                center_x - radius : center_x + radius,
+                center_y - hole_radius : center_y + hole_radius,
+                center_x - hole_radius : center_x + hole_radius,
             ][mask] = 0
     return Device(device_array=holes_varying, **kwargs)

{prefab-1.1.0.dist-info → prefab-1.1.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: prefab
-Version: 1.1.0
+Version: 1.1.2
 Summary: Artificial nanofabrication of integrated photonic circuits using deep learning
 Project-URL: Homepage, https://prefabphotonics.com
 Project-URL: Repository, https://github.com/PreFab-Photonics/PreFab
@@ -516,7 +516,7 @@ Classifier: License :: OSI Approved :: GNU Lesser General Public License v2 (LGP
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.9
-Requires-Dist: gdstk
+Requires-Dist: gdstk>=0.9.55
 Requires-Dist: matplotlib
 Requires-Dist: numpy
 Requires-Dist: opencv-python-headless
@@ -533,23 +533,23 @@ Description-Content-Type: text/markdown
 
 ![PreFab logo](https://github.com/PreFab-Photonics/PreFab/blob/main/docs/assets/logo.png?raw=true)
 
-PreFab leverages **deep learning** to model fabrication-induced structural variations in integrated photonic devices. Through this _virtual nanofabrication environment_, we uncover valuable insights into nanofabrication processes and enhance device design accuracy.
+PreFab is a _virtual nanofabrication environment_ that leverages **deep learning** and **computer vision** to predict and correct for structural variations in integrated photonic devices during nanofabrication.
 
 ## Prediction
 
-PreFab accurately predicts process-induced structural alterations such as corner rounding, washing away of small lines and islands, and filling of narrow holes in planar photonic devices. This enables designers to quickly prototype expected performance and rectify designs prior to nanofabrication.
+PreFab predicts process-induced structural variations, including corner rounding, loss of small lines and islands, filling of narrow holes and channels, sidewall angle deviations, and stochastic effects. This allows designers to rapidly prototype and evaluate expected performance pre-fabrication.
 
 ![Example of PreFab prediction](https://github.com/PreFab-Photonics/PreFab/blob/main/docs/assets/promo_p.png?raw=true)
 
 ## Correction
 
-PreFab automates corrections to device designs, ensuring the fabricated outcome aligns with the original design. This results in reduced structural variation and performance disparity from simulation to experiment.
+PreFab corrects device designs to ensure that the fabricated outcome closely matches the intended specifications. This minimizes structural variations and reduces performance discrepancies between simulations and actual experiments.
 
 ![Example of PreFab correction](https://github.com/PreFab-Photonics/PreFab/blob/main/docs/assets/promo_c.png?raw=true)
 
 ## Models
 
-PreFab accommodates unique _predictor_ and _corrector_ models for each photonic foundry, regularly updated based on recent fabrication data. Current models include (see full list on [`docs/models.md`](https://github.com/PreFab-Photonics/PreFab/blob/main/docs/models.md)):
+Each photonic nanofabrication process requires unique models, which are regularly updated with the latest data. The current models include (see the full list in [`docs/models.md`](https://github.com/PreFab-Photonics/PreFab/blob/main/docs/models.md)):
 
 | Foundry | Process | Latest Version    | Latest Dataset   | Model Name  |
 | ------- | ------- | ----------------- | ---------------- | ----------- |
@@ -557,7 +557,7 @@ PreFab accommodates unique _predictor_ and _corrector_ models for each photonic
 | ANT     | SiN     | ANF1 (May 6 2024) | d1 (Jan 31 2024) | ANT_SiN_ANF1_d1 |
 | Generic | DUV-SOI | ANF1 (May 6 2024) | d0 (Jul 30 2024) | generic_DUV_SOI_ANF1_d0 |
 
-> _New models and foundries are to be regularly added. Usage may change. For additional foundry and process models, feel free to contact us._
+> _New models are to be regularly added. Usage may change. For additional foundry and process models, feel free to [contact us](mailto:hi@prefabphotonics.com) or raise an issue._
 
 ## Installation
 
@@ -581,7 +581,7 @@ pip install -e .
 
 Before you can make PreFab requests, you will need to [create an account](https://www.prefabphotonics.com/login).
 
-To link your account, you will need a token. You can do this by running the following command in your terminal. This will open a browser window where you can log in and authenticate your token.
+To link your account, you will need an token. You can do this by running the following command in your terminal. This will open a browser window where you can log in and authenticate your token.
 
 ```sh
 python3 -m prefab setup
@@ -593,11 +593,11 @@ Visit [`/docs/examples`](https://github.com/PreFab-Photonics/PreFab/tree/main/do
 
 ## Performance and Usage
 
-PreFab models are served via a serverless cloud platform. Please note:
+PreFab models are hosted on a [serverless cloud platform](https://modal.com/). Please keep in mind:
 
-- 🐢 CPU inference may result in slower performance. Future updates will introduce GPU inference.
-- 🥶 The first prediction may take longer due to cold start server loading. Subsequent predictions will be faster.
-- 😊 Be considerate of usage. Start small and limit usage during the initial stages. Thank you!
+- 🐢 Default CPU inference may be slower.
+- 🥶 The first prediction using optional GPU inference may take longer due to cold start server loading. Subsequent predictions will be faster.
+- 😊 Please be considerate of usage. Start with small tasks and limit usage during the initial stages. Thank you!
 
 ## License
 

prefab-1.1.2.dist-info/RECORD

@@ -0,0 +1,12 @@
+prefab/__init__.py,sha256=fbGTDuVA76ol5cM6fXbPAZMB0BCT2zmHD7Pgr9I-zV0,401
+prefab/__main__.py,sha256=aAgt1WXa44k1nJqsiSD3uAfNeGpwtjWqMUYCHN5_Qrw,2759
+prefab/compare.py,sha256=2MKUT7N2A639tUGCnJHpfF9MmS-v3oARDkTqHbWJ9OM,3239
+prefab/device.py,sha256=dpx4dDspruImy__bp3X11y_s-CBJZr6dKpxn8wGtmSA,58314
+prefab/geometry.py,sha256=0sa6ietUWZGkxOnUPUzD3q2QpFuOpWkSANoopGpPd6s,11035
+prefab/models.py,sha256=UMzYZzKouroxlwkXCMKIYozmQCMhNhvt8kQrZmwmZB4,3671
+prefab/read.py,sha256=MuF-cugFQ7MWBJ8DOvQuwktIk0fJ8PXBeLye0ydrB8o,14734
+prefab/shapes.py,sha256=2qaqyNzu5WG3wVdk4oQzeNXmhwXRHcPnRZlgRrM4MoA,25576
+prefab-1.1.2.dist-info/METADATA,sha256=wZOFUncUh7ZmZRoJ8AxH_SfpKwd2KdxDnVvmTyiLSR0,34824
+prefab-1.1.2.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+prefab-1.1.2.dist-info/licenses/LICENSE,sha256=IMF9i4xIpgCADf0U-V1cuf9HBmqWQd3qtI3FSuyW4zE,26526
+prefab-1.1.2.dist-info/RECORD,,

prefab-1.1.0.dist-info/RECORD

@@ -1,12 +0,0 @@
-prefab/__init__.py,sha256=Tx4t6ODZeL-V-ZPuQXjEHHtwb7rjqCb2ApLFDniQ5fA,401
-prefab/__main__.py,sha256=aAgt1WXa44k1nJqsiSD3uAfNeGpwtjWqMUYCHN5_Qrw,2759
-prefab/compare.py,sha256=AfLJ69DTqvt0mkMqNCTdn2KWKoclt_0htGVXvarEhkY,2709
-prefab/device.py,sha256=lklENpvqROifkEgNCT4BwU9xnsLt1nwdLksh5VDgpKU,58507
-prefab/geometry.py,sha256=pXsVeu4Ycnq60bG6WqFNoUWnyiNStIaYQgbMIrEyndM,9614
-prefab/models.py,sha256=UMzYZzKouroxlwkXCMKIYozmQCMhNhvt8kQrZmwmZB4,3671
-prefab/read.py,sha256=Rzj9GGrszsKWdY8GxtmpfYcA4nsiuxgwSdEDVvfHN80,14624
-prefab/shapes.py,sha256=Hc6dc2Y5Wmb2mZAxhdjBNEJF7C7tF2o460HNvcqcQdo,24856
-prefab-1.1.0.dist-info/METADATA,sha256=tHahGccx-TKDbeo2ZMKTjC_JYPWesvovFyUuTONF_YA,34817
-prefab-1.1.0.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
-prefab-1.1.0.dist-info/licenses/LICENSE,sha256=IMF9i4xIpgCADf0U-V1cuf9HBmqWQd3qtI3FSuyW4zE,26526
-prefab-1.1.0.dist-info/RECORD,,