endoreg-db 0.5.3__py3-none-any.whl → 0.6.1__py3-none-any.whl

endoreg_db/utils/video/extract_frames.py

@@ -0,0 +1,121 @@
+import os
+import shutil
+from pathlib import Path
+from icecream import ic
+import subprocess
+from django.db import transaction
+from tqdm import tqdm
+from typing import TYPE_CHECKING, Union, List
+
+if TYPE_CHECKING:
+    from endoreg_db.models import RawVideoFile, Video
+
+from django.core.files import File
+import io
+
+
+def prepare_bulk_frames(frame_paths: List[Path]):
+    """
+    Reads the frame paths into memory as Django File objects.
+    This avoids 'seek of closed file' errors by using BytesIO for each frame.
+    """
+    for path in frame_paths:
+        frame_number = int(path.stem.split("_")[1])
+        with open(path, "rb") as f:
+            content = f.read()
+        file_obj = File(io.BytesIO(content), name=path.name)
+        yield frame_number, file_obj
+
+
+def extract_frames(
+    video: Union["RawVideoFile", "Video"],
+    quality: int = 2,
+    overwrite: bool = False,
+    ext="jpg",
+    verbose=False,
+) -> List[Path]:
+    """
+    Extract frames from the video file and save them to the frame_dir.
+    For this, ffmpeg must be available in in the current environment.
+    """
+    frame_dir = Path(video.frame_dir)
+    ic(f"Extracting frames to {frame_dir}")
+    if not frame_dir.exists():
+        frame_dir.mkdir(parents=True, exist_ok=True)
+
+    if not overwrite and len(list(frame_dir.glob(f"*.{ext}"))) > 0:
+        video.state_frames_extracted = True  # Mark frames as extracted
+        extracted_paths = sorted(frame_dir.glob(f"*.{ext}"))
+        return extracted_paths
+
+    video_path = Path(video.file.path).resolve().as_posix()
+
+    frame_path_string = frame_dir.resolve().as_posix()
+    command = [
+        "ffmpeg",
+        "-i",
+        video_path,  #
+        "-q:v",
+        str(quality),
+        os.path.join(frame_path_string, f"frame_%07d.{ext}"),
+    ]
+
+    # Ensure FFmpeg is available
+    if not shutil.which("ffmpeg"):
+        raise EnvironmentError(
+            "FFmpeg could not be found. Ensure it is installed and in your PATH."
+        )
+
+    # Extract frames from the video file
+    # Execute the command
+    process = subprocess.Popen(
+        command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True
+    )
+    stdout_data, stderr_data = process.communicate()
+
+    if process.returncode != 0:
+        raise Exception(f"Error extracting frames: {stderr_data}")
+
+    if verbose and stdout_data:
+        print(stdout_data)
+
+    # After extracting frames with ffmpeg, parse frame filenames and batch-create
+    extracted_paths = sorted(frame_dir.glob(f"*.{ext}"))
+
+    return extracted_paths
+
+
+def initialize_frame_objects(
+    video: Union["RawVideoFile", "Video"], extracted_paths: List[Path]
+):
+    """
+    Initialize frame objects for the extracted frames.
+    """
+    if video.state_frames_initialized:
+        return
+    video.frame_count = len(extracted_paths)
+    frames_to_create = []
+    batch_size = int(os.environ.get("DJANGO_FFMPEG_EXTRACT_FRAME_BATCHSIZE", "500"))
+    for i, (frame_number, file_obj) in tqdm(
+        enumerate(prepare_bulk_frames(extracted_paths), start=1)
+    ):
+        frame_obj_instance = video.create_frame_object(
+            frame_number, image_file=file_obj, extracted=True
+        )
+        frames_to_create.append(frame_obj_instance)
+
+        if i % batch_size == 0:
+            with transaction.atomic():
+                video.bulk_create_frames(frames_to_create)
+            frames_to_create.clear()
+
+    if frames_to_create:
+        with transaction.atomic():
+            video.bulk_create_frames(frames_to_create)
+
+    video.set_frames_extracted(True)
+    video.save()
+
+    frame_dir = extracted_paths[0].parent
+    ic(f"Removing frame directory: {frame_dir}")
+    shutil.rmtree(frame_dir)

endoreg_db/utils/video/transcode_videofile.py

