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

endoreg_db/models/data_file/import_classes/raw_video.py

@@ -1,46 +1,70 @@
-from django.db import models
+import shutil
+import subprocess
 from pathlib import Path
-from collections import defaultdict, Counter
+from django.db import models
+from typing import TYPE_CHECKING, List, Tuple
+
+from icecream import ic
+from tqdm import tqdm
+import cv2
+from django.core.validators import FileExtensionValidator
+from django.core.files.storage import FileSystemStorage
+
+from endoreg_db.utils.validate_endo_roi import validate_endo_roi
+from ..base_classes.utils import (
+    anonymize_frame,
+    RAW_VIDEO_DIR_NAME,
+    VIDEO_DIR,
+    STORAGE_LOCATION,
+)
+from ..base_classes.abstract_video import AbstractVideoFile
+
+if TYPE_CHECKING:
+    # import Queryset
+    from django.db.models import QuerySet
+    from endoreg_db.models import (
+        SensitiveMeta,
+        LabelVideoSegment,
+    )
 
-from endoreg_db.utils.hashs import get_video_hash
-from endoreg_db.utils.file_operations import get_uuid_filename
-from endoreg_db.utils.ocr import extract_text_from_rois
 
-import shutil
-import os
-import subprocess
+# pylint: disable=attribute-defined-outside-init,no-member
+class RawVideoFile(AbstractVideoFile):
+    """ """
 
-from ..metadata import VideoMeta, SensitiveMeta
+    file = models.FileField(
+        upload_to=RAW_VIDEO_DIR_NAME,
+        validators=[FileExtensionValidator(allowed_extensions=["mp4"])],  # FIXME
+        storage=FileSystemStorage(location=STORAGE_LOCATION.resolve().as_posix()),
+    )
 
-class RawVideoFile(models.Model):
-    uuid = models.UUIDField()
-    file = models.FileField(upload_to="raw_data/")
-    
-    sensitive_meta = models.OneToOneField(
-        "SensitiveMeta", on_delete=models.CASCADE, blank=True, null=True
-    ) 
+    patient = models.ForeignKey(
+        "Patient", on_delete=models.SET_NULL, blank=True, null=True
+    )
 
