Change Channel Color

Allows the user to change channel color within Channel Editor Widget
Updated channel map after user chooses new channel color
Trying out new dynamic RGB channel that uses first two channel rather than hard-coded magenta mode.

Author: jtle00

src/pymapmanager/interface/stackWidgets/annotationListWidget2.py

@@ -617,4 +617,4 @@ def _contextMenuEvent(self, event):
         menu.addAction(colorAction)
 
         # action = _menu.exec_(self.mapToGlobal(event.pos()))
-        self.menu.popup(QtGui.QCursor.pos())
+        menu.popup(QtGui.QCursor.pos())

src/pymapmanager/interface/stackWidgets/base/annotationPlotWidget2.py

@@ -1280,10 +1280,17 @@ def toggleRadiusLines(self, toggle: bool = None) -> bool:
 
         return self.showRadiusLines
 
-    def togglePivotPoints(self):
-        self.showPivotPoints = not self.showPivotPoints
+    def togglePivotPoints(self, toggle: bool = None):
+        if toggle is None:
+            self.showPivotPoints = not self.showPivotPoints
+        else:
+            self.showPivotPoints = toggle
+            
         self._pivotPoints.setVisible(self.showPivotPoints)
         return self.showPivotPoints
+    
+    def arePivotPointsShown(self):
+        return self.showPivotPoints
 
     # def _getScatterColor(self):
     #     """

src/pymapmanager/interface/stackWidgets/base/mmWidget2.py

@@ -57,6 +57,7 @@ class pmmEventType(Enum):
     setColorChannel = auto()
 
     setRadius = auto() # abj
+    updateChannelMetadata = auto()
 
     # added to refresh gui after modifying the core with undo and redo
     refreshSpineEvent = auto()
@@ -851,8 +852,9 @@ def getStack(self):
     def getMapTimepoint(self) -> Optional[int]:
         """Get map session from the stack.
         """
-        if self.getStack() is not None:
-            return self.getStack().timepoint
+        stack = self.getStack() # time series core object?
+        if stack is not None:
+            return stack.timepoint
             # return self.getStack().timepoint()
 
     def getClassName(self) -> str:
@@ -969,6 +971,8 @@ def slot_pmmEvent(self, event : pmmEvent):
         #abj
         elif event.type == pmmEventType.setRadius:
             acceptEvent = self.setRadiusEvent(event)
+        elif event.type == pmmEventType.updateChannelMetadata:
+            acceptEvent = self.updateChannelMetadataEvent(event)
 
         # abb 20240716
         # segment events
@@ -1323,6 +1327,9 @@ def setRadiusEvent(self, event : pmmEvent):
         # logger.warning(f'{self.getClassName()} base class called')
         pass
 
+    def updateChannelMetadataEvent(self, event: pmmEvent):
+        pass
+
     def setSegmentColorEvent(self, event : pmmEvent):
         pass
 

src/pymapmanager/interface/stackWidgets/base/stacktoolbar.py

@@ -265,6 +265,14 @@ def _buildUI(self):
 
         #self.setFocus()
 
+    def manuallyUpdatePlotBoxes(self, plotName, checked: bool = False):
+        """
+        """
+        action = self.actionMenuDict[plotName]
+        # self.plotMenuChange(action)
+        action.setChecked(checked)
+        self.plotMenuChange(action)
+
     def labelBoxUpdate(self):
         """ Part of plot menu Change
 
@@ -307,6 +315,9 @@ def checkAnnotations(self, check: bool = False):
         centerLineAction = self.actionMenuDict["Center Line"]
         centerLineAction.setChecked(check)
 
+        pivotPointsAction = self.actionMenuDict["Pivot Points"]
+        pivotPointsAction.setChecked(check)
+
     def plotMenuChange(self, action):
         """ Emit a plot name after a given action (check box) is clicked
 

src/pymapmanager/interface/stackWidgets/channelEditor.py

@@ -1,6 +1,7 @@
 
 from functools import partial
 # from tkinter import Image
+from PyQt5 import QtGui
 from qtpy import QtWidgets, QtCore
 from PIL import Image
 
@@ -106,12 +107,21 @@ def _buildGUI(self):
 
                 self.gridLayout.addWidget(activateBox, self.totalChannelsShown, 2)
                 activateBox.currentTextChanged.connect(partial(self._onActivate, channelKey))
