sgtlib 3.3.9__py3-none-any.whl

StructuralGT/apps/gui_mcw/image_provider.py

@@ -0,0 +1,74 @@
+from PIL import Image, ImageQt  # Import ImageQt for conversion
+from PySide6.QtGui import QPixmap
+from PySide6.QtQuick import QQuickImageProvider
+
+
+class ImageProvider(QQuickImageProvider):
+
+    def __init__(self, img_controller):
+        super().__init__(QQuickImageProvider.ImageType.Pixmap)
+        self.pixmap = QPixmap()
+        self.img_controller = img_controller
+        self.img_controller.changeImageSignal.connect(self.handle_change_image)
+
+    def handle_change_image(self):
+        if len(self.img_controller.sgt_objs) > 0:
+            img_cv = None
+            sgt_obj = self.img_controller.get_selected_sgt_obj()
+            ntwk_p = sgt_obj.ntwk_p
+            sel_img_batch = ntwk_p.get_selected_batch()
+            if sel_img_batch.current_view == "binary":
+                ntwk_p.apply_img_filters(filter_type=2)
+                bin_images = [obj.img_bin for obj in sel_img_batch.images]
+                if self.img_controller.is_img_3d():
+                    self.img_controller.img3dGridModel.reset_data(bin_images, sel_img_batch.selected_images)
+                else:
+                    # 2D, Do not use if 3D
+                    img_cv = bin_images[0]
+            elif sel_img_batch.current_view  == "processed":
+                ntwk_p.apply_img_filters(filter_type=1)
+                mod_images = [obj.img_mod for obj in sel_img_batch.images]
+                if self.img_controller.is_img_3d():
+                    self.img_controller.img3dGridModel.reset_data(mod_images, sel_img_batch.selected_images)
+                else:
+                    # 2D, Do not use if 3D
+                    img_cv = mod_images[0]
+            elif sel_img_batch.current_view  == "graph":
+                # If any is None, start the task
+                if sel_img_batch.graph_obj.img_ntwk is None:
+                    self.img_controller.run_extract_graph()
+                    # Wait for the task to finish
+                    return
+                else:
+                    net_images = [sel_img_batch.graph_obj.img_ntwk]
+                    self.img_controller.img3dGridModel.reset_data(net_images, sel_img_batch.selected_images)
+                    img_cv = net_images[0]
+            else:
+                # Original
+                images = [obj.img_2d for obj in sel_img_batch.images]
+                if self.img_controller.is_img_3d():
+                    self.img_controller.img3dGridModel.reset_data(images, sel_img_batch.selected_images)
+                else:
+                    # 2D, Do not use if 3D
+                    img_cv = images[0]
+
+            if img_cv is not None:
+                # Create Pixmap image
+                img = Image.fromarray(img_cv)
+                self.pixmap = ImageQt.toqpixmap(img)
+
+            # Reset graph/image configs with selected values - reloads QML
+            self.img_controller.update_graph_models(sgt_obj)
+
+            # Save changes to the project data file
+            if len(self.img_controller.sgt_objs.items()) <= 10:
+                self.img_controller.save_project_data()
+
+            # Acknowledge the image load and send the signal to update QML
+            self.img_controller.img_loaded = True
+            self.img_controller.imageChangedSignal.emit()
+        else:
+            self.img_controller.img_loaded = False
+
+    def requestPixmap(self, img_id, requested_size, size):
+        return self.pixmap

StructuralGT/apps/gui_mcw/imagegrid_model.py

