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

endoreg_db/models/data_file/video_segment.py

@@ -0,0 +1,107 @@
+from django.db import models
+import numpy as np
+from ..annotation import ImageClassificationAnnotation
+
+def find_segments_in_prediction_array(prediction_array: np.array, min_frame_len: int):
+    """
+    Expects a prediction array of shape (num_frames) and a minimum frame length.
+    Returns a list of tuples (start_frame_number, end_frame_number) that represent the segments.
+    """
+    # Add False to the beginning and end to detect changes at the array boundaries
+    padded_prediction = np.pad(prediction_array, (1, 1), 'constant', constant_values=False)
+    
+    # Find the start points and end points of the segments
+    diffs = np.diff(padded_prediction.astype(int))
+    segment_starts = np.where(diffs == 1)[0]
+    segment_ends = np.where(diffs == -1)[0]
+    
+    # Filter segments based on min_frame_len
+    segments = [(start, end) for start, end in zip(segment_starts, segment_ends) if end - start >= min_frame_len]
+    
+    return segments
+
+class AbstractLabelVideoSegment(models.Model):
+    video = None # Placeholder for the video field, to be defined in derived classes
+    prediction_meta = None # Placeholder for the prediction_meta field, to be defined in derived classes
+    start_frame_number = models.IntegerField()
+    end_frame_number = models.IntegerField()
+    source = models.ForeignKey("InformationSource", on_delete=models.CASCADE)
+    label = models.ForeignKey("Label", on_delete=models.CASCADE)
+
+    class Meta:
+        abstract = True
+
+    def __str__(self):
+        return self.video.file.path + " Label - " + self.label.name + " - " + str(self.start_frame_number) + " - " + str(self.end_frame_number)
+    
+    def get_frames(self):
+        return self.video.get_frame_range(self.start_frame_number, self.end_frame_number)
+    
+    def get_annotations(self) -> ImageClassificationAnnotation.objects:
+        frames = self.get_frames()
+        annotations = ImageClassificationAnnotation.objects.filter(frame__in=frames, label=self.label)
+
+        return annotations
+    
+    def get_frames_without_annotation(self):
+        """
+        Get a frame without an annotation.
+        """
+        assert 1 == 2, "This method should be overridden in derived classes"
+
+    def get_segment_len_in_s(self):
+        return (self.end_frame_number - self.start_frame_number) / self.video.fps
+
+class LegacyLabelVideoSegment(AbstractLabelVideoSegment):
+    video = models.ForeignKey("LegacyVideo", on_delete=models.CASCADE)
+    prediction_meta = models.ForeignKey("LegacyVideoPredictionMeta", on_delete=models.CASCADE, related_name="video_segments")
+
+    def get_video_model(self):
+        from endoreg_db.models.data_file.video import LegacyVideo
+        return LegacyVideo
+
+    def get_annotations(self) -> ImageClassificationAnnotation.objects:
+        frames = self.get_frames()
+        annotations = ImageClassificationAnnotation.objects.filter(legacy_frame__in=frames, label=self.label)
+
+        return annotations
+
+    def get_frames_without_annotation(self, n_frames):
+        """
+        Get a frame without an annotation.
+        """
+        frames = self.get_frames()
+        annotations = ImageClassificationAnnotation.objects.filter(legacy_frame__in=frames, label=self.label)
+
+        annotated_frames = [annotation.legacy_frame for annotation in annotations]
+        frames_without_annotation = [frame for frame in frames if frame not in annotated_frames]
+
+        # draw n random frames
+        if len(frames_without_annotation) > n_frames:
+            frames_without_annotation = np.random.choice(frames_without_annotation, n_frames, replace=False)
+
+        return frames_without_annotation
+    
+class LabelVideoSegment(AbstractLabelVideoSegment):
+    video = models.ForeignKey("Video", on_delete=models.CASCADE)
+    prediction_meta = models.ForeignKey("VideoPredictionMeta", on_delete=models.CASCADE, related_name="video_segments")
+
+    def get_video_model(self):
+        from endoreg_db.models.data_file.video import Video
+        return Video
+
+    def get_frames_without_annotation(self, n_frames):
+        """
+        Get a frame without an annotation.
+        """
+        frames = self.get_frames()
+        annotations = ImageClassificationAnnotation.objects.filter(frame__in=frames, label=self.label)
+
+        annotated_frames = [annotation.frame for annotation in annotations]
+        frames_without_annotation = [frame for frame in frames if frame not in annotated_frames]
+
+        # draw n random frames
+        if len(frames_without_annotation) > n_frames:
+            frames_without_annotation = np.random.choice(frames_without_annotation, n_frames, replace=False)
+
+        return frames_without_annotation

