Merge branch 'main' into ITEP-83030/renovate-config

Author: dmytroye

manager/src/django/mesh_generator.py

@@ -113,8 +113,9 @@ class Scene(models.Model):
   name = models.CharField(max_length=200, unique=True)
   map_type = models.CharField("Map Type", max_length=20, choices=MAP_TYPE_CHOICES, default='map_upload', null=True)
   thumbnail = models.ImageField(default=None, null=True, editable=False)
-  map = models.FileField("Scene map as .glb or .ply or image or .zip", default=None, null=True, blank=True,
-                            validators=[FileExtensionValidator(["glb","png","jpeg","jpg","zip","ply"]),
+  map = models.FileField("Scene map as .glb or .ply or image or .zip or video", default=None, null=True, blank=True,
+                            validators=[FileExtensionValidator(["glb","png","jpeg","jpg","zip","ply","mp4",
+                            "mov", "mkv", "webm", "avi"]),
                                         validate_map_file])
   scale = models.FloatField("Pixels per meter", default=None, null=True, blank=True,
                             validators=[MinValueValidator(np.nextafter(0, 1))])

manager/src/django/models.py

@@ -29,6 +29,7 @@
   path('scene/update/<uuid:pk>/', views.SceneUpdateView.as_view(), name='scene_update'),
   path('scene/delete/<uuid:pk>/', views.SceneDeleteView.as_view(), name='scene_delete'),
   path('scene/generate-mesh/<uuid:pk>/', views.generate_mesh, name='generate_mesh'),
+  path('scene/generate-mesh-status/<uuid:pk>/',views.generate_mesh_status, name='generate_mesh_status'),
   path('mapping-service/status/', views.check_mapping_service_status, name='mapping_service_status'),
   path('cam/list/', views.CamListView.as_view(), name='cam_list'),
   path('cam/create/', views.CamCreateView.as_view(), name='cam_create'),

manager/src/django/urls.py

@@ -8,6 +8,9 @@
 import traceback
 import uuid
 from collections import namedtuple
+import tempfile
+import subprocess
+from pathlib import Path
 
 from django.conf import settings
 from django.contrib.admin.views.decorators import user_passes_test
@@ -19,7 +22,7 @@
 from django.contrib.auth import user_logged_in, user_login_failed
 from django.contrib.sessions.models import Session
 from rest_framework.authtoken.models import Token
-from django.db import IntegrityError
+from django.db import IntegrityError, transaction
 from django.dispatch.dispatcher import receiver
 from django.http import FileResponse, HttpResponse, HttpResponseNotFound, HttpResponseRedirect, JsonResponse
 from django.shortcuts import get_object_or_404, redirect, render
@@ -890,6 +893,57 @@ def generate_camera_pipeline(request, sensor_id):
     log.error(f"Traceback: {traceback.format_exc()}")
     return JsonResponse({"error": "Error generating pipeline"}, status=500)
 
+@superuser_required
+def generate_mesh_status(request, pk):
+  scene = get_object_or_404(Scene, pk=pk)
+  request_id = request.GET.get("request_id")
+  if not request_id:
+    return JsonResponse({"success": False, "error": "missing request_id"}, status=400)
+
+  try:
+    from .mesh_generator import MeshGenerator
+    mesh_generator = MeshGenerator()
+
+    status_data = mesh_generator.mapping_client.getReconstructionStatus(request_id)
+
+    # If mapping service couldn't find it / errored, just return it
+    if not status_data.get("success"):
+      return JsonResponse(status_data, status=200)
+
+    state = status_data.get("state")
+
+    if state != "complete":
+      return JsonResponse(status_data, status=200)
+
+    with transaction.atomic():
+      scene = Scene.objects.select_for_update().get(pk=scene.pk)
+
+      if hasattr(scene, "mesh_state") and scene.mesh_state == "complete":
+        status_data["finalized"] = True
+        return JsonResponse(status_data, status=200)
+      finalize_result = mesh_generator.finalizeMeshFromStatus(scene, request_id)
+
+      if not finalize_result.get("success"):
+        if hasattr(scene, "mesh_state"):
+          scene.mesh_state = "failed"
+          scene.save(update_fields=["mesh_state"])
+        return JsonResponse(finalize_result, status=500)
+
+      if hasattr(scene, "mesh_state"):
+        scene.mesh_state = "complete"
+        scene.save(update_fields=["mesh_state"])
+
+    status_data["finalized"] = True
+    return JsonResponse(status_data, status=200)
+
+  except Exception as e:
+    log.error(f"Mesh status error: {e}")
+    log.error(f"Traceback: {traceback.format_exc()}")
+    return JsonResponse({
+      "success": False,
+      "error": "An internal error occurred while getting mesh status",
+    }, status=500)
+
 @superuser_required
 def generate_mesh(request, pk):
   """Generate 3D mesh from scene cameras using mapping service."""
@@ -899,39 +953,37 @@ def generate_mesh(request, pk):
   try:
     from .mesh_generator import MeshGenerator
 
-    # Get request parameters
-    request_data = json.loads(request.body.decode('utf-8'))
-    mesh_type = request_data.get('mesh_type', 'mesh')
-
     # Get scene object
     scene = get_object_or_404(Scene, pk=pk)
 
     # Initialize mesh generator
+    mesh_type = request.POST.get("mesh_type", "mesh")
+    uploaded_map = request.FILES.get("map", None)
     mesh_generator = MeshGenerator()
 
     # Generate mesh
-    result = mesh_generator.generateMeshFromScene(scene, mesh_type)
-
-    if result['success']:
+    result = mesh_generator.startMeshGeneration(scene, mesh_type, uploaded_map=uploaded_map)
+    if result.get("success"):
       return JsonResponse({
         "success": True,
         "message": "Mesh generated successfully",
-        "processing_time": result.get('processing_time', 0)
+        "request_id": result["request_id"],
+        "processing_time": result.get("processing_time", 0),
       })
-    else:
-      return JsonResponse({
-        "success": False,
-        "error": result.get('error', 'Unknown error occurred while generating mesh'),
-        "processing_time": result.get('processing_time', 0)
-      }, status=400)
+
+    return JsonResponse({
+      "success": False,
+      "error": result.get("error", "Unknown error occurred while generating mesh"),
+      "processing_time": result.get("processing_time", 0),
+    }, status=400)
 
   except Exception as e:
     log.error(f"Mesh generation error: {e}")
     import traceback
     log.error(f"Traceback: {traceback.format_exc()}")
     return JsonResponse({
       "success": False,
-      "error": f"An internal error occurred while generating mesh"
+      "error": "An internal error occurred while generating mesh",
     }, status=500)
 
 @superuser_required

manager/src/django/views.py

@@ -1466,88 +1466,158 @@ function setupSceneRotationTranslationFields(event = null) {
 
 function setupGenerateMesh() {
   const generateMeshButton = document.getElementById("generate_mesh");
+  const saveButton = document.getElementById("save");
+  const mapInput = document.getElementById("id_map");
+
+  saveButton?.addEventListener("click", async (e) => {
+    const allowedExtensions = ["mp4", "mov", "avi", "webm", "mkv"];
+
+    const file = mapInput?.files?.[0];
+    if (!file) {
+      // No file selected; nothing to validate here.
+      return;
+    }
+    const extension = file.name.split(".").pop().toLowerCase();
+
+    const isVideoMime = file.type.startsWith("video/");
+    const isVideoExt = allowedExtensions.includes(extension);
+
+    if (isVideoMime && isVideoExt) {
+      e.preventDefault();
+      alert("Please click generate mesh when uploading video file.");
+      return;
+    }
+  });
+
   if (!generateMeshButton) return;
 
   // Start monitoring mapping service status
   startMappingServiceStatusMonitoring();
 
-  generateMeshButton.addEventListener("click", async function () {
+  generateMeshButton?.addEventListener("click", async (e) => {
+    e.preventDefault();
+
     const sceneId = document.getElementById("sceneUID")?.value;
-    if (!sceneId) {
-      alert("Scene ID not found");
-      return;
-    }
+    const form = document.getElementById("scene_update_form");
+
+    if (!sceneId) return alert("Scene ID not found");
+    if (!form) return alert("Form not found");
 
     // Show loading state
     const spinner = document.getElementById("mesh_spinner");
-    spinner.classList.remove("d-none");
+
+    spinner?.classList.remove("d-none");
+    generateMeshButton.dataset.meshRunning = "1";
     generateMeshButton.disabled = true;
 
     try {
-      await generateMeshFromCameras(sceneId);
-    } catch (error) {
-      console.error("Mesh generation failed:", error);
-      alert("Mesh generation failed: " + error.message);
+      const startResult = await generateMeshFromCameras(sceneId, form);
+
+      const requestId = startResult.request_id;
+      if (!requestId) {
+        throw new Error("Backend did not return request_id");
+      }
+
+      await pollMeshStatus(sceneId, requestId);
+
+      alert("Mesh generated successfully! The scene map has been updated.");
+
+      $("#id_rotation_x").val(0);
+      $("#id_rotation_y").val(0);
+      $("#id_rotation_z").val(0);
+      $("#id_translation_x").val(0);
+      $("#id_translation_y").val(0);
+      $("#id_translation_z").val(0);
+      window.location.reload();
+    } catch (err) {
+      console.error(err);
+      alert("Mesh generation failed: " + (err?.message ?? String(err)));
     } finally {
       // Hide loading state
-      spinner.classList.add("d-none");
+      spinner?.classList.add("d-none");
+      generateMeshButton.dataset.meshRunning = "0";
       generateMeshButton.disabled = false;
     }
   });
 }
 
-async function generateMeshFromCameras(sceneId) {
-  const tokenElement = document.getElementById("auth-token");
-  if (!tokenElement) {
-    throw new Error("Authentication token not found");
-  }
+async function pollMeshStatus(sceneId, requestId) {
+  const timeout = 10 * 60 * 1000; // 10 minutes
+  const start = Date.now();
 
-  const authToken = `Token ${tokenElement.value}`;
-  try {
-    const response = await fetch(`/scene/generate-mesh/${sceneId}/`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: authToken,
-        "X-CSRFToken": document.querySelector("[name=csrfmiddlewaretoken]")
-          ?.value,
-      },
-      body: JSON.stringify({
-        mesh_type: "mesh",
-      }),
-    });
+  while (true) {
+    if (Date.now() - start > timeout) {
+      throw new Error("Timed out waiting for mesh generation.");
+    }
 
-    // Log response for debugging
-    console.log("Response status:", response.status);
-    console.log("Response headers:", response.headers);
+    const resp = await fetch(
+      `/scene/generate-mesh-status/${sceneId}/?request_id=${encodeURIComponent(requestId)}`,
+    );
 
-    if (!response.ok) {
-      const errorText = await response.text();
-      console.log("Error response text:", errorText);
-      throw new Error(`HTTP ${response.status}: ${errorText}`);
+    const data = await resp.json();
+
+    if (!resp.ok) {
+      throw new Error(data?.error || "Status check failed");
     }
 
-    const result = await response.json();
+    if (data.success === false) {
+      throw new Error(data?.error || "Mesh generation failed");
+    }
 
-    if (result.success) {
-      alert("Mesh generated successfully! The scene map has been updated.");
-      // Optionally reload the page to show the updated map
-      // window.location.reload();
-      // Set rotation and translation fields to zero
-      $("#id_rotation_x").val(0);
-      $("#id_rotation_y").val(0);
-      $("#id_rotation_z").val(0);
-      $("#id_translation_x").val(0);
-      $("#id_translation_y").val(0);
-      $("#id_translation_z").val(0);
-    } else {
-      throw new Error(result.message || "Mesh generation failed");
+    if (data.state === "complete") {
+      return data;
     }
-  } catch (error) {
-    throw error;
+
+    if (data.state === "failed") {
+      throw new Error(data.error || "Mesh generation failed");
+    }
+
+    // Wait before next poll
+    await new Promise((r) => setTimeout(r, 1500));
   }
 }
 
+async function generateMeshFromCameras(sceneId, form) {
+  const url = `/scene/generate-mesh/${sceneId}/`;
+
+  const formData = new FormData(form);
+
+  // Make sure CSRF is sent (Django)
+  const csrfToken =
+    document.querySelector('input[name="csrfmiddlewaretoken"]')?.value ||
+    getCookie("csrftoken");
+
+  const resp = await fetch(url, {
+    method: "POST",
+    headers: {
+      "X-CSRFToken": csrfToken,
+      Accept: "application/json",
+    },
+    body: formData,
+  });
+
+  const data = await resp.json().catch(() => ({}));
+
+  if (!resp.ok || data.success === false) {
+    throw new Error(
+      data?.error || `Generate mesh failed (HTTP ${resp.status})`,
+    );
+  }
+
+  // expects { success: true, request_id: "..." }
+  if (!data.request_id) {
+    throw new Error("Generate mesh response missing request_id");
+  }
+
+  return data;
+}
+
+// Optional cookie helper if you don't already have one:
+function getCookie(name) {
+  const match = document.cookie.match(new RegExp("(^| )" + name + "=([^;]+)"));
+  return match ? decodeURIComponent(match[2]) : null;
+}
+
 async function checkMappingServiceStatus() {
   const generateMeshButton = document.getElementById("generate_mesh");
   if (!generateMeshButton) return;
@@ -1577,7 +1647,10 @@ async function checkMappingServiceStatus() {
       if (status.available) {
         // Service is available, show the button
         generateMeshButton.style.display = "inline-block";
-        generateMeshButton.disabled = false;
+        const running = generateMeshButton.dataset.meshRunning === "1";
+        if (!running) {
+          generateMeshButton.disabled = false;
+        }
         generateMeshButton.title =
           "Generate 3D mesh from camera images using mapping service";