endoreg-db 0.1.0__py3-none-any.whl → 0.2.0__py3-none-any.whl

endoreg_db/models/ai_model/model_meta.py

@@ -0,0 +1,24 @@
+from django.db import models
+
+class ModelMetaManager(models.Manager):
+    # natural key is name and version
+    def get_by_natural_key(self, name, version):
+        return self.get(name=name, version=version)
+
+class ModelMeta(models.Model):
+    name = models.CharField(max_length=255)
+    version = models.CharField(max_length=255)
+    type = models.ForeignKey("ModelType", on_delete=models.CASCADE, related_name="models")
+    labelset = models.ForeignKey("LabelSet", on_delete=models.CASCADE, related_name="models")
+    weights = models.FileField(upload_to='weights/')
+    
+    description = models.TextField(blank=True, null=True)
+    date_created = models.DateTimeField(auto_now_add=True)
+    objects = ModelMetaManager()
+
+    def natural_key(self):
+        return (self.name, self.version)
+
+    def __str__(self):
+        return f"{self.name} (v: {self.version})"
+

endoreg_db/models/ai_model/model_type.py

@@ -0,0 +1,26 @@
+from django.db import models
+from django.core import serializers
+
+class ModelTypeManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+    
+class ModelType(models.Model):
+    """
+    A class representing a model type.
+
+    Attributes:
+        name (str): The name of the model type.
+        description (str): A description of the model type.
+
+    """
+    name = models.CharField(max_length=255)
+    description = models.TextField(blank=True, null=True)
+
+    objects = ModelTypeManager()
+
+    def natural_key(self):
+        return (self.name,)
+
+    def __str__(self):
+        return self.name

endoreg_db/models/ai_model/utils.py

@@ -0,0 +1,8 @@
+from .model_meta import ModelMeta
+
+# get latest model meta by model name
+
+# TODO MOVE THIS TO A QUERY FILE
+def get_latest_model_meta_by_model_name(model_name):
+    model_meta = ModelMeta.objects.filter(name=model_name).order_by('-version').first()
+    return model_meta

endoreg_db/models/annotation/__init__.py

@@ -0,0 +1,2 @@
+from .image_classification import ImageClassificationAnnotation
+from .binary_classification_annotation_task import LegacyBinaryClassificationAnnotationTask, BinaryClassificationAnnotationTask

endoreg_db/models/annotation/binary_classification_annotation_task.py

@@ -0,0 +1,80 @@
+from django.db import models
+from rest_framework import serializers
+from ..label import Label
+from ..data_file.video_segment import LegacyLabelVideoSegment
+from .image_classification import ImageClassificationAnnotation
+
+ANNOTATION_PER_S_THRESHOLD = 2
+
+def clear_finished_legacy_tasks():
+    # fetch all BinaryClassificationAnnotationTasks that are finished and delete them
+    tasks = LegacyBinaryClassificationAnnotationTask.objects.filter(finished=True)
+
+    # delete tasks with a bulk operation
+    tasks.delete()
+
+def get_legacy_binary_classification_annotation_tasks_by_label(label:Label, n:int=100, legacy=False):
+    clear_finished_legacy_tasks()
+
+    if legacy:
+        # fetch all LegacyLabelVideoSegments with the given label
+        _segments = LegacyLabelVideoSegment.objects.filter(label=label)
+        frames_for_tasks = []
+
+        for segment in _segments:
+            # check if the segment has already been annotated
+            annotations = list(ImageClassificationAnnotation.objects.filter(legacy_frame__in=segment.get_frames(), label=label))
+            segment_len_in_s = segment.get_segment_len_in_s()
+
+            target_annotation_number = segment_len_in_s * ANNOTATION_PER_S_THRESHOLD
+
+            if len(annotations) < target_annotation_number:
+                get_frame_number = int(target_annotation_number - len(annotations))
+                frames = segment.get_frames_without_annotation(get_frame_number)
+                frames_for_tasks.extend(frames)
+
+            if len(frames_for_tasks) >= n:
+                break
+
+        # create tasks
+        tasks = []
+        for frame in frames_for_tasks:
+
+            # get_or_create task
+            task, created = LegacyBinaryClassificationAnnotationTask.objects.get_or_create(
+                label=label,
+                image_path=frame.image.path,
+                frame_id=frame.pk,
+            )
+        
+
+class AbstractBinaryClassificationAnnotationTask(models.Model):
+    label = models.ForeignKey("Label", on_delete=models.CASCADE)
+    is_finished = models.BooleanField(default=False)
+    date_created = models.DateTimeField(auto_now_add=True)
+    date_finished = models.DateTimeField(blank=True, null=True)
+    image_path = models.CharField(max_length=255, blank=True, null=True)
+    image_type = models.CharField(max_length=255, blank=True, null=True)
+    frame_id = models.IntegerField(blank=True, null=True)
+    labelstudio_project_id = models.IntegerField(blank=True, null=True)
+    labelstudio_task_id = models.IntegerField(blank=True, null=True)
+
+    class Meta:
+        abstract = True
+
+class BinaryClassificationAnnotationTask(AbstractBinaryClassificationAnnotationTask):
+    frame = models.ForeignKey("Frame", on_delete=models.CASCADE, related_name="binary_classification_annotation_tasks")
+    image_type = models.CharField(max_length=255, default="frame")
+
+    def get_frame(self):
+        return self.video_segment.get_frame_by_id(self.frame_id)
+
+class LegacyBinaryClassificationAnnotationTask(AbstractBinaryClassificationAnnotationTask):
+    frame = models.ForeignKey("LegacyFrame", on_delete=models.CASCADE, related_name="binary_classification_annotation_tasks")
+    image_type = models.CharField(max_length=255, default="legacy")
+
+    def get_frame(self):
+        return self.frame
+
+
+