@@ -0,0 +1,111 @@
+import shutil
+import subprocess
+import os
+from pathlib import Path
+from icecream import ic
+
+
+def get_transcoded_file_path(source_file_path: Path, suffix: str = "mp4"):
+    """
+    Method to get the transcoded file path.
+
+    Args:
+        source_file_path (Path): Source file path.
+        suffix (str): Suffix of the transcoded file.
+
+    Returns:
+        transcoded_file_path (Path): Transcoded file path.
+    """
+    transcoded_file_name = f"{source_file_path.stem}_transcoded.{suffix}"
+    transcoded_file_path = source_file_path.parent / transcoded_file_name
+    return transcoded_file_path
+
+
+def check_require_transcode(
+    filepath: Path, transcoded_file_path: Path, target_suffix=".mp4"
+):
+    """
+    Checks whether a video file requires transcoding.\
+    We check if the current suffix of the file path matches the target suffix\
+    and if the transcoded file path exists.\
+    If the current suffix does not match the target suffix and the transcoded file path does not exist,\
+    transcoding is required.
+    """
+    current_suffix = filepath.suffix
+
+    require_transcode = False
+    if not current_suffix == target_suffix and not transcoded_file_path.exists():
+        if not transcoded_file_path.exists():
+            require_transcode = True
+    return require_transcode
+
+
+def transcode_videofile_if_required(filepath: Path):
+    """
+    Perform transcoding on a video file if required.
+    This method checks whether a transcoded version (with an ".mp4" suffix) of the given
+    video file exists or needs to be produced. It first computes the expected transcoded file path,
+    then uses a class-specific check (check_require_transcode) to decide if transcoding is necessary.
+    If so, it transcodes the video file by calling the class method transcode_videofile and returns
+    the path of the transcoded file after ensuring that the resulting file path matches the computed one.
+    If transcoding is not required, the original file path is returned.
+    Args:
+        filepath (Path): The path to the original video file that may require transcoding.
+    Returns:
+        Path: The path to the transcoded video file if transcoding was performed; otherwise, the original file path.
+    """
+
+    transcoded_file_path = get_transcoded_file_path(filepath, suffix=".mp4")
+    if check_require_transcode(filepath, transcoded_file_path):
+        transcoded_path = transcode_videofile(
+            filepath, transcoded_path=transcoded_file_path
+        )
+        assert transcoded_file_path == transcoded_path
+        return transcoded_path
+    else:
+        return filepath
+
+
+def transcode_videofile(filepath: Path, transcoded_path: Path):
+    """
+    Transcodes a video to a compatible MP4 format using ffmpeg.
+    If the transcoded file exists, it is returned.
+
+    Parameters
+    ----------
+    mov_file : str
+        The full path to the video file.
+
+    Returns
+    -------
+    transcoded_path : str
+        The full path to the transcoded video file.
+    """
+    ic("Transcoding video")
+    ic(f"Input path: {filepath}")
+
+    # if filepath suffix is .mp4 or .MP4 we dont need to transcode and can copy the file
+    if filepath.suffix.lower() in [".mp4"]:
+        shutil.copyfile(filepath, transcoded_path)
+        return transcoded_path
+
+    ic(f"Transcoded path: {transcoded_path}")
+    if os.path.exists(transcoded_path):
+        return transcoded_path
+
+    # Run ffmpeg to transcode the video using H264 and AAC
+    # TODO Document settings, check if we need to change them
+    command = [
+        "ffmpeg",
+        "-i",
+        filepath.resolve().as_posix(),
+        "-c:v",
+        "libx264",
+        "-preset",
+        "fast",
+        "-c:a",
+        "aac",
+        transcoded_path,
+    ]
+    subprocess.run(command, check=True)
+    return transcoded_path

endoreg_db/views/__init__.py

@@ -0,0 +1,2 @@
+# Import the views so they are available for Django
+from .patient_views import start_examination

endoreg_db/views/csrf.py

@@ -0,0 +1,7 @@
+from django.http import JsonResponse
+from django.middleware.csrf import get_token
+
+# New view to return the CSRF token in JSON format
+def csrf_token_view(request):
+    token = get_token(request)
+    return JsonResponse({'csrf_token': token})

endoreg_db/views/patient_views.py