-    center = models.ForeignKey("Center", on_delete=models.CASCADE)
-    processor = models.ForeignKey(
-        "EndoscopyProcessor", on_delete=models.CASCADE, blank=True, null=True
+    sensitive_meta = models.ForeignKey(
+        "SensitiveMeta",
+        on_delete=models.SET_NULL,
+        related_name="raw_videos",
+        null=True,
+        blank=True,
     )
-    video_meta = models.OneToOneField(
-        "VideoMeta", on_delete=models.CASCADE, blank=True, null=True
+
+    video = models.ForeignKey(
+        "Video",
+        on_delete=models.SET_NULL,
+        related_name="raw_videos",
+        null=True,
+        blank=True,
     )
-    original_file_name = models.CharField(max_length=255)
-    video_hash = models.CharField(max_length=255, unique=True)
-    uploaded_at = models.DateTimeField(auto_now_add=True)
-
-    # Frame Extraction States
-    state_frames_required = models.BooleanField(default=True)
-    state_frames_extracted = models.BooleanField(default=False)
-
-    # Video
-    ## Prediction
-    state_initial_prediction_required = models.BooleanField(default=True)
-    state_initial_prediction_completed = models.BooleanField(default=False)
-    state_initial_prediction_import_required = models.BooleanField(default=True)
-    state_initial_prediction_import_completed = models.BooleanField(default=False)
+
+    if TYPE_CHECKING:
+        sensitive_meta: "SensitiveMeta"
+        label_video_segments: "QuerySet[LabelVideoSegment]"
+
+    # Crop Frames
+    state_anonymized_frames_generated = models.BooleanField(default=False)
+
     ## OCR
     state_ocr_required = models.BooleanField(default=True)
     state_ocr_completed = models.BooleanField(default=False)
@@ -50,294 +74,215 @@ class RawVideoFile(models.Model):
 
     state_sensitive_data_retrieved = models.BooleanField(default=False)
 
-    # Dataset complete?
-    state_histology_required = models.BooleanField(blank=True, null=True)
-    state_histology_available = models.BooleanField(default=False)
-    state_follow_up_intervention_required = models.BooleanField(blank=True, null=True)
-    state_follow_up_intervention_available = models.BooleanField(default=False)
-    state_dataset_complete = models.BooleanField(default=False)
-
-    # Finalizing for Upload
-    state_anonym_video_required = models.BooleanField(default=True)
-    state_anonym_video_performed = models.BooleanField(default=False)
-    state_original_reports_deleted = models.BooleanField(default=False)
-    state_original_video_deleted = models.BooleanField(default=False)
-    state_finalized = models.BooleanField(default=False)
-
-    frame_dir = models.CharField(max_length=255)
-    prediction_dir = models.CharField(max_length=255)
-
-    @classmethod
-    def create_from_file(
-        cls,
-        file_path: Path,
-        video_dir: Path,
-        center_name: str,
-        processor_name: str,
-        frame_dir_parent: Path,
-        save: bool = True,
-    ):
-        from endoreg_db.models import Center, EndoscopyProcessor
-
-        print(f"Creating RawVideoFile from {file_path}")
-        original_file_name = file_path.name
-        # Rename and and move
-
-        new_file_name, uuid = get_uuid_filename(file_path)
-        framedir: Path = frame_dir_parent / str(uuid)
-
-        if not framedir.exists():
-            framedir.mkdir(parents=True, exist_ok=True)
-
-        if not video_dir.exists():
-            video_dir.mkdir(parents=True, exist_ok=True)
-
-        video_hash = get_video_hash(file_path)
-
-        center = Center.objects.get(name=center_name)
-        assert center is not None, "Center must exist"
-
-        processor = EndoscopyProcessor.objects.get(name=processor_name)
-        assert processor is not None, "Processor must exist"
-
-        new_filepath = video_dir / new_file_name
-
-        print(f"Moving {file_path} to {new_filepath}")
-        shutil.move(file_path.resolve().as_posix(), new_filepath.resolve().as_posix())
-        print(f"Moved to {new_filepath}")
-
-        # Make sure file was transferred correctly and hash is correct
-        if not new_filepath.exists():
-            print(f"File {file_path} was not transferred correctly to {new_filepath}")
-            return None
-
-        new_hash = get_video_hash(new_filepath)
-        if new_hash != video_hash:
-            print(f"Hash of file {file_path} is not correct")
-            return None
-
-        # make sure that no other file with the same hash exists
-        if cls.objects.filter(video_hash=video_hash).exists():
-            # log and print warnint
-            print(f"File with hash {video_hash} already exists")
-            return None
-
-        else:
-            print(center)
-            # Create a new instance of RawVideoFile
-            raw_video_file = cls(
-                uuid=uuid,
-                file=new_filepath.resolve().as_posix(),
-                center=center,
-                processor=processor,
-                original_file_name=original_file_name,
-                video_hash=video_hash,
-                frame_dir=framedir.as_posix(),
-            )
-
-            # Save the instance to the database
-            raw_video_file.save()
+    # Censor Outside
+    state_censor_outside_required = models.BooleanField(default=True)
+    state_censor_outside_completed = models.BooleanField(default=False)
+    state_make_anonymized_video_required = models.BooleanField(default=True)
+    state_make_anonymized_video_completed = models.BooleanField(default=False)
+
+    def get_anonymized_video_path(self):
+        video_dir = VIDEO_DIR
+        video_suffix = Path(self.file.path).suffix
+        video_name = f"{self.uuid}{video_suffix}"
+        anonymized_video_name = f"TMP_anonymized_{video_name}"
+        anonymized_video_path = video_dir / anonymized_video_name
+
+        return anonymized_video_path
+
+    def censor_outside_frames(self):
+        assert self.state_frames_extracted, "Frames not extracted"
+        assert self.state_initial_prediction_completed, (
+            "Initial prediction not completed"
+        )
+        assert self.state_sensitive_data_retrieved, "Sensitive data not retrieved"
+
+        ic(
+            "WARNING: Outside validation is not yet implemented and automatically set to true in this function"
+        )
+
+        self.state_outside_validated = True
+        self.save()
 
-            return raw_video_file
+        assert self.state_outside_validated, "Outside validation not completed"
 
-    def __str__(self):
-        return self.file.name
+        outside_frame_paths = self.get_outside_frame_paths()
 
-    def get_endo_roi(self):
-        endo_roi = self.video_meta.get_endo_roi()
-        return endo_roi
+        if not outside_frame_paths:
+            ic("No outside frames found")
 
-    # video meta should be created when video file is created
-    def save(self, *args, **kwargs):
-        if self.video_meta is None:
-            center = self.center
-            processor = self.processor
-            self.video_meta = VideoMeta.objects.create(
-                center=center, processor=processor
-            )
-            self.video_meta.initialize_ffmpeg_meta(self.file.path)
-        super(RawVideoFile, self).save(*args, **kwargs)
-
-    def extract_frames(
-        self,
-        quality: int = 2,
-        frame_dir: Path = None,
-        overwrite: bool = False,
-        ext="jpg",
-    ):
-        """
-        Extract frames from the video file and save them to the frame_dir.
-        For this, ffmpeg must be available in in the current environment.
-        """
-        if frame_dir is None:
-            frame_dir = Path(self.frame_dir)
         else:
-            frame_dir = Path(frame_dir)
+            ic(f"Found {len(outside_frame_paths)} outside frames")
+            # use cv2 to replace all outside frames with completely black frames
 
-        if not frame_dir.exists():
-            frame_dir.mkdir(parents=True, exist_ok=True)
+            for frame_path in tqdm(outside_frame_paths):
+                frame = cv2.imread(frame_path.as_posix())
+                frame.fill(0)
+                cv2.imwrite(frame_path.as_posix(), frame)
 
-        if not overwrite and len(list(frame_dir.glob("*.jpg"))) > 0:
-            print(f"Frames already extracted for {self.file.name}")
-            return
+        self.state_censor_outside_required = False
+        self.state_censor_outside_completed = True
+        self.save()
 
-        video_path = Path(self.file.path).resolve().as_posix()
+    def get_anonymized_frame_dir(self):
+        anonymized_frame_dir = Path(self.frame_dir).parent / f"tmp_{self.uuid}"
+        return anonymized_frame_dir
 
-        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}"),
-        ]
+    def make_temporary_anonymized_frames(self) -> Tuple[Path, List[Path]]:
+        anonymized_frame_dir = self.get_anonymized_frame_dir()
 
