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

mwx/plugins/ffmpeg_view.py

@@ -1,16 +1,15 @@
 #! python3
 """FFmpeg wrapper.
 """
-from functools import partial
 from subprocess import Popen, PIPE
 import numpy as np
 import os
 import wx
 import wx.media
 
-from mwx.framework import _F, hotkey
+from mwx.framework import _F
 from mwx.graphman import Layer
-from mwx.controls import LParam, Icon, Button, TextCtrl
+from mwx.controls import Param, LParam, Icon, Button, TextBox
 
 
 def read_info(path):
@@ -35,8 +34,8 @@ def capture_video(path, ss=0):
                '-pix_fmt', 'rgb24',     # rgb24, gray, etc.
                'pipe:'                  # pipe to stdout: '-'
                ]
-    bufsize = 4096 # w * h * 3
-    buf = b"" # bytearray()
+    bufsize = 4096  # w * h * 3
+    buf = b""
     with Popen(command, stdout=PIPE) as fp:
         while 1:
             s = fp.stdout.read(bufsize)
@@ -63,9 +62,9 @@ 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.
+        path = filenames[-1]  # Only the last one will be loaded.
         if len(filenames) > 1:
             print("- Drop only one file please."
                   "Loading {!r} ...".format(path))
@@ -78,13 +77,13 @@ class Plugin(Layer):
     """
     menukey = "Plugins/Extensions/FFMpeg viewer"
     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
+                       # szBackend=wx.media.MEDIABACKEND_DIRECTSHOW
         )
         self.mc.ShowPlayerControls()
         self.mc.Bind(wx.media.EVT_MEDIA_LOADED, self.OnMediaLoaded)
@@ -93,29 +92,32 @@ class Plugin(Layer):
         
         self._path = None
         
-        self.ss = LParam("ss:", # range/value will be set when loaded later.
+        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.
+        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),
+        self.crop = TextBox(self, icon="cut", size=(140,-1),
                         handler=self.set_crop,
                         updater=self.get_crop,
                         )
+        self.rate = Param("rate", (1/8,1/4,1/2,1,2,4,8),
+                        handler=self.set_rate,
+                        )
         
         self.snp = Button(self, handler=self.snapshot, icon='clip')
         self.exp = Button(self, handler=self.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.rw = Button(self, handler=lambda v: self.seekto(-100), icon='|<-')
+        self.fw = Button(self, handler=lambda v: self.seekto(+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.snp, self.crop, self.rate, self.exp),
+                    expand=0, row=8, type='vspin', style='button', lw=32, cw=-1, tw=64)
         
         self.menu[0:5] = [
             (1, "&Load file", Icon('open'),
@@ -129,55 +131,51 @@ class Plugin(Layer):
         
         self.parent.handler.bind("unknown_format", self.load_media)
         
-        self.handler.update({ # DNA<ffmpeg_viewer>
-            0 : {
-                         'play' : (1, ),
-                'space pressed' : (1, _F(self.mc.Play)),
+        self.handler.update({  # DNA<ffmpeg_viewer>
+            None : {
+               'C-left pressed' : (None, _F(self.seekd, -1000)),
+              'C-right pressed' : (None, _F(self.seekd,  1000)),
+            },
+            0 : {  # MEDIASTATE_STOPPED
+                         'play' : (2, ),
+                'space pressed' : (2, _F(self.mc.Play)),
             },
-            1 : {
+            1 : {  # MEDIASTATE_PAUSED
                          'stop' : (0, ),
-                        'pause' : (0, ),
+                'space pressed' : (2, _F(self.mc.Play)),
+            },
+            2 : {  # MEDIASTATE_PLAYING
+                         'stop' : (0, ),
+                        'pause' : (1, ),
                 'space pressed' : (1, _F(self.mc.Pause)),
             },
         })
         
-        self.mc.Bind(wx.media.EVT_MEDIA_PAUSE, partial(self.handler, 'pause'))
-        self.mc.Bind(wx.media.EVT_MEDIA_PLAY, partial(self.handler, 'play'))
-        self.mc.Bind(wx.media.EVT_MEDIA_STOP, partial(self.handler, 'stop'))
-        
-        ## self.mc.Bind(wx.EVT_KEY_DOWN, self.on_hotkey_down)
-        ## self.mc.Bind(wx.EVT_KEY_UP, self.on_hotkey_up)
-        self.mc.Bind(wx.EVT_KEY_DOWN, self.OnKeyDown)
-        self.mc.Bind(wx.EVT_KEY_UP, self.OnKeyUp)
+        self.mc.Bind(wx.media.EVT_MEDIA_PAUSE, lambda v: self.handler('pause', v))
+        self.mc.Bind(wx.media.EVT_MEDIA_PLAY, lambda v: self.handler('play', v))
+        self.mc.Bind(wx.media.EVT_MEDIA_STOP, lambda v: self.handler('stop', v))
         
-        self.Bind(wx.EVT_SHOW, self.OnShow)
-    
+        self.mc.Bind(wx.EVT_KEY_DOWN, self.on_hotkey_down)
+        self.mc.Bind(wx.EVT_KEY_UP, self.on_hotkey_up)
+
     def Destroy(self):
-        try:
-            self.parent.handler.unbind("unknown_format", self.load_media)
-        finally:
-            return Layer.Destroy(self)
-    
-    def OnKeyDown(self, evt):
-        if self.handler('{} pressed'.format(hotkey(evt)), evt) is None:
-            evt.Skip()
-    
-    def OnKeyUp(self, evt):
-        if self.handler('{} released'.format(hotkey(evt)), evt) is None:
-            evt.Skip()
-    
+        self.parent.handler.unbind("unknown_format", self.load_media)
+        if self.mc:
+            self.mc.Destroy()
+        return Layer.Destroy(self)
+
     def OnShow(self, evt):
         if not evt.IsShown():
             if self.mc:
                 self.mc.Stop()
-        evt.Skip()
-    
+        Layer.OnShow(self, evt)
+
     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 load_media(self, path=None):
         if path is None:
             with wx.FileDialog(self, "Choose a media file",
@@ -185,11 +183,11 @@ class Plugin(Layer):
                 if dlg.ShowModal() != wx.ID_OK:
                     return None
                 path = dlg.Path
-        self.mc.Load(path) # -> True (always)
+        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['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']
@@ -205,64 +203,72 @@ class Plugin(Layer):
         else:
             self.message(f"Failed to load file {path!r}.")
             return False
-    
-    DELTA = 1000 # correction ▲理由は不明 (WMP10 backend only?)
-    
+
+    ## Correction for seek position. ▲理由は不明 (WMP10 backend only?)
+    @property
+    def DELTA(self):
+        return int(1000 / self.mc.PlaybackRate)
+
     def set_offset(self, tc):
         """Set offset value by referring to ss/to value."""
-        try:
+        if self._path:
             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:
+        if self._path:
             tc.value = round(self.mc.Tell()) / 1000
-        except Exception:
-            pass
-    
+
     def set_crop(self):
-        """Set crop area (W:H:Left:Top) to roi."""
+        """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
+                w, h, xo, yo = map(float, self.crop.Value.split(':'))
+                xo -= 0.5  # Correction with half-pixel offset.
+                yo -= 0.5  # Select left-top corner position.
                 nx = xo, xo+w
                 ny = yo, yo+h
                 frame.region = frame.xyfrompixel(nx, ny)