endoreg_db/models/examination/__init__.py

@@ -0,0 +1,4 @@
+from .examination import Examination
+from .examination_type import ExaminationType
+from .examination_time import ExaminationTime
+from .examination_time_type import ExaminationTimeType

endoreg_db/models/examination/examination.py

@@ -0,0 +1,26 @@
+from django.db import models
+
+class ExaminationManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+    
+class Examination(models.Model):
+    name = models.CharField(max_length=100, unique=True)
+    name_de = models.CharField(max_length=100, blank=True, null=True)
+    name_en = models.CharField(max_length=100, blank=True, null=True)
+    examination_types = models.ManyToManyField('ExaminationType', blank=True)
+    objects = ExaminationManager()
+    date = models.DateField(blank=True, null=True)
+    time = models.TimeField(blank=True, null=True)
+
+    def __str__(self):
+        return self.name
+    
+    def natural_key(self):
+        return (self.name,)
+
+    class Meta:
+        verbose_name = 'Examination'
+        verbose_name_plural = 'Examinations'
+        ordering = ['name']
+

endoreg_db/models/examination/examination_time.py

@@ -0,0 +1,27 @@
+from django.db import models
+from rest_framework import serializers
+
+class ExaminationTimeManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+    
+class ExaminationTime(models.Model):
+    name = models.CharField(max_length=100, unique=True)
+    name_de = models.CharField(max_length=100, blank=True, null=True)
+    name_en = models.CharField(max_length=100, blank=True, null=True)
+    start_time = models.TimeField(blank=True, null=True)
+    time_types = models.ManyToManyField('ExaminationTimeType', blank=True)
+    end_time = models.TimeField(blank=True, null=True)
+    objects = ExaminationTimeManager()
+
+    def __str__(self):
+        return self.name
+    
+    def natural_key(self):
+        return (self.name,)
+
+    class Meta:
+        verbose_name = 'Examination Time'
+        verbose_name_plural = 'Examination Times'
+        ordering = ['name']
+

endoreg_db/models/examination/examination_time_type.py

@@ -0,0 +1,24 @@
+from django.db import models
+
+class ExaminationTimeTypeManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+    
+class ExaminationTimeType(models.Model):
+    objects = ExaminationTimeTypeManager()
+    name = models.CharField(max_length=100, unique=True)
+    name_de = models.CharField(max_length=100, blank=True, null=True)
+    name_en = models.CharField(max_length=100, blank=True, null=True)
+    examinations = models.ManyToManyField('Examination', blank=True)
+
+    def __str__(self):
+        return self.name
+    
+    def natural_key(self):
+        return (self.name,)
+
+    class Meta:
+        verbose_name = 'Examination Time Type'
+        verbose_name_plural = 'Examination Time Types'
+        ordering = ['name']
+

endoreg_db/models/examination/examination_type.py

@@ -0,0 +1,18 @@
+from django.db import models
+
+class ExaminationTypeManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+    
+class ExaminationType(models.Model):
+    objects = ExaminationTypeManager()
+    name = models.CharField(max_length=100, unique=True)
+    name_de = models.CharField(max_length=100, blank=True, null=True)
+    name_en = models.CharField(max_length=100, blank=True, null=True)
+
+    def __str__(self):
+        return self.name_en
+    
+    def natural_key(self):
+        return (self.name,)
+    

endoreg_db/models/hardware/__init__.py

@@ -0,0 +1,2 @@
+from .endoscopy_processor import EndoscopyProcessor
+from .endoscope import Endoscope, EndoscopeType

endoreg_db/models/hardware/endoscope.py

