lavavu 1.8.84__cp39-cp39-win_amd64.whl → 1.9.5__cp39-cp39-win_amd64.whl

lavavu/lavavu.py

@@ -14,7 +14,8 @@ See the :any:`lavavu.Viewer` class documentation for more information.
 """
 
 __all__ = ['Viewer', 'Object', 'Properties', 'ColourMap', 'DrawData', 'Figure', 'Geometry', 'Image', 'Video',
-           'download', 'grid2d', 'grid3d', 'cubehelix', 'loadCPT', 'matplotlib_colourmap', 'printH5', 'lerp',
+           'download', 'grid2d', 'grid3d', 'cubehelix', 'loadCPT', 'matplotlib_colourmap', 'printH5',
+           'lerp', 'vector_magnitude', 'vector_normalise', 'vector_align',
            'player', 'inject', 'hidecode', 'style', 'cellstyle', 'cellwidth',
            'version', 'settings', 'is_ipython', 'is_notebook', 'getname']
 
@@ -50,6 +51,9 @@ from collections import deque
 import time
 import weakref
 import asyncio
+import quaternion as quat
+import platform
+import matplotlib
 
 if sys.version_info[0] < 3:
     print("Python 3 required. LavaVu no longer supports Python 2.7.")
@@ -73,8 +77,38 @@ try:
 except (ImportError) as e:
     moderngl_window = None
 
+try:
+    import av
+except (ImportError) as e:
+    av = None
+
 #import swig module
-import LavaVuPython
+context = os.environ.get("LV_CONTEXT", "").strip()
+if platform.system() == 'Linux':
+    #Default context requires DISPLAY set for X11
+    display = os.environ.get("DISPLAY", "").strip()
+    if len(context) == 0: context = 'default'
+    if context != 'default' or len(display) == 0:
+        if context != 'osmesa':
+            try:
+                #Try EGL via moderngl, will use headless GPU if available
+                testctx = moderngl.create_context(standalone=True, require=330, backend='egl')
+                context = 'moderngl'
+            except Exception as e:
+                context = 'osmesa'
+
+        if context == 'osmesa':
+            #OSMesa fallback, CPU only, multicore
+            from osmesa import LavaVuPython
+
+#Default module if none already loaded
+try:
+    LavaVuPython
+except:
+    import LavaVuPython
+
+os.environ['LV_CONTEXT'] = context
+
 version = LavaVuPython.version
 server_ports = []
 
@@ -577,12 +611,12 @@ class Object(dict):
         return key in self.dict
 
     def __repr__(self):
-        return str(self.ref)
+        return self.__str__()
 
     def __str__(self):
         #Default string representation
         self.parent._get() #Ensure in sync
-        return '{\n' + str('\n'.join(['  %s=%s' % (k,json.dumps(v)) for k,v in self.dict.items()])) + '\n}\n'
+        return '{\n' + str('\n'.join(['  %s=%s' % (k,json.dumps(v)) for k,v in self.dict.items()])) + '\n}'
 
     #Interface for setting filters
     def include(self, *args, **kwargs):
@@ -1111,7 +1145,12 @@ class Object(dict):
             #Re-arrange to array of [r,g,b,a] values
             data = numpy.dstack((data[0],data[1],data[2]))
 
-        self._loadScalar(data, LavaVuPython.lucRGBAData)
+        #Use the shape as dims for texture image data
+        if len(data.shape) > 1:
+            width, height =  data.shape[1], data.shape[0]
+            depth = 4 #4 channel RGBA
+
+        self._loadScalar(data, LavaVuPython.lucRGBAData, width, height, depth)
 
 
     def luminance(self, data):
@@ -1133,7 +1172,7 @@ class Object(dict):
 
         self._loadScalar(data, LavaVuPython.lucLuminanceData, width, height, depth)
 
-    def texture(self, data=None, flip=True, filter=2, bgr=False, label=""):
+    def texture(self, data=None, flip=None, filter=2, bgr=False, label=""):
         """
         Load or clear texture data for object
 