@@ -0,0 +1,75 @@
+from PySide6.QtCore import Qt, QAbstractListModel
+from ...utils.sgt_utils import img_to_base64
+
+
+class ImageGridModel(QAbstractListModel):
+    IdRole = Qt.ItemDataRole.UserRole + 1
+    SelectedRole = Qt.ItemDataRole.UserRole + 20
+    ImageRole = Qt.ItemDataRole.UserRole + 21
+
+    def __init__(self, img_lst: list, selected_images: set, parent=None):
+        super().__init__(parent)
+        if len(img_lst) == 0:
+            self._image_data = []
+            return
+        self._image_data = [{
+            "id": i,
+            "image": img_to_base64(img_lst[i]) if img_lst[i] is not None else "",
+            "selected": 1 if i in selected_images else 0
+        } for i in range(len(img_lst))]
+
+    def rowCount(self, parent=None):
+        return len(self._image_data)
+
+    def data(self, index, role=Qt.ItemDataRole.DisplayRole):
+        if not index.isValid() or index.row() >= len(self._image_data):
+            return None
+
+        item = self._image_data[index.row()]
+        if item["image"] is None:
+            return None
+
+        if role == self.IdRole:
+            return item["id"]
+        elif role == self.ImageRole:
+            return item["image"]
+        elif role == self.SelectedRole:
+            return item["selected"]
+        return ""
+
+    def setData(self, index, value, role=Qt.ItemDataRole.DisplayRole):
+        if not index.isValid() or index.row() >= len(self._image_data):
+            return False
+
+        if role == self.SelectedRole:
+            self._image_data[index.row()]["selected"] = value
+            self.dataChanged.emit(index, index, [role])
+            return True
+        if role == self.ImageRole:
+            self._image_data[index.row()]["image"] = value
+            self.dataChanged.emit(index, index, [role])
+            return True
+        return False
+
+    def reset_data(self, new_data: list, selected_images: set):
+        """ Resets the data to be displayed. """
+        if new_data is None:
+            return
+        self.beginResetModel()
+
+        self._image_data = [{
+            "id": i,
+            "image": img_to_base64(new_data[i]) if new_data[i] is not None else "",
+            "selected": 1 if i in selected_images else 0
+        } for i in range(len(new_data))]
+
+        self.endResetModel()
+        self.dataChanged.emit(self.index(0, 0), self.index(len(new_data), 0),
+                              [self.IdRole, self.ImageRole, self.SelectedRole])
+
+    def roleNames(self):
+        return {
+            self.IdRole: b"id",
+            self.ImageRole: b"image",
+            self.SelectedRole: b"selected",
+        }

StructuralGT/apps/gui_mcw/qthread_worker.py

