MRG: Bump colorbar control points

mne/viz/_brain/_brain.py

@@ -863,64 +863,61 @@ def set_time_point(self, time_idx):
     def update_fmax(self, fmax):
         """Set the colorbar max point."""
         from ..backends._pyvista import _set_colormap_range
-        if fmax > self._data['fmid']:
-            ctable = self.update_lut(fmax=fmax)
-            ctable = (ctable * 255).astype(np.uint8)
-            center = self._data['center']
-            for hemi in ['lh', 'rh']:
-                actor = self._data.get(hemi + '_actor')
-                if actor is not None:
-                    fmin = self._data['fmin']
-                    center = self._data['center']
-                    dt_max = fmax
-                    dt_min = fmin if center is None else -1 * fmax
-                    rng = [dt_min, dt_max]
-                    if self._colorbar_added:
-                        scalar_bar = self._renderer.plotter.scalar_bar
-                    else:
-                        scalar_bar = None
-                    _set_colormap_range(actor, ctable, scalar_bar, rng)
-                    self._data['fmax'] = fmax
-                    self._data['ctable'] = ctable
+        ctable = self.update_lut(fmax=fmax)
+        ctable = (ctable * 255).astype(np.uint8)
+        center = self._data['center']
+        for hemi in ['lh', 'rh']:
+            actor = self._data.get(hemi + '_actor')
+            if actor is not None:
+                fmin = self._data['fmin']
+                center = self._data['center']
+                dt_max = fmax
+                dt_min = fmin if center is None else -1 * fmax
+                rng = [dt_min, dt_max]
+                if self._colorbar_added:
+                    scalar_bar = self._renderer.plotter.scalar_bar
+                else:
+                    scalar_bar = None
+                _set_colormap_range(actor, ctable, scalar_bar, rng)
+                self._data['fmax'] = fmax
+                self._data['ctable'] = ctable
 
     def update_fmid(self, fmid):
         """Set the colorbar mid point."""
         from ..backends._pyvista import _set_colormap_range
-        if self._data['fmin'] < fmid < self._data['fmax']:
-            ctable = self.update_lut(fmid=fmid)
-            ctable = (ctable * 255).astype(np.uint8)
-            for hemi in ['lh', 'rh']:
-                actor = self._data.get(hemi + '_actor')
-                if actor is not None:
-                    if self._colorbar_added:
-                        scalar_bar = self._renderer.plotter.scalar_bar
-                    else:
-                        scalar_bar = None
-                    _set_colormap_range(actor, ctable, scalar_bar)
-                    self._data['fmid'] = fmid
-                    self._data['ctable'] = ctable
+        ctable = self.update_lut(fmid=fmid)
+        ctable = (ctable * 255).astype(np.uint8)
+        for hemi in ['lh', 'rh']:
+            actor = self._data.get(hemi + '_actor')
+            if actor is not None:
+                if self._colorbar_added:
+                    scalar_bar = self._renderer.plotter.scalar_bar
+                else:
+                    scalar_bar = None
+                _set_colormap_range(actor, ctable, scalar_bar)
+                self._data['fmid'] = fmid
+                self._data['ctable'] = ctable
 
     def update_fmin(self, fmin):
         """Set the colorbar min point."""
         from ..backends._pyvista import _set_colormap_range
-        if fmin < self._data['fmid']:
-            ctable = self.update_lut(fmin=fmin)
-            ctable = (ctable * 255).astype(np.uint8)
-            for hemi in ['lh', 'rh']:
-                actor = self._data.get(hemi + '_actor')
-                if actor is not None:
-                    fmax = self._data['fmax']
-                    center = self._data['center']
-                    dt_max = fmax
-                    dt_min = fmin if center is None else -1 * fmax
-                    rng = [dt_min, dt_max]
-                    if self._colorbar_added:
-                        scalar_bar = self._renderer.plotter.scalar_bar
-                    else:
-                        scalar_bar = None
-                    _set_colormap_range(actor, ctable, scalar_bar, rng)
-                    self._data['fmin'] = fmin
-                    self._data['ctable'] = ctable
+        ctable = self.update_lut(fmin=fmin)
+        ctable = (ctable * 255).astype(np.uint8)
+        for hemi in ['lh', 'rh']:
+            actor = self._data.get(hemi + '_actor')
+            if actor is not None:
+                fmax = self._data['fmax']
+                center = self._data['center']
+                dt_max = fmax
+                dt_min = fmin if center is None else -1 * fmax
+                rng = [dt_min, dt_max]
+                if self._colorbar_added:
+                    scalar_bar = self._renderer.plotter.scalar_bar
+                else:
+                    scalar_bar = None
+                _set_colormap_range(actor, ctable, scalar_bar, rng)
+                self._data['fmin'] = fmin
+                self._data['ctable'] = ctable
 
     def update_fscale(self, fscale):
         """Scale the colorbar points."""

mne/viz/_brain/_timeviewer.py

@@ -50,6 +50,69 @@ def __call__(self, value):
                 slider_rep.SetValue(fmax)
 
 
