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

prefab/__init__.py

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

prefab/device.py

@@ -397,6 +397,54 @@ class Device(BaseModel):
         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:
         """
         Converts the device geometry to an ndarray.
@@ -413,22 +461,17 @@ class Device(BaseModel):
         """
         device_array = np.copy(self.device_array)
         buffer_thickness = self.buffer_spec.thickness
-        buffer_mode = self.buffer_spec.mode
 
-        crop_top = buffer_thickness["top"] if buffer_mode["top"] == "constant" else 0
-        crop_bottom = (
-            buffer_thickness["bottom"] if buffer_mode["bottom"] == "constant" else 0
-        )
-        crop_left = buffer_thickness["left"] if buffer_mode["left"] == "constant" else 0
-        crop_right = (
-            buffer_thickness["right"] if buffer_mode["right"] == "constant" else 0
-        )
+        crop_top = buffer_thickness["top"]
+        crop_bottom = buffer_thickness["bottom"]
+        crop_left = buffer_thickness["left"]
+        crop_right = buffer_thickness["right"]
 
         ndarray = device_array[
             crop_top : device_array.shape[0] - crop_bottom,
             crop_left : device_array.shape[1] - crop_right,
         ]
-        return np.squeeze(ndarray)
+        return ndarray
 
     def to_img(self, img_path: str = "prefab_device.png"):
         """
@@ -525,7 +568,7 @@ class Device(BaseModel):
         gdstk.Cell
             The GDSTK cell object representing the device geometry.
         """
