mosamatic2 2.0.1__py3-none-any.whl → 2.0.3__py3-none-any.whl

mosamatic2/core/utils.py

@@ -0,0 +1,316 @@
+import time
+import os
+import click
+import textwrap
+import math
+import pendulum
+import numpy as np
+import struct
+import binascii
+import pydicom
+import warnings
+from pathlib import Path
+from pydicom.uid import (
+    ExplicitVRLittleEndian, ImplicitVRLittleEndian, ExplicitVRBigEndian
+)
+from PIL import Image
+
+warnings.filterwarnings("ignore", message="Invalid value for VR UI:", category=UserWarning)
+
+MUSCLE, VAT, SAT = 1, 5, 7
+
+
+def create_name_with_timestamp(prefix: str='') -> str:
+    tz = pendulum.local_timezone()
+    timestamp = pendulum.now(tz).strftime('%Y%m%d%H%M%S%f')[:17]
+    if prefix != '' and not prefix.endswith('-'):
+        prefix = prefix + '-'
+    name = f'{prefix}{timestamp}'
+    return name
+
+
+def show_doc_command(cli_group: click.Group) -> click.Command:
+    @click.command(name="showdoc")
+    @click.argument("command_name", required=False)
+    def show_doc(command_name):
+        commands = cli_group.commands
+        if command_name:
+            cmd = commands.get(command_name)
+            if cmd and hasattr(cmd, 'callback') and cmd.callback.__doc__:
+                print()
+                print(textwrap.dedent(cmd.callback.__doc__).strip())
+            else:
+                click.echo(f'No docstring found for command: {command_name}')
+        else:
+            click.echo('Available commands with docstrings:')
+            for name, cmd in commands.items():
+                if hasattr(cmd, 'callback') and cmd.callback.__doc__:
+                    click.echo(f"  {name}")
+            click.echo('\nUse: `mosamatic show-doc <command>` to view a commands docstring')
+    return show_doc
+
+
+def home_dir():
+    return Path.home()
+
+
+def mosamatic_dir():
+    d = os.path.join(home_dir(), '.mosamatic2')
+    os.makedirs(d, exist_ok=True)
+    return d
+
+
+def mosamatic_data_dir():
+    data_dir = os.path.join(mosamatic_dir(), 'data')
+    os.makedirs(data_dir, exist_ok=True)
+    return data_dir
+
+
+def mosamatic_output_dir():
+    output_dir = os.path.join(mosamatic_data_dir(), 'output')
+    os.makedirs(output_dir, exist_ok=True)
+    return output_dir
+
+
+def current_time_in_milliseconds():
+    return int(round(time.time() * 1000))
+
+
+def current_time_in_seconds() -> int:
+    return int(round(current_time_in_milliseconds() / 1000.0))
+
+
+def elapsed_time_in_milliseconds(start_time_in_milliseconds):
+    return current_time_in_milliseconds() - start_time_in_milliseconds
+
+
+def elapsed_time_in_seconds(start_time_in_seconds):
+    return current_time_in_seconds() - start_time_in_seconds
+
+
+def duration(seconds):
+    h = int(math.floor(seconds/3600.0))
+    remainder = seconds - h * 3600
+    m = int(math.floor(remainder/60.0))
+    remainder = remainder - m * 60
+    s = int(math.floor(remainder))
+    return '{} hours, {} minutes, {} seconds'.format(h, m, s)
+
+
+def is_dicom(f):
+    try:
+        pydicom.dcmread(f, stop_before_pixels=True)
+        return True
+    except pydicom.errors.InvalidDicomError:
+        return False
+    
+
+def load_dicom(f, stop_before_pixels=False):
+    if is_dicom(f):
+        return pydicom.dcmread(f, stop_before_pixels=stop_before_pixels)
+    return None
+
+
+def is_jpeg2000_compressed(p):
+    return p.file_meta.TransferSyntaxUID not in [ExplicitVRLittleEndian, ImplicitVRLittleEndian, ExplicitVRBigEndian]
+
+
+def is_numpy_array(value):
+    return isinstance(value, np.array)
+
+
+def load_numpy_array(f):
+    try:
+        return np.load(f)
+    except Exception as e:
+        return None
+
+
+def get_pixels_from_tag_file(tag_file_path):
+    f = open(tag_file_path, 'rb')
+    f.seek(0)
+    byte = f.read(1)
+    # Make sure to check the byte-value in Python 3!!
+    while byte != b'':
+        byte_hex = binascii.hexlify(byte)
+        if byte_hex == b'0c':
+            break
+        byte = f.read(1)
+    values = []
+    f.read(1)
+    while byte != b'':
+        v = struct.unpack('b', byte)
+        values.append(v)
+        byte = f.read(1)
+    values = np.asarray(values)
+    values = values.astype(np.uint16)
+    return values
+
+
+def get_rescale_params(p):
+    rescale_slope = getattr(p, 'RescaleSlope', None)
+    rescale_intercept = getattr(p, 'RescaleIntercept', None)
+    if rescale_slope is not None and rescale_intercept is not None:
+        return rescale_slope, rescale_intercept
+    # Try Enhanced DICOM structure
+    if 'SharedFunctionalGroupsSequence' in p:
+        fg = p.SharedFunctionalGroupsSequence[0]
+        if 'PixelValueTransformationSequence' in fg:
+            pvt = fg.PixelValueTransformationSequence[0]
+            rescale_slope = pvt.get('RescaleSlope', 1)
+            rescale_intercept = pvt.get('RescaleIntercept', 0)
+            return rescale_slope, rescale_intercept
+    return 1, 0
+
+
+def get_pixels_from_dicom_object(p, normalize=True):
+    pixels = p.pixel_array
+    if not normalize:
+        return pixels
+    if normalize is True: # Map pixel values back to original HU values
+        rescale_slope, rescale_intercept = get_rescale_params(p)
+        return rescale_slope * pixels + rescale_intercept
+    if isinstance(normalize, int):
+        return (pixels + np.min(pixels)) / (np.max(pixels) - np.min(pixels)) * normalize
+    if isinstance(normalize, list):
+        return (pixels + np.min(pixels)) / (np.max(pixels) - np.min(pixels)) * normalize[1] + normalize[0]
+    return pixels
+
+
+def convert_labels_to_157(label_image: np.array) -> np.array:
+    label_image157 = np.copy(label_image)
+    label_image157[label_image157 == 1] = 1
+    label_image157[label_image157 == 2] = 5
+    label_image157[label_image157 == 3] = 7
+    return label_image157
+
+
+def normalize_between(img: np.array, min_bound: int, max_bound: int) -> np.array:
+    img = (img - min_bound) / (max_bound - min_bound)
+    img[img > 1] = 0
+    img[img < 0] = 0
+    c = (img - np.min(img))
+    d = (np.max(img) - np.min(img))
+    img = np.divide(c, d, np.zeros_like(c), where=d != 0)
+    return img
+
+
+def apply_window_center_and_width(image: np.array, center: int, width: int) -> np.array:
+    image_min = center - width // 2
+    image_max = center + width // 2
+    windowed_image = np.clip(image, image_min, image_max)
+    windowed_image = ((windowed_image - image_min) / (image_max - image_min)) * 255.0
+    return windowed_image.astype(np.uint8)
+
+
+def calculate_area(labels: np.array, label, pixel_spacing) -> float:
+    mask = np.copy(labels)
+    mask[mask != label] = 0
+    mask[mask == label] = 1
+    area = np.sum(mask) * (pixel_spacing[0] * pixel_spacing[1]) / 100.0
+    return area
+
+
+def calculate_index(area: float, height: float) -> float:
+    return area / (height * height)
+
+
+def calculate_mean_radiation_attenuation(image: np.array, labels: np.array, label: int) -> float:
+    mask = np.copy(labels)
+    mask[mask != label] = 0
+    mask[mask == label] = 1
+    subtracted = image * mask
+    mask_sum = np.sum(mask)
+    if mask_sum > 0.0:
+        mean_radiation_attenuation = np.sum(subtracted) / np.sum(mask)
+    else:
+        # print('Sum of mask pixels is zero, return zero radiation attenuation')
+        mean_radiation_attenuation = 0.0
+    return mean_radiation_attenuation
+
+
+def calculate_dice_score(ground_truth: np.array, prediction: np.array, label: int) -> float:
+    numerator = prediction[ground_truth == label]
+    numerator[numerator != label] = 0
+    n = ground_truth[prediction == label]
+    n[n != label] = 0
+    if np.sum(numerator) != np.sum(n):
+        raise RuntimeError('Mismatch in Dice score calculation!')
+    denominator = (np.sum(prediction[prediction == label]) + np.sum(ground_truth[ground_truth == label]))
+    dice_score = np.sum(numerator) * 2.0 / denominator
+    return dice_score
+
+
+def convert_dicom_to_numpy_array(dicom_file_path: str, window_level: int=50, window_width: int=400, normalize=True) -> np.array:
+    p = pydicom.dcmread(dicom_file_path)
+    pixels = p.pixel_array
+    pixels = pixels.reshape(p.Rows, p.Columns)
+    if normalize:
+        b = p.RescaleIntercept
+        m = p.RescaleSlope
+        pixels = m * pixels + b
+    pixels = apply_window_center_and_width(pixels, window_level, window_width)
+    return pixels
+
+
+class ColorMap:
+    def __init__(self, name: str) -> None:
+        self._name = name
+        self._values = []
+
+    def name(self) -> str:
+        return self._name
+    
+    def values(self):
+        return self._values
+    
+
+class GrayScaleColorMap(ColorMap):
+    def __init__(self) -> None:
+        super(GrayScaleColorMap, self).__init__(name='GrayScaleColorMap')
+        # Implement your own gray scale map or let NumPy do this more efficiently?
+        pass    
+
+class AlbertaColorMap(ColorMap):
+    def __init__(self) -> None:
+        super(AlbertaColorMap, self).__init__(name='AlbertaColorMap')
+        for i in range(256):
+            if i == 1:  # muscle
+                self.values().append([255, 0, 0])
+            elif i == 2:  # inter-muscular adipose tissue
+                self.values().append([0, 255, 0])
+            elif i == 5:  # visceral adipose tissue
+                self.values().append([255, 255, 0])
+            elif i == 7:  # subcutaneous adipose tissue
+                self.values().append([0, 255, 255])
+            elif i == 12:  # unknown
+                self.values().append([0, 0, 255])
+            else:
+                self.values().append([0, 0, 0])
+
+
+def apply_color_map(pixels: np.array, color_map: ColorMap) -> np.array:
+    pixels_new = np.zeros((*pixels.shape, 3), dtype=np.uint8)
+    np.take(color_map.values(), pixels, axis=0, out=pixels_new)
+    return pixels_new
+
+
+def convert_numpy_array_to_png_image(
+        numpy_array_file_path_or_object: str, output_dir_path: str, color_map: ColorMap=None, png_file_name: str=None, fig_width: int=10, fig_height: int=10) -> str:
+    if isinstance(numpy_array_file_path_or_object, str):
+        numpy_array = np.load(numpy_array_file_path_or_object)
+    else:
+        numpy_array = numpy_array_file_path_or_object
+        if not png_file_name:
+            raise RuntimeError('PNG file name required for NumPy array object')
+    if color_map:
+        numpy_array = apply_color_map(pixels=numpy_array, color_map=color_map)
+    image = Image.fromarray(numpy_array)
+    if not png_file_name:
+        numpy_array_file_name = os.path.split(numpy_array_file_path_or_object)[1]
+        png_file_name = numpy_array_file_name + '.png'      
+    elif not png_file_name.endswith('.png'):
+        png_file_name += '.png'
+    png_file_path = os.path.join(output_dir_path, png_file_name)
+    image.save(png_file_path)
+    return png_file_path

