Spaces:

KennethTM
/

paragraf-3-screener

Sleeping

App Files Files Community

KennethTM commited on Mar 25

Commit

ec92a3d

verified ·

1 Parent(s): 7ebc378

Upload 6 files

Browse files

Files changed (6) hide show

Dockerfile +13 -0
idx_to_target.json +1 -0
index.html +232 -0
main.py +228 -0
model.bin +3 -0
requirements.txt +9 -0

Dockerfile ADDED Viewed

	@@ -0,0 +1,13 @@

+FROM python:3.10
+RUN useradd -m -u 1000 user
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+WORKDIR /app
+COPY --chown=user ./requirements.txt requirements.txt
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+COPY --chown=user . /app
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

idx_to_target.json ADDED Viewed

	@@ -0,0 +1 @@


1	+ {"hovednaturtype": {"0": "Ferskeng", "1": "Hede", "2": "Mose og K\u00e6r", "3": "Overdrev", "4": "Skov", "5": "Strandenge, strandsumpe", "6": "Strandklit", "7": "S\u00f8"}, "arealet_nbl": {"0": "ja", "1": "nej"}, "naturtilstand": {"0": "I", "1": "II", "2": "III", "3": "IV", "4": "V"}}

index.html ADDED Viewed

	@@ -0,0 +1,232 @@

