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

endoreg_db/models/data_file/metadata/video_meta.py

@@ -1,133 +0,0 @@
-from django.db import models
-import ffmpeg
-from pathlib import Path
-
-# import endoreg_center_id from django settings
-from django.conf import settings
-
-# check if endoreg_center_id is set
-if not hasattr(settings, 'ENDOREG_CENTER_ID'):
-    ENDOREG_CENTER_ID = 9999
-else:
-    ENDOREG_CENTER_ID = settings.ENDOREG_CENTER_ID
-
-# VideoMeta
-class VideoMeta(models.Model):
-    processor = models.ForeignKey('EndoscopyProcessor', on_delete=models.CASCADE, blank=True, null=True)
-    endoscope = models.ForeignKey('Endoscope', on_delete=models.CASCADE, blank=True, null=True)
-    center = models.ForeignKey('Center', on_delete=models.CASCADE)
-    import_meta = models.OneToOneField('VideoImportMeta', on_delete=models.CASCADE, blank=True, null=True)
-    ffmpeg_meta = models.OneToOneField('FFMpegMeta', on_delete=models.CASCADE, blank=True, null=True)
-
-    def __str__(self):
-
-        processor_name = self.processor.name if self.processor is not None else "None"
-        endoscope_name = self.endoscope.name if self.endoscope is not None else "None"
-        center_name = self.center.name if self.center is not None else "None"
-
-        result_html = ""
-
-        result_html += f"Processor: {processor_name}<br>"
-        result_html += f"Endoscope: {endoscope_name}<br>"
-        result_html += f"Center: {center_name}<br>"
-
-        return result_html
-    
-    # import meta should be created when video meta is created
-    def save(self, *args, **kwargs):
-        if self.import_meta is None:
-            self.import_meta = VideoImportMeta.objects.create()
-        super(VideoMeta, self).save(*args, **kwargs)
-
-    def initialize_ffmpeg_meta(self, file_path):
-        """Initializes FFMpeg metadata for the video file if not already done."""
-        self.ffmpeg_meta = FFMpegMeta.create_from_file(Path(file_path))
-        self.save()
-
-    def update_meta(self, file_path):
-        """Updates the video metadata from the file."""
-        self.initialize_ffmpeg_meta(file_path)
-        self.save()
-
-    def get_endo_roi(self):
-        endo_roi = self.processor.get_roi_endoscope_image()
-        return endo_roi
-
-    def get_fps(self):
-        if not self.ffmpeg_meta:
-            return None
-    
-        return self.ffmpeg_meta.frame_rate
- 
-
-class FFMpegMeta(models.Model):
-    # Existing fields
-    duration = models.FloatField(blank=True, null=True)
-    width = models.IntegerField(blank=True, null=True)
-    height = models.IntegerField(blank=True, null=True)
-    frame_rate = models.FloatField(blank=True, null=True)
-    
-    # New fields for comprehensive information
-    video_codec = models.CharField(max_length=50, blank=True, null=True)
-    audio_codec = models.CharField(max_length=50, blank=True, null=True)
-    audio_channels = models.IntegerField(blank=True, null=True)
-    audio_sample_rate = models.IntegerField(blank=True, null=True)
-
-    # Existing __str__ method can be updated to include new fields
-
-    @classmethod
-    def create_from_file(cls, file_path: Path):
-        """Creates an FFMpegMeta instance from a video file using ffmpeg probe."""
-        try:
-            probe = ffmpeg.probe(file_path.resolve().as_posix())
-        except: # ffmpeg.Error as e:
-            # print(e.stderr)
-            print(f"Error while probing {file_path}")
-            return None
-
-        video_stream = next((stream for stream in probe['streams'] if stream['codec_type'] == 'video'), None)
-        audio_streams = [stream for stream in probe['streams'] if stream['codec_type'] == 'audio']
-
-        # Check for the existence of a video stream
-        if video_stream is None:
-            print(f"No video stream found in {file_path}")
-            return None
-
-        # Extract and store video metadata
-        metadata = {
-            'duration': float(video_stream.get('duration', 0)),
-            'width': int(video_stream.get('width', 0)),
-            'height': int(video_stream.get('height', 0)),
-            'frame_rate': float(next(iter(video_stream.get('avg_frame_rate', '').split('/')), 0)),
-            'video_codec': video_stream.get('codec_name', ''),
-        }
-
-        # If there are audio streams, extract and store audio metadata from the first stream
-        if audio_streams:
-            first_audio_stream = audio_streams[0]
-            metadata.update({
-                'audio_codec': first_audio_stream.get('codec_name', ''),
-                'audio_channels': int(first_audio_stream.get('channels', 0)),
-                'audio_sample_rate': int(first_audio_stream.get('sample_rate', 0)),
-            })
-
-        # Create and return the FFMpegMeta instance
-        return cls.objects.create(**metadata)
-
-class VideoImportMeta(models.Model):
-
-    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"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/report_file.py

