[fix] reformat code, use input from request

.dockerignore

@@ -0,0 +1,6 @@
+venv/
+*.pyc
+__cache__
+.idea
+tmp/
+.env*

dockerfiles/dockerfile-base-webserver

@@ -0,0 +1,22 @@
+FROM python:3.11
+
+WORKDIR /code
+
+RUN which python
+RUN python --version
+RUN python -m pip install --no-cache-dir fastapi uvicorn
+
+RUN useradd -m -u 1000 user
+
+USER user
+
+ENV HOME=/home/user \
+	PATH=/home/user/.local/bin:$PATH
+
+WORKDIR $HOME/app
+
+RUN ls -l ${HOME}/
+COPY --chown=user src $HOME/app/src
+COPY --chown=user static $HOME/app/static
+
+CMD ["uvicorn", "src.main:app", "--host", "0.0.0.0", "--port", "7860"]

src/main.py

@@ -6,29 +6,42 @@ from fastapi.responses import FileResponse, JSONResponse
 from fastapi.staticfiles import StaticFiles
 from pydantic import BaseModel
 
+from src.utilities.type_hints import input_floatlist, input_floatlist2
 from src.utilities.utilities import setup_logging
 
 
 app = FastAPI()
-local_logger = setup_logging()
 
 
 class Input(BaseModel):
-    name: str
-    bbox: List[float]
-    points_coords: List[List[float]]
+    x1: float
+    y1: float
+    x2: float
+    y2: float
+    x: float
+    y: float
+
+
+class BBoxWithPoint(BaseModel):
+    bbox: input_floatlist
+    point: input_floatlist2
+
+
+def get_parsed_bbox_points(request_input: Input) -> BBoxWithPoint:
+    return {
+        "bbox": [
+            request_input.x1, request_input.x2,
+            request_input.y1, request_input.y2
+        ],
+        "point": [[request_input.x, request_input.y]]
+    }
 
 
 @app.post("/post_test")
-async def post_test(input: Input) -> JSONResponse:
-    bbox = input.bbox
-    name = input.name
-    points_coords = input.points_coords
+async def post_test(request_input: Input) -> JSONResponse:
     return JSONResponse(
         status_code=200,
-        content={
-            "msg": name, "bbox": bbox, "points_coords": points_coords
-        }
+        content=get_parsed_bbox_points(request_input)
     )
 
 
@@ -38,7 +51,7 @@ async def hello() -> JSONResponse:
 
 
 @app.post("/infer_samgeo")
-def samgeo():
+def samgeo(request_input: Input):
     import subprocess
 
     from src.prediction_api.predictor import base_predict
@@ -52,15 +65,16 @@ def samgeo():
         time_start_run = time.time()
         # debug = True
         # local_logger = setup_logging(debug)
-        message = "point_coords_segmentation"
-        bbox = [-122.1497, 37.6311, -122.1203, 37.6458]
-        point_coords = [[-122.1419, 37.6383]]
+        request_body = get_parsed_bbox_points(request_input)
+        local_logger.info(f"request_body:{request_body}.")
         try:
-            output = base_predict(bbox=bbox, point_coords=point_coords)
+            output = base_predict(
+                bbox=request_body["bbox"],
+                point_coords=request_body["point"]
+            )
 
             duration_run = time.time() - time_start_run
             body = {
-                "message": message,
                 "duration_run": duration_run,
                 # "request_id": request_id
             }
@@ -80,6 +94,7 @@ def samgeo():
 
 @app.exception_handler(RequestValidationError)
 async def request_validation_exception_handler(request: Request, exc: RequestValidationError) -> JSONResponse:
+    local_logger = setup_logging()
     local_logger.error(f"exception errors: {exc.errors()}.")
     local_logger.error(f"exception body: {exc.body}.")
     headers = request.headers.items()
