batoolset-gui 0.2.0__py3-none-any.whl

batoolset/luts/lutcreatorfromformula.py

@@ -0,0 +1,209 @@
+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.")
+
+    def get_palette(self):
+        """
+        Returns the current LUT.
+
+        :return: The current LUT or None if no LUT has been generated.
+        """
+        return self.palette
+
+
+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/luts/luteditor.py

@@ -0,0 +1,243 @@
+# MEGA TODO --> maybe append the newly created LUTs from formula at the end or add a button to append it to the list and then ask for a name an ddo not allow duplication of names -−> TODO --> think about it
+
+from batoolset.GUI.customdialog import CustomDialog
+from batoolset.luts.lutcreatorfromformula import PaletteFormulaEditor
+from batoolset.settings.global_settings import set_UI # set the UI to qtpy
+set_UI()
+import traceback
+from batoolset.files.tools import get_home_dir
+from batoolset.luts.lut_minimal_test import list_available_luts, PaletteCreator
+import sys
+from qtpy.QtWidgets import QApplication, QWidget, QGridLayout, QPushButton, QColorDialog, QLabel, QVBoxLayout, QHBoxLayout, QFileDialog, QMessageBox, QComboBox, QLineEdit, QFormLayout
+from qtpy.QtGui import QColor, QPixmap, QImage
+from qtpy.QtCore import Qt
+from batoolset.pyqts.tools import updateLutLabelPreview
+import numpy as np
+
+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.last_used_path = ""  # Store the last used path
+
+        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()
+
+        # Add QComboBox for selecting LUT models with a label
+        comboLayout = QHBoxLayout()
+        self.lut_label = QLabel("Select LUT:")
+        self.lut_combo = QComboBox()
+        available_luts = list_available_luts()
+        for lll, lut in enumerate(available_luts):
+            if lll == 0:
+                continue
+            self.lut_combo.addItem(lut)
+
+        # Select the "gray" entry by default
+        self.lut_combo.setCurrentText("GRAY")
+
+        self.lut_combo.currentIndexChanged.connect(self.setSelectedLUT)
+        comboLayout.addWidget(self.lut_label)
+        comboLayout.addWidget(self.lut_combo)
+
+        # Set stretch factors to make the combo box occupy more space
+        comboLayout.setStretchFactor(self.lut_label, 1)
+        comboLayout.setStretchFactor(self.lut_combo, 7)
+
+        mainLayout.addLayout(comboLayout)
+
+        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)
+
+        # Add LO and HI buttons
+        buttonLayout = QHBoxLayout()
+        self.loButton = QPushButton("LO")
+        self.loButton.clicked.connect(self.setFirstButton)
+        self.hiButton = QPushButton("HI")
+        self.hiButton.clicked.connect(self.setLastButton)
+        buttonLayout.addWidget(self.loButton)
+        buttonLayout.addWidget(self.hiButton)
+
+        # Add Import and Export buttons
+        self.importButton = QPushButton("Import LUT")
+        self.importButton.clicked.connect(self.importLUT)
+        self.exportButton = QPushButton("Export LUT")
+        self.exportButton.clicked.connect(self.exportLUT)
+        buttonLayout.addWidget(self.importButton)
+        buttonLayout.addWidget(self.exportButton)
+
+        # Add Formula Editor button
+        self.formulaEditorButton = QPushButton("New Lut formula")
+        self.formulaEditorButton.clicked.connect(self.openFormulaEditor)
+        buttonLayout.addWidget(self.formulaEditorButton)
+
+        mainLayout.addLayout(buttonLayout)
+
+        self.setLayout(mainLayout)
+        self.setWindowTitle('Palette Editor (256 entries)')
+        self.show()
+
+    def openFormulaEditor(self):
+        lut_from_formula = PaletteFormulaEditor(self)
+        custom_dialog = CustomDialog(title="Edit text", message="Do you want to proceed?", main_widget=lut_from_formula,
+                                     parent=self, options=['Ok', 'Cancel'],
+                                     auto_adjust=True)  # that is really very good --> I can do it like that
+        # custom_dialog.adjustSize()
+        result = custom_dialog.exec_()
+        if result:
+            try:
+                lut = lut_from_formula.get_palette()
+                self.setLUT(lut)
+                total_length = (self.button_width * self.columns) + (self.spacing * (self.columns - 1))
+                updateLutLabelPreview(self.getLUT(), self.previewLabel, total_length)
+            except:
+                traceback.print_exc()
+                print('invalid lut')
+
+    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):
+                entry = lut[index]
+                if isinstance(entry, str):
+                    # Handle string representation of the color
+                    color = QColor(entry)
+                elif isinstance(entry, (list, np.ndarray)) and len(entry) == 3:
+                    # Handle [R, G, B] array
+                    color = QColor(entry[0], entry[1], entry[2])
+                else:
+                    raise ValueError(f"Invalid LUT entry: {entry}")
+
+                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 setFirstButton(self):
+        self.buttons[(0, 0)].setStyleSheet("background-color: #0000FF;")
+        total_length = (self.button_width * self.columns) + (self.spacing * (self.columns - 1))
+        updateLutLabelPreview(self.getLUT(), self.previewLabel, total_length)
+
+    def setLastButton(self):
+        self.buttons[(self.rows - 1, self.columns - 1)].setStyleSheet("background-color: #FF0000;")
+        total_length = (self.button_width * self.columns) + (self.spacing * (self.columns - 1))
+        updateLutLabelPreview(self.getLUT(), self.previewLabel, total_length)
+
+    def importLUT(self):
+        options = QFileDialog.Options()
+        fileName, _ = QFileDialog.getOpenFileName(self, "Import LUT", self.last_used_path if self.last_used_path else get_home_dir(), "Text Files (*.lut);;All Files (*)", options=options)
+        if fileName:
+            try:
+                with open(fileName, 'r') as file:
+                    lut = [line.strip() for line in file]
+                    if len(lut) != 256:
+                        raise ValueError("LUT must contain exactly 256 entries")
+                    self.setLUT(lut)
+                    total_length = (self.button_width * self.columns) + (self.spacing * (self.columns - 1))
+                    updateLutLabelPreview(self.getLUT(), self.previewLabel, total_length)
+            except Exception as e:
+                QMessageBox.critical(self, "Error", str(e))
+
+    def exportLUT(self):
+        options = QFileDialog.Options()
+        fileName, _ = QFileDialog.getSaveFileName(self, "Export LUT", self.last_used_path if self.last_used_path else get_home_dir(), "Text Files (*.lut);;All Files (*)", options=options)
+        if fileName:
+            if not fileName.lower().endswith('.lut'):
+                fileName=fileName+'.lut'
+            try:
+                with open(fileName, 'w', encoding='utf-8') as file:
+                    lut = self.getLUT()
+                    for color in lut:
+                        file.write(f"{color}\n")
+
+                # Update the last used path
+                self.last_used_path = fileName
+            except Exception as e:
+                QMessageBox.critical(self, "Error", str(e))
+
+    def setSelectedLUT(self):
+        selected_lut = self.lut_combo.currentText()
+        # lut = list_available_luts()[index + 1]  # Adjust index to skip the first entry
+        available_luts = list_available_luts()
+        lutcreator = PaletteCreator()
+        lut_list = lutcreator.list
+        if selected_lut in available_luts:
+            try:
+                lut = lutcreator.create3(lut_list[selected_lut])
+                self.setLUT(lut)
+                total_length = (self.button_width * self.columns) + (self.spacing * (self.columns - 1))
+                updateLutLabelPreview(self.getLUT(), self.previewLabel, total_length)
+            except:
+                traceback.print_exc()
+                print('invalid LUT')
+
+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/pyqts/pleasewaitdialog.py

@@ -0,0 +1,14 @@
+from batoolset.settings.global_settings import set_UI # set the UI to qtpy
+set_UI()
+from qtpy.QtWidgets import QApplication, QDialog, QLabel, QVBoxLayout
+
+class PleaseWaitDialog(QDialog):
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setWindowTitle("Please wait")
+        self.setModal(True)
+
+        label = QLabel("Please wait... The slow process is running.")
+        layout = QVBoxLayout()
+        layout.addWidget(label)
+        self.setLayout(layout)