@@ -0,0 +1,102 @@
+import logging
+from PySide6.QtCore import QObject, QThread, Signal
+from ...compute.graph_analyzer import GraphAnalyzer
+from ...utils.sgt_utils import AbortException
+
+
+
+class QThreadWorker(QThread):
+    def __init__(self, func, args, parent=None):
+        super().__init__(parent)
+        self.func = func  # Store function reference
+        self.args = args  # Store arguments
+
+    def run(self):
+        if self.func:
+            self.func(*self.args)  # Call function with arguments
+
+
+class WorkerTask (QObject):
+
+    inProgressSignal = Signal(int, str)         # progress-value (0-100), progress-message (str)
+    taskFinishedSignal = Signal(bool, object)    # success/fail (True/False), result (object)
+
+    def __init__(self):
+        super().__init__()
+
+    def update_progress(self, value, msg):
+        """
+        Send the update_progress signal to all listeners.
+        Progress-value (0-100), progress-message (str)
+        Args:
+            value: progress value (0-100), (-1, if it is an error), (101, if it is the nav-control message)
+            msg: progress message (str)
+
+        Returns:
+
+        """
+        self.inProgressSignal.emit(value, msg)
+
+    def task_apply_img_filters(self, ntwk_p):
+        """"""
+        try:
+            ntwk_p.add_listener(self.update_progress)
+            ntwk_p.apply_img_filters()
+            ntwk_p.remove_listener(self.update_progress)
+            self.taskFinishedSignal.emit(True, ntwk_p)
+        except Exception as err:
+            logging.exception("Error: %s", err, extra={'user': 'SGT Logs'})
+            # self.abort = True
+            self.update_progress(-1, "Error encountered! Try again")
+            # Emit failure signal (aborted)
+            self.taskFinishedSignal.emit(False, ["Apply Filters Failed", "Fatal error while applying filters! "
+                                                                         "Change filter settings and try again; "
+                                                                         "Or, Close the app and try again."])
+
+    def task_extract_graph(self, ntwk_p):
+        """"""
+        try:
+            ntwk_p.abort = False
+            ntwk_p.add_listener(self.update_progress)
+            ntwk_p.apply_img_filters()
+            ntwk_p.build_graph_network()
+            if ntwk_p.abort:
+                raise AbortException("Process aborted")
+            ntwk_p.remove_listener(self.update_progress)
+            self.taskFinishedSignal.emit(True, ntwk_p)
+        except AbortException as err:
+            logging.exception("Task Aborted: %s", err, extra={'user': 'SGT Logs'})
+            # Clean up listeners before exiting
+            ntwk_p.remove_listener(self.update_progress)
+            # Emit failure signal (aborted)
+            self.taskFinishedSignal.emit(False, ["Extract Graph Aborted", "Graph extraction aborted due to error! "
+                                                                          "Change image filters and/or graph settings "
+                                                                          "and try again. If error persists then close "
+                                                                          "the app and try again."])
+        except Exception as err:
+            logging.exception("Error: %s", err, extra={'user': 'SGT Logs'})
+            self.update_progress(-1, "Error encountered! Try again")
+            # Clean up listeners before exiting
+            ntwk_p.remove_listener(self.update_progress)
+            # Emit failure signal (aborted)
+            self.taskFinishedSignal.emit(False, ["Extract Graph Failed", "Graph extraction aborted due to error! "
+                                                                          "Change image filters and/or graph settings "
+                                                                          "and try again. If error persists then close "
+                                                                          "the app and try again."])
+
+    def task_compute_gt(self, sgt_obj):
+        """"""
+        success, new_sgt = GraphAnalyzer.safe_run_analyzer(sgt_obj, self.update_progress)
+        if success:
+            self.taskFinishedSignal.emit(False, new_sgt)
+        else:
+            self.taskFinishedSignal.emit(False, ["SGT Computations Failed", "Fatal error occurred while computing GT parameters. Change image filters and/or graph settings and try again. If error persists then close the app and try again."])
+
+    def task_compute_multi_gt(self, sgt_objs):
+        """"""
+        new_sgt_objs = GraphAnalyzer.safe_run_multi_analyzer(sgt_objs, self.update_progress)
+        if new_sgt_objs is not None:
+            self.taskFinishedSignal.emit(True, sgt_objs)
+        else:
+            msg = "Either task was aborted by user or a fatal error occurred while computing GT parameters. Change image filters and/or graph settings and try again. If error persists then close the app and try again."
+            self.taskFinishedSignal.emit(False, ["SGT Computations Aborted/Failed", msg])

StructuralGT/apps/gui_mcw/table_model.py

