Spaces:

KennethTM
/

ortofoto-arter

Sleeping

App Files Files Community

KennethTM commited on Feb 28

Commit

d081540

verified ·

1 Parent(s): 45c924a

Upload 7 files

Browse files

Files changed (7) hide show

Dockerfile +13 -0
id2spec.bin +3 -0
image_encoder.bin +3 -0
index.html +281 -0
main.py +168 -0
requirements.txt +9 -0
species_features.bin +3 -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"]

id2spec.bin ADDED Viewed

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

+version https://git-lfs.github.com/spec/v1
+oid sha256:396276ababa85a106aa27022c4d311e54722bd8b0af10a9189365ee940547a74
+size 98956

image_encoder.bin ADDED Viewed

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

+version https://git-lfs.github.com/spec/v1
+oid sha256:2c4888f31c1e368352cb327442975096865a2e627f2e76393d2e386f1c850599
+size 498149900

index.html ADDED Viewed

	@@ -0,0 +1,281 @@

+<!DOCTYPE html>
+<html>
+<head>
+    <title>Matchmaking for habitater og arter</title>
+    <link rel="stylesheet" href="https://unpkg.com/[email protected]/dist/leaflet.css" />
+    <script src="https://unpkg.com/[email protected]/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;
+        }
+        #downloadButton {
+            position: absolute;
+            top: 10px;
+            right: 10px;
+            z-index: 401;
+            padding: 10px;
+            background-color: white;
+            border: 1px solid black;
+            cursor: pointer;
+            display: none;
+        }
+        /* 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>
+    <button id="downloadButton">Download GeoJSON</button>
+    <script>
+        var map = L.map('map').setView([56.2, 10.3], 7);
+        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);
+        });
+        map.on('draw:edited', function(e){
+            var layers = e.layers;
+            layers.eachLayer(function(layer) {
+                predictAndShow(layer);
+            });
+        });
+        map.on('draw:deleted', function(e){
+            updateDownloadButton();
+        });
+        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 and restore original style
+                map.removeLayer(loadingMarker);
+                layer.setStyle(originalStyle);
+                var predictions = data.predictions;
+                var popupContent = "<b>Arter:</b><br>";
+                // Display all predictions
+                Object.entries(predictions).forEach(([species, score]) => {
+                    popupContent += species + ": " + score.toFixed(2) + "<br>";
+                });
+                // Store the popup content in the layer for later use
+                layer.popupContent = popupContent;
+                // Only add click handler, no mouseover/hover effects
+                layer.on('click', function(e) {
+                    if (!layer._popup || !map.hasLayer(layer._popup)) {
+                        var popup = L.popup({
+                            closeButton: true,
+                            autoClose: false,
+                            closeOnEscapeKey: false,
+                            closeOnClick: false
+                        })
+                        .setLatLng(e.latlng)
+                        .setContent(layer.popupContent);
+                        layer.bindPopup(popup).openPopup();
+                    } else {
+                        layer.closePopup();
+                    }
+                });
+                // Ensure the feature object exists before assigning to it
+                if (!layer.feature) {
+                    layer.feature = {};
+                }
+                if (!layer.feature.properties) {
+                    layer.feature.properties = {};
+                }
+                // Store both the raw predictions and formatted text
+                layer.feature.properties.arter = predictions;
+                updateDownloadButton();
+            })
+            .catch(error => {
+                // Remove the spinner and restore original style on error
+                map.removeLayer(loadingMarker);
+                layer.setStyle(originalStyle);
+                console.error('Error:', error);
+                alert('Prediction failed.');
+            });
+        }
+        document.getElementById('downloadButton').addEventListener('click', function() {
+            var features = [];
+            // Collect all drawn layers with their prediction data
+            drawnItems.eachLayer(function(layer){
+                // Get the GeoJSON representation of the layer
+                var featureGeoJSON = layer.toGeoJSON();
+                // Ensure type is explicitly set to "Feature"
+                featureGeoJSON.type = "Feature";
+                // Make sure we have properties object
+                if (!featureGeoJSON.properties) {
+                    featureGeoJSON.properties = {};
+                }
+                // Ensure prediction data is included in properties
+                if (layer.feature && layer.feature.properties && layer.feature.properties.arter) {
+                    featureGeoJSON.properties.arter = layer.feature.properties.arter;
+                }
+                features.push(featureGeoJSON);
+            });
+            // Create a proper GeoJSON FeatureCollection
+            var featureCollection = {
+                "type": "FeatureCollection",
+                "features": features
+            };
+            // Convert to a JSON string with pretty formatting
+            var geojsonString = JSON.stringify(featureCollection, null, 2);
+            // Create a Blob from the GeoJSON
+            var blob = new Blob([geojsonString], {type: 'application/geo+json'});
+            // Create download link
+            var url = window.URL.createObjectURL(blob);
+            var a = document.createElement('a');
+            a.style.display = 'none';
+            a.href = url;
+            a.download = 'polygoner.geojson';
+            document.body.appendChild(a);
+            a.click();
+            // Clean up
+            setTimeout(function() {
+                document.body.removeChild(a);
+                window.URL.revokeObjectURL(url);
+            }, 100);
+        });
+        function updateDownloadButton(){
+            var geojsonData = [];
+            drawnItems.eachLayer(function(layer){
+                geojsonData.push(layer.toGeoJSON());
+            });
+            if(geojsonData.length > 0){
+                document.getElementById('downloadButton').style.display = "block";
+            } else {
+                document.getElementById('downloadButton').style.display = "none";
+            }
+        }
+        updateDownloadButton();
+    </script>
+</body>
+</html>

main.py ADDED Viewed

	@@ -0,0 +1,168 @@

+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("MODEL_KEY")
+cipher = Fernet(key)
+with open("species_features.bin", "rb") as f:
+    bin_data = f.read()
+data = cipher.decrypt(bin_data)
+species_features = np.load(BytesIO(data))
+with open("id2spec.bin", "rb") as f:
+    bin_data = f.read()
+data = cipher.decrypt(bin_data)
+id2spec = json.loads(data)
+with open("image_encoder.bin", "rb") as f:
+    bin_data = f.read()
+data = cipher.decrypt(bin_data)
+image_encoder = ort.InferenceSession(data)
+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), std=(0.229, 00.224, 0.225)):
+    image = (image / 255.0).astype("float32")
+    image[:, :, 0] = (image[:, :, 0] - mean[0]) / std[0]
+    image[:, :, 1] = (image[:, :, 1] - mean[1]) / std[1]
+    image[:, :, 2] = (image[:, :, 2] - mean[2]) / std[2]
+    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, 3), dtype="uint8")
+    background[y0:(y0 + height), x0:(x0 + width), :] = image
+    return background
+def predict(image, image_size, top_k = 20):
+    image = image.convert("RGB")
+    image = np.array(image)
+    image = pad_if_needed(image, image_size)
+    image = normalize_image(image)
+    image = np.transpose(image, (2, 0, 1))
+    image = image[np.newaxis]
+    image_features = image_encoder.run(None, {"input.1": image})[0]
+    similarity = np.dot(image_features, species_features.T)
+    sorted_similarity = np.argsort(similarity[0])[::-1][:top_k]
+    species_scores = {id2spec[str(idx)]: similarity[0, idx] for idx in sorted_similarity}
+    return species_scores
+def get_image(coords, max_dim):
+    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
+    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': 'orto_foraar',
+        'STYLES': '',
+        'FORMAT': 'image/png',
+        'DPI': 96,
+        'MAP_RESOLUTION': 96,
+        'FORMAT_OPTIONS': 'dpi:96'
+    }
+    base_url = "https://services.datafordeler.dk/GeoDanmarkOrto/orto_foraar/1.0.0/WMS"
+    response = requests.get(base_url, params=wms_params)
+    if response.status_code != 200:
+        raise HTTPException(status_code=500, detail=f"Error fetching image: {response.status_code}")
+    img = Image.open(BytesIO(response.content))
+    mask = Image.new('L', (width, height), 0)
+    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]
+    ImageDraw.Draw(mask).polygon(list(zip(x_img, y_img)), outline=255, fill=255)
+    masked_img = Image.new('RGB', img.size)
+    masked_img.paste(img, mask=mask)
+    return masked_img
+class GeoJSONInput(BaseModel):
+    geojson: Dict[str, Any]
+@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):
+    try:
+        coords = geojson_input.geojson['geometry']['coordinates'][0]
+        image = get_image(coords, IMAGE_SIZE)
+        predictions_raw = predict(image, IMAGE_SIZE)
+        # Convert numpy.float32 values to native Python floats
+        predictions = {species: float(score) for species, score in predictions_raw.items()}
+        return {"predictions": predictions}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

requirements.txt ADDED Viewed

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

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

species_features.bin ADDED Viewed

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

+version https://git-lfs.github.com/spec/v1
+oid sha256:8591833f20df53e9c0e294eda39e312ef3f7943ac3cbd0273ad5863b96843022
+size 3391756