From 7531a1cbfad3b878faf14c465bc8b01caea4280b Mon Sep 17 00:00:00 2001 From: Louis Mazin Date: Fri, 26 Sep 2025 17:51:43 +0200 Subject: [PATCH] big translation --- .env.example | 8 - app/core/alert_manager.py | 1 - app/core/dicom_manager.py | 387 ++++++++++++++++++++ app/core/export_manager.py | 567 +++++++++++++++++++++++++++++ app/core/main_manager.py | 13 +- app/core/observer_manager.py | 1 + app/core/theme_manager.py | 7 + app/core/update_manager.py | 2 +- app/ui/main_window.py | 33 +- app/ui/widgets/drag_drop_frame.py | 59 +++ app/ui/widgets/image_viewer.py | 176 +++++++++ app/ui/widgets/loading_bar.py | 16 +- app/ui/widgets/subfolder_widget.py | 107 ++++++ app/ui/windows/dicom_window.py | 507 ++++++++++++++++++++++++++ app/ui/windows/export_window.py | 370 +++++++++++++++++++ app/ui/windows/import_window.py | 330 +++++++++++++++++ app/ui/windows/settings_window.py | 60 +-- app/ui/windows/splash_screen.py | 2 +- app/utils/image_editor.py | 30 ++ app/utils/paths.py | 2 + config.json | 4 +- data/assets/back.svg | 6 + data/assets/export.svg | 4 + data/assets/first.svg | 7 + data/assets/folder.svg | 3 + data/assets/ghla.png | Bin 0 -> 56371 bytes data/assets/ghla.svg | 1 + data/assets/icon.icns | Bin 55740 -> 7114800 bytes data/assets/icon.ico | Bin 8591 -> 24757 bytes data/assets/icon.png | Bin 16156 -> 66468 bytes data/assets/import.svg | 4 + data/assets/last.svg | 7 + data/assets/mia.png | Bin 0 -> 54710 bytes data/assets/next.svg | 6 + data/assets/play.svg | 6 + data/assets/stop.svg | 18 + data/lang/en.json | 47 ++- data/lang/es.json | 77 ++++ data/lang/fr.json | 47 ++- data/themes/dark.json | 2 +- data/themes/light.json | 2 +- main.py | 13 +- requirements.txt | 8 +- 43 files changed, 2873 insertions(+), 67 deletions(-) delete mode 100644 .env.example create mode 100644 app/core/dicom_manager.py create mode 100644 app/core/export_manager.py create mode 100644 app/ui/widgets/drag_drop_frame.py create mode 100644 app/ui/widgets/image_viewer.py create mode 100644 app/ui/widgets/subfolder_widget.py create mode 100644 app/ui/windows/dicom_window.py create mode 100644 app/ui/windows/export_window.py create mode 100644 app/ui/windows/import_window.py create mode 100644 app/utils/image_editor.py create mode 100644 data/assets/back.svg create mode 100644 data/assets/export.svg create mode 100644 data/assets/first.svg create mode 100644 data/assets/folder.svg create mode 100644 data/assets/ghla.png create mode 100644 data/assets/ghla.svg create mode 100644 data/assets/import.svg create mode 100644 data/assets/last.svg create mode 100644 data/assets/mia.png create mode 100644 data/assets/next.svg create mode 100644 data/assets/play.svg create mode 100644 data/assets/stop.svg create mode 100644 data/lang/es.json diff --git a/.env.example b/.env.example deleted file mode 100644 index 16bd4e2..0000000 --- a/.env.example +++ /dev/null @@ -1,8 +0,0 @@ -# Python Configuration -PYTHON_PATH=C:/Path/To/Your/Python/python.exe - -# Email configuration for suggestion system -EMAIL_ADDRESS=your_email@gmail.com -EMAIL_PASSWORD=your_app_password -EMAIL_SMTP_SERVER=smtp.gmail.com -EMAIL_SMTP_PORT=587 diff --git a/app/core/alert_manager.py b/app/core/alert_manager.py index c969486..edfb1c7 100644 --- a/app/core/alert_manager.py +++ b/app/core/alert_manager.py @@ -1,5 +1,4 @@ from PyQt6.QtWidgets import QMessageBox -from typing import Optional class AlertManager: diff --git a/app/core/dicom_manager.py b/app/core/dicom_manager.py new file mode 100644 index 0000000..2420189 --- /dev/null +++ b/app/core/dicom_manager.py @@ -0,0 +1,387 @@ +from numpy import clip, stack, array +from os import path, listdir +from pydicom import dcmread +from PyQt6.QtGui import QImage, QIcon, QPixmap +from pydicom.multival import MultiValue +from pydicom.fileset import FileSet +from app.core.export_manager import ExportCategory +from PyQt6.QtCore import QObject, pyqtSignal +import json, pandas +class Dicom: + def __init__(self, files=None, name='', path=None): + self.childs = files or [] # Default to empty list + self.name = name + self.path = path + self.mask = None + self.category = ExportCategory.A + self.export = False # Default export status + + def set_export(self, export): + """Set the export status of this dicom""" + if not isinstance(export, bool): + raise ValueError("Export status must be a boolean") + self.export = export + + def get_export(self): + """Get the export status of this dicom""" + return self.export + + def get_category(self): + """Get the category associated with this dicom""" + return self.category + + def set_category(self, category): + self.category = category + + def get_mask(self): + """Get the mask associated with this dicom""" + return self.mask + + def set_mask(self, mask): + """Set the mask for this dicom""" + self.mask = mask + + def get_path(self): + return self.path + + def add_file_or_folder(self, file): + if file not in self.childs: + self.childs.append(file) + + def add_files_or_folders(self, files): + self.childs.extend(file for file in files if file not in self.childs) + + def get_icon(self): + return self.childs[0].get_icon() if self.childs else None + + def get_subfolders(self): + return [child for child in self.childs if isinstance(child, Dicom)] + + def get_files(self): + return [child for child in self.childs if isinstance(child, DicomFile)] + + def get_children_types(self): + return type(self.childs[0]) if self.childs else None + + def get_name(self): + return self.name + + def is_empty(self): + return len(self.childs) == 0 + + def export_metadata_json(self, destPath): + dicom_file = self.get_files()[0] if self.get_files() else None + if dicom_file: + dicom_file.export_metadata_json(destPath) + def export_metadata_xls(self, destPath): + dicom_file = self.get_files()[0] if self.get_files() else None + if dicom_file: + dicom_file.export_metadata_xls(destPath) + def __repr__(self): + return f"Dicom(name={self.name}, path={self.path}, files={len(self.childs)}, mask={self.mask is not None}, export={self.export}, category={self.category})" + +class DicomFile: + def __init__(self, file_path): + self.file_path = file_path + self.name = path.basename(file_path) + self.image = None + self.icon = None + self.is_valid = None # Changed to None for lazy validation + self.error_message = None + self.ds = None # Don't load immediately + self._metadata_loaded = False + + def _ensure_loaded(self): + """Lazy loading of DICOM dataset""" + if self.ds is None and self.is_valid is None: + try: + # Use more aggressive deferring + self.ds = dcmread(self.file_path, defer_size="1 KB", stop_before_pixels=True) + self.is_valid = True + except Exception as e: + self.is_valid = False + self.error_message = str(e) + self.ds = None + + def _ensure_pixel_data_loaded(self): + """Load pixel data only when needed""" + if self.ds is not None and not hasattr(self.ds, 'pixel_array'): + try: + # Reload with pixel data + self.ds = dcmread(self.file_path, defer_size="100 MB") + except Exception as e: + pass + + def get_image(self): + self._ensure_loaded() + if not self.is_valid: + return None + if self.image is None: + self._ensure_pixel_data_loaded() + self.image = self.get_scaled_image() + return self.image + + def get_name(self): + return self.name + + def get_icon(self): + self._ensure_loaded() + if not self.is_valid: + return None + if self.icon is None: + try: + image = self.get_image() + if image is not None: + self.icon = QIcon(QPixmap.fromImage(DicomManager().array_to_image(image))) + except Exception: + self.icon = None + return self.icon + + def get_scaled_image(self): + self._ensure_loaded() + if not self.is_valid or self.ds is None: + return None + + self._ensure_pixel_data_loaded() + + try: + if not hasattr(self.ds, 'pixel_array'): + return None + + float_array = self.ds.pixel_array.astype('float32') + slope = getattr(self.ds, 'RescaleSlope', 1.0) + intercept = getattr(self.ds, 'RescaleIntercept', 0.0) + float_array = float_array * slope + intercept + + if self.ds.get('PhotometricInterpretation', '').upper() == 'MONOCHROME1': + float_array = float_array.max() - float_array + + window_center = self.ds.get('WindowCenter', None) + window_width = self.ds.get('WindowWidth', None) + + if isinstance(window_center, MultiValue): window_center = window_center[0] + if isinstance(window_width, MultiValue): window_width = window_width[0] + + if window_center is not None and window_width is not None and float(window_width) > 0: + lo = float(window_center) - float(window_width) / 2 + hi = float(window_center) + float(window_width) / 2 + float_array = clip(float_array, lo, hi) + else: + float_array = clip(float_array, float_array.min(), float_array.max()) + + float_array = ((float_array - float_array.min()) / (float_array.max() - float_array.min()) * 255.0).astype('uint8') + if float_array.ndim == 2: # Grayscale image + float_array = stack([float_array, float_array, float_array], axis=-1) + return float_array + except Exception as e: + return None + + def get_metadata(self, metadata : str): + return self.ds.get(metadata, "") + + def get_all_metadata(self): + """Get all metadata with proper type conversion for JSON serialization""" + self._ensure_loaded() + if not self.ds: + return {} + + # Load full dataset for metadata export + if not self._metadata_loaded: + try: + self.ds = dcmread(self.file_path, defer_size="100 MB") + self._metadata_loaded = True + except: + return {} + + metadata = {} + for tag in self.ds.keys(): + try: + element = self.ds[tag] + value = element.value + + # Convert various DICOM types to JSON-serializable types + if hasattr(value, '__iter__') and not isinstance(value, (str, bytes)): + # Handle sequences and arrays + try: + value = list(value) + except: + value = str(value) + elif hasattr(value, 'decode') and callable(value.decode): + # Handle bytes + try: + value = value.decode('utf-8', errors='ignore') + except: + value = str(value) + else: + # Convert other types to string if they're not basic types + if not isinstance(value, (str, int, float, bool, type(None))): + value = str(value) + + # Use tag name if available, otherwise use hex representation + tag_name = element.name if hasattr(element, 'name') and element.name else str(tag) + metadata[tag_name] = value + + except Exception as e: + # If there's any error with a specific tag, skip it + continue + + return metadata + + def set_metadata(self, metadata, value): + if not isinstance(metadata, str): + raise ValueError("Metadata key must be a string") + if not isinstance(value, (str, int, float)): + raise ValueError("Metadata value must be a string, int, or float") + self.ds[metadata] = value + + def export_metadata_json(self, destPath): + """Export metadata to JSON with proper error handling""" + try: + metadata = self.get_all_metadata() + json_path = path.join(destPath, f"{self.name}_metadata.json") + + with open(json_path, 'w', encoding='utf-8') as json_file: + json.dump(metadata, json_file, indent=4, ensure_ascii=False, default=str) + + except Exception as e: + # Re-raise with more context + raise Exception(f"Error exporting JSON for {self.name}: {str(e)}") + + def export_metadata_xls(self, destPath): + """Export metadata to XLS with proper error handling""" + try: + metadata = self.get_all_metadata() + + # Convert to list of tuples for pandas + metadata_list = [(tag, value) for tag, value in metadata.items()] + + df = pandas.DataFrame(metadata_list, columns=['Tag', 'Value']) + xls_path = path.join(destPath, f"{self.name}_metadata.xlsx") + + # Use xlsxwriter engine for better compatibility + with pandas.ExcelWriter(xls_path, engine='openpyxl') as writer: + df.to_excel(writer, sheet_name='Metadata', index=False) + + except Exception as e: + # Re-raise with more context + raise Exception(f"Error exporting XLS for {self.name}: {str(e)}") + def extract_metadata(self, imagePath, toGet=[]): + if not isinstance(imagePath, str): + raise ValueError("Image path must be a string") + try: + file_set = FileSet(imagePath) + for record in file_set: + metadata = record.get_metadata() + if not metadata: + continue + # Extract only the requested metadata keys + if toGet: + return {key: metadata.get(key, "") for key in toGet} + else: + return metadata + except Exception as e: + return {} + + def __repr__(self): + return f"DicomFile(path={self.file_path}, name={self.name})" + +class DicomManager(QObject): + progress_changed = pyqtSignal(int) + error_occurred = pyqtSignal(str) # New signal for errors + + def __init__(self, dicoms=[]): + super().__init__() + self.dicoms = dicoms + + def add_dicom(self, dicom): + if isinstance(dicom, Dicom): + self.dicoms.append(dicom) + elif isinstance(dicom, str): + self.dicoms.append(self.process_dicomdir(dicom)) + elif isinstance(dicom, list): + for item in dicom: + self.add_dicom(item) + else: + raise TypeError("Expected Dicom or str, got {}".format(type(dicom))) + + def get_dicoms(self): + return self.dicoms + + def get_dicom_paths(self): + return [dicom.get_path() for dicom in self.dicoms] + + def process_dicomdir(self, dicomdirPath): + try: + if dicomdirPath.endswith('DICOMDIR'): + image_files = [] + subDirs = [] + currentName = "" + ds = dcmread(dicomdirPath) + if hasattr(ds, 'DirectoryRecordSequence'): + basePath = path.dirname(dicomdirPath) + total_records = len(ds.DirectoryRecordSequence) + + for i, record in enumerate(ds.DirectoryRecordSequence): + # Emit progress for DICOM processing + if i % 5 == 0: # More frequent updates + progress = int((i / total_records) * 100) + self.progress_changed.emit(progress) + + if record.DirectoryRecordType == "IMAGE" and hasattr(record, 'ReferencedFileID'): + relativePath = path.join(*record.ReferencedFileID) + imagePath = path.join(basePath, relativePath) + name = record.ReferencedFileID[-2] + if name != currentName: + if currentName: + subDirs.append(Dicom(image_files,currentName)) + currentName = name + image_files = [] + + # Create DicomFile without immediate validation + dicom_file = DicomFile(imagePath) + image_files.append(dicom_file) + + if image_files: # Don't forget the last group + subDirs.append(Dicom(image_files,currentName)) + + if len(subDirs) <= 1 and len(image_files) > 0: + return Dicom(image_files, path.basename(path.dirname(dicomdirPath)), dicomdirPath) + return Dicom(subDirs, path.basename(path.dirname(dicomdirPath)), dicomdirPath) + elif dicomdirPath.endswith('.dcm'): + # Process single DCM file with lazy loading + dicom_file = DicomFile(dicomdirPath) + return Dicom([dicom_file], path.basename(dicomdirPath), dicomdirPath) + else: + # Process directory containing DCM files + dcm_files = [] + file_list = [f for f in listdir(dicomdirPath) if f.lower().endswith('.dcm')] + total_files = len(file_list) + + for i, dcm_file in enumerate(file_list): + # Emit progress for DCM file processing + if i % 10 == 0: # Update every 10 files + progress = int((i / total_files) * 100) + self.progress_changed.emit(progress) + + # Create DicomFile without immediate validation + dicom_file = DicomFile(path.join(dicomdirPath, dcm_file)) + dcm_files.append(dicom_file) + + # Create Dicom object with all files (validation will happen later) + if dcm_files: + return Dicom(dcm_files, path.basename(dicomdirPath), dicomdirPath) + else: + return None + + except Exception as e: + self.error_occurred.emit("load_error") + return None + + def image_to_array(self,qimg): + ptr = qimg.bits() + ptr.setsize(qimg.width() * qimg.height() * 3) + return array(ptr).reshape(qimg.height(), qimg.width(), 3) + + def array_to_image(self, arr): + h, w, ch = arr.shape + return QImage(arr.data, w, h, ch * w, QImage.Format.Format_RGB888).copy() \ No newline at end of file diff --git a/app/core/export_manager.py b/app/core/export_manager.py new file mode 100644 index 0000000..546e8d4 --- /dev/null +++ b/app/core/export_manager.py @@ -0,0 +1,567 @@ +import os +from reportlab.pdfgen import canvas +from reportlab.lib.pagesizes import A4 +import numpy as np +from PIL import Image +import app.utils.image_editor as image_editor +from PyQt6.QtCore import QObject, pyqtSignal +import pydicom +from pydicom.uid import generate_uid +from datetime import datetime + +class ExportCategory: + A = (180, 0, 0) + B = (0, 180, 0) + C = (0, 0, 180) + D = (180, 180, 0) + E = (180, 0, 180) + F = (0, 180, 180) + G = (120, 60, 0) + H = (60, 120, 0) + I = (0, 120, 60) + J = (120, 0, 60) + + # Noms lisibles pour les catégories + CATEGORY_NAMES = { + A: "Rouge", + B: "Vert", + C: "Bleu", + D: "Jaune", + E: "Magenta", + F: "Cyan", + G: "Marron", + H: "Olive", + I: "Teal", + J: "Bordeaux" + } + + @classmethod + def list(cls): + return [cls.A, cls.B, cls.C, cls.D, cls.E, cls.F, cls.G, cls.H, cls.I, cls.J] + + @classmethod + def get_name(cls, category): + """Get readable name for a category""" + return cls.CATEGORY_NAMES.get(category, f"Groupe_{category}") + +class ExportManager(QObject): + # Signaux pour le suivi de progression + progress_changed = pyqtSignal(int) + phase_changed = pyqtSignal(str) + export_finished = pyqtSignal(bool) # True = success, False = error + + def __init__(self, dicom_manager): + super().__init__() + self.export_data = [] # Placeholder for data to export + self.dicom_manager = dicom_manager + self.export_destination = None # Destination folder for exports + + def set_export_data(self, data): + self.export_data = data + + def set_export_destination(self, destination_path): + """Set the destination folder for exports""" + self.export_destination = destination_path + + def get_export_folder_name(self, root_name, category): + """Generate export folder name with readable category name""" + category_name = ExportCategory.get_name(category) + return f"{root_name}_{category_name}" + + def get_export_dicom_list(self): + result = [] + for parent in self.dicom_manager.get_dicoms(): + if parent is None or parent.is_empty(): # Skip None or empty entries + continue + + subfolders = parent.get_subfolders() + if subfolders: + result.append([parent, subfolders]) + else: + # For single files without subfolders, create a list with the parent itself + result.append([parent, [parent]]) + return result + + def fetch_export_data(self): + result = [] + for parent in self.dicom_manager.get_dicoms(): + if parent is None or parent.is_empty(): # Skip None or empty entries + continue + + subfolders = parent.get_subfolders() + + # Handle case where there are no subfolders (single file DICOMs) + if not subfolders: + if parent.get_export(): # Check if the parent itself is marked for export + result.append([parent, [parent]]) + continue + + # Filter only checked subfolders + checked_subfolders = [subfolder for subfolder in subfolders if subfolder.get_export()] + + if not checked_subfolders: + continue + + # Group subfolders by category + categories = {} + for subfolder in checked_subfolders: + category = subfolder.get_category() + if category not in categories: + categories[category] = [] + categories[category].append(subfolder) + + # Create separate lists for each category + for category, category_subfolders in categories.items(): + result.append([parent, category_subfolders]) + return result + + def export_images_as_pdf(self): + """Export images as PDF with progress tracking""" + self.phase_changed.emit("preparing_export") + data = self.fetch_export_data() + if not data: + self.export_finished.emit(False) + return False + + try: + total_files = 0 + # Count total files for progress calculation + for liste in data: + subfolders = liste[1] + for subfolder in subfolders: + files = subfolder.get_files() + total_files += len(files) + + if total_files == 0: + self.export_finished.emit(False) + return False + + self.phase_changed.emit("exporting_pdf") + processed_files = 0 + + for liste in data: + root = liste[0] + subfolders = liste[1] + + # Use readable category name and destination + folder_name = self.get_export_folder_name(root.get_name(), subfolders[0].get_category()) + base_path = self.export_destination if self.export_destination else os.getcwd() + pdf_path = os.path.join(base_path, f"{folder_name}.pdf") + c = canvas.Canvas(pdf_path) + first_image = True + + for subfolder in subfolders: + files = subfolder.get_files() + mask = subfolder.get_mask() + if not files: + continue + + for file in files: + image_array = file.get_image() + if image_array is not None: + # Apply mask if it exists + if mask is not None: + image_array = image_editor.apply_mask(image_array, mask) + + # Convert numpy array to PIL Image + if isinstance(image_array, np.ndarray): + if not first_image: + c.showPage() + first_image = False + + pil_image = Image.fromarray(image_array.astype('uint8')) + img_width, img_height = pil_image.size + c.setPageSize((img_width, img_height)) + c.drawInlineImage(pil_image, 0, 0, width=img_width, height=img_height) + + processed_files += 1 + progress = int((processed_files / total_files) * 100) + self.progress_changed.emit(progress) + + c.save() + + self.phase_changed.emit("export_complete") + self.export_finished.emit(True) + return True + + except Exception as e: + self.export_finished.emit(False) + return False + + def export_images_as_png(self): + """Export images as PNG with progress tracking""" + self.phase_changed.emit("preparing_export") + data = self.fetch_export_data() + if not data: + self.export_finished.emit(False) + return False + + try: + total_files = 0 + # Count total files for progress calculation + for liste in data: + subfolders = liste[1] + for subfolder in subfolders: + files = subfolder.get_files() + total_files += len(files) + + if total_files == 0: + self.export_finished.emit(False) + return False + + self.phase_changed.emit("exporting_png") + processed_files = 0 + + for liste in data: + root = liste[0] + subfolders = liste[1] + + # Use readable category name and destination + folder_name = self.get_export_folder_name(root.get_name(), subfolders[0].get_category()) + base_path = self.export_destination if self.export_destination else os.getcwd() + png_folder = os.path.join(base_path, folder_name) + os.makedirs(png_folder, exist_ok=True) + + for subfolder in subfolders: + files = subfolder.get_files() + mask = subfolder.get_mask() + if not files: + continue + + for file in files: + image_array = file.get_image() + if image_array is not None: + # Apply mask if it exists + if mask is not None: + image_array = image_editor.apply_mask(image_array, mask) + + # Convert numpy array to PIL Image + if isinstance(image_array, np.ndarray): + pil_image = Image.fromarray(image_array.astype('uint8')) + # Keep original filename + original_name = os.path.splitext(file.get_name())[0] + png_path = os.path.join(png_folder, f"{original_name}.png") + pil_image.save(png_path) + + processed_files += 1 + progress = int((processed_files / total_files) * 100) + self.progress_changed.emit(progress) + + self.phase_changed.emit("export_complete") + self.export_finished.emit(True) + return True + + except Exception as e: + self.export_finished.emit(False) + return False + + def export_metadata_as_json(self): + """Export metadata as JSON with progress tracking""" + self.phase_changed.emit("preparing_export") + data = self.fetch_export_data() + if not data: + self.export_finished.emit(False) + return False + + try: + total_subfolders = sum(len(liste[1]) for liste in data) + if total_subfolders == 0: + self.export_finished.emit(False) + return False + + self.phase_changed.emit("exporting_json") + processed_subfolders = 0 + + for liste in data: + root = liste[0] + subfolders = liste[1] + + # Use readable category name and destination + folder_name = self.get_export_folder_name(root.get_name(), subfolders[0].get_category()) + base_path = self.export_destination if self.export_destination else os.getcwd() + json_folder = os.path.join(base_path, folder_name) + os.makedirs(json_folder, exist_ok=True) + + for subfolder in subfolders: + try: + subfolder.export_metadata_json(json_folder) + except Exception as e: + # Continue with other subfolders even if one fails + continue + + processed_subfolders += 1 + progress = int((processed_subfolders / total_subfolders) * 100) + self.progress_changed.emit(progress) + + self.phase_changed.emit("export_complete") + self.export_finished.emit(True) + return True + + except Exception as e: + self.export_finished.emit(False) + return False + + def export_metadata_as_xls(self): + """Export metadata as XLS with progress tracking""" + self.phase_changed.emit("preparing_export") + data = self.fetch_export_data() + if not data: + self.export_finished.emit(False) + return False + + try: + total_subfolders = sum(len(liste[1]) for liste in data) + if total_subfolders == 0: + self.export_finished.emit(False) + return False + + self.phase_changed.emit("exporting_xls") + processed_subfolders = 0 + + for liste in data: + root = liste[0] + subfolders = liste[1] + + # Use readable category name and destination + folder_name = self.get_export_folder_name(root.get_name(), subfolders[0].get_category()) + base_path = self.export_destination if self.export_destination else os.getcwd() + xls_folder = os.path.join(base_path, folder_name) + os.makedirs(xls_folder, exist_ok=True) + + for subfolder in subfolders: + try: + subfolder.export_metadata_xls(xls_folder) + except Exception as e: + # Continue with other subfolders even if one fails + continue + + processed_subfolders += 1 + progress = int((processed_subfolders / total_subfolders) * 100) + self.progress_changed.emit(progress) + + self.phase_changed.emit("export_complete") + self.export_finished.emit(True) + return True + + except Exception as e: + self.export_finished.emit(False) + return False + + def export_images_as_dicomdir(self): + """Export images as DICOMDIR with progress tracking""" + self.phase_changed.emit("preparing_export") + data = self.fetch_export_data() + if not data: + self.export_finished.emit(False) + return False + + try: + total_files = 0 + # Count total files for progress calculation + for liste in data: + subfolders = liste[1] + for subfolder in subfolders: + files = subfolder.get_files() + total_files += len(files) + + if total_files == 0: + self.export_finished.emit(False) + return False + + self.phase_changed.emit("exporting_dicomdir") + processed_files = 0 + + for liste in data: + root = liste[0] + subfolders = liste[1] + + # Use readable category name and destination + folder_name = self.get_export_folder_name(root.get_name(), subfolders[0].get_category()) + base_path = self.export_destination if self.export_destination else os.getcwd() + dicom_folder = os.path.join(base_path, f"{folder_name}_DICOMDIR") + os.makedirs(dicom_folder, exist_ok=True) + + # Create DICOM directory structure with proper hierarchy + study_uid = generate_uid() + + for i, subfolder in enumerate(subfolders): + files = subfolder.get_files() + mask = subfolder.get_mask() + if not files: + continue + + # Create series folder with original subfolder name + series_uid = generate_uid() + series_folder = os.path.join(dicom_folder, subfolder.get_name()) + os.makedirs(series_folder, exist_ok=True) + + for j, file in enumerate(files): + try: + # Get original DICOM dataset + if not file.ds: + continue + + # Create a deep copy of the dataset + new_ds = pydicom.dcmread(file.file_path) + + # Apply mask to pixel data if mask exists + if mask is not None: + image_array = file.get_image() + if image_array is not None: + # Apply mask + masked_array = image_editor.apply_mask(image_array, mask) + + # Convert RGB back to grayscale for DICOM storage + if len(masked_array.shape) == 3: + # Convert RGB to grayscale using standard weights + grayscale = np.dot(masked_array[...,:3], [0.2989, 0.5870, 0.1140]).astype(np.uint16) + else: + grayscale = masked_array.astype(np.uint16) + + # Update pixel data and related attributes + new_ds.PixelData = grayscale.tobytes() + new_ds.Rows = int(grayscale.shape[0]) + new_ds.Columns = int(grayscale.shape[1]) + new_ds.BitsAllocated = 16 + new_ds.BitsStored = 16 + new_ds.HighBit = 15 + new_ds.SamplesPerPixel = 1 + new_ds.PhotometricInterpretation = 'MONOCHROME2' + + # Update required DICOM attributes for DICOMDIR + new_ds.StudyInstanceUID = study_uid + new_ds.SeriesInstanceUID = series_uid + new_ds.SOPInstanceUID = generate_uid() + new_ds.InstanceNumber = str(j + 1) + new_ds.SeriesNumber = str(i + 1) + + # Ensure required attributes exist + if not hasattr(new_ds, 'StudyID'): + new_ds.StudyID = '1' + if not hasattr(new_ds, 'SeriesDescription'): + new_ds.SeriesDescription = subfolder.get_name() + if not hasattr(new_ds, 'StudyDescription'): + new_ds.StudyDescription = root.get_name() + if not hasattr(new_ds, 'PatientName'): + new_ds.PatientName = 'Anonymous' + if not hasattr(new_ds, 'PatientID'): + new_ds.PatientID = 'ANON001' + if not hasattr(new_ds, 'StudyDate'): + new_ds.StudyDate = datetime.now().strftime('%Y%m%d') + if not hasattr(new_ds, 'StudyTime'): + new_ds.StudyTime = datetime.now().strftime('%H%M%S') + + + # Save modified DICOM file with original name + original_name = os.path.splitext(file.get_name())[0] + output_path = os.path.join(series_folder, original_name) + + # Save without file extension for DICOMDIR compatibility + new_ds.save_as(output_path, write_like_original=False) + + except Exception as e: + continue + + processed_files += 1 + progress = int((processed_files / total_files) * 90) + self.progress_changed.emit(progress) + + # Create DICOMDIR file + self.progress_changed.emit(95) + success = self._create_dicomdir_file(dicom_folder) + if not success: + # If DICOMDIR creation fails, still consider export successful + # but create a simple index file + self._create_simple_index(dicom_folder) + + self.phase_changed.emit("export_complete") + self.export_finished.emit(True) + return True + + except Exception as e: + self.export_finished.emit(False) + return False + + def _create_dicomdir_file(self, dicom_folder): + """Create a proper DICOMDIR file""" + try: + # Create DICOMDIR manually since pydicom's FileSet might have issues + from pydicom.dataset import Dataset, FileDataset + from pydicom import uid + + # Create the DICOMDIR dataset + file_meta = Dataset() + file_meta.MediaStorageSOPClassUID = uid.MediaStorageDirectoryStorage + file_meta.MediaStorageSOPInstanceUID = generate_uid() + file_meta.ImplementationClassUID = generate_uid() + file_meta.TransferSyntaxUID = uid.ExplicitVRLittleEndian + + # Create main dataset + ds = FileDataset('DICOMDIR', {}, file_meta=file_meta, preamble=b"\0" * 128) + ds.FileSetID = 'EXPORTED_STUDY' + ds.DirectoryRecordSequence = [] + + # Add directory records for each DICOM file + for root, dirs, files in os.walk(dicom_folder): + for file in files: + if not file.startswith('IM'): # Only process our DICOM files + continue + + file_path = os.path.join(root, file) + try: + # Read the DICOM file to get metadata + file_ds = pydicom.dcmread(file_path) + + # Create directory record + record = Dataset() + record.DirectoryRecordType = 'IMAGE' + + # Set file reference + rel_path = os.path.relpath(file_path, dicom_folder) + # Convert path separators for DICOM + rel_path_parts = rel_path.replace('\\', '/').split('/') + record.ReferencedFileID = rel_path_parts + + # Add essential metadata + if hasattr(file_ds, 'StudyInstanceUID'): + record.StudyInstanceUID = file_ds.StudyInstanceUID + if hasattr(file_ds, 'SeriesInstanceUID'): + record.SeriesInstanceUID = file_ds.SeriesInstanceUID + if hasattr(file_ds, 'SOPInstanceUID'): + record.ReferencedSOPInstanceUIDInFile = file_ds.SOPInstanceUID + if hasattr(file_ds, 'InstanceNumber'): + record.InstanceNumber = file_ds.InstanceNumber + + ds.DirectoryRecordSequence.append(record) + + except Exception as e: + continue + + # Save DICOMDIR + dicomdir_path = os.path.join(dicom_folder, 'DICOMDIR') + ds.save_as(dicomdir_path, write_like_original=False) + return True + + except Exception as e: + return False + + def _create_simple_index(self, dicom_folder): + """Create a simple text index if DICOMDIR creation fails""" + try: + index_path = os.path.join(dicom_folder, 'INDEX.txt') + with open(index_path, 'w') as f: + f.write("DICOM Export Index\n") + f.write("==================\n\n") + + for root, dirs, files in os.walk(dicom_folder): + for file in files: + if file.startswith('IM'): + rel_path = os.path.relpath(os.path.join(root, file), dicom_folder) + f.write(f"{rel_path}\n") + except: + pass + + # Write DICOMDIR + dicomdir_path = os.path.join(dicom_folder, 'DICOMDIR') + f.write(dicomdir_path) + diff --git a/app/core/main_manager.py b/app/core/main_manager.py index 439b5c4..3a51516 100644 --- a/app/core/main_manager.py +++ b/app/core/main_manager.py @@ -4,6 +4,8 @@ from app.core.theme_manager import ThemeManager from app.core.settings_manager import SettingsManager from app.core.alert_manager import AlertManager from app.core.update_manager import UpdateManager +from app.core.dicom_manager import DicomManager +from app.core.export_manager import ExportManager from typing import Optional class MainManager: @@ -20,7 +22,8 @@ class MainManager: self.language_manager: LanguageManager = LanguageManager(self.settings_manager) self.alert_manager: AlertManager = AlertManager(self.language_manager, self.theme_manager) self.update_manager: UpdateManager = UpdateManager(self.settings_manager, self.language_manager, self.alert_manager) - + self.dicom_manager: DicomManager = DicomManager() + self.export_manager: ExportManager = ExportManager(self.dicom_manager) @classmethod def get_instance(cls) -> 'MainManager': if cls._instance is None: @@ -43,4 +46,10 @@ class MainManager: return self.alert_manager def get_update_manager(self) -> UpdateManager: - return self.update_manager \ No newline at end of file + return self.update_manager + + def get_dicom_manager(self) -> DicomManager: + return self.dicom_manager + + def get_export_manager(self) -> ExportManager: + return self.export_manager \ No newline at end of file diff --git a/app/core/observer_manager.py b/app/core/observer_manager.py index e1f8364..173880c 100644 --- a/app/core/observer_manager.py +++ b/app/core/observer_manager.py @@ -3,6 +3,7 @@ from typing import Callable, Dict, List, Any class NotificationType: THEME = 0 LANGUAGE = 1 + DICOM = 2 class ObserverManager: """ diff --git a/app/core/theme_manager.py b/app/core/theme_manager.py index 6cd9f9f..9f7f5da 100644 --- a/app/core/theme_manager.py +++ b/app/core/theme_manager.py @@ -155,4 +155,11 @@ class ThemeManager: #tab_bar {{ background-color: {self.current_theme.get_color("background_color")}; }} + #drag_area {{ + border: 2px dashed {self.current_theme.get_color("border_color")}; + }} + #drag_indicator {{ + border: 2px dashed #0078d7; + font-size: 60px; + }} """ \ No newline at end of file diff --git a/app/core/update_manager.py b/app/core/update_manager.py index 3eba809..159ee97 100644 --- a/app/core/update_manager.py +++ b/app/core/update_manager.py @@ -1,7 +1,7 @@ import requests from packaging import version from PyQt6.QtWidgets import QApplication -from PyQt6.QtWidgets import QFileDialog, QDialog, QVBoxLayout, QTextEdit, QPushButton, QHBoxLayout, QLabel +from PyQt6.QtWidgets import QFileDialog, QDialog, QVBoxLayout, QTextEdit, QPushButton from app.core.alert_manager import AlertManager from app.core.settings_manager import SettingsManager from app.core.language_manager import LanguageManager diff --git a/app/ui/main_window.py b/app/ui/main_window.py index f5c21c4..fa68f34 100644 --- a/app/ui/main_window.py +++ b/app/ui/main_window.py @@ -1,10 +1,13 @@ -from PyQt6.QtWidgets import QApplication, QMainWindow, QVBoxLayout, QLabel, QFrame +from PyQt6.QtWidgets import QApplication, QMainWindow, QLabel from PyQt6.QtGui import QResizeEvent, QCloseEvent -from PyQt6.QtCore import QSize, QEvent, Qt +from PyQt6.QtCore import QSize, QEvent from app.core.main_manager import MainManager, NotificationType from app.ui.widgets.tabs_widget import TabsWidget, MenuDirection, ButtonPosition, BorderSide, TabSide from app.ui.windows.settings_window import SettingsWindow from app.ui.windows.suggestion_window import SuggestionWindow +from app.ui.windows.dicom_window import DicomWindow +from app.ui.windows.export_window import ExportWindow +from app.ui.windows.import_window import ImportWindow import app.utils.paths as paths, shutil from typing import Optional @@ -19,7 +22,7 @@ class MainWindow(QMainWindow): self.settings_manager = self.main_manager.get_settings_manager() self.observer_manager = self.main_manager.get_observer_manager() self.observer_manager.subscribe(NotificationType.THEME, self.update_theme) - + self.observer_manager.subscribe(NotificationType.DICOM, self.goto_dicom_window) self.is_maximizing: bool = False self.current_size: QSize self.previous_size: QSize @@ -77,8 +80,6 @@ class MainWindow(QMainWindow): self.current_size.width(), self.current_size.height() ) - - # Nettoyage des icônes temporaires générées (supprime tout le dossier temp_icons à la fermeture) try: shutil.rmtree(paths.get_user_temp(self.settings_manager.get_config("app_name"))) except Exception: @@ -86,18 +87,30 @@ class MainWindow(QMainWindow): def setup_ui(self) -> None: - self.side_menu = TabsWidget(self, MenuDirection.HORIZONTAL, 70, None, 10, 1, BorderSide.BOTTOM, TabSide.TOP) + self.side_menu = TabsWidget(self, MenuDirection.VERTICAL, 70, None, 10, 1, BorderSide.LEFT, TabSide.LEFT) + + self.import_window = ImportWindow(self) + self.side_menu.add_widget(self.import_window, "", paths.get_asset_svg_path("import"), position=ButtonPosition.CENTER) + + self.dicom_window = DicomWindow(self) + self.side_menu.add_widget(self.dicom_window, "", paths.get_asset_svg_path("folder"), position=ButtonPosition.CENTER) + self.export_window = ExportWindow(self) + self.side_menu.add_widget(self.export_window, "", paths.get_asset_svg_path("export"), position=ButtonPosition.CENTER) self.suggestion_window = SuggestionWindow(self) - self.side_menu.add_widget(self.suggestion_window, "", paths.get_asset_svg_path("suggestion"), position=ButtonPosition.CENTER) + self.side_menu.add_widget(self.suggestion_window, "", paths.get_asset_svg_path("suggestion"), position=ButtonPosition.END) self.settings_window = SettingsWindow(self) - self.side_menu.add_widget(self.settings_window, "", paths.get_asset_svg_path("settings"), position=ButtonPosition.CENTER) - + self.side_menu.add_widget(self.settings_window, "", paths.get_asset_svg_path("settings"), position=ButtonPosition.END) + self.setCentralWidget(self.side_menu) def update_theme(self) -> None: self.setStyleSheet(self.theme_manager.get_sheet()) def update_language(self) -> None: - self.footer_label.setText(self.language_manager.get_text("footer_text")) \ No newline at end of file + self.footer_label.setText(self.language_manager.get_text("footer_text")) + + def goto_dicom_window(self): + """Navigate to DICOM window when DICOMs are imported""" + self.side_menu.switch_to_tab(1) \ No newline at end of file diff --git a/app/ui/widgets/drag_drop_frame.py b/app/ui/widgets/drag_drop_frame.py new file mode 100644 index 0000000..5f92dd0 --- /dev/null +++ b/app/ui/widgets/drag_drop_frame.py @@ -0,0 +1,59 @@ +from PyQt6.QtWidgets import QFrame, QLabel +from PyQt6.QtCore import Qt + +class DragDropFrame(QFrame): + def __init__(self, parent=None): + super().__init__(parent) + self.parent_window = parent + self.setAcceptDrops(True) + self.is_dragging = False + self.drag_indicator = self.getDragIndicator() + self.drag_text = self.getDragText() + + def dragEnterEvent(self, event): + if event.mimeData().hasUrls(): + self.is_dragging = True + self.drag_text.hide() + self.drag_indicator.show() + event.acceptProposedAction() + else: + event.ignore() + + def dragLeaveEvent(self, event): + self.is_dragging = False + self.drag_indicator.hide() + self.drag_text.show() + super().dragLeaveEvent(event) + + def dropEvent(self, event): + self.is_dragging = False + self.drag_indicator.hide() + self.drag_text.show() + urls = event.mimeData().urls() + if urls and self.parent_window: + file_path = urls[0].toLocalFile() + self.parent_window.set_dicom_from_files(file_path) + + def getDragIndicator(self) -> QLabel: + drag_indicator = QLabel(self) + drag_indicator.setText("+") + drag_indicator.setObjectName("drag_indicator") + drag_indicator.setAlignment(Qt.AlignmentFlag.AlignCenter) + drag_indicator.show() + return drag_indicator + + def getDragText(self) -> QLabel: + drag_text = QLabel(self) + drag_text.setObjectName("drag_area") + drag_text.setAlignment(Qt.AlignmentFlag.AlignCenter) + drag_text.show() + return drag_text + + def setDragText(self, text: str): + self.drag_text.setText(text) + + def resizeEvent(self, event): + super().resizeEvent(event) + # Ensure components fill the entire frame + self.drag_indicator.resize(self.size()) + self.drag_text.resize(self.size()) \ No newline at end of file diff --git a/app/ui/widgets/image_viewer.py b/app/ui/widgets/image_viewer.py new file mode 100644 index 0000000..dcabc30 --- /dev/null +++ b/app/ui/widgets/image_viewer.py @@ -0,0 +1,176 @@ +from PyQt6.QtCore import Qt +from PyQt6.QtGui import QPainter, QPixmap, QPen, QImage +from PyQt6.QtWidgets import QWidget +from app.core.main_manager import MainManager +import numpy as np + +class ImageViewer(QWidget): + def __init__(self, parent = None): + super().__init__(parent) + self.DicomWindow = parent + + self.main_manager = MainManager.get_instance() + self.dicom_manager = self.main_manager.get_dicom_manager() + + self.display_image = None + self.original_image = None + self.drawing = False + self.brush_size = 10 + self.current_stroke = [] # Points du trait en cours + self.last_point = None + self.setMouseTracking(True) + + def set_image(self, image): + self.original_image = image + self.display_image = QPixmap.fromImage(image) + self.update() + + def paintEvent(self, event): + _ = event + if self.display_image: + painter = QPainter(self) + scaled = self.display_image.scaled(self.size(), Qt.AspectRatioMode.KeepAspectRatio, Qt.TransformationMode.FastTransformation) + x = (self.width() - scaled.width()) // 2 + y = (self.height() - scaled.height()) // 2 + painter.drawPixmap(x, y, scaled) + + # Dessiner le trait en cours en temps réel avec la même taille que le brush + if self.drawing and len(self.current_stroke) > 1: + pen = QPen(Qt.GlobalColor.black, self.brush_size, Qt.PenStyle.SolidLine) + pen.setCapStyle(Qt.PenCapStyle.RoundCap) + pen.setJoinStyle(Qt.PenJoinStyle.RoundJoin) + painter.setPen(pen) + + # Dessiner des lignes entre les points pour un rendu fluide + for i in range(1, len(self.current_stroke)): + painter.drawLine( + int(self.current_stroke[i-1][0]), int(self.current_stroke[i-1][1]), + int(self.current_stroke[i][0]), int(self.current_stroke[i][1]) + ) + + def mousePressEvent(self, event): + if event.buttons() & Qt.MouseButton.LeftButton: + self.drawing = True + point = (event.position().x(), event.position().y()) + self.current_stroke = [point] + self.last_point = point + + def mouseMoveEvent(self, event): + if self.drawing: + current_point = (event.position().x(), event.position().y()) + + # Interpoler avec moins de points pour plus de fluidité + if self.last_point: + interpolated_points = self.interpolate_points(self.last_point, current_point, max_distance=3) + self.current_stroke.extend(interpolated_points) + else: + self.current_stroke.append(current_point) + + self.last_point = current_point + self.update() + + def mouseReleaseEvent(self, event): + if self.drawing: + self.drawing = False + mask = self.create_mask_from_stroke() + if mask is not None: + self.DicomWindow.apply_brush_mask(mask) + self.current_stroke = [] + self.last_point = None + + def wheelEvent(self, event): + delta = event.angleDelta().y() + if delta != 0: + self.DicomWindow.scroll_images(1 if delta > 0 else -1) + event.accept() + + def screen_to_image_coords(self, x, y): + if not self.display_image: + return None + + scaled = self.display_image.scaled(self.size(), Qt.AspectRatioMode.KeepAspectRatio, Qt.TransformationMode.FastTransformation) + x_offset = (self.width() - scaled.width()) // 2 + y_offset = (self.height() - scaled.height()) // 2 + + # Vérifie que le point est dans l'image affichée + if not (x_offset <= x <= x_offset + scaled.width()) or not (y_offset <= y <= y_offset + scaled.height()): + return None + + # Ramène dans les coordonnées de l'image d'origine + img_x = (x - x_offset) * self.original_image.width() / scaled.width() + img_y = (y - y_offset) * self.original_image.height() / scaled.height() + return int(img_x), int(img_y) + + def interpolate_points(self, start_point, end_point, max_distance=2): + """Interpole les points avec une distance maximale réduite pour plus de fluidité""" + x1, y1 = start_point + x2, y2 = end_point + + # Calcule la distance entre les points + distance = max(abs(x2 - x1), abs(y2 - y1)) + + # Si la distance est petite, pas besoin d'interpoler + if distance <= max_distance: + return [end_point] + + # Crée des points intermédiaires avec une granularité plus fine + points = [] + steps = max(2, int(distance / max_distance)) + + for i in range(1, steps + 1): + t = i / steps + x = x1 + (x2 - x1) * t + y = y1 + (y2 - y1) * t + points.append((x, y)) + + return points + + def create_mask_from_stroke(self): + """Crée un mask en utilisant QPainter sur une QImage temporaire""" + if not self.original_image or len(self.current_stroke) < 1: + return None + + # Créer une QImage temporaire de même taille que l'image originale + mask_image = QImage(self.original_image.width(), self.original_image.height(), QImage.Format.Format_Grayscale8) + mask_image.fill(0) # Remplir de noir (0) + + # Calculer les paramètres d'affichage + scaled = self.display_image.scaled(self.size(), Qt.AspectRatioMode.KeepAspectRatio, Qt.TransformationMode.FastTransformation) + x_offset = (self.width() - scaled.width()) // 2 + y_offset = (self.height() - scaled.height()) // 2 + + scale_x = self.original_image.width() / scaled.width() + scale_y = self.original_image.height() / scaled.height() + + # Dessiner sur le mask avec QPainter + painter = QPainter(mask_image) + pen = QPen(Qt.GlobalColor.white, self.brush_size * scale_x, Qt.PenStyle.SolidLine) + pen.setCapStyle(Qt.PenCapStyle.RoundCap) + pen.setJoinStyle(Qt.PenJoinStyle.RoundJoin) + painter.setPen(pen) + + # Convertir et dessiner les points + for i in range(1, len(self.current_stroke)): + # Point précédent + sx1, sy1 = self.current_stroke[i-1] + img_x1 = (sx1 - x_offset) * scale_x + img_y1 = (sy1 - y_offset) * scale_y + + # Point actuel + sx2, sy2 = self.current_stroke[i] + img_x2 = (sx2 - x_offset) * scale_x + img_y2 = (sy2 - y_offset) * scale_y + + # Dessiner la ligne + painter.drawLine(int(img_x1), int(img_y1), int(img_x2), int(img_y2)) + + painter.end() + + # Convertir en numpy array + width = mask_image.width() + height = mask_image.height() + ptr = mask_image.constBits() + ptr.setsize(height * width) + mask_array = np.frombuffer(ptr, np.uint8).reshape((height, width)).copy() + + return mask_array \ No newline at end of file diff --git a/app/ui/widgets/loading_bar.py b/app/ui/widgets/loading_bar.py index bfc61b3..fa50439 100644 --- a/app/ui/widgets/loading_bar.py +++ b/app/ui/widgets/loading_bar.py @@ -5,7 +5,7 @@ class LoadingBar(QWidget): def __init__(self, label_text: str = "", parent=None) -> None: super().__init__(parent) layout = QVBoxLayout(self) - layout.setAlignment(Qt.AlignmentFlag.AlignCenter) + layout.setAlignment(Qt.AlignmentFlag.AlignBaseline) self.label = QLabel(label_text, self) self.progress = QProgressBar(self) self.progress.setMinimum(0) @@ -18,3 +18,17 @@ class LoadingBar(QWidget): def set_progress(self, value: int) -> None: self.progress.setValue(value) + + def set_progress_range(self, value: int, min_range: int, max_range: int) -> None: + """Set progress within a specific range""" + if min_range >= max_range: + return + # Clamp value to range + clamped_value = max(min_range, min(max_range, value)) + # Convert to 0-100 scale + progress = int(((clamped_value - min_range) / (max_range - min_range)) * 100) + self.progress.setValue(progress) + + def get_progress(self) -> int: + """Get current progress value""" + return self.progress.value() diff --git a/app/ui/widgets/subfolder_widget.py b/app/ui/widgets/subfolder_widget.py new file mode 100644 index 0000000..b4ea8bd --- /dev/null +++ b/app/ui/widgets/subfolder_widget.py @@ -0,0 +1,107 @@ +from PyQt6.QtWidgets import (QWidget, QVBoxLayout, QScrollArea, + QFrame, QHBoxLayout, QLabel) +from PyQt6.QtCore import pyqtSignal, Qt + +class SelectableWidgetItem(QFrame): + clicked = pyqtSignal(object) + + def __init__(self, dicom=None, parent=None): + super().__init__(parent) + self.selected = False + self.dicom = dicom + self.setup_ui(dicom.get_name(), dicom.get_icon()) + + def setup_ui(self, label_text, icon=None): + self.setFrameStyle(QFrame.Shape.Box) + self.setLineWidth(1) + + layout = QHBoxLayout(self) + + if icon: + try: + icon_label = QLabel() + icon_label.setPixmap(icon.pixmap(32, 32)) + layout.addWidget(icon_label) + except Exception: + # Skip icon if there's an error + pass + + if label_text: + label = QLabel(label_text) + layout.addWidget(label) + + def mousePressEvent(self, event): + if event.button() == Qt.MouseButton.LeftButton: + self.clicked.emit(self) + super().mousePressEvent(event) + + def set_selected(self, selected): + self.selected = selected +class SubfolderWidget(QWidget): + widgetSelected = pyqtSignal(object) + + def __init__(self, parent=None, dicoms=None): + super().__init__(parent) + self.parent = parent + self.widget_items = [] + self.selected_item = None + self.setup_ui() + if dicoms: + self.create_and_add_widgets(dicoms) + + def setup_ui(self): + layout = QVBoxLayout(self) + + self.scroll_area = QScrollArea() + self.scroll_area.setWidgetResizable(True) + + self.content_widget = QWidget() + self.content_layout = QVBoxLayout(self.content_widget) + self.content_layout.setAlignment(Qt.AlignmentFlag.AlignTop) + + self.scroll_area.setWidget(self.content_widget) + layout.addWidget(self.scroll_area) + + def add_widget(self, dicom): + """Add a widget to the list""" + item = SelectableWidgetItem(dicom, self) + item.clicked.connect(self.on_item_selected) + + self.widget_items.append(item) + self.content_layout.addWidget(item) + + def on_item_selected(self, item): + """Handle item selection""" + if self.selected_item: + self.selected_item.set_selected(False) + self.selected_item = None + + self.selected_item = item + item.set_selected(True) + + self.widgetSelected.emit(item.dicom) + + def get_selected_widget(self): + """Get the currently selected widget""" + if self.selected_item: + return self.selected_item + elif self.widget_items: + self.selected_item = self.widget_items[0] + return self.selected_item + return None + + def clear_widgets(self): + """Remove all widgets from the list""" + for item in self.widget_items: + self.content_layout.removeWidget(item) + item.deleteLater() + + self.widget_items.clear() + self.selected_item = None + + def create_and_add_widgets(self, dicoms): + for dicom in dicoms: + widget = SelectableWidgetItem(dicom, self) + widget.clicked.connect(self.on_item_selected) + self.widget_items.append(widget) + self.content_layout.addWidget(widget) \ No newline at end of file diff --git a/app/ui/windows/dicom_window.py b/app/ui/windows/dicom_window.py new file mode 100644 index 0000000..dc4ad0f --- /dev/null +++ b/app/ui/windows/dicom_window.py @@ -0,0 +1,507 @@ +from PyQt6.QtWidgets import ( + QWidget, QVBoxLayout, QHBoxLayout, QPushButton, QComboBox, + QLabel, QSlider, QSizePolicy, QStackedWidget, QGridLayout +) +from PyQt6.QtGui import QImage, QIcon +from PyQt6.QtCore import Qt, QTimer, QSize, pyqtSignal +import app.utils.paths as paths +import app.utils.image_editor as image_editor +from app.core.main_manager import MainManager, NotificationType +from app.ui.widgets.subfolder_widget import SubfolderWidget +from app.ui.widgets.image_viewer import ImageViewer +import os + +class DicomWindow(QWidget): + setup_progress = pyqtSignal(int) + + def __init__(self, parent=None): + super().__init__(parent) + + self.main_manager = MainManager.get_instance() + self.dicom_manager = self.main_manager.get_dicom_manager() + self.language_manager = self.main_manager.get_language_manager() + self.settings_manager = self.main_manager.get_settings_manager() + + self.observer_manager = self.main_manager.get_observer_manager() + self.observer_manager.subscribe(NotificationType.LANGUAGE, self.update_texts) + self.observer_manager.subscribe(NotificationType.DICOM, self.on_dicoms_imported) + + self.current_dicom_count = 0 # Track how many DICOMs we have displayed + self.current_image_index = 0 + self.timer = QTimer(self) + self.timer.timeout.connect(self.go_to_next) + self.selected_dicom = None + self.is_brush_enabled = False + self.init_ui() + + def init_ui(self): + self.main_layout = QVBoxLayout() + self.main_layout.setSpacing(5) + self.main_layout.setContentsMargins(10, 10, 10, 10) + self.setLayout(self.main_layout) + + # Create stacked widget for switching between states + self.stacked_widget = QStackedWidget() + self.main_layout.addWidget(self.stacked_widget) + self.create_no_dicom_widget() + self.create_dicom_viewer_widget() + + # Start with no dicom message + self.stacked_widget.setCurrentIndex(0) + + def on_dicoms_imported(self): + """Called when new DICOMs are imported""" + current_dicoms = self.dicom_manager.get_dicoms() + + # Check if we have new DICOMs to add + if len(current_dicoms) > self.current_dicom_count: + new_dicoms = current_dicoms[self.current_dicom_count:] + self.add_new_dicoms(new_dicoms) + self.current_dicom_count = len(current_dicoms) + + # Select the LAST imported DICOM (not the first) + if self.dicom_combobox.count() > 0: + self.stacked_widget.setCurrentIndex(1) + # Select the last item in the combobox (most recently added) + last_index = self.dicom_combobox.count() - 1 + self.dicom_combobox.setCurrentIndex(last_index) + self.on_dicom_selected(last_index) + + def add_new_dicoms(self, new_dicoms): + """Add only the new DICOMs to the combobox""" + if not new_dicoms: + return + + # Filter out invalid DICOMs + valid_dicoms = [d for d in new_dicoms if d is not None and not d.is_empty()] + + if not valid_dicoms: + return + + # Build set of existing DICOM paths (normalized) + existing_paths = set() + for i in range(self.dicom_combobox.count()): + existing_dicom = self.dicom_combobox.itemData(i) + if existing_dicom and existing_dicom.get_path(): + existing_paths.add(os.path.normpath(existing_dicom.get_path())) + + # Filter out DICOMs with paths that already exist in combobox + unique_dicoms = [] + for dicom in valid_dicoms: + if dicom.get_path(): + normalized_path = os.path.normpath(dicom.get_path()) + if normalized_path not in existing_paths: + unique_dicoms.append(dicom) + existing_paths.add(normalized_path) # Add to set to avoid duplicates within this batch + + if not unique_dicoms: + return + + # Temporarily disconnect the signal to avoid triggering during batch add + try: + self.dicom_combobox.currentIndexChanged.disconnect() + except: + pass + + # Add each unique DICOM to the combobox + for dicom in unique_dicoms: + try: + icon = dicom.get_icon() + if icon is not None: + self.dicom_combobox.addItem(icon, dicom.get_name(), dicom) + else: + self.dicom_combobox.addItem(dicom.get_name(), dicom) + except Exception as e: + continue + + # Reconnect the signal + self.dicom_combobox.currentIndexChanged.connect(self.on_dicom_selected) + + def setup_ui(self): + """Legacy method - now just calls on_dicoms_imported for compatibility""" + self.on_dicoms_imported() + + def empty_dicom_combobox(self): + """Empty the DICOM combobox and reset state""" + try: + self.dicom_combobox.currentIndexChanged.disconnect() + except: + pass + self.dicom_combobox.clear() + self.selected_dicom = None + self.current_dicom_count = 0 + + def create_no_dicom_widget(self): + """Create widget shown when no DICOM files are available""" + no_dicom_widget = QWidget() + no_dicom_layout = QVBoxLayout(no_dicom_widget) + no_dicom_layout.setContentsMargins(0, 0, 0, 0) + no_dicom_layout.setSpacing(0) + + self.no_dicom_label = QLabel(self.language_manager.get_text("no_dicom_files")) + self.no_dicom_label.setAlignment(Qt.AlignmentFlag.AlignCenter) + no_dicom_layout.addWidget(self.no_dicom_label) + + self.stacked_widget.addWidget(no_dicom_widget) + + def create_dicom_viewer_widget(self): + """Create widget shown when DICOM files are available""" + main_widget = QWidget() + main_layout = QHBoxLayout(main_widget) + main_layout.setContentsMargins(0, 0, 0, 0) + main_layout.setSpacing(10) + + left_layout = QVBoxLayout() + left_layout.setContentsMargins(0, 0, 0, 0) + left_layout.setSpacing(0) + + self.dicom_combobox = QComboBox() + self.dicom_combobox.setMaximumWidth(200) + left_layout.addWidget(self.dicom_combobox) + + self.subfolder_widget = SubfolderWidget(self) + self.subfolder_widget.widgetSelected.connect(self.process_dicom) + self.subfolder_widget.setMaximumWidth(200) + left_layout.addWidget(self.subfolder_widget) + + main_layout.addLayout(left_layout) + dicom_layout = QVBoxLayout() + dicom_layout.setContentsMargins(0, 0, 0, 0) + dicom_layout.setSpacing(0) + + self.controls_layout = QGridLayout() + self.first_button = self.create_icon_button(paths.get_asset_svg_path("first"), self.go_to_first) + self.controls_layout.addWidget(self.first_button, 0, 0) + self.previous_button = self.create_icon_button(paths.get_asset_svg_path("back"), self.go_to_previous) + self.controls_layout.addWidget(self.previous_button, 0, 1) + self.play_button = self.create_icon_button(paths.get_asset_svg_path("play"), self.start_stop_playback) + self.controls_layout.addWidget(self.play_button, 0, 2) + self.next_button = self.create_icon_button(paths.get_asset_svg_path("next"), self.go_to_next) + self.controls_layout.addWidget(self.next_button, 0, 3) + self.last_button = self.create_icon_button(paths.get_asset_svg_path("last"), self.go_to_last) + self.controls_layout.addWidget(self.last_button, 0, 4) + + self.slider = QSlider(Qt.Orientation.Horizontal) + self.slider.setMinimum(0) + self.slider.setValue(0) + self.slider.setTickInterval(1) + self.slider.valueChanged.connect(self.slider_changed) + self.controls_layout.addWidget(self.slider, 0, 5, 1, 5) + + self.index_label = QLabel("0 / 0") + self.index_label.setAlignment(Qt.AlignmentFlag.AlignCenter) + self.controls_layout.addWidget(self.index_label, 0, 10) + + # Add the controls menu to the layout + dicom_layout.addLayout(self.controls_layout) + + # Image viewer + self.image_viewer = ImageViewer(self) + self.image_viewer.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Expanding) + dicom_layout.addWidget(self.image_viewer, 1) + + # Bottom filename label + self.bottom_filename_label = QLabel() + self.bottom_filename_label.setAlignment(Qt.AlignmentFlag.AlignCenter) + dicom_layout.addWidget(self.bottom_filename_label, 0) + + # Bottom controls + self.bottom_layout = QHBoxLayout() + self.bottom_layout.setContentsMargins(0, 0, 0, 0) + self.bottom_layout.setSpacing(5) + + self.brush_button = QPushButton(self.language_manager.get_text("eraser")) + self.brush_button.clicked.connect(self.enable_brush) + self.bottom_layout.addWidget(self.brush_button) + + self.clear_button = QPushButton(self.language_manager.get_text("rebuild")) + self.clear_button.clicked.connect(self.clear_all_masks) + self.bottom_layout.addWidget(self.clear_button) + + dicom_layout.addLayout(self.bottom_layout, 0) + + + main_layout.addLayout(dicom_layout) + + self.stacked_widget.addWidget(main_widget) + + def create_icon_button(self, icon_path, callback): + btn = QPushButton() # Define the QPushButton instance + btn.setIconSize(QSize(20, 20)) + btn.setIcon(QIcon(icon_path)) + btn.setFlat(True) + btn.setStyleSheet("QPushButton { background: transparent; border: none; margin: 0 2px; }") + btn.clicked.connect(callback) + return btn + + def update_texts(self): + self.brush_button.setText(self.language_manager.get_text("quit_eraser") if self.is_brush_enabled else self.language_manager.get_text("eraser")) + self.clear_button.setText(self.language_manager.get_text("clear_mask")) + self.no_dicom_label.setText(self.language_manager.get_text("no_dicom_files")) + + def on_dicom_selected(self, index): + """Handle DICOM selection from combobox""" + if index < 0 or index >= self.dicom_combobox.count(): + return + + dicom = self.dicom_combobox.itemData(index) + self.combobox_change(dicom) + + def combobox_change(self, dicom): + """Handle DICOM combobox change event""" + # Add null check to prevent AttributeError + if dicom is None: + self.bottom_filename_label.setText(self.language_manager.get_text("no_images_found")) + self.selected_dicom = None + self.current_image_index = 0 + return + + if dicom.get_subfolders() or dicom.get_files(): + self.selected_dicom = dicom + self.current_image_index = 0 # Reset image index when changing DICOM + self.set_subfolder_widget() + self.process_dicom() + else: + self.bottom_filename_label.setText(self.language_manager.get_text("no_images_found")) + self.selected_dicom = None + self.current_image_index = 0 + + def process_dicom(self): + """Process DICOM selection and update UI accordingly""" + if self.get_displayed_dicom().get_files(): + self.current_image_index = 0 + self.update_slider_range() + self.load_image() + else: + self.set_subfolder_widget() + + def update_slider_range(self): + """Update slider range when new DICOM is loaded""" + if not self.selected_dicom: + self.slider.setMaximum(0) + self.slider.setValue(0) + self.index_label.setText("0 / 0") + return + dicom = self.get_displayed_dicom() + files = dicom.get_files() if dicom else [] + self.slider.setValue(0) + self.slider.setMaximum(len(files)-1) + + def load_image(self): + # Verify image viewer is still valid before using it + if not hasattr(self, 'image_viewer') or not self.image_viewer: + return + + try: + # Test if the widget is still valid by calling a simple method + self.image_viewer.parentWidget() + except RuntimeError: + # Widget has been deleted, skip loading + return + + dicom = self.get_displayed_dicom() + if not dicom: + return + + mask = dicom.get_mask() + used_list = dicom.get_files() + + if not used_list or self.current_image_index >= len(used_list): + return + + current_image = used_list[self.current_image_index] + + # Check if the current image is valid + if not hasattr(current_image, 'is_valid') or not current_image.is_valid: + self.bottom_filename_label.setText(f"{current_image.get_name()} - Error loading") + return + + try: + pixel_array = current_image.get_scaled_image() + if pixel_array is None: + self.bottom_filename_label.setText(f"{current_image.get_name()} - No image data") + return + + height, width, channel = pixel_array.shape + bytes_per_line = channel * width + qt_image = QImage(pixel_array.data, width, height, bytes_per_line, QImage.Format.Format_RGB888) + + # Apply existing mask if it exists for this subfolder + if mask is not None: + pixel_array_for_mask = self.dicom_manager.image_to_array(qt_image) + masked_array = image_editor.apply_mask(pixel_array_for_mask, mask) + qt_image = self.dicom_manager.array_to_image(masked_array) + + self.image_viewer.set_image(qt_image) + + self.bottom_filename_label.setText(current_image.get_name()) + self.slider.setValue(self.current_image_index) + self.index_label.setText(f"{self.current_image_index + 1} / {len(used_list)}") + + except Exception as e: + self.bottom_filename_label.setText(self.language_manager.get_text("error_loading_image").replace("{x}", current_image.get_name())) + + def slider_changed(self, value): + self.current_image_index = value + self.load_image() + + def scroll_images(self, delta): + new_index = self.current_image_index + delta + if 0 <= new_index < len(self.get_displayed_dicom().get_files()): + self.current_image_index = new_index + self.load_image() + + def go_to_first(self): + if self.get_displayed_dicom(): + self.current_image_index = 0 + self.load_image() + + def go_to_previous(self): + if self.current_image_index > 0: + self.current_image_index -= 1 + self.load_image() + + def go_to_next(self): + # Get the correct file list + dicom = self.get_displayed_dicom() + if dicom: + files = dicom.get_files() + else: + files = [] + + if self.current_image_index < len(files) - 1: + self.current_image_index += 1 + self.load_image() + elif self.timer.isActive(): + self.current_image_index = 0 + self.load_image() + + def go_to_last(self): + if self.selected_dicom: + dicom = self.get_displayed_dicom() + if dicom: + files = dicom.get_files() + self.current_image_index = len(files) - 1 + self.load_image() + + def start_stop_playback(self): + if self.selected_dicom: + if self.timer.isActive(): + # Update the play button icon in the menu + self.play_button.setIcon(QIcon(paths.get_asset_svg_path("play"))) + self.timer.stop() + else: + # Update the play button icon in the menu + self.play_button.setIcon(QIcon(paths.get_asset_svg_path("stop"))) + if self.current_image_index > len(self.selected_dicom.get_files()) - 1: + self.current_image_index = 0 + self.slider.setValue(0) + self.timer.start(100) + + def enable_brush(self): + self.is_brush_enabled = not self.is_brush_enabled # Bascule l'état + self.brush_button.setText(self.language_manager.get_text("quit_eraser") if self.is_brush_enabled else self.language_manager.get_text("eraser")) # Met à jour le texte du bouton + + # Change cursor when brush is enabled/disabled + if self.is_brush_enabled: + self.image_viewer.setCursor(Qt.CursorShape.CrossCursor) + else: + self.image_viewer.setCursor(Qt.CursorShape.ArrowCursor) + + def apply_brush(self, screen_points): + if not self.is_brush_enabled: # Vérifie si le mode "masque" est activé + return + + img = self.image_viewer.original_image + if img is None: + return + + img_shape = (img.height(), img.width(), 3) + brush_coords = [] + + for sx, sy in screen_points: + res = self.image_viewer.screen_to_image_coords(sx, sy) + if res: + x, y = res + if 0 <= x < img_shape[1] and 0 <= y < img_shape[0]: + brush_coords.append((x, y)) + + # Get the current subfolder path instead of filename + dicom = self.get_displayed_dicom() + + # Get existing mask or create new one + existing_mask = dicom.get_mask() + + # Create new mask from brush coords + new_mask = image_editor.get_mask(brush_coords, img_shape) + + # Combine with existing mask if it exists + if existing_mask is not None: + combined_mask = image_editor.combine_masks(existing_mask, new_mask) + else: + combined_mask = new_mask + + # Update mask for current subfolder + dicom.set_mask(combined_mask) + + # Refresh the display to show the updated mask + self.load_image() + + def apply_brush_mask(self, new_mask): + """Applique un mask numpy directement""" + if not self.is_brush_enabled: + return + + # Get the current subfolder + dicom = self.get_displayed_dicom() + + # Get existing mask or create new one + existing_mask = dicom.get_mask() + + # Combine with existing mask if it exists + if existing_mask is not None: + combined_mask = image_editor.combine_masks(existing_mask, new_mask) + else: + combined_mask = new_mask + # Update mask for current subfolder + dicom.set_mask(combined_mask) + + # Refresh the display to show the updated mask + self.load_image() + + def clear_all_masks(self): + self.get_displayed_dicom().set_mask(None) + self.load_image() + + def hideEvent(self, event): + if self.timer.isActive(): + self.start_stop_playback() + super().hideEvent(event) + + def showEvent(self, event): + """Called when the widget is shown""" + # Only update if we have a mismatch between displayed and actual DICOMs + current_dicoms = self.dicom_manager.get_dicoms() + if len(current_dicoms) != self.current_dicom_count: + self.on_dicoms_imported() + super().showEvent(event) + + def set_subfolder_widget(self): + """Update the existing subfolder widget with the current DICOM's subfolders""" + if hasattr(self, 'subfolder_widget') and self.subfolder_widget: + # Clear existing widgets + self.subfolder_widget.clear_widgets() + # Always show the subfolder widget, but only add widgets if subfolders exist + if self.selected_dicom and self.selected_dicom.get_subfolders(): + self.subfolder_widget.create_and_add_widgets(self.selected_dicom.get_subfolders()) + + def get_displayed_dicom(self): + """Return the currently displayed DICOM object""" + if self.selected_dicom is None: + return None + + if self.selected_dicom.get_subfolders(): + selected_widget = self.subfolder_widget.get_selected_widget() + if selected_widget: + return selected_widget.dicom + return self.selected_dicom \ No newline at end of file diff --git a/app/ui/windows/export_window.py b/app/ui/windows/export_window.py new file mode 100644 index 0000000..25dd71a --- /dev/null +++ b/app/ui/windows/export_window.py @@ -0,0 +1,370 @@ +from PyQt6.QtWidgets import QWidget, QVBoxLayout, QLabel, QPushButton, QComboBox, QDialog, QTreeWidget, QTreeWidgetItem, QHeaderView, QGridLayout, QFileDialog +from PyQt6.QtCore import Qt, QEvent, QThread, pyqtSignal +from app.core.main_manager import MainManager, NotificationType +from app.core.export_manager import ExportCategory +from app.ui.widgets.loading_bar import LoadingBar + +class ExportWorker(QThread): + progress_changed = pyqtSignal(int) + phase_changed = pyqtSignal(str) + export_finished = pyqtSignal(bool) + + def __init__(self, export_manager, export_type, export_format): + super().__init__() + self.export_manager = export_manager + self.export_type = export_type + self.export_format = export_format + + def run(self): + try: + # Connect export manager signals + self.export_manager.progress_changed.connect(self.progress_changed.emit) + self.export_manager.phase_changed.connect(self.phase_changed.emit) + self.export_manager.export_finished.connect(self.export_finished.emit) + + # Determine which export method to call + success = False + if self.export_type == 0: # Images + if self.export_format == 0: # PDF + success = self.export_manager.export_images_as_pdf() + elif self.export_format == 1: # PNG + success = self.export_manager.export_images_as_png() + elif self.export_format == 2: # DICOMDIR + success = self.export_manager.export_images_as_dicomdir() + elif self.export_format == 3: # DCM + success = self.export_manager.export_images_as_dcm() + elif self.export_type == 1: # Metadata + if self.export_format == 0: # JSON + success = self.export_manager.export_metadata_as_json() + elif self.export_format == 1: # XLS + success = self.export_manager.export_metadata_as_xls() + + # Emit final result if not already emitted by export manager + if not success: + self.export_finished.emit(False) + + except Exception as e: + self.export_finished.emit(False) + finally: + # Disconnect signals + try: + self.export_manager.progress_changed.disconnect() + self.export_manager.phase_changed.disconnect() + self.export_manager.export_finished.disconnect() + except: + pass + +class ExportWindow(QWidget): + def __init__(self, parent=None): + super().__init__(parent) + self.main_manager = MainManager.get_instance() + self.language_manager = self.main_manager.get_language_manager() + self.export_manager = self.main_manager.get_export_manager() + self.observer_manager = self.main_manager.get_observer_manager() + self.alert_manager = self.main_manager.get_alert_manager() + self.observer_manager.subscribe(NotificationType.LANGUAGE, self.update_texts) + + self.export_type_combo = None + self.export_format_combo = None + self.export_worker = None + self.progress_dialog = None + + self.setup_ui() + + def setup_ui(self): + layout = QVBoxLayout(self) + layout.setAlignment(Qt.AlignmentFlag.AlignTop) + layout.setSpacing(20) + layout.setContentsMargins(20, 20, 20, 20) + + self.export_label = QLabel(self.language_manager.get_text("export_label"), self) + layout.addWidget(self.export_label) + + # Add combo box for export type + self.export_type_combo = QComboBox(self) + self.export_type_combo.addItems([self.language_manager.get_text("export_type_images"), self.language_manager.get_text("export_type_metadata")]) + self.export_type_combo.currentIndexChanged.connect(self.update_export_formats) + layout.addWidget(self.export_type_combo) + + # Add combo box for export format + self.export_format_combo = QComboBox(self) + self.update_export_formats() # Initialize formats based on default type + layout.addWidget(self.export_format_combo) + + self.export_button = QPushButton(self.language_manager.get_text("export_button"), self) + self.export_button.clicked.connect(self.show_dicom_selection_popup) + layout.addWidget(self.export_button) + + def update_texts(self): + self.export_label.setText(self.language_manager.get_text("export_label")) + self.export_button.setText(self.language_manager.get_text("export_button")) + self.export_type_combo.setItemText(0, self.language_manager.get_text("export_type_images")) + self.export_type_combo.setItemText(1, self.language_manager.get_text("export_type_metadata")) + + def update_export_formats(self): + self.export_format_combo.clear() + if self.export_type_combo.currentIndex() < 1: # Images + self.export_format_combo.addItems(["PDF", "PNG", "DICOMDIR", "DCM"]) + else: # Metadata + self.export_format_combo.addItems(["JSON", "XLS"]) + + def show_dicom_selection_popup(self): + dicom_list = self.export_manager.get_export_dicom_list() + if not dicom_list: + return + + popup = QDialog(self) + popup.setWindowTitle(self.language_manager.get_text("select_dicom_to_export")) + popup.setLayout(QVBoxLayout()) + popup.resize(400, 600) # Set initial size with increased height + + tree = QTreeWidget(popup) + tree.setHeaderHidden(False) + tree.setColumnCount(2) + tree.setHeaderLabels([self.language_manager.get_text("dicom_name"), + self.language_manager.get_text("group")]) + # disable automatic stretch and fit col 1 to its contents + tree.header().setStretchLastSection(False) + tree.header().setSectionResizeMode(1, QHeaderView.ResizeMode.ResizeToContents) + popup.layout().addWidget(tree) + + for dicom, sub_dicoms in dicom_list: + parent_item = QTreeWidgetItem([dicom.get_name()]) + parent_item.setCheckState(0, Qt.CheckState.Unchecked) # Add checkbox to parent item + parent_item.setData(0, Qt.ItemDataRole.UserRole, dicom) # Link parent item to its original object + tree.addTopLevelItem(parent_item) + + # Handle case where there are no subfolders (direct files) + if not sub_dicoms and dicom.get_files(): + # Create a single child for the DICOM itself + child_item = QTreeWidgetItem([dicom.get_name()]) + child_item.setCheckState(0, Qt.CheckState.Unchecked) + child_item.setData(0, Qt.ItemDataRole.UserRole, dicom) + parent_item.addChild(child_item) + + # Create color selection button + color_button = QPushButton(parent=popup) + color_button.setFixedSize(20, 20) + colors = ExportCategory.list() + + # Set initial color + color_button.setStyleSheet(f""" + QPushButton {{ + background-color: rgb{dicom.get_category()}; + border: none; + padding: 0px; + margin: 0px; + }} + """) + color_button.clicked.connect(lambda _, btn=color_button, item=child_item, cols=colors: + self.show_color_dialog(item, btn, cols)) + tree.setItemWidget(child_item, 1, color_button) + else: + # Handle subfolders as before + for sub_dicom in sub_dicoms: + child_item = QTreeWidgetItem([sub_dicom.get_name()]) + child_item.setCheckState(0, Qt.CheckState.Unchecked) # Add checkbox to child item + child_item.setData(0, Qt.ItemDataRole.UserRole, sub_dicom) # Link child item to its original object + parent_item.addChild(child_item) + + # Create color selection button instead of combo box + color_button = QPushButton(parent=popup) + color_button.setFixedSize(20, 20) + colors = ExportCategory.list() + + # Set initial color + color_button.setStyleSheet(f""" + QPushButton {{ + background-color: rgb{sub_dicom.get_category()}; + border: none; + padding: 0px; + margin: 0px; + }} + """) + # Connect to custom color dialog + color_button.clicked.connect(lambda _, btn=color_button, item=child_item, cols=colors: + self.show_color_dialog(item, btn, cols)) + tree.setItemWidget(child_item, 1, color_button) + + # single connection to handle both directions + tree.itemChanged.connect(self.on_item_changed) + tree.resizeColumnToContents(0) # Resize first column to fit content + tree.setColumnWidth(0, max(200, tree.columnWidth(0))) # Ensure minimum 200px for first column + tree.setColumnWidth(1, 20) # Exact width for button + # Adjust dialog size to fit content + popup.adjustSize() + popup.setMinimumHeight(600) # Ensure minimum height + + confirm_button = QPushButton(self.language_manager.get_text("confirm"), popup) + confirm_button.clicked.connect(lambda: (self.export_data(), popup.accept())) + popup.layout().addWidget(confirm_button) + + popup.exec() + + def toggle_child_items(self, item): + if item.childCount() > 0: # Check if the item has children + for i in range(item.childCount()): + child = item.child(i) + child.setCheckState(0, item.checkState(0)) # Set child state to match parent state + + def show_color_dialog(self, item, button, colors): + dialog = QDialog(self) + dialog.setWindowFlags(Qt.WindowType.Popup) + dialog.setFixedSize(200, 40) # Increased height for labels + + # Position dialog to the left of the button + button_pos = button.mapToGlobal(button.rect().topLeft()) + dialog.move(button_pos.x() - 200, button_pos.y()) + + layout = QGridLayout(dialog) + layout.setSpacing(0) + layout.setContentsMargins(0, 0, 0, 0) + + for i, color in enumerate(colors): + color_btn = QPushButton() + color_btn.setFixedSize(20, 20) + color_btn.setStyleSheet(f""" + QPushButton {{ + background-color: rgb{color}; + border: none; + padding: 0px; + margin: 0px; + }} + """) + # Add tooltip with category name + color_btn.setToolTip(ExportCategory.get_name(color)) + color_btn.clicked.connect(lambda _, c=color: self.select_color(item, button, c, dialog)) + layout.addWidget(color_btn, 0, i) + + # Add label below button + label = QLabel(ExportCategory.get_name(color)[:3]) # First 3 letters + label.setAlignment(Qt.AlignmentFlag.AlignCenter) + label.setStyleSheet("font-size: 8px; color: black;") + layout.addWidget(label, 1, i) + + dialog.exec() + + def select_color(self, item, button, color, dialog): + button.setStyleSheet(f""" + QPushButton {{ + background-color: rgb{color}; + border: none; + padding: 0px; + margin: 0px; + }} + """) + item.setData(1, Qt.ItemDataRole.UserRole, color) + item.data(0, Qt.ItemDataRole.UserRole).set_category(color) + dialog.accept() + + def export_data(self): + """Start the export process with progress tracking""" + # Check if there's data to export + data = self.export_manager.fetch_export_data() + if not data: + self.alert_manager.show_error("no_data_to_export") + return + + # Choose export destination + destination = QFileDialog.getExistingDirectory( + self, + self.language_manager.get_text("choose_export_destination"), + "" + ) + + if not destination: + return # User cancelled + + # Set export destination + self.export_manager.set_export_destination(destination) + + # Create and show progress dialog + self.progress_dialog = QDialog(self) + self.progress_dialog.setWindowTitle(self.language_manager.get_text("export_label")) + self.progress_dialog.setModal(True) + self.progress_dialog.setFixedSize(400, 120) + + layout = QVBoxLayout(self.progress_dialog) + self.progress_bar = LoadingBar(self.language_manager.get_text("preparing_export"), self.progress_dialog) + layout.addWidget(self.progress_bar) + + # Cancel button + cancel_button = QPushButton(self.language_manager.get_text("cancel"), self.progress_dialog) + cancel_button.clicked.connect(self.cancel_export) + layout.addWidget(cancel_button) + + self.progress_dialog.show() + + # Start export worker + export_type = self.export_type_combo.currentIndex() + export_format = self.export_format_combo.currentIndex() + + self.export_worker = ExportWorker(self.export_manager, export_type, export_format) + self.export_worker.progress_changed.connect(self.progress_bar.set_progress) + self.export_worker.phase_changed.connect(self.update_export_phase) + self.export_worker.export_finished.connect(self.on_export_finished) + self.export_worker.start() + + def update_export_phase(self, phase): + """Update the progress bar label based on current phase""" + if hasattr(self, 'progress_bar') and self.progress_bar: + self.progress_bar.set_label(self.language_manager.get_text(phase)) + + def cancel_export(self): + """Cancel the export process""" + if self.export_worker and self.export_worker.isRunning(): + self.export_worker.terminate() + self.export_worker.wait() + + if self.progress_dialog: + self.progress_dialog.close() + self.progress_dialog = None + + def on_export_finished(self, success): + """Handle export completion""" + if self.progress_dialog: + self.progress_dialog.close() + self.progress_dialog = None + + if self.export_worker: + self.export_worker.deleteLater() + self.export_worker = None + + if success: + self.alert_manager.show_success("export_success") + else: + self.alert_manager.show_error("export_error") + + def eventFilter(self, source, event): + if isinstance(source, QComboBox) and event.type() == QEvent.Type.Wheel: + return True + return super().eventFilter(source, event) + + def on_item_changed(self, item, column): + if column != 0: + return + tree = item.treeWidget() + tree.blockSignals(True) + + # Set export status based on check state + is_checked = item.checkState(0) == Qt.CheckState.Checked + item.data(0, Qt.ItemDataRole.UserRole).set_export(is_checked) + + # if parent toggled → toggle all children + if item.childCount() > 0: + state = item.checkState(0) + for i in range(item.childCount()): + child = item.child(i) + child.setCheckState(0, state) + # Set export status for children too + child.data(0, Qt.ItemDataRole.UserRole).set_export(state == Qt.CheckState.Checked) + # if child toggled → update parent + parent = item.parent() + if parent: + all_checked = all(parent.child(i).checkState(0) == Qt.CheckState.Checked + for i in range(parent.childCount())) + parent.setCheckState(0, + Qt.CheckState.Checked if all_checked else Qt.CheckState.Unchecked) + # Set export status for parent + parent.data(0, Qt.ItemDataRole.UserRole).set_export(all_checked) + tree.blockSignals(False) \ No newline at end of file diff --git a/app/ui/windows/import_window.py b/app/ui/windows/import_window.py new file mode 100644 index 0000000..6a0b63f --- /dev/null +++ b/app/ui/windows/import_window.py @@ -0,0 +1,330 @@ +from PyQt6.QtWidgets import ( + QWidget, QVBoxLayout, QHBoxLayout, QLabel, QPushButton, + QFileDialog +) +from PyQt6.QtCore import Qt, QThread, pyqtSignal +from os import walk, path as Path +import os +from app.core.main_manager import MainManager, NotificationType +from app.utils.paths import get_current_dir +from app.ui.widgets.drag_drop_frame import DragDropFrame +from app.ui.widgets.loading_bar import LoadingBar + + + +class ImportWorker(QThread): + progress_changed = pyqtSignal(int) + phase_changed = pyqtSignal(str) + import_finished = pyqtSignal() + error_occurred = pyqtSignal(str) + dicoms_imported = pyqtSignal(int) # Signal for number of imported DICOMs + + def __init__(self, dicom_manager, dicom_paths): + super().__init__() + self.dicom_manager = dicom_manager + self.dicom_paths = dicom_paths + self.current_progress = 0 + + def run(self): + total_paths = len(self.dicom_paths) + + # Phase 1: Path processing (0-20%) + self.phase_changed.emit("processing_paths") + for i, dicom_path in enumerate(self.dicom_paths): + self.current_progress = int((i / total_paths) * 20) + self.progress_changed.emit(self.current_progress) + + # Phase 2: DICOM object creation (20-70%) - Now much faster + self.phase_changed.emit("creating_dicoms") + + self.dicom_manager.error_occurred.connect(self.error_occurred.emit) + + successfully_added = 0 + for i, dicom_path in enumerate(self.dicom_paths): + try: + dicom = self.dicom_manager.process_dicomdir(dicom_path) + + if dicom is not None and not dicom.is_empty(): + self.dicom_manager.dicoms.append(dicom) + successfully_added += 1 + + except Exception as e: + self.error_occurred.emit("load_error") + + self.current_progress = 20 + int((i / total_paths) * 50) + self.progress_changed.emit(self.current_progress) + + try: + self.dicom_manager.error_occurred.disconnect() + except: + pass + + self.dicoms_imported.emit(successfully_added) + + # Phase 3: Background validation (70-90%) + self.phase_changed.emit("validating_files") + self._validate_files_in_background() + + # Phase 4: UI preparation (90-100%) + self.phase_changed.emit("preparing_display") + for i in range(10): + self.current_progress = 90 + i + 1 + self.progress_changed.emit(self.current_progress) + self.msleep(10) + + self.phase_changed.emit("import_complete") + self.import_finished.emit() + + def _validate_files_in_background(self): + """Validate DICOM files in background without blocking UI""" + all_files = [] + + # Collect all DicomFile objects + for dicom in self.dicom_manager.dicoms: + if dicom is None: + continue + all_files.extend(dicom.get_files()) + for subfolder in dicom.get_subfolders(): + all_files.extend(subfolder.get_files()) + + total_files = len(all_files) + invalid_count = 0 + + for i, dicom_file in enumerate(all_files): + # Trigger lazy loading/validation + dicom_file._ensure_loaded() + if not dicom_file.is_valid: + invalid_count += 1 + + # Update progress + if i % 10 == 0: + progress = 70 + int((i / total_files) * 20) + self.progress_changed.emit(progress) + + # Log validation results if needed + if invalid_count > 0: + print(f"Warning: {invalid_count} invalid DICOM files found during validation") + +class ImportWindow(QWidget): + def __init__(self, parent=None): + super().__init__(parent) + self.main_manager = MainManager.get_instance() + self.language_manager = self.main_manager.get_language_manager() + self.dicom_manager = self.main_manager.get_dicom_manager() + self.alert_manager = self.main_manager.get_alert_manager() + self.observer_manager = self.main_manager.get_observer_manager() + self.observer_manager.subscribe(NotificationType.LANGUAGE, self.update_texts) + + self.dicom_paths = None + self.setup_ui() + self.update_texts() + + self.import_worker = None + + def setup_ui(self): + layout = QVBoxLayout(self) + layout.setAlignment(Qt.AlignmentFlag.AlignHCenter | Qt.AlignmentFlag.AlignVCenter) + self.drag_area = DragDropFrame(self) + self.drag_area.setMinimumHeight(100) + self.drag_area.setMaximumHeight(200) + layout.addWidget(self.drag_area) + + + self.file_btn = QPushButton() + self.file_btn.clicked.connect(self.select_file) + self.folder_btn = QPushButton() + self.folder_btn.clicked.connect(self.select_folder) + file_layout = QHBoxLayout() + file_layout.addWidget(self.file_btn) + file_layout.addWidget(self.folder_btn) + layout.addLayout(file_layout) + + self.input_entry = QLabel() + self.input_entry.setText(self.language_manager.get_text("path_placeholder")) + layout.addWidget(self.input_entry) + + layout.addStretch() + + self.progress_bar = LoadingBar() + layout.addWidget(self.progress_bar) + + layout.addStretch() + + self.import_btn = QPushButton() + self.import_btn.clicked.connect(self.start_import) + layout.addWidget(self.import_btn, alignment=Qt.AlignmentFlag.AlignCenter) + + def update_texts(self): + self.drag_area.setDragText(self.language_manager.get_text("drag_drop")) + if ":" not in self.input_entry.text(): + self.input_entry.setText(self.language_manager.get_text("path_placeholder")) + self.file_btn.setText(self.language_manager.get_text("select_image")) + self.folder_btn.setText(self.language_manager.get_text("select_folder")) + self.import_btn.setText(self.language_manager.get_text("import")) + + def start_import(self): + self.find_dicoms_from_files(self.input_entry.text()) + self.import_dicoms() + + def import_dicoms(self): + if not self.dicom_paths: + self.alert_manager.show_error("no_dicom_found") + return + + # Build a comprehensive set of all existing file paths (normalized) + existing_file_paths = set() + existing_dicom_paths = set() + + for dicom in self.dicom_manager.get_dicoms(): + if dicom is None: + continue + + # Add the DICOM's main path (normalized) + if dicom.get_path(): + existing_dicom_paths.add(os.path.normpath(dicom.get_path())) + + # Add all individual file paths within this DICOM (normalized) + files = dicom.get_files() + for file in files: + if hasattr(file, 'file_path') and file.file_path: + existing_file_paths.add(os.path.normpath(file.file_path)) + + # Add files from subfolders + subfolders = dicom.get_subfolders() + for subfolder in subfolders: + subfolder_files = subfolder.get_files() + for file in subfolder_files: + if hasattr(file, 'file_path') and file.file_path: + existing_file_paths.add(os.path.normpath(file.file_path)) + + # Filter out duplicates + dicom_paths_filtered = [] + for path in self.dicom_paths: + normalized_path = os.path.normpath(path) + should_skip = False + + # Check if this exact path is already imported + if normalized_path in existing_dicom_paths: + continue + + # For single DCM files, check if already part of existing DICOM + if path.endswith('.dcm'): + if normalized_path in existing_file_paths: + continue + # Also check if parent directory is already imported as DICOM + parent_dir = os.path.normpath(os.path.dirname(path)) + if parent_dir in existing_dicom_paths: + continue + + # For directories, check more thoroughly + elif Path.isdir(path): + # Check if this directory path is already imported + if normalized_path in existing_dicom_paths: + continue + + # Check if any parent directory is already imported + current_path = normalized_path + while current_path != os.path.dirname(current_path): # Until we reach root + if current_path in existing_dicom_paths: + should_skip = True + break + current_path = os.path.dirname(current_path) + + if should_skip: + continue + + # Check if any child directories are already imported + for existing_path in existing_dicom_paths: + if existing_path.startswith(normalized_path + os.sep): + should_skip = True + break + + if should_skip: + continue + + # If we get here, the path is not a duplicate + dicom_paths_filtered.append(path) + + if not dicom_paths_filtered: + self.alert_manager.show_info("Tous les DICOMs sont déjà importés") + return + + # Show loading bar and start import + self.progress_bar.set_label(self.language_manager.get_text("importing")) + self.progress_bar.set_progress(0) + + # Disable buttons during import + self.file_btn.setEnabled(False) + self.folder_btn.setEnabled(False) + self.import_btn.setEnabled(False) + + # Start import worker + self.import_worker = ImportWorker(self.dicom_manager, dicom_paths_filtered) + self.import_worker.progress_changed.connect(self.progress_bar.set_progress) + self.import_worker.phase_changed.connect(self.update_phase_label) + self.import_worker.error_occurred.connect(self.handle_import_error) + self.import_worker.import_finished.connect(self.on_import_finished) + self.import_worker.start() + + def handle_import_error(self, error_key): + """Handle errors during import""" + self.alert_manager.show_error(error_key) + + def update_phase_label(self, phase): + """Update the loading bar label based on current phase""" + self.progress_bar.set_label(self.language_manager.get_text(phase)) + + def on_import_finished(self): + + # Re-enable buttons + self.import_btn.setEnabled(True) + self.file_btn.setEnabled(True) + self.folder_btn.setEnabled(True) + + # Reset paths + self.dicom_paths = None + self.input_entry.setText(self.language_manager.get_text("path_placeholder")) + + # Clean up worker + if self.import_worker: + self.import_worker.deleteLater() + self.import_worker = None + + # Notify observers + self.observer_manager.notify(NotificationType.DICOM) + + def select_file(self): + self.input_entry.setText(QFileDialog.getOpenFileName(self, self.language_manager.get_text("select_image"), get_current_dir(), "DICOMDIR Files (DICOMDIR) ;; DICOM Files (*.dcm)")[0]) + + def select_folder(self): + self.input_entry.setText(QFileDialog.getExistingDirectory(self, self.language_manager.get_text("select_folder"), get_current_dir())) + + def find_dicoms_from_files(self, path): + if isinstance(path, tuple): + path = path[0] # Extract the file path from the tuple if needed + if not path: + return + if Path.isdir(path): + if path: + fichiers_dicomdir = [] + for racine, _, fichiers in walk(path): + for fichier in fichiers: + if fichier == 'DICOMDIR': + chemin_complet = Path.join(racine, fichier) + fichiers_dicomdir.append(chemin_complet) + if fichier.endswith('.dcm'): + chemin_complet = Path.join(racine, fichier) + parent_folder = Path.dirname(chemin_complet) + if parent_folder not in fichiers_dicomdir: + fichiers_dicomdir.append(parent_folder) + if fichiers_dicomdir: + self.dicom_paths = fichiers_dicomdir + self.input_entry.setText(path) + else: + if path.endswith('DICOMDIR'): + self.dicom_paths = [path] + self.input_entry.setText(path) + elif path.endswith('.dcm'): + # For single DCM file, use the file path directly, not the parent folder + self.dicom_paths = [path] + self.input_entry.setText(path) \ No newline at end of file diff --git a/app/ui/windows/settings_window.py b/app/ui/windows/settings_window.py index 50b8d13..f8bd67d 100644 --- a/app/ui/windows/settings_window.py +++ b/app/ui/windows/settings_window.py @@ -1,4 +1,4 @@ -from PyQt6.QtWidgets import QWidget, QVBoxLayout, QComboBox, QLabel, QHBoxLayout, QSizePolicy +from PyQt6.QtWidgets import QWidget, QVBoxLayout, QComboBox, QLabel, QHBoxLayout from PyQt6.QtCore import Qt from app.core.main_manager import MainManager, NotificationType from typing import Optional @@ -16,12 +16,12 @@ class SettingsWindow(QWidget): # Type hints for UI elements self.language_layout: QHBoxLayout - self.languageLabel: QLabel - self.languageCombo: QComboBox + self.language_label: QLabel + self.language_combo: QComboBox self.theme_layout: QHBoxLayout - self.themeLabel: QLabel - self.themeCombo: QComboBox - + self.theme_label: QLabel + self.theme_combo: QComboBox + self.setup_ui() def setup_ui(self) -> None: @@ -34,12 +34,12 @@ class SettingsWindow(QWidget): self.language_layout = QHBoxLayout() # Paramètres de langue - self.languageLabel = QLabel(self.language_manager.get_text("language"),self) - self.languageLabel.setFixedWidth(120) # Largeur fixe pour l'alignement - self.language_layout.addWidget(self.languageLabel) + self.language_label = QLabel(self.language_manager.get_text("language"),self) + self.language_label.setFixedWidth(120) # Largeur fixe pour l'alignement + self.language_layout.addWidget(self.language_label) - self.languageCombo = self.createLanguageSelector() - self.language_layout.addWidget(self.languageCombo) + self.language_combo = self.createLanguageSelector() + self.language_layout.addWidget(self.language_combo) layout.addLayout(self.language_layout) @@ -48,12 +48,12 @@ class SettingsWindow(QWidget): # Paramètres de thème self.theme_layout = QHBoxLayout() - self.themeLabel = QLabel(self.language_manager.get_text("theme"), self) - self.themeLabel.setFixedWidth(120) # Même largeur fixe pour l'alignement - self.theme_layout.addWidget(self.themeLabel) + self.theme_label = QLabel(self.language_manager.get_text("theme"), self) + self.theme_label.setFixedWidth(120) # Même largeur fixe pour l'alignement + self.theme_layout.addWidget(self.theme_label) - self.themeCombo = self.createThemeSelector() - self.theme_layout.addWidget(self.themeCombo) + self.theme_combo = self.createThemeSelector() + self.theme_layout.addWidget(self.theme_combo) layout.addLayout(self.theme_layout) @@ -62,12 +62,12 @@ class SettingsWindow(QWidget): def createLanguageSelector(self) -> QComboBox: combo: QComboBox = QComboBox() # Ajouter toutes les langues disponibles - for langCode, langData in self.language_manager.translations.items(): - combo.addItem(langData["lang_name"], langCode) - + for lang_code, lang_data in self.language_manager.translations.items(): + combo.addItem(lang_data["lang_name"], lang_code) + # Sélectionner la langue actuelle - currentIndex = combo.findData(self.settings_manager.get_language()) - combo.setCurrentIndex(currentIndex) + current_index = combo.findData(self.settings_manager.get_language()) + combo.setCurrentIndex(current_index) combo.currentIndexChanged.connect(self.change_language) return combo @@ -79,23 +79,23 @@ class SettingsWindow(QWidget): combo.addItem(self.language_manager.get_text(theme.name+"_theme"), theme.name) # Sélectionner le thème actuel - currentIndex = combo.findData(self.settings_manager.get_theme()) - combo.setCurrentIndex(currentIndex) + current_index = combo.findData(self.settings_manager.get_theme()) + combo.setCurrentIndex(current_index) combo.currentIndexChanged.connect(self.change_theme) return combo def change_language(self, index: int) -> None: - self.settings_manager.set_language(self.languageCombo.itemData(index)) + self.settings_manager.set_language(self.language_combo.itemData(index)) def change_theme(self, index: int) -> None: - theme: str = self.themeCombo.itemData(index) + theme: str = self.theme_combo.itemData(index) self.settings_manager.set_theme(theme) def update_language(self) -> None: - self.languageLabel.setText(self.language_manager.get_text("language")) - self.themeLabel.setText(self.language_manager.get_text("theme")) - + self.language_label.setText(self.language_manager.get_text("language")) + self.theme_label.setText(self.language_manager.get_text("theme")) + # Mettre à jour les textes dans la combo de thème - for i in range(self.themeCombo.count()): - self.themeCombo.setItemText(i, self.language_manager.get_text(self.themeCombo.itemData(i)+ "_theme")) \ No newline at end of file + for i in range(self.theme_combo.count()): + self.theme_combo.setItemText(i, self.language_manager.get_text(self.theme_combo.itemData(i)+ "_theme")) \ No newline at end of file diff --git a/app/ui/windows/splash_screen.py b/app/ui/windows/splash_screen.py index 3bcc02a..459752e 100644 --- a/app/ui/windows/splash_screen.py +++ b/app/ui/windows/splash_screen.py @@ -122,8 +122,8 @@ class SplashScreen(QWidget): if hasattr(self, 'spinner'): self.spinner.stop() self.timer.stop() - self.hide() self.finished.emit() + self.close() def show_splash(self): """Affiche le splash screen""" diff --git a/app/utils/image_editor.py b/app/utils/image_editor.py new file mode 100644 index 0000000..223bd04 --- /dev/null +++ b/app/utils/image_editor.py @@ -0,0 +1,30 @@ +from numpy import uint8, logical_or + +def combine_masks(mask1, mask2): + """Combine two masks using logical OR operation""" + if mask1 is None: + return mask2 + if mask2 is None: + return mask1 + + # S'assurer que les masks ont la même forme + if mask1.shape != mask2.shape: + return mask2 # En cas de problème, utiliser le nouveau mask + + return logical_or(mask1 > 0, mask2 > 0).astype(uint8) * 255 + +def apply_mask(image_array, mask): + if mask is None or image_array is None: + return image_array + + # Vérifier que les dimensions correspondent + if len(image_array.shape) != 3 or len(mask.shape) != 2: + return image_array + + if image_array.shape[:2] != mask.shape: + return image_array + + result = image_array.copy() + result[mask > 0] = [0, 0, 0] # Pixel noir + + return result diff --git a/app/utils/paths.py b/app/utils/paths.py index 991026b..f0d649a 100644 --- a/app/utils/paths.py +++ b/app/utils/paths.py @@ -17,6 +17,8 @@ def resource_path(relative_path: str) -> str: return path.join(base_path, relative_path) +def get_current_dir() -> str: + return str(Path.cwd()) def get_data_dir() -> str: return resource_path("data") diff --git a/config.json b/config.json index 2735aaa..f5f3370 100644 --- a/config.json +++ b/config.json @@ -1,10 +1,10 @@ { - "app_name": "Application", + "app_name": "HoDA Radio", "app_os": "Windows", "app_version": "1.0.0", "architecture": "x64", "icon_path": "data/assets/icon.ico", "splash_image": "splash", "main_script": "main.py", - "git_repo": "https://gitea.louismazin.ovh/LouisMazin/PythonApplicationTemplate" + "git_repo": "https://gitea.louismazin.ovh/LouisMazin/HoDA_Radio" } \ No newline at end of file diff --git a/data/assets/back.svg b/data/assets/back.svg new file mode 100644 index 0000000..fc53d81 --- /dev/null +++ b/data/assets/back.svg @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/data/assets/export.svg b/data/assets/export.svg new file mode 100644 index 0000000..9b7cbf1 --- /dev/null +++ b/data/assets/export.svg @@ -0,0 +1,4 @@ + + + + \ No newline at end of file diff --git a/data/assets/first.svg b/data/assets/first.svg new file mode 100644 index 0000000..165c4fb --- /dev/null +++ b/data/assets/first.svg @@ -0,0 +1,7 @@ + + + + + + + \ No newline at end of file diff --git a/data/assets/folder.svg b/data/assets/folder.svg new file mode 100644 index 0000000..395303d --- /dev/null +++ b/data/assets/folder.svg @@ -0,0 +1,3 @@ + + + \ No newline at end of file diff --git a/data/assets/ghla.png b/data/assets/ghla.png new file mode 100644 index 0000000000000000000000000000000000000000..2d38c9a652dc55d4fb2ed26b965086a4dd042064 GIT binary patch literal 56371 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 literal 0 HcmV?d00001 diff --git a/data/assets/ghla.svg b/data/assets/ghla.svg new file mode 100644 index 0000000..795c683 --- /dev/null +++ b/data/assets/ghla.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/data/assets/icon.icns b/data/assets/icon.icns index 69fd9679720bc2be5b304d6d9f514a78069830e0..75ecd98622d5fdd6d72139095fc5db77ba1e9871 100644 GIT binary patch literal 7114800 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 S-gF)SFKcsqv$rOGcmEII0fScn literal 8591 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⩔%Ls|L>(Opwgoyy+)#ky%MHbOPDe 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 bo+o4eknPCd_HtZ73#ck-Ud_F1`N#hO5j$v! diff --git a/data/assets/import.svg b/data/assets/import.svg new file mode 100644 index 0000000..99b8b89 --- /dev/null +++ b/data/assets/import.svg @@ -0,0 +1,4 @@ + + + + \ No newline at end of file diff --git a/data/assets/last.svg b/data/assets/last.svg new file mode 100644 index 0000000..7db4eff --- /dev/null +++ b/data/assets/last.svg @@ -0,0 +1,7 @@ + + + + + + + \ No newline at end of file diff --git a/data/assets/mia.png b/data/assets/mia.png new file mode 100644 index 0000000000000000000000000000000000000000..89673dc60cadd35a6f445961ed911f61c16c9e05 GIT binary patch literal 54710 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

