endoreg-db 0.6.0__py3-none-any.whl → 0.6.2__py3-none-any.whl

endoreg_db/views/video_segmentation_views.py

@@ -0,0 +1,149 @@
+from rest_framework.views import APIView
+from rest_framework.response import Response
+from rest_framework import status
+from django.http import FileResponse, Http404
+from ..models import RawVideoFile, Label
+from ..serializers.video_segmentation import VideoFileSerializer,VideoListSerializer,LabelSerializer
+import mimetypes
+import os
+
+
+class VideoView(APIView):
+    """
+    API endpoint to:
+    - Fetch video metadata (JSON)
+    - Serve the actual video file dynamically
+    """
+
+    def get(self, request, video_id=None):
+        """
+        Handles GET requests:
+        - If no `video_id` is provided, return a list of all videos for frontend dropdown.
+        - If `Accept: application/json` is in the request headers, return metadata for a specific video.
+        - Otherwise, return the video file.
+        """
+        if video_id is None:
+            return self.get_all_videos()
+        return self.get_video_details(request, video_id)
+
+    def get_all_videos(self):
+        """
+        Returns a list of all available videos along with available labels.
+        Used to populate the video selection dropdown in Vue.js.
+        """
+        videos = RawVideoFile.objects.all()
+        labels = Label.objects.all()  # Fetch all labels
+
+        video_serializer = VideoListSerializer(videos, many=True)
+        label_serializer = LabelSerializer(labels, many=True)  # Serialize labels
+
+        return Response({
+            "videos": video_serializer.data,  # List of videos
+            "labels": label_serializer.data  # List of labels
+        }, status=status.HTTP_200_OK)
+
+    def get_video_details(self, request, video_id):
+        """
+        Returns metadata for a specific video if `Accept: application/json` is set.
+        Otherwise, streams the video file.
+        """
+        try:
+            video_entry = RawVideoFile.objects.get(id=video_id)
+            serializer = VideoFileSerializer(video_entry, context={'request': request})
+
+            accept_header = request.headers.get('Accept', '')
+
+            if "application/json" in accept_header:
+                return Response(serializer.data, status=status.HTTP_200_OK)
+
+            return self.serve_video_file(video_entry)
+
+        except RawVideoFile.DoesNotExist:
+            return Response({"error": "Video not found in the database."}, status=status.HTTP_404_NOT_FOUND)
+        except Exception as e:
+            return Response({"error": f"Internal error: {str(e)}"}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
+
+    def serve_video_file(self, video_entry):
+        """
+        Serves the video file dynamically.
+        """
+        try:
+            full_video_path = video_entry.file.path  # Get the correct file path
+
+            if not os.path.exists(full_video_path):
+                raise Http404("Video file not found.")
+
+            mime_type, _ = mimetypes.guess_type(full_video_path)  # Determine the content type (e.g., video/mp4, video/avi)
+            response = FileResponse(open(full_video_path, "rb"), content_type=mime_type or "video/mp4")
+
+            # Enable video streaming and CORS
+            response["Access-Control-Allow-Origin"] = "*"  # Allow frontend access
+            response["Access-Control-Allow-Credentials"] = "true"
+            response["Accept-Ranges"] = "bytes"  # Enable seeking in video player
+            response["Content-Disposition"] = f'inline; filename="{os.path.basename(full_video_path)}"'  # Instructs the browser to play the video instead of downloading it.
+
+            return response
+
+        except Exception as e:
+            return Response({"error": f"Internal error: {str(e)}"}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
+
+
+
+from ..serializers.video_segmentation import VideoFileSerializer
+
+class VideoLabelView(APIView):
+    """
+    API to fetch time segments (start & end times in seconds) for a specific label.
+    """
+
+    def get(self, request, video_id, label_name):
+        """
+        Handles GET request to return:
+        - Time segments for the selected label.
+        - Frame-wise predictions within those segments.
+        """
+        try:
+            video_entry = RawVideoFile.objects.get(id=video_id)
+            
+            serializer = VideoFileSerializer(video_entry, context={'request': request})
+            label_data = serializer.get_label_time_segments(video_entry)
+
+            # Ensure the requested label exists
+            if label_name not in label_data:
+                return Response({"error": f"Label '{label_name}' not found"}, status=status.HTTP_404_NOT_FOUND)
+
+            return Response({
+                "label": label_name,
+                "time_segments": label_data[label_name]["time_ranges"],
+                "frame_predictions": label_data[label_name]["frame_predictions"]
+            }, status=status.HTTP_200_OK)
+
+        except RawVideoFile.DoesNotExist:
+            return Response({"error": "Video not found"}, status=status.HTTP_404_NOT_FOUND)
+
+        except Exception as e:
+            return Response({"error": f"Internal error: {str(e)}"}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
+
+
+from ..serializers.video_segmentation import LabelSegmentUpdateSerializer, LabelSegmentSerializer
+
+class UpdateLabelSegmentsView(APIView):
+    """
+    API to update or create label segments for a video.
+    """
+
+    def put(self, request, video_id, label_id):
+        """
+        Handles PUT request to update or create label segments.
+        """
+        serializer = LabelSegmentUpdateSerializer(data=request.data)
+
+        if serializer.is_valid():
+            result = serializer.save()
+            return Response({
+                "message": "Segments updated successfully",
+                "updated_segments": result["updated_segments"],
+                "new_segments": result["new_segments"]
+            }, status=status.HTTP_200_OK)
+        
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

endoreg_db/views/views_for_timeline.py

@@ -0,0 +1,46 @@
+from django.shortcuts import render, get_object_or_404
+from ..models import RawVideoFile
+import json
+from ..serializers.video_segmentation import VideoFileSerializer
+
+def video_timeline_view(request, video_id):
+    """
+    Fetches 'outside' label segments and passes their timestamps to the template.
+    """
+    video_entry = get_object_or_404(RawVideoFile, id=video_id)
+
+    # Get metadata (Assumes serializer method exists)
+    video_serializer = VideoFileSerializer(video_entry, context={'request': request})
+    label_segments = video_serializer.get_label_time_segments(video_entry)
+
+    segments = []
+    frame_markers = []  # Store frame timestamps
+    fps = 50  # Fixed FPS
+
+    # Ensure "outside" label exists
+    if "outside" in label_segments:
+        for segment in label_segments["outside"]["time_ranges"]:
+            segments.append({
+                "start_time": segment["start_time"],
+                "end_time": segment["end_time"]
+            })
+
+            # Extract frame timestamps for markers
+            for frame_num, _ in segment["frames"].items():
+                time_in_seconds = frame_num / fps
+                frame_markers.append(time_in_seconds)
+
+    # Set video duration correctly
+    video_duration = video_entry.duration if hasattr(video_entry, "duration") and video_entry.duration else 226  # Default to 226 seconds
+
+    print("Video ID:", video_id)
+    print("Segments:", segments)
+    print("Video Duration:", video_duration)
+
+    return render(request, "timeline.html", {
+        "video_id": video_id,
+        "video_url": video_serializer.get_video_url(video_entry),
+        "segments": json.dumps(segments),  # Send segment start/end times
+        "frame_markers": json.dumps(frame_markers),  # Send frame timestamps
+        "video_duration": video_duration,
+    })

{endoreg_db-0.6.0.dist-info → endoreg_db-0.6.2.dist-info}/METADATA

@@ -1,10 +1,19 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: endoreg-db
-Version: 0.6.0
+Version: 0.6.2
 Summary: EndoReg Db Django App
-Requires-Python: >=3.11
-Description-Content-Type: text/markdown
+Project-URL: Homepage, https://info.coloreg.de
+Project-URL: Repository, https://github.com/wg-lux/endoreg-db
+Author: Max Hild, Hamza Zahid, Peter Kowalczyk
+Author-email: "Thomas J. Lux" <lux_t1@ukw.de>
+Maintainer: Max Hild, Hamza Zahid, Peter Kowalczyk
+Maintainer-email: "Thomas J. Lux" <lux_t1@ukw.de>
 License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Medical Science Apps.
+Requires-Python: >=3.11
 Requires-Dist: agl-report-reader>=0.4.0
 Requires-Dist: django-bootstrap5>=24.3
 Requires-Dist: django-cors-headers>=4.7.0
@@ -27,6 +36,7 @@ Requires-Dist: scipy>=1.14.1
 Requires-Dist: tesseract>=0.1.3
 Requires-Dist: tqdm>=4.67.0
 Requires-Dist: urllib3>=2.2.3
+Description-Content-Type: text/markdown
 
 # EndoregDB - Professional Data Infrastructure for Clinical Research