-                
+
+                # Color picker
+                # logger.info(f"checking channelKey {channelKey}")
+                channelMetaData = self.getStack().getChannelMetadata(channelKey)
+                initialColor = channelMetaData.color
+                # logger.info(f"checking initialColor {initialColor}")
+                colorPicker = ColorPicker(initialColor, channelKey, self.stackWidget)
+                self.gridLayout.addWidget(colorPicker, self.totalChannelsShown, 3)
+
+                # Deleting Channel
                 if channelKey > 1: # For now have a restriction on deleting first channel
                 # if 1:
                     deleteButton = QtWidgets.QPushButton('')
                     # self.gridLayout.addWidget(deleteButton, channelIdx + 1, 2)
-                    self.gridLayout.addWidget(deleteButton, self.totalChannelsShown, 3)
+                    self.gridLayout.addWidget(deleteButton, self.totalChannelsShown, 4)
 
                     # Set a trashcan icon (using standard icon set)
                     pixmapi = getattr(QtWidgets.QStyle, "SP_TrashIcon")
@@ -518,3 +528,38 @@ def swapDraggableWidget(self, widgetUnderCursor):
 
     def updateChannelName(self, newChannelName: str = ""):
         self.stackWidget.updateChannel(newChannelName, channelIdx = self.getChannelIdx())
+
+class ColorPicker(QtWidgets.QWidget):
+    def __init__(self, initialColor, channelIdx, stackWidget):
+        super().__init__()
+        self.setWindowTitle("Color Picker")
+
+        self.initialColor = initialColor
+        self.channelIdx = channelIdx
+        self.stackWidget = stackWidget
+        self.button = QtWidgets.QPushButton("", self)
+        self.button.setStyleSheet(f"background-color: {initialColor}; padding: 10px;")
+        self.button.clicked.connect(self.open_color_dialog)
+
+        layout = QtWidgets.QVBoxLayout()
+        # layout.addWidget(self.label)
+        layout.addWidget(self.button)
+        self.setLayout(layout)
+
+    def open_color_dialog(self):
+        if type(self.initialColor) == str:
+            self.initialColor = QtGui.QColor(self.initialColor)
+        color = QtWidgets.QColorDialog.getColor(self.initialColor)
+
+        if color.isValid():
+            # self.label.setText(f"Selected Color: {color.name()}")
+            logger.info(f"name is {color.name()}")
+            self.button.setStyleSheet(f"background-color: {color.name()}; padding: 10px;")
+            self.storeChannelColor(self.channelIdx, color.name())
+            self.initialColor = color.name() # update color picker to new color
+
+    def storeChannelColor(self, channelIdx, newColor):
+        """ Store channel color into channelMetadata
+        """
+        # stackwidget wil emit signal to update the rest of widgets
+        self.stackWidget.setChannelProperty(channelIdx, "color", newColor)

src/pymapmanager/interface/stackWidgets/imagePlotWidget2.py

@@ -1,9 +1,13 @@
 import os
 import numpy as np
+import re
+import matplotlib.colors as mcolors
 
+import matplotlib.pyplot as plt
 from qtpy import QtGui, QtCore, QtWidgets
 import pyqtgraph as pg
-
+from pyqtgraph.exporters import ImageExporter
+from matplotlib.colors import to_rgb
 from mapmanagercore.imageImporter import acceptedExtensions
 
 import pymapmanager
@@ -252,7 +256,7 @@ def contextMenuEvent(self, event : QtGui.QContextMenuEvent):
 
         elif action == copyImageAction:
             # pass
-            exporter = pg.exporters.ImageExporter(self.getPlotWidget().plotItem)
+            exporter = ImageExporter(self.getPlotWidget().plotItem)
             qimage = exporter.export(toBytes=True)
 
             app = self._stackWidget.getPyMapManagerApp()
@@ -262,7 +266,7 @@ def contextMenuEvent(self, event : QtGui.QContextMenuEvent):
 
         elif action == exportImageAction:
             # Prompt for file location
