samgis_core 3.0.5__tar.gz → 3.0.8__tar.gz

{samgis_core-3.0.5 → samgis_core-3.0.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: samgis_core
-Version: 3.0.5
+Version: 3.0.8
 Summary: SamGIS CORE
 License: MIT
 Author: alessandro trinca tornidor

{samgis_core-3.0.5 → samgis_core-3.0.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "samgis_core"
-version = "3.0.5"
+version = "3.0.8"
 description = "SamGIS CORE"
 authors = ["alessandro trinca tornidor <alessandro@trinca.tornidor.com>"]
 license = "MIT license"
@@ -8,7 +8,7 @@ readme = "README.md"
 
 [metadata]
 name = "samgis_core"
-version = "3.0.5"
+version = "3.0.8"
 
 [tool.poetry.urls]
 Source = "https://gitlab.com/aletrn/samgis_core"
@@ -37,6 +37,7 @@ optional = true
 mpld3 = "^0.5.10"
 pytest = "^8.2.2"
 pytest-cov = "^5.0.0"
+rasterio = "^1.3.10"
 
 [build-system]
 requires = ["poetry-core"]

{samgis_core-3.0.5 → samgis_core-3.0.8}/samgis_core/prediction_api/sam_onnx_inference.py

@@ -70,7 +70,8 @@ def get_inference_embedding(
 
 
 def get_raster_inference_using_existing_embedding(
-        embedding: dict, prompt: ListDict, models_instance: SegmentAnythingONNX2) -> TupleNdarrayInt:
+        embedding: dict, prompt: ListDict, models_instance: SegmentAnythingONNX2, folder_write_tmp_on_disk: str = None,
+        key: str = None) -> TupleNdarrayInt:
     """
     Get inference output for a given image using a SegmentAnythingONNX model, using an existing embedding instead of a
     new ndarray or PIL image
@@ -79,6 +80,8 @@ def get_raster_inference_using_existing_embedding(
         embedding: dict
         prompt: list of prompt dict
         models_instance: SegmentAnythingONNX instance model
+        folder_write_tmp_on_disk: output folder where to write debug images
+        key: embedding key
 
     Returns:
         raster prediction mask, prediction number
@@ -90,16 +93,27 @@ def get_raster_inference_using_existing_embedding(
     app_logger.info(f"Created {len_inference_out} prediction_masks,"
                     f"shape:{inference_out.shape}, dtype:{inference_out.dtype}.")
     mask = zeros((inference_out.shape[2], inference_out.shape[3]), dtype=uint8)
+    write_tmp_img = bool(folder_write_tmp_on_disk)
     for n, m in enumerate(inference_out[0, :, :, :]):
         app_logger.debug(f"{n}th of prediction_masks shape {inference_out.shape}"
                          f" => mask shape:{mask.shape}, {mask.dtype}.")
         mask[m > 0.0] = 255
+        if write_tmp_img:
+            from pathlib import Path
+            from datetime import datetime
+            from samgis_core.utilities.utilities import convert_ndarray_to_pil, normalize_array
+            m_normalized = normalize_array(m, type_normalization="float")
+            m_out = convert_ndarray_to_pil(m_normalized)
+            now = datetime.now().isoformat()
+            if len(m.shape) == 2:
+                m_out = m_out.convert("L")
+            m_out.save(Path(folder_write_tmp_on_disk) / f"mask_{key}_{now}_n{n}.png")
     return mask, len_inference_out
 
 
 def get_raster_inference_with_embedding_from_dict(
         img: PIL_Image | ndarray, prompt: ListDict, models_instance: SegmentAnythingONNX2, model_name: str,
-        embedding_key: str, embedding_dict: dict) -> TupleNdarrayInt:
+        embedding_key: str, embedding_dict: dict, folder_write_tmp_on_disk: str = None) -> TupleNdarrayInt:
     """
     Get inference output using a SegmentAnythingONNX model, but get the image embedding from the given embedding dict
      instead of creating a new embedding. This function needs the img argument to update the embedding dict if necessary
@@ -111,6 +125,7 @@ def get_raster_inference_with_embedding_from_dict(
         model_name: model name string
         embedding_key: embedding id
         embedding_dict: embedding images dict
+        folder_write_tmp_on_disk: output folder where to write debug images
 
     Returns:
         raster prediction mask, prediction number
@@ -122,4 +137,5 @@ def get_raster_inference_with_embedding_from_dict(
     embedding = embedding_dict[embedding_key]
     n_keys = len(embedding_dict)
     app_logger.info(f"embedding created ({n_keys} keys in embedding dict), running predict_masks with prompt {prompt}.")
-    return get_raster_inference_using_existing_embedding(embedding, prompt, models_instance)
+    return get_raster_inference_using_existing_embedding(
+        embedding, prompt, models_instance, folder_write_tmp_on_disk=folder_write_tmp_on_disk, key=embedding_key)

samgis_core-3.0.8/samgis_core/utilities/frontend_builder.py

@@ -0,0 +1,150 @@
+import os
+import subprocess
+from pathlib import Path
+
+from dotenv import load_dotenv
+
+from samgis_core import app_logger
+from samgis_core.utilities.type_hints import ListStr
+
+
+load_dotenv()
+root_folder = Path(globals().get("__file__", "./_")).absolute().parent.parent.parent
+env_project_root_folder = os.getenv("PROJECT_ROOT_FOLDER", str(root_folder))
+env_input_css_path = os.getenv("INPUT_CSS_PATH")
+
+
+def assert_envs(envs_list: ListStr) -> None:
+    """
+    Assert env variables are not empty.
+
+    Args:
+        envs_list: list of env variables
+
+    Returns:
+
+    """
+    for current_env in envs_list:
+        try:
+            assert current_env is not None and current_env != ""
+        except AssertionError as aex:
+            app_logger.error(f"error on assertion for current_env: {current_env}.")
+            raise aex
+
+
+def read_std_out_err(std_out_err: str, output_type: str, command: ListStr) -> None:
+    """
+    Capture the standard output or standard error content for a given system command pipe.
+
+    Args:
+        std_out_err: str
+        output_type: output type (stdout or stderr)
+        command: command executed
+
+    Returns:
+
+    """
+    output = std_out_err.split("\n")
+    app_logger.info(f"output type:{output_type} for command:{' '.join(command)}.")
+    for line in iter(output):
+        app_logger.info(f"output_content_home stdout:{line.strip()}.")
+    app_logger.info("########")
+
+
+def run_command(commands_list: ListStr, capture_output: bool = True, text: bool = True, check: bool = True) -> None:
+    """
+    Run a system command and capture its output.
+    See https://docs.python.org/3.11/library/subprocess.html#subprocess.run for more details
+
+    Args:
+        commands_list: list of single string commands
+        capture_output: if true, stdout and stderr will be captured
+        text: if true, capture stdout and stderr as strings
+        check: If check is true, and the process exits with a non-zero exit code, a CalledProcessError exception will
+               be raised. Attributes of that exception hold the arguments, the exit code, and stdout and stderr if they
+               were captured.
+
+    Returns:
+
+    """
+    try:
+        output_content_home = subprocess.run(
+            commands_list,
+            capture_output=capture_output,
+            text=text,
+            check=check
+        )
+        read_std_out_err(output_content_home.stdout, "stdout", commands_list)
+        read_std_out_err(output_content_home.stderr, "stderr", commands_list)
+    except Exception as ex:
+        app_logger.error(f"ex:{ex}.")
+        raise ex
+
+
+def build_frontend(
+        project_root_folder: str | Path,
+        input_css_path: str | Path,
+        output_dist_folder: Path = root_folder / "static" / "dist",
+        index_page_filename: str = "index.html",
+        output_css_filename: str = "output.css",
+        force_build: bool = False,
+    ) -> bool:
+    """
+    Build a static [Vue js](https://vuejs.org/), [tailwindcss](https://tailwindcss.com/) frontend.
+    If force_build is False, the function also check if index_page_filename and output_css_filename already exists:
+    in this case skip the build.
+
+    Args:
+        project_root_folder: Project folder that contains the static frontend
+        input_css_path: file path pointing to the input css file
+        output_dist_folder: dist folder path where to write the frontend bundle
+        index_page_filename: index html filename
+        output_css_filename: output css filename
+        force_build: useful to skip the frontend build
+
+    Returns:
+        state of the build (True in case of build completed, False in case of build skipped)
+
+    """
+    assert_envs([
+        str(project_root_folder),
+        str(input_css_path)
+    ])
+    project_root_folder = Path(project_root_folder)
+    index_html_pathfile = Path(output_dist_folder) / index_page_filename
+    output_css_pathfile = Path(output_dist_folder) / output_css_filename
+    if not force_build and output_css_pathfile.is_file() and index_html_pathfile.is_file():
+        app_logger.info("frontend ok, build_frontend not necessary...")
+        return False
+
+    # install deps
+    os.chdir(project_root_folder / "static")
+    current_folder = os.getcwd()
+    app_logger.info(f"current_folder:{current_folder}, install pnpm...")
+    run_command(["which", "npm"])
+    run_command(["npm", "install", "-g", "npm", "pnpm"])
+    app_logger.info(f"install pnpm dependencies...")
+    run_command(["pnpm", "install"])
+
+    # build frontend dist and assert for its correct build
+    output_css = str(output_dist_folder / output_css_filename)
+    output_index_html = str(output_dist_folder / index_page_filename)
+    output_dist_folder = str(output_dist_folder)
+    app_logger.info(f"pnpm: build '{output_dist_folder}'...")
+    run_command(["pnpm", "build"])
+    app_logger.info(f"pnpm: ls -l {output_index_html}:")
+    run_command(["ls", "-l", output_index_html])
+    cmd = ["pnpm", "tailwindcss", "-i", str(input_css_path), "-o", output_css]
+    app_logger.info(f"pnpm: {' '.join(cmd)}...")
+    run_command(["pnpm", "tailwindcss", "-i", str(input_css_path), "-o", output_css])
+    app_logger.info(f"pnpm: ls -l {output_css}:")
+    run_command(["ls", "-l", output_css])
+    app_logger.info(f"end!")
+    return True
+
+
+if __name__ == '__main__':
+    build_frontend(
+        project_root_folder=Path(env_project_root_folder),
+        input_css_path=Path(env_input_css_path)
+    )

{samgis_core-3.0.5 → samgis_core-3.0.8}/samgis_core/utilities/plot_images.py

@@ -1,12 +1,15 @@
+import structlog.stdlib
 from numpy import ndarray
 from matplotlib import pyplot as plt
 
-from samgis_core.utilities.type_hints import ListStr, TupleInt
-
+from samgis_core.utilities.type_hints import ListStr, MatplotlibBackend
 
 FigAxes = tuple[plt.Figure, plt.Axes]
 
 
+logger = structlog.stdlib.get_logger(__file__)
+
+
 def helper_imshow_output_expected(
         img_list: list[ndarray], titles_list: ListStr, cmap: str = "gist_rainbow", plot_size: int = 5,
         show=False, debug: bool = False, close_after: float = 0.0) -> FigAxes:
@@ -47,10 +50,9 @@ def helper_imshow_output_expected(
     return fig, ax
 
 
-
 def imshow_raster(
         raster, title, cmap: str = "gist_rainbow", interpolation: str = None, alpha=None, transform=None, plot_size=5,
-        show=False, debug: bool = False, close_after: float = 0.0) -> FigAxes:
+        show=False, debug: bool = False, close_after: float = 0.0, backend: MatplotlibBackend = None) -> FigAxes:
     """
     Displays raster images lists/arrays with titles, legend, alpha transparency, figure sizes
     and geographic transformations, if not none (leveraging rasterio.plot)
@@ -66,6 +68,7 @@ def imshow_raster(
         show: fire plt.show() action if needed
         debug: workaround useful in an interactive context, like Pycharm debugger
         close_after: close after give seconds (useful in tests, contrasted to 'debug' option)
+        backend: matplotlib backend string
 
     Returns:
         tuple of matplotlib Figure, Axes
@@ -73,6 +76,11 @@ def imshow_raster(
     """
     from rasterio import plot
 
+    if not backend:
+        backend = plt.get_backend()
+        plt.rcParams["backend"] = backend
+    logger.info(f"use {backend} as matplotlib backend...")
+
     fig, ax = plt.subplots(figsize=(plot_size, plot_size))
     raster_ax = raster[0] if transform is not None else raster
     image_hidden = ax.imshow(raster_ax, cmap=cmap, interpolation=interpolation, alpha=alpha)

{samgis_core-3.0.5 → samgis_core-3.0.8}/samgis_core/utilities/type_hints.py

@@ -67,5 +67,32 @@ class EmbeddingPILImage(TypedDict):
     resized_size: TupleInt2
 
 
+class MatplotlibBackend(StrEnum):
+    gtk3agg = "gtk3agg"
+    gtk3cairo = "gtk3cairo"
+    gtk4agg = "gtk4agg"
+    gtk4cairo = "gtk4cairo"
+    macosx = "macosx"
+    nbagg = "nbagg"
+    notebook = "notebook"
+    qtagg = "qtagg"
+    qtcairo = "qtcairo"
+    qt5agg = "qt5agg"
+    qt5cairo = "qt5cairo"
+    tkagg = "tkagg"
+    tkcairo = "tkcairo"
+    webagg = "webagg"
+    wx = "wx"
+    wxagg = "wxagg"
+    wxcairo = "wxcairo"
+    agg = "agg"
+    cairo = "cairo"
+    pdf = "pdf"
+    pgf = "pgf"
+    ps = "ps"
+    svg = "svg"
+    template = "template"
+
+
 EmbeddingDict = dict[str, EmbeddingImage]
 EmbeddingPILDict = dict[str, EmbeddingPILImage]

{samgis_core-3.0.5 → samgis_core-3.0.8}/samgis_core/utilities/utilities.py

@@ -1,6 +1,7 @@
 """Various utilities (logger, time benchmark, args dump, numerical and stats info)"""
 from copy import deepcopy
 
+import numpy as np
 from numpy import ndarray, float32
 
 from samgis_core import app_logger
@@ -136,3 +137,24 @@ def apply_coords(coords: ndarray, embedding: EmbeddingPILImage):
     coords[..., 1] = coords[..., 1] * (resized_height / orig_height)
 
     return coords.astype(float32)
+
+
+def normalize_array(arr: ndarray, new_h: int | float = 255., type_normalization: str = "int") -> ndarray:
+    """
+    Normalize numpy array between 0 and 'new_h' value. Default dtype of output array is int
+
+
+    Args:
+        arr: input numpy array
+        new_h: max value of output array
+        type_normalization: default dtype of output array
+
+    Returns:
+        numpy array
+    """
+    arr = arr.astype(float)
+    arr_max = np.nanmax(arr)
+    arr_min = np.nanmin(arr)
+    scaled_arr = (arr - arr_min) / (arr_max - arr_min)
+    multiplied_arr = scaled_arr * new_h
+    return multiplied_arr.astype(int) if type_normalization == "int" else multiplied_arr