mwxlib 0.99.0__py3-none-any.whl → 1.7.13__py3-none-any.whl

mwx/matplot2lg.py

@@ -8,7 +8,7 @@ import wx
 from matplotlib import patches
 import numpy as np
 from scipy import signal
-## from scipy import ndimage as ndi
+from scipy import ndimage
 
 from . import framework as mwx
 from .utilus import funcall as _F
@@ -18,7 +18,7 @@ from .matplot2 import NORMAL, MARK, LINE, REGION
 
 
 class LinePlot(MatplotPanel):
-    """Line plot 1D base panel
+    """Line plot 1D base panel.
     
     region : selected range (l,r) on the plot
     """
@@ -45,7 +45,7 @@ class LinePlot(MatplotPanel):
             },
         })
         self.modeline.Show(0)
-    
+
     def clear(self):
         MatplotPanel.clear(self)
         
@@ -64,14 +64,14 @@ class LinePlot(MatplotPanel):
         #<matplotlib.patches.Rectangle>
         self.__vspan = self.axes.axvspan(0, 0,
             color='none', ls='dashed', lw=1, ec='black', visible=0, zorder=2)
-    
-    ## the limit for dragging region
+
+    ## The limit for dragging region.
     boundary = None
-    
+
     @property
     def region(self):
         return self.__region
-    
+
     @region.setter
     def region(self, v):
         if v is not None:
@@ -95,11 +95,11 @@ class LinePlot(MatplotPanel):
             self.__vspan.set_visible(0)
             self.handler('region_unset', self.frame)
         self.__region = v
-    
+
     @region.deleter
     def region(self):
         self.region = None
-    
+
     def annotate(self):
         for art in self.__annotations:
             art.remove()
@@ -116,9 +116,9 @@ class LinePlot(MatplotPanel):
             x = (b + a) / 2
             y = self.ylim[0] + 20/self.ddpu[1]
             if (b - a) > 60/self.ddpu[0]:
-                p = _A(b-a, (x,y), (-20,8), arrowstyle='-') # wide space
+                p = _A(b-a, (x,y), (-20,8), arrowstyle='-')  # wide space
             else:
-                p = _A(b-a, (x,y), (16,16), arrowstyle='-', # narrow space
+                p = _A(b-a, (x,y), (16,16), arrowstyle='-',  # narrow space
                         connectionstyle="angle,angleA=0,angleB=90,rad=8")
             self.__annotations = [
                 _A(a, (a,y), (-54,-3), arrowstyle='->'),
@@ -126,53 +126,53 @@ class LinePlot(MatplotPanel):
                 _A(None, (a,y), (b,y), textcoords='data', arrowstyle='<->'),
                 p,
             ]
-    
+
     ## --------------------------------
-    ## Motion/Drag actions (override)
+    ## Region/Drag actions (override).
     ## --------------------------------
-    
+
     def region_test(self, evt):
         if self.region is not None:
             x = evt.xdata
             a, b = self.region
             d = 4 / self.ddpu[0]
-            if   a+d < x < b-d: return 1 # insdie
-            elif a-d < x < a+d: return 2 # left-edge
-            elif b-d < x < b+d: return 3 # right-edge
-            else: return 0 # outside
-    
+            if   a+d < x < b-d: return 1  # insdie
+            elif a-d < x < a+d: return 2  # left-edge
+            elif b-d < x < b+d: return 3  # right-edge
+            else: return 0  # outside
+
     def OnDraw(self, evt):
         """Called before canvas.draw."""
         self.annotate()
-    
+
     def OnMotion(self, evt):
         MatplotPanel.OnMotion(self, evt)
         
         v = self.region_test(evt)
         if v == 1:
-            self.set_wxcursor(wx.CURSOR_HAND) # insdie
+            self.set_wxcursor(wx.CURSOR_HAND)  # insdie
         elif v in (2,3):
-            self.set_wxcursor(wx.CURSOR_SIZEWE) # on-edge
+            self.set_wxcursor(wx.CURSOR_SIZEWE)  # on-edge
         else:
-            self.set_wxcursor(wx.CURSOR_ARROW) # outside or None
-    
+            self.set_wxcursor(wx.CURSOR_ARROW)  # outside or None
+
     def OnDragLock(self, evt):
         self.__lastpoint = evt.xdata
         self.__selection = self.region_test(evt)
-    
+
     def OnDragBegin(self, evt):
         v = self.__selection
         if v == 1:
-            self.set_wxcursor(wx.CURSOR_HAND) # inside
+            self.set_wxcursor(wx.CURSOR_HAND)  # inside
         elif v == 2:
-            self.set_wxcursor(wx.CURSOR_SIZEWE) # left-edge
-            self.__lastpoint = self.region[1]   # set origin right
+            self.set_wxcursor(wx.CURSOR_SIZEWE)  # left-edge
+            self.__lastpoint = self.region[1]    # set origin right
         elif v == 3:
-            self.set_wxcursor(wx.CURSOR_SIZEWE) # right-edge
-            self.__lastpoint = self.region[0]   # set origin left
+            self.set_wxcursor(wx.CURSOR_SIZEWE)  # right-edge
+            self.__lastpoint = self.region[0]    # set origin left
         else:
-            self.set_wxcursor(wx.CURSOR_SIZEWE) # outside
-    
+            self.set_wxcursor(wx.CURSOR_SIZEWE)  # outside
+
     def OnDragMove(self, evt):
         x = evt.xdata
         if self.__selection != 1:
@@ -196,12 +196,12 @@ class LinePlot(MatplotPanel):
                 self.region = (a+d, b+d)
                 self.__lastpoint = x
         else:
-            self.message("- No region.") #<FSM logic-error>
+            self.message("- No region.")  #<FSM logic-error>
         self.draw()
-    
+
     def OnDragEnd(self, evt):
         self.set_wxcursor(wx.CURSOR_ARROW)
-    
+
     def OnEscapeSelection(self, evt):
         MatplotPanel.OnEscapeSelection(self, evt)
         
@@ -211,23 +211,19 @@ class LinePlot(MatplotPanel):
 
 
 class Histogram(LinePlot):
-    """LinePlot panel for histogram (Multi-graph : Single-frame)
-    
-    frame.image <uint8> (buffer ではない) を参照して，ヒストグラムをプロットする
-    常に整数ビット画像となるので，高速なビンづめ法で計算する
+    """LinePlot panel for histogram (Multi-graph : Single-frame).
     
-    Attributes:
-       __graphs : list of attached graph <matplot2g.GraphPlot>
-        __frame : reference to the current frame
+    frame.image <uint8> (buffer ではない) を参照して，ヒストグラムをプロットする．
+    常に整数ビット画像となるので，高速なビンづめ法で計算する．
     """
     def __init__(self, *args, **kwargs):
         LinePlot.__init__(self, *args, **kwargs)
         
         self.handler.update({ # DNA<Histogram>
             NORMAL : {
-                 'ctrl pressed' : (NORMAL, ), # Pan prohibits
-                'space pressed' : (NORMAL, ), # 〃
-                    'z pressed' : (NORMAL, ), # Zoom prohibits
+                 'ctrl pressed' : (NORMAL, ),  # Pan prohibits
+                'space pressed' : (NORMAL, ),  # 〃
+                    'z pressed' : (NORMAL, ),  # Zoom prohibits
             },
         })
         self.context = { # DNA<GraphPlot>
@@ -240,17 +236,17 @@ class Histogram(LinePlot):
         self.modeline.Show(0)
         
         self.Bind(wx.EVT_WINDOW_DESTROY, self.OnDestroy)
-    
+
     def OnDestroy(self, evt):
-        for graph in self.__graphs:
-            self.detach(graph)
+        for view in self.__views:
+            self.detach(view)
         evt.Skip()
-    
+
     def clear(self):
         LinePlot.clear(self)
         
-        self.__graphs = []
-        self.__frame = None
+        self.__views = []    # A list of attached view <matplot2g.GraphPlot>.
+        self.__frame = None  # Reference to the current frame.
         
         #<matplotlib.lines.Line2D>
         self.__plot, = self.axes.plot([], [], lw=1, color='c', alpha=1)
@@ -258,56 +254,54 @@ class Histogram(LinePlot):
         #<matplotlib.patches.Polygon>
         self.__fil = patches.Polygon([(0,0)], color='c', alpha=1)
         self.axes.add_patch(self.__fil)
-    
-    def attach(self, *graphs):
-        for graph in graphs:
-            if graph not in self.__graphs:
-                self.__graphs.append(graph)
-                graph.handler.append(self.context)
-    
-    def detach(self, *graphs):
-        for graph in graphs:
-            if graph in self.__graphs:
-                self.__graphs.remove(graph)
-                graph.handler.remove(self.context)
-    
+
+    def attach(self, *views):
+        for view in views:
+            if view not in self.__views:
+                self.__views.append(view)
+                view.handler.append(self.context)
+
+    def detach(self, *views):
+        for view in views:
+            if view in self.__views:
+                self.__views.remove(view)
+                view.handler.remove(self.context)
+
     @property
     def boundary(self):
-        return [0,255]
-    
+        return [0, 255]
+
     def calc(self, frame):
         BINS = 256
         img = frame.image
         if img.dtype == np.uint8:
-            ## 整数ビット画像は，高速なビンづめ法で計算する
+            ## 整数ビット画像は，高速なビンづめ法で計算する．
             hist = np.bincount(img.ravel(), minlength=BINS)
             bins = np.arange(BINS)
         else:
-            ## hist は [min:max] 段階 (256 BINS) で保持されている
-            ## bins は 端数含め [0:BINS] (257 コ) あるので１個減す
+            ## hist は [min:max] 段階 (256 BINS) で保持されている．
+            ## bins は 端数含め [0:BINS] (257 コ) あるので１個減す．
             hist, bins = np.histogram(img, BINS)
             bins = np.linspace(img.min(), img.max(), BINS)
         return bins, hist
-    
+
     def hplot(self, frame):
-        self.__frame = frame # update reference of the frame
+        self.__frame = frame  # Update reference of the frame.
         if frame:
-            x, y = frame.__data = self.calc(frame) # histogram_data buffer
+            x, y = frame.__data = self.calc(frame)  # histogram_data buffer
             self.__plot.set_data(x, y)
             self.xlim = x.min(), x.max()
             self.ylim = 0, y.max()
             self.region = None
-            self.toolbar.update()
-            self.toolbar.push_current()
             self.draw()
-    
+
     def hreplot(self, frame):
-        self.__frame = frame # update reference of the frame
+        self.__frame = frame  # Update reference of the frame.
         if frame:
             try:
-                x, y = frame.__data # reuse cached data
+                x, y = frame.__data  # Reuse cached data.
             except Exception:
-                x, y = frame.__data = self.calc(frame) # new histogram_data buffer
+                x, y = frame.__data = self.calc(frame)  # new histogram_data buffer
             
             self.__plot.set_data(x, y)
             self.xlim = x.min(), x.max()
@@ -322,10 +316,8 @@ class Histogram(LinePlot):
             self.__plot.set_data([], [])
             self.region = None
         
-        self.toolbar.update()
-        self.toolbar.push_current()
         self.draw()
-    
+
     def writeln(self):
         if not self.modeline.IsShown():
             return
@@ -343,11 +335,11 @@ class Histogram(LinePlot):
                 ))
         else:
             self.modeline.SetLabel("")
