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

mwx/matplot2g.py

@@ -13,7 +13,6 @@ from scipy import ndimage as ndi
 
 from . import framework as mwx
 from .framework import Menu
-# from .utilus import warn
 from .utilus import funcall as _F
 from .controls import Clipboard
 from .matplot2 import MatplotPanel
@@ -125,30 +124,35 @@ class AxesImagePhantom:
         **kwargs: frame attributes
     
     Note:
-        Due to the problem of performance,
-        the image pixel size could be reduced by binning.
+        Due to the problem of performance, the image pixel size could be reduced by binning.
     """
     def __init__(self, parent, buf, name, show=True, **kwargs):
         self.parent = parent
+        
+        ## Properties of the frame/image.
         self.__name = name
         self.__attributes = kwargs
+        self.__pathname = kwargs.get('pathname')
+        self.__annotation = kwargs.get('annotation', '')
         self.__localunit = kwargs.get('localunit')
-        self.__center = kwargs.get('center', (0, 0))
-        self.__aspect_ratio = 1
+        self.__center = kwargs.get('center', [0, 0])
+        
+        ## Conditions for image loading.
         self.__buf = _to_buffer(buf)
         bins, vlim, img = _to_image(self.__buf,
-                cutoff = self.parent.score_percentile,
-             threshold = self.parent.nbytes_threshold,
-        )
+                                    cutoff=self.parent.score_percentile,
+                                    threshold=self.parent.nbytes_threshold,
+                                    )
         self.__bins = bins
         self.__cuts = vlim
         self.__art = parent.axes.imshow(img,
-                  cmap = cm.gray,
-                aspect = 'equal',
-         interpolation = 'nearest',
-               visible = show,
-                picker = True,
-        )
+                                        cmap=cm.gray,
+                                        aspect='equal',  # cf. aspect_ratio => xy_unit
+                                        interpolation='nearest',
+                                        visible=show,
+                                        picker=True,
+                                        )
+        self.aspect_ratio = 1
         self.update_extent()
 
     def __getattr__(self, attr):
@@ -159,29 +163,47 @@ class AxesImagePhantom:
         return x is self.__art
 
     def update_attr(self, attr):
-        """Update frame-specifc attributes:
-        
-            annotation : aux info (also displayed as a message in the infobar)
-            center     : frame.center defaults to (0, 0)
-            localunit  : frame.unit
-            pathname   : full path of the buffer file
-        """
+        """Update frame-specifc attributes."""
         if not attr:
             return
-        self.__attributes.update(attr)
         
-        if 'localunit' in attr:
-            self.unit = attr['localunit']  # => [frame_updated]
-        
-        if 'center' in attr:
-            self.center = attr['center']  # => [frame_updated]
+        FLAG_ANNOTATION = 1
+        FLAG_UPDATE_EXTENT = 2
+        flag = 0
+        if 'pathname' in attr:
+            self.__pathname = attr['pathname']
+            flag |= FLAG_ANNOTATION
         
         if 'annotation' in attr:
-            v = attr['annotation']
+            self.__annotation = attr['annotation']
             if self.parent.frame is self:
-                self.parent.infobar.ShowMessage(v)
+                self.parent.infobar.ShowMessage(attr['annotation'])
+            flag |= FLAG_ANNOTATION
+        
+        if 'center' in attr:
+            v = list(attr['center'])  # for json format
+            if v != self.__center:
+                self.__center = v
+                flag |= FLAG_UPDATE_EXTENT
+        
+        if 'localunit' in attr:
+            v = attr['localunit']
+            if v is None or np.isnan(v):  # nan => None: undefined.
+                v = None
+            elif np.isinf(v):
+                raise ValueError("The unit value must not be inf")
+            elif v <= 0:
+                raise ValueError("The unit value must be greater than zero")
+            if v != self.__localunit:
+                self.__localunit = v
+                flag |= FLAG_UPDATE_EXTENT
+        
+        self.__attributes.update(attr)
         
-        if {'pathname', 'annotation'} & attr.keys():
+        if flag & FLAG_UPDATE_EXTENT:
+            self.update_extent()
+            self.parent.canvas.draw_idle()
+        if flag:
             self.parent.handler('frame_updated', self)
 
     def update_buffer(self, buf=None):
@@ -190,9 +212,9 @@ class AxesImagePhantom:
             self.__buf = _to_buffer(buf)
         
         bins, vlim, img = _to_image(self.__buf,
-                cutoff = self.parent.score_percentile,
-             threshold = self.parent.nbytes_threshold,
-        )
+                                    cutoff = self.parent.score_percentile,
+                                    threshold = self.parent.nbytes_threshold,
+                                    )
         self.__bins = bins
         self.__cuts = vlim
         self.__art.set_array(img)
@@ -232,80 +254,44 @@ class AxesImagePhantom:
         doc="Auxiliary info about the frame.")
 
     pathname = property(
-        lambda self: self.__attributes.get('pathname'),
+        lambda self: self.__pathname,
         lambda self, v: self.update_attr({'pathname': v}),
         doc="Fullpath of the buffer, if bound to a file.")
 
     annotation = property(
-        lambda self: self.__attributes.get('annotation', ''),
+        lambda self: self.__annotation,
         lambda self, v: self.update_attr({'annotation': v}),
         doc="Annotation of the buffer.")
 
-    @property
-    def name(self):
-        return self.__name
+    center = property(
+        lambda self: self.__center,
+        lambda self, v: self.update_attr({'center': v}),
+        doc="Center coordinates of the frame in logical units.")
 
-    @name.setter
-    def name(self, v):
-        self.__name = v
-        self.parent.handler('frame_updated', self)
+    localunit = property(
+        lambda self: self.__localunit,
+        lambda self, v: self.update_attr({'localunit': v}),
+        doc="Logical length per pixel in arbitrary units [u/pix], or None if not assigned.")
 
-    @property
-    def localunit(self):
-        return self.__localunit
-
-    @property
-    def unit(self):
-        """Logical length per pixel arb.unit [u/pix]."""
-        return self.__localunit or self.parent.unit
-
-    @unit.setter
-    def unit(self, v):
-        if v == self.__localunit:  # no effect
-            return
-        if v is None or np.isnan(v):  # nan => undefined
-            v = None
-        elif np.isinf(v):
-            raise ValueError("The unit value must not be inf")
-        elif v <= 0:
-            raise ValueError("The unit value must be greater than zero")
-        
-        self.__localunit = v
-        self.__attributes['localunit'] = self.__localunit
-        self.update_extent()
-        self.parent.handler('frame_updated', self)
-        self.parent.canvas.draw_idle()
-
-    @unit.deleter
-    def unit(self):
-        self.unit = None
+    unit = property(
+        lambda self: self.__localunit or self.parent.unit,
+        lambda self, v: self.update_attr({'localunit': v}),
+        doc="Logical length per pixel in arbitrary units [u/pix].")
 
     @property
     def xy_unit(self):
-        u = self.__localunit or self.parent.unit
-        return (u, u * self.__aspect_ratio)
-
-    @property
-    def center(self):
-        """Center of logical unit."""
-        return self.__center
-
-    @center.setter
-    def center(self, v):
-        self.__center = tuple(v)
-        self.__attributes['center'] = self.__center
-        self.update_extent()
-        self.parent.handler('frame_updated', self)
+        """Logical length per pixel in arbitrary units [u/pix] for (X, Y) directions."""
+        u = self.unit
+        r = self.aspect_ratio
+        return (u, u) if r == 1 else (u, u * r)
 
     @property
-    def aspect_ratio(self):
-        """Aspect ratio of logical unit."""
-        return self.__aspect_ratio
+    def name(self):
+        return self.__name
 
-    @aspect_ratio.setter
-    def aspect_ratio(self, v):
-        self.__aspect_ratio = v or 1
-        self.update_extent()
+    @name.setter
+    def name(self, v):
+        self.__name = v
         self.parent.handler('frame_updated', self)
 
     @property
@@ -317,7 +303,7 @@ class AxesImagePhantom:
     def roi(self):
         """Current buffer ROI (region of interest)."""
         if self.parent.region.size:
-            nx, ny = self.xytopixel(*self.region)
+            nx, ny = self.xytopixel(self.region)
             sx = slice(max(0, nx[0]), nx[1])  # nx slice
             sy = slice(max(0, ny[1]), ny[0])  # ny slice 反転 (降順)
             return self.__buf[sy, sx]
@@ -326,7 +312,7 @@ class AxesImagePhantom:
     @roi.setter
     def roi(self, v):
         if not self.parent.region.size:
-             raise ValueError("region is not selected.")
+            raise ValueError("region is not selected.")
         self.roi[:] = v  # cannot broadcast input array into different shape
         self.update_buffer()
 
@@ -393,43 +379,31 @@ class AxesImagePhantom:
 
     @property
     def selector_pix(self):
-        """Selected points array [[x],[y]] in pixels."""
+        """Selected points array [[x], [y]] in pixels."""
         return self.xytopixel(self.selector)
 
     @selector_pix.setter
     def selector_pix(self, v):
         self.selector = self.xyfrompixel(v)
 
-    @selector_pix.deleter
-    def selector_pix(self):
-        del self.selector
-
     @property
     def markers_pix(self):
-        """Marked points data array [[x],[y]] in pixels."""
+        """Marked points data array [[x], [y]] in pixels."""
         return self.xytopixel(self.markers)
 
     @markers_pix.setter
     def markers_pix(self, v):
         self.markers = self.xyfrompixel(v)
 
-    @markers_pix.deleter
-    def markers_pix(self):
-        del self.markers
-
     @property
     def region_pix(self):
-        """Cropped points data array [l,r],[b,t] in pixels."""
+        """Cropped points data array [[l,r], [b,t]] in pixels."""
         return self.xytopixel(self.region)
 
     @region_pix.setter
     def region_pix(self, v):
         self.region = self.xyfrompixel(v)
 
-    @region_pix.deleter
-    def region_pix(self):
-        del self.region
-
 
 class GraphPlot(MatplotPanel):
     """Graph panel for 2D graph.