+<!DOCTYPE html>
+<html>
+<head>
+    <title>Paragraf 3 screener</title>
+    <link rel="stylesheet" href="https://unpkg.com/leaflet@1.7.1/dist/leaflet.css" />
+    <script src="https://unpkg.com/leaflet@1.7.1/dist/leaflet.js"></script>
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/leaflet.draw/1.0.4/leaflet.draw.js"></script>
+    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/leaflet.draw/1.0.4/leaflet.draw.css"/>
+    <style>
+        html, body, #map {
+            height: 100%;
+            width: 100%;
+            margin: 0;
+            padding: 0;
+        }
+        #infoBox {
+            position: absolute;
+            top: 10px;
+            right: 10px;
+            background-color: rgba(255, 255, 255, 0.8);
+            padding: 10px;
+            border-radius: 5px;
+            z-index: 1000;
+            box-shadow: 0 0 10px rgba(0, 0, 0, 0.2);
+            font-family: Arial, sans-serif;
+            text-align: center;
+            max-width: 300px;
+        }
+        /* Loading spinner styles */
+        .spinner {
+            position: absolute;
+            width: 40px;
+            height: 40px;
+            margin: 0;
+            background-color: rgba(255, 255, 255, 0.8);
+            border-radius: 50%;
+            border: 3px solid transparent;
+            border-top-color: #3498db;
+            border-bottom-color: #3498db;
+            animation: spin 2s linear infinite;
+            z-index: 1000;
+        }
+        /* Add this if not already present */
+        @keyframes spin {
+            0% { transform: rotate(0deg); }
+            100% { transform: rotate(360deg); }
+        }
+        .spinner-container {
+            background: none !important;
+        }
+        /* Make sure there's no Leaflet default icon background */
+        .leaflet-div-icon {
+            background: transparent;
+            border: none;
+        }
+    </style>
+</head>
+<body>
+    <div id="map"></div>
+    <div id="infoBox">
+        <h3 style="margin: 0 0 5px 0;">Paragraf 3 screener</h3>
+        <p style="margin: 0;">Tegn et område på kortet og bestem <b>hovednaturtype</b>, <b>naturtilstand</b> og <b>om det er omfattet af §3</b></p>
+        <br>
+        <p style="margin: 0;">Udviklet af:<br>Kenneth Thorø Martinsen (kenneth2810@gmail.com)</p>
+    </div>
+    <script>
+        var map = L.map('map').setView([56.2, 11.5], 8);
+        L.tileLayer('https://services.datafordeler.dk/GeoDanmarkOrto/orto_foraar_webm/1.0.0/WMTS/orto_foraar_webm/default/DFD_GoogleMapsCompatible/{z}/{y}/{x}.jpg?username=BJSIGPGRVW&password=Panseryrtat*56klinge', {
+            attribution: 'CC BY 4.0, GeoDanmark, Forårsbilleder Ortofoto, dataforsyningen.dk',
+            maxZoom: 19
+        }).addTo(map);
+        var drawnItems = new L.FeatureGroup();
+        map.addLayer(drawnItems);
+        var drawControl = new L.Control.Draw({
+            draw: {
+                polygon: true,
+                polyline: false,
+                circle: false,
+                rectangle: false,
+                marker: false,
+                circlemarker: false
+            },
+            edit: {
+                featureGroup: drawnItems
+            }
+        });
+        map.addControl(drawControl);
+        map.on('draw:created', function (e) {
+            var layer = e.layer;
+            drawnItems.addLayer(layer);
+            predictAndShow(layer);
+            // Click handler will be set in predictAndShow after the data is loaded
+        });
+        map.on('draw:edited', function(e){
+            var layers = e.layers;
+            layers.eachLayer(function(layer) {
+                predictAndShow(layer);
+            });
+        });
+        function predictAndShow(layer) {
+            var geojson = layer.toGeoJSON();
+            // Get the center of the polygon for placing the spinner
+            var bounds = layer.getBounds();
+            var center = bounds.getCenter();
+            // Create a more visible spinner with custom HTML
+            var spinnerHtml = '<div class="spinner" style="width: 25px; height: 25px; ' +
+                            'border: 5px solid #f3f3f3; border-top: 5px solid #3498db; ' +
+                            'border-radius: 50%; animation: spin 2s linear infinite;"></div>';
+            var spinner = L.divIcon({
+                html: spinnerHtml,
+                className: 'spinner-container',
+                iconSize: [50, 50],
+                iconAnchor: [25, 25]  // Center the spinner on the point
+            });
+            // Add the spinner to the map
+            var loadingMarker = L.marker(center, {
+                icon: spinner,
+                interactive: false,
+                zIndexOffset: 1000  // Ensure spinner appears above other elements
+            }).addTo(map);
+            // Change the polygon style to indicate loading
+            var originalStyle = {
+                color: layer.options.color || '#3388ff',
+                fillOpacity: layer.options.fillOpacity || 0.2
+            };
+            layer.setStyle({
+                fillOpacity: 0.1,
+                color: '#aaa'
+            });
+            fetch('/predict', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify({ geojson: geojson })
+            })
+            .then(response => response.json())
+            .then(data => {
+                // Remove the spinner
+                map.removeLayer(loadingMarker);
+                // Restore original style
+                layer.setStyle(originalStyle);
+                // Create popup content from data
+                var popupContent = "<div><strong>Resultat:</strong><br>";
+                popupContent += data.result;
+                popupContent += "</div>";
+                // Store the result in layer options for future reference
+                layer.options.result = data.result;
+                // Create popup content
+                var popupContent = "<div><strong>Resultat:</strong><br>";
+                popupContent += data.result;
+                popupContent += "</div>";
+                // Create popup configuration
+                var popup = L.popup({
+                    closeButton: true,
+                    autoClose: false,
+                    closeOnEscapeKey: false,
+                    closeOnClick: false
+                });
+                // Remove any existing click handlers
+                layer.off('click');
+                // Unbind any existing popups
+                if (layer.getPopup()) {
+                    layer.unbindPopup();
+                }
+                // Bind the popup with content and open it
+                layer.bindPopup(popup)
+                    .setPopupContent(popupContent)
+                    .openPopup();
+                // Store the result in layer options for future reference
+                layer.options.result = data.result;
+                // Create popup content
+                var popupContent = "<div><strong>Resultat:</strong><br>";
+                popupContent += data.result;
+                popupContent += "</div>";
+                // Create popup configuration
+                var popup = L.popup({
+                    closeButton: true,
+                    autoClose: false,
+                    closeOnEscapeKey: false,
+                    closeOnClick: false
+                }).setContent(popupContent);
+                // Remove any existing click handlers
+                layer.off('click');
+                // Unbind any existing popups
+                if (layer.getPopup()) {
+                    layer.unbindPopup();
+                }
+                // Bind the popup with content and open it
+                layer.bindPopup(popup);
+                layer.openPopup();
+                // Add a click handler to toggle the popup
+                layer.on('click', function(e) {
+                    layer.openPopup(layer.getBounds().getCenter());
+                });
+            });
+        }
+    </script>
+</body>
+</html>