@@ -1153,7 +1192,7 @@ class Object(dict):
             If not provided, will use the default/primary texture for the object
         flip : boolean
             flip the texture vertically after loading
-            (default is enabled as usually required for OpenGL but can be disabled)
+            (default is to load value from "fliptexture" property)
         filter : int
             type of filtering, 0=None/nearest, 1=linear, 2=mipmap linear
         bgr : boolean
@@ -1163,6 +1202,11 @@ class Object(dict):
             #Clear texture
             self.parent.app.clearTexture(self.ref)
             return
+        if flip is None:
+            if "fliptexture" in self:
+                flip = self["fliptexture"]
+            else:
+                flip = self.parent["fliptexture"]
         if isinstance(data, str):
             self.parent.app.setTexture(self.ref, data, flip, filter, bgr, label)
             return
@@ -1233,6 +1277,8 @@ class Object(dict):
             self.ref.colourMap = data.ref
             data = None
         else:
+            if isinstance(data, matplotlib.colors.Colormap):
+                data = matplotlib_cmap(data)
             if data is None:
                 self.parent._get() #Ensure in sync
                 cmid = self["colourmap"]
@@ -2052,13 +2098,15 @@ class _LavaVuWrapper(LavaVuPython.LavaVu):
     #Shared context
     _ctx = None
 
-    def __init__(self, threaded, runargs, resolution=None, binpath=None, context="default"):
+    def __init__(self, threaded, runargs, resolution=None, binpath=None, context=None):
         self.args = runargs
         self._closing = False
         self.resolution = resolution
         self._loop = None
 
         #OpenGL context creation options
+        if context is None:
+            context = os.environ.get("LV_CONTEXT", "default")
         havecontext = False
         self.use_moderngl = False
         self.use_moderngl_window = False
@@ -2319,11 +2367,10 @@ class _LavaVuWrapper(LavaVuPython.LavaVu):
                 if _LavaVuWrapper._ctx:
                     self.ctx = _LavaVuWrapper._ctx
                 else:
-                    import platform
                     if platform.system() == 'Linux':
                         self.ctx = moderngl.create_context(standalone=True, require=330, backend='egl')
                     else:
-                        self.ctx = moderngl.create_standalone_context(require=330)
+                        self.ctx = moderngl.create_context(standalone=True, require=330)
                     #print(self.ctx.info)
                     _LavaVuWrapper._ctx = self.ctx
 
@@ -2700,7 +2747,7 @@ class Viewer(dict):
 
     """
 
-    def __init__(self, *args, resolution=None, binpath=None, context="default", port=8080, threads=False, **kwargs):
+    def __init__(self, *args, resolution=None, binpath=None, context=None, port=8080, threads=False, **kwargs):
         """
         Create and init viewer instance
 
@@ -2716,6 +2763,7 @@ class Viewer(dict):
         context : str
             OpenGL context type, *"default"* will create a context and window based on available configurations.
             *"provided"* specifies a user provided context, set this if you have already created and activated the context. 
+            *"osmesa"* if built with the osmesa module, will use the self-contained software renderer to render without a window or GPU, needs to be set in LV_CONTEXT to work
             *"moderngl"* creates a context in python using the moderngl module (experimental). 
             *"moderngl."* creates a context and a window in python using the moderngl module (experimental) specify class after separator, eg: moderngl.headless, moderngl.pyglet, moderngl.pyqt5.
         port : int
@@ -2735,6 +2783,10 @@ class Viewer(dict):
         self._thread = None
         self._collections = {}
         self.validate = True #Property validation flag
+        self.recording = None
+        self.context = context
+        if self.context is None:
+            self.context = os.environ.get('LV_CONTEXT', 'default')
 
         #Exit handler to clean up threads
         #(__del__ does not always seem to get called on termination)
@@ -2775,7 +2827,7 @@ class Viewer(dict):
         if not binpath:
             binpath = os.path.abspath(os.path.dirname(__file__))
         try:
-            self.app = _LavaVuWrapper(threads, self.args(*args, **kwargs), resolution, binpath, context)
+            self.app = _LavaVuWrapper(threads, self.args(*args, **kwargs), resolution, binpath, self.context)
         except (RuntimeError) as e:
             print("LavaVu Init error: " + str(e))
             pass
