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

lavavu/html/webview.html

@@ -27,7 +27,7 @@
 
     <input id="fileinput" type="file" style="visibility:hidden" onchange="useFileInput(this)" />
 
-    <script async src="https://cdn.jsdelivr.net/gh/lavavu/lavavu.github.io@1.8.84/LavaVu-amalgamated.min.js"></script>
+    <script async src="https://cdn.jsdelivr.net/gh/lavavu/lavavu.github.io@1.9.0/LavaVu-amalgamated.min.js"></script>
     <!--script src="dat.gui.min.js"></script>
     <script src="OK-min.js"></script>
 

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,8 @@ from collections import deque
 import time
 import weakref
 import asyncio
+import quaternion as quat
+import platform
 
 if sys.version_info[0] < 3:
     print("Python 3 required. LavaVu no longer supports Python 2.7.")
@@ -73,8 +76,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 = []
 
@@ -2052,13 +2085,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 +2354,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
 
@@ -2716,6 +2750,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 +2770,8 @@ class Viewer(dict):
         self._thread = None
         self._collections = {}
         self.validate = True #Property validation flag
+        self.recording = None
+        self.context = os.environ.get('LV_CONTEXT', context)
 
         #Exit handler to clean up threads
         #(__del__ does not always seem to get called on termination)
@@ -2775,7 +2812,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
@@ -3821,6 +3858,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 +4168,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 +4185,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):
         """
+        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.
@@ -4378,7 +4429,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 +4440,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 +4452,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]:
@@ -4417,8 +4471,9 @@ class Viewer(dict):
 
             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:
@@ -4428,6 +4483,88 @@ class Viewer(dict):
         #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)
+
+    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)
+        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
@@ -5268,11 +5405,9 @@ def player(filename, params="controls autoplay loop", **kwargs):
             return filename
         ''';
 
-        import uuid
-        uid = uuid.uuid1()
-        
         #Embed player
-        display(Video(url=os.path.relpath(filename), html_attributes=f"id='{vid}' " + params, **kwargs))
+        filename = os.path.relpath(filename)
+        display(Video(url=filename, html_attributes=f"id='{vid}' " + params, **kwargs))
 
         #Add download link
         display(HTML(f'<a id="link_{vid}" href="{filename}" download>Download Video</a>'))
@@ -5304,6 +5439,8 @@ 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 +5452,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=None, filename="", resolution=(0,0), framerate=30, quality=0, encoder="h264", player=None, options={}, **kwargs):
         """
         Record and show the generated video inline within an ipython notebook.
 
@@ -5335,79 +5472,141 @@ 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, 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
         """
+        if av is None:
+            raise(ImportError("Video output not supported without pyAV - pip install av"))
+            return
         self.resolution = resolution
+        if self.resolution[0] == 0:
+            self.resolution = viewer.width
+        if self.resolution[1] == 0:
+            self.resolution = viewer.height
         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
+        if len(self.filename) == 0:
+            self.filename = "lavavu.mp4"
+        self.player = player
+        if self.player is None:
+            #Default player is half output resolution
+            self.player = {"width": self.resolution[0] // 2, "height": self.resolution[1] // 2}
+        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
 
     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 +5614,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 +5622,18 @@ 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
         """
-        player(self.filename, **self.kwargs)
+        print(self.player)
+        player(self.filename, **self.player)
 
     def __enter__(self):
         self.start()
@@ -5848,6 +6052,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 +6111,4 @@ if __name__ == '__main__':
         import doctest
         doctest.testmod()
 
+