endoreg-db 0.4.5__py3-none-any.whl → 0.8.6.3__py3-none-any.whl

endoreg_db/queries/get/center.py

@@ -1,42 +0,0 @@
-from endoreg_db.models import Center
-from typing import Optional
-
-def get_centers() -> Center:
-    """
-    Returns all Center objects from the database.
-    """
-    return Center.objects.all()
-
-def get_center_by_name(name) -> Optional[Center]:
-    """Retrieve a Center object by its name.
-
-    Args:
-        name (str): The name of the center to retrieve.
-
-    Returns:
-        Optional[Center]: The Center object with the given name, or None if it does not exist.
-    """
-    return Center.objects.get(name=name)
-
-def get_center_by_id(id) -> Optional[Center]:
-    """Retrieve a Center object by its id.
-
-    Args:
-        id (int): The id of the center to retrieve.
-
-    Returns:
-        Optional[Center]: The Center object with the given id, or None if it does not exist.
-    """
-    return Center.objects.get(id=id)
-
-def get_center_by_natural_key(name: str) -> Optional[Center]:
-    """
-    Retrieve a Center object by its natural key.
-
-    Args:
-        name: The name of the center to retrieve.
-
-    Returns:
-        The Center object with the given name, or None if it does not exist.
-    """
-    return Center.objects.get_by_natural_key(name=name)

endoreg_db/queries/get/model.py

@@ -1,13 +0,0 @@
-from endoreg_db.models import (
-    ModelMeta,
-)
-
-def get_latest_model_by_name(model_name):
-    """
-    Expects model name. Fetches models by name from database, sorts by version and returns latest version.
-    """
-    models = ModelMeta.objects.filter(name=model_name).order_by('-version')
-    if len(models) == 0:
-        return None
-    else:
-        return models[0]

endoreg_db/queries/get/patient.py

@@ -1,14 +0,0 @@
-from endoreg_db.models import Patient
-
-def get_patients() -> Patient:
-    """
-    Returns all Patient objects from the database.
-    """
-    return Patient.objects.all()
-
-def get_patients_without_dob() -> Patient:
-    """
-    Returns all Patient objects from the database without a date of birth.
-    """
-    return Patient.objects.filter(dob__isnull=True)
-

endoreg_db/queries/get/patient_examination.py

@@ -1,20 +0,0 @@
-from endoreg_db.models import PatientExamination
-from typing import Optional
-
-def get_patient_examinations() -> PatientExamination:
-    """
-    Returns all PatientExamination objects from the database.
-    """
-    return PatientExamination.objects.all()
-
-def get_patient_examinations_without_report_file() -> PatientExamination:
-    """
-    Returns all PatientExamination objects from the database without a report_file.
-    """
-    return PatientExamination.objects.filter(report_file__isnull=True)
-
-def get_patient_examinations_without_video() -> PatientExamination:
-    """
-    Returns all PatientExamination objects from the database without a video.
-    """
-    return PatientExamination.objects.filter(video__isnull=True)

endoreg_db/queries/get/report_file.py

@@ -1,33 +0,0 @@
-from endoreg_db.models import ReportFile
-from typing import Optional
-
-def get_report_files() -> ReportFile:
-    """
-    Returns all ReportFile objects from the database.
-    """
-    return ReportFile.objects.all()
-
-def get_report_file_by_id(id) -> Optional[ReportFile]:
-    """Retrieve a ReportFile object by its id.
-
-    Args:
-        id (int): The id of the report_file to retrieve.
-
-    Returns:
-        Optional[ReportFile]: The ReportFile object with the given id, or None if it does not exist.
-    """
-    return ReportFile.objects.get(id=id)
-
-def get_report_files_without_examination() -> ReportFile:
-    """
-    Returns all ReportFile objects from the database without an examination.
-    """
-    return ReportFile.objects.filter(patient_examination__isnull=True)
-
-def get_report_files_without_patient() -> ReportFile:
-    """
-    Returns all ReportFile objects from the database without a patient.
-    """
-    return ReportFile.objects.filter(patient__isnull=True)
-
-

endoreg_db/queries/get/video.py