-            exporter = pg.exporters.ImageExporter(self.getPlotWidget().plotItem)
+            exporter = ImageExporter(self.getPlotWidget().plotItem)
             _path = self.getPath()
             filters = '(*.png)'
             savePath, _ = QtWidgets.QFileDialog.getSaveFileName(self,
@@ -500,6 +504,12 @@ def setRadiusEvent(self, event):
         sliceNumber = self._currentSlice
         self._aLinePlot.slot_setSlice(sliceNumber)
 
+    def updateChannelMetadataEvent(self, event):
+        """
+        """
+        # refresh image with new image color
+        self.refreshSlice()
+
     def slot_setSlice(self, sliceNumber, doEmit=True):
         if self.slotsBlocked():
             return
@@ -546,20 +556,82 @@ def _setColorLut(self, update=False):
         if not self._channelIsRGB():
             logger.warning("TODO: add color str like ('red', 'green' 'blue')")
             colorStr = self._myStack.getChannelColor(self._displayThisChannelIdx)  # like 'r', 
-
+            logger.info(f"colorStr is {colorStr}")
             if colorStr == 'red':
                 cm = pg.colormap.get('Reds_r', source='matplotlib')
             elif colorStr == 'green':
                 cm = pg.colormap.get('Greens_r', source='matplotlib')
             elif colorStr == 'blue':
                 cm = pg.colormap.get('Blues_r', source='matplotlib')
             else:
-                logger.warning(f'did not understand color {colorStr} -->> defaulting to Greens_r')
-                # cm = pg.colormap.get('Greys_r', source='matplotlib')
-                cm = pg.colormap.get('Greens_r', source='matplotlib')
+            
+                # logger.warning(f'did not understand color {colorStr} -->> defaulting to Greens_r')
+                # # cm = pg.colormap.get('Greens_r', source='matplotlib')
+
+                # here colorStr is a hehex code
+                colorRGB = to_rgb(colorStr)
+                
+                # Create a list of colors transitioning from dark to bright
+                cm_qcolors = []
+                num_steps = 256  # More steps for smoother gradient
+                
+                import numpy as np
+                
+                for i in range(num_steps):
+                    value_factor = i / (num_steps - 1)
+                    # Adjust logarithmic scaling to match matplotlib's dynamic range
+                    log_factor = np.log1p(value_factor * 5) / np.log1p(5)
+                    log_factor = log_factor ** 0.7
+                    
+                    # Start from a dark version of the color and interpolate to bright
+                    dark_brightness = 0.3
+                    
+                    # Find the dominant channel (should be the one with highest value)
+                    max_channel = max(colorRGB)
+                    is_dominant = [c == max_channel for c in colorRGB]
+                    
+                    # Calculate base factors for each channel
+                    r_factor = log_factor * 1.2 if is_dominant[0] else log_factor * 0.3
+                    g_factor = log_factor * 1.2 if is_dominant[1] else log_factor * 0.3
+                    b_factor = log_factor * 1.2 if is_dominant[2] else log_factor * 0.3
+                    
+                    # Allow transition to white at highest intensities
+                    white_threshold = 0.7  # When to start transitioning to white
+                    if log_factor > white_threshold:
+                        # Calculate how far we are into the white transition
+                        white_amount = (log_factor - white_threshold) / (1 - white_threshold)
+                        # Smoothly interpolate to white
+                        r_factor = r_factor * (1 - white_amount) + white_amount
+                        g_factor = g_factor * (1 - white_amount) + white_amount
+                        b_factor = b_factor * (1 - white_amount) + white_amount
+                    
+                    # Ensure we don't exceed valid values
+                    r_factor = min(1.0, r_factor)
+                    g_factor = min(1.0, g_factor)
+                    b_factor = min(1.0, b_factor)
+                    
+                    r = int((colorRGB[0] * dark_brightness * 255) + (255 - colorRGB[0] * dark_brightness * 255) * r_factor)
+                    g = int((colorRGB[1] * dark_brightness * 255) + (255 - colorRGB[1] * dark_brightness * 255) * g_factor)
+                    b = int((colorRGB[2] * dark_brightness * 255) + (255 - colorRGB[2] * dark_brightness * 255) * b_factor)
+                    
+                    # Keep alpha at full opacity
+                    a = 255
+                    
+                    cm_qcolors.append(QtGui.QColor(r, g, b, a))
+
+                # Create matching normalized positions
+                positions = [i / (len(cm_qcolors) - 1) for i in range(len(cm_qcolors))]
+
+                # Create pyqtgraph ColorMap
+                cm = pg.ColorMap(positions, cm_qcolors)
+            
+                # # Apply to image
+                # self._myImage.setLookupTable(lut)
+                    
 
             self._myImage.setColorMap(cm)
 
+
     def _setContrast(self):
         if self._channelIsRGB():
             tmpLevelList = []  # list of [min,max]
@@ -649,6 +721,8 @@ def _setSlice(self, sliceNumber : int, doEmit = True):
                                     upSlices=upDownSlices, downSlices=upDownSlices,
                                     func=np.max)
 