-    
+
     ## --------------------------------
-    ## Motion/Drag actions (override)
+    ## Region/Drag actions (override).
     ## --------------------------------
-    
+
     def annotate(self):
         if self.__frame:
             x, y = self.__frame.__data
@@ -356,24 +348,24 @@ class Histogram(LinePlot):
                     i, j = x.searchsorted(self.region)
                 else:
                     i, j = (0, -1)
-                self.__fil.set_xy(list(chain([(x[i],0)], zip(x[i:j],y[i:j]), [(x[j-1],0)])))
+                self.__fil.set_xy(list(chain([(x[i], 0)], zip(x[i:j], y[i:j]), [(x[j-1], 0)])))
             else:
                 self.__fil.set_xy([(0,0)])
         else:
             self.__fil.set_xy([(0,0)])
         self.writeln()
-    
+
     def OnDragEnd(self, evt):
         LinePlot.OnDragEnd(self, evt)
         
         if self.__frame:
-            self.xbound = self.region # 拡大表示したのち region 消去
+            self.xbound = self.region  # 拡大表示したのち region 消去
             self.region = None
             self.toolbar.push_current()
             self.draw()
             self.__frame.clim = self.xlim
             self.__frame.parent.draw()
-    
+
     def OnEscapeSelection(self, evt):
         LinePlot.OnEscapeSelection(self, evt)
         