@@ -1,31 +0,0 @@
-from endoreg_db.models import Video, PatientExamination
-from typing import Optional
-
-def get_videos() -> Video:
-    """
-    Returns all Video objects from the database.
-    """
-    return Video.objects.all()
-
-def get_video_by_id(id) -> Optional[Video]:
-    """Retrieve a Video object by its id.
-
-    Args:
-        id (int): The id of the video to retrieve.
-
-    Returns:
-        Optional[Video]: The Video object with the given id, or None if it does not exist.
-    """
-    return Video.objects.get(id=id)
-
-def get_video_without_examination() -> Video:
-    """
-    Returns all Video objects from the database without an examination.
-    """
-    return Video.objects.filter(patient_examination__isnull=True)
-
-def get_video_without_patient() -> Video:
-    """
-    Returns all Video objects from the database without a patient.
-    """
-    return Video.objects.filter(patient__isnull=True)

endoreg_db/serializers/ai_model.py

@@ -1,19 +0,0 @@
-from endoreg_db.models import ModelMeta, ModelType, ActiveModel
-from rest_framework import serializers
-
-class ModelMetaSerializer(serializers.ModelSerializer):
-    weights = serializers.FileField(use_url=True)  # use_url=True will provide the file's URI
-
-    class Meta:
-        model = ModelMeta
-        fields = '__all__'
-
-class ModelTypeSerializer(serializers.ModelSerializer):
-    class Meta:
-        model = ModelType
-        fields = '__all__'
-
-class ActiveModelSerializer(serializers.ModelSerializer):
-    class Meta:
-        model = ActiveModel
-        fields = '__all__'

endoreg_db/serializers/annotation.py

@@ -1,17 +0,0 @@
-from rest_framework import serializers
-from endoreg_db.models import LegacyBinaryClassificationAnnotationTask, BinaryClassificationAnnotationTask, ImageClassificationAnnotation
-
-class LegacyBinaryClassificationAnnotationTaskSerializer(serializers.ModelSerializer):
-    class Meta:
-        model = LegacyBinaryClassificationAnnotationTask
-        fields = '__all__'
-
-class BinaryClassificationAnnotationTaskSerializer(serializers.ModelSerializer):
-    class Meta:
-        model = BinaryClassificationAnnotationTask
-        fields = '__all__'
-
-class ImageClassificationAnnotationSerializer(serializers.ModelSerializer):
-    class Meta:
-        model = ImageClassificationAnnotation
-        fields = '__all__'

endoreg_db/serializers/center.py

@@ -1,11 +0,0 @@
-from rest_framework import serializers
-from endoreg_db.models import (
-    Center,
-)
-
-class CenterSerializer(serializers.ModelSerializer):
-    class Meta:
-        model = Center
-        fields = '__all__'
-
-

endoreg_db/serializers/examination.py

@@ -1,33 +0,0 @@
-from rest_framework import serializers
-from endoreg_db.models import (
-    Examination,
-    ExaminationTimeType,
-    ExaminationTime,
-    ExaminationType,
-    PatientExamination
-)
-
-class ExaminationTimeTypeSerializer(serializers.ModelSerializer):
-    class Meta:
-        model = ExaminationTimeType
-        fields = '__all__'
-
-class ExaminationTimeSerializer(serializers.ModelSerializer):
-    class Meta:
-        model = ExaminationTime
-        fields = '__all__'
-
-class ExaminationTypeSerializer(serializers.ModelSerializer):
-    class Meta:
-        model = ExaminationType
-        fields = '__all__'
-
-class ExaminationSerializer(serializers.ModelSerializer): 
-    class Meta:
-        model = Examination
-        fields = '__all__'
-
-class PatientExaminationSerializer(serializers.ModelSerializer):
-    class Meta:
-        model = PatientExamination
-        fields = '__all__'

endoreg_db/serializers/frame.py

@@ -1,13 +0,0 @@
-from rest_framework import serializers
-from endoreg_db.models import Frame, LegacyFrame
-
-class FrameSerializer(serializers.ModelSerializer):
-    class Meta:
-        model = Frame
-        fields = '__all__'
-
-class LegacyFrameSerializer(serializers.ModelSerializer):
-    class Meta:
-        model = LegacyFrame
-        fields = '__all__'
-

endoreg_db/serializers/hardware.py

@@ -1,21 +0,0 @@
-from rest_framework import serializers
-from endoreg_db.models import (
-    Endoscope,
-    EndoscopeType,
-    EndoscopyProcessor,
-)
-
-class EndoscopeSerializer(serializers.ModelSerializer):
-    class Meta:
-        model = Endoscope
-        fields = '__all__'
-
-class EndoscopyProcessorSerializer(serializers.ModelSerializer):
-    class Meta:
-        model = EndoscopyProcessor
-        fields = '__all__'
-
-class EndoscopeTypeSerializer(serializers.ModelSerializer):
-    class Meta:
-        model = EndoscopeType
-        fields = '__all__'

