20260430_001744-feat: PyTorch CUDA + SAM2 GPU inference, video thumbnail, real FPS + configurable parse FPS, DICOM batch import

2026-04-30 00:30:58 +08:00
parent 35d6e1503c
commit 6d008ec4a2
15 changed files with 555 additions and 101 deletions
--- a/backend/routers/media.py
+++ b/backend/routers/media.py
@@ -6,16 +6,19 @@ import shutil
 import subprocess
 import tempfile
 from pathlib import Path
-from typing import Optional
+from typing import List, Optional

 from fastapi import APIRouter, Depends, File, Form, HTTPException, UploadFile, status
 from sqlalchemy.orm import Session

 from database import get_db
-from minio_client import upload_file, get_presigned_url
+from minio_client import upload_file, get_presigned_url, download_file
 from models import Project, Frame
 from schemas import FrameOut
-from services.frame_parser import parse_video, parse_dicom, upload_frames_to_minio
+from services.frame_parser import (
+    parse_video, parse_dicom, upload_frames_to_minio,
+    extract_thumbnail, get_video_fps,
+)

 logger = logging.getLogger(__name__)
 router = APIRouter(prefix="/api/media", tags=["Media"])
@@ -78,6 +81,7 @@ async def upload_media(
            description="Auto-created from upload",
            status="pending",
            video_path=object_name,
+            source_type="video",
        )
        db.add(project)
        db.commit()
