batoolset 0.1.8__tar.gz → 0.1.9__tar.gz

{batoolset-0.1.8 → batoolset-0.1.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: batoolset
-Version: 0.1.8
+Version: 0.1.9
 Summary: An aggregate of functions I find useful
 Home-page: https://github.com/baigouy/batoolset
 Author: Benoit Aigouy

{batoolset-0.1.8 → batoolset-0.1.9}/batoolset/luts/lut_minimal_test.py

@@ -11,6 +11,7 @@ from matplotlib.backends.backend_agg import FigureCanvasAgg
 from matplotlib.figure import Figure
 from batoolset.img import fig_to_numpy
 import base64
+import numexpr as ne
 
 def serialize_lut(lut_256_3):
     # see also /home/aigouy/mon_prog/Python/epyseg_pkg/personal/FigGen_EzFig2/trash/tst_base64_encode_the_whole_np_array.py
@@ -142,11 +143,10 @@ def list_available_luts(return_matplotlib_lib_luts_in_separate_database=False):
     """
     hash_pal = {
         "DEFAULT": "22,13,-23",
-        "GREEN": "0,3,0",
         "RED": "3,0,0",
+        "GREEN": "0,3,0",
         "BLUE": "0,0,3",
         "GRAY": "3,3,3",
-        "GREY": "3,3,3",
         "AFM_HOT": "34,35,36",
         "PACKING": "PACKING",
         "RED_HOT": "21,22,23",
@@ -451,6 +451,38 @@ class PaletteCreator:
 
         return equation
 
+    # def computeEquation(self, equation, variable, val):
+    #     """
+    #     Computes the result of an equation using the numexpr library.
+    #
+    #     Args:
+    #         equation (str): The equation to compute.
+    #         variable (str): The variable name in the equation.
+    #         val: The value for the variable.
+    #
+    #     Returns:
+    #         float: The computed result of the equation.
+    #
+    #     # Examples:
+    #     #     >>> palette_creator = PaletteCreator()
+    #     #     >>> result = palette_creator.computeEquation("2*a*(b/c)**2", "a", [1, 2, 2])
+    #     #     >>> print(result)
+    #     #     array([0.88888889, 0.44444444, 4.])
+    #     """
+    #     import numexpr as ne
+    #     var = {'a': np.array([1, 2, 2]), 'b': np.array([2, 1, 3]), 'c': np.array([3])}
+    #     print('TOO', ne.evaluate('2*a*(b/c)**2', local_dict=var))
+    #     try:
+    #         for i in range(10):
+    #             equation = equation.replace(str(i) + variable, str(i) + "*" + variable)
+    #         for i in range(10):
+    #             equation = equation.replace(variable + str(i), variable + "*" + str(i))
+    #
+    #         equation = equation.replace(variable, "(double)" + variable)
+    #         print(equation)
+    #     except:
+    #         traceback.print_exc()
+    #         return 0
     def computeEquation(self, equation, variable, val):
         """
         Computes the result of an equation using the numexpr library.
@@ -461,28 +493,29 @@ class PaletteCreator:
             val: The value for the variable.
 
         Returns:
-            float: The computed result of the equation.
-
-        # Examples:
-        #     >>> palette_creator = PaletteCreator()
-        #     >>> result = palette_creator.computeEquation("2*a*(b/c)**2", "a", [1, 2, 2])
-        #     >>> print(result)
-        #     array([0.88888889, 0.44444444, 4.])
+            numpy.ndarray: The computed result of the equation.
         """
-        import numexpr as ne
-        var = {'a': np.array([1, 2, 2]), 'b': np.array([2, 1, 3]), 'c': np.array([3])}
-        print('TOO', ne.evaluate('2*a*(b/c)**2', local_dict=var))
         try:
-            for i in range(10):
-                equation = equation.replace(str(i) + variable, str(i) + "*" + variable)
-            for i in range(10):
-                equation = equation.replace(variable + str(i), variable + "*" + str(i))
-
-            equation = equation.replace(variable, "(double)" + variable)
-            print(equation)
-        except:
+            # Handle the special case where the equation is just a minus sign
+            if equation.strip() == '-':
+                return -np.array(val)
+            if equation.strip() == '+':
+                return np.array(val)
+            # Prepare the variable dictionary
+            var = {variable: np.array(val)}
+
+            # Print the equation and variables for debugging
+            print(f"Evaluating equation: {equation}")
+            print(f"Variables: {var}")
+            # Evaluate the equation using numexpr
+            result = ne.evaluate(equation, local_dict=var)
+
+            return result
+        except Exception as e:
+            # Print the traceback and the error message
             traceback.print_exc()
-            return 0
+            print(f"Error evaluating the equation '{equation}': {e}")
+            return np.zeros_like(val)  # Return an array of zeros with the same shape as val
 
     def create5(self, red, green, blue):
         """
@@ -773,7 +806,7 @@ class PaletteCreator:
         final_palette = None
         try:
             r = g = b = 3
-            if "," in palette_name:
+            if palette_name and "," in palette_name:
                 formula_size = len(palette_name.split(","))
                 if formula_size == 3:
                     r = int(palette_name.split(",")[0])
@@ -786,15 +819,22 @@ class PaletteCreator:
                     equa2 = new_equa2
                     equa3 = new_equa3
 
+            # print('passing there')
+
             if abs(r) < 37 and abs(g) < 37 and abs(b) < 37:
                 return self.create3(palette_name)
 
             if abs(r) >= 37 and abs(g) >= 37 and abs(b) >= 37:
                 palette1 = self.createEmptyPalette()
             else:
-                palette1 = self.create(palette_name)
+                palette1 = self.create3(palette_name)
 
+            # print('inside equa', equa1, equa2, equa3)
             palette2 = self.create_from_formula(equa1, equa2, equa3)
+
+
+            # print(palette2.shape)
+
             final_palette = np.zeros((palette1.shape[0], palette1.shape[1]), dtype=np.uint8)
             l = 0
             l1 = 0
@@ -812,9 +852,14 @@ class PaletteCreator:
                 green = green2 if abs(g) >= 37 and abs(g) <= 39 else green1
                 blue = blue2 if abs(b) >= 37 and abs(b) <= 39 else blue1
 
-                final_palette[l, 0] = red
-                final_palette[l, 1] = green
-                final_palette[l, 2] = blue
+                # print('final_palette', final_palette.shape)
+                # print('red', red)
+                # print('green', green)
+                # print('blue', blue)
+
+                final_palette[l, 0] = red[0]
+                final_palette[l, 1] = green[1]
+                final_palette[l, 2] = blue[2]
                 l += 1
         except:
             traceback.print_exc()

batoolset-0.1.9/batoolset/luts/lutcreatorfromformula.py

@@ -0,0 +1,204 @@
+from batoolset.pyqts.tools import updateLutLabelPreview
+from batoolset.settings.global_settings import set_UI # set the UI to qtpy
+set_UI()
+import sys
+import random
+from qtpy.QtWidgets import (
+    QApplication, QWidget, QVBoxLayout, QHBoxLayout, QLabel, QLineEdit,
+    QPushButton, QTextEdit, QGroupBox, QMessageBox, QScrollArea,QSizePolicy,
+)
+from qtpy.QtCore import Qt
+from qtpy.QtGui import QFont
+
+from batoolset.luts.lut_minimal_test import PaletteCreator, list_available_luts, apply_lut, lsm_LUT_to_numpy
+
+
+
+
+class PaletteFormulaEditor(QWidget):
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.palette = None
+
+        # Initialize the UI components
+        self.initUI()
+
+    def initUI(self):
+        layout = QVBoxLayout()
+
+        # Preview Panel
+        self.preview_group = QGroupBox("Preview")
+        preview_layout = QVBoxLayout()
+        # Align the QLabel to the center
+
+        self.previewLabel = QLabel()
+        # self.previewLabel.setFixedSize(750,16)
+        preview_layout.addWidget(self.previewLabel)
+        preview_layout.setAlignment(self.previewLabel, Qt.AlignCenter)
+        self.preview_group.setLayout(preview_layout)
+        layout.addWidget(self.preview_group)
+
+        # Formula Panel
+        self.formula_group = QGroupBox("Formula")
+        formula_layout = QVBoxLayout()
+
+        h_layout1 = QHBoxLayout()
+        h_layout2 = QHBoxLayout()
+
+        # Red Formula
+        self.redLabel = QLabel("Red Formula:")
+        self.redFormula = QLineEdit("34")
+        self.redFormula.textChanged.connect(self.update_palette)
+
+        # Green Formula
+        self.greenLabel = QLabel("Green Formula:")
+        self.greenFormula = QLineEdit("35")
+        self.greenFormula.textChanged.connect(self.update_palette)
+
+        # Blue Formula
+        self.blueLabel = QLabel("Blue Formula:")
+        self.blueFormula = QLineEdit("36")
+        self.blueFormula.textChanged.connect(self.update_palette)
+
+        # Add to layout
+        h_layout1.addWidget(self.redLabel)
+        h_layout1.addWidget(self.redFormula)
+        h_layout1.addWidget(self.greenLabel)
+        h_layout1.addWidget(self.greenFormula)
+        h_layout1.addWidget(self.blueLabel)
+        h_layout1.addWidget(self.blueFormula)
+
+
+        # Equation Text Fields
+        self.eqLabel1 = QLabel("Eq. #1:")
+        self.eq1 = QLineEdit("x")
+        self.eq1.textChanged.connect(self.update_palette)
+
+        self.eqLabel2 = QLabel("Eq. #2:")
+        self.eq2 = QLineEdit("x")
+        self.eq2.textChanged.connect(self.update_palette)
+
+        self.eqLabel3 = QLabel("Eq. #3:")
+        self.eq3 = QLineEdit("x")
+        self.eq3.textChanged.connect(self.update_palette)
+
+        # Random Button
+        self.randomButton = QPushButton("Random")
+        self.randomButton.clicked.connect(self.randomize_formulas)
+
+        # Update Button
+        # self.updateButton = QPushButton("Update")
+        # self.updateButton.clicked.connect(self.update_palette)
+
+        if False:  # TODO --> really connect this in the future but ok for now
+            h_layout2.addWidget(self.eqLabel1)
+            h_layout2.addWidget(self.eq1)
+            h_layout2.addWidget(self.eqLabel2)
+            h_layout2.addWidget(self.eq2)
+            h_layout2.addWidget(self.eqLabel3)
+            h_layout2.addWidget(self.eq3)
+        h_layout2.addWidget(self.randomButton)
+        # h_layout2.addWidget(self.updateButton)
+
+        # Text Area
+        self.textArea = QTextEdit()
+        self.textArea.setReadOnly(True)
+        self.textArea.setText(
+            "0: 0\t\t\t1: 0.5\t\t\t2: 1\n"
+            "3: x\t\t\t4: x^2\t\t\t5: x^3\n"
+            "6: x^4\t\t\t7: sqrt(x)\t\t8: sqrt(sqrt(x))\n"
+            "9: sin(90*x)\t\t10: cos(90*x)\t\t11: |x-0.5|\n"
+            "12: (2*x-1)^2\t\t13: sin(180*x)\t\t14: |cos(180*x)|\n"
+            "15: sin(360*x)\t\t16: cos(360*x)\t\t17: |sin(360*x)|\n"
+            "18: |cos(360*x)|\t\t19: |sin(720*x)|\t\t20: |cos(720*x)|\n"
+            "21: 3*x\t\t\t22: 3*x-1\t\t23: 3*x-2\n"
+            "24: |3*x-1|\t\t25: |3*x-2|\t\t26: (3*x-1)/2\n"
+            "27: (3*x-2)/2\t\t28: |(3*x-1)/2|\t\t29: |(3*x-2)/2|\n"
+            "30: x/0.32-25/32\t\t31: 2*x-0.84\t\t32: x\n"
+            "33: |2*x - 0.5|\t\t34: 2*x\t\t\t35: 2*x - 0.5\n"
+            "36: 2*x - 1\t\t37: eq. #1\t\t38: eq. #2\n"
+            "39: eq. #3\n\n"
+            "NB: negative numbers --> returns the negative of the generated palette\n"
+            "NB2: I used Gnuplot numbering for equations to promote compatibility between the 2 softwares\n"
+            "NB3: the idea of using formulas to create LUTs is coming from Gnuplot"
+        )
+        # Set the font to monospace
+        font = QFont("Courier New", 12)  # You can adjust the font size as needed
+        self.textArea.setFont(font)
+
+        # Disable scrollbars
+        self.textArea.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
+        self.textArea.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
+
+        # Resize QTextEdit to fit its content
+        self.textArea.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
+        self.textArea.setMinimumHeight(360)  # Set a minimum height to ensure it's usable
+
+        formula_layout.addLayout(h_layout1)
+        formula_layout.addLayout(h_layout2)
+        formula_layout.addWidget(self.textArea)
+
+        self.formula_group.setLayout(formula_layout)
+        layout.addWidget(self.formula_group)
+
+        self.setLayout(layout)
+
+        self.update_palette()
+
+
+    def randomize_formulas(self):
+        rand = int(self.randomSign(random.uniform(0, 39)))
+        self.redFormula.setText(str(rand))
+        rand = int(self.randomSign(random.uniform(0, 39)))
+        self.greenFormula.setText(str(rand))
+        rand = int(self.randomSign(random.uniform(0, 39)))
+        self.blueFormula.setText(str(rand))
+        self.update_palette()
+
+    def randomSign(self, nb):
+        return nb if random.random() > 0.5 else -nb
+
+    def update_palette(self):
+        if self.check_validity():
+            # Here, you would call your function to create and update the palette
+            self.palette = self.create_palette(
+                self.redFormula.text(),
+                self.greenFormula.text(),
+                self.blueFormula.text(),
+                self.eq1.text(),
+                self.eq2.text(),
+                self.eq3.text()
+            )
+            self.show_palette()
+    def check_validity(self):
+        return all([self.redFormula.text(), self.greenFormula.text(), self.blueFormula.text()])
+
+    def create_palette(self, red_formula, green_formula, blue_formula, eq1, eq2, eq3):
+        # print('red_formula, green_formula, blue_formula, eq1, eq2, eq3', red_formula, green_formula, blue_formula, eq1, eq2, eq3)
+        pc = PaletteCreator()
+        # lut = pc.create2(None, str(red_formula)+str(eq1), str(green_formula)+str(eq2), str(blue_formula)+str(eq3))
+        lut = pc.create2(f'{str(red_formula)},{ str(green_formula)},{str(blue_formula)}', eq1,eq2, eq3)
+
+        # print('lut', lut)
+
+        # self.show_palette()
+        return lut  # Return the LUT for preview
+
+    def show_palette(self):
+        if self.palette is not None:
+            # print('show_palette called')
+            # Compute the total length based on your button dimensions and spacing
+            total_length = 760#(button_width * 16) + (spacing * 15)  # Adjust based on columns and spacing
+            updateLutLabelPreview(self.palette, self.previewLabel, total_length, height=32)
+        else:
+            if self.check_validity():
+                QMessageBox.warning(self, "No Palette", "No palette to display. Please generate a palette first.")
+
+
+if __name__ == '__main__':
+    app = QApplication(sys.argv)
+    jar_folder = ""  # Provide the correct path if needed
+    ex = PaletteFormulaEditor()
+    ex.setWindowTitle('Palette Formula Editor')
+    ex.show()
+    sys.exit(app.exec_())

batoolset-0.1.9/batoolset/luts/luteditor.py

@@ -0,0 +1,116 @@
+from batoolset.settings.global_settings import set_UI # set the UI to qtpy
+set_UI()
+import sys
+from qtpy.QtWidgets import QApplication, QWidget, QGridLayout, QPushButton, QColorDialog, QLabel, QVBoxLayout
+from qtpy.QtGui import QColor, QPixmap, QImage
+from qtpy.QtCore import Qt
+from batoolset.pyqts.tools import updateLutLabelPreview
+
+class PaletteEditor(QWidget):
+    def __init__(self, lut=None, parent=None):
+        super().__init__(parent)
+
+        self.button_width = 40  # Example button width
+        self.button_height = 20  # Example button height
+        self.spacing = 2  # Example spacing
+
+        self.rows = 16
+        self.columns = 16
+        self.buttons = {}
+
+        self.initUI()
+
+        if lut:
+            self.setLUT(lut)
+        else:
+            self.setDefaultLUT()
+
+        # self.updatePreview()
+        total_length = (self.button_width * self.columns) + ( self.spacing * (self.columns - 1))
+        updateLutLabelPreview(self.getLUT(), self.previewLabel,total_length)
+
+    def initUI(self):
+        mainLayout = QVBoxLayout()
+
+        gridLayout = QGridLayout()
+        gridLayout.setSpacing(2)
+
+        for row in range(self.rows):
+            for col in range(self.columns):
+                button = QPushButton()
+                button.setFixedSize(self.button_width, self.button_height)
+                button.setStyleSheet("background-color: white;")
+                button.clicked.connect(lambda _, r=row, c=col: self.openColorDialog(r, c))
+
+                gridLayout.addWidget(button, row, col)
+                self.buttons[(row, col)] = button
+
+        self.previewLabel = QLabel()
+        gridLayout.addWidget(self.previewLabel, self.rows, 0, 1, self.columns)
+
+        mainLayout.addLayout(gridLayout)
+        self.setLayout(mainLayout)
+        self.setWindowTitle('Palette Editor (256 entries)')
+        self.show()
+
+    def openColorDialog(self, row, col):
+        button = self.buttons[(row, col)]
+        current_color = button.palette().color(button.backgroundRole())
+
+        color = QColorDialog.getColor(current_color, self)
+
+        if color.isValid():
+            button.setStyleSheet(f"background-color: {color.name()};")
+            # self.updatePreview()
+            total_length = (self.button_width * self.columns) + (self.spacing * (self.columns - 1))
+            updateLutLabelPreview(self.getLUT(), self.previewLabel, total_length)
+
+    def getLUT(self):
+        lut = []
+        for row in range(self.rows):
+            for col in range(self.columns):
+                button = self.buttons[(row, col)]
+                color = button.palette().color(button.backgroundRole())
+                lut.append(color.name())
+        return lut
+
+    def setLUT(self, lut):
+        if len(lut) != 256:
+            raise ValueError("LUT must contain exactly 256 entries")
+
+        index = 0
+        for row in range(self.rows):
+            for col in range(self.columns):
+                color = QColor(lut[index])
+                if color.isValid():
+                    self.buttons[(row, col)].setStyleSheet(f"background-color: {color.name()};")
+                index += 1
+
+    def setDefaultLUT(self):
+        default_lut = [f"#{i:02x}{i:02x}{i:02x}" for i in range(256)]
+        self.setLUT(default_lut)
+
+    # def updatePreview(self):
+    #     lut = self.getLUT()
+    #     image = QImage(256, 16, QImage.Format_RGB32)
+    #
+    #     for i in range(256):
+    #         color = QColor(lut[i])
+    #         for j in range(16):
+    #             image.setPixelColor(i, j, color)
+    #
+    #     pixmap = QPixmap.fromImage(image)
+    #     total_width = (40 * self.columns) + (2 * (self.columns - 1))
+    #     scaled_pixmap = pixmap.scaled(total_width, 16, Qt.IgnoreAspectRatio, Qt.SmoothTransformation)
+    #     self.previewLabel.setPixmap(scaled_pixmap)
+
+
+if __name__ == '__main__':
+    # this is the first version of my LUT editor
+
+    app = QApplication(sys.argv)
+
+    # Create PaletteEditor with the default grayscale LUT
+    ex = PaletteEditor()
+
+    sys.exit(app.exec_())

{batoolset-0.1.8 → batoolset-0.1.9}/batoolset/pyqts/tools.py

@@ -1,13 +1,13 @@
 from batoolset.settings.global_settings import set_UI # set the UI to qtpy
 set_UI()
-from qtpy.QtGui import QPainter,QTransform,QImage,QPolygonF,QFont, QTextDocument,QColor,QPolygon
+from qtpy.QtGui import QPainter,QTransform,QImage,QPolygonF,QFont, QTextDocument,QColor,QPolygon,QPixmap
 from qtpy.QtCore import QRectF, QPointF, QSize, QRect, QPoint
 from qtpy.QtCore import Qt, QObject, QEvent
 from qtpy.QtWidgets import QHBoxLayout, QSlider,QLabel,QComboBox,QSpinBox,QWidget,QScrollArea,QDoubleSpinBox
 import math
+import numpy as np
 import sys
 
-
 # class WheelFilter(QObject):
 #     def eventFilter(self, obj, event):
 #         if event.type() == QEvent.Wheel:
@@ -44,7 +44,43 @@ import sys
 #     blocker = WheelBlocker(app)
 #     app.installEventFilter(blocker)
 
+def updateLutLabelPreview(lut, previewLabel, length, orientation='horizontal', height=16):
+    """
+    Updates the preview label with an image representing the LUT.
+
+    :param lut: List of color values in the LUT.
+    :param previewLabel: The QLabel where the preview image will be displayed.
+    :param length: The total length of the preview, including buttons and spacing.
+    :param orientation: The orientation of the LUT ('horizontal' or 'vertical').
+    """
+    image = QImage(256, height, QImage.Format_RGB32)
+
+    for i in range(256):
+        if isinstance(lut[i], str):
+            # If lut[i] is a string, convert it to QColor
+            color = QColor(lut[i])
+        elif isinstance(lut[i], (list, np.ndarray)) and len(lut[i]) == 3:
+            # If lut[i] is an RGB array, convert it to QColor
+            color = QColor(int(lut[i][0]), int(lut[i][1]), int(lut[i][2]))
+        else:
+            raise ValueError("LUT entry must be a color string or an RGB array")
+
+        for j in range(height):
+            image.setPixelColor(i, j, color)
+
+    pixmap = QPixmap.fromImage(image)
+    scaled_pixmap = pixmap.scaled(length, height, Qt.IgnoreAspectRatio, Qt.SmoothTransformation)
+
+    if orientation != 'horizontal':
+        # Rotate the scaled pixmap 90 degrees clockwise for vertical orientation
+        transform = QTransform().rotate(90)
+        scaled_pixmap = scaled_pixmap.transformed(transform)
+
+    previewLabel.setPixmap(scaled_pixmap)
+
+
 def getCtrlModifierAsString():
+    import sys
     if sys.platform == "darwin":
         return "Meta"  # Command key on macOS
     # else:

{batoolset-0.1.8 → batoolset-0.1.9}/batoolset/version.py

@@ -1,6 +1,6 @@
 __MAJOR__ = 0
 __MINOR__ = 1
-__MICRO__ = 8
+__MICRO__ = 9
 __RELEASE__ = ''  # a #b  # https://www.python.org/dev/peps/pep-0440/#public-version-identifiers --> alpha beta, ...
 __VERSION__ = ''.join([str(__MAJOR__), '.', str(__MINOR__), '.', str(__MICRO__)])
 __DESCRIPTION__ = """An aggregate of functions I find useful"""

{batoolset-0.1.8 → batoolset-0.1.9}/batoolset.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: batoolset
-Version: 0.1.8
+Version: 0.1.9
 Summary: An aggregate of functions I find useful
 Home-page: https://github.com/baigouy/batoolset
 Author: Benoit Aigouy

{batoolset-0.1.8 → batoolset-0.1.9}/batoolset.egg-info/SOURCES.txt

@@ -86,6 +86,8 @@ batoolset/lists/__init__.py
 batoolset/lists/tools.py
 batoolset/luts/__init__.py
 batoolset/luts/lut_minimal_test.py
+batoolset/luts/lutcreatorfromformula.py
+batoolset/luts/luteditor.py
 batoolset/matplolibs/__init__.py
 batoolset/matplolibs/tools.py
 batoolset/nps/__init__.py