[refactor] remove and transform unuseful logs to debug

src/app.py

@@ -1,17 +1,15 @@
 import json
 import time
 from http import HTTPStatus
-from pathlib import Path
 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.io.coordinates_pixel_conversion import get_latlng_to_pixel_coordinates, get_point_latlng_to_pixel_coordinates
+from src.io.coordinates_pixel_conversion import get_latlng_to_pixel_coordinates
 from src.prediction_api.predictors import samexporter_predict
-from src.utilities.constants import CUSTOM_RESPONSE_MESSAGES, ROOT
-from src.utilities.serialize import serialize
+from src.utilities.constants import CUSTOM_RESPONSE_MESSAGES
 from src.utilities.utilities import base64_decode
 
 
@@ -59,32 +57,40 @@ def get_parsed_bbox_points(request_input: Dict) -> Dict:
     for prompt in request_input["prompt"]:
         app_logger.info(f"current prompt: {type(prompt)}, value:{prompt}.")
         data = prompt["data"]
-        if prompt["type"] == "rectangle":
-            app_logger.info(f"current data points: {type(data)}, value:{data}.")
-            data_ne = data["ne"]
-            app_logger.info(f"current data_ne point: {type(data_ne)}, value:{data_ne}.")
-            data_sw = data["sw"]
-            app_logger.info(f"current data_sw point: {type(data_sw)}, value:{data_sw}.")
-
-            diff_pixel_coords_origin_data_ne = get_latlng_to_pixel_coordinates(ne, sw, data_ne, zoom, "ne")
-            app_logger.info(f'current diff prompt ne: {type(data)}, {data} => {diff_pixel_coords_origin_data_ne}.')
-            diff_pixel_coords_origin_data_sw = get_latlng_to_pixel_coordinates(ne, sw, data_sw, zoom, "sw")
-            app_logger.info(f'current diff prompt sw: {type(data)}, {data} => {diff_pixel_coords_origin_data_sw}.')
-            prompt["data"] = [
-                diff_pixel_coords_origin_data_ne["x"], diff_pixel_coords_origin_data_ne["y"],
-                diff_pixel_coords_origin_data_sw["x"], diff_pixel_coords_origin_data_sw["y"]
-            ]
-        elif prompt["type"] == "point":
+        # if prompt["type"] == "rectangle":
+        #     app_logger.info(f"current data points: {type(data)}, value:{data}.")
+        #     data_ne = data["ne"]
+        #     app_logger.info(f"current data_ne point: {type(data_ne)}, value:{data_ne}.")
+        #     data_sw = data["sw"]
+        #     app_logger.info(f"current data_sw point: {type(data_sw)}, value:{data_sw}.")
+        #
+        #     diff_pixel_coords_origin_data_ne = get_latlng_to_pixel_coordinates(ne, sw, data_ne, zoom, "ne")
+        #     app_logger.info(f'current diff prompt ne: {type(data)}, {data} => {diff_pixel_coords_origin_data_ne}.')
+        #     diff_pixel_coords_origin_data_sw = get_latlng_to_pixel_coordinates(ne, sw, data_sw, zoom, "sw")
+        #     app_logger.info(f'current diff prompt sw: {type(data)}, {data} => {diff_pixel_coords_origin_data_sw}.')
+        #     prompt["data"] = [
+        #         diff_pixel_coords_origin_data_ne["x"], diff_pixel_coords_origin_data_ne["y"],
+        #         diff_pixel_coords_origin_data_sw["x"], diff_pixel_coords_origin_data_sw["y"]
+        #     ]
+        #     # rect_diffs_input = str(Path(ROOT) / "rect_diffs_input.json")
+        #     # with open(rect_diffs_input, "w") as jj_out3:
+        #     #     json.dump({
+        #     #         "prompt_data": serialize(prompt["data"]),
+        #     #         "diff_pixel_coords_origin_data_ne": serialize(diff_pixel_coords_origin_data_ne),
+        #     #         "diff_pixel_coords_origin_data_sw": serialize(diff_pixel_coords_origin_data_sw),
+        #     #     }, jj_out3)
+        #     # app_logger.info(f"written json:{rect_diffs_input}.")
+        if prompt["type"] == "point":
             current_point = get_latlng_to_pixel_coordinates(ne, sw, data, zoom, "point")
             app_logger.info(f"current prompt: {type(current_point)}, value:{current_point}.")
             new_prompt_data = [current_point['x'], current_point['y']]
             app_logger.info(f"new_prompt_data: {type(new_prompt_data)}, value:{new_prompt_data}.")
             prompt["data"] = new_prompt_data
         else:
-            raise ValueError("valid prompt types are only 'point' and 'rectangle'")
+            raise ValueError("valid prompt type is only 'point'")
 
     app_logger.info(f"bbox => {bbox}.")
-    app_logger.info(f'## request_input["prompt"] updated => {request_input["prompt"]}.')
+    app_logger.info(f'## request_input-prompt updated => {request_input["prompt"]}.')
 
     app_logger.info(f"unpacking elaborated {request_input}...")
     return {
@@ -125,9 +131,7 @@ def lambda_handler(event: dict, context: LambdaContext):
             app_logger.info(f"prompt_latlng:{prompt_latlng}.")
             body_request = get_parsed_bbox_points(body)
             app_logger.info(f"body_request=> {type(body_request)}, {body_request}.")
-            body_response = samexporter_predict(
-                body_request["bbox"], body_request["prompt"], body_request["zoom"], prompt_latlng
-            )
+            body_response = samexporter_predict(body_request["bbox"], body_request["prompt"], body_request["zoom"])
             app_logger.info(f"output body_response:{body_response}.")
             response = get_response(HTTPStatus.OK.value, start_time, context.aws_request_id, body_response)
         except Exception as ex2:

src/io/tiles_to_tiff.py

@@ -1,15 +1,14 @@
 """Async download raster tiles"""
-import os
 from pathlib import Path
 
 import numpy as np
 
 from src import app_logger, PROJECT_ROOT_FOLDER
-from src.io.helpers import get_lat_lon_coords, merge_tiles, get_geojson_square_angles, crop_raster
-from src.io.tms2geotiff import download_extent, save_geotiff_gdal
+from src.io.tms2geotiff import download_extent
 from src.utilities.constants import COMPLETE_URL_TILES, DEFAULT_TMS
 from src.utilities.type_hints import ts_llist2
 
+
 COOKIE_SESSION = {
     "Accept": "*/*",
     "Accept-Encoding": "gzip, deflate",
@@ -58,137 +57,34 @@ def convert(bounding_box: ts_llist2, zoom: int) -> tuple:
         dict: uploaded_file_name (str), bucket_name (str), prediction_georef (dict), n_total_obj_prediction (str)
 
     """
-    import tempfile
-
-    # from src.surferdtm_prediction_api.utilities.constants import NODATA_VALUES
-    # from src.surferdtm_prediction_api.utilities.utilities import setup_logging
-    # from src.surferdtm_prediction_api.raster.elaborate_images import elaborate_images.get_rgb_prediction_image
-    # from src.surferdtm_prediction_api.raster.prediction import model_prediction
-    # from src.surferdtm_prediction_api.geo.helpers import get_lat_lon_coords, merge_tiles, crop_raster, get_prediction_georeferenced, \
-    #     get_geojson_square_angles, get_perc
-
-    # app_logger = setup_logging(debug)
-    ext = "tif"
-    debug = False
+
     tile_source = COMPLETE_URL_TILES
     app_logger.info(f"start_args: tile_source:{tile_source},bounding_box:{bounding_box},zoom:{zoom}.")
 
     try:
         import rasterio
 
-        lon_min, lat_min, lon_max, lat_max = get_lat_lon_coords(bounding_box)
-
-        with tempfile.TemporaryDirectory() as input_tmp_dir:
-            # with tempfile.TemporaryDirectory() as output_tmp_dir:
-            output_tmp_dir = input_tmp_dir
-            app_logger.info(f'tile_source: {tile_source}!')
-            app_logger.info(f'created temporary input/output directory: {input_tmp_dir} => {output_tmp_dir}!')
-            pt0, pt1 = bounding_box
-            app_logger.info("downloading...")
-            img, matrix = download_extent(DEFAULT_TMS, pt0[0], pt0[1], pt1[0], pt1[1], zoom)
-
-            app_logger.info(f'img: type {type(img)}, len_matrix:{len(matrix)}, matrix {matrix}.')
-            app_logger.info(f'img: size (shape if PIL) {img.size}.')
-            try:
-                np_img = np.array(img)
-                app_logger.info(f'img: shape (numpy) {np_img.shape}.')
-            except Exception as e_shape:
-                app_logger.info(f'e_shape {e_shape}.')
-                raise e_shape
-            img.save(f"/tmp/downloaded_{pt0[0]}_{pt0[1]}_{pt1[0]}_{pt1[1]}.png")
-            app_logger.info("saved PIL image")
-
-            return img, matrix
-            # app_logger.info("prepare writing...")
-            # app_logger.info(f'img: type {type(img)}, len_matrix:{len(matrix)}, matrix {matrix}.')
-            #
-            # rio_output = str(Path(output_tmp_dir) / "downloaded_rio.tif")
-            # app_logger.info(f'writing to disk img, output file {rio_output}.')
-            # save_geotiff_gdal(img, rio_output, matrix)
-            # app_logger.info(f'img written to output file {rio_output}.')
-            #
-            # source_tiles = os.path.join(input_tmp_dir, f"*.{ext}")
-            # suffix_raster_filename = f"{lon_min},{lat_min},{lon_max},{lat_max}_{zoom}"
-            # merged_raster_filename = f"merged_{suffix_raster_filename}.{ext}"
-            # masked_raster_filename = f"masked_{suffix_raster_filename}.{ext}"
-            # output_merged_path = os.path.join(output_tmp_dir, merged_raster_filename)
-            #
-            # app_logger.info(f"try merging tiles to:{output_merged_path}.")
-            # merge_tiles(source_tiles, output_merged_path, input_tmp_dir)
-            # app_logger.info(f"Merge complete, try crop...")
-            # geojson = get_geojson_square_angles(bounding_box, name=suffix_raster_filename, debug=debug)
-            # app_logger.info(f"geojson to convert:{geojson}.")
-            #
-            # crop_raster_output = crop_raster(output_merged_path, geojson, debug=False)
-            # masked_raster = crop_raster_output["masked_raster"]
-            # masked_meta = crop_raster_output["masked_meta"]
-            # masked_transform = crop_raster_output["masked_transform"]
-            #
-            # return masked_raster, masked_transform
-
-            # app_logger.info(f"resampling -32768 values as NaN for file:{masked_raster_filename}.")
-            # masked_raster = masked_raster[0].astype(float)
-            # masked_raster[masked_raster == NODATA_VALUES] = 0
-            # # info
-            # nan_count = np.count_nonzero(~np.isnan(masked_raster))
-            # total_count = masked_raster.shape[-1] * masked_raster.shape[-2]
-            # perc = get_perc(nan_count, total_count)
-            # msg = f"img:{masked_raster_filename}, shape:{masked_raster.shape}: found {nan_count} not-NaN values / {total_count} total, %:{perc}."
-            # app_logger.info(msg)
-            #
-            # app_logger.info(f"crop complete, shape:{masked_raster.shape}, dtype:{masked_raster.dtype}. Create RGB image...")
-            # # rgb_filename, rgb_path = elaborate_images.get_rgb_prediction_image(masked_raster, slope_cellsize, suffix_raster_filename, output_tmp_dir, debug=debug)
-            # # prediction = model_prediction(rgb_path, project_name=model_project_name, version=model_version, api_key=model_api_key, debug=False)
-            #
-            # mask_vectorizing = np.ones(masked_raster.shape).astype(rasterio.uint8)
-            # app_logger.info(f"prediction success, try to geo-referencing it with transform:{masked_transform}.")
-            #
-            # app_logger.info(
-            #     f"image/geojson origin matrix:, masked_transform:{masked_transform}: create shapes_generator...")
-            # app_logger.info(f"raster mask to vectorize, type:{type(mask_vectorizing)}.")
-            # app_logger.info(f"raster mask to vectorize: shape:{mask_vectorizing.shape}, {mask_vectorizing.dtype}.")
-            #
-            # shapes_generator = ({
-            #     'properties': {'raster_val': v}, 'geometry': s}
-            #     for i, (s, v)
-            #     in enumerate(shapes(mask_vectorizing, mask=mask_vectorizing, transform=masked_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: type {type(gpd_polygonized_raster)}.")
-            # geojson = gpd_polygonized_raster.to_json(to_wgs84=True)
-            # app_logger.info(f"created geojson: type {type(geojson)}, len:{len(geojson)}.")
-            # serialized_geojson = serialize.serialize(geojson)
-            # app_logger.info(f"created serialized_geojson: type {type(serialized_geojson)}, len:{len(serialized_geojson)}.")
-            # loaded_geojson = json.loads(geojson)
-            # app_logger.info(f"loaded_geojson: type {type(loaded_geojson)}, loaded_geojson:{loaded_geojson}.")
-            # n_feats = len(loaded_geojson["features"])
-            # app_logger.info(f"created geojson: n_feats {n_feats}.")
-            #
-            # output_geojson = str(Path(ROOT) / "geojson_output.json")
-            # with open(output_geojson, "w") as jj_out:
-            #     app_logger.info(f"writing geojson file to {output_geojson}.")
-            #     json.dump(loaded_geojson, jj_out)
-            #     app_logger.info(f"geojson file written to {output_geojson}.")
-            #
-            # # prediction_georef = helpers.get_prediction_georeferenced(prediction, masked_transform, skip_conditions_list, debug=debug)
-            # app_logger.info(f"success on geo-referencing prediction.")
-            # # app_logger.info(f"success on creating file {rgb_filename}, now try upload it to bucket_name {bucket_name}...")
-            # return {
-            #     # "uploaded_file_name": rgb_filename,
-            #     "geojson": loaded_geojson,
-            #     # "prediction_georef": prediction_georef,
-            #     "n_total_obj_prediction": n_feats
-            # }
+        app_logger.info(f'tile_source: {tile_source}!')
+        pt0, pt1 = bounding_box
+        app_logger.info("downloading...")
+        img, matrix = download_extent(DEFAULT_TMS, pt0[0], pt0[1], pt1[0], pt1[1], zoom)
+
+        app_logger.info(f'img: type {type(img)}, len_matrix:{len(matrix)}, matrix {matrix}.')
+        app_logger.info(f'img: size (shape if PIL) {img.size}.')
+        try:
+            np_img = np.array(img)
+            app_logger.info(f'img: shape (numpy) {np_img.shape}.')
+        except Exception as e_shape:
+            app_logger.info(f'e_shape {e_shape}.')
+            raise e_shape
+
+        return img, matrix
     except ImportError as e_import_convert:
         app_logger.error(f"e0:{e_import_convert}.")
         raise e_import_convert
 
 
 if __name__ == '__main__':
-    from PIL import Image
-
     npy_file = "prediction_masks_46.27697017893455_9.616470336914064_46.11441972281433_9.264907836914064.npy"
     prediction_masks = np.load(Path(PROJECT_ROOT_FOLDER) / "tmp" / "try_by_steps" / "t0" / npy_file)
 

src/main.py

@@ -1,14 +0,0 @@
-import rasterio
-from affine import loadsw
-
-from src import PROJECT_ROOT_FOLDER
-
-if __name__ == '__main__':
-    with open(PROJECT_ROOT_FOLDER / "tmp" / "japan_out_main.pgw") as pgw:
-        pgw_file = pgw.read()
-        a = loadsw(pgw_file)
-    with rasterio.open(PROJECT_ROOT_FOLDER / "tmp" / "japan_out_main.png", "r") as src:
-        src_transform = src.transform
-        print(a, src_transform)
-        print(a, src_transform)
-        print("a, src_tranform")

src/prediction_api/predictors.py

@@ -1,18 +1,16 @@
 # Press the green button in the gutter to run the script.
-import json
+import tempfile
 from pathlib import Path
 from typing import List
 
 import numpy as np
 import rasterio
-from PIL import Image
 
 from src import app_logger, MODEL_FOLDER
 from src.io.tiles_to_tiff import convert
 from src.io.tms2geotiff import save_geotiff_gdal
 from src.prediction_api.sam_onnx import SegmentAnythingONNX
-from src.utilities.constants import MODEL_ENCODER_NAME, ZOOM, MODEL_DECODER_NAME, ROOT
-from src.utilities.serialize import serialize
+from src.utilities.constants import MODEL_ENCODER_NAME, MODEL_DECODER_NAME
 
 
 models_dict = {"fastsam": {"instance": None}}
@@ -51,128 +49,87 @@ 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, prompt: list[dict], zoom: float = ZOOM, model_name: str = "fastsam") -> dict:
+def samexporter_predict(bbox, prompt: list[dict], zoom: float, model_name: str = "fastsam") -> dict:
     try:
         from rasterio.features import shapes
         from geopandas import GeoDataFrame
 
         if models_dict[model_name]["instance"] is None:
-            app_logger.info(f"missing instance model {model_name}, instantiating it now")
+            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
             )
             models_dict[model_name]["instance"] = model_instance
-        app_logger.info(f"using a {model_name} instance model...")
+        app_logger.debug(f"using a {model_name} instance model...")
         models_instance = models_dict[model_name]["instance"]
 
-        img, matrix = convert(
-            bounding_box=bbox,
-            zoom=int(zoom)
-        )
-
-        pt0, pt1 = bbox
-        rio_output = f"/tmp/downloaded_rio_{pt0[0]}_{pt0[1]}_{pt1[0]}_{pt1[1]}.tif"
-        save_geotiff_gdal(img, rio_output, matrix)
-        app_logger.info(f"saved downloaded geotiff image to {rio_output}...")
-
-        np_img = np.array(img)
-        app_logger.info(f"## img type {type(np_img)}, prompt:{prompt}.")
-
-        app_logger.info(f"onnxruntime input shape/size (shape if PIL) {np_img.size},"
-                        f"start to initialize SamGeo instance:")
-        try:
-            app_logger.info(f"onnxruntime input shape (NUMPY) {np_img.shape}.")
-        except Exception as e_shape:
-            app_logger.error(f"e_shape:{e_shape}.")
-        app_logger.info(f"use {model_name} model, ENCODER model {MODEL_ENCODER_NAME} and"
-                        f" {MODEL_DECODER_NAME} from {MODEL_FOLDER}): 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"predict_masks terminated, prediction masks shape:{prediction_masks.shape}, {prediction_masks.dtype}.")
-        pt0, pt1 = bbox
-        prediction_masks_output = f"/tmp/prediction_masks_{pt0[0]}_{pt0[1]}_{pt1[0]}_{pt1[1]}.npy"
-        np.save(
-            prediction_masks_output,
-            prediction_masks, allow_pickle=True, fix_imports=True
-        )
-        app_logger.info(f"saved prediction_masks:{prediction_masks_output}.")
-
-        mask = np.zeros((prediction_masks.shape[2], prediction_masks.shape[3]), dtype=np.uint8)
-        app_logger.info(f"output mask shape:{mask.shape}, {mask.dtype}.")
-        for n, m in enumerate(prediction_masks[0, :, :, :]):
-            app_logger.info(f"## {n} mask => m shape:{mask.shape}, {mask.dtype}.")
-            mask[m > 0.0] = 255
-        # prediction_masks0 = prediction_masks[0]
-        # app_logger.info(f"prediction_masks0 shape:{prediction_masks0.shape}.")
-        #
-        # try:
-        #     pmf = np.sum(prediction_masks0, axis=0).astype(np.uint8)
-        # except Exception as e_sum_pmf:
-        #     app_logger.error(f"e_sum_pmf:{e_sum_pmf}.")
-        #     pmf = prediction_masks0[0]
-        # app_logger.info(f"creating pil image from prediction mask with shape {pmf.shape}.")
-        # pil_pmf = Image.fromarray(pmf)
-        # pil_pmf_output = f"/tmp/pil_pmf_{pmf.shape[0]}_{pmf.shape[1]}.png"
-        # pil_pmf.save(pil_pmf_output)
-        # app_logger.info(f"saved pil_pmf:{pil_pmf_output}.")
-        #
-        # mask = np.zeros(pmf.shape, dtype=np.uint8)
-        # mask[pmf > 0] = 255
-
-        # cv2.imwrite(f"/tmp/cv2_mask_predicted_{mask.shape[0]}_{mask.shape[1]}_{mask.shape[2]}.png", mask)
-        pil_mask = Image.fromarray(mask)
-        pil_mask_predicted_output = f"/tmp/pil_mask_predicted_{mask.shape[0]}_{mask.shape[1]}.png"
-        pil_mask.save(pil_mask_predicted_output)
-        app_logger.info(f"saved pil_mask_predicted:{pil_mask_predicted_output}.")
-
-        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}.")
-
-        app_logger.info(f"read geotiff:{rio_output}: create shapes_generator...")
-        # app_logger.info(f"image/geojson transform:{transform}: create shapes_generator...")
-        with rasterio.open(rio_output, "r", driver="GTiff") as rio_src:
-            band = rio_src.read()
-            try:
-                transform = load_affine_transformation_from_matrix(matrix)
-                app_logger.info(f"geotiff band:{band.shape}, type: {type(band)}, dtype: {band.dtype}.")
-                app_logger.info(f"geotiff band:{mask.shape}.")
-                app_logger.info(f"transform from matrix:{transform}.")
-                app_logger.info(f"rio_src crs:{rio_src.crs}.")
-                app_logger.info(f"rio_src transform:{rio_src.transform}.")
-            except Exception as e_shape_band:
-                app_logger.error(f"e_shape_band:{e_shape_band}.")
-                raise e_shape_band
-            # mask_band = band != 0
-            shapes_generator = ({
-                'properties': {'raster_val': v}, 'geometry': s}
-                for i, (s, v)
-                # in enumerate(shapes(mask, mask=(band != 0), transform=rio_src.transform))
-                # use mask=None to avoid using source
-                in enumerate(shapes(mask, mask=None, transform=rio_src.transform))
+        with tempfile.TemporaryDirectory() as input_tmp_dir:
+            img, matrix = convert(
+                bounding_box=bbox,
+                zoom=int(zoom)
             )
-            app_logger.info(f"created shapes_generator.")
-            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...")
-
-            output_geojson = str(Path(ROOT) / "geojson_output.json")
-            with open(output_geojson, "w") as jj_out:
-                app_logger.info(f"writing geojson file to {output_geojson}.")
-                json.dump(json.loads(geojson), jj_out)
-                app_logger.info(f"geojson file written to {output_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),
-            }
+            app_logger.debug(f"## img type {type(img)} with shape/size:{img.size}, matrix:{matrix}.")
+
+            pt0, pt1 = bbox
+            rio_output = str(Path(input_tmp_dir) / f"downloaded_rio_{pt0[0]}_{pt0[1]}_{pt1[0]}_{pt1[1]}.tif")
+            app_logger.debug(f"saving downloaded geotiff image to {rio_output}...")
+            save_geotiff_gdal(img, rio_output, matrix)
+            app_logger.info(f"saved downloaded geotiff image to {rio_output}...")
+
+            np_img = np.array(img)
+            app_logger.info(f"## img type {type(np_img)}, prompt:{prompt}.")
+
+            app_logger.info(f"onnxruntime input shape/size (shape if PIL) {np_img.size}.")
+            try:
+                app_logger.info(f"onnxruntime input shape (NUMPY) {np_img.shape}.")
+            except Exception as e_shape:
+                app_logger.error(f"e_shape:{e_shape}.")
+            app_logger.info(f"instantiated model {model_name}, ENCODER {MODEL_ENCODER_NAME}, "
+                            f"DECODER {MODEL_DECODER_NAME} from {MODEL_FOLDER}: Creating embedding...")
+            embedding = models_instance.encode(np_img)
+            app_logger.info(f"embedding created, running predict_masks with prompt {prompt}...")
+            prediction_masks = models_instance.predict_masks(embedding, prompt)
+            app_logger.info(f"Created {len(prediction_masks)} prediction_masks,"
+                            f"shape:{prediction_masks.shape}, dtype:{prediction_masks.dtype}.")
+
+            mask = np.zeros((prediction_masks.shape[2], prediction_masks.shape[3]), dtype=np.uint8)
+            for n, m in enumerate(prediction_masks[0, :, :, :]):
+                app_logger.debug(f"## {n} mask => m shape:{mask.shape}, {mask.dtype}.")
+                mask[m > 0.0] = 255
+
+            app_logger.info(f"read downloaded geotiff:{rio_output} to create the shapes_generator...")
+
+            with rasterio.open(rio_output, "r", driver="GTiff") as rio_src:
+                band = rio_src.read()
+                try:
+                    app_logger.debug(f"geotiff band:{band.shape}, type: {type(band)}, dtype: {band.dtype}.")
+                    app_logger.debug(f"rio_src crs:{rio_src.crs}.")
+                    app_logger.debug(f"rio_src transform:{rio_src.transform}.")
+                except Exception as e_shape_band:
+                    app_logger.error(f"e_shape_band:{e_shape_band}.")
+                    raise e_shape_band
+                # mask_band = band != 0
+                shapes_generator = ({
+                    'properties': {'raster_val': v}, 'geometry': s}
+                    for i, (s, v)
+                    # in enumerate(shapes(mask, mask=(band != 0), transform=rio_src.transform))
+                    # use mask=None to avoid using source
+                    in enumerate(shapes(mask, mask=None, transform=rio_src.transform))
+                )
+                app_logger.info(f"created shapes_generator, transform it to a polygon list...")
+                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, export to geojson...")
+                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}.")

src/prediction_api/sam_onnx.py

@@ -1,4 +1,3 @@
-import json
 from copy import deepcopy
 
 import cv2
@@ -6,7 +5,6 @@ import numpy as np
 import onnxruntime
 
 from src import app_logger
-from src.utilities.serialize import serialize
 
 
 class SegmentAnythingONNX:
@@ -149,22 +147,10 @@ class SegmentAnythingONNX:
                 mask = masks[batch, mask_id]
                 try:
                     try:
-                        app_logger.info(f"mask_shape transform_masks:{mask.shape}, dtype:{mask.dtype}.")
+                        app_logger.debug(f"mask_shape transform_masks:{mask.shape}, dtype:{mask.dtype}.")
                     except Exception as e_mask_shape_transform_masks:
                         app_logger.error(f"e_mask_shape_transform_masks:{e_mask_shape_transform_masks}.")
                         # raise e_mask_shape_transform_masks
-                    output_filename = f"2_cv2img_{'_'.join([str(s) for s in mask.shape])}.npy"
-                    np.save(output_filename, np.array(mask), allow_pickle=True, fix_imports=True)
-                    app_logger.info(f"written: /tmp/{output_filename} ...")
-                    with open("/tmp/2_args.json", "w") as jj_out_dst:
-                        json.dump({
-                            "transform_matrix": serialize(transform_matrix),
-                            "M": serialize(transform_matrix[:2]),
-                            "original_size": serialize(original_size),
-                            "dsize": serialize((original_size[1], original_size[0])),
-                            "flags": cv2.INTER_LINEAR
-                        }, jj_out_dst)
-                    app_logger.info(f"written: /tmp/jj_out.json")
                     mask = cv2.warpAffine(
                         mask,
                         transform_matrix[:2],
@@ -198,22 +184,6 @@ class SegmentAnythingONNX:
             ]
         )
         try:
-            np_cv_image = np.array(cv_image)
-            try:
-                app_logger.info(f"cv_image shape_encode:{np_cv_image.shape}, dtype:{np_cv_image.dtype}.")
-            except Exception as e_cv_image_shape_encode:
-                app_logger.error(f"e_cv_image_shape_encode:{e_cv_image_shape_encode}.")
-                # raise e_cv_image_shape_encode
-            output_filename = f"/tmp/1_cv2img_{'_'.join([str(s) for s in np_cv_image.shape])}.npy"
-            np.save(output_filename, np_cv_image, allow_pickle=True, fix_imports=True)
-            app_logger.info(f"written: /tmp/{output_filename} ...")
-            with open("/tmp/1_args.json", "w") as jj_out_dst:
-                json.dump({
-                    "transform_matrix": serialize(transform_matrix),
-                    "M": serialize(transform_matrix[:2]),
-                    "flags": cv2.INTER_LINEAR
-                }, jj_out_dst)
-            app_logger.info(f"written: /tmp/jj_out.json")
             cv_image = cv2.warpAffine(
                 cv_image,
                 transform_matrix[:2],