@@ -3212,10 +3264,12 @@ class Viewer(dict):
             self.validate = self.state["properties"]["validate"]
         self._objects._sync()
 
-    def _set(self):
+    def _set(self, reload=None):
         #Export state to lavavu
         #(include current object list state)
         #self.state["objects"] = [obj.dict for obj in self._objects.list]
+        if reload is not None:
+            self.state["reload"] = reload
         self.app.setState(json.dumps(self.state))
 
     def commands(self, cmds, queue=False):
@@ -3695,7 +3749,7 @@ class Viewer(dict):
         else:
             return c.tolist()
 
-    def texture(self, label, data=None, flip=True, filter=2, bgr=False):
+    def texture(self, label, data=None, flip=None, filter=2, bgr=False):
         """
         Load or clear global/shared texture data
 
@@ -3714,7 +3768,7 @@ class Viewer(dict):
             Pass a string to load a texture from given filename
         flip : boolean
             flip the texture vertically after loading
-            (default is enabled as usually required for OpenGL but can be disabled)
+            (default is to load value from "fliptexture" property)
         filter : int
             type of filtering, 0=None/nearest, 1=linear, 2=mipmap linear
         bgr : boolean
@@ -3724,6 +3778,8 @@ class Viewer(dict):
             #Clear texture
             self.app.clearTexture(None, label)
             return
+        if flip is None:
+            flip = self["fliptexture"]
         if isinstance(data, str):
             self.app.setTexture(None, data, flip, filter, bgr, label)
             return
@@ -3821,6 +3877,9 @@ class Viewer(dict):
         Render a new frame, explicit display update
         """
         self.app.render()
+        #Video recording?
+        if self.recording:
+            self.recording.frame()
 
     def init(self):
         """        
@@ -4128,7 +4187,7 @@ class Viewer(dict):
         from IPython.display import display,HTML,Javascript
         display(Javascript(js + code))
 
-    def video(self, filename="", fps=30, quality=1, resolution=(0,0), **kwargs):
+    def video(self, filename="", resolution=(0,0), fps=30, quality=0, encoder="h264", player=None, options={}, **kwargs):
         """
         Record and show the generated video inline within an ipython notebook.
 
@@ -4145,25 +4204,36 @@ class Viewer(dict):
         ----------
         filename : str
             Name of the file to save, if not provided a default will be used
+        resolution : list or tuple
+            Video resolution in pixels [x,y]
         fps : int
             Frames to output per second of video
         quality : int
-            Encoding quality, 1=low(default), 2=medium, 3=high, higher quality reduces
+            Encoding quality, 1=low, 2=medium, 3=high, higher quality reduces
             encoding artifacts at cost of larger file size
-        resolution : list or tuple
-            Video resolution in pixels [x,y]
+            If omitted will use default settings, can fine tune settings in kwargs
+        encoder : str
+            Name of encoder to use, eg: "h264" (default), "mpeg"
+        player : dict
+            Args to pass to the player when the video is finished, eg:
+            {"width" : 800, "height", 400, "params": "controls autoplay"}
+        options : dict
+            Args to pass to the encoder, eg: see 
+            https://trac.ffmpeg.org/wiki/Encode/H.264
         **kwargs :
-            Any additional keyword args will be passed to lavavu.player()
+            Any additional keyword args will also be passed as options to the encoder
 
         Returns
         -------
         recorder : Video(object)
             Context manager object that controls the video recording
         """
-        return Video(self, filename, resolution, fps, quality, **kwargs)
+        return Video(self, filename, resolution, fps, quality, encoder, player, options, **kwargs)
 
-    def video_steps(self, filename="", start=0, end=0, fps=10, quality=1, resolution=(0,0), **kwargs):
+    def video_steps(self, filename="", start=0, end=0, resolution=(0,0), fps=30, quality=2, encoder="h264", player=None, options={}, **kwargs):
         """
