Semapp 1.0.5__py3-none-any.whl

semapp/Layout/main_window_att.py

@@ -0,0 +1,54 @@
+"""
+Manage the scrollbar and the functions for the window size
+"""
+from PyQt5.QtCore import Qt, QSize
+from PyQt5.QtWidgets import QScrollArea, QVBoxLayout
+from PyQt5.QtGui import QGuiApplication
+
+
+class LayoutFrame:
+    """Class for setting up layout and scroll area"""
+
+    def __init__(self, main_window):
+        self.main_window = main_window
+        self.canvas_widget = None
+        self.canvas_layout = None
+        self.scroll_area = QScrollArea(main_window)
+
+    def setup_layout(self, canvas_widget, canvas_layout):
+        """Set up layout with scroll area and other settings"""
+        self.canvas_widget = canvas_widget
+        self.canvas_layout = canvas_layout
+
+        # Set up the QScrollArea
+        self.scroll_area.setWidget(self.canvas_widget)
+        self.scroll_area.setWidgetResizable(True)
+        self.scroll_area.setHorizontalScrollBarPolicy(Qt.ScrollBarAsNeeded)
+        self.scroll_area.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded)
+
+        # Set layout for the main window
+        layout = QVBoxLayout(self.main_window)
+        layout.addWidget(self.scroll_area)
+        self.main_window.setLayout(layout)
+
+    def set_max_window_size(self):
+        """Set the maximum window size based on the screen size"""
+        screen_geometry = QGuiApplication.primaryScreen().availableGeometry()
+        max_width = screen_geometry.width()
+        max_height = screen_geometry.height() - 50
+        self.main_window.setMaximumSize(max_width, max_height)
+
+    def position_window_top_left(self):
+        """Position the window at the top-left corner of the screen"""
+        screen_geometry = QGuiApplication.primaryScreen().availableGeometry()
+        self.main_window.move(screen_geometry.topLeft())
+
+    def adjust_scroll_area_size(self):
+        """Adjust the size of the window based on the content"""
+        self.canvas_widget.adjustSize()
+        optimal_size = self.canvas_widget.sizeHint()
+
+        screen_size = QGuiApplication.primaryScreen().availableSize()
+        new_size = QSize(min(optimal_size.width(), screen_size.width()) + 50,
+                         min(optimal_size.height(), screen_size.height()) + 50)
+        self.main_window.resize(new_size)

semapp/Layout/settings.py