@@ -1,89 +0,0 @@
-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):
-        #FIXME should use endoreg_db.utils.get_pdf_hash in future
-        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

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

endoreg_db/models/data_file/video/import_meta.py

@@ -1,25 +0,0 @@
-# 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

@@ -1,25 +0,0 @@
-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

endoreg_db/models/data_file/video_segment.py

@@ -1,107 +0,0 @@
-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/disease.py

@@ -1,56 +0,0 @@
-from django.db import models
-
-class DiseaseManager(models.Manager):
-    def get_by_natural_key(self, name):
-        return self.get(name=name)
-
-class Disease(models.Model):
-    name = models.CharField(max_length=255, unique=True)
-    name_de = models.CharField(max_length=255, blank=True, null=True)
-    name_en = models.CharField(max_length=255, blank=True, null=True)
-
-    objects = DiseaseManager()
-
-    def natural_key(self):
-        return (self.name,)
-
-    def __str__(self):
-        return self.name
-    
-class DiseaseClassificationManager(models.Manager):
-    def get_by_natural_key(self, name):
-        return self.get(name=name)
-
-class DiseaseClassification(models.Model):
-    name = models.CharField(max_length=255, unique=True)
-    name_de = models.CharField(max_length=255, blank=True, null=True)
-    name_en = models.CharField(max_length=255, blank=True, null=True)
-
-    disease = models.ForeignKey(Disease, on_delete=models.CASCADE)
-
-    objects = DiseaseClassificationManager()
-
-    def natural_key(self):
-        return (self.name,)
-
-    def __str__(self):
-        return self.name
-    
-class DiseaseClassificationChoiceManager(models.Manager):
-    def get_by_natural_key(self, name):
-        return self.get(name=name)
-
-class DiseaseClassificationChoice(models.Model):
-    name = models.CharField(max_length=255, unique=True)
-    name_de = models.CharField(max_length=255, blank=True, null=True)
-    name_en = models.CharField(max_length=255, blank=True, null=True)
-
-    disease_classification = models.ForeignKey(DiseaseClassification, on_delete=models.CASCADE)
-
-    objects = DiseaseClassificationChoiceManager()
-
-    def natural_key(self):
-        return (self.name,)
-
-    def __str__(self):
-        return self.name

endoreg_db/models/emission/__init__.py

@@ -1 +0,0 @@
-from .emission_factor import EmissionFactor

endoreg_db/models/emission/emission_factor.py

@@ -1,20 +0,0 @@
-from django.db import models
-
-class EmissionFactorManager(models.Manager):
-    def get_by_natural_key(self, name):
-        return self.get(name=name)
-    
-class EmissionFactor(models.Model):
-    objects = EmissionFactorManager()
-
-    name = models.CharField(max_length=255)
-    name_de = models.CharField(max_length=255, null=True)
-    name_en = models.CharField(max_length=255, null=True)
-    unit = models.ForeignKey("Unit", on_delete=models.SET_NULL, null=True)
-    value = models.FloatField()
-    
-    def natural_key(self):
-        return (self.name,)
-    
-    def __str__(self):
-        return self.name

endoreg_db/models/event.py

@@ -1,22 +0,0 @@
-from django.db import models
-
-class Event(models.Model):
-    """
-    A class representing an event.
-
-    Attributes:
-        name (str): The name of the event.
-        name_de (str): The German name of the event.
-        name_en (str): The English name of the event.
-        description (str): A description of the event.
-    """
-    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)
-    description = models.TextField(blank=True, null=True)
-
-    def natural_key(self):
-        return (self.name,)
-
-    def __str__(self):
-        return self.name

endoreg_db/models/examination/__init__.py

@@ -1,4 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

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

endoreg_db/models/hardware/endoscope.py

@@ -1,44 +0,0 @@
-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'