7?3K~2WCe}Q0Womlr)lmhd%5Hprhvs#= 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%0ABx_kCsaswb|Lw8UN9Hdr6W->IGH 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 Rc~B-yQBGAh{no=5{{#4 + + + + + \ No newline at end of file diff --git a/data/assets/play.svg b/data/assets/play.svg new file mode 100644 index 0000000..4098666 --- /dev/null +++ b/data/assets/play.svg @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/data/assets/stop.svg b/data/assets/stop.svg new file mode 100644 index 0000000..64cb7d7 --- /dev/null +++ b/data/assets/stop.svg @@ -0,0 +1,18 @@ + + + + + + + + + diff --git a/data/lang/en.json b/data/lang/en.json index 3d40ef6..2d75877 100644 --- a/data/lang/en.json +++ b/data/lang/en.json @@ -28,5 +28,50 @@ "version": "Version", "details": "Details", "update_details": "Update Details", - "update_aborted": "Update aborted by user" + "update_aborted": "Update aborted by user", + "select_image": "Select a File", + "select_folder": "Select a Folder", + "import": "Import", + "drag_drop": "Drag and Drop here", + "path_placeholder": "Path to file or folder", + "about": "

Image anonymization application.

\n

Version {v}

\n

Developed in Python.

", + "export_label": "Export Data", + "export_button": "Export", + "export_type_images": "Export Images", + "export_type_metadata": "Export Metadata", + "no_dicom_files": "No files loaded", + "eraser": "Eraser", + "quit_eraser": "Quit Eraser", + "rebuild": "Rebuild", + "dicom_name": "Radio Name", + "select_dicom_to_export": "Select radios to export", + "confirm": "Confirm", + "cancel": "Cancel", + "group": "Group", + "importing": "Importing...", + "import_complete": "Import complete", + "processing_paths": "Searching for DICOMs...", + "creating_dicoms": "Creating DICOM objects...", + "preparing_display": "Preparing display...", + "validating_files": "Validating files...", + "no_dicom_found": "No DICOM files found in the selected path.", + "no_images_found": "No images found.", + "all_dicoms_already_imported": "Founded DICOM files are already imported.", + "clear_mask": "Clear mask", + "load_error": "Error loading DICOM files. If this problem persists, feel free to contact me via the dedicated tab.", + "preparing_export": "Preparing export...", + "exporting_pdf": "Exporting to PDF...", + "exporting_png": "Exporting to PNG...", + "exporting_json": "Exporting JSON metadata...", + "exporting_xls": "Exporting XLS metadata...", + "exporting_dicomdir": "Exporting to DICOMDIR...", + "exporting_dcm": "Exporting to DCM...", + "export_complete": "Export complete", + "export_success": "Export successful!", + "export_error": "Error during export.", + "no_data_to_export": "No data selected for export.", + "error_loading_image": "Error loading image : {x}.", + "export_metadata_error": "Error exporting metadata. Some files may have been exported.", + "export_partial_success": "Export partially successful. Some files could not be exported.", + "choose_export_destination": "Choose export destination folder" } \ No newline at end of file diff --git a/data/lang/es.json b/data/lang/es.json new file mode 100644 index 0000000..557bc1f --- /dev/null +++ b/data/lang/es.json @@ -0,0 +1,77 @@ +{ + "lang_name": "Español", + "language": "Idioma :", + "theme": "Tema :", + "dark_theme": "Tema Oscuro", + "light_theme": "Tema Claro", + "yes": "Sí", + "no": "No", + "confirmation": "Confirmación", + "information": "Información", + "close": "Cerrar", + "suggestion_text": "¿Tienes una pregunta o una idea para mejorar esta aplicación? ¡Envíame un mensaje!", + "suggestion_placeholder": "Escribe tu mensaje aquí...", + "send_suggestion": "Enviar", + "sending": "Enviando...", + "success": "Éxito", + "error": "Error", + "suggestion_sent_success": "¡Tu mensaje ha sido enviado con éxito!", + "suggestion_send_error": "Error al enviar el mensaje. Inténtalo de nuevo más tarde.", + "email_credentials_error": "Credenciales de correo electrónico no configuradas o mal configuradas. Por favor, establece tu correo y contraseña en el archivo .env.", + "suggestion_too_short": "El mensaje debe tener al menos 15 caracteres.", + "update_found": "Nueva versión disponible: {latest_tag} \n¿Quieres instalar la actualización?", + "choose_update_folder": "Elige la carpeta de destino", + "downloading_update": "Descargando actualización...", + "update_downloaded": "Actualización descargada en {local_path}", + "update_download_error": "Error al descargar la actualización", + "update": "Actualizar", + "version": "Versión", + "details": "Detalles", + "update_details": "Detalles de la actualización", + "update_aborted": "Actualización abortada por el usuario", + "select_image": "Seleccionar un Archivo", + "select_folder": "Seleccionar una Carpeta", + "import": "Importar", + "drag_drop": "Arrastra y suelta aquí", + "path_placeholder": "Ruta al archivo o carpeta", + "about": "

