batoolset-gui 0.2.0__py3-none-any.whl

batoolset/figure/user_selection.py

@@ -0,0 +1,287 @@
+# below is the java code of my selection --> I should inspire myself from it
+# see the best way todo that
+# or maybe allow to handle only elements of a given scope --> in a way that simplifies a lot the things !!! --> think about it
+# if scope is images --> only offer images options, if scope is panel --> offer panel options
+# if scope is Figure --> only offer figure options
+
+
+# package GUIs;
+#
+# import MyShapes.Figure;
+# import MyShapes.Montage;
+# import MyShapes.MyImage2D;
+# import MyShapes.PARoi;
+# import MyShapes.Row;
+# import MyShapes.MyTextRow;
+# import java.awt.geom.Point2D;
+# import java.util.ArrayList;
+#
+# /**
+#  * This class deals with selections
+#  *
+#  * @author benoit aigouy
+#  */
+# public class OptimalSelection {
+#
+#     public static Object getSelectionAt(ArrayList<Object> ROIs, boolean goDeeper, Point2D.Double mouseClick, Object objectsAlreadySelected) {
+#         Object sel = null;
+#         if (ROIs == null || ROIs.isEmpty()) {
+#             return null;
+#         }
+#         int size = ROIs.size();
+#         /* we loop in reverse order */
+#         loop1:
+#         for (int i = size - 1; i >= 0; i--) {
+#             Object object = ROIs.get(i);
+#             if (object == null) {
+#                 continue;
+#             }
+#             if (objectsAlreadySelected instanceof MyImage2D) {
+#                 /* we are at the lowest level --> we go up again */
+#                 if ((object instanceof Figure) || (object instanceof Row) || (object instanceof Montage)) {
+#                     if (object instanceof PARoi) {
+#                         if (((PARoi) object).contains(mouseClick)) {
+#                             return object;
+#                         }
+#                     }
+#                 }
+#             }
+#             /* go deeper --> if selected object is a figure --> return the row under the mouse */
+#             if (objectsAlreadySelected instanceof Figure) {
+#                 Row montageContainingClick = ((Figure) objectsAlreadySelected).getRowAtPosition(mouseClick);
+#                 if (montageContainingClick instanceof Row) {
+#                     return montageContainingClick;
+#                 }
+#             }
+#             /* go deeper --> if selected object is a row --> return the montage under the mouse */
+#             if (objectsAlreadySelected instanceof Row) {
+#                 Montage montageContainingClick = ((Row) objectsAlreadySelected).getMontageAtPosition(mouseClick);
+#                 if (montageContainingClick instanceof Montage) {
+#                     return montageContainingClick;
+#                 }
+#             }
+#             /* go deeper --> if selected object is a Montage --> return the image2D under the mouse */
+#             if (objectsAlreadySelected instanceof Montage) {
+#                 MyImage2D montageContainingClick = ((Montage) objectsAlreadySelected).getMyImage2DAtPosition(mouseClick);
+#                 if (montageContainingClick instanceof MyImage2D) {
+#                     return montageContainingClick;
+#                 }
+#             }
+#             if (object instanceof PARoi) {
+#                 if (((PARoi) object).contains(mouseClick)) {
+#                     return object;
+#                 }
+#             }
+#         }
+#         return sel;
+#     }
+#
+#     /**
+#      * adds to the current selection the newly selected object
+#      *
+#      * @param ROIs
+#      * @param breakOnFirstEncounter
+#      * @param onlyAllowSameInstanceAsSelection
+#      * @param mouseClick
+#      * @param objectsAlreadySelected
+#      * @return
+#      */
+#     public static Object addToSelection(ArrayList<Object> ROIs, boolean breakOnFirstEncounter, boolean onlyAllowSameInstanceAsSelection, Point2D.Double mouseClick, Object objectsAlreadySelected) {
+#         Object newSel = getSelection(ROIs, breakOnFirstEncounter, onlyAllowSameInstanceAsSelection, mouseClick, objectsAlreadySelected);
+# //        System.out.println("potentially newly selected object " + newSel + " " + objectsAlreadySelected);
+#         /* if there is no cur sel return new sel as cur sel */
+#         if (objectsAlreadySelected == null) {
+#             return newSel;
+#         }
+#         if (newSel == null) {
+#             return objectsAlreadySelected;
+#         }
+#         /* if sel is already a list of selected objects add the new sel to the list and return it */
+#         if (objectsAlreadySelected instanceof ArrayList) {
+#             ArrayList<Object> sel = ((ArrayList<Object>) objectsAlreadySelected);
+#             if (!sel.contains(newSel)) {
+#                 sel.add(newSel);
+#             }
+#             return sel;
+#         } else {
+#             /* there is already a selected object but we create a list and add all objects to it */
+#             ArrayList<Object> sel = new ArrayList<Object>();
+#             sel.add(objectsAlreadySelected);
+#             if (newSel != objectsAlreadySelected) {
+#                 sel.add(newSel);
+#             }
+#             return sel;
+#         }
+#     }
+#
+#     public static Object getSelection(ArrayList<Object> ROIs, boolean breakOnFirstEncounter, boolean onlyAllowSameInstanceAsSelection, Point2D.Double mouseClick, Object objectsAlreadySelected) {
+#         if (ROIs == null || ROIs.isEmpty()) {
+#             return null;
+#         }
+#         int size = ROIs.size();
+#         ArrayList<Object> foundObjects = new ArrayList<Object>();
+#         /* we loop in reverse order */
+#         loop1:
+#         for (int i = size - 1; i >= 0; i--) {
+#             Object object = ROIs.get(i);
+#             /* we prevent the object from being selected twice */
+#             if (object == objectsAlreadySelected) {
+#                 continue;
+#             }
+#             if (objectsAlreadySelected != null && (objectsAlreadySelected instanceof ArrayList)) {
+#                 /* prevent from selecting the same object again */
+#                 ArrayList<Object> curObjects = ((ArrayList<Object>) objectsAlreadySelected);
+#                 for (Object foundObject : curObjects) {
+#                     if (object == foundObject) {
+#                         continue loop1;
+#                     }
+#                 }
+#             }
+#             if (object instanceof PARoi) {
+#                 if (((PARoi) object).contains(mouseClick)) {
+#                     if (objectsAlreadySelected == null) {
+#                         return object;
+#                     }
+#                     if (onlyAllowSameInstanceAsSelection) {
+#                         /* if they are of the same instance take it directly otherwise look inside */
+#  /* here we just get objects of the same type */
+#                         if ((object instanceof Figure) && ((objectsAlreadySelected instanceof Figure) || ((objectsAlreadySelected instanceof ArrayList) && ((ArrayList<Object>) objectsAlreadySelected).get(0) instanceof Figure))) {
+#                             if (breakOnFirstEncounter) {
+#                                 return object;
+#                             } else {
+#                                 foundObjects.add(object);
+#                             }
+#                         }
+#                         /* prevent MyTextRow to be selected with Rows even if they are Rows */
+#                         if (((object instanceof MyTextRow)) && (((objectsAlreadySelected instanceof MyTextRow)) || ((objectsAlreadySelected instanceof ArrayList) && (((ArrayList<Object>) objectsAlreadySelected).get(0) instanceof MyTextRow)))) {
+#                             if (breakOnFirstEncounter) {
+#                                 return object;
+#                             } else {
+#                                 foundObjects.add(object);
+#                             }
+#                         } else if (((object instanceof Row) && !(object instanceof MyTextRow)) && (((objectsAlreadySelected instanceof Row) && !(objectsAlreadySelected instanceof MyTextRow)) || ((objectsAlreadySelected instanceof ArrayList) && (((ArrayList<Object>) objectsAlreadySelected).get(0) instanceof Row) && !(((ArrayList<Object>) objectsAlreadySelected).get(0) instanceof MyTextRow)))) {
+#                             if (breakOnFirstEncounter) {
+#                                 return object;
+#                             } else {
+#                                 foundObjects.add(object);
+#                             }
+#                         }
+#                         if ((object instanceof Montage) && ((objectsAlreadySelected instanceof Montage) || ((objectsAlreadySelected instanceof ArrayList) && ((ArrayList<Object>) objectsAlreadySelected).get(0) instanceof Montage))) {
+#                             if (breakOnFirstEncounter) {
+#                                 return object;
+#                             } else {
+#                                 foundObjects.add(object);
+#                             }
+#                         }
+#                         if ((object instanceof MyImage2D) && ((objectsAlreadySelected instanceof MyImage2D) || ((objectsAlreadySelected instanceof ArrayList) && ((ArrayList<Object>) objectsAlreadySelected).get(0) instanceof MyImage2D))) {
+#                             if (breakOnFirstEncounter) {
+#                                 return object;
+#                             } else {
+#                                 foundObjects.add(object);
+#                             }
+#                         }
+#                         if ((object instanceof Figure) && ((objectsAlreadySelected instanceof MyTextRow) || ((objectsAlreadySelected instanceof ArrayList) && ((ArrayList<Object>) objectsAlreadySelected).get(0) instanceof MyTextRow))) {
+#                             Object innerSelectedObject = ((Figure) object).getRowAtPosition(mouseClick);
+#                             if (innerSelectedObject instanceof MyTextRow) {
+#                                 if (breakOnFirstEncounter) {
+#                                     return innerSelectedObject;
+#                                 } else {
+#                                     foundObjects.add(innerSelectedObject);
+#                                 }
+#                             }
+#                         } else if ((object instanceof Figure) && (((objectsAlreadySelected instanceof Row) && !(objectsAlreadySelected instanceof MyTextRow)) || ((objectsAlreadySelected instanceof ArrayList) && ((ArrayList<Object>) objectsAlreadySelected).get(0) instanceof Row && !(((ArrayList<Object>) objectsAlreadySelected).get(0) instanceof MyTextRow)))) {
+#                             Object innerSelectedObject = ((Figure) object).getRowAtPosition(mouseClick);
+#                             if ((innerSelectedObject instanceof Row) && !(innerSelectedObject instanceof MyTextRow) ) {
+#                                 if (breakOnFirstEncounter) {
+#                                     return innerSelectedObject;
+#                                 } else {
+#                                     foundObjects.add(innerSelectedObject);
+#                                 }
+#                             }
+#                         }
+#                         /* if instance of objects differ then take the compatible one when grouping */
+#                         if ((object instanceof Figure) && ((objectsAlreadySelected instanceof Montage) || ((objectsAlreadySelected instanceof ArrayList) && ((ArrayList<Object>) objectsAlreadySelected).get(0) instanceof Montage))) {
+#                             Object innerSelectedObject = ((Figure) object).getRowAtPosition(mouseClick);
+#                             if (innerSelectedObject instanceof Row) {
+#                                 innerSelectedObject = ((Row) innerSelectedObject).getMontageAtPosition(mouseClick);
+#                             }
+#                             if (innerSelectedObject instanceof Montage) {
+#                                 if (breakOnFirstEncounter) {
+#                                     return innerSelectedObject;
+#                                 } else {
+#                                     foundObjects.add(innerSelectedObject);
+#                                 }
+#                             }
+#                         }
+#                         /* if instance of objects differ then take the compatible one when grouping */
+#                         if ((object instanceof Figure) && ((objectsAlreadySelected instanceof MyImage2D) || ((objectsAlreadySelected instanceof ArrayList) && ((ArrayList<Object>) objectsAlreadySelected).get(0) instanceof MyImage2D))) {
+#                             Object innerSelectedObject = ((Figure) object).getRowAtPosition(mouseClick);
+#                             if (innerSelectedObject instanceof Row) {
+#                                 innerSelectedObject = ((Row) innerSelectedObject).getMontageAtPosition(mouseClick);
+#                             }
+#                             if (innerSelectedObject instanceof Montage) {
+#                                 innerSelectedObject = ((Montage) innerSelectedObject).getMyImage2DAtPosition(mouseClick);
+#                             }
+#                             if (innerSelectedObject instanceof MyImage2D) {
+#                                 if (breakOnFirstEncounter) {
+#                                     return innerSelectedObject;
+#                                 } else {
+#                                     foundObjects.add(innerSelectedObject);
+#                                 }
+#                             }
+#                         }
+#                         /* if instance of objects differ then take the compatible one when grouping */
+#                         if ((object instanceof Row) && ((objectsAlreadySelected instanceof Montage) || ((objectsAlreadySelected instanceof ArrayList) && ((ArrayList<Object>) objectsAlreadySelected).get(0) instanceof Montage))) {
+#                             //get the montage at position
+#                             Object innerSelectedObject = ((Row) object).getMontageAtPosition(mouseClick);
+#                             if (innerSelectedObject instanceof Montage) {
+#                                 if (breakOnFirstEncounter) {
+#                                     return innerSelectedObject;
+#                                 } else {
+#                                     foundObjects.add(innerSelectedObject);
+#                                 }
+#                             }
+#                         }
+#                         /* if instance of objects differ then take the compatible one when grouping */
+#                         if ((object instanceof Row) && ((objectsAlreadySelected instanceof MyImage2D) || ((objectsAlreadySelected instanceof ArrayList) && ((ArrayList<Object>) objectsAlreadySelected).get(0) instanceof MyImage2D))) {
+#                             Object innerSelectedObject = ((Row) object).getMontageAtPosition(mouseClick);
+#                             if (innerSelectedObject instanceof Montage) {
+#                                 innerSelectedObject = ((Montage) innerSelectedObject).getMyImage2DAtPosition(mouseClick);
+#                             }
+#                             if (innerSelectedObject instanceof MyImage2D) {
+#                                 if (breakOnFirstEncounter) {
+#                                     return innerSelectedObject;
+#                                 } else {
+#                                     foundObjects.add(innerSelectedObject);
+#                                 }
+#                             }
+#                         }
+#                         /* if instance of objects differ then take the compatible one when grouping */
+#                         if ((object instanceof Montage) && ((objectsAlreadySelected instanceof MyImage2D) || ((objectsAlreadySelected instanceof ArrayList) && ((ArrayList<Object>) objectsAlreadySelected).get(0) instanceof MyImage2D))) {
+#                             //get the montage at position
+#                             Object innerSelectedObject = ((Montage) object).getMyImage2DAtPosition(mouseClick);
+#                             if (innerSelectedObject instanceof MyImage2D) {
+#                                 if (breakOnFirstEncounter) {
+#                                     return innerSelectedObject;
+#                                 } else {
+#                                     foundObjects.add(innerSelectedObject);
+#                                 }
+#                             }
+#                         }
+#                     } else {
+#                         return object;
+#                     }
+#                 }
+#             }
+#         }
+#         if (!foundObjects.isEmpty()) {
+#             return foundObjects;
+#         }
+#         return null;
+#     }
+#
+#     public static void main(String[] args) {
+#         System.exit(0);
+#     }
+#
+# }