-        # Ensure FFmpeg is available
-        if not shutil.which("ffmpeg"):
-            raise EnvironmentError(
-                "FFmpeg could not be found. Ensure it is installed and in your PATH."
-            )
+        assert self.state_frames_extracted, "Frames not extracted"
+        assert self.processor, "Processor not set"
 
-        # Extract frames from the video file
-        # Execute the command
-        result = subprocess.run(command, capture_output=True, text=True)
-        if result.returncode != 0:
-            raise Exception(f"Error extracting frames: {result.stderr}")
+        anonymized_frame_dir.mkdir(parents=True, exist_ok=True)
+        endo_roi = self.get_endo_roi()
+        assert validate_endo_roi(endo_roi), "Endoscope ROI is not valid"
+        generated_frame_paths = []
 
-        self.state_frames_extracted = True
+        all_frames = self.frames.all()
+        outside_frames = self.get_outside_frames()  #
+        outside_frame_numbers = [frame.frame_number for frame in outside_frames]
 
-        return f"Frames extracted to {frame_dir} ({frame_path_string}) with quality {quality}"
+        # anonymize frames: copy endo-roi content while making other pixels black. (frames are Path objects to jpgs or pngs)
+        for frame in tqdm(all_frames):
+            frame_path = Path(frame.image.path)
+            frame_name = frame_path.name
+            frame_number = frame.frame_number
 
-    def delete_frames(self):
-        """
-        Delete frames extracted from the video file.
-        """
-        frame_dir = Path(self.frame_dir)
-        if frame_dir.exists():
-            shutil.rmtree(frame_dir)
-            self.state_frames_extracted = False
-            self.save()
-            return f"Frames deleted from {frame_dir}"
-        else:
-            return f"No frames to delete for {self.file.name}"
+            if frame_number in outside_frame_numbers:
+                all_black = True
+            else:
+                all_black = False
 
-    def get_frame_path(self, n: int = 0):
-        """
-        Get the path to the n-th frame extracted from the video file.
-        Note that the frame numbering starts at 1 in our naming convention.
-        """
-        # Adjust index
-        n = n + 1
+            target_frame_path = anonymized_frame_dir / frame_name
+            anonymize_frame(
+                frame_path, target_frame_path, endo_roi, all_black=all_black
+            )
+            generated_frame_paths.append(target_frame_path)
 