endoreg_db/models/annotation/image_classification.py

@@ -0,0 +1,27 @@
+from django.db import models
+
+class ImageClassificationAnnotation(models.Model):
+    """
+    A class representing an image classification annotation.
+
+    Attributes:
+        label (str): The label that was assigned to the image.
+        confidence (float): The confidence that the label is correct.
+        annotator (User): The user that created this annotation.
+        date (datetime.datetime): The date and time when this annotation was created.
+
+    """
+    # Foreign keys to Frame, LegacyFrame, and LegacyImage (only one of these should be set)
+    frame = models.ForeignKey("Frame", on_delete=models.CASCADE, blank=True, null=True, related_name="image_classification_annotations")
+    legacy_frame = models.ForeignKey("LegacyFrame", on_delete=models.CASCADE, blank=True, null=True, related_name="image_classification_annotations")
+    legacy_image = models.ForeignKey("LegacyImage", on_delete=models.CASCADE, blank=True, null=True, related_name="image_classification_annotations")
+
+    label = models.ForeignKey("Label", on_delete=models.CASCADE, related_name="image_classification_annotations")
+    value = models.BooleanField()
+    annotator = models.CharField(max_length=255)
+    date_created = models.DateTimeField(auto_now_add=True)
+    date_modified = models.DateTimeField(auto_now=True)
+
+    def __str__(self):
+        return self.label.name + " - " + str(self.value)
+    

endoreg_db/models/center.py

@@ -0,0 +1,19 @@
+from django.db import models
+
+class CenterManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+
+class Center(models.Model):
+    objects = CenterManager()
+
+    # import_id = models.IntegerField(primary_key=True)
+    name = models.CharField(max_length=255)
+    name_de = models.CharField(max_length=255, blank=True, null=True)
+    name_en = models.CharField(max_length=255, blank=True, null=True)
+
+    def natural_key(self):
+        return (self.name,)
+    
+    def __str__(self):
+        return self.name

endoreg_db/models/data_file/__init__.py

@@ -0,0 +1,4 @@
+from .frame import Frame, LegacyFrame
+from .report_file import ReportFile
+from .video import Video, LegacyVideo, VideoImportMeta
+from .video_segment import LegacyLabelVideoSegment, LabelVideoSegment

endoreg_db/models/data_file/base_classes/__init__.py

@@ -0,0 +1,3 @@
+from .abstract_frame import AbstractFrame
+from .abstract_video import AbstractVideo
+

endoreg_db/models/data_file/base_classes/abstract_frame.py