+        TODO: Fix to use pyAV
+
         Record a video of the model by looping through all time steps
 
         Shows the generated video inline within an ipython notebook.
@@ -4181,20 +4251,26 @@ class Viewer(dict):
             First timestep to record, if not specified will use first available
         end : int
             Last timestep to record, if not specified will use last available
+        resolution : list or tuple
+            Video resolution in pixels [x,y]
         fps : int
             Frames to output per second of video
         quality : int
-            Encoding quality, 1=low(default), 2=medium, 3=high, higher quality reduces
+            Encoding quality, 1=low, 2=medium(default), 3=high, higher quality reduces
             encoding artifacts at cost of larger file size
-        resolution : list or tuple
-            Video resolution in pixels [x,y]
         **kwargs :
-            Any additional keyword args will be passed to lavavu.player()
+            Any additional keyword args will also be passed as options to the encoder
         """
 
         try:
-            fn = self.app.video(filename, fps, resolution[0], resolution[1], start, end, quality, **kwargs)
-            player(fn, **kwargs)
+            steps = self.steps
+            if end == 0: end = len(steps)
+            steps = steps[start:end]
+            from tqdm.notebook import tqdm
+            with Video(self, filename, resolution, fps, quality, encoder, player, options, **kwargs):
+                for s in tqdm(steps, desc='Rendering loop'):
+                    self.timestep(s)
+                    self.render()
         except (Exception) as e:
             print("Video output error: " + str(e))
             pass
@@ -4378,7 +4454,7 @@ class Viewer(dict):
         #Issue redisplay to active viewer
         self.control.redisplay()
 
-    def camera(self, data=None):
+    def camera(self, data=None, quiet=False):
         """
         Get/set the current camera viewpoint
 
@@ -4389,6 +4465,8 @@ class Viewer(dict):
         ----------
         data : dict
             Camera view to apply if any
+        quiet : bool
+            Skip print and calling "camera" script command which produces noisy terminal output
 
         Returns
         -------
@@ -4399,7 +4477,8 @@ class Viewer(dict):
         me = getname(self)
         if not me: me = "lv"
         #Also print in terminal for debugging
-        self.commands("camera")
+        if not quiet and not data:
+            self.commands("camera")
         #Get: export from first view
         vdat = {}
         if len(self.state["views"]) and self.state["views"][0]:
@@ -4407,27 +4486,110 @@ class Viewer(dict):
                 for key in ["translate", "rotate", "xyzrotate", "fov", "focus"]:
                     if key in src:
                         dst[key] = copy.copy(src[key])
-                        #Round down arrays to max 3 decimal places
+                        #Round down arrays to max 6 decimal places
                         try:
                             for r in range(len(dst[key])):
-                                dst[key][r] = round(dst[key][r], 3)
+                                dst[key][r] = round(dst[key][r], 6)
                         except:
                             #Not a list/array
                             pass
 
             copyview(vdat, self.state["views"][0])
 
-            print(me + ".translation(" + str(vdat["translate"])[1:-1] + ")")
-            print(me + ".rotation(" + str(vdat["xyzrotate"])[1:-1] + ")")
+            if not quiet and not data:
+                print(me + ".translation(" + str(vdat["translate"])[1:-1] + ")")
+                print(me + ".rotation(" + str(vdat["xyzrotate"])[1:-1] + ")")
 
             #Set
             if data is not None:
                 copyview(self.state["views"][0], data)
-                self._set()
+                self._set(reload=False)
 
         #Return
         return vdat
 