Aplicación de anonimización de imágenes.

\n

Versión {v}

\n

Desarrollada en Python.

", + "export_label": "Exportar Datos", + "export_button": "Exportar", + "export_type_images": "Exportar Imágenes", + "export_type_metadata": "Exportar Metadatos", + "no_dicom_files": "No hay archivos cargados", + "eraser": "Borrador", + "quit_eraser": "Salir del Borrador", + "rebuild": "Reconstruir", + "dicom_name": "Nombre Radio", + "select_dicom_to_export": "Selecciona los radios para exportar", + "confirm": "Confirmar", + "cancel": "Cancelar", + "group": "Grupo", + "importing": "Importando...", + "import_complete": "Importación completa", + "processing_paths": "Buscando DICOMs...", + "creating_dicoms": "Creando objetos DICOM...", + "preparing_display": "Preparando visualización...", + "validating_files": "Validando archivos...", + "no_dicom_found": "No se encontraron archivos DICOM en la ruta seleccionada.", + "no_images_found": "No se encontraron imágenes.", + "all_dicoms_already_imported": "Los archivos DICOM encontrados ya están importados.", + "clear_mask": "Limpiar máscara", + "load_error": "Error al cargar archivos DICOM. Si este problema persiste, no dudes en contactarme a través de la pestaña dedicada.", + "preparing_export": "Preparando exportación...", + "exporting_pdf": "Exportando a PDF...", + "exporting_png": "Exportando a PNG...", + "exporting_json": "Exportando metadatos JSON...", + "exporting_xls": "Exportando metadatos XLS...", + "exporting_dicomdir": "Exportando a DICOMDIR...", + "exporting_dcm": "Exportando a DCM...", + "export_complete": "Exportación completa", + "export_success": "¡Exportación exitosa!", + "export_error": "Error durante la exportación.", + "no_data_to_export": "No se seleccionaron datos para exportar.", + "error_loading_image": "Error al cargar la imagen: {x}.", + "export_metadata_error": "Error al exportar metadatos. Algunos archivos pueden haber sido exportados.", + "export_partial_success": "Exportación parcialmente exitosa. Algunos archivos no pudieron ser exportados.", + "choose_export_destination": "Elige la carpeta de destino para la exportación" +} \ No newline at end of file diff --git a/data/lang/fr.json b/data/lang/fr.json index cd713fc..805b6d3 100644 --- a/data/lang/fr.json +++ b/data/lang/fr.json @@ -28,5 +28,50 @@ "version": "Version", "details": "Détails", "update_details": "Détails de la mise à jour", - "update_aborted": "Mise à jour annulée par l'utilisateur" + "update_aborted": "Mise à jour annulée par l'utilisateur", + "select_image": "Sélectionner un Fichier", + "select_folder": "Sélectionner un Dossier", + "import": "Importer", + "drag_drop": "Glisser-Déposer ici", + "path_placeholder": "Chemin vers le fichier ou dossier", + "about": "

