endoreg-db 0.6.4__py3-none-any.whl → 0.8.2__py3-none-any.whl

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/transcode_videofile.py

@@ -1,111 +0,0 @@
-import shutil
-import subprocess
-import os
-from pathlib import Path
-from icecream import ic
-
-
-def get_transcoded_file_path(source_file_path: Path, suffix: str = "mp4"):
-    """
-    Method to get the transcoded file path.
-
-    Args:
-        source_file_path (Path): Source file path.
-        suffix (str): Suffix of the transcoded file.
-
-    Returns:
-        transcoded_file_path (Path): Transcoded file path.
-    """
-    transcoded_file_name = f"{source_file_path.stem}_transcoded.{suffix}"
-    transcoded_file_path = source_file_path.parent / transcoded_file_name
-    return transcoded_file_path
-
-
-def check_require_transcode(
-    filepath: Path, transcoded_file_path: Path, target_suffix=".mp4"
-):
-    """
-    Checks whether a video file requires transcoding.\
-    We check if the current suffix of the file path matches the target suffix\
-    and if the transcoded file path exists.\
-    If the current suffix does not match the target suffix and the transcoded file path does not exist,\
-    transcoding is required.
-    """
-    current_suffix = filepath.suffix
-
-    require_transcode = False
-    if not current_suffix == target_suffix and not transcoded_file_path.exists():
-        if not transcoded_file_path.exists():
-            require_transcode = True
-    return require_transcode
-
-
-def transcode_videofile_if_required(filepath: Path):
-    """
-    Perform transcoding on a video file if required.
-    This method checks whether a transcoded version (with an ".mp4" suffix) of the given
-    video file exists or needs to be produced. It first computes the expected transcoded file path,
-    then uses a class-specific check (check_require_transcode) to decide if transcoding is necessary.
-    If so, it transcodes the video file by calling the class method transcode_videofile and returns
-    the path of the transcoded file after ensuring that the resulting file path matches the computed one.
-    If transcoding is not required, the original file path is returned.
-    Args:
-        filepath (Path): The path to the original video file that may require transcoding.
-    Returns:
-        Path: The path to the transcoded video file if transcoding was performed; otherwise, the original file path.
-    """
-
-    transcoded_file_path = get_transcoded_file_path(filepath, suffix=".mp4")
-    if check_require_transcode(filepath, transcoded_file_path):
-        transcoded_path = transcode_videofile(
-            filepath, transcoded_path=transcoded_file_path
-        )
-        assert transcoded_file_path == transcoded_path
-        return transcoded_path
-    else:
-        return filepath
-
-
-def transcode_videofile(filepath: Path, transcoded_path: Path):
-    """
-    Transcodes a video to a compatible MP4 format using ffmpeg.
-    If the transcoded file exists, it is returned.
-
-    Parameters
-    ----------
-    mov_file : str
-        The full path to the video file.
-
-    Returns
-    -------
-    transcoded_path : str
-        The full path to the transcoded video file.
-    """
-    ic("Transcoding video")
-    ic(f"Input path: {filepath}")
-
-    # if filepath suffix is .mp4 or .MP4 we dont need to transcode and can copy the file
-    if filepath.suffix.lower() in [".mp4"]:
-        shutil.copyfile(filepath, transcoded_path)
-        return transcoded_path
-
-    ic(f"Transcoded path: {transcoded_path}")
-    if os.path.exists(transcoded_path):
-        return transcoded_path
-
-    # Run ffmpeg to transcode the video using H264 and AAC
-    # TODO Document settings, check if we need to change them
-    command = [
-        "ffmpeg",
-        "-i",
-        filepath.resolve().as_posix(),
-        "-c:v",
-        "libx264",
-        "-preset",
-        "fast",
-        "-c:a",
-        "aac",
-        transcoded_path,
-    ]
-    subprocess.run(command, check=True)
-    return transcoded_path

endoreg_db/views/patient_views.py