+    def lookat(self, pos, at=None, up=None):
+        """
+        Set the camera with a position coord and lookat coord
+
+        Parameters
+        ----------
+        pos : list/numpy.ndarray
+            Camera position in world coords
+        lookat : list/numpy.ndarray
+            Look at position in world coords, defaults to model origin
+        up : list/numpy.ndarray
+            Up vector, defaults to Y axis [0,1,0]
+        """
+
+        # Use the origin from viewer if no target provided
+        if at is None:
+            at = self["focus"]
+        else:
+            self.focus(*at)
+
+        # Default to Y-axis up vector
+        if up is None:
+            up = numpy.array([0, 1, 0])
+
+        # Calculate the rotation matrix
+        heading = numpy.array(pos) - numpy.array(at)
+        zd = vector_normalise(heading)
+        xd = vector_normalise(numpy.cross(up, zd))
+        yd = vector_normalise(numpy.cross(zd, xd))
+        q = quat.from_rotation_matrix(numpy.array([xd, yd, zd]))
+        q = q.normalized()
+
+        # Apply the rotation
+        self.rotation(q.x, q.y, q.z, q.w)
+
+        # Translate back by heading vector length in Z
+        # (model origin in lavavu takes care of lookat offset)
+        tr = [0, 0, -vector_magnitude(numpy.array(pos) - numpy.array(at))]
+
+        # Apply translation
+        self.translation(tr)
+
+    def camlerpto(self, pos, L):
+        # Lerp using current camera orientation as start point
+        pos0 = self.camera(quiet=True)
+        return self.camlerp(pos0, pos)
+
+    def camlerp(self, pos0, pos1, L):
+        """
+        Linearly Interpolate between two camera positions/orientations and
+        set the camera to the resulting position/orientation
+        """
+        final = {}
+        for key in ["translate", "rotate", "focus"]:
+            val0 = numpy.array(pos0[key])
+            val1 = numpy.array(pos1[key])
+            res = val0 + (val1 - val0) * L
+            if len(res) > 3:
+                # Normalise quaternion
+                res = res / numpy.linalg.norm(res)
+            final[key] = res.tolist()
+
+        self.camera(final, quiet=True)
+
+    def flyto(self, pos, steps, stop=False, callback=None):
+        # Fly using current camera orientation as start point
+        pos0 = self.camera(quiet=True)
+        return self.fly(pos0, pos, steps, stop, callback)
+
+    def fly(self, pos0, pos1, steps, stop=False, callback=None):
+        self.camera(pos0, quiet=True)
+        self.render()
+
+        for i in range(steps):
+            if stop and i > stop:
+                break
+            L = i / (steps - 1)
+            self.camlerp(pos0, pos1, L)
+            if callback is not None:
+                callback(self, i, steps)
+            self.render()
+
     def getview(self):
         """
         Get current view settings
@@ -5256,54 +5418,42 @@ def player(filename, params="controls autoplay loop", **kwargs):
         import uuid
         vid = 'video_' + str(uuid.uuid4())[:8]
 
-        '''
-        def get_fn(filename):
-            import os
-            #This is unreliable, path incorrect on NCI
-            nbpath = os.getenv('JPY_SESSION_NAME')
-            if nbpath is not None:
-                import os.path
-                relpath = os.path.relpath(os.getcwd(), start=os.path.dirname(nbpath))
-                return relpath + '/' + filename
-            return filename
-        ''';
-
-        import uuid
-        uid = uuid.uuid1()
-        
-        #Embed player
-        display(Video(url=os.path.relpath(filename), html_attributes=f"id='{vid}' " + params, **kwargs))
-
-        #Add download link
-        display(HTML(f'<a id="link_{vid}" href="{filename}" download>Download Video</a>'))
-
         # Fallback - replace url on gadi and similar jupyterhub installs with 
         # fixed working directory that doesn't match notebook dir
         # check the video tag url and remove subpath on 404 error
         display(Javascript(f"""
-        let el = document.getElementById('{vid}');
-        let url = el.src;
-        fetch(url, {{method: 'HEAD'}}).then(response=>{{
-          if(response.status == 404) {{
+        function video_error(el) {{
+            let url = el.src;
             console.log("Bad video url: " + url);
             let toppath = "/files/home/"
             let baseurl = url.substring(0, url.indexOf(toppath)+toppath.length);
             let endurl = url.substring(url.indexOf("{filename}"));
             let fixed = baseurl + endurl;
-            console.log("Replaced video url: " + fixed);
-            el.src = fixed;
-            //Also fix download link
-            document.getElementById('link_{vid}').href = fixed;
-          }}
-        }});
+            if (url != fixed) {{
+              console.log("Replaced video url: " + fixed);
+              el.src = fixed;
+              //Also fix download link
+              document.getElementById('link_{vid}').href = fixed;
+            }} else {{
+              console.log("Not replacing video url, no change: " + fixed);
+            }}
+        }}
         """))
-        
+
+        #Embed player
+        filename = os.path.relpath(filename)
+        display(Video(url=filename, html_attributes=f'id="{vid}" onerror="video_error(this)"' + params, **kwargs))
+
+        #Add download link
+        display(HTML(f'<a id="link_{vid}" href="{filename}" download>Download Video</a>'))
 
 #Class for managing video animation recording
 class Video(object):
     """
     The Video class provides an interface to record animations
 