@@ -440,41 +414,41 @@ class GraphPlot(MatplotPanel):
         def _draw(evt):
             self.canvas.draw_idle()
         
-        self.handler.update({ # DNA<GraphPlot>
+        self.handler.update({  # DNA<GraphPlot>
             None : {
-                  'frame_shown' : [ None ],  # show
-                 'frame_hidden' : [ None ],  # show
-                 'frame_loaded' : [ None ],  # load
-                'frame_removed' : [ None ],  # del[] ! event arg is indices, not frames.
-               'frame_selected' : [ None ],  # = focus_set
-             'frame_deselected' : [ None ],  # = focus_kill
-               'frame_modified' : [ None, _F(self.writeln) ],  # set[],load,roi  => update_buffer
-                'frame_updated' : [ None, _F(self.writeln) ],  # unit,name,ratio => update_extent
-                'frame_cmapped' : [ None, _F(self.writeln) ],  # cmap
-                    'line_draw' : [ None ],
-                   'line_drawn' : [ None, _draw ],
-                    'line_move' : [ None ],
-                   'line_moved' : [ None, _draw ],
-                 'line_removed' : [ None, _draw ],
-                    'mark_draw' : [ None ],
-                   'mark_drawn' : [ None, _draw ],
-                 'mark_removed' : [ None, _draw ],
-                  'region_draw' : [ None ],
-                 'region_drawn' : [ None, _draw ],
-               'region_removed' : [ None, _draw ],
-                 'M-up pressed' : [ None, self.OnPageUp ],
-               'M-down pressed' : [ None, self.OnPageDown ],
-               'pageup pressed' : [ None, self.OnPageUp ],
-             'pagedown pressed' : [ None, self.OnPageDown ],
-                 'home pressed' : [ None, _F(self.select, index=0) ],
-                  'end pressed' : [ None, _F(self.select, index=-1) ],
-                  'M-a pressed' : [ None, _F(self.fit_to_canvas) ],
-                  'C-a pressed' : [ None, _F(self.fit_to_axes) ],
-                  'C-i pressed' : [ None, _F(self.invert_cmap) ],
-                  'C-k pressed' : [ None, _F(self.kill_buffer) ],
-                'C-S-k pressed' : [ None, _F(self.kill_buffer_all) ],
-                  'C-c pressed' : [ None, _F(self.write_buffer_to_clipboard) ],
-                  'C-v pressed' : [ None, _F(self.read_buffer_from_clipboard) ],
+                  'frame_shown' : [None, ],  # show
+                 'frame_hidden' : [None, ],  # show
+                 'frame_loaded' : [None, ],  # load
+                'frame_removed' : [None, ],  # del[] ! event arg is indices, not frames.
+               'frame_selected' : [None, ],  # = focus_set
+             'frame_deselected' : [None, ],  # = focus_kill
+               'frame_modified' : [None, _F(self.writeln)],  # set[],load,roi  => update_buffer
+                'frame_updated' : [None, _F(self.writeln)],  # unit,name,ratio => update_extent
+                'frame_cmapped' : [None, _F(self.writeln)],  # cmap
+                    'line_draw' : [None, ],
+                   'line_drawn' : [None, _draw],
+                    'line_move' : [None, ],
+                   'line_moved' : [None, _draw],
+                 'line_removed' : [None, _draw],
+                    'mark_draw' : [None, ],
+                   'mark_drawn' : [None, _draw],
+                 'mark_removed' : [None, _draw],
+                  'region_draw' : [None, ],
+                 'region_drawn' : [None, _draw],
+               'region_removed' : [None, _draw],
+                 'M-up pressed' : [None, self.OnPageUp],
+               'M-down pressed' : [None, self.OnPageDown],
+               'pageup pressed' : [None, self.OnPageUp],
+             'pagedown pressed' : [None, self.OnPageDown],
+                 'home pressed' : [None, _F(self.select, index=0)],
+                  'end pressed' : [None, _F(self.select, index=-1)],
+                  'M-a pressed' : [None, _F(self.fit_to_canvas)],
+                  'C-a pressed' : [None, _F(self.fit_to_axes)],
+                  'C-i pressed' : [None, _F(self.invert_cmap)],
+                  'C-k pressed' : [None, _F(self.kill_buffer)],
+                'C-S-k pressed' : [None, _F(self.kill_all_buffers)],
+                  'C-c pressed' : [None, _F(self.write_buffer_to_clipboard)],
+                  'C-v pressed' : [None, _F(self.read_buffer_from_clipboard)],
             },
             NORMAL : {
                  'image_picked' : (NORMAL, self.OnImagePicked),
@@ -581,6 +555,7 @@ class GraphPlot(MatplotPanel):
                'delete pressed' : (NORMAL, self.OnRegionRemove),
                 'space pressed' : (PAN, self.OnPanBegin),
                  'ctrl pressed' : (PAN, self.OnPanBegin),
+                    'c pressed' : (REGION, self.OnRegionCenter),
                     'z pressed' : (ZOOM, self.OnZoomBegin),
                  '*Ldrag begin' : (REGION+DRAGGING, self.OnRegionDragBegin),
               'Rbutton pressed' : (REGION, self.on_menu_lock),
@@ -618,7 +593,7 @@ class GraphPlot(MatplotPanel):
                 lambda v: v.Enable(self.frame is not None)),
                 
             (wx.ID_CLOSE_ALL, "&Kill all buffer\t(C-S-k)", "Kill buffers", _Icon(wx.ART_DELETE),
-                lambda v: self.kill_buffer_all(),
+                lambda v: self.kill_all_buffers(),
                 lambda v: v.Enable(self.frame is not None)),
         ]
         
@@ -628,14 +603,13 @@ class GraphPlot(MatplotPanel):
                 lambda v: self.select(s),
                 lambda v: v.Check(self.frame is not None and self.frame.name == s))
         
-        self.modeline.Bind(wx.EVT_CONTEXT_MENU, lambda v:
-            Menu.Popup(self,
-                (_menu(j, art.name) for j, art in enumerate(self.__Arts))))
-        
-        self.modeline.Show(1)
-        self.Layout()
+        self.modeline.Bind(wx.EVT_CONTEXT_MENU,
+                           lambda v: Menu.Popup(self, (_menu(j, art.name)
+                                                for j, art in enumerate(self.__Arts))))
         
+        self.modeline.Show()
         self.writeln()
+        self.Layout()
 
     def clear(self):
         MatplotPanel.clear(self)
@@ -646,14 +620,14 @@ class GraphPlot(MatplotPanel):
         ## cf. self.figure.dpi = 80 dpi (0.3175 mm/pix)
         self.__unit = 1.0
         
-        #<matplotlib.lines.Line2D>
+        # <matplotlib.lines.Line2D>
         (self.marked,) = self.axes.plot([], [], "r+", ms=8, mew=1,
                                         picker=8)
         self.__marksel = []
         self.__markarts = []
         self.marked.set_clip_on(False)
         
-        #<matplotlib.lines.Line2D>
+        # <matplotlib.lines.Line2D>
         (self.rected,) = self.axes.plot([], [], "r+--", ms=4, lw=3/4,
                                         picker=4, alpha=0.8)
         self.__rectsel = []
@@ -688,13 +662,13 @@ class GraphPlot(MatplotPanel):
         if isinstance(buf, str):
             buf = Image.open(buf)
         
-        pathname = kwargs.get('pathname')
+        path = kwargs.get('pathname')
         paths = [art.pathname for art in self.__Arts]
         names = [art.name for art in self.__Arts]
         j = -1
-        if pathname:
-            if pathname in paths:
-                j = paths.index(pathname)  # identical path
+        if path:
+            if path in paths:
+                j = paths.index(path)  # existing path
         elif name in names:
             j = names.index(name)  # existing frame
         if j != -1:
@@ -880,12 +854,12 @@ class GraphPlot(MatplotPanel):
 
     @property
     def unit(self):
-        """Logical length per pixel arb.unit [u/pix]."""
+        """Logical length per pixel in arbitrary units [u/pix]."""
         return self.__unit
 
     @unit.setter
     def unit(self, v):
-        if v == self.__unit:  # no effect unless unit changes
+        if v == self.__unit:  # no effect
             return
         if v is None or np.isnan(v) or np.isinf(v):
             raise ValueError("The unit value must not be nan or inf")
@@ -902,7 +876,7 @@ class GraphPlot(MatplotPanel):
         if self.frame:
             del self[self.__index]
 
-    def kill_buffer_all(self):
+    def kill_all_buffers(self):
         del self[:]
 
     def fit_to_axes(self):
@@ -962,21 +936,22 @@ class GraphPlot(MatplotPanel):
 
     def trace_point(self, x, y, type=NORMAL):
         """Puts (override) a message of points x and y."""
+        if not hasattr(x, '__iter__'):  # called from OnMotion
+            return self.trace_point([x], [y], type)
+        
         frame = self.frame
         if frame:
-            if not hasattr(x, '__iter__'):  # called from OnMotion
-                nx, ny = frame.xytopixel(x, y)
-                z = frame.xytoc(x, y)
-                self.message(f"[{nx:-4d},{ny:-4d}] ({x:-8.3f},{y:-8.3f}) value: {z}")
-                return
-            
             if len(x) == 0:  # no selection
                 return
             
-            if len(x) == 1:  # 1-selector trace point (called from Marker:setter)
-                return self.trace_point(x[0], y[0], type)
+            if len(x) == 1:  # 1-selector trace point (called from markers.setter)
+                x, y = x[0], y[0]
+                z = frame.xytoc(x, y)
+                nx, ny = frame.xytopixel(x, y)
+                self.message(f"[{nx:-4d},{ny:-4d}] ({x:-8.3f},{y:-8.3f}) value: {z}")
+                return
             
-            if len(x) == 2:  # 2-selector trace line (called from selector:setter)
+            if len(x) == 2:  # 2-selector trace line (called from selector.setter)
                 nx, ny = frame.xytopixel(x, y)
                 dx = x[1] - x[0]
                 dy = y[1] - y[0]
@@ -985,11 +960,11 @@ class GraphPlot(MatplotPanel):
                 li = np.hypot(nx[1]-nx[0], ny[1]-ny[0])
                 self.message(f"[Line] Length: {li:.1f} pixel ({lu:g}u) Angle: {a:.1f} deg")
             
-            elif type == REGION:  # N-selector trace polygon (called from region:setter)
+            elif type == REGION:  # N-selector trace polygon (called from region.setter)
                 nx, ny = frame.xytopixel(x, y)
-                xo, yo = min(nx), min(ny)  # top-left
-                xr, yr = max(nx), max(ny)  # bottom-right
-                self.message(f"[Region] crop={xr-xo}:{yr-yo}:{xo}:{yo}")  # (W:H:left:top)
+                xo, xp = min(nx), max(nx)
+                yo, yp = min(ny), max(ny)
+                self.message(f"[Region] crop={xp-xo}:{yp-yo}:{xo}:{yo}")  # (W:H:left:top)
 
     def writeln(self):
         """Puts (override) attributes of current frame to the modeline."""
@@ -1086,7 +1061,7 @@ class GraphPlot(MatplotPanel):
     ## matplotlib interface.
     ## --------------------------------
 
-    def on_pick(self, evt):  #<matplotlib.backend_bases.PickEvent>
+    def on_pick(self, evt):  # <matplotlib.backend_bases.PickEvent>
         """Pickup image and other arts.
         Called (maybe) after mouse buttons are pressed.
         """
@@ -1135,19 +1110,18 @@ class GraphPlot(MatplotPanel):
     def on_picker_unlock(self, evt):
         self.__isPicked = False
 
-    def OnImagePicked(self, evt):  #<matplotlib.backend_bases.PickEvent>
+    def OnImagePicked(self, evt):  # <matplotlib.backend_bases.PickEvent>
         x = evt.mouseevent.xdata
         y = evt.mouseevent.ydata
         nx, ny = self.frame.xytopixel(x, y)
-        x, y = self.frame.xyfrompixel(nx, ny)
         evt.ind = (ny, nx)
-        self.selector = (x, y)
+        self.selector = self.frame.xyfrompixel(nx, ny)
 
     def _inaxes(self, evt):
         try:
-            return evt.inaxes is not self.axes  #<matplotlib.backend_bases.MouseEvent>
+            return evt.inaxes is not self.axes  # <matplotlib.backend_bases.MouseEvent>
         except AttributeError:
-            return None  #<wx._core.KeyEvent>
+            return None  # <wx._core.KeyEvent>
 
     ## --------------------------------
     ## Pan/Zoom actions (override).
@@ -1314,7 +1288,7 @@ class GraphPlot(MatplotPanel):
         dots = np.hypot(x-xs[k], y-ys[k]) * self.ddpu[0]
         self.__linesel = k if dots < 8 else None
 
-    def OnLineDeselected(self, evt):  #<matplotlib.backend_bases.PickEvent>
+    def OnLineDeselected(self, evt):  # <matplotlib.backend_bases.PickEvent>
         self.__linesel = None
 
     def OnLineDragBegin(self, evt):
@@ -1365,10 +1339,10 @@ class GraphPlot(MatplotPanel):
         if self.selector.size and self.frame:
             ux, uy = self.frame.xy_unit
             du = {
-                'up' : ( 0., uy),
-              'down' : ( 0.,-uy),
-              'left' : (-ux, 0.),
-             'right' : ( ux, 0.),
+                'up' : (0, +uy),
+              'down' : (0, -uy),
+              'left' : (-ux, 0),
+             'right' : (+ux, 0),
             }
             self.selector += np.resize(du[evt.key], (2,1))
             self.handler('line_move', self.frame)
@@ -1399,7 +1373,7 @@ class GraphPlot(MatplotPanel):
             return
         self.marked.set_data(x, y)
         self.__marksel = []
-        self.update_art_of_mark()
+        self.update_mark_art()
         self.handler('mark_drawn', self.frame)
 
     @markers.deleter
@@ -1407,7 +1381,7 @@ class GraphPlot(MatplotPanel):
         if self.markers.size:
             self.marked.set_data([], [])
             self.__marksel = []
-            self.update_art_of_mark()
+            self.update_mark_art()
             self.handler('mark_removed', self.frame)
 
     def get_current_mark(self):
@@ -1421,7 +1395,7 @@ class GraphPlot(MatplotPanel):
         if j:
             xm[j], ym[j] = x, y
             self.marked.set_data(xm, ym)
-            self.update_art_of_mark(j, xm[j], ym[j])
+            self.update_mark_art(j, xm[j], ym[j])
         else:
             n = len(xm)
             k = len(x) if hasattr(x, '__iter__') else 1
@@ -1429,7 +1403,7 @@ class GraphPlot(MatplotPanel):
             xm, ym = np.append(xm, x), np.append(ym, y)
             self.marked.set_data(xm, ym)
             self.marked.set_visible(1)
-            self.update_art_of_mark()
+            self.update_mark_art()
         self.selector = (x, y)
 
     def del_current_mark(self):
@@ -1441,9 +1415,9 @@ class GraphPlot(MatplotPanel):
             self.marked.set_data(xm, ym)
             n = len(xm)
             self.__marksel = [j[-1] % n] if n > 0 else []
-            self.update_art_of_mark()
+            self.update_mark_art()
 
-    def update_art_of_mark(self, *args):
+    def update_mark_art(self, *args):
         if args:
             for k, x, y in zip(*args):
                 art = self.__markarts[k]  # art の再描画処理をして終了
@@ -1458,11 +1432,11 @@ class GraphPlot(MatplotPanel):
             xm, ym = self.marked.get_data(orig=0)
             for k, (x, y) in enumerate(zip(xm[:N], ym[:N])):
                 self.__markarts.append(
-                  self.axes.annotate(k,  #<matplotlib.text.Annotation>
+                  self.axes.annotate(k,  # <matplotlib.text.Annotation>
                     xy=(x,y), xycoords='data',
                     xytext=(6,6), textcoords='offset points',
                     bbox=dict(boxstyle="round", fc=(1,1,1,), ec=(1,0,0,)),
-                    color='red', size=7, #fontsize=8,
+                    color='red', size=7,  # fontsize=8,
                   )
                 )
             self.trace_point(*self.get_current_mark(), type=MARK)
@@ -1473,28 +1447,28 @@ class GraphPlot(MatplotPanel):
         if not self.__marksel and len(xs) > 0:
             self.set_current_mark(xs, ys)
             self.handler('mark_drawn', self.frame)
-        self.update_art_of_mark()
+        self.update_mark_art()
 
     def OnMarkRemove(self, evt):
         if self.__marksel:
             self.del_current_mark()
             self.handler('mark_removed', self.frame)
 
-    def OnMarkSelected(self, evt):  #<matplotlib.backend_bases.PickEvent>
+    def OnMarkSelected(self, evt):  # <matplotlib.backend_bases.PickEvent>
         k = evt.ind[0]
         if evt.mouseevent.key == 'shift':  # 多重マーカー選択
             if k not in self.__marksel:
                 self.__marksel += [k]
         else:
             self.__marksel = [k]
-        self.update_art_of_mark()
+        self.update_mark_art()
         self.selector = self.get_current_mark()
         if self.selector.shape[1] > 1:
             self.handler('line_drawn', self.frame)  # 多重マーカー選択時
 
-    def OnMarkDeselected(self, evt):  #<matplotlib.backend_bases.PickEvent>
+    def OnMarkDeselected(self, evt):  # <matplotlib.backend_bases.PickEvent>
         self.__marksel = []
-        self.update_art_of_mark()
+        self.update_mark_art()
 
     def OnMarkDragBegin(self, evt):
         if not self.frame or self._inaxes(evt):
@@ -1519,10 +1493,10 @@ class GraphPlot(MatplotPanel):
         if j and self.frame:
             ux, uy = self.frame.xy_unit
             du = {
-                'up' : ( 0., uy),
-              'down' : ( 0.,-uy),
-              'left' : (-ux, 0.),
-             'right' : ( ux, 0.),
+                'up' : (0,  uy),
+              'down' : (0, -uy),
+              'left' : (-ux, 0),
+             'right' : ( ux, 0),
             }
             p = self.get_current_mark() + np.resize(du[evt.key], (2,1))
             self.set_current_mark(*p)
@@ -1562,13 +1536,13 @@ class GraphPlot(MatplotPanel):
 
     @property
     def region(self):
-        """Cropped rectangle points data array [l,r],[b,t]."""
+        """Cropped rectangle points data array [[l,r], [b,t]]."""
         x, y = self.rected.get_data(orig=0)
         if len(x) and len(y):
-            xo, x = min(x), max(x)  # x[[0, 2]]
-            yo, y = min(y), max(y)  # y[[0, 2]]
-            return np.array(((xo, x), (yo, y)))
-        return np.resize(0., (2,0))
+            l, r = min(x), max(x)
+            b, t = min(y), max(y)
+            return np.array(((l,r), (b,t)))
+        return np.resize(0., (2, 0))
 
     @region.setter
     def region(self, v):
@@ -1597,8 +1571,6 @@ class GraphPlot(MatplotPanel):
             l,r,b,t = self.frame.get_extent()
             xa, xb = min(x), max(x)
             ya, yb = min(y), max(y)
-            # if (xa < l or xb > r) or (ya < b or yb > t):
-            #     return
             ## Modify range so that it does not exceed the extent.
             w, h = xb-xa, yb-ya
             if xa < l: xa, xb = l, l+w
@@ -1609,15 +1581,15 @@ class GraphPlot(MatplotPanel):
         y = [ya, ya, yb, yb, ya]
         self.rected.set_data(x, y)
         self.rected.set_visible(1)
-        self.update_art_of_region()
+        self.update_rect_art()
 
     def del_current_rect(self):
         self.__rectsel = []
         self.rected.set_data([], [])
         self.rected.set_visible(0)
-        self.update_art_of_region()
+        self.update_rect_art()
 
-    def update_art_of_region(self, *args):
+    def update_rect_art(self, *args):
         if args:
             art = self.__rectarts  # art の再描画処理をして終了
             art.xy = args
@@ -1638,6 +1610,12 @@ class GraphPlot(MatplotPanel):
             self.trace_point(x, y, type=REGION)
         self.draw(self.rected)
 
+    def OnRegionCenter(self, evt):
+        if self.region.size and self.frame:
+            (l,r), (b,t) = self.region
+            c = np.array(((l+r)/2, (b+t)/2))
+            self.region += self.frame.center - c[:,None]
+
     def OnRegionAppend(self, evt):
         xs, ys = self.selector
         if len(xs) > 0 and self.frame:
@@ -1645,7 +1623,7 @@ class GraphPlot(MatplotPanel):
             xs = (xs.min()-ux/2, xs.max()+ux/2)
             ys = (ys.max()+uy/2, ys.min()-uy/2)
             self.set_current_rect(xs, ys)
-            self.update_art_of_region()
+            self.update_rect_art()
             self.handler('region_drawn', self.frame)
 
     def OnRegionRemove(self, evt):
@@ -1654,18 +1632,18 @@ class GraphPlot(MatplotPanel):
             self.handler('region_removed', self.frame)
         self.set_wxcursor(wx.CURSOR_ARROW)
 
-    def OnRegionSelected(self, evt):  #<matplotlib.backend_bases.PickEvent>
+    def OnRegionSelected(self, evt):  # <matplotlib.backend_bases.PickEvent>
         k = evt.ind[0]
         x = evt.mouseevent.xdata
         y = evt.mouseevent.ydata
         xs, ys = evt.artist.get_data(orig=0)
         dots = np.hypot(x-xs[k], y-ys[k]) * self.ddpu[0]
         self.__rectsel = [k] if dots < 8 else [0,1,2,3,4]  # リージョンの全選択
-        self.update_art_of_region()
+        self.update_rect_art()
 
-    def OnRegionDeselected(self, evt):  #<matplotlib.backend_bases.PickEvent>
+    def OnRegionDeselected(self, evt):  # <matplotlib.backend_bases.PickEvent>
         self.__rectsel = []
-        self.update_art_of_region()
+        self.update_rect_art()
         self.set_wxcursor(wx.CURSOR_ARROW)
 
     def OnRegionDragBegin(self, evt):
@@ -1723,10 +1701,10 @@ class GraphPlot(MatplotPanel):
         if j and self.frame:
             ux, uy = self.frame.xy_unit
             du = {
-                'up' : ( 0., uy),
-              'down' : ( 0.,-uy),
-              'left' : (-ux, 0.),
-             'right' : ( ux, 0.),
+                'up' : (0,  uy),
+              'down' : (0, -uy),
+              'left' : (-ux, 0),
+             'right' : ( ux, 0),
             }
             dp = du[evt.key]
             p = self.get_current_rect().T