+class BumpColorbarPoints(object):
+    """Class that ensure constraints over the colorbar points."""
+
+    def __init__(self, plotter=None, brain=None, name=None):
+        self.plotter = plotter
+        self.brain = brain
+        self.name = name
+        self.callback = {
+            "fmin": brain.update_fmin,
+            "fmid": brain.update_fmid,
+            "fmax": brain.update_fmax
+        }
+
+    def __call__(self, value):
+        """Update the colorbar sliders."""
+        eps = 1e-4
+        fmin = self.brain._data['fmin']
+        fmid = self.brain._data['fmid']
+        fmax = self.brain._data['fmax']
+        fmin_rep = None
+        fmid_rep = None
+        fmax_rep = None
+        for slider in self.plotter.slider_widgets:
+            name = getattr(slider, "name", None)
+            if name == "fmin":
+                fmin_rep = slider.GetRepresentation()
+            elif name == "fmid":
+                fmid_rep = slider.GetRepresentation()
+            elif name == "fmax":
+                fmax_rep = slider.GetRepresentation()
+        if self.name == "fmin" and fmin_rep is not None:
+            if value + eps > fmax:
+                fmax = value + 2 * eps
+                self.brain.update_fmax(fmax)
+                fmax_rep.SetValue(fmax)
+            if value > fmid:
+                fmid = value + eps
+                self.brain.update_fmid(fmid)
+                fmid_rep.SetValue(fmid)
+            fmin_rep.SetValue(value)
+        elif self.name == "fmid" and fmid_rep is not None:
+            if value < fmin:
+                fmin = value - eps
+                self.brain.update_fmin(fmin)
+                fmin_rep.SetValue(fmin)
+            if value > fmax:
+                fmax = value + eps
+                self.brain.update_fmax(fmax)
+                fmax_rep.SetValue(fmax)
+            fmid_rep.SetValue(value)
+        elif self.name == "fmax" and fmax_rep is not None:
+            if value - eps < fmin:
+                fmin = value - 2 * eps
+                self.brain.update_fmin(fmin)
+                fmin_rep.SetValue(fmin)
+            if value < fmid:
+                fmid = value - eps
+                self.brain.update_fmid(fmid)
+                fmid_rep.SetValue(fmid)
+            fmax_rep.SetValue(value)
+        self.callback[self.name](value)
+
+
 class _TimeViewer(object):
     """Class to interact with _Brain."""
 
@@ -122,30 +185,45 @@ def __init__(self, brain):
         # colormap slider
         scaling_limits = [0.2, 2.0]
         fmin = brain._data["fmin"]
+        update_fmin = BumpColorbarPoints(
+            plotter=self.plotter,
+            brain=brain,
+            name="fmin"
+        )
         fmin_slider = self.plotter.add_slider_widget(
-            brain.update_fmin,
+            update_fmin,
             value=fmin,
-            rng=_get_range(fmin, scaling_limits), title="fmin",
+            rng=_get_range(brain), title="fmin",
             pointa=(0.82, 0.26),
-            pointb=(0.98, 0.26)
+            pointb=(0.98, 0.26),
         )
         fmin_slider.name = "fmin"
         fmid = brain._data["fmid"]
+        update_fmid = BumpColorbarPoints(
+            plotter=self.plotter,
+            brain=brain,
+            name="fmid"
+        )
         fmid_slider = self.plotter.add_slider_widget(
-            brain.update_fmid,
+            update_fmid,
             value=fmid,
-            rng=_get_range(fmid, scaling_limits), title="fmid",
+            rng=_get_range(brain), title="fmid",
             pointa=(0.82, 0.42),
-            pointb=(0.98, 0.42)
+            pointb=(0.98, 0.42),
         )
         fmid_slider.name = "fmid"
         fmax = brain._data["fmax"]
+        update_fmax = BumpColorbarPoints(
+            plotter=self.plotter,
+            brain=brain,
+            name="fmax"
+        )
         fmax_slider = self.plotter.add_slider_widget(
-            brain.update_fmax,
+            update_fmax,
             value=fmax,
-            rng=_get_range(fmax, scaling_limits), title="fmax",
+            rng=_get_range(brain), title="fmax",
             pointa=(0.82, 0.58),
-            pointb=(0.98, 0.58)
+            pointb=(0.98, 0.58),
         )
         fmax_slider.name = "fmax"
         update_fscale = UpdateColorbarScale(
@@ -194,5 +272,7 @@ def _set_slider_style(slider, show_label=True):
         slider_rep.ShowSliderLabelOff()
 
 
-def _get_range(val, rng):
-    return [val * rng[0], val * rng[1]]
+def _get_range(brain):
+    import numpy as np
+    val = abs(brain._data['array'])
+    return [np.min(val), np.max(val)]

mne/viz/_brain/tests/test_brain.py

@@ -145,8 +145,8 @@ def test_brain_timeviewer(renderer):
 
     brain_data.set_data_smoothing(n_steps=1)
     brain_data.set_time_point(time_idx=0)
-    brain_data.update_fmax(fmax=1.0)
-    brain_data.update_fmid(fmid=0.5)
+    brain_data.update_fmax(fmax=11.0)
+    brain_data.update_fmid(fmid=5.0)
     brain_data.update_fmin(fmin=0.0)
 
     _TimeViewer(brain_data)