main.py ADDED Viewed

	@@ -0,0 +1,228 @@

+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+from typing import Dict, Any
+import numpy as np
+from PIL import Image, ImageDraw
+import json
+from dotenv import load_dotenv
+import os
+import requests
+from io import BytesIO
+from pyproj import Transformer
+import onnxruntime as ort
+from cryptography.fernet import Fernet
+from fastapi.responses import HTMLResponse
+load_dotenv()
+app = FastAPI()
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # Allows all origins
+    allow_credentials=True,
+    allow_methods=["*"],  # Allows all methods
+    allow_headers=["*"],  # Allows all headers
+)
+# Model load
+key = os.getenv("CLASSIF_MODEL")
+cipher = Fernet(key)
+with open("model.bin", "rb") as f:
+    bin_data = f.read()
+    data = cipher.decrypt(bin_data)
+    model = ort.InferenceSession(data)
+#model = ort.InferenceSession("model.onnx")
+with open("idx_to_target.json", "r") as f:
+    idx_to_target = json.load(f)
+transformer = Transformer.from_crs("EPSG:4326", "EPSG:25832", always_xy=True)
+IMAGE_SIZE = 384
+def normalize_image(image,
+                    mean=(0.485, 0.456, 0.406, 0.5, 0.5),
+                    std=(0.229, 00.224, 0.225, 0.5, 0.5)):
+    image = (image / 255.0).astype("float32")
+    for i in range(image.shape[2]):
+        image[:, :, i] = (image[:, :, i] - mean[i]) / std[i]
+    return image
+def pad_if_needed(image, target_size):
+    height, width, _ = image.shape
+    y0 = abs((height - target_size) // 2)
+    x0 = abs((width - target_size) // 2)
+    background = np.zeros((target_size, target_size, 5), dtype="uint8")
+    background[y0:(y0 + height), x0:(x0 + width), :] = image
+    return background
+def softmax(x):
+    return np.exp(x) / np.sum(np.exp(x), axis=1)
+def get_image(coords, max_dim: int) -> Image:
+    coords_utm = [transformer.transform(lon, lat) for lon, lat in coords]
+    xs, ys = zip(*coords_utm)
+    xmin, ymin, xmax, ymax = min(xs), min(ys), max(xs), max(ys)
+    roi_width = xmax - xmin
+    roi_height = ymax - ymin
+    aspect_ratio = roi_width / roi_height
+    if aspect_ratio > 1:
+        width = max_dim
+        height = int(max_dim / aspect_ratio)
+    else:
+        width = int(max_dim * aspect_ratio)
+        height = max_dim
+    # Construct WMS parameters
+    wms_params = {
+        'username': os.getenv('WMSUSER'),
+        'password': os.getenv('WMSPW'),
+        'SERVICE': 'WMS',
+        'VERSION': '1.3.0',
+        'REQUEST': 'GetMap',
+        'BBOX': f"{xmin},{ymin},{xmax},{ymax}",
+        'CRS': 'EPSG:25832',
+        'WIDTH': width,
+        'HEIGHT': height,
+        'LAYERS': "geodanmark_2023_12_5cm",
+        'FORMAT': 'image/png',
+        'STYLES': '',
+        'DPI': 96,
+        'MAP_RESOLUTION': 96,
+        'FORMAT_OPTIONS': 'dpi:96'
+    }
+    # Down rgb image
+    base_url = "https://services.datafordeler.dk/GeoDanmarkOrto/orto_foraar/1.0.0/WMS"
+    try:
+        response = requests.get(base_url, params=wms_params)
+        response.raise_for_status()
+    except requests.exceptions.HTTPError as err:
+        print(err)
+        return None
+    img = Image.open(BytesIO(response.content)).convert("RGB")
+    # Download terrain
+    skygge_url = "https://services.datafordeler.dk/DHMNedboer/dhm/1.0.0/WMS"
+    wms_params["LAYERS"] = "dhm_terraen_skyggekort"
+    try:
+        response = requests.get(skygge_url, params=wms_params)
+        response.raise_for_status()
+    except requests.exceptions.HTTPError as err:
+        print(err)
+        return None
+    skygge_img = Image.open(BytesIO(response.content)).convert("L")
+    # Create mask
+    mask = Image.new('L', (width, height), 0)
+    # Convert coordinates to image space
+    x_norm = [(x - xmin) / roi_width for x in xs]
+    y_norm = [(y - ymin) / roi_height for y in ys]
+    x_img = [int(x * width) for x in x_norm]
+    y_img = [int((1 - y) * height) for y in y_norm]
+    # Draw polygon on mask
+    ImageDraw.Draw(mask).polygon(list(zip(x_img, y_img)), outline=255, fill=255)
+    array = np.concatenate([np.array(img),
+                            np.array(skygge_img)[:, :, np.newaxis],
+                            np.array(mask)[:, :, np.newaxis]],
+                           axis=2)
+    return array
+def predict(image, image_size):
+    image = pad_if_needed(image, image_size)
+    image = normalize_image(image)
+    image = np.transpose(image, (2, 0, 1))
+    image = image[np.newaxis]
+    input_names = model.get_inputs()[0].name
+    output_names = [output.name for output in model.get_outputs()]
+    ort_inputs = {input_names: image}
+    ort_outputs = model.run(None, ort_inputs)
+    predictions = {name: softmax(output) for name, output in zip(output_names, ort_outputs)}
+    return predictions
+pretty_target_name = {
+    "hovednaturtype": "Hovednaturtype",
+    "arealet_nbl": "Paragraf 3",
+    "naturtilstand": "Naturtilstand",
+}
+def format_predictions(predictions):
+    result_list = []
+    for target, logits in predictions.items():
+        # Get the index of the highest probability
+        top_idx = np.argmax(logits[0])
+        # Get the probability value
+        confidence = float(logits[0][top_idx])
+        # Get the class name from idx_to_target mapping
+        class_name = idx_to_target[target][str(top_idx)]
+        if target != "naturtilstand":
+            class_name = class_name.capitalize()
+        else:
+            class_name = class_name.upper()
+        target_name = pretty_target_name[target]
+        # Format as concise HTML with class name and confidence percentage
+        html_result = f"<div>{target_name}: <i>{class_name}</i> ({confidence:.1%})</div>"
+        result_list.append(html_result)
+    return "".join(result_list)
+class GeoJSONInput(BaseModel):
+    geojson: Dict[str, Any]
+class ResultOutput(BaseModel):
+    result: str
+@app.get("/", response_class=HTMLResponse)
+async def get_html():
+    html_file = "index.html"
+    with open(html_file, "r") as f:
+        content = f.read()
+    return HTMLResponse(content=content)
+@app.post("/predict")
+async def predict_endpoint(geojson_input: GeoJSONInput) -> ResultOutput:
+    try:
+        coords = geojson_input.geojson['geometry']['coordinates'][0]
+        image = get_image(coords, IMAGE_SIZE)
+        predictions = predict(image, IMAGE_SIZE)
+        result = format_predictions(predictions)
+        return ResultOutput(result = result)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

model.bin ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:96b1c612a6425460917fc754d93e76d2601523b6f7218e6c12d12fd19737a13e
+size 513406756

requirements.txt ADDED Viewed

	@@ -0,0 +1,9 @@

+fastapi
+uvicorn
+numpy
+onnxruntime
+pydantic
+cryptography
+requests
+pyproj
+pillow