@@ -0,0 +1,44 @@
+from django.db import models
+
+class EndoscopeManager(models.Manager):
+    def get_by_natural_key(self, name, sn):
+        return self.get(name=name, sn=sn)
+    
+class Endoscope(models.Model):
+    objects = EndoscopeManager()
+    
+    name = models.CharField(max_length=255)
+    sn = models.CharField(max_length=255)
+    
+    def natural_key(self):
+        return (self.name, self.sn)
+    
+    def __str__(self):
+        return self.name
+    
+    class Meta:
+        ordering = ['name']
+        verbose_name = 'Endoscope'
+        verbose_name_plural = 'Endoscopes'
+
+class EndoscopeTypeManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+    
+class EndoscopeType(models.Model):
+    objects = EndoscopeTypeManager()
+    
+    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
+    
+    class Meta:
+        ordering = ['name']
+        verbose_name = 'Endoscope Type'
+        verbose_name_plural = 'Endoscope Types'

endoreg_db/models/hardware/endoscopy_processor.py

@@ -0,0 +1,143 @@
+from django.db import models
+
+class EndoscopyProcessorManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+
+class EndoscopyProcessor(models.Model):
+    objects = EndoscopyProcessorManager()
+
+    name = models.CharField(max_length=255)
+    image_width = models.IntegerField()
+    image_height = models.IntegerField()
+    # image_fps = models.IntegerField()
+
+    # Roi for endoscope image
+    endoscope_image_x = models.IntegerField()
+    endoscope_image_y = models.IntegerField()
+    endoscope_image_width = models.IntegerField()
+    endoscope_image_height = models.IntegerField()
+
+    # Roi for examination date
+    examination_date_x = models.IntegerField()
+    examination_date_y = models.IntegerField()
+    examination_date_width = models.IntegerField()
+    examination_date_height = models.IntegerField()
+
+    # Roi for examination time
+    examination_time_x = models.IntegerField(blank=True, null=True)
+    examination_time_y = models.IntegerField(blank=True, null=True)
+    examination_time_width = models.IntegerField(blank=True, null=True)
+    examination_time_height = models.IntegerField(blank=True, null=True)
+
+    # Roi for patient first name
+    patient_first_name_x = models.IntegerField()
+    patient_first_name_y = models.IntegerField()
+    patient_first_name_width = models.IntegerField()
+    patient_first_name_height = models.IntegerField()
+
+    # Roi for patient name
+    patient_last_name_x = models.IntegerField()
+    patient_last_name_y = models.IntegerField()
+    patient_last_name_width = models.IntegerField()
+    patient_last_name_height = models.IntegerField()
+
+    # Roi for patient dob
+    patient_dob_x = models.IntegerField()
+    patient_dob_y = models.IntegerField()
+    patient_dob_width = models.IntegerField()
+    patient_dob_height = models.IntegerField()
+
+    # Roi for endoscope type
+    endoscope_type_x = models.IntegerField(blank=True, null=True)
+    endoscope_type_y = models.IntegerField(blank=True, null=True)
+    endoscope_type_width = models.IntegerField(blank=True, null=True)
+    endoscope_type_height = models.IntegerField(blank=True, null=True)
+
+    # Roi for endoscopy sn
+    endoscope_sn_x = models.IntegerField(blank=True, null=True)
+    endoscope_sn_y = models.IntegerField(blank=True, null=True)
+    endoscope_sn_width = models.IntegerField(blank=True, null=True)
+    endoscope_sn_height = models.IntegerField(blank=True, null=True)
+
+    def natural_key(self):
+        return (self.name,)
+    
+    def __str__(self):
+        return self.name
+    
+    def get_roi_endoscope_image(self):
+        return {
+            "x": self.endoscope_image_x,
+            "y": self.endoscope_image_y,
+            "width": self.endoscope_image_width,
+            "height": self.endoscope_image_height
+        }
+    
+    def get_roi_examination_date(self):
+        return {
+            "x": self.examination_date_x,
+            "y": self.examination_date_y,
+            "width": self.examination_date_width,
+            "height": self.examination_date_height
+        }
+    
+    def get_roi_examination_time(self):
+        return {
+            "x": self.examination_time_x,
+            "y": self.examination_time_y,
+            "width": self.examination_time_width,
+            "height": self.examination_time_height
+        }
+    
+    def get_roi_patient_last_name(self):
+        return {
+            "x": self.patient_last_name_x,
+            "y": self.patient_last_name_y,
+            "width": self.patient_last_name_width,
+            "height": self.patient_last_name_height
+        }
+    
+    def get_roi_patient_first_name(self):
+        return {
+            "x": self.patient_first_name_x,
+            "y": self.patient_first_name_y,
+            "width": self.patient_first_name_width,
+            "height": self.patient_first_name_height
+        }
+    
+    def get_roi_patient_dob(self):
+        return {
+            "x": self.patient_dob_x,
+            "y": self.patient_dob_y,
+            "width": self.patient_dob_width,
+            "height": self.patient_dob_height
+        }
+    
+    def get_roi_endoscope_type(self):
+        return {
+            "x": self.endoscope_type_x,
+            "y": self.endoscope_type_y,
+            "width": self.endoscope_type_width,
+            "height": self.endoscope_type_height
+        }
+    
+    def get_roi_endoscopy_sn(self):
+        return {
+            "x": self.endoscope_sn_x,
+            "y": self.endoscope_sn_y,
+            "width": self.endoscope_sn_width,
+            "height": self.endoscope_sn_height
+        }
+    
+    def get_rois(self):
+        return {
+            "endoscope_image": self.get_roi_endoscope_image(),
+            "examination_date": self.get_roi_examination_date(),
+            "examination_time": self.get_roi_examination_time(),
+            "patient_first_name": self.get_roi_patient_first_name(),
+            "patient_last_name": self.get_roi_patient_last_name(),
+            "patient_dob": self.get_roi_patient_dob(),
+            "endoscope_type": self.get_roi_endoscope_type(),
+            "endoscope_sn": self.get_roi_endoscopy_sn()
+        }