@@ -0,0 +1,51 @@
+from endoreg_db.models.annotation.image_classification import ImageClassificationAnnotation
+from endoreg_db.models.label.label import Label
+
+from django.db import models
+
+
+class AbstractFrame(models.Model):
+    video = None # Placeholder for the video field, to be defined in derived classes
+    frame_number = models.IntegerField()
+    # Add any other fields you need to store frame-related information
+    image = models.ImageField(upload_to="frames")  # Or some other field type, depending on how you're storing the frame
+    suffix = models.CharField(max_length=255)
+    # ImageClassificationAnnotation has a foreign key to this model (related name: image_classification_annotations)
+
+    class Meta:
+        # Ensure that for each video, the frame_number is unique
+        abstract = True
+        unique_together = ('video', 'frame_number')
+        # Optimize for retrieval in frame_number order
+        indexes = [models.Index(fields=['video', 'frame_number'])]
+
+
+    def __str__(self):
+        return self.video.file.path + " - " + str(self.frame_number)
+
+    def get_frame_model(self):
+        assert 1 == 2, "This method should be overridden in derived classes"
+
+    def get_classification_annotations(self):
+        """
+        Get all image classification annotations for this frame.
+        """
+        return ImageClassificationAnnotation.objects.filter(frame=self)
+
+    def get_classification_annotations_by_label(self, label:Label):
+        """
+        Get all image classification annotations for this frame with the given label.
+        """
+        return ImageClassificationAnnotation.objects.filter(frame=self, label=label)
+
+    def get_classification_annotations_by_value(self, value:bool):
+        """
+        Get all image classification annotations for this frame with the given value.
+        """
+        return ImageClassificationAnnotation.objects.filter(frame=self, value=value)
+
+    def get_classification_annotations_by_label_and_value(self, label:Label, value:bool):
+        """
+        Get all image classification annotations for this frame with the given label and value.
+        """
+        return ImageClassificationAnnotation.objects.filter(frame=self, label=label, value=value)

endoreg_db/models/data_file/base_classes/abstract_video.py