-        print(f"Creating cell '{cell_name}'...")
+        # print(f"Creating cell '{cell_name}'...")
         gdstk_cell = self.flatten()._device_to_gdstk(
             cell_name=cell_name,
             gds_layer=gds_layer,

prefab/predict.py

@@ -5,6 +5,7 @@ import io
 import json
 import os
 
+import gdstk
 import numpy as np
 import requests
 import toml
@@ -17,7 +18,175 @@ from .geometry import binarize_hard
 from .models import Model
 
 BASE_ENDPOINT_URL = "https://prefab-photonics--predict"
-ENDPOINT_VERSION = 2
+ENDPOINT_VERSION = "2"
+
+
+def _predict_poly(
+    polygon_points: list,
+    model: Model,
+    model_type: str,
+    eta: float = 0.5,
+) -> list:
+    """
+    Predict the nanofabrication outcome for a list of polygons.
+
+    This function sends polygon data to the server, which uses a specified machine
+    learning model to predict the outcome of the nanofabrication process.
+
+    Parameters
+    ----------
+    polygon_points : list
+        List of polygon points, where each polygon is a list of [x, y] coordinates.
+    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.
+    model_type : str
+        The type of model to use ('p' for prediction, 'c' for correction).
+    eta : float
+        The threshold value for binarization. Defaults to 0.5. Because intermediate
+        values cannot be preserved in the polygon data, the predicted polygons are
+        binarized using a threshold value of eta.
+
+    Returns
+    -------
+    list
+        List of predicted polygon points with channel information. Each polygon is a
+        dict with 'points' (list of coordinates) and 'channel' (int) keys.
+
+    Raises
+    ------
+    ValueError
+        If the server returns an error or empty response.
+    requests.exceptions.RequestException
+        If the request to the prediction service fails.
+    json.JSONDecodeError
+        If the response cannot be parsed as JSON.
+    """
+    predict_data = {
+        "polygons": polygon_points,
+        "model": model.to_json(),
+        "model_type": model_type,
+        "eta": eta,
+    }
+
+    endpoint_url = f"{BASE_ENDPOINT_URL}-poly-v{ENDPOINT_VERSION}.modal.run"
+    headers = _prepare_headers()
+
+    try:
+        response = requests.post(
+            endpoint_url, data=json.dumps(predict_data), headers=headers
+        )
+        response.raise_for_status()
+
+        if not response.content:
+            raise ValueError("Empty response received from server")
+
+        response_data = response.json()
+
+        if "polygons" in response_data:
+            polygons = response_data["polygons"]
+            if polygons and isinstance(polygons[0], dict) and "channel" in polygons[0]:
+                return polygons
+            else:
+                return [{"points": points, "channel": 0} for points in polygons]
+        else:
+            if "error" in response_data:
+                raise ValueError(f"Prediction error: {response_data['error']}")
+            return []
+
+    except requests.exceptions.RequestException as e:
+        print(f"Request failed: {str(e)}")
+        raise
+    except json.JSONDecodeError as e:
+        print(f"JSON decode error: {str(e)}")
+        raise
+
+
+def predict_gdstk(
+    gdstk_cell: gdstk.Cell,
+    model: Model,
+    model_type: str,
+    gds_layer: tuple[int, int] = (1, 0),
+    eta: float = 0.5,
+) -> gdstk.Cell:
+    """
+    Predict the nanofabrication outcome of a gdstk cell using a specified model.
+
+    This function extracts polygons from a gdstk cell, sends them to the prediction
+    server, and returns a new cell containing the predicted polygons.
+
+    Parameters
+    ----------
+    gdstk_cell : gdstk.Cell
+        The gdstk.Cell object containing polygons to predict.
+    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.
+    model_type : str
+        The type of model to use ('p' for prediction, 'c' for correction).
+    gds_layer : tuple[int, int]
+        The layer and datatype to use within the GDSTK cell. Defaults to (1, 0).
+    eta : float
+        The threshold value for binarization. Defaults to 0.5. Because intermediate
+        values cannot be preserved in the polygon data, the predicted polygons are
+        binarized using a threshold value of eta.
+
+    Returns
+    -------
+    gdstk.Cell
+        A new gdstk cell containing the predicted polygons. For multi-level
+        predictions, each level's polygons will be placed on a different layer:
+        - Level 0: (layer, 99)
+        - Level 1: (layer, 100)
+
+    Raises
+    ------
+    ValueError
+        If no polygons are found in the specified layer.
+    """
+    polygons = gdstk_cell.get_polygons(layer=gds_layer[0], datatype=gds_layer[1])
+    if not polygons:
+        raise ValueError("No polygons found in the specified layer")
+
+    polygon_points = [polygon.points.tolist() for polygon in polygons]
+
+    predicted_polygon_data = _predict_poly(
+        polygon_points=polygon_points,
+        model=model,
+        model_type=model_type,
+        eta=eta,
+    )
+
+    result_cell = gdstk.Cell(f"{gdstk_cell.name}_predicted")
+
+    polygons_by_channel = {}
+    for polygon_data in predicted_polygon_data:
+        channel = polygon_data.get("channel", 0)
+        points = polygon_data.get("points", [])
+
+        if channel not in polygons_by_channel:
+            polygons_by_channel[channel] = []
+
+        polygons_by_channel[channel].append(points)
+
+    for channel, points_list in polygons_by_channel.items():
+        layer = gds_layer[0]
+        datatype = 99 + channel
+
+        for points in points_list:
+            points_array = np.array(points)
+            polygon = gdstk.Polygon(points_array, layer=layer, datatype=datatype)
+            result_cell.add(polygon)
+
+    return result_cell
 
 
 def predict_array(

{prefab-1.1.8.dist-info → prefab-1.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: prefab
-Version: 1.1.8
+Version: 1.2.0
 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
@@ -586,7 +586,7 @@ Before you can make PreFab requests, you will need to [create an account](https:
 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
+prefab setup
 ```
 
 ### Guides
@@ -603,4 +603,4 @@ PreFab models are hosted on a [serverless cloud platform](https://modal.com/). P
 
 ## License
 
-This project is licensed under the LGPL-2.1 license. © 2024 PreFab Photonics.
+This project is licensed under the LGPL-2.1 license. © 2025 PreFab Photonics.

prefab-1.2.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+prefab/__init__.py,sha256=1aWNs6J8s6UlWOvSlZscZ1W_uZboUlkhVkmJCWvJ7RU,425
+prefab/__main__.py,sha256=1eXWiEoG7eetJMm1qRbK2I5MnzuRgKIoQtBeT-Ps8es,3523
+prefab/compare.py,sha256=0Xgp3tFuP4of-ce9Opc19p8i8lIyXkbVGLuwWBaHSeE,3486
+prefab/device.py,sha256=ZuppXLmDPSfym37U25hSsNu6JNM8ujrr4Bxh3VH4-4s,56582
+prefab/geometry.py,sha256=4fekWMlkdS_qlPNTdPXPhwKuQ5qdQ1Zjf8m9JKd1dA8,12049
+prefab/models.py,sha256=waPNGtuISyY0f8cz7dnbD451CKYCt8EpPGt-4lSOPNU,2581
+prefab/predict.py,sha256=I0gdO0nNAdNQn_ALrHxrDjmBgxIGpPyU_hQYtnF9hYU,17733
+prefab/read.py,sha256=WNqC3xENlndzFwXeCF2E7H3Iq2dO_6rPEPZ58DuloqY,16259
+prefab/shapes.py,sha256=58cyXFNh1kEErq2jEbGd3dWSediU1OSmor_FWwc1V8A,25098
+prefab-1.2.0.dist-info/METADATA,sha256=rd9O4Q3C0adI7BYkkuiEwlqkGw6UlQMpSAFA5Qbuwd0,35025
+prefab-1.2.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+prefab-1.2.0.dist-info/entry_points.txt,sha256=h1_A9O9F3NAIoKXD1RPb3Eo-WCSiHhMB_AnagBi6XTQ,48
+prefab-1.2.0.dist-info/licenses/LICENSE,sha256=IMF9i4xIpgCADf0U-V1cuf9HBmqWQd3qtI3FSuyW4zE,26526
+prefab-1.2.0.dist-info/RECORD,,

prefab-1.1.8.dist-info/RECORD

@@ -1,14 +0,0 @@
-prefab/__init__.py,sha256=V4m0w3VrKeMgeNeqyc_45E5KXH9fVOQKO5xyH42uDmg,425
-prefab/__main__.py,sha256=1eXWiEoG7eetJMm1qRbK2I5MnzuRgKIoQtBeT-Ps8es,3523
-prefab/compare.py,sha256=0Xgp3tFuP4of-ce9Opc19p8i8lIyXkbVGLuwWBaHSeE,3486
-prefab/device.py,sha256=1rqs_VQ7am6W473C-EZTsPFDlqNIMMd26VZAUV1tNS0,54885
-prefab/geometry.py,sha256=4fekWMlkdS_qlPNTdPXPhwKuQ5qdQ1Zjf8m9JKd1dA8,12049
-prefab/models.py,sha256=waPNGtuISyY0f8cz7dnbD451CKYCt8EpPGt-4lSOPNU,2581
-prefab/predict.py,sha256=h13523jasg1WbdiYbkXy43SWTGfQXjq6oEe0O8DT2U0,11731
-prefab/read.py,sha256=WNqC3xENlndzFwXeCF2E7H3Iq2dO_6rPEPZ58DuloqY,16259
-prefab/shapes.py,sha256=58cyXFNh1kEErq2jEbGd3dWSediU1OSmor_FWwc1V8A,25098
-prefab-1.1.8.dist-info/METADATA,sha256=d5ide0FP2wUQALM_2SSFhA_BGU6s3waxWjtXwsbjivs,35036
-prefab-1.1.8.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-prefab-1.1.8.dist-info/entry_points.txt,sha256=h1_A9O9F3NAIoKXD1RPb3Eo-WCSiHhMB_AnagBi6XTQ,48
-prefab-1.1.8.dist-info/licenses/LICENSE,sha256=IMF9i4xIpgCADf0U-V1cuf9HBmqWQd3qtI3FSuyW4zE,26526
-prefab-1.1.8.dist-info/RECORD,,