-            except Exception:
-                self.message("Failed to evaluate crop text.")
-    
+            except Exception as e:
+                self.message("Failed to evaluate crop text;", e)
+
     def get_crop(self):
-        """Get crop area (W:H:Left:Top) from roi."""
-        crop = ''
+        """Get crop area (W:H:Left:Top) from ROI."""
         frame = self.graph.frame
         if frame:
-            nx, ny = frame.xytopixel(*frame.region)
+            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:
+                xo, xp = nx
+                yp, yo = ny
+                self.crop.Value = f"{xp-xo}:{yp-yo}:{xo}:{yo}"  # (W:H:left:top)
+                return
+        if self._path:
+            self.crop.Value = "{}:{}:0:0".format(*self.video_size)
+
+    def set_rate(self, rate):
+        if self._path:
+            self.mc.PlaybackRate = rate
+
+    def get_rate(self):
+        if self._path:
+            return self.mc.PlaybackRate
+
+    def seekto(self, offset):
+        """Seek position with offset [ms] from the `to` position."""
+        if self._path:
             t = self.to.value + offset/1000
-        except Exception as e:
-            print(e)
-        else:
-            if self._path and 0 <= t < self.video_dur:
+            if 0 <= t < self.video_dur:
                 self.to.value = round(t, 3)
-            self.set_offset(self.to) # => seek
-    
+            self.set_offset(self.to)
+
+    def seekd(self, offset):
+        """Seek position with offset [ms] from the current position."""
+        if self._path:
+            t = self.mc.Tell() + offset
+            if 0 <= t < self.video_dur * 1000:
+                self.mc.Seek(self.DELTA + t)
+
     def snapshot(self):
         """Create a snapshot of the current frame.
         Load the snapshot image into the graph window.
@@ -274,7 +280,7 @@ class Plugin(Layer):
         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:

mwx/plugins/fft_view.py

@@ -3,7 +3,7 @@
 """
 import wx
 import numpy as np
-from numpy.fft import fft2,ifft2,fftshift,ifftshift
+from numpy.fft import fft2, ifft2, fftshift, ifftshift
 
 from mwx.graphman import Layer
 from mwx.controls import Param
@@ -13,7 +13,7 @@ def fftcrop(src):
     """Crop src image in 2**N square ROI centered at (x, y)."""
     h, w = src.shape
     m = min(h, w)
-    n = 1 if m < 2 else 2 ** int(np.log2(m) - 1) # +-m/2
+    n = 1 if m < 2 else 2 ** int(np.log2(m) - 1)  # +-m/2
     x, y = w//2, h//2
     return src[y-n:y+n, x-n:x+n]
 
@@ -28,30 +28,30 @@ class Plugin(Layer):
     """
     menukey = "Plugins/Extensions/&FFT view\tAlt+f"
     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.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.undefine_key('C-f')
         self.parent.undefine_key('C-S-f')
         return Layer.Destroy(self)
-    
+
     def newfft(self):
         """New FFT of graph to output."""
         frame = self.graph.frame
         if frame:
             self.message("FFT execution...")
-            src = fftcrop(frame.roi)
+            src = fftcrop(frame.roi_or_buffer)
             h, w = src.shape
             
             dst = fftshift(fft2(src))
@@ -60,27 +60,25 @@ class Plugin(Layer):
             u = 1 / w
             if self.pchk.Value:
                 u /= frame.unit
-            self.output.load(dst, "*fft of {}*".format(frame.name),
-                                  localunit=u)
+            self.output.load(dst, f"*fft of {frame.name}*", localunit=u)
             self.message("\b done")
-    
+
     def newifft(self):
         """New inverse FFT of output to graph."""
         frame = self.output.frame
         if frame:
             self.message("iFFT execution...")
-            src = frame.roi
+            src = frame.buffer  # Don't crop fft region
             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
+                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.graph.load(dst.real, f"*ifft of {frame.name}*", localunit=1/w/frame.unit)
             self.message("\b done")