@@ -0,0 +1,90 @@
+from django.shortcuts import render
+from django.contrib.admin.views.decorators import staff_member_required
+from django.http import JsonResponse
+from django.http import JsonResponse
+from django.views.decorators.http import require_GET
+from django.core.exceptions import ObjectDoesNotExist
+from rest_framework import viewsets
+from ..models import Patient
+from ..serializers import PatientSerializer
+from rest_framework.permissions import IsAuthenticatedOrReadOnly
+from endoreg_db.models import (
+    FindingLocationClassification,
+    FindingLocationClassificationChoice,
+    FindingMorphologyClassification,
+    FindingMorphologyClassificationType
+)
+
+@staff_member_required  # Ensures only staff members can access the page
+def start_examination(request):
+    return render(request, 'admin/start_examination.html')  # Loads the simple HTML page
+
+#from ..models.patient.patient_finding_location import PatientFindingLocation
+from ..models import FindingLocationClassification, FindingLocationClassificationChoice  # Correct models
+
+
+#need to implement one with json data after tesing whethe rthis works or not
+"""def get_location_choices(request, location_id):
+   
+    try:
+        # Ensure the location exists
+        location = FindingLocationClassification.objects.get(id=location_id)
+        # Get only choices related to the selected location classification
+        #location_choices = FindingLocationClassificationChoice.objects.filter(location_classification=location)
+        #its many to may relation so
+        location_choices = location.choices.all()
+        
+    except FindingLocationClassification.DoesNotExist:
+        location_choices = []
+
+    # Get previously selected values to retain them after reloading
+    selected_location = int(location_id) if location_id else None
+
+    return render(request, 'admin/patient_finding_intervention.html', {
+        "location_choices": location_choices,  # Pass updated choices to the template
+        "selected_location": location_id,  # Keep previous selection
+    })
+"""
+
+class PatientViewSet(viewsets.ModelViewSet):
+    """API endpoint for managing patients."""
+    queryset = Patient.objects.all()
+    serializer_class = PatientSerializer
+    #permission_classes = [IsAuthenticatedOrReadOnly] 
+
+    def perform_create(self, serializer):
+        serializer.save()
+    
+    def update(self, request, *args, **kwargs):
+        # custom edit logic here if needed
+        return super().update(request, *args, **kwargs)
+
+    def destroy(self, request, *args, **kwargs):
+        # custom delete logic here if needed
+        return super().destroy(request, *args, **kwargs)
+
+@require_GET
+def get_location_choices(request, location_id):
+    """Fetch location choices dynamically based on FindingLocationClassification."""
+    try:
+        location = FindingLocationClassification.objects.get(id=location_id)
+        location_choices = location.choices.all()
+        data = [{"id": choice.id, "name": choice.name} for choice in location_choices]
+        return JsonResponse({"location_choices": data})
+    except FindingLocationClassification.DoesNotExist:
+        return JsonResponse({"error": "Location classification not found", "location_choices": []}, status=404)
+
+@require_GET
+def get_morphology_choices(request, morphology_id):
+    """Fetch morphology choices dynamically based on FindingMorphologyClassification."""
+    try:
+        morphology_classification = FindingMorphologyClassification.objects.get(id=morphology_id)
+        morphology_choices = FindingMorphologyClassificationType.objects.filter(
+            id=morphology_classification.classification_type_id
+        )
+        data = [{"id": choice.id, "name": choice.name} for choice in morphology_choices]
+        return JsonResponse({"morphology_choices": data})
+    except ObjectDoesNotExist:
+        return JsonResponse({"error": "Morphology classification not found", "morphology_choices": []}, status=404)
+    except Exception as e:
+        return JsonResponse({"error": "Internal server error", "morphology_choices": []}, status=500)

endoreg_db/views/raw_video_meta_validation_views.py

@@ -0,0 +1,38 @@
+from rest_framework.views import APIView
+from rest_framework.response import Response
+from rest_framework import status
+from ..models import RawVideoFile
+from ..serializers.raw_video_meta_validation import VideoFileForMetaSerializer
+
+class VideoFileForMetaView(APIView):
+    """
+    API endpoint to fetch video metadata step-by-step.
+    If last_id is not provided  Returns the first video.
+     If last_id is given Returns the next available video.
+    """
+
+    ##need to change this fucntion , like the previous one
+
+    def get(self, request):
+        """
+        Handles:
+        First video if last_id is nt in query params.
+        Next video where id > last_id` if provided.
+        """
+        last_id = request.GET.get("last_id")  # Get last_id from query params (e.g., ?last_id=2)
+
+        try:
+            # If last_id is provided, fetch the next video where id > last_id
+            # id__gt is orm syntax which is equal to SELECT * FROM rawvideofile WHERE id > 2 ORDER BY id ASC LIMIT 1;
+
+            query_filter = {} if last_id is None else {"id__gt": int(last_id)}
+            video_entry = RawVideoFile.objects.select_related("sensitive_meta").filter(**query_filter).order_by('id').first()
+
+            if not video_entry:
+                return Response({"message": "No more videos available."}, status=status.HTTP_404_NOT_FOUND)
+
+            serializer = VideoFileForMetaSerializer(video_entry)
+            return Response(serializer.data, status=status.HTTP_200_OK)
+
+        except Exception as e:
+            return Response({"error": f"Internal server error: {str(e)}"}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)