Application d'anonymisation d'images.

\n

Version {v}

\n

Développée en Python.

", + "export_label": "Exporter les Données", + "export_button": "Exporter", + "export_type_images": "Exporter les Images", + "export_type_metadata": "Exporter les Métadonnées", + "no_dicom_files": "Aucun fichier chargé", + "eraser": "Gomme", + "quit_eraser": "Quitter la Gomme", + "rebuild": "Reconstruire", + "dicom_name": "Nom Radio", + "select_dicom_to_export": "Sélectionnez les radios à exporter", + "confirm": "Confirmer", + "cancel": "Annuler", + "group": "Groupe", + "importing": "Importation...", + "import_complete": "Importation terminée", + "processing_paths": "Recherche des DICOMs...", + "creating_dicoms": "Création des objets DICOM...", + "preparing_display": "Préparation de l'affichage...", + "validating_files": "Validation des fichiers...", + "no_dicom_found": "Aucun fichier DICOM trouvé dans le chemin sélectionné.", + "no_images_found": "Aucune image trouvée.", + "all_dicoms_already_imported": "Les fichiers DICOM trouvés ont déjà été importés.", + "clear_mask": "Effacer le masque", + "load_error": "Erreur lors du chargement des fichiers DICOM. Si ce problème persiste, n'hésitez pas à me contacter via l'onglet dédié.", + "preparing_export": "Préparation de l'exportation...", + "exporting_pdf": "Exportation en PDF...", + "exporting_png": "Exportation en PNG...", + "exporting_json": "Exportation des métadonnées JSON...", + "exporting_xls": "Exportation des métadonnées XLS...", + "exporting_dicomdir": "Exportation en DICOMDIR...", + "exporting_dcm": "Exportation en DCM...", + "export_complete": "Exportation terminée", + "export_success": "Exportation réussie !", + "export_error": "Erreur lors de l'exportation.", + "no_data_to_export": "Aucune donnée sélectionnée pour l'exportation.", + "error_loading_image": "Erreur lors du chargement de l'image : {x}.", + "export_metadata_error": "Erreur lors de l'exportation des métadonnées. Certains fichiers ont pu être exportés.", + "export_partial_success": "Exportation partiellement réussie. Certains fichiers n'ont pas pu être exportés.", + "choose_export_destination": "Choisissez le dossier de destination pour l'exportation" } \ No newline at end of file diff --git a/data/themes/dark.json b/data/themes/dark.json index 4ee5cd8..47ac691 100644 --- a/data/themes/dark.json +++ b/data/themes/dark.json @@ -6,7 +6,7 @@ "background_tertiary_color": "#4A4A4A", "border_color": "#3C3C3E", "text_color": "#D1D1D6", - "primary_color": "#0A84FF", + "primary_color": "#4A4A4A", "primary_hover_color": "#007AFF", "icon_selected_color": "#D1D1D6", "icon_unselected_color": "#4A4A4A", diff --git a/data/themes/light.json b/data/themes/light.json index 4fe80b3..aae582a 100644 --- a/data/themes/light.json +++ b/data/themes/light.json @@ -6,7 +6,7 @@ "background_tertiary_color": "#E0E0E0", "border_color": "#1f1f20", "text_color": "#000000", - "primary_color": "#0A84FF", + "primary_color": "#5D5A5A", "primary_hover_color": "#007AFF", "icon_selected_color": "#000000", "icon_unselected_color": "#5D5A5A", diff --git a/main.py b/main.py index 29bf4bd..7e71c1e 100644 --- a/main.py +++ b/main.py @@ -21,26 +21,27 @@ def main() -> int: splash_image_path = paths.get_asset_path(settings_manager.get_config("splash_image")) use_splash = splash_image_path and paths.Path(splash_image_path).exists() - # Créer la fenêtre principale - window: MainWindow = MainWindow() - if use_splash: # Créer et afficher le splash screen splash = SplashScreen(duration=1500) splash.show_splash() - # Connecter le signal finished pour afficher la fenêtre principale et vérifier les mises à jour + # Connecter le signal finished pour créer et afficher la fenêtre principale def show_main_window(): if update_manager.check_for_update(): - return 0 + app.quit() + return + window: MainWindow = MainWindow() window.show() - splash.finished.connect(lambda: show_main_window()) + splash.finished.connect(show_main_window) else: # Pas de splash screen, vérifier les mises à jour puis afficher la fenêtre principale if update_manager.check_for_update(): return 0 + window: MainWindow = MainWindow() window.show() + return app.exec() if __name__ == "__main__": diff --git a/requirements.txt b/requirements.txt index 390d828..03f9b39 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,4 +1,10 @@ PyQt6 pyinstaller python-dotenv -requests \ No newline at end of file +requests +reportlab +pydicom +numpy +opencv-python +pandas +openpyxl \ No newline at end of file