endoreg_db/models/information_source.py

@@ -0,0 +1,22 @@
+from django.db import models
+
+def get_prediction_information_source():
+    _source = InformationSource.objects.get(name="prediction")
+
+    # make sure to return only one object
+    assert _source, "No prediction information source found"
+    return _source
+
+class InformationSourceManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+
+class InformationSource(models.Model):
+    objects = InformationSourceManager()
+
+    name = models.CharField(max_length=100)
+    name_de = models.CharField(max_length=100, blank=True, null=True)
+    name_en = models.CharField(max_length=100, blank=True, null=True)
+
+    def __str__(self):
+        return self.name

endoreg_db/models/label/__init__.py

@@ -0,0 +1 @@
+from .label import Label, LabelType, LabelSet

endoreg_db/models/label/label.py

@@ -0,0 +1,84 @@
+from django.db import models
+
+class LabelTypeManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+
+class LabelType(models.Model):
+    """
+    A class representing a label type.
+
+    Attributes:
+        name (str): The name of the label type.
+        description (str): A description of the label type.
+
+    """
+    name = models.CharField(max_length=255)
+    description = models.TextField(blank=True, null=True)
+
+    objects = LabelTypeManager()
+
+    def natural_key(self):
+        return (self.name,)
+
+    def __str__(self):
+        return self.name
+
+
+class LabelManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+
+class Label(models.Model):
+    """
+    A class representing a label.
+
+    Attributes:
+        name (str): The name of the label.
+        label_type (LabelType): The type of the label.
+        description (str): A description of the label.
+
+    """
+    name = models.CharField(max_length=255)
+    label_type = models.ForeignKey("LabelType", on_delete=models.CASCADE, related_name="labels")
+    description = models.TextField(blank=True, null=True)
+
+    objects = LabelManager()
+
+    def natural_key(self):
+        return (self.name,)
+
+    def __str__(self):
+        return self.name
+
+class LabelSetManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+
+class LabelSet(models.Model):
+    """
+    A class representing a label set.
+
+    Attributes:
+        name (str): The name of the label set.
+        description (str): A description of the label set.
+
+    """
+    name = models.CharField(max_length=255)
+    description = models.TextField(blank=True, null=True)
+    version = models.IntegerField()
+    labels = models.ManyToManyField("Label", related_name="labels")
+    
+    objects = LabelSetManager()
+
+    def natural_key(self):
+        return (self.name,)
+
+    def __str__(self):
+        return self.name
+    
+    def get_labels_in_order(self):
+        """
+        Get all labels in this label set as list in the correct order.
+        """
+        return list(self.labels.all().order_by('id'))

