mwxlib 0.93.1__py3-none-any.whl → 0.93.7__py3-none-any.whl

mwx/matplot2lg.py

@@ -31,7 +31,7 @@ class LinePlot(MatplotPanel):
                'delete pressed' : (NORMAL, self.OnEscapeSelection),
                   'M-a pressed' : (NORMAL, self.OnHomePosition),
                   'C-a pressed' : (NORMAL, self.OnHomePosition),
-             'Lbutton dblclick' : (NORMAL, self.OnEscapeSelection),
+             'Lbutton dblclick' : (NORMAL, self.OnEscapeSelection, self.OnDragLock),
              '*Lbutton pressed' : (NORMAL, self.OnDragLock),
                  '*Ldrag begin' : (REGION, self.OnDragBegin),
             },
@@ -166,7 +166,7 @@ class LinePlot(MatplotPanel):
             if   x < l: x = l
             elif x > r: x = r
             self.region = (self.__lastpoint, x)
-        else:
+        elif self.region is not None:
             a, b = self.region
             d = x - self.__lastpoint
             if self.boundary is not None:
@@ -181,6 +181,8 @@ class LinePlot(MatplotPanel):
             else:
                 self.region = (a+d, b+d)
                 self.__lastpoint = x
+        else:
+            self.message("- No region.") #<FSM logic-error>
         self.draw()
     
     def OnDragEnd(self, evt):
@@ -282,7 +284,8 @@ class Histogram(LinePlot):
             self.xlim = x.min(), x.max()
             self.ylim = 0, y.max()
             self.region = None
-            self.update_position()
+            self.toolbar.update()
+            self.toolbar.push_current()
             self.draw()
     
     def hreplot(self, frame):
@@ -308,7 +311,8 @@ class Histogram(LinePlot):
             self.__plot.set_data([], [])
             self.region = None
         
-        self.update_position()
+        self.toolbar.update()
+        self.toolbar.push_current()
         self.draw()
     
     def writeln(self):