-        frame_dir = Path(self.frame_dir)
-        return frame_dir / f"frame_{n:07d}.jpg"
-    
-    def get_frame_paths(self):
-        if not self.state_frames_extracted:
-            return None
-        frame_dir = Path(self.frame_dir)
-        paths = [p for p in frame_dir.glob('*')]
-        indices = [int(p.stem.split("_")[1]) for p in paths]
-        path_index_tuples = list(zip(paths, indices))
-        # sort ascending by index
-        path_index_tuples.sort(key=lambda x: x[1])
-        paths, indices = zip(*path_index_tuples)
-
-        return paths
-
-    def get_prediction_dir(self):
-        return Path(self.prediction_dir)
-
-    def get_predictions_path(self, suffix = ".json"):
-        pred_dir = self.get_prediction_dir()
-        return pred_dir.joinpath("predictions").with_suffix(suffix)
-    
-    def get_smooth_predictions_path(self, suffix = ".json"):
-        pred_dir = self.get_prediction_dir()
-        return pred_dir.joinpath("smooth_predictions").with_suffix(suffix)
-    
-    def get_binary_predictions_path(self, suffix = ".json"):
-        pred_dir = self.get_prediction_dir()
-        return pred_dir.joinpath("binary_predictions").with_suffix(suffix)
-    
-    def get_raw_sequences_path(self, suffix = ".json"):
-        pred_dir = self.get_prediction_dir()
-        return pred_dir.joinpath("raw_sequences").with_suffix(suffix)
-
-    def get_filtered_sequences_path(self, suffix=".json"):
-        pred_dir = self.get_prediction_dir()
-        return pred_dir.joinpath("filtered_sequences").with_suffix(suffix)
-
-    def extract_text_information(self, frame_fraction: float = 0.001):
+        return anonymized_frame_dir, generated_frame_paths
+
+    def make_anonymized_video(self):
         """
-        Extract text information from the video file.
-        Makes sure that frames are extracted and then processes the frames.
-        gets all frames from frame_dir and selects a fraction of them to process (at least 1)
+        Make an anonymized video from the anonymized frames.
         """
-        if not self.state_frames_extracted:
-            print(f"Frames not extracted for {self.file.name}")
-            return None
 
-        processor = self.processor
+        assert self.state_initial_prediction_completed, (
+            "Initial prediction not completed"
+        )
+        assert self.state_sensitive_data_retrieved, "Sensitive data not retrieved"
 