@@ -1,90 +0,0 @@
-from django.shortcuts import render
-from django.contrib.admin.views.decorators import staff_member_required
-from django.http import JsonResponse
-from django.http import JsonResponse
-from django.views.decorators.http import require_GET
-from django.core.exceptions import ObjectDoesNotExist
-from rest_framework import viewsets
-from ..models import Patient
-from ..serializers import PatientSerializer
-from rest_framework.permissions import IsAuthenticatedOrReadOnly
-from endoreg_db.models import (
-    FindingLocationClassification,
-    FindingLocationClassificationChoice,
-    FindingMorphologyClassification,
-    FindingMorphologyClassificationType
-)
-
-@staff_member_required  # Ensures only staff members can access the page
-def start_examination(request):
-    return render(request, 'admin/start_examination.html')  # Loads the simple HTML page
-
-#from ..models.patient.patient_finding_location import PatientFindingLocation
-from ..models import FindingLocationClassification, FindingLocationClassificationChoice  # Correct models
-
-
-#need to implement one with json data after tesing whethe rthis works or not
-"""def get_location_choices(request, location_id):
-   
-    try:
-        # Ensure the location exists
-        location = FindingLocationClassification.objects.get(id=location_id)
-        # Get only choices related to the selected location classification
-        #location_choices = FindingLocationClassificationChoice.objects.filter(location_classification=location)
-        #its many to may relation so
-        location_choices = location.choices.all()
-        
-    except FindingLocationClassification.DoesNotExist:
-        location_choices = []
-
-    # Get previously selected values to retain them after reloading
-    selected_location = int(location_id) if location_id else None
-
-    return render(request, 'admin/patient_finding_intervention.html', {
-        "location_choices": location_choices,  # Pass updated choices to the template
-        "selected_location": location_id,  # Keep previous selection
-    })
-"""
-
-class PatientViewSet(viewsets.ModelViewSet):
-    """API endpoint for managing patients."""
-    queryset = Patient.objects.all()
-    serializer_class = PatientSerializer
-    #permission_classes = [IsAuthenticatedOrReadOnly] 
-
-    def perform_create(self, serializer):
-        serializer.save()
-    
-    def update(self, request, *args, **kwargs):
-        # custom edit logic here if needed
-        return super().update(request, *args, **kwargs)
-
-    def destroy(self, request, *args, **kwargs):
-        # custom delete logic here if needed
-        return super().destroy(request, *args, **kwargs)
-
-@require_GET
-def get_location_choices(request, location_id):
-    """Fetch location choices dynamically based on FindingLocationClassification."""
-    try:
-        location = FindingLocationClassification.objects.get(id=location_id)
-        location_choices = location.choices.all()
-        data = [{"id": choice.id, "name": choice.name} for choice in location_choices]
-        return JsonResponse({"location_choices": data})
-    except FindingLocationClassification.DoesNotExist:
-        return JsonResponse({"error": "Location classification not found", "location_choices": []}, status=404)
-
-@require_GET
-def get_morphology_choices(request, morphology_id):
-    """Fetch morphology choices dynamically based on FindingMorphologyClassification."""
-    try:
-        morphology_classification = FindingMorphologyClassification.objects.get(id=morphology_id)
-        morphology_choices = FindingMorphologyClassificationType.objects.filter(
-            id=morphology_classification.classification_type_id
-        )
-        data = [{"id": choice.id, "name": choice.name} for choice in morphology_choices]
-        return JsonResponse({"morphology_choices": data})
-    except ObjectDoesNotExist:
-        return JsonResponse({"error": "Morphology classification not found", "morphology_choices": []}, status=404)
-    except Exception as e:
-        return JsonResponse({"error": "Internal server error", "morphology_choices": []}, status=500)

endoreg_db/views/raw_pdf_anony_text_validation_views.py

