feat: automated project creation option using image upload and EXIF scan to determine AOI (#802)

* feat: allow automated creation of drone-tm project based on scanned image exif

Assisted by: Opus 4.6 LLM

* fix: ensure created project aoi via import is square

* fix: ensure import button is visible, fix project metrics logic after creation

* fix: add additional validation checks on import, omit bad data from far outside aoi

Author: spwoodcock

src/backend/app/arq/tasks.py

@@ -12,11 +12,12 @@
 
 from drone_flightplan.drone_type import DroneType
 
-from app.arq.tasks import get_redis_pool
+from app.arq.tasks import get_redis_pool, validate_s3_access
 from app.db import database
 from app.models.enums import HTTPStatus, State
 from app.images.image_classification import ImageClassifier
 from app.images.flight_gap_identification import identify_flight_gaps
+from app.projects import project_schemas
 from app.users.user_deps import login_required
 from app.users.user_schemas import AuthUser
 from app.waypoints.flightplan_output import (
@@ -204,6 +205,54 @@ async def ingest_existing_uploads(
     }
 
 
+@router.post("/project-from-imagery-exif/", tags=["Image Classification"])
+async def create_project_from_imagery_exif(
+    body: project_schemas.ProjectFromImageryExifIn,
+    redis: Annotated[ArqRedis, Depends(get_redis_pool)],
+    user: Annotated[AuthUser, Depends(login_required)],
+):
+    """Create a drone-tm project by scanning EXIF GPS from a remote S3 path.
+
+    Lists JPEG files (depth <=3 from the given prefix) in a public S3-compatible
+    bucket, extracts GPS via exiftool on the first ~128KB of each, builds a
+    100m-buffered convex hull as the AOI, then creates the project with a 600m
+    task split. Imagery transfer and ingestion are run separately afterwards
+    (existing justfile + ingest endpoint).
+    """
+    try:
+        await validate_s3_access(body.endpoint, body.bucket_name, body.path)
+    except ValueError as e:
+        raise HTTPException(status_code=HTTPStatus.UNPROCESSABLE_ENTITY, detail=str(e))
+
+    job = await redis.enqueue_job(
+        "create_project_from_imagery_exif",
+        user.id,
+        body.endpoint,
+        body.bucket_name,
+        body.path,
+        body.project_name,
+        _queue_name="default_queue",
+    )
+
+    if job is None:
+        raise HTTPException(
+            status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
+            detail="Failed to enqueue project creation job",
+        )
+
+    log.info(
+        f"create_project_from_imagery_exif: queued job {job.job_id} "
+        f"for user {user.id} ({body.bucket_name}/{body.path})"
+    )
+
+    return {
+        "message": (
+            "Please be patient while the project is created in the background. "
+            "For many images, this may take several hours."
+        ),
+    }
+
+
 @router.get("/{project_id}/imagery/status/", tags=["Image Classification"])
 async def get_project_imagery_status(
     project_id: UUID,

src/backend/app/projects/classification_routes.py

@@ -540,6 +540,10 @@ async def process_task_metrics(db, tasks_data, project):
         gsd = project.gsd_cm_px
         altitude = project.altitude_from_ground
 
+        if altitude is None or gsd is None:
+            task_updates.append((total_area_sqkm, None, None, task_id))
+            continue
+
         parameters = calculate_parameters(
             forward_overlap, side_overlap, altitude, gsd, 2
         )

src/backend/app/projects/project_logic.py

@@ -100,6 +100,31 @@ def enum_to_str(value: Union[IntEnum, str]) -> str:
     return value
 
 
+class ProjectFromImageryExifIn(BaseModel):
+    """Request body for creating a project by scanning EXIF GPS from a remote S3 path.
+
+    The endpoint, bucket, and path are kept as separate params so we work
+    against any S3-compatible provider (AWS S3, Wasabi, MinIO, B2, etc).
+    """
+
+    endpoint: str = Field(
+        ...,
+        description=(
+            "S3-compatible host, e.g. 's3.amazonaws.com', "
+            "'s3.us-west-1.wasabisys.com'. May include scheme; defaults to https."
+        ),
+    )
+    bucket_name: str = Field(..., description="Bucket containing the imagery")
+    path: str = Field(
+        "",
+        description=(
+            "Prefix within the bucket. Subdirectories are scanned up to 3 "
+            "levels deep from this prefix."
+        ),
+    )
+    project_name: str = Field(..., min_length=1, description="Project name")
+
+
 class ProjectIn(BaseModel):
     """Upload new project."""
 

src/backend/app/projects/project_schemas.py

@@ -2,6 +2,7 @@
 
 import json
 import logging
+import time
 from pathlib import Path
 from typing import Optional, Union
 
@@ -218,6 +219,18 @@ def splitBySquare(self, meters: int) -> FeatureCollection:
             shapely_transform(transformer_to_mercator.transform, self.aoi)
         )
         xmin, ymin, xmax, ymax = aoi_mercator.bounds
+        est_cols = int((xmax - xmin) / meters) + 1
+        est_rows = int((ymax - ymin) / meters) + 1
+        log.debug(
+            f"splitBySquare: AOI bounds {xmin:.0f},{ymin:.0f} → {xmax:.0f},{ymax:.0f} (~{est_cols}×{est_rows} grid)"
+        )
+        _MAX_CELLS = 50_000
+        if est_cols * est_rows > _MAX_CELLS:
+            raise GeometryValidationError(
+                f"AOI grid would require {est_cols * est_rows:,} cells at {meters}m - "
+                "this is almost certainly caused by invalid GPS coordinates in the imagery. "
+                f"AOI spans {(xmax - xmin) / 1000:.1f} km × {(ymax - ymin) / 1000:.1f} km."
+            )
 
         # Generate grid columns and rows based on AOI bounds and specified square length in meters
         def frange(start: float, stop: float, step: float):
@@ -235,6 +248,7 @@ def frange(start: float, stop: float, step: float):
         small_polygons = []
 
         area_threshold = (meters**2) / 3
+        _t0 = time.perf_counter()
 
         # Create a grid of square cells in Web Mercator
         for x in cols[:-1]:
@@ -259,6 +273,12 @@ def frange(start: float, stop: float, step: float):
                 else:
                     polygons.append(clipped_polygon)
 
+        log.debug(
+            f"splitBySquare: grid intersections done in {time.perf_counter() - _t0:.2f}s "
+            f"({len(polygons)} full cells, {len(small_polygons)} slivers to merge)"
+        )
+        _t1 = time.perf_counter()
+
         for small_polygon in small_polygons:
             while True:
                 adjacent_polygons = [
@@ -307,6 +327,11 @@ def frange(start: float, stop: float, step: float):
                     polygons.append(small_polygon)
                     break
 
+        log.debug(
+            f"splitBySquare: sliver merge done in {time.perf_counter() - _t1:.2f}s; "
+            f"total {time.perf_counter() - _t0:.2f}s → {len(polygons)} final polygons"
+        )
+
         # Transform all polygons back to WGS84 for final output
         polygons_wgs84 = [
             shapely_transform(transformer_to_wgs84.transform, p)

src/backend/app/tasks/task_splitter.py

@@ -15,6 +15,7 @@ const TaskDescription = lazy(() => import("@Views/TaskDescription"));
 const UpdateUserProfile = lazy(() => import("@Views/UpdateUserProfile"));
 const RegulatorsApprovalPage = lazy(() => import("@Views/RegulatorsApprovalPage"));
 const Tutorials = lazy(() => import("@Views/Tutorial"));
+const ImportPage = lazy(() => import("@Views/Import"));
 
 const appRoutes: IRoute[] = [
   ...userRoutes,
@@ -90,6 +91,12 @@ const appRoutes: IRoute[] = [
     component: RegulatorsApprovalPage,
     authenticated: false,
   },
+  {
+    path: "/import",
+    name: "Import Imagery",
+    component: ImportPage,
+    authenticated: true,
+  },
 ];
 
 export default appRoutes;

src/frontend/src/routes/appRoutes.ts

@@ -108,6 +108,32 @@ export const ingestExistingUploads = async (
   return response.data;
 };
 
+export interface ProjectFromImageryExifRequest {
+  endpoint: string;
+  bucket_name: string;
+  path: string;
+  project_name: string;
+}
+
+/**
+ * Submit a job to create a drone-tm project by scanning EXIF GPS from a remote
+ * S3-compatible bucket. The backend handles listing, GPS extraction, AOI
+ * computation, and project + task creation. Imagery transfer + ingest are
+ * performed separately afterwards.
+ *
+ * Fire-and-forget: the backend runs the job in the background and may take
+ * several hours for large datasets. Users can find the project on their
+ * dashboard once it has been created.
+ */
+export const createProjectFromImageryExif = async (
+  body: ProjectFromImageryExifRequest,
+): Promise<{ message: string }> => {
+  const response = await authenticated(api).post(`/projects/project-from-imagery-exif/`, body, {
+    headers: { "Content-Type": "application/json" },
+  });
+  return response.data;
+};
+
 /**
  * Reset images stuck in 'classifying' state back to 'uploaded' so they can be re-classified.
  * Resets all images stuck in 'classifying' state back to 'uploaded'.

src/frontend/src/services/classification.ts

@@ -0,0 +1,118 @@
+import { useState } from "react";
+import { toast } from "react-toastify";
+
+import { Button } from "@Components/RadixComponents/Button";
+import { FormControl, Input, Label } from "@Components/common/FormUI";
+import { createProjectFromImageryExif } from "@Services/classification";
+import hasErrorBoundary from "@Utils/hasErrorBoundary";
+
+const Import = () => {
+  const [endpoint, setEndpoint] = useState("s3.amazonaws.com");
+  const [bucketName, setBucketName] = useState("");
+  const [path, setPath] = useState("");
+  const [projectName, setProjectName] = useState("");
+  const [submitting, setSubmitting] = useState(false);
+  const [submitted, setSubmitted] = useState(false);
+
+  const handleSubmit = async (e: React.FormEvent) => {
+    e.preventDefault();
+    if (!endpoint || !bucketName || !projectName) {
+      toast.error("Endpoint, bucket name, and project name are required");
+      return;
+    }
+    setSubmitting(true);
+    try {
+      await createProjectFromImageryExif({
+        endpoint,
+        bucket_name: bucketName,
+        path,
+        project_name: projectName,
+      });
+      setSubmitted(true);
+      toast.success("Project creation job submitted");
+    } catch (err: any) {
+      const detail = err?.response?.data?.detail || err?.message || "Request failed";
+      toast.error(detail);
+    } finally {
+      setSubmitting(false);
+    }
+  };
+
+  return (
+    <section className="naxatw-flex naxatw-min-h-screen-nav naxatw-flex-col naxatw-items-center naxatw-px-4 naxatw-py-8 md:naxatw-px-16">
+      <div className="naxatw-w-full naxatw-max-w-2xl naxatw-rounded-md naxatw-bg-white naxatw-p-6 naxatw-shadow-md">
+        <h4 className="naxatw-mb-2 naxatw-font-bold">Import imagery from S3</h4>
+        <p className="naxatw-mb-6 naxatw-text-body-md naxatw-text-grey-600">
+          Point at a public S3-compatible bucket. We&apos;ll scan EXIF GPS from each JPEG
+          (subdirectories up to 3 levels deep), build a buffered AOI, and create a drone-tm project.
+          Imagery transfer and ingestion are run separately afterwards.
+        </p>
+
+        <form onSubmit={handleSubmit} className="naxatw-flex naxatw-flex-col naxatw-gap-4">
+          <FormControl>
+            <Label>Project name</Label>
+            <Input
+              placeholder="My drone survey"
+              value={projectName}
+              onChange={(e) => setProjectName(e.target.value)}
+              disabled={submitting}
+              required
+            />
+          </FormControl>
+
+          <FormControl>
+            <Label>S3 endpoint</Label>
+            <Input
+              placeholder="s3.amazonaws.com"
+              value={endpoint}
+              onChange={(e) => setEndpoint(e.target.value)}
+              disabled={submitting}
+              required
+            />
+          </FormControl>
+
+          <FormControl>
+            <Label>Bucket name</Label>
+            <Input
+              placeholder="my-bucket"
+              value={bucketName}
+              onChange={(e) => setBucketName(e.target.value)}
+              disabled={submitting}
+              required
+            />
+          </FormControl>
+
+          <FormControl>
+            <Label>Path / prefix (optional)</Label>
+            <Input
+              placeholder="surveys/2025-01/site-a"
+              value={path}
+              onChange={(e) => setPath(e.target.value)}
+              disabled={submitting}
+            />
+          </FormControl>
+
+          <Button
+            className="naxatw-bg-red naxatw-mt-2 naxatw-self-end"
+            type="submit"
+            disabled={submitting || !endpoint || !bucketName || !projectName}
+            withLoader
+            isLoading={submitting}
+          >
+            Create project
+          </Button>
+        </form>
+
+        {submitted && (
+          <div className="naxatw-mt-6 naxatw-rounded-md naxatw-border naxatw-border-grey-200 naxatw-bg-grey-50 naxatw-p-4 naxatw-text-body-md">
+            Please be patient while the project is created in the background. For many images, this
+            may take several hours. The new project will appear on your projects list once it has
+            been created.
+          </div>
+        )}
+      </div>
+    </section>
+  );
+};
+
+export default hasErrorBoundary(Import);