-        frame_dir = Path(self.frame_dir)
-        frames = list(frame_dir.glob("*"))
-        n_frames = len(frames)
-        n_frames_to_process = max(1, int(frame_fraction * n_frames))
-
-        # Select evenly spaced frames
-        frames = frames[:: n_frames // n_frames_to_process]
+        ic(
+            "WARNING: Outside validation is not yet implemented and automatically set to true in this function"
+        )
+        self.state_outside_validated = True
+        self.save()
 
-        # extract text from each frame and store the value to
-        # defaultdict of lists.
-        # Then, extract the most frequent value from each list
-        # Finally, return the dictionary of most frequent values
+        assert self.state_outside_validated, "Outside validation not completed"
 
-        # Create a defaultdict to store the extracted text from each ROI
-        rois_texts = defaultdict(list)
+        _anonymized_frame_dir, generated_frame_paths = (
+            self.make_temporary_anonymized_frames()
+        )
 
-        print(f"Processing {n_frames_to_process} frames from {self.file.name}")
-        # Process frames
-        for frame_path in frames[:n_frames_to_process]:
-            extracted_texts = extract_text_from_rois(frame_path, processor)
-            for roi, text in extracted_texts.items():
-                rois_texts[roi].append(text)
+        anonymized_video_path = self.get_anonymized_video_path()
+        # if anonymized video already exists, delete it
+        if anonymized_video_path.exists():
+            anonymized_video_path.unlink()
 
-        # Get the most frequent text values for each ROI using Counter
-        for key in rois_texts.keys():
-            counter = Counter([text for text in rois_texts[key] if text])
-            rois_texts[key] = counter.most_common(1)[0][0] if counter else None
+        # Use ffmpeg and the frame paths to create a video
+        fps = self.get_fps()
+        height, width = cv2.imread(generated_frame_paths[0].as_posix()).shape[:2]
+        ic("Assembling anonymized video")
+        ic(f"Frame width: {width}, height: {height}")
+        ic(f"FPS: {fps}")
 
-        return rois_texts
+        command = [
+            "ffmpeg",
+            "-y",
+            "-pattern_type",
+            "glob",
+            "-f",
+            "image2",
+            "-framerate",
+            str(fps),
+            "-i",
+            f"{generated_frame_paths[0].parent.as_posix()}/frame_[0-9]*.jpg",
+            "-c:v",
+            "libx264",
+            "-pix_fmt",
+            "yuv420p",
+            "-vf",
+            f"scale={width}:{height}",
+            anonymized_video_path.as_posix(),
+        ]
 
-    def update_text_metadata(self, ocr_frame_fraction=0.001):
-        print(f"Updating metadata for {self.file.name}")
-        texts = self.extract_text_information(ocr_frame_fraction)
+        subprocess.run(command, check=True)
+        ic(f"Anonymized video saved at {anonymized_video_path}")
 
-        self.sensitive_meta = SensitiveMeta.create_from_dict(texts)
-        self.state_sensitive_data_retrieved = True
+        self.state_make_anonymized_video_required = False
+        self.state_make_anonymized_video_completed = True
         self.save()
 
-        # Resulting dict depends on defined ROIs for this processor type!
-
-    def update_video_meta(self):
-        video_meta = self.video_meta
-        video_path = Path(self.file.path)
-
-        if video_meta is None:
-            video_meta = VideoMeta.create_from_video(video_path)
-            self.video_meta = video_meta
-            self.save()
+        return anonymized_video_path, generated_frame_paths
 
+    def delete_frames_anonymized(self):
+        """
+        Delete anonymized frames extracted from the video file.
+        """
+        frame_dir = Path(self.frame_dir)
+        anonymized_frame_dir = frame_dir.parent / f"anonymized_{self.uuid}"
+        if anonymized_frame_dir.exists():
+            shutil.rmtree(anonymized_frame_dir)
+            return f"Anonymized frames deleted from {anonymized_frame_dir}"
         else:
-            video_meta.update_meta(video_path)
-
-    def get_fps(self):
-        if self.video_meta is None:
-            self.update_video_meta()
-
-        if self.video_meta.ffmpeg_meta is None:
-            self.video_meta.initialize_ffmpeg_meta(self.file.path)
+            return f"No anonymized frames to delete for {self.file.name}"
+
+    def get_or_create_video(self):
+        from endoreg_db.models import Video, Patient, PatientExamination
+
+        video = self.video
+        expected_path = self.get_anonymized_video_path()
+        if not video:
+            video_hash = self.video_hash
+            if Video.objects.filter(video_hash=video_hash).exists():
+                video = Video.objects.filter(video_hash=video_hash).first()
+
+            else:
+                if not expected_path.exists():
+                    ic(
+                        f"No anonymized video found at {expected_path}, Creating new one"
+                    )
+                    video_path, frame_paths = self.make_anonymized_video()
+
+                else:
+                    ic(f"Anonymized video found at {expected_path}")
+                    video_path = expected_path
+                    frame_dir = self.get_anonymized_frame_dir()
+                    ic(f"Frame dir: {frame_dir}")
+                    frame_paths = list(frame_dir.glob("*.jpg"))
+                    ic(f"Found {len(frame_paths)} frames")
+
+                video_object = Video.create_from_file(
+                    video_path,
+                    self.center,
+                    self.processor,
+                    video_dir=VIDEO_DIR,
+                    frame_paths=frame_paths,
+                )
+
+                ex: PatientExamination = self.sensitive_meta.pseudo_examination
+                pat: Patient = self.sensitive_meta.pseudo_patient
+                video_object.examination = ex
+                video_object.patient = pat
+
+                self.video = video_object
+                self.save()
+                video_object.sync_from_raw_video()
+
+                ic(f"Video object created: {video_object}")
+                return video_object
+
+            self.video = video
+            self.save()
 
-        return self.video_meta.get_fps()
+        # self.vi
+        return video

endoreg_db/models/data_file/metadata/__init__.py

@@ -1,3 +1,13 @@
 from .sensitive_meta import SensitiveMeta
 from .pdf_meta import PdfMeta, PdfType
 from .video_meta import VideoMeta, FFMpegMeta, VideoImportMeta
+
+
+__all__ = [
+    "SensitiveMeta",
+    "PdfMeta",
+    "PdfType",
+    "VideoMeta",
+    "FFMpegMeta",
+    "VideoImportMeta",
+]

endoreg_db/models/data_file/metadata/pdf_meta.py

@@ -52,6 +52,10 @@ class PdfType(models.Model):
     
         return summary
 
+    @classmethod
+    def default_pdf_type(cls):
+        return PdfType.objects.get(name="ukw-endoscopy-examination-report-generic")
+
 class PdfMeta(models.Model):
     pdf_type = models.ForeignKey(PdfType, on_delete=models.CASCADE)
     date = models.DateField()