@@ -1,95 +0,0 @@
-from rest_framework.views import APIView
-from rest_framework.response import Response
-from rest_framework import status
-from django.http import FileResponse, Http404
-import os, mimetypes
-from ..models import RawPdfFile
-from ..serializers.raw_pdf_anony_text_validation import RawPdfAnonyTextSerializer
-
-class RawPdfAnonyTextView(APIView):
-    """
-    API for:
-    - Fetching PDF metadata including `anonymized_text`.
-    - Fetching the next available PDF.
-    - Serving the actual PDF file.
-    """
-
-    def get(self, request):
-        """
-        Handles:
-        - First available PDF if `last_id` is NOT provided.
-        - Next available PDF if `last_id` is provided.
-        - Returns the actual PDF file if `id` is provided.
-        """
-
-        pdf_id = request.GET.get("id")
-        last_id = request.GET.get("last_id")
-
-        if pdf_id:
-            return self.serve_pdf_file(pdf_id)
-        else:
-            return self.fetch_pdf_metadata(last_id)
-
-    def fetch_pdf_metadata(self, last_id):
-        """
-        Fetches the next available PDF metadata, including `anonymized_text`.
-        """
-        pdf_entry = RawPdfAnonyTextSerializer.get_next_pdf(last_id)
-
-        if pdf_entry is None:
-            return Response({"error": "No more PDFs available."}, status=status.HTTP_404_NOT_FOUND)
-
-        serialized_pdf = RawPdfAnonyTextSerializer(pdf_entry, context={'request': self.request})
-        return Response(serialized_pdf.data, status=status.HTTP_200_OK)
-
-    def serve_pdf_file(self, pdf_id):
-        """
-        Serves the actual PDF file for viewing.
-        """
-        try:
-            pdf_entry = RawPdfFile.objects.get(id=pdf_id)
-            if not pdf_entry.file:
-                return Response({"error": "PDF file not found."}, status=status.HTTP_404_NOT_FOUND)
-
-            full_pdf_path = pdf_entry.file.path
-            if not os.path.exists(full_pdf_path):
-                raise Http404("PDF file not found on server.")
-
-            mime_type, _ = mimetypes.guess_type(full_pdf_path)
-            response = FileResponse(open(full_pdf_path, "rb"), content_type=mime_type or "application/pdf")
-            response["Content-Disposition"] = f'inline; filename="{os.path.basename(full_pdf_path)}"'
-            return response
-
-        except RawPdfFile.DoesNotExist:
-            return Response({"error": "Invalid PDF ID."}, status=status.HTTP_400_BAD_REQUEST)
-        except Exception as e:
-            return Response({"error": f"Internal error: {str(e)}"}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
-
-
-class UpdateAnonymizedTextView(APIView):
-    """
-    API to update only `anonymized_text` in `RawPdfFile`
-    """
-
-    def patch(self, request):
-        """
-        Updates `anonymized_text` for a given `pdf_id`.
-        """
-        pdf_id = request.data.get("id")
-
-        if not pdf_id:
-            return Response({"error": "pdf_id is required."}, status=status.HTTP_400_BAD_REQUEST)
-
-        try:
-            pdf_entry = RawPdfFile.objects.get(id=pdf_id)
-        except RawPdfFile.DoesNotExist:
-            return Response({"error": "PDF not found."}, status=status.HTTP_404_NOT_FOUND)
-
-        serializer = RawPdfAnonyTextSerializer(pdf_entry, data=request.data, partial=True)
-
-        if serializer.is_valid():
-            serializer.save()
-            return Response({"message": "PDF anonymized_text updated successfully.", "updated_data": serializer.data},
-                            status=status.HTTP_200_OK)
-
-        return Response({"error": "Invalid data.", "details": serializer.errors}, status=status.HTTP_400_BAD_REQUEST)

endoreg_db/views/raw_pdf_meta_validation_views.py

@@ -1,111 +0,0 @@
-from rest_framework.views import APIView
-from rest_framework.response import Response
-from rest_framework import status
-from django.http import FileResponse, Http404
-import mimetypes
-import os
-from ..models import RawPdfFile
-from ..serializers.raw_pdf_meta_validation import PDFFileForMetaSerializer
-
-
-class PDFFileForMetaView(APIView):
-    """
-    API endpoint to:
-    - Fetch PDF metadata if `id` is NOT provided.
-    - Serve the actual PDF file if `id` is provided.
-    """
-
-    def get(self, request):
-        """
-        Handles both:
-        Fetching PDF metadata** (if `id` is NOT provided)
-         Serving the actual PDF file** (if `id` is provided)
-        """
-
-        pdf_id = request.GET.get("id")  # Check if 'id' is provided in the query params
-        last_id = request.GET.get("last_id")  # Check if 'last_id' is provided for pagination
-
-        if pdf_id:
-            return self.serve_pdf_file(pdf_id)  # Serve the actual PDF file
-        else:
-            return self.fetch_pdf_metadata(last_id)  # Fetch metadata for the first or next PDF
-
-    def fetch_pdf_metadata(self, last_id):
-        """
-        Fetches the first or next available PDF metadata.
-        """
-        pdf_entry = PDFFileForMetaSerializer.get_next_pdf(last_id)
-
-        if pdf_entry is None:
-            return Response({"error": "No more PDFs available."}, status=status.HTTP_404_NOT_FOUND)
-
-        serialized_pdf = PDFFileForMetaSerializer(pdf_entry, context={'request': self.request})
-
-        print("Debugging API Response:")
-        print("Serialized Data:", serialized_pdf.data)  # Debugging
-        return Response(serialized_pdf.data, status=status.HTTP_200_OK)
-    
-    def serve_pdf_file(self, pdf_id):
-        """
-        Serves the actual PDF file for download or viewing.
-        """
-        try:
-            pdf_entry = RawPdfFile.objects.get(id=pdf_id)  # Get the PDF file by ID
-
-            if not pdf_entry.file:
-                return Response({"error": "PDF file not found."}, status=status.HTTP_404_NOT_FOUND)
-
-            full_pdf_path = pdf_entry.file.path  # Get the absolute file path
-
-            if not os.path.exists(full_pdf_path):
-                raise Http404("PDF file not found on server.")
-
-            mime_type, _ = mimetypes.guess_type(full_pdf_path)  # Detect file type
-            response = FileResponse(open(full_pdf_path, "rb"), content_type=mime_type or "application/pdf")
-
-            response["Content-Disposition"] = f'inline; filename="{os.path.basename(full_pdf_path)}"'  # Allows direct viewing
-
-            return response  # Sends the PDF file as a stream
-
-        except RawPdfFile.DoesNotExist:
-            return Response({"error": "Invalid PDF ID."}, status=status.HTTP_400_BAD_REQUEST)
-
-        except Exception as e:
-            return Response({"error": f"Internal error: {str(e)}"}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
-
-from rest_framework.views import APIView
-from rest_framework.response import Response
-from rest_framework import status
-from ..models import SensitiveMeta
-from ..serializers.raw_pdf_meta_validation import SensitiveMetaUpdateSerializer
-
-class UpdateSensitiveMetaView(APIView):
-    """
-    API endpoint to update patient details in the SensitiveMeta table.
-    Handles partial updates (only edited fields).
-    """
-
-    def patch(self, request, *args, **kwargs):
-        """
-        Updates the provided fields for a specific patient record.
-        Only updates fields that are sent in the request.
-        """
-        sensitive_meta_id = request.data.get("sensitive_meta_id")  # Required field
-
-        if not sensitive_meta_id:
-            return Response({"error": "sensitive_meta_id is required."}, status=status.HTTP_400_BAD_REQUEST)
-
-        try:
-            sensitive_meta = SensitiveMeta.objects.get(id=sensitive_meta_id)
-        except SensitiveMeta.DoesNotExist:
-            return Response({"error": "Patient record not found."}, status=status.HTTP_404_NOT_FOUND)
-
-        # Serialize the request data with partial=True to allow partial updates
-        serializer = SensitiveMetaUpdateSerializer(sensitive_meta, data=request.data, partial=True)
-
-        if serializer.is_valid():
-            serializer.save()
-            return Response({"message": "Patient information updated successfully.", "updated_data": serializer.data},
-                            status=status.HTTP_200_OK)
-        
-        return Response({"error": "Invalid data.", "details": serializer.errors}, status=status.HTTP_400_BAD_REQUEST)