endoreg_db/views/report_views.py

@@ -0,0 +1,96 @@
+from django.shortcuts import render
+from django.contrib.admin.views.decorators import staff_member_required
+
+@staff_member_required  # Ensures only staff members can access the page
+def start_examination(request):
+    return render(request, 'admin/start_examination.html')  # Loads the simple HTML page
+
+from django.shortcuts import render
+#from ..models.patient.patient_finding_location import PatientFindingLocation
+from ..models import FindingLocationClassification, FindingLocationClassificationChoice  # Correct models
+
+
+#need to implement one with json data after tesing whethe rthis works or not
+"""def get_location_choices(request, location_id):
+   
+    try:
+        # Ensure the location exists
+        location = FindingLocationClassification.objects.get(id=location_id)
+        # Get only choices related to the selected location classification
+        #location_choices = FindingLocationClassificationChoice.objects.filter(location_classification=location)
+        #its many to may relation so
+        location_choices = location.choices.all()
+        
+    except FindingLocationClassification.DoesNotExist:
+        location_choices = []
+
+    # Get previously selected values to retain them after reloading
+    selected_location = int(location_id) if location_id else None
+
+    return render(request, 'admin/patient_finding_intervention.html', {
+        "location_choices": location_choices,  # Pass updated choices to the template
+        "selected_location": location_id,  # Keep previous selection
+    })
+"""
+from django.shortcuts import render
+from rest_framework import viewsets
+from ..models import Patient
+from ..serializers import PatientSerializer
+from rest_framework.permissions import IsAuthenticatedOrReadOnly
+
+class PatientViewSet(viewsets.ModelViewSet):
+    """API endpoint for managing patients."""
+    queryset = Patient.objects.all()
+    serializer_class = PatientSerializer
+    permission_classes = [IsAuthenticatedOrReadOnly] 
+
+    def perform_create(self, serializer):
+        serializer.save()
+
+from django.http import JsonResponse
+from ..models import FindingLocationClassification, FindingLocationClassificationChoice
+
+def get_location_choices(request, location_id):
+    """
+    Fetch location choices dynamically based on the selected FindingLocationClassification (Location).
+    """
+    try:
+        location = FindingLocationClassification.objects.get(id=location_id)
+        location_choices = location.choices.all()  # Get choices via Many-to-Many relationship
+        data = [{"id": choice.id, "name": choice.name} for choice in location_choices]
+    except FindingLocationClassification.DoesNotExist:
+        data = []
+
+    return JsonResponse({"location_choices": data})
+
+from django.http import JsonResponse
+from ..models import FindingMorphologyClassification, FindingMorphologyClassificationChoice, FindingMorphologyClassificationType
+from django.core.exceptions import ObjectDoesNotExist
+
+
+
+def get_morphology_choices(request, morphology_id):
+    """
+    Fetch morphology choices dynamically based on the selected FindingMorphologyClassification.
+    """
+    try:
+        # Find the selected Morphology Classification
+        morphology_classification = FindingMorphologyClassification.objects.get(id=morphology_id)
+
+        # Fetch choices from FindingMorphologyClassificationType using classification_type_id
+        morphology_choices = FindingMorphologyClassificationType.objects.filter(
+            id=morphology_classification.classification_type_id
+        )
+
+        #  Cpnvert QuerySet to JSON
+        data = [{"id": choice.id, "name": choice.name} for choice in morphology_choices]
+
+        return JsonResponse({"morphology_choices": data})  #  Always return JSON
+
+    except ObjectDoesNotExist:
+        return JsonResponse({"error": "Morphology classification not found", "morphology_choices": []}, status=404)
+
+    except Exception as e:
+        print(f"Error fetching morphology choices: {e}")  # Debugging Log
+        return JsonResponse({"error": "Internal server error", "morphology_choices": []}, status=500)
+

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/views.py

@@ -1,3 +0,0 @@
-from django.shortcuts import render
-
-# Create your views here.