endoreg_db/serializers/label.py

@@ -1,22 +0,0 @@
-from rest_framework import serializers
-from endoreg_db.models import (
-    Label,
-    LabelSet,
-    LabelType,
-)
-
-class LabelTypeSerializer(serializers.ModelSerializer):
-    class Meta:
-        model = LabelType
-        fields = '__all__'
-
-class LabelSetSerializer(serializers.ModelSerializer):
-    class Meta:
-        model = LabelSet
-        fields = '__all__'
-
-class LabelSerializer(serializers.ModelSerializer):
-    class Meta:
-        model = Label
-        fields = '__all__'
-        

endoreg_db/serializers/patient.py

@@ -1,10 +0,0 @@
-from rest_framework import serializers
-from endoreg_db.models import (
-    Patient,
-)
-
-class PatientSerializer(serializers.ModelSerializer):
-    class Meta:
-        model = Patient
-        fields = '__all__'
-

endoreg_db/serializers/prediction.py

@@ -1,15 +0,0 @@
-from rest_framework import serializers
-from endoreg_db.models import (
-    ImageClassificationPrediction,
-    LegacyVideoPredictionMeta
-)
-
-class ImageClassificationPredictionSerializer(serializers.ModelSerializer):
-    class Meta:
-        model = ImageClassificationPrediction
-        fields = '__all__'
-
-class LegacyVideoPredictionMetaSerializer(serializers.ModelSerializer):
-    class Meta:
-        model = LegacyVideoPredictionMeta
-        fields = '__all__'

endoreg_db/serializers/report_file.py

@@ -1,7 +0,0 @@
-from rest_framework import serializers
-from endoreg_db.models import ReportFile
-
-class ReportFileSerializer(serializers.ModelSerializer):
-    class Meta:
-        model = ReportFile
-        fields = '__all__'

endoreg_db/serializers/video.py

@@ -1,27 +0,0 @@
-from rest_framework import serializers
-from endoreg_db.models import Video, LegacyVideo, VideoImportMeta, LegacyLabelVideoSegment, LabelVideoSegment
-
-class VideoSerializer(serializers.ModelSerializer):
-    class Meta:
-        model = Video
-        fields = '__all__'
-
-class LegacyVideoSerializer(serializers.ModelSerializer):
-    class Meta:
-        model = LegacyVideo
-        fields = '__all__'
-
-class VideoImportMetaSerializer(serializers.ModelSerializer):
-    class Meta:
-        model = VideoImportMeta
-        fields = '__all__'
-
-class LabelVideoSegmentSerializer(serializers.ModelSerializer):
-    class Meta:
-        model = LabelVideoSegment
-        fields = '__all__'
-
-class LegacyLabelVideoSegmentSerializer(serializers.ModelSerializer):
-    class Meta:
-        model = LegacyLabelVideoSegment
-        fields = '__all__'

endoreg_db/tests.py

@@ -1,3 +0,0 @@
-from django.test import TestCase
-
-# Create your tests here.

endoreg_db/utils/legacy_ocr.py