@@ -0,0 +1,170 @@
+"""Module for settings window"""
+# pylint: disable=no-name-in-module, trailing-whitespace, too-many-branches, too-many-statements
+import os
+import json
+from PyQt5.QtWidgets import (
+    QDialog, QVBoxLayout, QTableWidget, QPushButton,
+    QTableWidgetItem
+)
+from PyQt5.QtCore import pyqtSignal
+
+class SettingsWindow(QDialog):
+    """Class for settings window"""
+    data_updated = pyqtSignal()  # Signal emitted when data is updated
+
+    def __init__(self):
+        super().__init__()
+        self.setWindowTitle("Settings")
+
+        # Get the user's folder path (C:\Users\XXXXX)
+        self.user_folder = os.path.expanduser("~")
+
+        # Define the new folder "SEM" and the file to store settings
+        self.new_folder = os.path.join(self.user_folder, "SEM")
+        self.data_file = os.path.join(self.new_folder, "settings_data.json")
+        self.data = []  # Structure to store the table data
+
+        # Set up the UI layout
+        self.layout = QVBoxLayout()
+        self.setLayout(self.layout)
+
+        # Create and add the table and buttons to the layout
+        self.create_table()
+        self.create_buttons()
+
+        # Load data from the settings file
+        self.load_data()
+
+    def create_table(self):
+        """Create the settings table."""
+        self.table = QTableWidget()
+        self.table.setColumnCount(2)
+        self.table.setHorizontalHeaderLabels(["Scale", "Image Type"])
+
+        # Temporarily block signals to prevent updates during initialization
+        self.table.blockSignals(True)
+
+        # Populate the table with existing data
+        for row_data in self.data:
+            if "Scale" in row_data and "Image Type" in row_data:
+                self.add_row(row_data["Scale"], row_data["Image Type"], update_data=False)
+            else:
+                print(f"Invalid row data: {row_data}")
+
+        # Re-enable signals after table population
+        self.table.blockSignals(False)
+
+        # Connect the itemChanged signal to update the data structure
+        self.table.itemChanged.connect(self.update_data)
+        self.layout.addWidget(self.table)
+
+    def create_buttons(self):
+        """Create buttons to add and remove rows."""
+        add_button = QPushButton("Add Row")
+        remove_button = QPushButton("Remove Selected Row")
+
+        add_button.clicked.connect(self.add_row)
+        remove_button.clicked.connect(self.remove_selected_row)
+
+        self.layout.addWidget(add_button)
+        self.layout.addWidget(remove_button)
+
+    def add_row(self, scale="5x5", image_type="Type", update_data=True):
+        """Add a new row to the table with default values."""
+        row_position = self.table.rowCount()
+        self.table.insertRow(row_position)
+
+        scale_item = QTableWidgetItem(scale)
+        image_type_item = QTableWidgetItem(image_type)
+
+        self.table.setItem(row_position, 0, scale_item)
+        self.table.setItem(row_position, 1, image_type_item)
+
+        if update_data:
+            self.data.append({"Scale": scale, "Image Type": image_type})
+            print("Row added:", self.data)
+
+    def remove_selected_row(self):
+        """Remove the currently selected row from the table."""
+        current_row = self.table.currentRow()
+        if current_row != -1:
+            self.table.removeRow(current_row)
+            del self.data[current_row]
+            print("Row removed:", self.data)
+
+    def update_data(self, item):
+        """Update the data structure when a cell value changes."""
+        try:
+            row = item.row()
+            column = item.column()
+            value = item.text().strip()
+
+            while len(self.data) <= row:
+                self.data.append({"Scale": "", "Image Type": ""})
+
+            if column == 0:  # Update "Scale"
+                if not value.replace('.', '', 1).isdigit():
+                    print(f"Invalid value for Scale: {value}")
+                    return
+                self.data[row]["Scale"] = value
+            elif column == 1:  # Update "Image Type"
+                self.data[row]["Image Type"] = value
+            else:
+                print(f"Unexpected column index: {column}")
+                return
+
+            self.save_data()
+            print(f"Data updated successfully: {self.data[row]}")
+        except Exception as e:
+            print(f"Error updating data: {e}")
+
+    def closeEvent(self, event):
+        """Save data to a file when the dialog is closed."""
+        self.save_data()
+        self.data_updated.emit()
+        super().closeEvent(event)
+
+    def normalize_data(self):
+        """Synchronize self.data with the actual table contents."""
+        self.data = self.get_table_data()
+
+    def save_data(self):
+        """Save the table data to a JSON file."""
+        self.normalize_data()
+        with open(self.data_file, "w") as file:
+            json.dump(self.data, file, indent=4)
+        print("Data saved successfully.")
+
+    def load_data(self):
+        """Load the table data from the JSON file."""
+        try:
+            with open(self.data_file, "r") as file:
+                self.data = json.load(file)
+            print("Data loaded successfully:", self.data)
+        except FileNotFoundError:
+            print("No previous data found. Starting fresh.")
+            self.data = []
+        except Exception as err:
+            print(f"Error loading data: {err}")
+            self.data = []
+
+        self.table.blockSignals(True)
+        self.table.setRowCount(0)
+        for row_data in self.data:
+            self.add_row(row_data.get("Scale", ""),
+                        row_data.get("Image Type", ""), update_data=False)
+        self.table.blockSignals(False)
+
+    def get_table_data(self):
+        """Get the current data from the table as a list of dictionaries."""
+        table_data = []
+        for row in range(self.table.rowCount()):
+            scale_item = self.table.item(row, 0)
+            image_type_item = self.table.item(row, 1)
+
+            if scale_item and image_type_item:
+                scale = scale_item.text()
+                image_type = image_type_item.text()
+                table_data.append({"Scale": scale, "Image Type": image_type})
+
+        return table_data 

semapp/Layout/styles.py

