prefab 1.0.4__py3-none-any.whl → 1.1.1__py3-none-any.whl

prefab/__init__.py

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

prefab/device.py

@@ -16,9 +16,12 @@ from matplotlib.axes import Axes
 from matplotlib.patches import Rectangle
 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 geometry
+from . import compare, geometry
 from .models import Model
 
 Image.MAX_IMAGE_PIXELS = None
@@ -490,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:
@@ -670,6 +674,152 @@ class Device(BaseModel):
 
         return cell
 
+    def to_gdsfactory(self) -> "gf.Component":  # noqa: F821
+        """
+        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":  # noqa: F821
+        """
+        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)), medium=medium
+        )
+
+    def to_3d(self, thickness_nm: int) -> np.ndarray:
+        """
+        Convert the 2D device geometry into a 3D representation.
+
+        This method creates a 3D array by interpolating between the bottom and top
+        layers of the device geometry. The interpolation is linear.
+
+        Parameters
+        ----------
+        thickness_nm : int
+            The thickness of the 3D representation in nanometers.
+
+        Returns
+        -------
+        np.ndarray
+            A 3D narray representing the device geometry with the specified thickness.
+        """
+        bottom_layer = self.device_array[:, :, 0]
+        top_layer = self.device_array[:, :, -1]
+        dt_bottom = distance_transform_edt(bottom_layer) - distance_transform_edt(
+            1 - bottom_layer
+        )
+        dt_top = distance_transform_edt(top_layer) - distance_transform_edt(
+            1 - top_layer
+        )
+        weights = np.linspace(0, 1, thickness_nm)
+        layered_array = np.zeros(
+            (bottom_layer.shape[0], bottom_layer.shape[1], thickness_nm)
+        )
+        for i, w in enumerate(weights):
+            dt_interp = (1 - w) * dt_bottom + w * dt_top
+            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, optional
+            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
+        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,
@@ -1294,4 +1444,90 @@ class Device(BaseModel):
         """
         return 1 - 2 * np.abs(0.5 - self.device_array)
 
-        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.
+
+        Parameters
+        ----------
+        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
+        -------
+        Device
+            A new instance of the Device with the modified geometry.
+
+        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(self.device_array[:, :, 0], structuring_element)
+        modified_geometry = opening(modified_geometry, structuring_element)
+        modified_geometry = np.expand_dims(modified_geometry, axis=-1)
+        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.
+
+        Parameters
+        ----------
+        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".
+
+        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}"
+        )

prefab/read.py

@@ -219,6 +219,73 @@ def _gdstk_to_device_array(
     return device_array
 
 
+def from_gdsfactory(
+    component: "gf.Component",  # noqa: F821
+    **kwargs,
+) -> Device:
+    """
+    Create a Device from a gdsfactory component.
+
+    Parameters
+    ----------
+    component : gf.Component
+        The gdsfactory component to be converted into a Device object.
+    **kwargs
+        Additional keyword arguments to be passed to the Device constructor.
+
+    Returns
+    -------
+    Device
+        A Device object representing the gdsfactory component.
+
+    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
+
+    bounds = (
+        (component.xmin * 1000, component.ymin * 1000),
+        (component.xmax * 1000, component.ymax * 1000),
+    )
+
+    polygons = [
+        polygon
+        for polygons_list in component.get_polygons_points().values()
+        for polygon in polygons_list
+    ]
+
+    contours = [
+        np.array(
+            [
+                [
+                    [
+                        int(1000 * vertex[0] - bounds[0][0]),
+                        int(1000 * vertex[1] - bounds[0][1]),
+                    ]
+                ]
+                for vertex in polygon
+            ]
+        )
+        for polygon in polygons
+    ]
+
+    device_array = np.zeros(
+        (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)
+    return Device(device_array=device_array, **kwargs)
+
+
 def from_sem(
     sem_path: str,
     sem_resolution: float = None,
@@ -314,3 +381,73 @@ def get_sem_resolution(sem_path: str, sem_resolution_key: str) -> float:
                         value /= 1000
                     return value
     raise ValueError(f"Resolution key '{sem_resolution_key}' not found in {sem_path}.")
+
+
+def from_tidy3d(
+    tidy3d_sim: "tidy3d.Simulation",  # noqa: F821
+    eps_threshold: float,
+    z: float,
+    **kwargs,
+) -> Device:
+    """
+    Create a Device from a Tidy3D simulation.
+
+    Parameters
+    ----------
+    tidy3d_sim : tidy3d.Simulation
+        The Tidy3D simulation object.
+    eps_threshold : float
+        The threshold value for the permittivity to binarize the device array.
+    z : float
+        The z-coordinate at which to extract the permittivity.
+    **kwargs
+        Additional keyword arguments to be passed to the Device constructor.
+
+    Returns
+    -------
+    Device
+        A Device object representing the permittivity cross-section at the specified
+        z-coordinate for the Tidy3D simulation.
+
+    Raises
+    ------
+    ValueError
+        If the z-coordinate is outside the bounds of the simulation size in the
+        z-direction.
+    ImportError
+        If the tidy3d package is not installed.
+    """
+    try:
+        from tidy3d import Coords, Grid
+    except ImportError:
+        raise ImportError(
+            "The tidy3d package is required to use this function; "
+            "try `pip install tidy3d`."
+        ) from None
+
+    if not (
+        tidy3d_sim.center[2] - tidy3d_sim.size[2] / 2
+        <= z
+        <= tidy3d_sim.center[2] + tidy3d_sim.size[2] / 2
+    ):
+        raise ValueError(
+            f"z={z} is outside the bounds of the simulation size in the z-direction."
+        )
+
+    x = np.arange(
+        tidy3d_sim.center[0] - tidy3d_sim.size[0] / 2,
+        tidy3d_sim.center[0] + tidy3d_sim.size[0] / 2,
+        0.001,
+    )
+    y = np.arange(
+        tidy3d_sim.center[1] - tidy3d_sim.size[1] / 2,
+        tidy3d_sim.center[1] + tidy3d_sim.size[1] / 2,
+        0.001,
+    )
+    z = np.array([z])
+
+    grid = Grid(boundaries=Coords(x=x, y=y, z=z))
+    eps = np.real(tidy3d_sim.epsilon_on_grid(grid=grid, coord_key="boundaries").values)
+    device_array = geometry.binarize_hard(device_array=eps, eta=eps_threshold)[:, :, 0]
+    device_array = np.fliplr(np.rot90(device_array, k=-1))
+    return Device(device_array=device_array, **kwargs)

{prefab-1.0.4.dist-info → prefab-1.1.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: prefab
-Version: 1.0.4
+Version: 1.1.1
 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
@@ -524,6 +524,7 @@ Requires-Dist: pillow
 Requires-Dist: pydantic
 Requires-Dist: requests
 Requires-Dist: scikit-image
+Requires-Dist: scipy
 Requires-Dist: toml
 Requires-Dist: tqdm
 Description-Content-Type: text/markdown

prefab-1.1.1.dist-info/RECORD

@@ -0,0 +1,12 @@
+prefab/__init__.py,sha256=v7MDKK-aRRrdT77IJ5jUcfBc3k6zmGUQnn_fqzNoj_A,401
+prefab/__main__.py,sha256=aAgt1WXa44k1nJqsiSD3uAfNeGpwtjWqMUYCHN5_Qrw,2759
+prefab/compare.py,sha256=AfLJ69DTqvt0mkMqNCTdn2KWKoclt_0htGVXvarEhkY,2709
+prefab/device.py,sha256=Fxgl1Yhc-5KQyrt80NlLsmsr47kz3fShjZdoXw9zZbc,58687
+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.1.dist-info/METADATA,sha256=ZHKTRE8c39t2itPHkTWJ8wZUJ4Wk0BQcDgmkjLIYRGQ,34817
+prefab-1.1.1.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+prefab-1.1.1.dist-info/licenses/LICENSE,sha256=IMF9i4xIpgCADf0U-V1cuf9HBmqWQd3qtI3FSuyW4zE,26526
+prefab-1.1.1.dist-info/RECORD,,

prefab-1.0.4.dist-info/RECORD

@@ -1,12 +0,0 @@
-prefab/__init__.py,sha256=z7di6Rcufbv_haAVfAam3Q_EZaBWjv-DWpidsqLlBmc,401
-prefab/__main__.py,sha256=aAgt1WXa44k1nJqsiSD3uAfNeGpwtjWqMUYCHN5_Qrw,2759
-prefab/compare.py,sha256=AfLJ69DTqvt0mkMqNCTdn2KWKoclt_0htGVXvarEhkY,2709
-prefab/device.py,sha256=qIPQNt3nqIpeZasBWHNFxdHC6EBt1_fgWdmeUVWDPlE,50109
-prefab/geometry.py,sha256=pXsVeu4Ycnq60bG6WqFNoUWnyiNStIaYQgbMIrEyndM,9614
-prefab/models.py,sha256=UMzYZzKouroxlwkXCMKIYozmQCMhNhvt8kQrZmwmZB4,3671
-prefab/read.py,sha256=HNuovvQx0Vg0X-z5-gUlL-T1M1RQf81Bmy0wDAdqO28,10782
-prefab/shapes.py,sha256=Hc6dc2Y5Wmb2mZAxhdjBNEJF7C7tF2o460HNvcqcQdo,24856
-prefab-1.0.4.dist-info/METADATA,sha256=DI5SMrZH42zLQnaJlzzKkU5BU9KEpAJsSayAvIxIAk0,34796
-prefab-1.0.4.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
-prefab-1.0.4.dist-info/licenses/LICENSE,sha256=IMF9i4xIpgCADf0U-V1cuf9HBmqWQd3qtI3FSuyW4zE,26526
-prefab-1.0.4.dist-info/RECORD,,