@@ -94,6 +109,7 @@ async def request_validation_exception_handler(request: Request, exc: RequestVal
 
 @app.exception_handler(HTTPException)
 async def http_exception_handler(request: Request, exc: HTTPException) -> JSONResponse:
+    local_logger = setup_logging()
     local_logger.error(f"exception: {str(exc)}.")
     headers = request.headers.items()
     local_logger.error(f'request header: {dict(headers)}.' )

src/prediction_api/predictor.py

@@ -2,21 +2,26 @@
 import json
 
 from src.utilities.constants import ROOT
+from src.utilities.type_hints import input_floatlist, input_floatlist2
 from src.utilities.utilities import setup_logging
 
-
 local_logger = setup_logging()
 
 
-def base_predict(bbox, point_coords, point_crs="EPSG:4326", zoom=16, model_name:str="vit_h", root_folder:str=ROOT) -> str:
+def base_predict(
+        bbox: input_floatlist, point_coords: input_floatlist2, point_crs: str = "EPSG:4326", zoom: float = 16, model_name: str = "vit_h", root_folder: str = ROOT
+) -> str:
     from samgeo import SamGeo, tms_to_geotiff
 
     image = f"{root_folder}/satellite.tif"
-    local_logger.info("start tms_to_geotiff")
+    local_logger.info(f"start tms_to_geotiff using bbox:{bbox}, type:{type(bbox)}.")
+    for coord in bbox:
+        local_logger.info(f"coord:{coord}, type:{type(coord)}.")
     # bbox: image input coordinate
     tms_to_geotiff(output=image, bbox=bbox, zoom=zoom, source="Satellite", overwrite=True)
 
     local_logger.info(f"geotiff created, start to initialize samgeo instance (read model {model_name} from {root_folder})...")
+
     predictor = SamGeo(
         model_type=model_name,
         checkpoint_dir=root_folder,
@@ -26,10 +31,10 @@ def base_predict(bbox, point_coords, point_crs="EPSG:4326", zoom=16, model_name:
     local_logger.info(f"initialized samgeo instance, start to set_image {image}...")
     predictor.set_image(image)
     output_name = f"{root_folder}/output.tif"
-    
+
     local_logger.info(f"done set_image, start prediction...")
     predictor.predict(point_coords, point_labels=len(point_coords), point_crs=point_crs, output=output_name)
-    
+
     local_logger.info(f"done prediction, start tiff to geojson conversion...")
 
     # geotiff to geojson

src/utilities/type_hints.py

@@ -11,20 +11,3 @@ ts_dict_str2 = Dict[str, str]
 ts_dict_str3 = Dict[str, str, any]
 ts_float64_1 = Tuple[np.float64, np.float64, np.float64, np.float64, np.float64, np.float64]
 ts_float64_2 = Tuple[np.float64, np.float64, np.float64, np.float64, np.float64, np.float64, np.float64]
-
-"""
-ts_list_str1 = List[str]
-ts_http2 = Tuple[ts_list_str1, ts_list_str1]
-ts_list_float2 = List[float, float]
-ts_llist_float2 = List[ts_list_float2, ts_list_float2]
-ts_geojson = Dict[str, str, Dict[str, Dict[str]], List[str, Dict[int], Dict[str, List]]]
-ts_dict_str2b = Dict[str, any]
-ts_ddict2 = Dict[str, Dict, Dict[str, List]]
-ts_tuple_str2 = Tuple[str, str]
-ts_tuple_arr2 = Tuple[np.ndarray, np.ndarray]
-ts_tuple_flat2 = Tuple[float, float]
-ts_tuple_flat4 = Tuple[float, float, float, float]
-ts_list_float4 = List[float, float, float, float]
-ts_tuple_int4 = Tuple[int, int, int, int]
-ts_ddict3 = Dict[List[Dict[float | int | str]], Dict[float | int]]
-"""

static/app.js

@@ -0,0 +1,33 @@
+const jsonBtn = document.getElementById("getJson");
+const apiBtn = document.getElementById("getApi");
+const output = document.getElementById("output");
+const coordsForm = document.getElementById("coords-form");
+
+function formData2json(dataId, newObj={}) {
+    const formData = new FormData(dataId);
+    formData.forEach(function(value, key){
+        newObj[key] = value;
+    });
+    return JSON.stringify(newObj);
+}
+
+coordsForm.addEventListener('submit', event => {
+    event.preventDefault();
+    const inputJson = formData2json(coordsForm)
+    console.log("inputJson", inputJson, "#");
+
+    fetch('/infer_samgeo', {
+        method: 'POST', // or 'PUT'
+        body: inputJson,  // a FormData will automatically set the 'Content-Type',
+        headers: {"Content-Type": "application/json"},
+    }).then(function (response) {
+        return response.json();
+    }).then(function (data) {
+        console.log("data:", data, "#")
+        output.innerHTML = JSON.stringify(data)
+    }).catch(function (err) {
+        console.log("err:", err, "#")
+        output.innerHTML = `err:${JSON.stringify(err)}.`;
+    });
+    event.preventDefault();
+});

static/index.html

@@ -1,24 +1,41 @@
-<main>
-    <section id="coords-gen">
-      <h2>Segment Geospatial: Instance segmentation within images based on Segment Anything</h2>
-      <p>
-        Model:
-        <a
-          href="https://github.com/opengeos/segment-geospatial/"
-          rel="noreferrer"
-          target="_blank"
-          >opengeos/segment-geospatial
-        </a>
-      </p>
-      <form class="coords-gen-form">
-        <label for="coords-gen-input">Text prompt</label>
-        <input
-          id="coords-gen-input"
-          type="coords"
-          value=""
-        />
-        <button id="coords-gen-submit">Submit</button>
-        <p class="coords-gen-output"></p>
-      </form>
-    </section>
-  </main>
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <meta http-equiv="X-UA-Compatible" content="ie=edge">
+    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/skeleton/2.0.4/skeleton.min.css" />
+    <title>Fetch API</title>
+</head>
+<body>
+    <div class="container">
+        <h1>Fetch API</h1>
+        <form id="coords-form">
+            <label>
+                bbox: x1 <input type="number" id="x-center-form" name="x1" value="-122.1497"/>
+            </label>
+            <label>
+                bbox: x2 <input type="number" id="y-center-form" name="x2" value="37.6311"/>
+            </label>
+            <label>
+                bbox: y1 <input type="number" id="y-center-form" name="y1" value="-122.1203"/>
+            </label>
+            <label>
+                bbox: y2 <input type="number" id="y-center-form" name="y2" value="37.6458"/>
+            </label>
+            <br/><br/>
+            <label>
+                x point: <input type="number" id="x-form" name="x" value="-122.1419"/>
+            </label>
+            <label>
+                y point: <input type="number" id="y-form" name="y" value="37.6383"/>
+            </label>
+            <br/><br/>
+            <button type="submit" id="submit-btn">submit form</button>
+          </form>
+        <br><br>
+        <div id="output"></div>     
+    </div>
+    <script src="app.js"></script>
+</body>
+</html>

static/script.js

@@ -1,17 +0,0 @@
-const coordsGenForm = document.querySelector(".coords-gen-form");
-
-const segmentCoords = async (coords) => {
-  const inferResponse = await fetch(`infer_samgeo?input=${coords}`);
-  const inferJson = await inferResponse.json();
-
-  return inferJson.output;
-};
-
-coordsGenForm.addEventListener("submit", async (event) => {
-  event.preventDefault();
-
-  const coordsGenInput = document.getElementById("coords-gen-input");
-  const coordsGenParagraph = document.querySelector(".coords-gen-output");
-
-  coordsGenParagraph.coordsContent = await segmentCoords(coordsGenInput.value);
-});