+    This now uses pyAV avoiding the need to build LavaVu with ffmpeg support
+
     Example
     -------
 
@@ -5315,7 +5465,7 @@ class Video(object):
     ...         lv.rotate('y', 10) # doctest: +SKIP
     ...         lv.render()        # doctest: +SKIP
     """
-    def __init__(self, viewer=None, filename="", resolution=(0,0), framerate=30, quality=1, **kwargs):
+    def __init__(self, viewer, filename="output.mp4", resolution=(0,0), framerate=30, quality=2, encoder="h264", player=None, options={}, **kwargs):
         """
         Record and show the generated video inline within an ipython notebook.
 
@@ -5335,79 +5485,149 @@ class Video(object):
         fps : int
             Frames to output per second of video
         quality : int
-            Encoding quality, 1=low(default), 2=medium, 3=high, higher quality reduces
+            Encoding quality, 1=low, 2=medium(default), 3=high, higher quality reduces
             encoding artifacts at cost of larger file size
+            If omitted will use default settings, can fine tune settings in kwargs
         resolution : list or tuple
             Video resolution in pixels [x,y]
+        encoder : str
+            Name of encoder to use, eg: "h264" (default), "mpeg"
+        player : dict
+            Args to pass to the player when the video is finished, eg:
+            {"width" : 800, "height", 400, "params": "controls autoplay"}
+        options : dict
+            Args to pass to the encoder, eg: see 
+            https://trac.ffmpeg.org/wiki/Encode/H.264
         **kwargs :