@@ -0,0 +1,79 @@
+from PySide6.QtCore import QAbstractTableModel, QModelIndex, Qt
+
+
+
+# Define a simple table model
+class TableModel(QAbstractTableModel):
+    SelectedRole = Qt.ItemDataRole.UserRole + 20
+
+    def __init__(self, data, parent=None):
+        super().__init__(parent)
+        self.itemData = data
+        self.imageCache = {}
+        self.selected_index = -1  # To track the selected row
+
+    def rowCount(self, parent=QModelIndex()):
+        return len(self.itemData) if self.itemData else 0
+
+    def columnCount(self, parent=QModelIndex()):
+        return len(self.itemData[0]) if self.itemData else 0
+
+    def data(self, index, role=Qt.ItemDataRole.DisplayRole):
+        if not index.isValid() or not (0 <= index.row() < self.rowCount()):
+            return None
+        if role == Qt.ItemDataRole.DisplayRole:
+            return self.itemData[index.row()][index.column()]
+        elif role == Qt.ItemDataRole.DecorationRole:
+            if len(self.imageCache) <= 0:
+                return None
+            image_name = self.itemData[index.row()][index.column()]
+            return self.imageCache[image_name]
+        elif role == self.SelectedRole:
+            return index.row() == self.selected_index  # True if selected
+        return None
+
+    def set_selected(self, row):
+        if 0 <= row < len(self.itemData):
+            old_index = self.selected_index
+            self.selected_index = row
+            if old_index != -1:
+                self.dataChanged.emit(self.index(old_index, 0), self.index(old_index, 0), [self.SelectedRole])
+            self.dataChanged.emit(self.index(row, 0), self.index(row, 0), [self.SelectedRole])
+
+    def reset_data(self, item_data):
+        self.beginResetModel()
+        self.imageCache = {}
+        self.itemData = item_data
+        self.endResetModel()
+        self.dataChanged.emit(self.index(0, 0), self.index(len(self.itemData) - 1, 0))
+
+    def update_data(self, img_list, img_cache):
+        """Updates model with new images from analyze_objs"""
+        self.beginResetModel()
+        if img_list is None or img_cache is None:
+            # No data to add/update
+            self.itemData = []
+            self.imageCache = {}
+            self.endResetModel()
+            # Emit dataChanged signal to notify QML
+            self.dataChanged.emit(self.index(0, 0), self.index(len(self.itemData) - 1, 0))
+            return
+
+        start_row = len(self.itemData)
+        self.itemData = img_list
+        self.imageCache = img_cache
+        self.endResetModel()
+        # Emit dataChanged signal to notify QML
+        self.dataChanged.emit(self.index(start_row, 0), self.index(len(self.itemData) - 1, 0))
+
+    def roleNames(self):
+        return {
+            Qt.ItemDataRole.DisplayRole: b"text",
+            Qt.ItemDataRole.DecorationRole: b"thumbnail",
+            self.SelectedRole: b"selected",
+        }
+
+    def headerData(self, section, orientation, role=Qt.ItemDataRole.DisplayRole):
+         if role == Qt.ItemDataRole.DisplayRole and orientation == Qt.Orientation.Horizontal:
+            return f"Column {section + 1}"
+         return super().headerData(section, orientation, role)

StructuralGT/apps/gui_mcw/tree_model.py