@@ -0,0 +1,152 @@
+"""Module containing all styles for the GUI"""
+
+# Radio button styles
+RADIO_BUTTON_STYLE = """
+    QRadioButton {
+        spacing: 0px;
+        font-size: 14px;
+    }
+    QRadioButton::indicator {
+        width: 20px;
+        height: 20px;
+    }
+    QRadioButton::indicator:checked {
+        background-color: #f0ca41;
+        border: 2px solid black;
+    }
+    QRadioButton::indicator:unchecked {
+        background-color: white;
+        border: 2px solid #ccc;
+    }
+"""
+
+# Settings button style
+SETTINGS_BUTTON_STYLE = """
+    QPushButton {
+        font-size: 16px;
+        background-color: #b3e5fc; 
+        border: 2px solid #8c8c8c;
+        border-radius: 10px;
+        padding: 5px;
+        height: 100px;
+    }
+    QPushButton:hover {
+        background-color: #64b5f6; 
+    }
+"""
+
+# Run button style
+RUN_BUTTON_STYLE = """
+    QPushButton {
+        font-size: 16px;
+        background-color: #ffcc80;
+        border: 2px solid #8c8c8c;
+        border-radius: 10px;
+        padding: 5px;
+        height: 100px;
+    }
+    QPushButton:hover {
+        background-color: #ffb74d;
+    }
+"""
+
+# Group box style
+GROUP_BOX_STYLE = """
+    QGroupBox {
+        border: 1px solid black;
+        border-radius: 5px;
+        margin-top: 10px;
+        font-size: 20px;
+        font-weight: bold;
+    }
+    QGroupBox::title {
+        font-size: 14px; 
+        font-weight: bold;
+        subcontrol-origin: margin;
+        subcontrol-position: top center;
+    }
+"""
+
+# Wafer button styles
+WAFER_BUTTON_DEFAULT_STYLE = """
+    QRadioButton {
+        spacing: 0px;
+        font-size: 16px;
+    }
+    QRadioButton::indicator {
+        width: 25px;
+        height: 25px;
+    }
+    QRadioButton::indicator:checked {
+        background-color: #ccffcc;
+        border: 2px solid black;
+    }
+    QRadioButton::indicator:unchecked {
+        background-color: white;
+        border: 2px solid #ccc;
+    }
+"""
+
+WAFER_BUTTON_EXISTING_STYLE = """
+    QRadioButton {
+        spacing: 0px;
+        font-size: 16px;
+    }
+    QRadioButton::indicator {
+        width: 25px;
+        height: 25px;
+        border: 2px solid #ccc;
+        background-color: lightblue;
+    }
+    QRadioButton::indicator:checked {
+        background-color: #ccffcc;
+        border: 2px solid black;
+    }
+    QRadioButton::indicator:unchecked {
+        background-color: lightblue;
+        border: 2px solid #ccc;
+    }
+"""
+
+WAFER_BUTTON_MISSING_STYLE = """
+    QRadioButton {
+        spacing: 0px;
+        font-size: 16px;
+    }
+    QRadioButton::indicator {
+        width: 25px;
+        height: 25px;
+        border: 2px solid #ccc;
+        background-color: lightcoral;
+    }
+    QRadioButton::indicator:checked {
+        background-color: #ccffcc;
+        border: 2px solid black;
+    }
+    QRadioButton::indicator:unchecked {
+        background-color: lightcoral;
+        border: 2px solid #ccc;
+    }
+"""
+
+# Style for folder/file selection buttons
+SELECT_BUTTON_STYLE = """
+    QPushButton {
+        font-size: 16px;
+        background-color: #b3e5fc; 
+        border: 2px solid #8c8c8c;
+        border-radius: 10px; 
+        padding: 10px;
+    }
+    QPushButton:hover {
+        background-color: #64b5f6; 
+    }
+"""
+
+# Style for path labels
+PATH_LABEL_STYLE = """
+    QLabel {
+        font-size: 14px;
+        padding: 5px;
+    }
+""" 

semapp/Layout/toast.py

