add building detection demo

package.json

@@ -7,6 +7,9 @@
     "@testing-library/jest-dom": "^6.6.3",
     "@testing-library/react": "^16.3.0",
     "@testing-library/user-event": "^13.5.0",
+    "geoai": "^1.0.0-rc.1",
+    "maplibre-gl": "^5.6.2",
+    "maplibre-gl-draw": "^1.6.9",
     "react": "^19.1.0",
     "react-dom": "^19.1.0",
     "react-scripts": "5.0.1",

src/App.css

@@ -1,38 +1,103 @@
-.App {
-  text-align: center;
+:root{
+  --bg: #ffffff;
+  --surface: #ffffff;
+  --card: #f6f8f7;
+  --accent: #247c53; /* main green */
+  --accent-2: #2fb36a; /* lighter green */
+  --text: #072021; /* dark text on white */
+  --muted: #5f6b67;
+  --danger: #ff4d4f;
 }
 
-.App-logo {
-  height: 40vmin;
-  pointer-events: none;
-}
+*{box-sizing:border-box}
+html,body,#root{height:100%;margin:0;background:var(--bg);color:var(--text);font-family:Inter, system-ui, -apple-system, 'Segoe UI', Roboto, 'Helvetica Neue', Arial}
+
+.app-root{display:flex;flex-direction:column;min-height:100vh;background:linear-gradient(180deg, var(--bg) 0%, #fbfdfb 100%);}
+
+.app-header{display:flex;align-items:center;justify-content:space-between;padding:18px 28px;background:var(--surface);border-bottom:1px solid rgba(6,21,13,0.06)}
+.brand{display:flex;align-items:center;gap:14px}
+.brand-logo{width:150px;}
+.brand-title{display:inline-flex;align-items:center;gap:8px;font-size:36px;margin:0}
+.theme-dark .brand-title{color:#ffffff}
+.theme-light .brand-title{color:#072021}
+.brand-title img{filter:grayscale(0);}
+.brand-text{display:flex;flex-direction:column;margin-left:100;}
+.demo-title{margin:0;font-size:20px;font-weight:700;color:var(--text)}
+.theme-dark .demo-title{color:#ffffff}
+.theme-light .demo-title{color:var(--text)}
+.tagline{margin:6px 0 0;color:var(--muted);font-size:13px}
+
+.status{display:flex;align-items:center;gap:8px;color:var(--muted);font-size:13px}
+.ready-dot{width:10px;height:10px;border-radius:50%;background:#e6f3ed}
+.ready-dot.on{background:var(--accent)}
+
+.app-main{display:flex;flex:1;gap:20px;padding:20px}
+.map-area{flex:1;border-radius:12px;overflow:hidden;box-shadow:0 6px 24px rgba(10,20,18,0.06);background:#f8fbfa;border:1px solid rgba(6,21,13,0.04)}
+.map-container{width:100%;height:100%;min-height:420px}
+
+.control-panel{width:360px;background:var(--card);border-radius:12px;padding:18px;border:1px solid rgba(6,21,13,0.04);display:flex;flex-direction:column;gap:12px;max-height:calc(100vh - 120px);overflow:hidden}
 
-@media (prefers-reduced-motion: no-preference) {
-  .App-logo {
-    animation: App-logo-spin infinite 20s linear;
-  }
+/* Ensure the geojson section takes remaining vertical space */
+.geojson-section{margin-top:14px;display:flex;flex-direction:column;flex:1;min-height:0}
+.geojson-header{display:flex;align-items:center;justify-content:space-between;gap:8px}
+.geojson-actions{display:flex;gap:8px}
+.geojson-box{
+  /* allow box to expand to fill remaining space */
+  flex:1;min-height:0;overflow:auto;background:#ffffff;padding:12px;border-radius:8px;border:1px solid rgba(6,21,13,0.04);font-size:12px;color:var(--text);white-space:pre-wrap;word-break:break-word;margin-top:8px
 }
 
-.App-header {
-  background-color: #282c34;
-  min-height: 100vh;
-  display: flex;
-  flex-direction: column;
-  align-items: center;
-  justify-content: center;
-  font-size: calc(10px + 2vmin);
-  color: white;
+.controls-row{display:flex;gap:12px;margin-top:12px}
+.btn{
+  background:linear-gradient(90deg,var(--accent) 0%, var(--accent-2) 100%);
+  color:#ffffff;
+  border:0;
+  padding:8px 14px;
+  border-radius:10px;
+  font-weight:600;
+  cursor:pointer;
+  box-shadow:0 8px 20px rgba(36,124,83,0.12);
+  transition:transform .12s ease,box-shadow .12s ease,opacity .12s ease;
+  display:inline-flex;align-items:center;gap:8px;
 }
+.btn:hover{transform:translateY(-2px)}
+.btn:disabled{opacity:.6;cursor:not-allowed;transform:none}
+.btn.secondary{
+  background:transparent;
+  color:var(--accent);
+  border:1px solid rgba(36,124,83,0.12);
+  box-shadow:none;
+}
+.btn.small{padding:6px 10px;font-size:13px;border-radius:8px;background:transparent;color:var(--muted);border:1px solid rgba(6,21,13,0.04)}
+
+.stats{display:flex;align-items:center;gap:12px;margin-top:12px}
+.stats strong{font-size:32px;color:var(--accent-2)}
+.stats span{color:var(--muted);font-size:13px}
 
-.App-link {
-  color: #61dafb;
+.geojson-section{margin-top:14px;display:flex;flex-direction:column;flex:1;min-height:0}
+.geojson-header{display:flex;align-items:center;justify-content:space-between;gap:8px}
+.geojson-actions{display:flex;gap:8px}
+.geojson-box{
+  flex:1;min-height:0;overflow:auto;background:#ffffff;padding:12px;border-radius:8px;border:1px solid rgba(6,21,13,0.04);font-size:12px;color:var(--text);white-space:pre-wrap;word-break:break-word;margin-top:8px
 }
 
-@keyframes App-logo-spin {
-  from {
-    transform: rotate(0deg);
-  }
-  to {
-    transform: rotate(360deg);
-  }
+.footer-note{margin-top:auto;color:var(--muted);font-size:13px;text-align:center}
+
+/* responsive */
+@media (max-width: 900px){
+  .app-main{flex-direction:column}
+  .control-panel{width:100%;max-height:none}
+  .map-container{min-height:320px}
 }
+
+/* Theme dark overrides */
+.theme-dark{background:linear-gradient(180deg,#071022 0%, #0f1724 100%);color:#e6eef3}
+.theme-dark .app-header{background:linear-gradient(90deg, rgba(255,255,255,0.01), rgba(255,255,255,0.005));border-bottom:1px solid rgba(255,255,255,0.03)}
+.theme-dark .brand-logo{box-shadow:0 6px 18px rgba(0,0,0,0.6)}
+.theme-dark .app-main{gap:20px;padding:20px}
+.theme-dark .map-area{background:#071022;border:1px solid rgba(255,255,255,0.03);box-shadow:0 6px 30px rgba(2,6,23,0.6)}
+.theme-dark .control-panel{background:rgba(3,6,12,0.45);border:1px solid rgba(255,255,255,0.03);color:#e6eef3}
+.theme-dark .geojson-box{background:#021017;color:#cfeff6;border:1px solid rgba(255,255,255,0.03)}
+.theme-dark .btn.small{background:transparent;color:#cfeff6;border:1px solid rgba(255,255,255,0.04)}
+
+/* keep buttons accessible in dark */
+.theme-dark .btn{box-shadow:0 8px 20px rgba(0,0,0,0.6)}

src/App.js

@@ -1,25 +1,272 @@
-import logo from './logo.svg';
+import { useEffect, useRef, useState } from 'react';
+import maplibregl from 'maplibre-gl';
+import 'maplibre-gl/dist/maplibre-gl.css';
+import MaplibreDraw from 'maplibre-gl-draw';
+import 'maplibre-gl-draw/dist/mapbox-gl-draw.css';
+import { useGeoAIWorker } from './hooks/useGeoAIWorker';
 import './App.css';
-
+ 
+const config = {
+  provider: "esri",
+  serviceUrl: "https://server.arcgisonline.com/ArcGIS/rest/services",
+  serviceName: "World_Imagery",
+  tileSize: 256,
+  attribution: "ESRI World Imagery",
+};
+ 
 function App() {
+  const mapContainer = useRef(null);
+  const map = useRef(null);
+  const drawRef = useRef(null);
+  const [detections, setDetections] = useState([]);
+  const [currentPolygon, setCurrentPolygon] = useState(null);
+  const [isDrawing, setIsDrawing] = useState(false);
+  const [zoom, setZoom] = useState(null);
+  const [theme, setTheme] = useState(() => localStorage.getItem('theme') || 'light');
+  const { isReady, isProcessing, result, initialize, runInference } = useGeoAIWorker();
+
+  useEffect(() => {
+    localStorage.setItem('theme', theme);
+  }, [theme]);
+
+  const toggleTheme = () => setTheme(t => (t === 'light' ? 'dark' : 'light'));
+
+  useEffect(() => {
+    initialize([{ task: "building-detection" }], config);
+  }, []);
+ 
+  useEffect(() => {
+    if (!mapContainer.current) return;
+
+    map.current = new maplibregl.Map({
+      container: mapContainer.current,
+      style: {
+        version: 8,
+        sources: {
+          satellite: {
+            type: 'raster',
+            tiles: [
+              `https://server.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/tile/{z}/{y}/{x}`,
+            ],
+            tileSize: 256,
+          },
+        },
+        layers: [{ id: 'satellite', type: 'raster', source: 'satellite' }],
+      },
+      center: [-117.59, 47.653],
+      zoom: 18,
+    });
+
+    // set initial zoom state
+    setZoom(map.current.getZoom());
+
+    // update zoom on changes
+    const onZoom = () => setZoom(Number(map.current.getZoom().toFixed(2)));
+    map.current.on('zoom', onZoom);
+
+    const draw = new MaplibreDraw({
+      displayControlsDefault: false,
+      controls: { polygon: true, trash: true },
+    });
+    drawRef.current = draw;
+
+    // @ts-ignore
+    map.current.addControl(draw);
+
+    // cleanup map listeners on unmount
+    const cleanupMap = () => {
+      try {
+        map.current?.off('zoom', onZoom);
+      } catch (e) {}
+    };
+
+    map.current.on('draw.create', (e) => {
+      const polygon = e.features[0];
+      setCurrentPolygon(polygon);
+      // exit draw mode when a polygon is created
+      try { drawRef.current.changeMode('simple_select'); } catch (err) {}
+      setIsDrawing(false);
+      // DO NOT run inference automatically here. User must click Analyze.
+    });
+
+    map.current.on('draw.update', (e) => {
+      const polygon = e.features[0];
+      setCurrentPolygon(polygon);
+    });
+
+    map.current.on('draw.delete', (e) => {
+      setCurrentPolygon(null);
+      setDetections([]);
+      setIsDrawing(false);
+      // remove detections layer/source if present
+      if (map.current?.getSource('detections')) {
+        try {
+          map.current.removeLayer('detections');
+          map.current.removeSource('detections');
+        } catch (err) {}
+      }
+    });
+
+    return () => {
+      cleanupMap();
+      try { map.current?.remove(); } catch (e) {}
+    };
+  }, [isReady]);
+ 
+  useEffect(() => {
+    if (!result) return;
+
+    const features = result.detections?.features || [];
+    setDetections(features);
+
+    if (map.current?.getSource('detections')) {
+      map.current.removeLayer('detections');
+      map.current.removeSource('detections');
+    }
+
+    // set detection fill color to yellow
+    const fillColor = '#fdb306ff';
+
+    map.current?.addSource('detections', { type: 'geojson', data: result.detections });
+    map.current?.addLayer({
+      id: 'detections',
+      type: 'fill',
+      source: 'detections',
+      paint: { 'fill-color': fillColor, 'fill-opacity': 0.7 },
+    });
+  }, [result, theme]);
+ 
+  // manual analyze handler
+  const handleAnalyze = () => {
+    if (!isReady || !currentPolygon) return;
+    runInference({
+      inputs: { polygon: currentPolygon },
+      mapSourceParams: { zoomLevel: map.current?.getZoom() || 18 },
+    });
+  };
+
+  // clear / reset everything on the map
+  const handleClear = () => {
+    // remove drawn shapes
+    if (drawRef.current) {
+      try { drawRef.current.deleteAll(); } catch (e) {}
+    }
+
+    // clear state
+    setCurrentPolygon(null);
+    setDetections([]);
+    setIsDrawing(false);
+
+    // remove detections layer/source if present
+    try {
+      if (map.current?.getLayer('detections')) map.current.removeLayer('detections');
+    } catch (e) {}
+    try {
+      if (map.current?.getSource('detections')) map.current.removeSource('detections');
+    } catch (e) {}
+
+    // optionally fly back to initial view
+    try { map.current?.flyTo({ center: [-117.59, 47.653], zoom: 18 }); } catch (e) {}
+  };
+
+  const getDetectionsGeoJSON = () => result?.detections || null;
+
+  const handleCopy = async () => {
+    const geojson = getDetectionsGeoJSON();
+    if (!geojson) return;
+    try {
+      await navigator.clipboard.writeText(JSON.stringify(geojson, null, 2));
+      // optionally give feedback
+    } catch (err) {
+      console.error('Copy failed', err);
+    }
+  };
+
+  const handleDownload = () => {
+    const geojson = getDetectionsGeoJSON();
+    if (!geojson) return;
+    const blob = new Blob([JSON.stringify(geojson, null, 2)], { type: 'application/geo+json' });
+    const url = URL.createObjectURL(blob);
+    const a = document.createElement('a');
+    a.href = url;
+    a.download = 'detections.geojson';
+    document.body.appendChild(a);
+    a.click();
+    a.remove();
+    URL.revokeObjectURL(url);
+  };
+ 
   return (
-    <div className="App">
-      <header className="App-header">
-        <img src={logo} className="App-logo" alt="logo" />
-        <p>
-          Edit <code>src/App.js</code> and save to reload.
-        </p>
-        <a
-          className="App-link"
-          href="https://reactjs.org"
-          target="_blank"
-          rel="noopener noreferrer"
-        >
-          Learn React
-        </a>
+    <div className={`app-root ${theme === 'dark' ? 'theme-dark' : 'theme-light'}`}>
+      <header className="app-header">
+        <div className="brand">
+          <h1 className="brand-title">
+            GeoAI
+            <img src="https://cdn-icons-png.flaticon.com/256/5968/5968292.png" alt="JS logo" height="24" style={{ verticalAlign: 'middle', marginLeft: 8 }} />
+          </h1>
+          <div className="brand-text">
+            <h4 className="demo-title">Building Detection (Demo)</h4>
+            <p className="tagline">Inspect satellite imagery and detect buildings with GeoAI</p>
+          </div>
+        </div>
+        <div className="status">
+          <div className={`ready-dot ${isReady ? 'on' : 'off'}`}></div>
+          <span>{isReady ? 'Model ready' : 'Initializing...'}</span>
+          <button className="btn small" onClick={toggleTheme} style={{marginLeft:12}}>{theme === 'dark' ? 'Light' : 'Dark'}</button>
+        </div>
       </header>
+
+      <main className="app-main">
+        <section className="map-area">
+          <div ref={mapContainer} className="map-container" />
+        </section>
+ 
+        <aside className="control-panel">
+          <h2>Controls</h2>
+          <p>Draw a polygon on the map to detect buildings in the selected area.</p>
+
+          <div className="controls-row">
+            <button className="btn" onClick={() => {
+              if (!drawRef.current) return;
+              try {
+                drawRef.current.changeMode('draw_polygon');
+                setIsDrawing(true);
+              } catch (err) { console.error(err); }
+            }} disabled={isDrawing || Boolean(currentPolygon)}>
+              {isDrawing ? 'Drawing…' : 'Draw Polygon'}
+            </button>
+            <button className="btn" onClick={handleAnalyze} disabled={!currentPolygon || !isReady || isProcessing}>
+              {isProcessing ? 'Analyzing…' : 'Analyze'}
+            </button>
+            <button className="btn secondary" onClick={handleClear}>
+              Clear
+            </button>
+          </div>
+
+          <div className="stats">
+            <strong>{detections.length}</strong>
+            <span>Buildings found</span>
+            <div style={{marginLeft:12,color:'var(--muted)'}}>Zoom: {zoom !== null ? zoom : '—'}</div>
+          </div>
+
+          <div className="geojson-section">
+            <div className="geojson-header">
+              <h3>Detections GeoJSON</h3>
+              <div className="geojson-actions">
+                <button className="btn small" onClick={handleCopy} disabled={!result}>Copy</button>
+                <button className="btn small" onClick={handleDownload} disabled={!result}>Download</button>
+              </div>
+            </div>
+            <pre className="geojson-box" aria-live="polite">
+              {result ? JSON.stringify(result.detections, null, 2) : 'No detections yet.'}
+            </pre>
+          </div>
+
+          <div className="footer-note">Powered by Geobase</div>
+        </aside>
+      </main>
     </div>
   );
 }
-
+ 
 export default App;

src/hooks/useGeoAIWorker.js

@@ -0,0 +1,50 @@
+import { useState, useEffect, useRef } from "react";
+ 
+export function useGeoAIWorker() {
+  const workerRef = useRef(null);
+  const [isReady, setIsReady] = useState(false);
+  const [isProcessing, setIsProcessing] = useState(false);
+  const [result, setResult] = useState(null);
+ 
+  useEffect(() => {
+    workerRef.current = new Worker(new URL("./worker.js", import.meta.url));
+ 
+    workerRef.current.onmessage = e => {
+      const { type, payload } = e.data;
+ 
+      switch (type) {
+        case "ready":
+          setIsReady(true);
+          break;
+        case "result":
+          setResult(payload);
+          setIsProcessing(false);
+          break;
+        case "error":
+          console.error("Worker error:", payload);
+          setIsProcessing(false);
+          break;
+      }
+    };
+ 
+    return () => workerRef.current?.terminate();
+  }, []);
+ 
+  const initialize = (tasks, providerParams) => {
+    workerRef.current?.postMessage({
+      type: "init",
+      payload: { tasks, providerParams },
+    });
+  };
+ 
+  const runInference = params => {
+    if (!isReady) return;
+    setIsProcessing(true);
+    workerRef.current?.postMessage({
+      type: "inference",
+      payload: params,
+    });
+  };
+ 
+  return { isReady, isProcessing, result, initialize, runInference };
+}

src/hooks/worker.js

@@ -0,0 +1,30 @@
+import { geoai } from "geoai";
+ 
+let modelInstance = null;
+ 
+// Use a Function to obtain the global object without referencing `globalThis` or `self`
+const workerGlobal = Function("return this")();
+ 
+workerGlobal.onmessage = async e => {
+  const { type, payload } = e.data;
+
+  try {
+    switch (type) {
+      case "init":
+        console.log({payload})
+        modelInstance = await geoai.pipeline(
+          payload.tasks,
+          payload.providerParams
+        );
+        workerGlobal.postMessage({ type: "ready" });
+        break;
+
+      case "inference":
+        const result = await modelInstance.inference(payload);
+        workerGlobal.postMessage({ type: "result", payload: result });
+        break;
+    }
+  } catch (error) {
+    workerGlobal.postMessage({ type: "error", payload: error.message });
+  }
+};