batoolset/icons/tools.py

@@ -0,0 +1,248 @@
+# TODO maybe worth speeding this up especially calls to icons that are not used and or the full list of icons that can take time --> need think
+
+from batoolset.settings.global_settings import set_UI  # set the UI to qtpy
+
+set_UI()
+import qtawesome as qta
+from batoolset.strings.tools import levenshtein_distance
+from qtpy.QtGui import QColor
+
+import re
+
+STYLE_SUFFIXES = [
+    "outline", "outlined", "fill", "filled",
+    "bold", "thin", "light", "regular",
+    "circle", "square",
+]
+
+# Cache for available icons
+_available_icons_cache = None
+
+
+def normalize_icon_name(name):
+    """Normalize icon name to its semantic core."""
+    base = name.split('.')[-1].lower()
+
+    # remove common legacy markers
+    base = re.sub(r"-o$", "", base)
+    base = re.sub(r"-alt$", "", base)
+
+    # remove style suffixes
+    for suffix in STYLE_SUFFIXES:
+        base = re.sub(rf"-{suffix}$", "", base)
+
+    return base
+
+
+def get_closest_icon_name(target_name, available_icons):
+    """Find the closest matching icon using semantic matching and Levenshtein distance."""
+    target_norm = normalize_icon_name(target_name)
+    target_base = target_name.split('.')[-1] if '.' in target_name else target_name
+    target_base_norm = normalize_icon_name(target_base)
+
+    best_score = float('inf')
+    best_icon = None
+
+    # Split target into words for matching
+    target_words = set(target_norm.split('-')) if target_norm else set()
+
+    for icon in available_icons:
+        icon_norm = normalize_icon_name(icon)
+        icon_base = icon.split('.')[-1] if '.' in icon else icon
+        icon_base_norm = normalize_icon_name(icon_base)
+
+        # Strong semantic preference - normalized bases match exactly
+        if icon_base_norm == target_base_norm:
+            return icon  # Perfect match, return immediately
+        elif icon_norm == target_norm:
+            score = 0.5
+        elif icon_base == target_base:
+            score = 1
+        elif icon_norm.startswith(target_norm):
+            score = 2
+        elif target_norm in icon_norm:
+            score = 3
+        elif target_words and all(word in icon_norm for word in target_words if word):
+            score = 4
+        else:
+            # Only compute Levenshtein for icons with some similarity
+            # Skip if length difference is too large
+            len_diff = abs(len(target_base_norm) - len(icon_base_norm))
+            if len_diff > max(len(target_base_norm), len(icon_base_norm)) * 0.6:
+                continue
+
+            # Skip if no common characters at all
+            if target_base_norm and icon_base_norm:
+                common = set(target_base_norm) & set(icon_base_norm)
+                if len(common) < min(3, len(target_base_norm) * 0.3):
+                    continue
+
+            dist = levenshtein_distance(target_base_norm, icon_base_norm)
+
+            # Reject if distance is too large
+            max_dist = max(len(target_base_norm), len(icon_base_norm)) * 0.5
+            if dist > max_dist:
+                continue
+
+            score = 10 + dist
+
+        if score < best_score:
+            best_score = score
+            best_icon = icon
+
+    # If no good match found (score too high), return None to trigger help icon
+    if best_score > 15:  # Threshold for "no good match"
+        return None
+
+    return best_icon if best_icon else None
+
+
+def get_available_icons():
+    global _available_icons_cache
+
+    if _available_icons_cache is not None:
+        return _available_icons_cache
+
+    # Force initialization by creating a dummy icon
+    try:
+        qta.icon('fa5s.home')
+    except Exception:
+        pass
+
+    # Get the charmap which contains prefix -> {icon_name: code} mappings
+    charmap = qta._instance().charmap
+
+    icon_names = []
+
+    # Iterate through each font prefix (fa5s, mdi, etc.)
+    for prefix, icons_dict in charmap.items():
+        if isinstance(icons_dict, dict):
+            # Add all icon names with their prefix
+            for icon_name in icons_dict.keys():
+                icon_names.append(f"{prefix}.{icon_name}")
+
+    _available_icons_cache = sorted(icon_names)
+    return _available_icons_cache
+
+
+def get_icon(icon_name, color=None, color_disabled=None, **qta_kwargs):
+    """
+    Get an icon with fallback support for different icon sets.
+
+    Args:
+        icon_name (str): The name of the icon (e.g., 'fa.newspaper-o').
+        color (QColor or str or None): Icon color.
+        color_disabled (QColor or str or None): Disabled icon color.
+        **qta_kwargs: Any additional qtawesome options (options, scale_factor, offset, etc.)
+
+    Returns:
+        QIcon
+    """
+
+    def to_color_str(c):
+        if isinstance(c, QColor):
+            return c.name()
+        return c
+
+    color_str = to_color_str(color)
+    color_disabled_str = to_color_str(color_disabled)
+
+    def make_icon(name):
+        kwargs = dict(qta_kwargs)
+
+        if color_str is not None:
+            kwargs.setdefault("color", color_str)
+        if color_disabled_str is not None:
+            kwargs.setdefault("color_disabled", color_disabled_str)
+
+        return qta.icon(name, **kwargs)
+
+    # Try exact icon
+    try:
+        return make_icon(icon_name)
+    except Exception:
+        pass
+
+    # Try common icon family upgrades
+    if icon_name.startswith('fa.'):
+        base_name = icon_name[3:]
+        normalized_base = base_name.replace('-o', '').replace('-alt', '')
+
+        for prefix in ['fa5s.', 'fa5.', 'fa5b.', 'fa6s.', 'fa6.', 'fa6b.']:
+            try:
+                return make_icon(prefix + normalized_base)
+            except Exception:
+                pass
+
+    # Fuzzy fallback
+    available_icons = get_available_icons()
+    closest_icon = get_closest_icon_name(icon_name, available_icons)
+
+    if closest_icon is None:
+        return make_icon("mdi.help")
+
+    try:
+        return make_icon(closest_icon)
+    except Exception:
+        return make_icon("mdi.help")
+
+
+
+if __name__ == "__main__":
+    from qtpy.QtWidgets import QApplication
+    from qtpy.QtWidgets import QApplication, QWidget, QVBoxLayout, QLabel
+    import sys
+
+    # Create a QApplication instance
+    app = QApplication(sys.argv)
+
+    if False:
+        # Get all available icon names
+        # Get the QtAwesome instance and access its icon map
+        # Force initialization by creating a dummy icon first
+        try:
+            qta.icon('fa5s.home')
+        except:
+            pass
+
+        # Now try to get the icon names
+        icon_names = list(qta._instance().charmap.keys())
+        print(icon_names)
+        print(f"Total icons: {len(icon_names)}")
+        sys.exit(0)
+
+    # Icons to test (mix of valid, legacy, and invalid)
+    test_icons = [
+        "fa.newspaper-o",
+        "fa.save",
+        "fa.folder",
+        "fa.file-o",
+        "fa.plus",
+        "fa.times",
+        "fa.trash-o",
+        "fa.pencil",
+        "fa.cog",
+        "fa.search",
+        "fa.home",
+        "fa.this-does-not-exist",  # intentional failure
+        "ri.layout-row-line",  # intentional failure
+        'fa.folder-open-o',
+        'fa.check'
+    ]
+
+    window = QWidget()
+    window.setWindowTitle("qtawesome icon loading test")
+
+    layout = QVBoxLayout(window)
+
+    for icon_name in test_icons:
+        icon = get_icon(icon_name)
+
+        label = QLabel(f"{icon_name}")
+        label.setPixmap(icon.pixmap(24, 24))
+        layout.addWidget(label)
+
+        print(f"Requested icon: {icon_name}")
+
+    window.show()
+    sys.exit(app.exec_())