-            Any additional keyword args will be passed to lavavu.player()
+            Any additional keyword args will also be passed as options to the encoder
         """
-        self.resolution = resolution
+        if av is None:
+            raise(ImportError("Video output not supported without pyAV - pip install av"))
+            return
+        self.resolution = list(resolution)
+        if self.resolution[0] == 0 or self.resolution[1] == 0:
+            self.resolution = (viewer.app.viewer.width, viewer.app.viewer.height)
+        #Ensure resolution values are even or encoder fails
+        self.resolution = (2 * int(self.resolution[0]//2), 2 * int(self.resolution[1] // 2))
         self.framerate = framerate
         self.quality = quality
         self.viewer = viewer
         self.filename = filename
-        self.kwargs = kwargs
-        if not viewer:
-            self.encoder = LavaVuPython.VideoEncoder(filename, framerate, quality);
-        else:
-            self.encoder = None
+        self.player = player
+        if self.player is None:
+            #Default player is half output resolution, unless < 900 then full
+            if "width" in kwargs or "height" in kwargs or "params" in kwargs:
+                #Back compatibility with old args
+                self.player = {}
+                self.player.update(kwargs)
+                kwargs = {}
+            elif self.resolution[0] > 900:
+                #Larger output res - default to half size player
+                self.player = {"width": self.resolution[0]//2, "height": self.resolution[1]//2}
+            else:
+                self.player = {}
+        self.encoder = encoder
+        self.options = options
+        #Also include extra args
+        options.update(kwargs)
+        self.container = None
 
     def start(self):
         """
         Start recording, all rendered frames will be added to the video
         """
-        if self.encoder:
-            if self.resolution[0] <= 0: self.resolution[0] = 1280
-            if self.resolution[1] <= 0: self.resolution[1] = 720
-            self.encoder.open(self.resolution[0], self.resolution[1])
-        else:
-            self.filename = self.viewer.app.encodeVideo(self.filename, self.framerate, self.quality, self.resolution[0], self.resolution[1])
-        #Clear existing image frames
-        if os.path.isdir(self.filename):
-            for f in glob.glob(self.filename + "/frame_*.jpg"):
-                os.remove(f)
+        #https://trac.ffmpeg.org/wiki/Encode/H.264
+        # The range of the CRF scale is 0–51, where 0 is lossless (for 8 bit only, for 10 bit use -qp 0), 
+        # 23 is the default, and 51 is worst quality possible
+        #Compression level, lower = high quality
+        #See also: https://github.com/PyAV-Org/PyAV/blob/main/tests/test_encode.py
+        options = {}
+        if self.encoder == 'h264' or self.encoder == 'libx265':
+            #Only have default options for h264/265 for now
+            if self.quality == 1:
+                options['qmin'] = '30' #'20' #'8'
+                options['qmax'] = '35' #'41'
+                options['crf'] = '30' #'40'
+            elif self.quality == 2:
+                options['qmin'] = '25' #'2'
+                options['qmax'] = '30' #'31'
+                options['crf'] = '20' #'23'
+            elif self.quality == 3:
+                options['qmin'] = '20' #'1'
+                options['qmax'] = '25' #'4'
+                options['crf'] = '10' #'10'
+
+            #Default preset, tune for h264
+            options["preset"] = 'veryfast' #'veryfast' 'medium' 'slow'
+            options["tune"] = 'animation' #'film'
+
+            #Settings from our original c++ encoder
+            #self.options['i_quant_factor'] = '0.71'
+            #self.options['qcompress'] = '0.6'
+            #self.options['max_qdiff'] = '4'
+            #self.options['refs'] = '3'
+
+        #Merge user options, allowing override of above settings
+        options.update(self.options)
+
+        #print(options)
+        self.container = av.open(self.filename, mode="w")
+        self.stream = self.container.add_stream(self.encoder, rate=self.framerate, options=options)
+        self.stream.width = self.resolution[0]
+        self.stream.height = self.resolution[1]
+        self.stream.pix_fmt = "yuv420p"
+        self.viewer.recording = self
+
+        stream = self.stream
+        #print(stream)
+        #print(stream.codec)
+        #print(stream.codec_context)
+        #print(stream.profiles)
+        #print(stream.profile)
+        #print(stream.options)
+        #Need to set profile here or it isn't applied
+        #(Default to main)
+        stream.profile = 'Main' #Baseline / High
+        cc = stream.codec_context
+        #print(cc.options)
+        #print(cc.profile)
+
+    def frame(self):
+        """
+        Write a frame, called when viewer.render() is called
+        while a recording is in progress
+        """
+        img = self.viewer.rawimage(resolution=self.resolution, channels=3)
+        frame = av.VideoFrame.from_ndarray(img.data, format="rgb24")
+        for packet in self.stream.encode(frame):
+            self.container.mux(packet)
 
     def pause(self):
         """
         Pause/resume recording, no rendered frames will be added to the video while paused
         """
-        if self.encoder:
-            self.encoder.render = not self.encoder.render
+        if self.viewer.recording:
+            self.viewer.recording = None
         else:
-            self.viewer.app.pauseVideo()
+            self.viewer.recording = self
 
     def stop(self):
         """
         Stop recording, final frames will be written and file closed, ready to play. 
         No further frames will be added to the video
         """
-        if self.encoder:
-            self.encoder.close()
-            self.filename = self.encoder.filename
-        else:
-            self.viewer.app.encodeVideo()
-        #Check if encoded video is a directory (not built with video encoding support)
-        #if so attempt to encode with ffmpeg
-        if os.path.isdir(self.filename):
-            log = ""
-            ffmpeg_exe = 'ffmpeg'
-            try:
-                outfn = '{0}.mp4'.format(self.filename)
-                cmd = ffmpeg_exe + ' -r {1} -i "{0}/frame_%05d.jpg" -c:v libx264 -vf fps={1} -movflags +faststart -pix_fmt yuv420p -y "{2}"'.format(self.filename, self.framerate, outfn)
-                log += "No built in video encoding, attempting to build movie from frames with ffmpeg:\n"
-                log += cmd
-
-                import subprocess
-                #os.system(cmd)
-                subprocess.check_call(cmd, shell=True)
-                self.filename = outfn
-            except (Exception) as e:
-                print("Video encoding failed: ", str(e), "\nlog:\n", log)
+        # Flush stream
+        for packet in self.stream.encode():
+            self.container.mux(packet)
+        # Close the file
+        self.container.close()
+        self.container = None
+        self.stream = None
+        self.viewer.recording = None
 
     def write(self, image):
         """