@@ -1,201 +0,0 @@
-import pytesseract
-# import cv2
-from endoreg_db.models import EndoscopyProcessor
-import os
-from collections import Counter
-from tempfile import TemporaryDirectory
-import re
-from datetime import datetime
-from typing import Dict, List
-import numpy as np
-
-N_FRAMES_MEAN_OCR = 2
-
-# Helper function to process date strings
-def process_date_text(date_text):
-    """
-    Processes a string of text that represents a date and returns a datetime.date object.
-
-    Args:
-        date_text (str): A string of text that represents a date.
-
-    Returns:
-        datetime.date: A datetime.date object representing the parsed date, or None if the text cannot be parsed.
-    """
-    try:
-        # Remove any non-digit characters
-        date_text_clean = re.sub(r'\D', '', date_text)
-        # Reformat to 'ddmmyyyy' if necessary
-        if len(date_text_clean) == 8:
-            return datetime.strptime(date_text_clean, "%d%m%Y").date()
-        elif len(date_text_clean) == 14:
-            return datetime.strptime(date_text_clean, "%d%m%Y%H%M%S").date()
-    except ValueError:
-        # Return None if the text cannot be parsed into a date
-        # set date to 1/1/1900
-        return datetime.strptime("01011900", "%d%m%Y").date()
-
-# Helper function to process patient names
-def process_name_text(name_text):
-    """
-    Remove all numbers, punctuation, and whitespace from a string of text and return the result.
-    """
-    name = re.sub(r'[0-9!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~\s]+', '', name_text).strip()
-    # capitalize first letter of each word
-    name = ' '.join([word.capitalize() for word in name.split()])
-    return name
-
-
-# Helper function to process endoscope type text
-def process_general_text(endoscope_text):
-    """
-    This function takes in a string of text from an endoscope and returns a cleaned version of the text.
-    """
-    return ' '.join(endoscope_text.split())
-
-def roi_values_valid(roi):
-    """
-    Check if all values in an ROI dictionary are valid (>=0).
-    """
-    return all([value >= 0 for value in roi.values()])
-
-# Function to extract text from ROIs
-def extract_text_from_rois(image_path, processor:EndoscopyProcessor):
-    """
-    Extracts text from regions of interest (ROIs) in an image using OCR.
-
-    Args:
-        image_path (str): The path to the image file.
-        processor (EndoscopyProcessor): An instance of the EndoscopyProcessor class.
-
-    Returns:
-        dict: A dictionary containing the extracted text for each ROI.
-    """
-    # Read the image using OpenCV
-    image = cv2.imread(image_path)
-
-    # Initialize the dictionary to hold the extracted text
-    extracted_texts = {}
-
-    # Define your ROIs and their corresponding post-processing functions in tuples
-    rois_with_postprocessing = [
-        ('examination_date', processor.get_roi_examination_date, process_date_text),
-        ("patient_first_name", processor.get_roi_patient_first_name, process_name_text),
-        ('patient_last_name', processor.get_roi_patient_last_name, process_name_text),
-        ('patient_dob', processor.get_roi_patient_dob, process_date_text),
-        ('endoscope_type', processor.get_roi_endoscope_type, process_general_text),
-        ('endoscope_sn', processor.get_roi_endoscopy_sn, process_general_text),
-    ]
-
-    # Extract and post-process text for each ROI
-    for roi_name, roi_function, post_process in rois_with_postprocessing:
-        # Get the ROI dictionary
-        roi = roi_function()
-        
-        # Check if the ROI has values
-        
-        if roi_values_valid(roi):
-            # Crop the image to the ROI
-            x, y, w, h = roi['x'], roi['y'], roi['width'], roi['height']
-            roi_cropped = image[y:y+h, x:x+w]
-            # Convert to grayscale
-            gray = cv2.cvtColor(roi_cropped, cv2.COLOR_BGR2GRAY)
-
-            # Invert colors for white text on black background
-            gray = cv2.bitwise_not(gray)
-
-            # Binarize the image - using Otsu's method
-            _, binary = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
-
-            # Dilate the image to improve the contour of the pixelated text
-            kernel = np.ones((2,2), np.uint8)
-            dilation = cv2.dilate(binary, kernel, iterations=1)
-
-            # OCR configuration: Recognize white text on black background without corrections
-            config = '--psm 10 -c tessedit_char_whitelist=0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-üöäÜÖÄß'
-
-            # Use pytesseract to do OCR on the preprocessed ROI
-            text = pytesseract.image_to_string(dilation, config=config).strip()
-
-            # Post-process extracted text
-            processed_text = post_process(text)
-            # processed_text = text
-            
-            # Store the processed text in the dictionary
-            extracted_texts[roi_name] = processed_text
-
-        else:
-            pass
-            # ic(roi_name)
-            # ic(roi)
-            # ic("No values for this ROI")
-
-    return extracted_texts
-
-
-def get_most_frequent_values(rois_texts: Dict[str, List[str]]) -> Dict[str, str]:
-    """
-    Given a dictionary of ROIs and their corresponding texts, returns a dictionary of the most frequent text for each ROI.
-
-    Args:
-        rois_texts: A dictionary where the keys are the names of the ROIs and the values are lists of texts.
-
-    Returns:
-        A dictionary where the keys are the names of the ROIs and the values are the most frequent text for each ROI.
-    """
-    most_frequent = {}
-    for key in rois_texts.keys():
-        counter = Counter([text for text in rois_texts[key] if text])
-        # ic(key)
-        # ic(counter)
-        most_frequent[key], _ = counter.most_common(1)[0] if counter else (None, None)
-    return most_frequent
-
-def process_video(video_path, processor):
-    """
-    Processes a video file by extracting text from regions of interest (ROIs) in each frame.
-
-    Args:
-        video_path (str): The path to the video file to process.
-        processor (OCRProcessor): An instance of the OCRProcessor class that defines the ROIs to extract text from.
-
-    Returns:
-        dict: A dictionary containing the most frequent text values extracted from each ROI.
-    """
-    # Create a temporary directory to store frames
-    with TemporaryDirectory() as temp_dir:
-        # ic(temp_dir)
-        # Capture the video
-        video = cv2.VideoCapture(video_path)
-        success, frame_number = True, 0
-        rois_texts = {roi_name: [] for roi_name in processor.get_rois().keys()}
-        frames_for_mean_extraction = 0
-
-        while success:
-            success, frame = video.read()
-
-            # Check if this is the 200th frame
-            if frame_number % 1000 == 0 and success:
-                frame_path = os.path.join(temp_dir, f"frame_{frame_number}.jpg")
-                cv2.imwrite(frame_path, frame)  # Save the frame as a JPEG file
-                # cv2.imwrite(f"_tmp/frame_{frame_number}.jpg", frame)
-                
-                # Extract text from ROIs
-                extracted_texts = extract_text_from_rois(frame_path, processor)
-                # ic(extracted_texts)
-                
-                # Store the extracted text from each ROI
-                for key, text in extracted_texts.items():
-                    rois_texts[key].append(text)
-                frames_for_mean_extraction += 1
-
-            frame_number += 1
-
-            if frames_for_mean_extraction >= N_FRAMES_MEAN_OCR: break
-
-        # Release the video capture object
-        video.release()
-
-        # Get the most frequent values for each ROI
-        return get_most_frequent_values(rois_texts)
-