mosamatic2/server.py

@@ -0,0 +1,98 @@
+import argparse
+import mosamatic2.constants as constants
+from flask import Flask, request
+from mosamatic2.core.tasks import RescaleDicomImagesTask
+from mosamatic2.core.tasks import SegmentMuscleFatL3TensorFlowTask
+from mosamatic2.core.tasks import CalculateScoresTask
+from mosamatic2.core.tasks import CreatePngsFromSegmentationsTask
+
+app = Flask(__name__)
+
+
+@app.route('/test')
+def run_tests():
+    return 'PASSED'
+
+
+@app.route('/rescaledicomimages')
+def run_rescaledicomimages():
+    images = request.args.get('images')
+    target_size = request.args.get('target_size', default=512, type=int)
+    output = request.args.get('output')
+    overwrite = request.args.get('overwrite', default=True, type=bool)
+    task = RescaleDicomImagesTask(
+        inputs={'images': images},
+        params={'target_size': target_size},
+        output=output,
+        overwrite=overwrite,
+    )
+    task.run()
+    return 'PASSED'
+
+
+@app.route('/segmentmusclefatl3tensorflow')
+def run_segmentmusclefatl3tensorflow():
+    images = request.args.get('images')
+    model_files = request.args.get('model_files')
+    output = request.args.get('output')
+    overwrite = request.args.get('overwrite', default=True, type=bool)
+    task = SegmentMuscleFatL3TensorFlowTask(
+        inputs={
+            'images': images,
+            'model_files': model_files,
+        },
+        params={'model_version': 1.0},
+        output=output,
+        overwrite=overwrite,
+    )
+    task.run()
+    return 'PASSED'
+
+
+@app.route('/calculatescores')
+def run_calculatescores():
+    images = request.args.get('images')
+    segmentations = request.args.get('segmentations')
+    file_type = request.args.get('file_type', default='npy', type=str)
+    output = request.args.get('output')
+    overwrite = request.args.get('overwrite', default=True, type=bool)
+    task = CalculateScoresTask(
+        inputs={
+            'images': images,
+            'segmentations': segmentations,
+        },
+        params={'file_type': file_type},
+        output=output,
+        overwrite=overwrite,
+    )
+    task.run()
+    return 'PASSED'
+
+
+@app.route('/createpngsfromsegmentations')
+def run_createpngsfromsegmentations():
+    segmentations = request.args.get('segmentations')
+    fig_width = request.args.get('fig_width', default=10, type=int)
+    fig_height = request.args.get('fig_height', default=10, type=int)
+    output = request.args.get('output')
+    overwrite = request.args.get('overwrite', default=True, type=bool)
+    task = CreatePngsFromSegmentationsTask(
+        inputs={'segmentations': segmentations},
+        params={
+            'fig_width': fig_width,
+            'fig_height': fig_height,
+        },
+        output=output,
+        overwrite=overwrite,
+    )
+    task.run()
+    return 'PASSED'
+
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--port', type=int, default=constants.MOSAMATIC2_SERVER_PORT)
+    parser.add_argument('--debug', type=bool, default=constants.MOSAMATIC2_SERVER_DEBUG)
+    args = parser.parse_args()
+    app.run(host='0.0.0.0', port=args.port, debug=args.debug)