@@ -384,13 +376,7 @@ class Histogram(LinePlot):
 
 
 class LineProfile(LinePlot):
-    """LinePlot panel for line profile (Multi-graph : Single-frame)
-    
-    Attributes:
-       __graphs : list of attached graph <matplot2g.GraphPlot>
-        __frame : reference to the current frame
-       __logicp : line axis in logical unit
-    __linewidth : line width to integrate [pixel]
+    """LinePlot panel for line profile (Multi-graph : Single-frame).
     """
     def __init__(self, *args, **kwargs):
         LinePlot.__init__(self, *args, **kwargs)
@@ -399,8 +385,8 @@ class LineProfile(LinePlot):
             None : {
                  'left pressed' : [ None, self.OnRegionShift ],
                 'right pressed' : [ None, self.OnRegionShift ],
-                 '[+-] pressed' : [ None, self.OnLineWidth ], # [+-] using numpad
-               'S-[;-] pressed' : [ None, self.OnLineWidth ], # [+-] using JP-keyboard
+                 '[+-] pressed' : [ None, self.OnLineWidth ],  # [+-] using numpad
+               'S-[;-] pressed' : [ None, self.OnLineWidth ],  # [+-] using JP-keyboard
             },
             NORMAL : {
             'S-Lbutton pressed' : (LINE, self.OnDragLock, self.OnRegionLock),
@@ -441,7 +427,7 @@ class LineProfile(LinePlot):
                    'line_moved' : [ None, _F(self.linplot, fit=0) ],
                   'frame_shown' : [ None, _F(self.linplot, fit=0) ],
                'frame_modified' : [ None, _F(self.linplot, fit=0) ],
-               'frame_selected' : [ None, _F(self.linplot, fit=0, force=0) ],
+               'frame_selected' : [ None, _F(self.linplot, fit=1, force=0) ],
             }
         }
         self.modeline.Show(1)
@@ -460,17 +446,17 @@ class LineProfile(LinePlot):
         ]
         
         self.Bind(wx.EVT_WINDOW_DESTROY, self.OnDestroy)
-    
+
     def OnDestroy(self, evt):
-        for graph in self.__graphs:
-            self.detach(graph)
+        for view in self.__views:
+            self.detach(view)
         evt.Skip()
-    
+
     def clear(self):
         LinePlot.clear(self)
         
-        self.__graphs = []
-        self.__frame = None
+        self.__views = []    # A list of attached view <matplot2g.GraphPlot>.
+        self.__frame = None  # Reference to the current frame.
         
         #<matplotlib.lines.Line2D>
         self.__plot, = self.axes.plot([], [], lw=0.1, color='c', alpha=1,
@@ -484,27 +470,27 @@ class LineProfile(LinePlot):
         self.__hline = self.axes.axhline(0, color='gray', ls='dashed', lw=1,
                                          visible=0, zorder=2)
         
-        self.__linewidth = 1
-        self.__logicp = True
+        self.__linewidth = 1  # Line width to integrate [pixel].
+        self.__logicp = True  # Line axis in logical unit.
         
         self.selected.set_linestyle('')
-    
-    def attach(self, *graphs):
-        for graph in graphs:
-            if graph not in self.__graphs:
-                self.__graphs.append(graph)
-                graph.handler.append(self.context)
-    
-    def detach(self, *graphs):
-        for graph in graphs:
-            if graph in self.__graphs:
-                self.__graphs.remove(graph)
-                graph.handler.remove(self.context)
-    
+
+    def attach(self, *views):
+        for view in views:
+            if view not in self.__views:
+                self.__views.append(view)
+                view.handler.append(self.context)
+
+    def detach(self, *views):
+        for view in views:
+            if view in self.__views:
+                self.__views.remove(view)
+                view.handler.remove(self.context)
+
     def set_logic(self, p):
         prep = self.__logicp
         self.__logicp = p = bool(p)
-        if self.__frame and prep != p: # replot if toggled
+        if self.__frame and prep != p:  # Replot if toggled.
             u = self.__frame.unit
             ru = u if p else 1/u
             self.xlim *= ru
@@ -512,60 +498,60 @@ class LineProfile(LinePlot):
             self.__plot.set_xdata(x * ru)
             if self.region is not None:
                 self.region *= ru
-            sel = self.Selector
-            self.Selector = (sel[0] * ru, sel[1])
+            sel = self.selector
+            self.selector = (sel[0] * ru, sel[1])
             self.draw()
-    
+
     def set_linewidth(self, w):
         if 0 < w < 256:
             self.__linewidth = w
         if self.__frame:
             self.linplot(self.__frame, fit=0)
         self.writeln()
-    
+
     @property
     def boundary(self):
         x = self.__plot.get_xdata(orig=0)
         if x.size:
             return x[[0,-1]]
-    
+
     @property
     def plotdata(self):
         """Plotted (xdata, ydata) in single plot."""
         return self.__plot.get_data(orig=0)
-    
+
     def calc_average(self):
-        X, Y = self.plotdata
+        x, y = self.plotdata
         if self.region is not None:
             a, b = self.region
-            Y = Y[(a <= X) & (X <= b)]
-        if Y.size:
-            return Y.mean()
-    
+            y = y[(a <= x) & (x <= b)]
+        if y.size:
+            return y.mean()
+
     def linplot(self, frame, fit=True, force=True):
         if not force:
             if frame is self.__frame:
                 return
-        self.__frame = frame # update reference of the frame
+        self.__frame = frame  # Update reference of the frame.
         if frame:
             sel = frame.selector
             if sel.shape[1] < 2:
                 return
-            if len(frame.buffer.shape) > 2: # RGB image
+            if len(frame.buffer.shape) > 2:  # RGB image
                 return
             
-            xx, yy = sel[:,-2:] # get the last 2-selected line
-            nx, ny = frame.xytopixel(xx, yy) # converts to pixel [ny,nx]
+            xx, yy = sel[:,-2:]  # Get the last 2-selected line.
+            nx, ny = frame.xytopixel(xx, yy)  # Converts to pixel [ny,nx]
             lx = nx[1] - nx[0]
             ly = ny[1] - ny[0]
             if lx or ly:
-                L = np.hypot(lx, ly) # pixel length
-                nv = (-ly/L, lx/L)   # and norm vector to L
+                L = np.hypot(lx, ly)  # pixel length
+                nv = (-ly/L, lx/L)    # and norm vector to L
             else:
                 L = 0
                 nv = (0, 0)
             
-            ## ピクセル空間：長さ L, サイズ N 分割でラインプロファイルをとる
+            ## ピクセル空間：長さ L, サイズ N 分割でラインプロファイルをとる．
             lw = self.__linewidth
             N = int(L) + 1
             xs = np.linspace(nx[0], nx[1], N)
@@ -579,29 +565,27 @@ class LineProfile(LinePlot):
                 if any(mask):
                     x = x[mask]
                     y = y[mask]
-                    zi = frame.buffer[y.astype(int), x.astype(int)] # nearest: 速くてそこそこ正確
-                    ## zi = ndi.map_coordinates(frame.buffer, np.vstack((y, x))) # spline: 遅いが正確
+                    zi = frame.buffer[y.astype(int), x.astype(int)]  # nearest: 速くてそこそこ正確
+                    # zi = ndimage.map_coordinates(frame.buffer, np.vstack((y, x)))  # spline: 遅いが正確
                     if zi.dtype in (np.complex64, np.complex128):
                         zi = np.log(1 + abs(zi))
                     zs[mask] += zi
             zs /= lw
             
-            if self.__logicp: # axis to logical length # 論理長さ空間を使用する
+            if self.__logicp:  # axis to logical length  # 論理長さ空間を使用する
                 L = np.hypot(xx[1]-xx[0], yy[1]-yy[0])
             
             ls = np.linspace(0, L, N)
             self.__plot.set_data(ls, zs)
             self.__plot.set_visible(1)
             
-            if fit and len(ls) > 1: # drawing area
+            if fit and len(ls) > 1:  # drawing area
                 ly = self.ylim
                 self.xlim = ls[0], ls[-1]
                 self.ylim = ly[0], max(ly[1], max(zs))
-            
-        self.toolbar.update()
-        self.toolbar.push_current()
+        
         self.draw()
-    
+
     def writeln(self):
         if not self.modeline.IsShown():
             return
@@ -609,7 +593,7 @@ class LineProfile(LinePlot):
         if frame:
             self.modeline.SetLabel(
                 "[--] -{a}- {name} ({type}:{mode}) "
-                "[{length}:{width}] {x} [{unit:g}/pixel]".format(
+                "[{length}:{width}] {x} [{unit:g}/pix]".format(
                 name = frame.name,
                 type = frame.buffer.dtype,
                 mode = "logic" if self.__logicp else "pixel",
@@ -620,7 +604,7 @@ class LineProfile(LinePlot):
                    a = '%%' if not frame.buffer.flags.writeable else '--'))
         else:
             self.modeline.SetLabel("")
-    
+
     def write_data_to_clipboard(self):
         """Write plot data to clipboard."""
         X, Y = self.plotdata
@@ -629,71 +613,85 @@ class LineProfile(LinePlot):
                 o.write("{:g}\t{:g}\n".format(x, y))
             Clipboard.write(o.getvalue())
             self.message("Write data to clipboard.")
-    
+
     def annotate(self):
         LinePlot.annotate(self)
         
         x, y = self.plotdata
         if x.size:
-            self.__fil.set_xy(list(chain([(x[0],0)], zip(x,y), [(x[-1],0)])))
+            self.__fil.set_xy(list(chain([(x[0], 0)], zip(x, y), [(x[-1], 0)])))
         self.writeln()
-    
+
     ## --------------------------------
-    ## Motion/Drag actions (override)
+    ## Region/Drag actions (override).
     ## --------------------------------
-    
+
+    def OnHomePosition(self, evt):
+        """Go back to home position."""
+        x, y = self.plotdata
+        if x.size and y.size:
+            self.xlim = x[0], x[-1]
+            self.ylim = 0, y.max()
+            self.toolbar.update()
+            self.toolbar.push_current()
+            self.draw()
+
     def OnHomeXPosition(self, evt):
         x = self.plotdata[0]
         if x.size:
             self.xlim = x[0], x[-1]
             self.toolbar.push_current()
             self.draw()
-    
+
     def OnHomeYPosition(self, evt):
         y = self.plotdata[1]
         if y.size:
             self.ylim = 0, y.max()
             self.toolbar.push_current()
             self.draw()
-    
+
     def OnLineWidth(self, evt):
         n = -2 if evt.key[-1] == '-' else 2
         self.set_linewidth(self.__linewidth + n)
-    
+
     def OnRegionShift(self, evt):
         if self.__frame and self.region is not None:
             u = self.__frame.unit
             if evt.key == "left": self.region -= u
             if evt.key == "right": self.region += u
             self.draw()
-    
+
     def OnEscapeSelection(self, evt):
         self.__hline.set_visible(0)
         LinePlot.OnEscapeSelection(self, evt)
-    
+
+    ## --------------------------------
+    ## Region-(H)Line/Drag actions.
+    ## --------------------------------
+
     def OnDragLineBegin(self, evt):
         self.set_wxcursor(wx.CURSOR_SIZENS)
-    
+
     def OnDragTrace(self, evt):
         """Show average value."""
         y = self.calc_average()
         if y is not None:
             self.message(f"ya = {y:g}")
-    
+
     def OnRegionLock(self, evt):
         """Show FWHM region."""
         x, y = self.plotdata
         if x.size:
             xc, yc = evt.xdata, evt.ydata
-            u = x[1] - x[0] # != frame.unit (斜め線の場合 dx=unit とは限らない)
+            u = x[1] - x[0]  # != frame.unit (斜め線の場合 dx=unit とは限らない)
             v = (y < yc)
             if v.all():
-                self.region = None # all y < yc
+                self.region = None  # all y < yc
             elif v.any():
                 xa = x[(x < xc) & v]
                 xb = x[(x > xc) & v]
-                a = xa[-1] if xa.any() else x[ 0] # left-under bound
-                b = xb[ 0] if xb.any() else x[-1] # right-over bound
+                a = xa[-1] if xa.any() else x[ 0]  # left-under bound
+                b = xb[ 0] if xb.any() else x[-1]  # right-over bound
                 if (b-a-u)/u > 1e-3:
                     if a > x[0]:
                         n = np.where(x == a)[0][0]
@@ -707,39 +705,48 @@ class LineProfile(LinePlot):
                 else:
                     self.region = None
             else:
-                self.region = x[[0,-1]] # all y > yc
+                self.region = x[[0,-1]]  # all y > yc
             
             self.__hline.set_ydata([yc])
             self.__hline.set_visible(1)
             self.draw()
             self.message(f"yc = {yc:g}")
-    
+
+    ## --------------------------------
+    ## Region-Mark/Drag actions.
+    ## --------------------------------
+    peak_blur_ratio = 0.01
+    peak_prominence_ratio = 0.1
+
     def OnMarkPeaks(self, evt):
         """Set markers on peaks."""
         x, y = self.plotdata
-        if x.size:
-            lw = 5
-            window = np.hanning(lw)
-            ys = np.convolve(window/window.sum(), y, mode='same')
-            
-            ## maxima = signal.find_peaks_cwt(ys, np.arange(lw,lw*2))
-            maxima,_ = signal.find_peaks(ys, width=lw, prominence=20)
+        if x.size > 1:
+            # lw = 5
+            ux = x[1] - x[0]  # equal spacing length
+            lw = max(1, self.peak_blur_ratio * (self.xbound[1] - self.xbound[0]) / ux)
+            lp = self.peak_prominence_ratio * (self.ybound[1] - self.ybound[0])
+            # window = np.hanning(lw)
+            # window = signal.windows.gaussian(lw, std=lw/6)
+            # ys = np.convolve(window/window.sum(), y, mode='same')
+            ys = ndimage.gaussian_filter1d(y, sigma=lw/6)
             
-            ## minima = signal.find_peaks_cwt(-ys, np.arange(lw,lw*2))
-            minima,_ = signal.find_peaks(-ys, width=lw, prominence=20)
+            maxima, _ = signal.find_peaks(ys, prominence=lp)
+            minima, _ = signal.find_peaks(-ys, prominence=lp)
             
             peaks = np.sort(np.append(maxima, minima))
             if peaks.size:
-                self.Selector = x[peaks], y[peaks]
-    
+                self.selector = x[peaks], y[peaks]
+            self.message(f"Peak detection: blur {lw=:g}, prom {lp=:g}")
+
     def OnMarkErase(self, evt):
         """Erase markers on peaks."""
-        ## del self.Selector
+        ## del self.selector
         self.OnEscapeSelection(evt)
-    
+
     def OnMarkSelectionBegin(self, evt):
         org = self.p_event
-        xs, ys = self.Selector
+        xs, ys = self.selector
         xc, yc = org.xdata, org.ydata
         ## xc, yc = evt.xdata, evt.ydata
         if xs.size:
@@ -748,14 +755,16 @@ class LineProfile(LinePlot):
             self.__orgpoint = xs[j]
         self.set_wxcursor(wx.CURSOR_SIZEWE)
         self.draw()
-    
+
     def OnMarkSelectionMove(self, evt):
-        xs, ys = self.Selector
+        xs, ys = self.selector
         xc, yc = evt.xdata, evt.ydata
         if xs.size:
             ld = np.hypot((xs-xc)*self.ddpu[0], (ys-yc)*self.ddpu[1])
             j = np.argmin(ld)
-            if ld[j] < 20: # check display-dot distance, snap to the nearest mark
+            if ld[j] < 20:  # check display-dot distance, snap to the nearest mark
                 xc = xs[j]
+                yc = ys[j]
+                self.message(f"({xc:g}, {yc:g})")
             self.region = (self.__orgpoint, xc)
             self.draw()