@@ -0,0 +1,154 @@
+from PySide6.QtCore import Qt, QAbstractItemModel, QModelIndex
+
+
+class TreeItem:
+    """ Represents a single item in the tree. """
+    def __init__(self, data, parent=None):
+        self._data = data  # Dictionary of data (id, text, value)
+        self._parent = parent
+        self.children = []
+
+    def append_child(self, child):
+        """ Adds a child node to this item. """
+        self.children.append(child)
+
+    def child(self, row):
+        """ Returns the child at the specified row. """
+        return self.children[row] if row < len(self.children) else None
+
+    def child_count(self):
+        """ Returns the number of children. """
+        return len(self.children)
+
+    def column_count(self):
+        """ Returns the number of columns (3: id, text, value). """
+        return len(self._data)
+
+    def data(self, column):
+        """ Returns the data for a specific column. """
+        if column == 0:
+            return self._data.get("id", "")
+        elif column == 1:
+            return self._data.get("text", "")
+        elif column == 2:
+            return self._data.get("value", 0)
+        return None
+
+    def set_data(self, column, value):
+        """ Sets the data for a specific column. """
+        if column == 0:
+            self._data["id"] = value
+        elif column == 1:
+            self._data["text"] = value
+        elif column == 2:
+            self._data["value"] = value
+        return True
+
+    def parent(self):
+        """ Returns the parent of this item. """
+        return self._parent
+
+    def row(self):
+        """ Returns this item's index in its parent's children list. """
+        if self._parent:
+            return self._parent.children.index(self)
+        return 0
+
+
+class TreeModel(QAbstractItemModel):
+    """ QAbstractItemModel for displaying hierarchical data in QML. """
+    # Qt.UserRole
+    IdRole = Qt.ItemDataRole.UserRole + 1
+    TextRole = Qt.ItemDataRole.UserRole + 2
+    ValueRole = Qt.ItemDataRole.UserRole + 3
+
+    def __init__(self, data, parent=None):
+        super().__init__(parent)
+        self._rootItem = TreeItem({"id": "root", "text": "Root", "value": None})
+        self.setup_model_data(data, self._rootItem)
+        # self.
+
+    def setup_model_data(self, data_list, parent):
+        """ Populates the model with data from a list of dictionaries. """
+        for item_data in data_list:
+            item = TreeItem(item_data, parent)
+            parent.append_child(item)
+            if 'items' in item_data:
+                self.setup_model_data(item_data['items'], item)
+
+    def rowCount(self, parent=QModelIndex()):
+        """ Returns the children count of the given parent. """
+        if not parent.isValid():
+            return self._rootItem.child_count()
+        return parent.internalPointer().child_count()
+
+    def columnCount(self, parent=QModelIndex()):
+        """ Returns the number of columns (fixed at 3). """
+        return 1
+
+    def data(self, index, role=Qt.ItemDataRole.DisplayRole):
+        """ Returns the data to be displayed. """
+        if not index.isValid():
+            return None
+        item = index.internalPointer()
+        # if role == Qt.DisplayRole:
+        #    return item.data(index.column())
+        if role == self.IdRole:
+            return item.data(0)  # id
+        elif role == self.TextRole:
+            return item.data(1)  # text
+        elif role == self.ValueRole:
+            return item.data(2)  # value
+        return None
+
+    def setData(self, index, value, role=Qt.ItemDataRole.EditRole):
+        if not index.isValid():
+            return False
+        item = index.internalPointer()
+        col = 2  # for valueRole
+        if item.set_data(col, value):
+            self.dataChanged.emit(index, index, [role])
+            return True
+        return False
+
+    def reset_data(self, new_data):
+        """ Resets the data to be displayed. """
+        self.beginResetModel()
+        self._rootItem = TreeItem({"id": "root", "text": "Root", "value": None})
+        self.setup_model_data(new_data, self._rootItem)
+        self.endResetModel()
+        self.dataChanged.emit(self.index(0,0), self.index(len(new_data), 0),
+                              [self.IdRole, self.TextRole, self.ValueRole])
+
+    def parent(self, index=QModelIndex()):
+        """ Returns the parent index of a given child index. """
+        if not index.isValid():
+            return QModelIndex()
+
+        item = index.internalPointer()
+        parent_item = item.parent()
+
+        if parent_item == self._rootItem:
+            return QModelIndex()
+
+        return self.createIndex(parent_item.row(), 0, parent_item)
+
+    def index(self, row, column, parent=QModelIndex()):
+        """ Returns the index of a given row and column. """
+        if not self.hasIndex(row, column, parent):
+            return QModelIndex()
+
+        parent_item = self._rootItem if not parent.isValid() else parent.internalPointer()
+        child_item = parent_item.child(row)
+
+        if child_item:
+            return self.createIndex(row, column, child_item)
+
+        return QModelIndex()
+
+    def roleNames(self):
+        return {
+            self.IdRole: b"id",
+            self.TextRole: b"text",
+            self.ValueRole: b"value",
+        }

StructuralGT/apps/sgt_qml/CenterMainContent.qml

@@ -0,0 +1,19 @@
+import QtQuick
+import QtQuick.Controls
+import QtQuick.Layouts
+import "widgets"
+
+Rectangle {
+    width: parent.width
+    height: parent.height
+    color: "#f0f0f0"
+
+    GridLayout {
+        anchors.fill: parent
+        columns: 1
+
+        ImageViewWidget{}
+
+    }
+
+}

StructuralGT/apps/sgt_qml/LeftContent.qml

@@ -0,0 +1,48 @@
+import QtQuick
+import QtQuick.Controls
+import QtQuick.Layouts
+import "components"
+
+Rectangle {
+    width: 300
+    height: parent.height
+    color: "#f0f0f0"
+    border.color: "#c0c0c0"
+
+    ColumnLayout {
+        anchors.fill: parent
+
+        TabBar {
+            id: tabBar
+            currentIndex: 2
+            Layout.fillWidth: true
+            TabButton { text: "Project" }
+            TabButton { text: "Properties" }
+            TabButton { text: "Filters" }
+        }
+
+        StackLayout {
+            id: stackLayout
+            //width: parent.width
+            Layout.fillWidth: true
+            currentIndex: tabBar.currentIndex
+
+
+            ProjectNav{}
+
+            ImageProperties{}
+
+            ImageFilters{}
+
+
+        }
+    }
+
+    Connections {
+        target: mainController
+
+        function onProjectOpenedSignal(name) {
+            tabBar.currentIndex = 0;
+        }
+    }
+}