@@ -0,0 +1,157 @@
+"""
+Toast notification widget for non-intrusive user feedback.
+"""
+
+from PyQt5.QtWidgets import QWidget, QLabel, QVBoxLayout
+from PyQt5.QtCore import Qt, QTimer, QPropertyAnimation, QEasingCurve, QPoint
+from PyQt5.QtGui import QFont
+
+
+class ToastNotification(QWidget):
+    """
+    A toast notification widget that appears temporarily to show messages.
+    Non-intrusive and auto-dismisses after a set duration.
+    """
+    
+    def __init__(self, message, parent=None, duration=3000, notification_type="info"):
+        """
+        Initialize the toast notification.
+        
+        Args:
+            message: Text message to display
+            parent: Parent widget
+            duration: Duration in milliseconds before auto-dismiss
+            notification_type: Type of notification ("info", "success", "warning", "error")
+        """
+        super().__init__(parent)
+        
+        self.duration = duration
+        self.notification_type = notification_type
+        
+        # Set window flags for frameless, always on top, tooltip behavior
+        self.setWindowFlags(
+            Qt.ToolTip | 
+            Qt.FramelessWindowHint | 
+            Qt.WindowStaysOnTopHint
+        )
+        
+        # Set up styles based on notification type
+        self._setup_style()
+        
+        # Create layout and label
+        layout = QVBoxLayout()
+        layout.setContentsMargins(15, 10, 15, 10)
+        
+        label = QLabel(message)
+        label.setWordWrap(True)
+        font = QFont()
+        font.setPointSize(10)
+        label.setFont(font)
+        label.setAlignment(Qt.AlignCenter)
+        
+        layout.addWidget(label)
+        self.setLayout(layout)
+        
+        # Adjust size to content
+        self.adjustSize()
+        
+    def _setup_style(self):
+        """Set up the style based on notification type."""
+        colors = {
+            "info": {
+                "bg": "#2196F3",
+                "border": "#1976D2"
+            },
+            "success": {
+                "bg": "#4CAF50",
+                "border": "#388E3C"
+            },
+            "warning": {
+                "bg": "#FF9800",
+                "border": "#F57C00"
+            },
+            "error": {
+                "bg": "#F44336",
+                "border": "#D32F2F"
+            }
+        }
+        
+        color = colors.get(self.notification_type, colors["info"])
+        
+        self.setStyleSheet(f"""
+            QWidget {{
+                background-color: {color['bg']};
+                color: white;
+                border: 2px solid {color['border']};
+                border-radius: 8px;
+                padding: 5px;
+            }}
+            QLabel {{
+                background-color: transparent;
+                color: white;
+                border: none;
+            }}
+        """)
+    
+    def show_toast(self):
+        """
+        Show the toast notification with fade-in animation.
+        Auto-dismisses after the specified duration.
+        """
+        if self.parent():
+            # Position relative to parent
+            parent_rect = self.parent().geometry()
+            x = parent_rect.right() - self.width() - 20
+            y = parent_rect.top() + 20
+            self.move(x, y)
+        else:
+            # Center on screen if no parent
+            from PyQt5.QtGui import QGuiApplication
+            screen = QGuiApplication.primaryScreen().geometry()
+            x = (screen.width() - self.width()) // 2
+            y = screen.height() - self.height() - 50
+            self.move(x, y)
+        
+        # Set initial opacity for fade-in
+        self.setWindowOpacity(0.0)
+        self.show()
+        
+        # Fade-in animation
+        fade_in = QPropertyAnimation(self, b"windowOpacity")
+        fade_in.setDuration(300)
+        fade_in.setStartValue(0.0)
+        fade_in.setEndValue(1.0)
+        fade_in.setEasingCurve(QEasingCurve.InOutQuad)
+        fade_in.start()
+        
+        # Auto-dismiss after duration
+        QTimer.singleShot(self.duration, self._dismiss)
+    
+    def _dismiss(self):
+        """Dismiss the toast with fade-out animation."""
+        fade_out = QPropertyAnimation(self, b"windowOpacity")
+        fade_out.setDuration(300)
+        fade_out.setStartValue(1.0)
+        fade_out.setEndValue(0.0)
+        fade_out.setEasingCurve(QEasingCurve.InOutQuad)
+        fade_out.finished.connect(self.close)
+        fade_out.start()
+
+
+def show_toast(parent, message, duration=3000, notification_type="info"):
+    """
+    Convenience function to show a toast notification.
+    
+    Args:
+        parent: Parent widget
+        message: Message to display
+        duration: Duration in milliseconds
+        notification_type: Type of notification
+    
+    Returns:
+        ToastNotification: The created toast widget
+    """
+    toast = ToastNotification(message, parent, duration, notification_type)
+    toast.show_toast()
+    return toast
+

semapp/Plot/__init__.py

@@ -0,0 +1,8 @@
+"""
+Plot package initialization.
+Contains plotting and visualization functionality for SEM data.
+"""
+
+from .utils import *
+
+__all__ = []