endoreg_db/models/legacy_data/__init__.py

@@ -0,0 +1,3 @@
+from ..data_file.frame import LegacyFrame
+from .image import LegacyImage
+from ..data_file.video import LegacyVideo

endoreg_db/models/legacy_data/image.py

@@ -0,0 +1,34 @@
+from django.db import models
+from ..label.label import Label
+from ..annotation.image_classification import ImageClassificationAnnotation
+
+class LegacyImage(models.Model):
+    # Add any other fields you need to store frame-related information
+    image = models.ImageField(upload_to="legacy_images")  # 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)
+
+    def get_classification_annotations(self):
+        """
+        Get all image classification annotations for this image.
+        """
+        return ImageClassificationAnnotation.objects.filter(legacy_image=self)
+    
+    def get_classification_annotations_by_label(self, label:Label):
+        """
+        Get all image classification annotations for this image with the given label.
+        """
+        return ImageClassificationAnnotation.objects.filter(legacy_image=self, label=label)
+    
+    def get_classification_annotations_by_value(self, value:bool):
+        """
+        Get all image classification annotations for this image with the given value.
+        """
+        return ImageClassificationAnnotation.objects.filter(legacy_image=self, value=value)
+    
+    def get_classification_annotations_by_label_and_value(self, label:Label, value:bool):
+        """
+        Get all image classification annotations for this image with the given label and value.
+        """
+        return ImageClassificationAnnotation.objects.filter(legacy_image=self, label=label, value=value)
+    

endoreg_db/models/patient_examination/__init__.py

@@ -0,0 +1,35 @@
+from django.db import models
+
+# Serializer located in serializers/examination.py
+class PatientExamination(models.Model):
+    patient = models.ForeignKey('Patient', on_delete=models.CASCADE, related_name='patient_examinations')
+    examination = models.ForeignKey('Examination', on_delete=models.CASCADE, null = True, blank = True)
+    video = models.OneToOneField('Video', on_delete=models.CASCADE, null = True, blank = True, related_name='patient_examination')
+    report_file = models.OneToOneField('ReportFile', on_delete=models.CASCADE, null = True, blank = True, related_name='patient_examination')
+
+    class Meta:
+        verbose_name = 'Patient Examination'
+        verbose_name_plural = 'Patient Examinations'
+        ordering = ['patient', 'examination']
+
+    def __str__(self):
+        return f"{self.patient} - {self.report_file}"
+    
+    def find_matching_video_from_patient(self):
+        """
+        Finds a video for this patient examination based on the patient's videos.
+        For this, the videos date must be the same as the report file's date.
+        #TODO add more criteria for matching: Examination type
+        """
+        videos = self.patient.video_set.filter(date=self.report_file.date, patient_examination__isnull=True)
+        if videos:
+            if len(videos) > 1:
+                print(f"Warning: Found more than one video for patient {self.patient} on date {self.report_file.date}. Choosing the first one.")
+            return videos[0]
+        else:
+            videos = self.patient.video_set.filter(patient_examination__isnull=True)
+            if len(videos)==1:
+                return videos[0]
+            
+        return None
+

endoreg_db/models/persons/__init__.py

@@ -0,0 +1,4 @@
+from .person import Person
+from .patient import Patient, PatientForm
+from .examiner import Examiner, ExaminerSerializer
+from .portal_user_information import PortalUserInfo, Profession

endoreg_db/models/persons/examiner/__init__.py

@@ -0,0 +1,2 @@
+from .examiner import Examiner, ExaminerSerializer
+# from .examiner_type import ExaminerType

endoreg_db/models/persons/examiner/examiner.py

@@ -0,0 +1,16 @@
+from django.db import models
+from ..person import Person
+from rest_framework import serializers
+
+class Examiner(Person):
+    center = models.ForeignKey('Center', on_delete=models.CASCADE, blank=True, null=True)
+
+    def __str__(self):
+        return self.first_name + " " + self.last_name
+    
+
+class ExaminerSerializer(serializers.ModelSerializer):
+    
+    class Meta:
+        model = Examiner
+        fields = '__all__'

endoreg_db/models/persons/examiner/examiner_type.py

@@ -0,0 +1,2 @@
+from .examiner import Examiner
+# from .examiner_type import ExaminerType