+            # logger.info(f"check ch0_image min {ch1_image.min()} max {ch1_image.max()}")
+            
             # rgb requires 8-bit images
             ch0_image = ch0_image/ch0_image.max() * 2**8
             ch1_image = ch1_image/ch1_image.max() * 2**8
@@ -662,10 +736,30 @@ def _setSlice(self, sliceNumber : int, doEmit = True):
             _yShape = ch0_image.shape[1]
             sliceImage = np.ndarray((_xShape,_yShape,3))
 
-            # magenta is blue + red
-            sliceImage[:,:,0] = ch1_image  # red
-            sliceImage[:,:,1] = ch0_image  # green
-            sliceImage[:,:,2] = ch1_image  # blue
+            # # magenta is blue + red
+            # sliceImage[:,:,0] = ch1_image  # red
+            # sliceImage[:,:,1] = ch0_image  # green
+            # sliceImage[:,:,2] = ch1_image  # blue
+
+            # Get first two channel colors
+            color0 = self._myStack.getChannelColor(1)
+            color1 = self._myStack.getChannelColor(2)
+
+            color0 = self.colorToHex(color0)
+            color1 = self.colorToHex(color1)
+            logger.info(f"color0 {color0} color1 {color1}")
+
+            # Convert hex color to RGB arrays
+            rgb0 = to_rgb(color0)  # for ch0_image
+            rgb1 = to_rgb(color1)  # for ch1_image
+
+            brightness_factor = 2
+            for i in range(3):  # R, G, B
+                sliceImage[:,:,i] = (
+                    brightness_factor *
+                    (ch0_image * (rgb0[i])) + 
+                    (ch1_image * (rgb1[i])) * i 
+                ).clip(0, 255).astype(np.uint8)
 
         else:
             sliceImage = self._myStack.getMaxProjectSlice(sliceNumber,
@@ -694,6 +788,23 @@ def _setSlice(self, sliceNumber : int, doEmit = True):
             logger.info(f'  -->> emitEvent signalUpdateSlice() _currentSlice:{self._currentSlice}')
             self.emitEvent(_pmmEvent, blockSlots=True)
 
+
+    def colorToHex(self, color_str):
+        # Normalize input
+        color_str = color_str.strip().lower()
+
+        # Regex for valid hex color: #RGB, #RRGGBB, RGB, or RRGGBB
+        hex_pattern = r'^#?([0-9a-f]{3}|[0-9a-f]{6})$'
+
+        if re.fullmatch(hex_pattern, color_str):
+            # Add '#' if missing
+            return '#' + color_str.lstrip('#')
+        
+        try:
+            return mcolors.to_hex(color_str)
+        except ValueError:
+            raise ValueError(f"Unknown color name or invalid hex: '{color_str}'")
+
     def _emitSetSlice(self, newSlice):
             _pmmEvent = pmmEvent(pmmEventType.setSlice, self)
             # _pmmEvent.setSliceNumber(self._currentSlice)
@@ -724,11 +835,13 @@ def togglePlot(self, plotName):
         if plotName == "Annotations":
             self._toggleAllAnnotations = not self._toggleAllAnnotations 
             toggle = self._toggleAllAnnotations
+            logger.info(f"toggle {toggle}")
             visible = self._aPointPlot.toggleScatterPlot(toggle) # spines
             self._aPointPlot.toggleSpineLines(toggle) # spine (lines)
-            visible2 = self._aLinePlot.toggleScatterPlot(toggle) # center line
+            visible2 = self._aLinePlot.toggleSegmentPlot(toggle) # center line
             visible3 = self._aLinePlot.toggleRadiusLines(toggle) # radius lines 
             visible4 = self._aPointPlot.toggleLabels(toggle) # labels
+            visible5 = self._aLinePlot.togglePivotPoints(toggle)
             # pass
         elif plotName == "Spines":
             visible = self._aPointPlot.toggleScatterPlot()