mosamatic2/ui/mainwindow.py

@@ -0,0 +1,196 @@
+import os
+import mosamatic2.constants as constants
+from PySide6.QtWidgets import (
+    QMainWindow,
+)
+from PySide6.QtGui import (
+    QGuiApplication,
+    QAction,
+    QIcon,
+)
+from PySide6.QtCore import Qt, QByteArray
+from mosamatic2.ui.utils import version, resource_path, is_macos
+from mosamatic2.core.managers.logmanager import LogManager
+from mosamatic2.ui.settings import Settings
+from mosamatic2.ui.widgets.panels.mainpanel import MainPanel
+from mosamatic2.ui.widgets.panels.logpanel import LogPanel
+from mosamatic2.ui.widgets.panels.tasks.rescaledicomimagestaskpanel import RescaleDicomImagesTaskPanel
+from mosamatic2.ui.widgets.panels.tasks.segmentmusclefatl3tensorflowtaskpanel import SegmentMuscleFatL3TensorFlowTaskPanel
+from mosamatic2.ui.widgets.panels.tasks.createpngsfromsegmentationstaskpanel import CreatePngsFromSegmentationsTaskPanel
+from mosamatic2.ui.widgets.panels.tasks.calculatescorestaskpanel import CalculateScoresTaskPanel
+from mosamatic2.ui.widgets.panels.pipelines.defaultpipelinepanel import DefaultPipelinePanel
+
+LOG = LogManager()
+
+
+class MainWindow(QMainWindow):
+    def __init__(self):
+        super(MainWindow, self).__init__()
+        self._settings = None
+        self._main_panel = None
+        self._log_panel = None
+        self._decompress_dicom_files_task_panel = None
+        self._rescale_dicom_images_task_panel = None
+        self._segment_muscle_fat_l3_tensorflow_task_panel = None
+        self._create_pngs_from_segmentations_task_panel = None
+        self._calculate_scores_task_panel = None
+        self._default_pipeline_panel = None
+        self.init_window()
+
+    def init_window(self):
+        self.setWindowTitle(f'{constants.MOSAMATIC2_WINDOW_TITLE} {version()}')
+        icon_file_name = constants.MOSAMATIC2_APP_ICON_FILE_NAME_MAC if is_macos() else constants.MOSAMATIC2_APP_ICON_FILE_NAME_WIN
+        icon_path = resource_path(os.path.join(constants.MOSAMATIC2_ICONS_DIR_PATH, icon_file_name))
+        self.setWindowIcon(QIcon(icon_path))
+        if not self.load_geometry_and_state():
+            self.set_default_size_and_position()
+        self.init_menus()
+        self.init_status_bar()
+        self.addDockWidget(Qt.DockWidgetArea.TopDockWidgetArea, self.main_panel())
+        self.addDockWidget(Qt.DockWidgetArea.BottomDockWidgetArea, self.log_panel())
+
+    def init_menus(self):
+        self.init_app_menu()
+        self.init_tasks_menu()
+        self.init_pipelines_menu()
+        if is_macos():            
+            self.menuBar().setNativeMenuBar(False)
+
+    def init_app_menu(self):
+        exit_action = QAction('Exit', self)
+        exit_action.triggered.connect(self.close)
+        app_menu = self.menuBar().addMenu('Application')
+        app_menu.addAction(exit_action)
+
+    def init_tasks_menu(self):
+        rescale_dicom_images_task_action = QAction('RescaleDicomImagesTask', self)
+        rescale_dicom_images_task_action.triggered.connect(self.handle_rescale_dicom_images_task_action)
+        segment_muscle_fat_l3_tensorflow_task_action = QAction('SegmentMuscleAndFatTask (TensorFlow)', self)
+        segment_muscle_fat_l3_tensorflow_task_action.triggered.connect(self.handle_segment_muscle_fat_l3_tensorflow_task_action)
+        calculate_scores_task_action = QAction('CalculateScoresTask', self)
+        calculate_scores_task_action.triggered.connect(self.handle_calculate_scores_task_action)
+        create_pngs_from_segmentations_task_action = QAction('CreatePngsFromSegmentationsTask', self)
+        create_pngs_from_segmentations_task_action.triggered.connect(self.handle_create_pngs_from_segmentations_task_action)
+        tasks_menu = self.menuBar().addMenu('Tasks')
+        tasks_menu.addAction(rescale_dicom_images_task_action)
+        tasks_menu.addAction(segment_muscle_fat_l3_tensorflow_task_action)
+        tasks_menu.addAction(calculate_scores_task_action)
+        tasks_menu.addAction(create_pngs_from_segmentations_task_action)
+
+    def init_pipelines_menu(self):
+        default_pipeline_action = QAction('DefaultPipeline', self)
+        default_pipeline_action.triggered.connect(self.handle_default_pipeline_action)
+        pipelines_menu = self.menuBar().addMenu('Pipelines')
+        pipelines_menu.addAction(default_pipeline_action)
+
+    def init_status_bar(self):
+        self.set_status('Ready')
+
+    # GET
+
+    def settings(self):
+        if not self._settings:
+            self._settings = Settings()
+        return self._settings
+
+    def main_panel(self):
+        if not self._main_panel:
+            self._main_panel = MainPanel(self)
+            self._main_panel.add_panel(self.rescale_dicom_images_task_panel(), 'rescaledicomimagestaskpanel')
+            self._main_panel.add_panel(self.segment_muscle_fat_l3_tensorflow_task_panel(), 'segmentmusclefatl3tensorflowtaskpanel')
+            self._main_panel.add_panel(self.create_pngs_from_segmentations_task_panel(), 'createpngsfromsegmentationstaskpanel')
+            self._main_panel.add_panel(self.calculate_scores_task_panel(), 'calculatescorestaskpanel')
+            self._main_panel.add_panel(self.default_pipeline_panel(), 'defaultpipelinepanel')
+            self._main_panel.select_panel('defaultpipelinepanel')
+        return self._main_panel
+    
+    def log_panel(self):
+        if not self._log_panel:
+            self._log_panel = LogPanel()
+            LOG.add_listener(self._log_panel)
+        return self._log_panel
+
+    # MISCELLANEOUS
+
+    def rescale_dicom_images_task_panel(self):
+        if not self._rescale_dicom_images_task_panel:
+            self._rescale_dicom_images_task_panel = RescaleDicomImagesTaskPanel()
+        return self._rescale_dicom_images_task_panel
+    
+    def segment_muscle_fat_l3_tensorflow_task_panel(self):
+        if not self._segment_muscle_fat_l3_tensorflow_task_panel:
+            self._segment_muscle_fat_l3_tensorflow_task_panel = SegmentMuscleFatL3TensorFlowTaskPanel()
+        return self._segment_muscle_fat_l3_tensorflow_task_panel
+
+    def create_pngs_from_segmentations_task_panel(self):
+        if not self._create_pngs_from_segmentations_task_panel:
+            self._create_pngs_from_segmentations_task_panel = CreatePngsFromSegmentationsTaskPanel()
+        return self._create_pngs_from_segmentations_task_panel
+    
+    def calculate_scores_task_panel(self):
+        if not self._calculate_scores_task_panel:
+            self._calculate_scores_task_panel = CalculateScoresTaskPanel()
+        return self._calculate_scores_task_panel
+    
+    def default_pipeline_panel(self):
+        if not self._default_pipeline_panel:
+            self._default_pipeline_panel = DefaultPipelinePanel()
+        return self._default_pipeline_panel
+
+    # SETTERS
+
+    def set_status(self, message):
+        self.statusBar().showMessage(message)
+
+    # EVENT HANDLERS
+
+    def handle_rescale_dicom_images_task_action(self):
+        self.main_panel().select_panel('rescaledicomimagestaskpanel')
+
+    def handle_segment_muscle_fat_l3_tensorflow_task_action(self):
+        self.main_panel().select_panel('segmentmusclefatl3tensorflowtaskpanel')
+
+    def handle_create_pngs_from_segmentations_task_action(self):
+        self.main_panel().select_panel('createpngsfromsegmentationstaskpanel')
+
+    def handle_calculate_scores_task_action(self):
+        self.main_panel().select_panel('calculatescorestaskpanel')
+
+    def handle_default_pipeline_action(self):
+        self.main_panel().select_panel('defaultpipelinepanel')
+
+    def showEvent(self, event):
+        return super().showEvent(event)
+
+    def closeEvent(self, event):
+        self.save_geometry_and_state()
+        # Save inputs and parameters of relevant panels
+        self.rescale_dicom_images_task_panel().save_inputs_and_parameters()
+        self.segment_muscle_fat_l3_tensorflow_task_panel().save_inputs_and_parameters()
+        self.create_pngs_from_segmentations_task_panel().save_inputs_and_parameters()
+        self.calculate_scores_task_panel().save_inputs_and_parameters()
+        self.default_pipeline_panel().save_inputs_and_parameters()
+        return super().closeEvent(event)
+
+    def load_geometry_and_state(self):
+        geometry = self.settings().get(constants.MOSAMATIC2_WINDOW_GEOMETRY_KEY)
+        state = self.settings().get(constants.MOSAMATIC2_WINDOW_STATE_KEY)
+        if isinstance(geometry, QByteArray) and self.restoreGeometry(geometry):
+            if isinstance(state, QByteArray):
+                self.restoreState(state)
+            return True
+        return False
+
+    def save_geometry_and_state(self):
+        self.settings().set(constants.MOSAMATIC2_WINDOW_GEOMETRY_KEY, self.saveGeometry())
+        self.settings().set(constants.MOSAMATIC2_WINDOW_STATE_KEY, self.saveState())
+
+    def set_default_size_and_position(self):
+        self.resize(constants.MOSAMATIC2_WINDOW_W, constants.MOSAMATIC2_WINDOW_H)
+        self.center_window()
+
+    def center_window(self):
+        screen = QGuiApplication.primaryScreen().geometry()
+        x = (screen.width() - self.geometry().width()) / 2
+        y = (screen.height() - self.geometry().height()) / 2
+        self.move(int(x), int(y))