endoreg_db/utils/video_metadata.py

@@ -1,87 +0,0 @@
-# import cv2
-from pathlib import Path
-import datetime
-
-def _extract_metadata_from_filename(filepath:Path, time_format = None): # deprecated
-    """
-    Extracts metadata from a video filename.
-
-    Args:
-        filepath (Path): The path to the video file.
-        time_format (str, optional): The format of the date in the filename. Defaults to None.
-
-    Returns:
-        dict: A dictionary containing the extracted metadata.
-
-    Example return value:
-        {
-            'examination_date': '2021-03-03',
-            'patient_last_name': 'Doe',
-            'patient_first_name': 'John',
-            'patient_dob': '1990-01-01'
-        }
-    """
-    # get filename without suffix
-    filename = filepath.stem    
-
-    if not time_format:
-        time_format = "%d.%m.%Y"
-
-    _info = [_.strip() for _ in filename.split("_")]
-
-    if len(_info) == 4:
-        examination_date, last_name, first_name, birthdate = _info
-    
-    else:
-        examination_date, last_name, first_name, birthdate = None, None, None, None
-
-    metadata = {}
-    metadata['examination_date'] = examination_date
-    metadata['patient_last_name'] = last_name
-    metadata['patient_first_name'] = first_name
-    metadata['patient_dob'] = birthdate
-
-    try:
-        metadata['examination_date'] = datetime.datetime.strptime(examination_date, time_format).date()
-        metadata['examination_date'] = metadata['examination_date'].strftime("%Y-%m-%d")
-    except:
-        metadata['examination_date'] = None
-
-    try:
-        metadata['patient_dob'] = datetime.datetime.strptime(birthdate, time_format).date()
-        metadata['patient_dob'] = metadata['patient_dob'].strftime("%Y-%m-%d")
-    except:
-        metadata['patient_dob'] = None
-
-    return metadata
-
-def _get_video_metadata(file_path): # Deprecated
-    """
-    Returns the framerate, dimensions, and duration of a video file.
-
-    Parameters:
-    file_path (str): The path to the video file.
-
-    Returns:
-    tuple: A tuple containing the framerate (float), dimensions (tuple of ints), and duration (float) of the video.
-    """
-    # Open the video file
-    video = cv2.VideoCapture(file_path)
-
-    # Get the video framerate
-    fps = video.get(cv2.CAP_PROP_FPS)
-
-    # Get the video dimensions
-    width = int(video.get(cv2.CAP_PROP_FRAME_WIDTH))
-    height = int(video.get(cv2.CAP_PROP_FRAME_HEIGHT))
-    dimensions = (width, height)
-
-    # Get the video duration
-    frame_count = int(video.get(cv2.CAP_PROP_FRAME_COUNT))
-    duration = frame_count / fps
-
-    # Release the video file
-    video.release()
-
-    # Return the metadata
-    return fps, dimensions, duration