-        Add a frame to the video (when writing custom video frames rather than rendering them within lavavu)
+        Add a frame to the video
 
         Parameters
         ----------
@@ -5415,7 +5635,7 @@ class Video(object):
             Pass a list or numpy uint8 array of rgba values or an Image object
             values are loaded as 8 bit unsigned integer values
         """
-        if self.encoder:
+        if self.container:
             if isinstance(image, Image):
                 image = image.data
             else:
@@ -5423,13 +5643,17 @@ class Video(object):
             if image.size == self.resolution[0] * self.resolution[1] * 4:
                 image = image.reshape(self.resolution[0], self.resolution[1], 4)
                 image = image[::,::,:3] #Remove alpha channel
-            self.encoder.copyframe(image.ravel())
+            #self.encoder.copyframe(image.ravel())
+
+            frame = av.VideoFrame.from_ndarray(image, format="rgb24")
+            for packet in self.stream.encode(frame):
+                self.container.mux(packet)
 
     def play(self):
         """
-        Show the video in an inline player if in an interative notebook
+        Show the video in an inline player if in an interactive notebook
         """
-        player(self.filename, **self.kwargs)
+        player(self.filename, **self.player)
 
     def __enter__(self):
         self.start()
@@ -5848,6 +6072,56 @@ def lerp(first, second, mu):
         final[i] += diff * mu
     return final
 
+def vector_magnitude(vec):
+    return numpy.linalg.norm(vec)
+
+def vector_normalise(vec):
+    norm = numpy.linalg.norm(vec)
+    if norm == 0:
+        vn = vec
+    else:
+        vn = vec / norm
+    return vn
+
+def vector_align(v1, v2, lvformat=True):
+    """
+    Get a rotation quaterion to align vectors v1 with v2
+
+    Parameters
+    ----------
+    v1 : list/numpy.ndarray
+         First 3 component vector
+    v2 : list/numpy.ndarray
+         Second 3 component vector to align the first to
+
+    Returns
+    -------
+    list: quaternion to rotate v1 to v2 (in lavavu format)
+    """
+
+    # Check for parallel or opposite
+    v1 = vector_normalise(numpy.array(v1))
+    v2 = vector_normalise(numpy.array(v2))
+    epsilon = numpy.finfo(numpy.float32).eps
+    one_minus_eps = 1.0 - epsilon
+    if numpy.dot(v1, v2) > one_minus_eps:  #  1.0
+        # No rotation
+        return [0, 0, 0, 1]
+    elif numpy.dot(v1, v2) < -one_minus_eps:  # -1.0
+        # 180 rotation about Y
+        return [0, 1, 0, 1]
+    xyz = numpy.cross(v1, v2)
+    l1 = numpy.linalg.norm(v1)
+    l2 = numpy.linalg.norm(v2)
+    w = math.sqrt((l1 * l1) * (l2 * l2)) + numpy.dot(v1, v2)
+    qr = quat.quaternion(w, xyz[0], xyz[1], xyz[2])
+    qr = qr.normalized()
+    # Return in LavaVu quaternion format
+    if lvformat:
+        return [qr.x, qr.y, qr.z, qr.w]
+    else:
+        return qr
+
 if __name__ == '__main__':
     #Run doctests - only works on numpy 1.14+ due to changes in array printing
     npyv = numpy.__version__.split('.')
@@ -5857,3 +6131,4 @@ if __name__ == '__main__':
         import doctest
         doctest.testmod()
 
+