[feat] use post body as input

.gitignore

@@ -3,4 +3,5 @@ venv/
 __cache__
 .idea
 tmp/
-.env*
+.env*
+*.onnx

dockerfiles/dockerfile-lambda-fastsam-api

@@ -21,6 +21,7 @@ RUN ls -l ${LAMBDA_TASK_ROOT}/models
 RUN python -c "import sys; print(sys.path)"
 RUN python -c "import osgeo"
 RUN python -c "import cv2"
+RUN python -c "import geopandas"
 RUN python -c "import onnxruntime"
 # RUN python -c "import rasterio"
 RUN python -c "import awslambdaric"

dockerfiles/dockerfile-lambda-gdal-runner

@@ -17,6 +17,7 @@ RUN ls -ld /usr/lib/*linux-gnu/libGL.so* || echo "libGL.so* not found..."
 RUN which python
 RUN python --version
 RUN python -m pip install -r ${LAMBDA_TASK_ROOT}/requirements_dev.txt --target ${LAMBDA_TASK_ROOT}
+RUN python -c "import sys;print(sys.path)"
 # RUN python -m pip install pillow awslambdaric aws-lambda-powertools httpx jmespath --target ${LAMBDA_TASK_ROOT}
 
 RUN curl -Lo /usr/local/bin/aws-lambda-rie ${RIE}

events/payload_point.json

@@ -0,0 +1,11 @@
+{
+  "ne": {"lat": 45.699, "lng": 127.1},
+  "sw": {"lat": 30.1, "lng": 148.492},
+  "prompt": [{
+    "type": "point",
+    "data": [500, 600],
+    "label": 0
+  }],
+  "zoom": 6,
+  "source_type": "Satellite"
+}

events/payload_point_colico.json

@@ -0,0 +1,11 @@
+{
+  "ne": {"lat": 46.1618799417681, "lng": 9.43905830383301},
+  "sw": {"lat": 46.12584245997462, "lng": 9.344301223754885},
+  "prompt": [{
+    "type": "point",
+    "data": [500, 600],
+    "label": 0
+  }],
+  "zoom": 14,
+  "source_type": "Satellite"
+}

events/payload_rectangle.json

@@ -0,0 +1,10 @@
+{
+  "ne": {"lat": 45.699, "lng": 127.1},
+  "sw": {"lat": 30.1, "lng": 148.492},
+  "prompt": [{
+    "type": "rectangle",
+    "data": [400, 460, 524, 628]
+  }],
+  "zoom": 6,
+  "source_type": "Satellite"
+}

requirements.txt

@@ -1,11 +1,11 @@
 aws-lambda-powertools
 awslambdaric
 bson
+geopandas
 httpx
 jmespath
 numpy
 onnxruntime
 opencv-python
 pillow
-rasterio
-geopandas
+rasterio

requirements_dev.txt

@@ -1,11 +1,11 @@
 aws-lambda-powertools
 awslambdaric
 bson
+geopandas
 httpx
 jmespath
 numpy
 onnxruntime
 opencv-python
 pillow
-rasterio
-geopandas
+rasterio

src/app.py

@@ -2,12 +2,14 @@ import json
 import time
 from http import HTTPStatus
 from typing import Dict
+
 from aws_lambda_powertools.event_handler import content_types
 from aws_lambda_powertools.utilities.typing import LambdaContext
 
 from src import app_logger
 from src.prediction_api.predictors import samexporter_predict
 from src.utilities.constants import CUSTOM_RESPONSE_MESSAGES
+from src.utilities.utilities import base64_decode
 
 
 def get_response(status: int, start_time: float, request_id: str, response_body: Dict = None) -> str:
@@ -39,6 +41,24 @@ def get_response(status: int, start_time: float, request_id: str, response_body:
     return json.dumps(response)
 
 
+def get_parsed_bbox_points(request_input: Dict) -> Dict:
+    app_logger.info(f"try to parsing input request {request_input}...")
+    ne = request_input["ne"]
+    sw = request_input["sw"]
+    bbox = [
+        [float(ne["lat"]), float(ne["lng"])],
+        [float(sw["lat"]), float(sw["lng"])]
+    ]
+    app_logger.info(f"bbox {bbox}.")
+
+    app_logger.info(f"unpacking {request_input}...")
+    return {
+        "bbox": bbox,
+        "prompt": request_input["prompt"],
+        "zoom": int(request_input["zoom"])
+    }
+
+
 def lambda_handler(event: dict, context: LambdaContext):
     app_logger.info(f"start with aws_request_id:{context.aws_request_id}.")
     start_time = time.time()
@@ -51,19 +71,30 @@ def lambda_handler(event: dict, context: LambdaContext):
         app_logger.info(f"context:{context}...")
 
         try:
-            pt0 = 45.699, 127.1
-            pt1 = 30.1, 148.492
-            bbox = [pt0, pt1]
-            zoom = 6
-            prompt = [{"type": "rectangle", "data": [400, 460, 524, 628]}]
-            body_response = {"geojson": samexporter_predict(bbox, prompt, zoom)}
+            body = event["body"]
+        except Exception as e_constants1:
+            app_logger.error(f"e_constants1:{e_constants1}.")
+            body = event
+
+        app_logger.info(f"body: {type(body)}, {body}...")
+
+        if isinstance(body, str):
+            body_decoded_str = base64_decode(body)
+            app_logger.info(f"body_decoded_str: {type(body_decoded_str)}, {body_decoded_str}...")
+            body = json.loads(body_decoded_str)
+
+        app_logger.info(f"body:{body}...")
+
+        try:
+            body_request = get_parsed_bbox_points(body)
+            body_response = samexporter_predict(body_request["bbox"], body_request["prompt"], body_request["zoom"])
             app_logger.info(f"body_response::output:{body_response}.")
             response = get_response(HTTPStatus.OK.value, start_time, context.aws_request_id, body_response)
-        except Exception as ve:
-            app_logger.error(f"validation error:{ve}.")
+        except Exception as ex2:
+            app_logger.error(f"exception2:{ex2}.")
             response = get_response(HTTPStatus.UNPROCESSABLE_ENTITY.value, start_time, context.aws_request_id, {})
-    except Exception as e:
-        app_logger.error(f"exception:{e}.")
+    except Exception as ex1:
+        app_logger.error(f"exception1:{ex1}.")
         response = get_response(HTTPStatus.INTERNAL_SERVER_ERROR.value, start_time, context.aws_request_id, {})
 
     app_logger.info(f"response_dumped:{response}...")

src/prediction_api/predictors.py

@@ -1,30 +1,35 @@
 # Press the green button in the gutter to run the script.
-import os
-from typing import List
-
 import numpy as np
+from typing import List
 
 from src import app_logger, MODEL_FOLDER
 from src.io.tms2geotiff import download_extent
 from src.prediction_api.sam_onnx import SegmentAnythingONNX
-from src.utilities.constants import ROOT, MODEL_ENCODER_NAME, ZOOM, SOURCE_TYPE, DEFAULT_TMS, MODEL_DECODER_NAME
+from src.utilities.constants import MODEL_ENCODER_NAME, ZOOM, DEFAULT_TMS, MODEL_DECODER_NAME
 from src.utilities.serialize import serialize
 from src.utilities.type_hints import input_float_tuples
 
 
+models_dict = {"fastsam": {"instance": None}}
+
+
 def zip_arrays(arr1, arr2):
-    arr1_list = arr1.tolist()
-    arr2_list = arr2.tolist()
-    # return {serialize(k): serialize(v) for k, v in zip(arr1_list, arr2_list)}
-    d = {}
-    for n1, n2 in zip(arr1_list, arr2_list):
-        app_logger.info(f"n1:{n1}, type {type(n1)}, n2:{n2}, type {type(n2)}.")
-        n1f = str(n1)
-        n2f = str(n2)
-        app_logger.info(f"n1:{n1}=>{n1f}, n2:{n2}=>{n2f}.")
-        d[n1f] = n2f
-    app_logger.info(f"zipped dict:{d}.")
-    return d
+    try:
+        arr1_list = arr1.tolist()
+        arr2_list = arr2.tolist()
+        # return {serialize(k): serialize(v) for k, v in zip(arr1_list, arr2_list)}
+        d = {}
+        for n1, n2 in zip(arr1_list, arr2_list):
+            app_logger.info(f"n1:{n1}, type {type(n1)}, n2:{n2}, type {type(n2)}.")
+            n1f = str(n1)
+            n2f = str(n2)
+            app_logger.info(f"n1:{n1}=>{n1f}, n2:{n2}=>{n2f}.")
+            d[n1f] = n2f
+        app_logger.info(f"zipped dict:{d}.")
+        return d
+    except Exception as e_zip_arrays:
+        app_logger.info(f"exception zip_arrays:{e_zip_arrays}.")
+        return {}
 
 
 def load_affine_transformation_from_matrix(matrix_source_coeffs: List):
@@ -41,68 +46,71 @@ def load_affine_transformation_from_matrix(matrix_source_coeffs: List):
         app_logger.error(f"exception:{e}, check https://github.com/rasterio/affine project for updates")
 
 
-def samexporter_predict(bbox: input_float_tuples, prompt: list[dict], zoom: float = ZOOM) -> dict:
-    import tempfile
-
+def samexporter_predict(bbox: input_float_tuples, prompt: list[dict], zoom: float = ZOOM, model_name: str = "fastsam") -> dict:
     try:
         from rasterio.features import shapes
         from geopandas import GeoDataFrame
 
-        with tempfile.NamedTemporaryFile(prefix=f"{SOURCE_TYPE}_", suffix=".tif", dir=ROOT) as image_input_tmp:
-            for coord in bbox:
-                app_logger.info(f"bbox coord:{coord}, type:{type(coord)}.")
-            app_logger.info(f"start download_extent using bbox:{bbox}, type:{type(bbox)}, download image...")
-
-            pt0 = bbox[0]
-            pt1 = bbox[1]
-            img, matrix = download_extent(DEFAULT_TMS, pt0[0], pt0[1], pt1[0], pt1[1], zoom)
-
-            app_logger.info(f"img type {type(img)}, matrix type {type(matrix)}.")
-            app_logger.info(f"matrix values: {serialize(matrix)}.")
-            np_img = np.array(img)
-            app_logger.info(f"np_img type {type(np_img)}.")
-            app_logger.info(f"np_img dtype {np_img.dtype}, shape {np_img.shape}.")
-            app_logger.info(f"geotiff created with size/shape {img.size} and transform matrix {str(matrix)}, start to initialize SamGeo instance:")
-            app_logger.info(f"use ENCODER model {MODEL_ENCODER_NAME} from {MODEL_FOLDER})...")
-            app_logger.info(f"use DECODER model {MODEL_DECODER_NAME} from {MODEL_FOLDER})...")
-
-            model = SegmentAnythingONNX(
+        if models_dict[model_name]["instance"] is None:
+            app_logger.info(f"missing instance model {model_name}, instantiating it now")
+            model_instance = SegmentAnythingONNX(
                 encoder_model_path=MODEL_FOLDER / MODEL_ENCODER_NAME,
                 decoder_model_path=MODEL_FOLDER / MODEL_DECODER_NAME
             )
-            app_logger.info(f"model instantiated, creating embedding...")
-            embedding = model.encode(np_img)
-            app_logger.info(f"embedding created, running predict_masks...")
-            prediction_masks = model.predict_masks(embedding, prompt)
-            app_logger.info(f"predict_masks terminated")
-            app_logger.info(f"prediction masks shape:{prediction_masks.shape}, {prediction_masks.dtype}.")
-
-            mask = np.zeros((prediction_masks.shape[2], prediction_masks.shape[3]), dtype=np.uint8)
-            for m in prediction_masks[0, :, :, :]:
-                mask[m > 0.0] = 255
-
-            mask_unique_values, mask_unique_values_count = serialize(np.unique(mask, return_counts=True))
-            app_logger.info(f"mask_unique_values:{mask_unique_values}.")
-            app_logger.info(f"mask_unique_values_count:{mask_unique_values_count}.")
-
-            transform = load_affine_transformation_from_matrix(matrix)
-            app_logger.info(f"image/geojson origin matrix:{matrix}, transform:{transform}.")
-            shapes_generator = (
-                {'properties': {'raster_val': v}, 'geometry': s}
-                for i, (s, v)
-                in enumerate(
-                shapes(mask, mask=mask, transform=transform))
-            )
-            shapes_list = list(shapes_generator)
-            app_logger.info(f"created {len(shapes_list)} polygons.")
-            gpd_polygonized_raster = GeoDataFrame.from_features(shapes_list, crs="EPSG:3857")
-            geojson = gpd_polygonized_raster.to_json(to_wgs84=True)
-
-            return {
-                "geojson": geojson,
-                "n_shapes_geojson": len(shapes_list),
-                "n_predictions": len(prediction_masks),
-                "n_pixels_predictions": zip_arrays(mask_unique_values, mask_unique_values_count),
-            }
+            models_dict[model_name]["instance"] = model_instance
+        app_logger.info(f"using a {model_name} instance model...")
+        models_instance = models_dict[model_name]["instance"]
+
+        for coord in bbox:
+            app_logger.info(f"bbox coord:{coord}, type:{type(coord)}.")
+        app_logger.info(f"start download_extent using bbox:{bbox}, type:{type(bbox)}, download image...")
+
+        pt0 = bbox[0]
+        pt1 = bbox[1]
+        img, matrix = download_extent(DEFAULT_TMS, pt0[0], pt0[1], pt1[0], pt1[1], zoom)
+
+        app_logger.info(f"img type {type(img)}, matrix type {type(matrix)}.")
+        app_logger.info(f"matrix values: {serialize(matrix)}.")
+        np_img = np.array(img)
+        app_logger.info(f"np_img type {type(np_img)}.")
+        app_logger.info(f"np_img dtype {np_img.dtype}, shape {np_img.shape}.")
+        app_logger.info(f"geotiff created with size/shape {img.size} and transform matrix {str(matrix)}, start to initialize SamGeo instance:")
+        app_logger.info(f"use fastsam_model, ENCODER model {MODEL_ENCODER_NAME} and {MODEL_DECODER_NAME} from {MODEL_FOLDER})...")
+
+        app_logger.info(f"model instantiated, creating embedding...")
+        embedding = models_instance.encode(np_img)
+        app_logger.info(f"embedding created, running predict_masks...")
+        prediction_masks = models_instance.predict_masks(embedding, prompt)
+        app_logger.info(f"predict_masks terminated")
+        app_logger.info(f"prediction masks shape:{prediction_masks.shape}, {prediction_masks.dtype}.")
+
+        mask = np.zeros((prediction_masks.shape[2], prediction_masks.shape[3]), dtype=np.uint8)
+        for m in prediction_masks[0, :, :, :]:
+            mask[m > 0.0] = 255
+
+        mask_unique_values, mask_unique_values_count = serialize(np.unique(mask, return_counts=True))
+        app_logger.info(f"mask_unique_values:{mask_unique_values}.")
+        app_logger.info(f"mask_unique_values_count:{mask_unique_values_count}.")
+
+        transform = load_affine_transformation_from_matrix(matrix)
+        app_logger.info(f"image/geojson origin matrix:{matrix}, transform:{transform}.")
+        shapes_generator = ({
+            'properties': {'raster_val': v}, 'geometry': s}
+            for i, (s, v)
+            in enumerate(shapes(mask, mask=mask, transform=transform))
+        )
+        shapes_list = list(shapes_generator)
+        app_logger.info(f"created {len(shapes_list)} polygons.")
+        gpd_polygonized_raster = GeoDataFrame.from_features(shapes_list, crs="EPSG:3857")
+        app_logger.info(f"created a GeoDataFrame...")
+        geojson = gpd_polygonized_raster.to_json(to_wgs84=True)
+        app_logger.info(f"created geojson...")
+
+        return {
+            "geojson": geojson,
+            "n_shapes_geojson": len(shapes_list),
+            "n_predictions": len(prediction_masks),
+            # "n_pixels_predictions": zip_arrays(mask_unique_values, mask_unique_values_count),
+        }
     except ImportError as e:
         app_logger.error(f"Error trying import module:{e}.")