@@ -90,7 +94,6 @@ async def upload_media(
        db.commit()
        logger.info("Auto-created project id=%s for upload %s", project_id, file.filename)

-    # TODO: enqueue async parsing job (Celery / background task)
    logger.info("Upload complete: %s (size=%d bytes). Async parsing queued.", object_name, len(data))

    return {
@@ -102,6 +105,66 @@ async def upload_media(
    }


+@router.post(
+    "/upload/dicom",
+    status_code=status.HTTP_201_CREATED,
+    summary="Upload multiple DICOM files",
+)
+async def upload_dicom_batch(
+    files: List[UploadFile] = File(...),
+    project_id: Optional[int] = Form(None),
+    db: Session = Depends(get_db),
+) -> dict:
+    """Upload multiple .dcm files for a DICOM series.
+
+    If project_id is provided, files are added to the existing project.
+    Otherwise a new DICOM project is created.
+    """
+    if not files:
+        raise HTTPException(status_code=400, detail="No files uploaded")
+
+    uploaded = []
+
+    if project_id:
+        project = db.query(Project).filter(Project.id == project_id).first()
+        if not project:
+            raise HTTPException(status_code=404, detail="Project not found")
+    else:
+        # Create new DICOM project
+        first_name = files[0].filename or "DICOM_Series"
+        project = Project(
+            name=first_name,
+            description=f"DICOM series with {len(files)} files",
+            status="pending",
+            source_type="dicom",
+        )
+        db.add(project)
+        db.commit()
+        db.refresh(project)
+        project_id = project.id
+        logger.info("Auto-created DICOM project id=%s", project_id)
+
+    for file in files:
+        if not file.filename or not file.filename.lower().endswith(".dcm"):
+            continue
+        data = await file.read()
+        object_name = f"uploads/{project_id}/dicom/{file.filename}"
+        try:
+            upload_file(object_name, data, content_type="application/dicom", length=len(data))
+            uploaded.append(object_name)
+        except Exception as exc:  # noqa: BLE001
+            logger.error("Failed to upload DICOM %s: %s", file.filename, exc)
+
+    project.video_path = f"uploads/{project_id}/dicom"
+    db.commit()
+
+    return {
+        "project_id": project_id,
+        "uploaded_count": len(uploaded),
+        "message": f"Uploaded {len(uploaded)} DICOM files. Parsing job queued.",
+    }
+
+
@router.post(
    "/parse",
    status_code=status.HTTP_202_ACCEPTED,
@@ -109,12 +172,12 @@ async def upload_media(
 )
 def parse_media(
    project_id: int,
-    source_type: str = "video",  # video | dicom
+    source_type: Optional[str] = None,
    db: Session = Depends(get_db),
 ) -> dict:
    """Trigger frame extraction for a project's uploaded media.

-    * video: uses FFmpeg or OpenCV fallback.
+    * video: uses FFmpeg or OpenCV fallback, extracts thumbnail.
    * dicom: uses pydicom to read DCM frames.

    Extracted frames are uploaded to MinIO and registered in the database.
@@ -126,37 +189,53 @@ def parse_media(
    if not project.video_path:
        raise HTTPException(status_code=400, detail="Project has no media uploaded")

-    # Download from MinIO to a temp directory
-    from minio_client import download_file
-
-    try:
-        media_bytes = download_file(project.video_path)
-    except Exception as exc:  # noqa: BLE001
-        logger.error("Failed to download media for parsing: %s", exc)
-        raise HTTPException(status_code=500, detail="Failed to retrieve media from storage") from exc
+    effective_source = source_type or project.source_type or "video"
+    parse_fps = project.parse_fps or 30.0

    tmp_dir = tempfile.mkdtemp(prefix=f"seg_parse_{project_id}_")
-    local_path = os.path.join(tmp_dir, Path(project.video_path).name)
-
-    with open(local_path, "wb") as f:
-        f.write(media_bytes)
-
    output_dir = os.path.join(tmp_dir, "frames")
    os.makedirs(output_dir, exist_ok=True)

    try:
-        if source_type == "dicom":
-            # For DICOM, treat local_path as a directory if it contains multiple .dcm
-            # If a single .dcm file was uploaded, put it in its own sub-dir
+        if effective_source == "dicom":
+            # Download all dicom files from MinIO
            dcm_dir = os.path.join(tmp_dir, "dcm")
            os.makedirs(dcm_dir, exist_ok=True)
-            if local_path.lower().endswith(".dcm"):
-                shutil.move(local_path, os.path.join(dcm_dir, os.path.basename(local_path)))
-            else:
-                shutil.unpack_archive(local_path, dcm_dir) if shutil.which("unzip") else shutil.move(local_path, dcm_dir)
+
+            from minio_client import get_minio_client, BUCKET_NAME
+            client = get_minio_client()
+            prefix = project.video_path
+            objects = list(client.list_objects(BUCKET_NAME, prefix=prefix, recursive=True))
+            for obj in objects:
+                if obj.object_name.lower().endswith(".dcm"):
+                    data = download_file(obj.object_name)
+                    local_dcm = os.path.join(dcm_dir, os.path.basename(obj.object_name))
+                    with open(local_dcm, "wb") as f:
+                        f.write(data)
+
            frame_files = parse_dicom(dcm_dir, output_dir)
        else:
-            frame_files = parse_video(local_path, output_dir, fps=30)
+            # Video: download and parse
+            media_bytes = download_file(project.video_path)
+            local_path = os.path.join(tmp_dir, Path(project.video_path).name)
+            with open(local_path, "wb") as f:
+                f.write(media_bytes)
+
+            frame_files, original_fps = parse_video(local_path, output_dir, fps=int(parse_fps))
+            project.original_fps = original_fps
+
+            # Extract thumbnail from first frame
+            thumbnail_path = os.path.join(tmp_dir, "thumbnail.jpg")
+            try:
+                extract_thumbnail(local_path, thumbnail_path)
+                with open(thumbnail_path, "rb") as f:
+                    thumb_data = f.read()
+                thumb_object = f"projects/{project_id}/thumbnail.jpg"
+                upload_file(thumb_object, thumb_data, content_type="image/jpeg", length=len(thumb_data))
+                project.thumbnail_url = thumb_object
+                logger.info("Uploaded thumbnail for project_id=%s", project_id)
+            except Exception as exc:  # noqa: BLE001
+                logger.warning("Thumbnail extraction failed: %s", exc)
    except Exception as exc:  # noqa: BLE001
        logger.error("Frame extraction failed: %s", exc)
        shutil.rmtree(tmp_dir, ignore_errors=True)
@@ -173,7 +252,6 @@ def parse_media(
    # Register frames in DB
    frames_out = []
    for idx, obj_name in enumerate(object_names):
-        # Get image dimensions
        local_frame = frame_files[idx]
        try:
            import cv2
--- a/backend/routers/projects.py
+++ b/backend/routers/projects.py
@@ -44,6 +44,8 @@ def list_projects(skip: int = 0, limit: int = 100, db: Session = Depends(get_db)
    projects = db.query(Project).offset(skip).limit(limit).all()
    for p in projects:
        p.frame_count = len(p.frames)
+        if p.thumbnail_url:
+            p.thumbnail_url = get_presigned_url(p.thumbnail_url, expires=3600)
    return projects


@@ -58,6 +60,8 @@ def get_project(project_id: int, db: Session = Depends(get_db)) -> Project:
    if not project:
        raise HTTPException(status_code=404, detail="Project not found")
    project.frame_count = len(project.frames)
+    if project.thumbnail_url:
+        project.thumbnail_url = get_presigned_url(project.thumbnail_url, expires=3600)
    return project