@@ -392,9 +396,9 @@ class LineProfile(LinePlot):
                  '*Ldrag begin' : (REGION, self.OnDragBegin),
             },
             REGION : {
-                 'S-Ldrag move' : (REGION+LINE, self.OnRegionLock),
+                 'S-Ldrag move' : (REGION+LINE, self.OnRegionLock, self.OnDragLineBegin),
                  'M-Ldrag move' : (REGION+MARK, self.OnMarkPeaks, self.OnMarkSelectionBegin),
-                  '*Ldrag move' : (REGION, self.OnDragMove),
+                  '*Ldrag move' : (REGION, self.OnDragMove, self.OnDragTrace),
                    '*Ldrag end' : (NORMAL, self.OnDragEnd),
             },
             LINE: {
@@ -431,7 +435,7 @@ class LineProfile(LinePlot):
         
         self.menu += [
             (mwx.ID_(510), "&Copy data", "Copy data to clipboard",
-                lambda v: self.copy_data_to_clipboard()),
+                lambda v: self.write_data_to_clipboard()),
             (),
             (mwx.ID_(511), "Logic length", "Set axis-unit in logic base", wx.ITEM_RADIO,
                 lambda v: self.set_logic(1),
@@ -516,6 +520,14 @@ class LineProfile(LinePlot):
         """Plotted (xdata, ydata) in single plot."""
         return self.__plot.get_data(orig=0)
     
+    def calc_average(self):
+        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()
+    
     def linplot(self, frame, fit=True, force=True):
         if not force:
             if frame is self.__frame:
@@ -572,7 +584,8 @@ class LineProfile(LinePlot):
                 self.xlim = ls[0], ls[-1]
                 self.ylim = ly[0], max(ly[1], max(zs))
             
-        self.update_position()
+        self.toolbar.update()
+        self.toolbar.push_current()
         self.draw()
     
     def writeln(self):
@@ -594,14 +607,14 @@ class LineProfile(LinePlot):
         else:
             self.modeline.write("")
     
-    def copy_data_to_clipboard(self):
-        """Copy plotdata to clipboard."""
-        self.message("Copy data to clipboard.")
+    def write_data_to_clipboard(self):
+        """Write plot data to clipboard."""
         X, Y = self.plotdata
         with io.StringIO() as o:
             for x, y in zip(X, Y):
                 o.write("{:g}\t{:g}\n".format(x, y))
             Clipboard.write(o.getvalue(), verbose=0)
+            self.message("Write data to clipboard.")
     
     ## --------------------------------
     ## Motion/Drag actions (override)
@@ -629,7 +642,7 @@ class LineProfile(LinePlot):
         if x.size:
             self.__fil.set_xy(list(chain([(x[0],0)], zip(x,y), [(x[-1],0)])))
         self.writeln()
-        
+    
     def OnLineWidth(self, evt):
         n = -2 if evt.key[-1] == '-' else 2
         self.set_linewidth(self.__linewidth + n)
@@ -648,7 +661,17 @@ class LineProfile(LinePlot):
     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.__hline.set_ydata([y])
+            ## self.__hline.set_visible(1)
+            ## self.canvas.draw_idle()
+            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
@@ -676,12 +699,13 @@ class LineProfile(LinePlot):
             else:
                 self.region = x[[0,-1]] # all y > yc
             
-            self.__hline.set_ydata(yc)
+            self.__hline.set_ydata([yc])
             self.__hline.set_visible(1)
-            self.message("y = {:g}, xr = {}".format(yc, self.region))
             self.draw()
+            self.message(f"yc = {yc:g}")
     
     def OnMarkPeaks(self, evt):
+        """Set markers on peaks."""
         x, y = self.plotdata
         if x.size:
             lw = 5
@@ -699,7 +723,9 @@ class LineProfile(LinePlot):
                 self.Selector = x[peaks], y[peaks]
     
     def OnMarkErase(self, evt):
-        del self.Selector
+        """Erase markers on peaks."""
+        ## del self.Selector
+        self.OnEscapeSelection(evt)
     
     def OnMarkSelectionBegin(self, evt):
         org = self.p_event

mwx/nutshell.py

@@ -1682,7 +1682,7 @@ class Buffer(EditWindow, EditorInterface):
                 self.EnsureCaretVisible()
                 self.AnnotationSetStyle(lx, stc.STC_STYLE_ANNOTATION)
                 self.AnnotationSetText(lx, msg)
-            self.message("- {}".format(e))
+            self.message(e)
             ## print(msg, file=sys.__stderr__)
         else:
             self.code = code
@@ -2299,7 +2299,7 @@ class Nautilus(Shell, EditorInterface):
             obj.this = inspect.getmodule(obj)
             obj.shell = self # overwrite the facade <wx.py.shell.ShellFacade>
         except AttributeError:
-            ## print("- cannot overwrite target vars: {}".format(e))
+            ## print("- cannot overwrite target vars:", e)
             pass
         self.parent.handler('title_window', obj)
     
@@ -2354,7 +2354,7 @@ class Nautilus(Shell, EditorInterface):
         wx.py.shell.USE_MAGIC = True
         wx.py.shell.magic = self.magic # called when USE_MAGIC
         
-        ## cf. sys.modules (shell.modules
+        ## cf. sys.modules
         if not self.modules:
             force = wx.GetKeyState(wx.WXK_CONTROL)\
                   & wx.GetKeyState(wx.WXK_SHIFT)
@@ -3292,7 +3292,7 @@ class Nautilus(Shell, EditorInterface):
                 if lines:
                     region = self.get_region(self.cline)
                     self.pointer = region[0] + lines[-1] - 1
-                self.message("- {}".format(e))
+                self.message(e)
                 ## print(msg, file=sys.__stderr__)
             else:
                 del self.pointer
@@ -3461,7 +3461,7 @@ class Nautilus(Shell, EditorInterface):
                 try:
                     modules = set(dir(import_module(text)))
                 except ImportError as e:
-                    self.message("\b failed: {}".format(e))
+                    self.message("\b failed:", e)
                     return
                 ## Add unimported module names.
                 p = "{}.{}".format(text, hint)

mwx/py/__init__.py

@@ -0,0 +1,2 @@
+#! python3
+"""Plug-ins / Add-ins."""

mwx/py/ffmpeg_view.py

@@ -0,0 +1,257 @@
+#! python3
+"""FFmpeg wrapper.
+"""
+from subprocess import Popen, PIPE
+import numpy as np
+import os
+import wx
+import wx.media
+
+from mwx.graphman import Layer, Frame
+from mwx.controls import LParam, Icon, Button, TextCtrl
+
+
+def read_info(path):
+    command = ['ffprobe',
+               '-i', path,
+               '-loglevel', 'quiet',    # no verbose
+               '-print_format', 'json', # -format json
+               '-show_streams',         # -streams info
+               ]
+    with Popen(command, stdout=PIPE, stderr=PIPE) as fp:
+        ret, err = fp.communicate()
+        if not err:
+            return eval(ret)
+
+
+def capture_video(path, ss=0):
+    command = ['ffmpeg',
+               '-ss', f"{ss}",          # Note: placing -ss before -i will be faster,
+               '-i', path,              #       but maybe not accurate.
+               '-frames:v', '1',        # -frame one shot
+               '-f', 'rawvideo',        # -format raw
+               '-pix_fmt', 'rgb24',     # rgb24, gray, etc.
+               'pipe:'                  # pipe to stdout: '-'
+               ]
+    bufsize = 4096 # w * h * 3
+    buf = b"" # bytearray()
+    with Popen(command, stdout=PIPE) as fp:
+        while 1:
+            s = fp.stdout.read(bufsize)
+            buf += s
+            if len(s) < bufsize:
+                break
+    return np.frombuffer(buf, np.uint8)
+
+
+def export_video(path, crop, ss, to, filename):
+    command = ['ffmpeg',
+               '-i', path,
+               '-vf', f"{crop=}",
+               '-ss', f"{ss}",
+               '-to', f"{to}",
+               '-y', filename,
+               ]
+    print('>', ' '.join(command))
+    with Popen(command) as fp:
+        ret, err = fp.communicate()
+
+
+class MyFileDropLoader(wx.FileDropTarget):
+    def __init__(self, target):
+        wx.FileDropTarget.__init__(self)
+        self.target = target
+    
+    def OnDropFiles(self, x, y, filenames):
+        path = filenames[-1] # Only the last one will be loaded.
+        if len(filenames) > 1:
+            print("- Drop only one file please."
+                  "Loading {!r} ...".format(path))
+        self.target.load_media(path)
+        return True
+
+
+class Plugin(Layer):
+    """Media loader using FFMpeg (installation required).
+    """
+    menukey = "Plugins/Extensions/FFMpeg viewer"
+    ## menukey = "FFMpeg/"
+    dockable = False
+    
+    def Init(self):
+        self.mc = wx.media.MediaCtrl()
+        self.mc.Create(self, size=(300,300),
+                       style=wx.SIMPLE_BORDER,
+                       szBackend=wx.media.MEDIABACKEND_WMP10
+                       ## szBackend=wx.media.MEDIABACKEND_DIRECTSHOW
+        )
+        self.mc.ShowPlayerControls()
+        self.mc.Bind(wx.media.EVT_MEDIA_LOADED, self.OnMediaLoaded)
+        self.mc.Bind(wx.media.EVT_MEDIA_PAUSE, self.OnMediaPause)
+        
+        self.mc.SetDropTarget(MyFileDropLoader(self))
+        
+        self._path = None
+        
+        self.ss = LParam("ss:", # range/value will be set when loaded later.
+                        handler=self.set_offset,
+                        updater=self.get_offset,
+                        )
+        self.to = LParam("to:", # range/value will be set when loaded later.
+                        handler=self.set_offset,
+                        updater=self.get_offset,
+                        )
+        self.crop = TextCtrl(self, icon="cut", size=(130,-1),
+                        handler=self.set_crop,
+                        updater=self.get_crop,
+                        )
+        
+        self.snp = Button(self, handler=self.snapshot, tip='Snapshot', icon='clock')
+        self.exp = Button(self, handler=self.export, tip="Export", icon='save')
+        
+        self.rw = Button(self, handler=lambda v: self.seekdelta(-100), icon='|<-')
+        self.fw = Button(self, handler=lambda v: self.seekdelta(+100), icon='->|')
+        
+        self.layout((self.mc,), expand=2)
+        self.layout((self.ss, self.to, self.rw, self.fw,
+                     self.snp, self.crop, self.exp),
+                    expand=0, row=7, style='button', lw=12, cw=0, tw=64)
+        
+        self.menu[0:5] = [
+            (1, "&Load file", Icon('open'),
+                lambda v: self.load_media()),
+                
+            (2, "&Snapshot", Icon('clock'),
+                lambda v: self.snapshot(),
+                lambda v: v.Enable(self._path is not None)),
+            (),
+        ]
+        
+        self.parent.handler.bind("unknown_format", self.load_media)
+    
+    def Destroy(self):
+        try:
+            self.parent.handler.unbind("unknown_format", self.load_media)
+            self.mc.Stop()
+        finally:
+            return Layer.Destroy(self)
+    
+    def OnMediaLoaded(self, evt):
+        self.ss.range = (0, self.video_dur, 0.01)
+        self.to.range = (0, self.video_dur, 0.01)
+        self.Show()
+        evt.Skip()
+    
+    def OnMediaPause(self, evt):
+        evt.Skip()
+    
+    def load_media(self, path=None):
+        if path is None:
+            with wx.FileDialog(self, "Choose a media file",
+                style=wx.FD_OPEN|wx.FD_CHANGE_DIR|wx.FD_FILE_MUST_EXIST) as dlg:
+                if dlg.ShowModal() != wx.ID_OK:
+                    return None
+                path = dlg.Path
+        self.mc.Load(path) # -> True (always)
+        self.info = read_info(path)
+        if self.info:
+            v = next(x for x in self.info['streams'] if x['codec_type'] == 'video')
+            ## self.video_fps = eval(v['r_frame_rate']) # real base frame rate
+            self.video_fps = eval(v['avg_frame_rate'])  # averaged frame rate
+            self.video_dur = eval(v['duration'])        # duration [s]
+            w, h = v['width'], v['height']
+            if v['tags'].get('rotate') in ('90', '270'):
+                w, h = h, w  # transpose
+            self.video_size = w, h
+            self._path = path
+            self.message(f"Loaded {path!r} successfully.")
+            return True
+        else:
+            self.message(f"Failed to load file {path!r}.")
+            return False
+    
+    DELTA = 1000 # correction ▲理由は不明 (WMP10 backend only?)
+    
+    def set_offset(self, tc):
+        """Set offset value by referring to ss/to value."""
+        try:
+            self.mc.Seek(self.DELTA + int(tc.value * 1000))
+        except Exception:
+            pass
+    
+    def get_offset(self, tc):
+        """Get offset value and assigns it to ss/to value."""
+        try:
+            tc.value = round(self.mc.Tell()) / 1000
+        except Exception:
+            pass
+    
+    def set_crop(self):
+        """Set crop area (W:H:Left:Top) to roi."""
+        frame = self.graph.frame
+        if frame:
+            try:
+                w, h, xo, yo = eval(self.crop.Value.replace(':', ','))
+                xo -= 0.5  # Correction with half-pixel
+                yo -= 0.5  # to select left-top (not center) position
+                nx = xo, xo+w
+                ny = yo, yo+h
+                frame.region = frame.xyfrompixel(nx, ny)
+            except Exception:
+                self.message("Failed to evaluate crop text.")
+    
+    def get_crop(self):
+        """Get crop area (W:H:Left:Top) from roi."""
+        crop = ''
+        frame = self.graph.frame
+        if frame:
+            nx, ny = frame.xytopixel(*frame.region)
+            if nx.size:
+                xo, yo = nx[0], ny[1]
+                xp, yp = nx[1], ny[0]
+                crop = "{}:{}:{}:{}".format(xp-xo, yp-yo, xo, yo)
+        if self._path and not crop:
+            crop = "{}:{}:0:0".format(*self.video_size)
+        self.crop.Value = crop
+    
+    def seekdelta(self, offset):
+        """Seek relative position [ms]."""
+        if wx.GetKeyState(wx.WXK_SHIFT):
+            offset /= 10
+        try:
+            t = self.to.value + offset/1000
+        except Exception as e:
+            print(e)
+        else:
+            if self._path and 0 <= t < self.video_dur:
+                self.to.value = round(t, 3)
+            self.set_offset(self.to) # => seek
+    
+    def snapshot(self):
+        """Create a snapshot of the current frame.
+        Load the snapshot image into the graph window.
+        """
+        if not self._path:
+            return
+        t = self.mc.Tell()
+        w, h = self.video_size
+        buf = capture_video(self._path, t/1000).reshape((h,w,3))
+        name = "{}-ss{}".format(os.path.basename(self._path), int(t))
+        self.graph.load(buf, name)
+    
+    def export(self):
+        """Export the cropped / clipped data to a media file."""
+        if not self._path:
+            return
+        fout = "{}_clip".format(os.path.splitext(self._path)[0])
+        with wx.FileDialog(self, "Save as",
+                defaultFile=os.path.basename(fout),
+                wildcard="Media file (*.mp4)|*.mp4|"
+                         "Animiation (*.gif)|*.gif",
+                style=wx.FD_SAVE|wx.FD_OVERWRITE_PROMPT) as dlg:
+            if dlg.ShowModal() != wx.ID_OK:
+                return
+            fout = dlg.Path
+        export_video(self._path,
+                     self.crop.Value or "{}:{}:0:0".format(*self.video_size),
+                     self.ss.value, self.to.value, fout)

mwx/py/fft_view.py

@@ -0,0 +1,79 @@
+#! python3
+"""View of FFT/iFFT.
+"""
+import wx
+import numpy as np
+from numpy.fft import fft2,ifft2,fftshift,ifftshift
+## from scipy.fftpack import fft,ifft,fft2,ifft2 Memory Leak? <scipy 0.16.1>
+## import cv2
+
+from jgdk import Layer, Param
+import editor as edi
+
+
+class Plugin(Layer):
+    """FFT view.
+    
+    FFT src (graph.buffer) to dst (output.buffer).
+    Note:
+        Rectangular regions will result in distorted patterns.
+        長方形のリージョンは歪んだパターンになるので要注意
+    """
+    menukey = "Plugins/Extensions/&FFT view"
+    caption = "FFT view"
+    
+    def Init(self):
+        self.pchk = wx.CheckBox(self, label="logical unit")
+        self.pchk.Value = True
+        
+        self.ftor = Param("mask", (2,4,8,16,32,64)) # masking area factor of 1/2
+        
+        self.layout((self.pchk,), title="normal FFT")
+        self.layout((self.ftor,), title="inverse FFT", style='chkbox', tw=32)
+        
+        self.parent.define_key('C-f', self.newfft)
+        self.parent.define_key('C-S-f', self.newifft)
+    
+    def Destroy(self):
+        self.parent.define_key('C-f', None)
+        self.parent.define_key('C-S-f', None)
+        return Layer.Destroy(self)
+    
+    def newfft(self, evt):
+        """New FFT of graph to output."""
+        frame = self.graph.frame
+        if frame:
+            self.message("FFT execution...")
+            src = edi.fftcrop(frame.roi)
+            h, w = src.shape
+            
+            dst = fftshift(fft2(src))
+            
+            self.message("\b Loading image...")
+            u = 1 / w
+            if self.pchk.Value:
+                u /= frame.unit
+            self.output.load(dst, "*fft of {}*".format(frame.name),
+                                  localunit=u)
+            self.message("\b done")
+    
+    def newifft(self, evt):
+        """New inverse FFT of output to graph."""
+        frame = self.output.frame
+        if frame:
+            self.message("iFFT execution...")
+            src = frame.roi
+            h, w = src.shape
+            
+            if self.ftor.check:
+                y, x = np.ogrid[-h/2:h/2, -w/2:w/2]
+                mask = np.hypot(y,x) > w / self.ftor.value
+                src = src.copy() # apply mask to the copy
+                src[mask] = 0
+            
+            dst = ifft2(ifftshift(src))
+            
+            self.message("\b Loading image...")
+            self.graph.load(dst.real, "*ifft of {}*".format(frame.name),
+                                      localunit=1/w/frame.unit)
+            self.message("\b done")