mosamatic2/ui/resources/VERSION

@@ -0,0 +1 @@
+2.0.3 

mosamatic2/ui/settings.py

@@ -0,0 +1,62 @@
+import mosamatic2.constants as constants
+from PySide6.QtCore import QSettings
+from mosamatic2.core.managers.logmanager import LogManager
+
+LOG = LogManager()
+
+
+class Settings(QSettings):
+    def __init__(self):
+        super(Settings, self).__init__(
+            QSettings.IniFormat, 
+            QSettings.UserScope, 
+            constants.MOSAMATIC2_BUNDLE_IDENTIFIER, 
+            constants.MOSAMATIC2_APP_NAME,
+        )
+
+    def prepend_bundle_identifier_and_name(self, name):
+        return '{}.{}.{}'.format(constants.MOSAMATIC2_BUNDLE_IDENTIFIER, constants.MOSAMATIC2_APP_NAME, name)
+
+    def get(self, name, default=None):
+        if not name.startswith(constants.MOSAMATIC2_BUNDLE_IDENTIFIER):
+            name = self.prepend_bundle_identifier_and_name(name)
+        value = self.value(name)
+        if value is None or value == '':
+            return default
+        return value
+    
+    def get_int(self, name, default=None):
+        try:
+            return int(self.get(name, default))
+        except ValueError as e:
+            return default
+        
+    def get_float(self, name, default=None):
+        try:
+            return float(self.get(name, default))
+        except ValueError as e:
+            return default
+        
+    def get_bool(self, name, default=None):
+        try:
+            value = self.get(name, default)
+            if value and isinstance(value, str):
+                if value == '0' or value.lower() == 'false':
+                    return False
+                elif value == '1' or value.lower() == 'true':
+                    return True
+                else:
+                    return default
+            if value and isinstance(value, bool):
+                return value
+        except ValueError as e:
+            return default
+    
+    def set(self, name, value):
+        name = self.prepend_bundle_identifier_and_name(name)
+        self.setValue(name, value)
+
+    def print(self):
+        LOG.info(f'Settings path: {self.fileName()}')
+        for key in self.allKeys():
+            LOG.info(f'Settings: {key}')