@@ -0,0 +1,200 @@
+# import cv2
+from PIL import Image
+from django.core.files.base import ContentFile
+from django.db import models, transaction
+from tqdm import tqdm
+import io
+from datetime import date
+
+BATCH_SIZE = 1000
+
+class AbstractVideo(models.Model):
+    file = models.FileField(upload_to="raw_videos", blank=True, null=True)
+    video_hash = models.CharField(max_length=255, unique=True)
+    patient = models.ForeignKey("Patient", on_delete=models.CASCADE, blank=True, null=True)
+    date = models.DateField(blank=True, null=True)
+    suffix = models.CharField(max_length=255)
+    fps = models.FloatField()
+    duration = models.FloatField()
+    width = models.IntegerField()
+    height = models.IntegerField()
+    endoscope_image_x = models.IntegerField(blank=True, null=True)
+    endoscope_image_y = models.IntegerField(blank=True, null=True)
+    endoscope_image_width = models.IntegerField(blank=True, null=True)
+    endoscope_image_height = models.IntegerField(blank=True, null=True)
+    center = models.ForeignKey("Center", on_delete=models.CASCADE, blank=True, null=True)
+    endoscopy_processor = models.ForeignKey("EndoscopyProcessor", on_delete=models.CASCADE, blank=True, null=True)
+    frames_extracted = models.BooleanField(default=False)
+
+    meta = models.JSONField(blank=True, null=True)
+
+    class Meta:
+        abstract = True
+
+    def get_roi_endoscope_image(self):
+        return {
+            'x': self.endoscope_image_content_x,
+            'y': self.endoscope_image_content_y,
+            'width': self.endoscope_image_content_width,
+            'height': self.endoscope_image_content_height,
+        }
+
+    def initialize_metadata_in_db(self, video_meta=None):
+        if not video_meta:
+            video_meta = self.meta
+        self.set_examination_date_from_video_meta(video_meta)
+        self.patient, created = self.get_or_create_patient(video_meta)
+        self.save()
+
+    def get_or_create_patient(self, video_meta=None):
+        from ...persons import Patient
+        if not video_meta:
+            video_meta = self.meta
+
+        patient_first_name = video_meta['patient_first_name']
+        patient_last_name = video_meta['patient_last_name']
+        patient_dob = video_meta['patient_dob']
+
+        # assert that we got all the necessary information
+        assert patient_first_name and patient_last_name and patient_dob, "Missing patient information"
+
+        patient, created = Patient.objects.get_or_create(
+            first_name=patient_first_name,
+            last_name=patient_last_name,
+            dob=patient_dob
+        )
+
+        return patient, created
+
+    def get_frame_model(self):
+        assert 1 == 2, "This method should be overridden in derived classes"
+
+    def get_video_model(self):
+        assert 1 == 2, "This method should be overridden in derived classes"
+
+    def get_frame_number(self):
+        """
+        Get the number of frames in the video.
+        """
+        frame_model = self.get_frame_model()
+        framecount = frame_model.objects.filter(video=self).count()
+        return framecount
+    
+    def set_frames_extracted(self, value:bool=True):
+        self.frames_extracted = value
+        self.save()
+        
+    def get_frames(self):
+        """
+        Retrieve all frames for this video in the correct order.
+        """
+        frame_model = self.get_frame_model()
+        return frame_model.objects.filter(video=self).order_by('frame_number')
+
+    def get_frame(self, frame_number):
+        """
+        Retrieve a specific frame for this video.
+        """
+        frame_model = self.get_frame_model()
+        return frame_model.objects.get(video=self, frame_number=frame_number)
+
+    def get_frame_range(self, start_frame_number:int, end_frame_number:int):
+        """
+        Expects numbers of start and stop frame.
+        Returns all frames of this video within the given range in ascending order.
+        """
+        frame_model = self.get_frame_model()
+        return frame_model.objects.filter(video=self, frame_number__gte=start_frame_number, frame_number__lte=end_frame_number).order_by('frame_number')
+
+    def _create_frame_object(self, frame_number, image_file):
+        frame_model = self.get_frame_model()
+        frame = frame_model(
+                video=self,
+                frame_number=frame_number,
+                suffix='jpg',
+            )
+        frame.image_file = image_file  # Temporary store the file-like object
+
+        return frame
+
+    def _bulk_create_frames(self, frames_to_create):
+        frame_model = self.get_frame_model()
+        with transaction.atomic():
+            frame_model.objects.bulk_create(frames_to_create)
+
+            # After the DB operation, save the ImageField for each object
+            for frame in frames_to_create:
+                frame_name = f"video_{self.id}_frame_{str(frame.frame_number).zfill(7)}.jpg"
+                frame.image.save(frame_name, frame.image_file)
+
+            # Clear the list for the next batch
+            frames_to_create = []
+
+    def set_examination_date_from_video_meta(self, video_meta=None):
+        if not video_meta:
+            video_meta = self.meta
+        date_str = video_meta['examination_date'] # e.g. 2020-01-01
+        if date_str:
+            self.date = date.fromisoformat(date_str)
+            self.save()
+
+    def extract_all_frames(self):
+        """
+        Extract all frames from the video and store them in the database.
+        Uses Django's bulk_create for more efficient database operations.
+        """
+        # Open the video file
+        video = cv2.VideoCapture(self.file.path)
+
+        # Initialize video properties
+        self.initialize_video_specs(video)
+
+        # Prepare for batch operation
+        frames_to_create = []
+
+        # Extract frames
+        for frame_number in tqdm(range(int(self.duration * self.fps))):
+            # Read the frame
+            success, image = video.read()
+            if not success:
+                break
+
+            # Convert the numpy array to a PIL Image object
+            pil_image = Image.fromarray(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
+
+            # Save the PIL Image to a buffer
+            buffer = io.BytesIO()
+            pil_image.save(buffer, format='JPEG')
+
+            # Create a file-like object from the byte data in the buffer
+            image_file = ContentFile(buffer.getvalue())
+
+            # Prepare Frame instance (don't save yet)
+            frame = self._create_frame_object(frame_number, image_file)
+            frames_to_create.append(frame)
+
+            # Perform bulk create when reaching BATCH_SIZE
+            if len(frames_to_create) >= BATCH_SIZE:
+                self._bulk_create_frames(frames_to_create)
+                frames_to_create = []
+
+
+        # Handle remaining frames
+        if frames_to_create:
+            self._bulk_create_frames(frames_to_create)
+            frames_to_create = []
+
+        # Close the video file
+        video.release()
+        self.set_frames_extracted(True)
+
+
+    def initialize_video_specs(self, video):
+        """
+        Initialize and save video metadata like framerate, dimensions, and duration.
+        """
+        self.fps = video.get(cv2.CAP_PROP_FPS)
+        self.width = int(video.get(cv2.CAP_PROP_FRAME_WIDTH))
+        self.height = int(video.get(cv2.CAP_PROP_FRAME_HEIGHT))
+        self.duration = video.get(cv2.CAP_PROP_FRAME_COUNT) / self.fps
+        self.save()

endoreg_db/models/data_file/frame.py

@@ -0,0 +1,45 @@
+from endoreg_db.models.annotation.image_classification import ImageClassificationAnnotation
+from endoreg_db.models.label.label import Label
+from .base_classes import AbstractFrame
+from django.db import models
+
+class Frame(AbstractFrame):
+    video = models.ForeignKey("Video", on_delete=models.CASCADE, related_name="frames")
+
+class LegacyFrame(AbstractFrame):
+    video = models.ForeignKey("LegacyVideo", on_delete=models.CASCADE, related_name='frames')
+    image = models.ImageField(upload_to="legacy_frames", blank=True, null=True)
+    suffix = models.CharField(max_length=255)
+    # ImageClassificationAnnotation has a foreign key to this model (related name: image_classification_annotations)
+
+    class Meta:
+        unique_together = ('video', 'frame_number')
+        indexes = [
+            models.Index(fields=['video', 'frame_number']),
+        ]
+
+    def get_classification_annotations(self):
+        """
+        Get all image classification annotations for this frame.
+        """
+        return ImageClassificationAnnotation.objects.filter(legacy_frame=self)
+
+    def get_classification_annotations_by_label(self, label:Label):
+        """
+        Get all image classification annotations for this frame with the given label.
+        """
+        return ImageClassificationAnnotation.objects.filter(legacy_frame=self, label=label)
+
+    def get_classification_annotations_by_value(self, value:bool):
+        """
+        Get all image classification annotations for this frame with the given value.
+        """
+        return ImageClassificationAnnotation.objects.filter(legacy_frame=self, value=value)
+
+    def get_classification_annotations_by_label_and_value(self, label:Label, value:bool):
+        """
+        Get all image classification annotations for this frame with the given label and value.
+        """
+        return ImageClassificationAnnotation.objects.filter(legacy_frame=self, label=label, value=value)
+
+    

endoreg_db/models/data_file/report_file.py

@@ -0,0 +1,88 @@
+from django.db import models
+from ..center import Center
+import hashlib
+from datetime import date, time
+
+class ReportFile(models.Model):
+    pdf = models.FileField(upload_to="raw_report_pdfs", blank=True, null=True)
+    pdf_hash = models.CharField(max_length=255, unique=True)
+    center = models.ForeignKey(Center, on_delete=models.CASCADE)
+    meta = models.JSONField(blank=True, null=True)
+    text = models.TextField(blank=True, null=True)
+    text_anonymized = models.TextField(blank=True, null=True)
+    patient = models.ForeignKey("Patient", on_delete=models.CASCADE, blank=True, null=True)
+    examiner = models.ForeignKey("Examiner", on_delete=models.CASCADE, blank=True, null=True)
+    date = models.DateField(blank=True, null=True)
+    time = models.TimeField(blank=True, null=True)
+
+    def get_pdf_hash(self):
+        pdf = self.pdf
+        pdf_hash = None
+
+        if pdf:
+            # Open the file in binary mode and read its contents
+            with pdf.open(mode='rb') as f:
+                pdf_contents = f.read()
+                # Create a hash object using SHA-256 algorithm
+                hash_object = hashlib.sha256(pdf_contents, usedforsecurity=False)
+                # Get the hexadecimal representation of the hash
+                pdf_hash = hash_object.hexdigest()
+                assert len(pdf_hash) <= 255, "Hash length exceeds 255 characters"
+
+        return pdf_hash
+
+    def initialize_metadata_in_db(self, report_meta=None):
+        if not report_meta:
+            report_meta = self.meta
+        self.set_examination_date_and_time(report_meta)
+        self.patient, created = self.get_or_create_patient(report_meta)
+        self.examiner, created = self.get_or_create_examiner(report_meta)
+        self.save()    
+
+    def get_or_create_patient(self, report_meta=None):
+        from ..persons import Patient
+        if not report_meta:
+            report_meta = self.meta
+        patient_first_name = report_meta['patient_first_name']
+        patient_last_name = report_meta['patient_last_name']
+        patient_dob = report_meta['patient_dob']
+
+        patient, created = Patient.objects.get_or_create(
+            first_name=patient_first_name,
+            last_name=patient_last_name,
+            dob=patient_dob
+        )
+
+        return patient, created
+    
+    def get_or_create_examiner(self, report_meta= None):
+        from ..persons import Examiner
+        if not report_meta:
+            report_meta = self.meta
+        examiner_first_name = report_meta['examiner_first_name']
+        examiner_last_name = report_meta['examiner_last_name']
+        examiner_center = self.center
+
+        examiner, created = Examiner.objects.get_or_create(
+            first_name=examiner_first_name,
+            last_name=examiner_last_name,
+            center=examiner_center
+        )
+
+        return examiner, created
+        
+    def set_examination_date_and_time(self, report_meta=None):
+        if not report_meta:
+            report_meta = self.meta
+        examination_date_str = report_meta['examination_date']
+        examination_time_str = report_meta['examination_time']
+
+        if examination_date_str:
+            # TODO: get django DateField compatible date from string (e.g. "2021-01-01")
+            self.date = date.fromisoformat(examination_date_str)
+        if examination_time_str:
+            # TODO: get django TimeField compatible time from string (e.g. "12:00")
+            self.time = time.fromisoformat(examination_time_str)
+        
+
+

endoreg_db/models/data_file/video/__init__.py

@@ -0,0 +1,7 @@
+from .video import (
+    Video,
+    LegacyVideo,
+)
+from .import_meta import (
+    VideoImportMeta,
+)

endoreg_db/models/data_file/video/import_meta.py

@@ -0,0 +1,25 @@
+from django.db import models
+
+class VideoImportMeta(models.Model):
+    processor = models.ForeignKey('EndoscopyProcessor', on_delete=models.CASCADE)
+    endoscope = models.ForeignKey('Endoscope', on_delete=models.CASCADE, blank=True, null=True)
+    center = models.ForeignKey('Center', on_delete=models.CASCADE)
+    video_anonymized = models.BooleanField(default=False)
+    video_patient_data_detected = models.BooleanField(default=False)
+    outside_detected = models.BooleanField(default=False)
+    patient_data_removed = models.BooleanField(default=False)
+    outside_removed = models.BooleanField(default=False)
+
+    def __str__(self):
+        result_html = ""
+
+        result_html += f"Processor: {self.processor.name}<br>"
+        result_html += f"Endoscope: {self.endoscope.name}<br>"
+        result_html += f"Center: {self.center.name}<br>"
+        result_html += f"Video anonymized: {self.video_anonymized}<br>"
+        result_html += f"Video patient data detected: {self.video_patient_data_detected}<br>"
+        result_html += f"Outside detected: {self.outside_detected}<br>"
+        result_html += f"Patient data removed: {self.patient_data_removed}<br>"
+        result_html += f"Outside removed: {self.outside_removed}<br>"
+        return result_html
+    

endoreg_db/models/data_file/video/video.py

@@ -0,0 +1,25 @@
+from ..base_classes import AbstractVideo
+from django.db import models
+
+from endoreg_db.models.data_file.frame import Frame
+from endoreg_db.models.data_file.frame import LegacyFrame
+
+BATCH_SIZE = 1000
+
+class Video(AbstractVideo):
+    import_meta = models.OneToOneField('VideoImportMeta', on_delete=models.CASCADE, blank=True, null=True)
+    def get_video_model(self):
+        return Video
+
+    def get_frame_model(self):
+        return Frame
+
+
+class LegacyVideo(AbstractVideo):
+    file = models.FileField(upload_to="legacy_videos", blank=True, null=True)
+
+    def get_video_model(self):
+        return LegacyVideo
+
+    def get_frame_model(self):
+        return LegacyFrame