lavavu 1.9.9__cp312-cp312-macosx_10_13_x86_64.whl → 1.9.10__cp312-cp312-macosx_10_13_x86_64.whl

lavavu/LavaVuPython.py

@@ -5,12 +5,14 @@
 # the SWIG interface file instead.
 
 from sys import version_info as _swig_python_version_info
-# Import the low-level C/C++ module
-if __package__ or "." in __name__:
-    from . import _LavaVuPython
+
+import os
+if 'osmesa' in os.environ.get('LV_CONTEXT', ''):
+    from osmesa import _LavaVuPython
 else:
     import _LavaVuPython
 
+
 try:
     import builtins as __builtin__
 except ImportError:

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.9.9/LavaVu-amalgamated.min.js"></script>
+    <script async src="https://cdn.jsdelivr.net/gh/lavavu/lavavu.github.io@1.9.10/LavaVu-amalgamated.min.js"></script>
     <!--script src="dat.gui.min.js"></script>
     <script src="OK-min.js"></script>
 

lavavu/lavavu.py

@@ -59,6 +59,7 @@ import quaternion as quat
 import platform
 import matplotlib
 from pathlib import Path
+from PIL import Image as PILImage
 
 if sys.version_info[0] < 3:
     print("Python 3 required. LavaVu no longer supports Python 2.7.")
@@ -101,10 +102,7 @@ if platform.system() == 'Linux':
                 context = 'moderngl'
             except Exception as e:
                 context = 'osmesa'
-
-        if context == 'osmesa':
-            #OSMesa fallback, CPU only, multicore
-            from osmesa import LavaVuPython
+            os.environ['LV_CONTEXT'] = context
 
 #Default module if none already loaded
 try:
@@ -112,8 +110,6 @@ try:
 except:
     import LavaVuPython
 
-os.environ['LV_CONTEXT'] = context
-
 version = LavaVuPython.version
 server_ports = []
 
@@ -4194,7 +4190,7 @@ class Viewer(dict):
         from IPython.display import display,HTML,Javascript
         display(Javascript(js + code))
 
-    def video(self, filename="", resolution=(0,0), fps=30, quality=2, encoder="h264", embed=False, player=None, options={}, **kwargs):
+    def video(self, filename="", resolution=(0,0), fps=30, quality=2, encoder=None, embed=False, player=None, options={}, **kwargs):
         """
         Record and show the generated video inline within an ipython notebook.
 
@@ -4220,7 +4216,7 @@ class Viewer(dict):
             encoding artifacts at cost of larger file size
             If omitted will use default settings, can fine tune settings in kwargs
         encoder : str
-            Name of encoder to use, eg: "h264" (default), "mpeg"
+            Name of encoder to use, eg: "h264" (default for .mp4), default will be selected based on filename extension
         embed : bool
             Set to true to embed the video file rather than link to url
             Not recommended for large videos, default is False
@@ -4240,8 +4236,7 @@ class Viewer(dict):
         """
         return Video(self, filename, resolution, fps, quality, encoder, embed, player, options, **kwargs)
 
-    def video_steps(self, filename="", start=0, end=0, resolution=(0,0), fps=30, quality=2, encoder="h264", embed=False, player=None, options={}, **kwargs):
-        my_func.__doc__
+    def video_steps(self, filename="", start=0, end=0, resolution=(0,0), fps=30, quality=2, encoder=None, embed=False, player=None, options={}, **kwargs):
         """
         Record a video of the model by looping through all time steps
 
@@ -5479,7 +5474,7 @@ class Video(object):
     ...         lv.rotate('y', 10) # doctest: +SKIP
     ...         lv.render()        # doctest: +SKIP
     """
-    def __init__(self, viewer, filename="output.mp4", resolution=(0,0), framerate=30, quality=2, encoder="h264", embed=False, player=None, options={}, **kwargs):
+    def __init__(self, viewer, filename="output.mp4", resolution=(0,0), framerate=30, quality=2, encoder=None, embed=False, player=None, options={}, **kwargs):
         """
         Record and show the generated video inline within an ipython notebook.
 
@@ -5505,7 +5500,7 @@ class Video(object):
         resolution : list or tuple
             Video resolution in pixels [x,y]
         encoder : str
-            Name of encoder to use, eg: "h264" (default), "mpeg"
+            Name of encoder to use, eg: "h264" (default for .mp4), default will be selected based on filename extension
         embed : bool
             Set to true to embed the video file rather than link to url
             Not recommended for large videos, default is False
@@ -5555,6 +5550,22 @@ class Video(object):
                 self.player = {}
         if embed:
             self.player["embed"] = True
+        if encoder is None:
+            if self.filename.suffix.lower() == '.mp4':
+                encoder = 'h264'
+            elif self.filename.suffix.lower() == '.webm':
+                encoder = 'libvpx-vp9'
+            elif self.filename.suffix.lower() == '.webp':
+                encoder = 'libwebp_anim'
+                options["lossless"] = "1"
+                options['pix_fmt'] = "rgb32" #Required for lossless
+                options["loop"] = "0" #This doesn't work, quality also has no effect
+                options["quality"] = str(min(30 + self.quality * 20, 100))
+            elif self.filename.suffix.lower() == '.gif':
+                encoder = 'gif'
+                options['pix_fmt'] = "rgb8"
+            else:
+                encoder = 'h264'
         self.encoder = encoder
         self.options = options
         #Also include extra args
@@ -5565,7 +5576,6 @@ class Video(object):
         """
         Start recording, all rendered frames will be added to the video
         """
-        #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
@@ -5578,7 +5588,8 @@ class Video(object):
             return
 
         if self.encoder == 'h264' or self.encoder == 'libx265':
-            #Only have default options for h264/265 for now
+            #https://trac.ffmpeg.org/wiki/Encode/H.264
+            #options['pix_fmt'] = "yuv420"
             if self.quality == 1:
                 options['qmin'] = '30' #'20' #'8'
                 options['qmax'] = '35' #'41'
@@ -5596,21 +5607,26 @@ class Video(object):
             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'
+        elif self.encoder == 'libvpx-vp9':
+            #https://trac.ffmpeg.org/wiki/Encode/VP9
+            options['crf'] = '15'
+            options['b:v'] = '0' #Required for constant quality single pass
+            if self.quality == 1:
+                options['crf'] = '30' #'40'
+            elif self.quality == 2:
+                options['crf'] = '20' #'23'
+            elif self.quality == 3:
+                options['crf'] = '10' #'10'
+                #options['pix_fmt'] = "yuv444p"
 
         #Merge user options, allowing override of above settings
         options.update(self.options)
+        #print(options, self.encoder)
 
-        #print(options)
         self.container = av.open(str(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
@@ -5620,14 +5636,52 @@ class Video(object):
         #print(stream.profiles)
         #print(stream.profile)
         #print(stream.options)
+
+        if 'pix_fmt' in options:
+            self.stream.pix_fmt = options['pix_fmt']
+        #Select higher quality colour where supported
+        elif self.encoder == 'h264' or self.encoder == 'libx265' or self.encoder == 'libvpx-vp9':
+            #Reduce chroma subsampling for better colour output
+            if self.quality < 3:
+                self.stream.pix_fmt = "yuv420p"
+            else:
+                self.stream.pix_fmt = "yuv422p"
+            #10 bit formats
+            #self.stream.pix_fmt = "yuv444p10le"
+            #self.stream.pix_fmt = "yuv422p10le"
+
         #Need to set profile here or it isn't applied
-        #(Default to main)
-        stream.profile = 'Main' #Baseline / High
+        #(better chroma sampling requires the correct profile)
+        if 'profile' in options:
+            stream.profile = options['profile']
+        elif self.encoder == 'h264' or self.encoder == 'libx265':
+            #['Baseline', 'Constrained Baseline', 'Main', 'Extended',
+            # 'High', 'High 10', 'High 10 Intra', 'High 4:2:2',
+            # 'High 4:2:2 Intra', 'High 4:4:4', 'High 4:4:4 Predictive',
+            # 'High 4:4:4 Intra', 'CAVLC 4:4:4', 'Multiview High', 'Stereo High']
+                    #stream.profile = 'High 4:4:4'
+            if self.stream.pix_fmt == 'yuv420p':
+                stream.profile = 'Main'
+            elif 'yuv422' in self.stream.pix_fmt:
+                stream.profile = 'High 4:2:2'
+            elif 'yuv444' in self.stream.pix_fmt:
+                stream.profile = 'High 4:4:4'
+        elif self.encoder == 'libvpx-vp9':
+            #Profile Color Depth    Chroma Subsampling
+            #0       8 bit/sample   4:2:0
+            #1       8 bit          4:2:2,4:4:4
+            #2       10 or 12 bit   4:2:0
+            #3       10 or 12 bit   4:2:2, 4:4:4
+            if self.stream.pix_fmt == 'yuv420p':
+                stream.profile = 'Profile 0'
+            elif 'yuv422' in self.stream.pix_fmt or 'yuv444' in self.stream.pix_fmt:
+                stream.profile = 'Profile 1'
+
         cc = stream.codec_context
         #print(cc.options)
-        #print(cc.profile)
+        #print(cc.profile, stream.pix_fmt)
 
-    def frame(self):
+    def frame(self, img=None):
         """
         Write a frame, called when viewer.render() is called
         while a recording is in progress
@@ -5639,10 +5693,17 @@ class Video(object):
             else:
                 fn = self.filename / f"{self.framecount:06}_{self.basename}.{self.encoder}"
             self.framecount += 1
-            self.viewer.image(str(fn), resolution=self.resolution)
+            if img:
+                image = PILImage.fromarray(img)
+                image.save(fn)
+                image.save(fn, subsampling=0, quality=95)
+            else:
+                self.viewer.image(str(fn), resolution=self.resolution)
         else:
-            img = self.viewer.rawimage(resolution=self.resolution, channels=3)
-            frame = av.VideoFrame.from_ndarray(img.data, format="rgb24")
+            if img is None:
+                img = self.viewer.rawimage(resolution=self.resolution, channels=3).data
+            frame = av.VideoFrame.from_ndarray(img, format="rgb24")
+            #frame = av.VideoFrame.from_image(PILImage.fromarray(img)) #, format="rgb24")
             for packet in self.stream.encode(frame):
                 self.container.mux(packet)
 
@@ -5697,23 +5758,16 @@ class Video(object):
                 image = image.reshape(self.resolution[0], self.resolution[1], 4)
                 image = image[::,::,:3] #Remove alpha channel
 
-            if self.encoder == 'jpg' or self.encoder == 'png':
-                from PIL import Image as PILImage
-                img = PILImage.fromarray(image)
-                fn = self.filename / f"{self.framecount:06}_{self.basename}.{self.encoder}"
-                self.framecount += 1
-                img.save(fn)
-                return
-
-            frame = av.VideoFrame.from_ndarray(image, format="rgb24")
-            for packet in self.stream.encode(frame):
-                self.container.mux(packet)
+            self.frame(image)
 
     def play(self):
         """
         Show the video in an inline player if in an interactive notebook
         """
-        if self.encoder == 'jpg' or self.encoder == 'png':
+        if self.encoder == 'gif' or self.encoder == 'libwebp_anim':
+            from IPython.display import display,Image
+            display(Image(self.filename, **self.player))
+        elif self.encoder == 'jpg' or self.encoder == 'png':
             from IPython.display import display,HTML
             display(HTML('<p>Video written to images, no player available</p>'))
         else:
@@ -5841,7 +5895,6 @@ class Image(object):
         """
         try:
             #Get array from PIL images
-            from PIL import Image as PILImage
             if isinstance(source, PILImage.Image):
                 source = numpy.array(source)
         except (ImportError) as e:

lavavu/tracers.py

@@ -24,7 +24,7 @@ def random_particles(count, lowerbound=[0,0,0], upperbound=[1,1,1], dims=3):
     return numpy.stack(p).T
 
 class Tracers():
-    def __init__(self, grid, count=1000, lowerbound=None, upperbound=None, limit=None, age=4, respawn_chance=0.2, speed_multiply=1.0, height=0.0, label='', viewer=None):
+    def __init__(self, grid, count=1000, lowerbound=None, upperbound=None, limit=0, age=4, respawn_chance=0.2, speed_multiply=1.0, height=0.0, label='', viewer=None, seed=0):
         """
         Seed random particles into a vector field and trace their positions
 
@@ -40,10 +40,7 @@ class Tracers():
         upperbound : optional maximum vertex point defining particle bounding box,
             if not provided will be taken from grid upper corner
         limit : float
-            Distance limit over which tracers are not connected,
-            For example if using a periodic boundary, setting limit to
-            half the bounding box size will prevent tracer lines being
-            connected when passing through the boundary
+            Distance limit over which tracers are not drawn
         age : int
             Minimum particle age in steps after which particle can be deleted and respawned, defaults to 4
         respawn : float
@@ -56,6 +53,9 @@ class Tracers():
             Name label prefix for the visualisation objects when plotting
         viewer : lavavu.Viewer
             Viewer object for plotting functions
+        seed : int
+            Random seed for deterministic random particle positions, default=0, set to None to use
+            system time which will produce non-deterministic results (different each run)
         """
         if len(grid) == 2:
             self.gridx = grid[0]
@@ -108,20 +108,18 @@ class Tracers():
         self.arrows = None
         self.tracers = None
 
+        if seed is not None:
+            random.seed(seed)
 
     def respawn(self, r):
         #Dead or out of bounds particle, start at new position
         #Loop until new position further from current position than limit
         old_pos = self.positions[r]
         pos = numpy.array([0.] * self.dims)
-        for i in range(10):
-            pos = random_particles(1, self.lowerbound, self.upperbound, self.dims)
-            dist = numpy.linalg.norm(old_pos - pos)
-            if dist > self.limit*1.01:
-                break
-
+        pos = random_particles(1, self.lowerbound, self.upperbound, self.dims)
         self.ages[r] = 0
         self.positions[r] = pos
+        self.velocities[r] = numpy.array([0.0] * self.dims)
 
     def update(self, vectors=None):
         #Interpolate velocity at all positions,
@@ -140,24 +138,21 @@ class Tracers():
 
         for r in range(len(self.velocities)):
             #Lookup velocity at this index, multiply by position to get delta and add
-            self.speed[r] = numpy.linalg.norm(self.velocities[r])
-            if numpy.isnan(self.speed[r]): self.speed[r] = 0.0
-            if self.speed[r] == 0.0: #numpy.any(numpy.isinf(self.old_pos[r])) or numpy.any(numpy.isinf(self.positions[r])):
+            if self.ages[r] < 0:
                 self.respawn(r)
             else:
+                self.speed[r] = numpy.linalg.norm(self.velocities[r])
+                if numpy.isnan(self.speed[r]) or numpy.isinf(self.speed[r]): self.speed[r] = 0.0
                 self.positions[r] = self.positions[r] + self.speed_multiply * self.velocities[r]
                 self.ages[r] += 1
 
-            #Bounds checks
-            #Chance of killing particle when over age, default 1 in 5 (0.2)
-            if (any(self.positions[r] < self.lowerbound[0:self.dims]) or any(self.positions[r] > self.upperbound[0:self.dims])
-            or (self.ages[r] > self.age and numpy.random.uniform() <= self.respawn_chance)):
-                #if r < 20: print("Kill", r, self.speed[r], numpy.isnan(self.speed[r])) # [0] == numpy.nan)
-                #self.positions[r] = numpy.array([numpy.inf] * self.dims)
-                #self.positions[r] = numpy.array([numpy.nan] * self.dims)
-                self.respawn(r)
-                self.velocities[r] = numpy.array([0.0] * self.dims)
-                self.speed[r] = 0.0
+                #Bounds checks
+                #Chance of killing particle when over age, default 1 in 5 (0.2)
+                if (any(self.positions[r] < self.lowerbound[0:self.dims]) or any(self.positions[r] > self.upperbound[0:self.dims])
+                or (self.ages[r] > self.age and numpy.random.uniform() <= self.respawn_chance)):
+                    self.positions[r] = numpy.array([numpy.nan] * self.dims)
+                    self.ages[r] = -1
+                    self.velocities[r] = numpy.array([0.0] * self.dims)
 
         if self.lv:
             positions = self.get_positions()

{lavavu-1.9.9.dist-info → lavavu-1.9.10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lavavu
-Version: 1.9.9
+Version: 1.9.10
 Summary: Python interface to LavaVu OpenGL 3D scientific visualisation utilities
 Author-email: Owen Kaluza <owen@kaluza.id.au>
 License: ### Licensing
@@ -217,6 +217,7 @@ Requires-Dist: aiohttp
 Requires-Dist: jupyter_server_proxy
 Requires-Dist: matplotlib
 Requires-Dist: numpy-quaternion
+Requires-Dist: pillow
 Dynamic: license-file
 
 ![# logo](http://owen.kaluza.id.au/Slides/2017-08-15/LavaVu.png)
@@ -224,7 +225,7 @@ Dynamic: license-file
 [![Build Status](https://github.com/lavavu/LavaVu/workflows/Test/badge.svg)](https://github.com/lavavu/LavaVu/actions?query=workflow:Test)
 [![Deploy Status](https://github.com/lavavu/LavaVu/workflows/Deploy/badge.svg?branch=1.7.3)](https://github.com/lavavu/LavaVu/actions?query=workflow:Deploy)
 [![DOI](https://zenodo.org/badge/45163055.svg)](https://zenodo.org/badge/latestdoi/45163055)
-[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/lavavu/LavaVu/1.9.9)
+[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/lavavu/LavaVu/1.9.10)
 
 A scientific visualisation tool with a python interface for fast and flexible visual analysis.
 

{lavavu-1.9.9.dist-info → lavavu-1.9.10.dist-info}/RECORD

@@ -1,11 +1,11 @@
-lavavu/lavavu.py,sha256=v7tXwp6gQzu1F05hHyALng8FXznv4rVwdCJ3sO65O8o,221223
+lavavu/lavavu.py,sha256=_OIsRSNqCrsfcOrRfjWMQKOV5r8dAvZVnmxZK9deDNc,224022
 lavavu/vutils.py,sha256=6Vm_xl1bp9mWlfk7jgLDwbRw-tdE_oxin77YkLel3_4,5437
 lavavu/dict.json,sha256=EcJsoHsiHDDmM8FGuBRF6eOG2nMr-Pda3sxE6v6KB80,52952
 lavavu/server.py,sha256=L-_yPCbNfwYxJCPjDQtr_lxPnDp4oMNVFyxXhBERYrQ,12468
 lavavu/points.py,sha256=jRRtA6CrcA46Y2jUJmkxnIiVoMC5a14xEd_ojhmjhz4,5871
-lavavu/_LavaVuPython.cpython-312-darwin.so,sha256=RrzmoM4H_Pn9SsNxvm2IfVragUTXyHeZntVLBlhPKyU,4125776
-lavavu/LavaVuPython.py,sha256=ixhceiAr0gGGfCe3d2cY0IIgS4hbgoYJGa_RfgAmmrU,33207
-lavavu/tracers.py,sha256=e10H8evUH7V-XUSkHjfoakaA4SfeuQ8-gWzfa86RGzQ,8997
+lavavu/_LavaVuPython.cpython-312-darwin.so,sha256=ie5pmQT6haAiM0qFLe8lsVFJKSmXVwzDWpU_Ff0K-ZA,4125776
+lavavu/LavaVuPython.py,sha256=rTMSBgFkQNzZ0cv1HSFGW7dIxYryoJSlSXhi3uKb1eI,33202
+lavavu/tracers.py,sha256=KZsCxHQm6EDdXfT997lbV6qqIEONNPeTP1R8GHqepOw,8738
 lavavu/convert.py,sha256=tbYRjLE2l1hI4d6tsW41Lia1JXmrWSc0-JAYCiMrjys,35516
 lavavu/control.py,sha256=s32rtLPXXYtxpeXd6-iHdupmaMTJ3KhK6Vq-CLjf9OQ,66755
 lavavu/__init__.py,sha256=JroZQiUbuVN7ifixk2zNDGlyLGaM8bqfRbw4D_F9qIQ,191
@@ -27,13 +27,12 @@ lavavu/html/dat.gui.min.js,sha256=S4_QjoXe4IOpU0f0Sj5jEQLTWPoX9uRl1ohB91jyhuw,56
 lavavu/html/OK-min.js,sha256=-4Gc1-dWfxP_w6r9ZOHa8u-X2BlGUoSQbX68lwCxQ3E,39115
 lavavu/html/emscripten.css,sha256=wkaIJhXaxuMchinQX9Z8c12cJomyvFQMeIZ62WGQEPQ,1813
 lavavu/html/drawbox.js,sha256=SJxFSmWd7QVFI5__66hFkKzLKeqg1JPcx-gJuqdMkXw,34590
-lavavu/html/webview.html,sha256=18jUDdjnNH0GEJl377vZ-2tj9AUawj3lUbveleBkguM,1521
+lavavu/html/webview.html,sha256=wLJjnQlVy7jSjhMcgUkerG23jK_fmPzmC7x_J7AJX3o,1522
 lavavu/html/emscripten-template.js,sha256=h63mzl3Lv7aQT1wMOiOucPOvHTJjpKkzsL-SFVYaZlA,6135
 lavavu/html/draw.js,sha256=57LlHlYRh0IvWVwzGDnF6PaCxYLzokpokLNCuZlG1ds,84108
 lavavu/html/dat-gui-light-theme.css,sha256=uPhvJs-1IAsdxudItyOw8lZy8Hrih0zmFM1u-xRwZ-M,1142
 lavavu/html/menu.js,sha256=42h-BCnrmEpW4IdZRKC_FIXUVczJP0sm4ciZ2ccfs-k,21630
 lavavu/html/baseviewer.js,sha256=u3UhC1At6rMBKmcQ7d2DXTRxQ20wsQkc4lqA-7sL7i4,9567
-lavavu/osmesa/LavaVuPython.py,sha256=ixhceiAr0gGGfCe3d2cY0IIgS4hbgoYJGa_RfgAmmrU,33207
 lavavu/osmesa/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lavavu/shaders/volumeShader.frag,sha256=Ajkpt0S2p0PpbQ2jygDnrymSgPMU2CG5xQT-dq2rr90,14194
 lavavu/shaders/pointShader.vert,sha256=mDMF4wAPvHELXT5rXN_QZFezxvK4q50Mdm-qZZJ7FYI,1160
@@ -47,9 +46,9 @@ lavavu/shaders/fontShader.vert,sha256=yCBmRugaPUeUQUdIh62-AK_5KELiJqVS2M82iyIqPw
 lavavu/shaders/pointShader.frag,sha256=3zREBdsimlL9fAXBPjhzomGaFUWmlG_QYkhwMTVURHQ,3291
 lavavu/shaders/volumeShader.vert,sha256=uGdQjGqi7V5kE6V7nxymfugtU4cbf6u570xBy13RgmY,78
 lavavu/shaders/default.frag,sha256=5XLYVfLwzN0sFT3aMYGmxbyquA_cmndp55YCOuy1t4E,180
-lavavu-1.9.9.dist-info/RECORD,,
-lavavu-1.9.9.dist-info/WHEEL,sha256=mer8vOuI-KlBtJIdzgyZALHdls6RZGRaE6RPt7dfKrk,138
-lavavu-1.9.9.dist-info/entry_points.txt,sha256=LC2qXR6EMe45Cb7zGAF99R9HFrAECP6Qkp_YuG6HZB0,44
-lavavu-1.9.9.dist-info/top_level.txt,sha256=JptS0k1nlBumjLs_0hITr3_XUJhxqvKBXD2jGho3E3A,7
-lavavu-1.9.9.dist-info/METADATA,sha256=m26xD1S57nTm100gH36OwCwzJRRHuaiqk0Ai7ZQV7iY,17877
-lavavu-1.9.9.dist-info/licenses/LICENSE.md,sha256=EhfNgC6BYh5gDEaq4tcrN3S0wbO4CtJO46botJnCF8c,8603
+lavavu-1.9.10.dist-info/RECORD,,
+lavavu-1.9.10.dist-info/WHEEL,sha256=mer8vOuI-KlBtJIdzgyZALHdls6RZGRaE6RPt7dfKrk,138
+lavavu-1.9.10.dist-info/entry_points.txt,sha256=LC2qXR6EMe45Cb7zGAF99R9HFrAECP6Qkp_YuG6HZB0,44
+lavavu-1.9.10.dist-info/top_level.txt,sha256=JptS0k1nlBumjLs_0hITr3_XUJhxqvKBXD2jGho3E3A,7
+lavavu-1.9.10.dist-info/METADATA,sha256=-v--Epjzy94gAFwLnDiYVtZ8chPgRKWxCmYjbm6es7Q,17901
+lavavu-1.9.10.dist-info/licenses/LICENSE.md,sha256=EhfNgC6BYh5gDEaq4tcrN3S0wbO4CtJO46botJnCF8c,8603

lavavu/osmesa/LavaVuPython.py

@@ -1,561 +0,0 @@
-# This file was automatically generated by SWIG (https://www.swig.org).
-# Version 4.2.0
-#
-# Do not make changes to this file unless you know what you are doing - modify
-# the SWIG interface file instead.
-
-from sys import version_info as _swig_python_version_info
-# Import the low-level C/C++ module
-if __package__ or "." in __name__:
-    from . import _LavaVuPython
-else:
-    import _LavaVuPython
-
-try:
-    import builtins as __builtin__
-except ImportError:
-    import __builtin__
-
-_swig_new_instance_method = _LavaVuPython.SWIG_PyInstanceMethod_New
-_swig_new_static_method = _LavaVuPython.SWIG_PyStaticMethod_New
-
-def _swig_repr(self):
-    try:
-        strthis = "proxy of " + self.this.__repr__()
-    except __builtin__.Exception:
-        strthis = ""
-    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)
-
-
-def _swig_setattr_nondynamic_instance_variable(set):
-    def set_instance_attr(self, name, value):
-        if name == "this":
-            set(self, name, value)
-        elif name == "thisown":
-            self.this.own(value)
-        elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
-            set(self, name, value)
-        else:
-            raise AttributeError("You cannot add instance attributes to %s" % self)
-    return set_instance_attr
-
-
-def _swig_setattr_nondynamic_class_variable(set):
-    def set_class_attr(cls, name, value):
-        if hasattr(cls, name) and not isinstance(getattr(cls, name), property):
-            set(cls, name, value)
-        else:
-            raise AttributeError("You cannot add class attributes to %s" % cls)
-    return set_class_attr
-
-
-def _swig_add_metaclass(metaclass):
-    """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass"""
-    def wrapper(cls):
-        return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
-    return wrapper
-
-
-class _SwigNonDynamicMeta(type):
-    """Meta class to enforce nondynamic attributes (no new attributes) for a class"""
-    __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__)
-
-
-class SwigPyIterator(object):
-    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
-
-    def __init__(self, *args, **kwargs):
-        raise AttributeError("No constructor defined - class is abstract")
-    __repr__ = _swig_repr
-    __swig_destroy__ = _LavaVuPython.delete_SwigPyIterator
-    value = _swig_new_instance_method(_LavaVuPython.SwigPyIterator_value)
-    incr = _swig_new_instance_method(_LavaVuPython.SwigPyIterator_incr)
-    decr = _swig_new_instance_method(_LavaVuPython.SwigPyIterator_decr)
-    distance = _swig_new_instance_method(_LavaVuPython.SwigPyIterator_distance)
-    equal = _swig_new_instance_method(_LavaVuPython.SwigPyIterator_equal)
-    copy = _swig_new_instance_method(_LavaVuPython.SwigPyIterator_copy)
-    next = _swig_new_instance_method(_LavaVuPython.SwigPyIterator_next)
-    __next__ = _swig_new_instance_method(_LavaVuPython.SwigPyIterator___next__)
-    previous = _swig_new_instance_method(_LavaVuPython.SwigPyIterator_previous)
-    advance = _swig_new_instance_method(_LavaVuPython.SwigPyIterator_advance)
-    __eq__ = _swig_new_instance_method(_LavaVuPython.SwigPyIterator___eq__)
-    __ne__ = _swig_new_instance_method(_LavaVuPython.SwigPyIterator___ne__)
-    __iadd__ = _swig_new_instance_method(_LavaVuPython.SwigPyIterator___iadd__)
-    __isub__ = _swig_new_instance_method(_LavaVuPython.SwigPyIterator___isub__)
-    __add__ = _swig_new_instance_method(_LavaVuPython.SwigPyIterator___add__)
-    __sub__ = _swig_new_instance_method(_LavaVuPython.SwigPyIterator___sub__)
-    def __iter__(self):
-        return self
-
-# Register SwigPyIterator in _LavaVuPython:
-_LavaVuPython.SwigPyIterator_swigregister(SwigPyIterator)
-SHARED_PTR_DISOWN = _LavaVuPython.SHARED_PTR_DISOWN
-class Line(object):
-    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
-    __repr__ = _swig_repr
-    iterator = _swig_new_instance_method(_LavaVuPython.Line_iterator)
-    def __iter__(self):
-        return self.iterator()
-    __nonzero__ = _swig_new_instance_method(_LavaVuPython.Line___nonzero__)
-    __bool__ = _swig_new_instance_method(_LavaVuPython.Line___bool__)
-    __len__ = _swig_new_instance_method(_LavaVuPython.Line___len__)
-    __getslice__ = _swig_new_instance_method(_LavaVuPython.Line___getslice__)
-    __setslice__ = _swig_new_instance_method(_LavaVuPython.Line___setslice__)
-    __delslice__ = _swig_new_instance_method(_LavaVuPython.Line___delslice__)
-    __delitem__ = _swig_new_instance_method(_LavaVuPython.Line___delitem__)
-    __getitem__ = _swig_new_instance_method(_LavaVuPython.Line___getitem__)
-    __setitem__ = _swig_new_instance_method(_LavaVuPython.Line___setitem__)
-    pop = _swig_new_instance_method(_LavaVuPython.Line_pop)
-    append = _swig_new_instance_method(_LavaVuPython.Line_append)
-    empty = _swig_new_instance_method(_LavaVuPython.Line_empty)
-    size = _swig_new_instance_method(_LavaVuPython.Line_size)
-    swap = _swig_new_instance_method(_LavaVuPython.Line_swap)
-    begin = _swig_new_instance_method(_LavaVuPython.Line_begin)
-    end = _swig_new_instance_method(_LavaVuPython.Line_end)
-    rbegin = _swig_new_instance_method(_LavaVuPython.Line_rbegin)
-    rend = _swig_new_instance_method(_LavaVuPython.Line_rend)
-    clear = _swig_new_instance_method(_LavaVuPython.Line_clear)
-    get_allocator = _swig_new_instance_method(_LavaVuPython.Line_get_allocator)
-    pop_back = _swig_new_instance_method(_LavaVuPython.Line_pop_back)
-    erase = _swig_new_instance_method(_LavaVuPython.Line_erase)
-
-    def __init__(self, *args):
-        _LavaVuPython.Line_swiginit(self, _LavaVuPython.new_Line(*args))
-    push_back = _swig_new_instance_method(_LavaVuPython.Line_push_back)
-    front = _swig_new_instance_method(_LavaVuPython.Line_front)
-    back = _swig_new_instance_method(_LavaVuPython.Line_back)
-    assign = _swig_new_instance_method(_LavaVuPython.Line_assign)
-    resize = _swig_new_instance_method(_LavaVuPython.Line_resize)
-    insert = _swig_new_instance_method(_LavaVuPython.Line_insert)
-    reserve = _swig_new_instance_method(_LavaVuPython.Line_reserve)
-    capacity = _swig_new_instance_method(_LavaVuPython.Line_capacity)
-    __swig_destroy__ = _LavaVuPython.delete_Line
-
-# Register Line in _LavaVuPython:
-_LavaVuPython.Line_swigregister(Line)
-class Array(object):
-    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
-    __repr__ = _swig_repr
-    iterator = _swig_new_instance_method(_LavaVuPython.Array_iterator)
-    def __iter__(self):
-        return self.iterator()
-    __nonzero__ = _swig_new_instance_method(_LavaVuPython.Array___nonzero__)
-    __bool__ = _swig_new_instance_method(_LavaVuPython.Array___bool__)
-    __len__ = _swig_new_instance_method(_LavaVuPython.Array___len__)
-    __getslice__ = _swig_new_instance_method(_LavaVuPython.Array___getslice__)
-    __setslice__ = _swig_new_instance_method(_LavaVuPython.Array___setslice__)
-    __delslice__ = _swig_new_instance_method(_LavaVuPython.Array___delslice__)
-    __delitem__ = _swig_new_instance_method(_LavaVuPython.Array___delitem__)
-    __getitem__ = _swig_new_instance_method(_LavaVuPython.Array___getitem__)
-    __setitem__ = _swig_new_instance_method(_LavaVuPython.Array___setitem__)
-    pop = _swig_new_instance_method(_LavaVuPython.Array_pop)
-    append = _swig_new_instance_method(_LavaVuPython.Array_append)
-    empty = _swig_new_instance_method(_LavaVuPython.Array_empty)
-    size = _swig_new_instance_method(_LavaVuPython.Array_size)
-    swap = _swig_new_instance_method(_LavaVuPython.Array_swap)
-    begin = _swig_new_instance_method(_LavaVuPython.Array_begin)
-    end = _swig_new_instance_method(_LavaVuPython.Array_end)
-    rbegin = _swig_new_instance_method(_LavaVuPython.Array_rbegin)
-    rend = _swig_new_instance_method(_LavaVuPython.Array_rend)
-    clear = _swig_new_instance_method(_LavaVuPython.Array_clear)
-    get_allocator = _swig_new_instance_method(_LavaVuPython.Array_get_allocator)
-    pop_back = _swig_new_instance_method(_LavaVuPython.Array_pop_back)
-    erase = _swig_new_instance_method(_LavaVuPython.Array_erase)
-
-    def __init__(self, *args):
-        _LavaVuPython.Array_swiginit(self, _LavaVuPython.new_Array(*args))
-    push_back = _swig_new_instance_method(_LavaVuPython.Array_push_back)
-    front = _swig_new_instance_method(_LavaVuPython.Array_front)
-    back = _swig_new_instance_method(_LavaVuPython.Array_back)
-    assign = _swig_new_instance_method(_LavaVuPython.Array_assign)
-    resize = _swig_new_instance_method(_LavaVuPython.Array_resize)
-    insert = _swig_new_instance_method(_LavaVuPython.Array_insert)
-    reserve = _swig_new_instance_method(_LavaVuPython.Array_reserve)
-    capacity = _swig_new_instance_method(_LavaVuPython.Array_capacity)
-    __swig_destroy__ = _LavaVuPython.delete_Array
-
-# Register Array in _LavaVuPython:
-_LavaVuPython.Array_swigregister(Array)
-class List(object):
-    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
-    __repr__ = _swig_repr
-    iterator = _swig_new_instance_method(_LavaVuPython.List_iterator)
-    def __iter__(self):
-        return self.iterator()
-    __nonzero__ = _swig_new_instance_method(_LavaVuPython.List___nonzero__)
-    __bool__ = _swig_new_instance_method(_LavaVuPython.List___bool__)
-    __len__ = _swig_new_instance_method(_LavaVuPython.List___len__)
-    __getslice__ = _swig_new_instance_method(_LavaVuPython.List___getslice__)
-    __setslice__ = _swig_new_instance_method(_LavaVuPython.List___setslice__)
-    __delslice__ = _swig_new_instance_method(_LavaVuPython.List___delslice__)
-    __delitem__ = _swig_new_instance_method(_LavaVuPython.List___delitem__)
-    __getitem__ = _swig_new_instance_method(_LavaVuPython.List___getitem__)
-    __setitem__ = _swig_new_instance_method(_LavaVuPython.List___setitem__)
-    pop = _swig_new_instance_method(_LavaVuPython.List_pop)
-    append = _swig_new_instance_method(_LavaVuPython.List_append)
-    empty = _swig_new_instance_method(_LavaVuPython.List_empty)
-    size = _swig_new_instance_method(_LavaVuPython.List_size)
-    swap = _swig_new_instance_method(_LavaVuPython.List_swap)
-    begin = _swig_new_instance_method(_LavaVuPython.List_begin)
-    end = _swig_new_instance_method(_LavaVuPython.List_end)
-    rbegin = _swig_new_instance_method(_LavaVuPython.List_rbegin)
-    rend = _swig_new_instance_method(_LavaVuPython.List_rend)
-    clear = _swig_new_instance_method(_LavaVuPython.List_clear)
-    get_allocator = _swig_new_instance_method(_LavaVuPython.List_get_allocator)
-    pop_back = _swig_new_instance_method(_LavaVuPython.List_pop_back)
-    erase = _swig_new_instance_method(_LavaVuPython.List_erase)
-
-    def __init__(self, *args):
-        _LavaVuPython.List_swiginit(self, _LavaVuPython.new_List(*args))
-    push_back = _swig_new_instance_method(_LavaVuPython.List_push_back)
-    front = _swig_new_instance_method(_LavaVuPython.List_front)
-    back = _swig_new_instance_method(_LavaVuPython.List_back)
-    assign = _swig_new_instance_method(_LavaVuPython.List_assign)
-    resize = _swig_new_instance_method(_LavaVuPython.List_resize)
-    insert = _swig_new_instance_method(_LavaVuPython.List_insert)
-    reserve = _swig_new_instance_method(_LavaVuPython.List_reserve)
-    capacity = _swig_new_instance_method(_LavaVuPython.List_capacity)
-    __swig_destroy__ = _LavaVuPython.delete_List
-
-# Register List in _LavaVuPython:
-_LavaVuPython.List_swigregister(List)
-class GeomList(object):
-    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
-    __repr__ = _swig_repr
-    iterator = _swig_new_instance_method(_LavaVuPython.GeomList_iterator)
-    def __iter__(self):
-        return self.iterator()
-    __nonzero__ = _swig_new_instance_method(_LavaVuPython.GeomList___nonzero__)
-    __bool__ = _swig_new_instance_method(_LavaVuPython.GeomList___bool__)
-    __len__ = _swig_new_instance_method(_LavaVuPython.GeomList___len__)
-    __getslice__ = _swig_new_instance_method(_LavaVuPython.GeomList___getslice__)
-    __setslice__ = _swig_new_instance_method(_LavaVuPython.GeomList___setslice__)
-    __delslice__ = _swig_new_instance_method(_LavaVuPython.GeomList___delslice__)
-    __delitem__ = _swig_new_instance_method(_LavaVuPython.GeomList___delitem__)
-    __getitem__ = _swig_new_instance_method(_LavaVuPython.GeomList___getitem__)
-    __setitem__ = _swig_new_instance_method(_LavaVuPython.GeomList___setitem__)
-    pop = _swig_new_instance_method(_LavaVuPython.GeomList_pop)
-    append = _swig_new_instance_method(_LavaVuPython.GeomList_append)
-    empty = _swig_new_instance_method(_LavaVuPython.GeomList_empty)
-    size = _swig_new_instance_method(_LavaVuPython.GeomList_size)
-    swap = _swig_new_instance_method(_LavaVuPython.GeomList_swap)
-    begin = _swig_new_instance_method(_LavaVuPython.GeomList_begin)
-    end = _swig_new_instance_method(_LavaVuPython.GeomList_end)
-    rbegin = _swig_new_instance_method(_LavaVuPython.GeomList_rbegin)
-    rend = _swig_new_instance_method(_LavaVuPython.GeomList_rend)
-    clear = _swig_new_instance_method(_LavaVuPython.GeomList_clear)
-    get_allocator = _swig_new_instance_method(_LavaVuPython.GeomList_get_allocator)
-    pop_back = _swig_new_instance_method(_LavaVuPython.GeomList_pop_back)
-    erase = _swig_new_instance_method(_LavaVuPython.GeomList_erase)
-
-    def __init__(self, *args):
-        _LavaVuPython.GeomList_swiginit(self, _LavaVuPython.new_GeomList(*args))
-    push_back = _swig_new_instance_method(_LavaVuPython.GeomList_push_back)
-    front = _swig_new_instance_method(_LavaVuPython.GeomList_front)
-    back = _swig_new_instance_method(_LavaVuPython.GeomList_back)
-    assign = _swig_new_instance_method(_LavaVuPython.GeomList_assign)
-    resize = _swig_new_instance_method(_LavaVuPython.GeomList_resize)
-    insert = _swig_new_instance_method(_LavaVuPython.GeomList_insert)
-    reserve = _swig_new_instance_method(_LavaVuPython.GeomList_reserve)
-    capacity = _swig_new_instance_method(_LavaVuPython.GeomList_capacity)
-    __swig_destroy__ = _LavaVuPython.delete_GeomList
-
-# Register GeomList in _LavaVuPython:
-_LavaVuPython.GeomList_swigregister(GeomList)
-class ByteArray(object):
-    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
-    __repr__ = _swig_repr
-    iterator = _swig_new_instance_method(_LavaVuPython.ByteArray_iterator)
-    def __iter__(self):
-        return self.iterator()
-    __nonzero__ = _swig_new_instance_method(_LavaVuPython.ByteArray___nonzero__)
-    __bool__ = _swig_new_instance_method(_LavaVuPython.ByteArray___bool__)
-    __len__ = _swig_new_instance_method(_LavaVuPython.ByteArray___len__)
-    __getslice__ = _swig_new_instance_method(_LavaVuPython.ByteArray___getslice__)
-    __setslice__ = _swig_new_instance_method(_LavaVuPython.ByteArray___setslice__)
-    __delslice__ = _swig_new_instance_method(_LavaVuPython.ByteArray___delslice__)
-    __delitem__ = _swig_new_instance_method(_LavaVuPython.ByteArray___delitem__)
-    __getitem__ = _swig_new_instance_method(_LavaVuPython.ByteArray___getitem__)
-    __setitem__ = _swig_new_instance_method(_LavaVuPython.ByteArray___setitem__)
-    pop = _swig_new_instance_method(_LavaVuPython.ByteArray_pop)
-    append = _swig_new_instance_method(_LavaVuPython.ByteArray_append)
-    empty = _swig_new_instance_method(_LavaVuPython.ByteArray_empty)
-    size = _swig_new_instance_method(_LavaVuPython.ByteArray_size)
-    swap = _swig_new_instance_method(_LavaVuPython.ByteArray_swap)
-    begin = _swig_new_instance_method(_LavaVuPython.ByteArray_begin)
-    end = _swig_new_instance_method(_LavaVuPython.ByteArray_end)
-    rbegin = _swig_new_instance_method(_LavaVuPython.ByteArray_rbegin)
-    rend = _swig_new_instance_method(_LavaVuPython.ByteArray_rend)
-    clear = _swig_new_instance_method(_LavaVuPython.ByteArray_clear)
-    get_allocator = _swig_new_instance_method(_LavaVuPython.ByteArray_get_allocator)
-    pop_back = _swig_new_instance_method(_LavaVuPython.ByteArray_pop_back)
-    erase = _swig_new_instance_method(_LavaVuPython.ByteArray_erase)
-
-    def __init__(self, *args):
-        _LavaVuPython.ByteArray_swiginit(self, _LavaVuPython.new_ByteArray(*args))
-    push_back = _swig_new_instance_method(_LavaVuPython.ByteArray_push_back)
-    front = _swig_new_instance_method(_LavaVuPython.ByteArray_front)
-    back = _swig_new_instance_method(_LavaVuPython.ByteArray_back)
-    assign = _swig_new_instance_method(_LavaVuPython.ByteArray_assign)
-    resize = _swig_new_instance_method(_LavaVuPython.ByteArray_resize)
-    insert = _swig_new_instance_method(_LavaVuPython.ByteArray_insert)
-    reserve = _swig_new_instance_method(_LavaVuPython.ByteArray_reserve)
-    capacity = _swig_new_instance_method(_LavaVuPython.ByteArray_capacity)
-    __swig_destroy__ = _LavaVuPython.delete_ByteArray
-
-# Register ByteArray in _LavaVuPython:
-_LavaVuPython.ByteArray_swigregister(ByteArray)
-lucMinType = _LavaVuPython.lucMinType
-lucLabelType = _LavaVuPython.lucLabelType
-lucPointType = _LavaVuPython.lucPointType
-lucGridType = _LavaVuPython.lucGridType
-lucTriangleType = _LavaVuPython.lucTriangleType
-lucVectorType = _LavaVuPython.lucVectorType
-lucTracerType = _LavaVuPython.lucTracerType
-lucLineType = _LavaVuPython.lucLineType
-lucShapeType = _LavaVuPython.lucShapeType
-lucVolumeType = _LavaVuPython.lucVolumeType
-lucScreenType = _LavaVuPython.lucScreenType
-lucMaxType = _LavaVuPython.lucMaxType
-lucMinDataType = _LavaVuPython.lucMinDataType
-lucVertexData = _LavaVuPython.lucVertexData
-lucNormalData = _LavaVuPython.lucNormalData
-lucVectorData = _LavaVuPython.lucVectorData
-lucColourValueData = _LavaVuPython.lucColourValueData
-lucOpacityValueData = _LavaVuPython.lucOpacityValueData
-lucRedValueData = _LavaVuPython.lucRedValueData
-lucGreenValueData = _LavaVuPython.lucGreenValueData
-lucBlueValueData = _LavaVuPython.lucBlueValueData
-lucIndexData = _LavaVuPython.lucIndexData
-lucXWidthData = _LavaVuPython.lucXWidthData
-lucYHeightData = _LavaVuPython.lucYHeightData
-lucZLengthData = _LavaVuPython.lucZLengthData
-lucRGBAData = _LavaVuPython.lucRGBAData
-lucTexCoordData = _LavaVuPython.lucTexCoordData
-lucSizeData = _LavaVuPython.lucSizeData
-lucLuminanceData = _LavaVuPython.lucLuminanceData
-lucRGBData = _LavaVuPython.lucRGBData
-lucMaxDataType = _LavaVuPython.lucMaxDataType
-class Colour(object):
-    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
-    __repr__ = _swig_repr
-    rgba = property(_LavaVuPython.Colour_rgba_get, _LavaVuPython.Colour_rgba_set)
-    value = property(_LavaVuPython.Colour_value_get, _LavaVuPython.Colour_value_set)
-    fvalue = property(_LavaVuPython.Colour_fvalue_get, _LavaVuPython.Colour_fvalue_set)
-
-    def __init__(self, *args):
-        _LavaVuPython.Colour_swiginit(self, _LavaVuPython.new_Colour(*args))
-    fromRGBA = _swig_new_instance_method(_LavaVuPython.Colour_fromRGBA)
-    fromJSON = _swig_new_instance_method(_LavaVuPython.Colour_fromJSON)
-    fromString = _swig_new_instance_method(_LavaVuPython.Colour_fromString)
-    fromX11Colour = _swig_new_instance_method(_LavaVuPython.Colour_fromX11Colour)
-    fromHex = _swig_new_instance_method(_LavaVuPython.Colour_fromHex)
-    invert = _swig_new_instance_method(_LavaVuPython.Colour_invert)
-    toJson = _swig_new_instance_method(_LavaVuPython.Colour_toJson)
-    toString = _swig_new_instance_method(_LavaVuPython.Colour_toString)
-    toArray = _swig_new_instance_method(_LavaVuPython.Colour_toArray)
-    __swig_destroy__ = _LavaVuPython.delete_Colour
-
-# Register Colour in _LavaVuPython:
-_LavaVuPython.Colour_swigregister(Colour)
-class OpenGLViewer(object):
-    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
-    __repr__ = _swig_repr
-    quitProgram = property(_LavaVuPython.OpenGLViewer_quitProgram_get, _LavaVuPython.OpenGLViewer_quitProgram_set)
-    isopen = property(_LavaVuPython.OpenGLViewer_isopen_get, _LavaVuPython.OpenGLViewer_isopen_set)
-    postdisplay = property(_LavaVuPython.OpenGLViewer_postdisplay_get, _LavaVuPython.OpenGLViewer_postdisplay_set)
-    nodisplay = property(_LavaVuPython.OpenGLViewer_nodisplay_get, _LavaVuPython.OpenGLViewer_nodisplay_set)
-    visible = property(_LavaVuPython.OpenGLViewer_visible_get, _LavaVuPython.OpenGLViewer_visible_set)
-    width = property(_LavaVuPython.OpenGLViewer_width_get, _LavaVuPython.OpenGLViewer_width_set)
-    height = property(_LavaVuPython.OpenGLViewer_height_get, _LavaVuPython.OpenGLViewer_height_set)
-    timer_animate = property(_LavaVuPython.OpenGLViewer_timer_animate_get, _LavaVuPython.OpenGLViewer_timer_animate_set)
-    output_path = property(_LavaVuPython.OpenGLViewer_output_path_get, _LavaVuPython.OpenGLViewer_output_path_set)
-    mouseState = property(_LavaVuPython.OpenGLViewer_mouseState_get, _LavaVuPython.OpenGLViewer_mouseState_set)
-    mouseX = property(_LavaVuPython.OpenGLViewer_mouseX_get, _LavaVuPython.OpenGLViewer_mouseX_set)
-    mouseY = property(_LavaVuPython.OpenGLViewer_mouseY_get, _LavaVuPython.OpenGLViewer_mouseY_set)
-    open = _swig_new_instance_method(_LavaVuPython.OpenGLViewer_open)
-    init = _swig_new_instance_method(_LavaVuPython.OpenGLViewer_init)
-    display = _swig_new_instance_method(_LavaVuPython.OpenGLViewer_display)
-    show = _swig_new_instance_method(_LavaVuPython.OpenGLViewer_show)
-    hide = _swig_new_instance_method(_LavaVuPython.OpenGLViewer_hide)
-    title = _swig_new_instance_method(_LavaVuPython.OpenGLViewer_title)
-    execute = _swig_new_instance_method(_LavaVuPython.OpenGLViewer_execute)
-    events = _swig_new_instance_method(_LavaVuPython.OpenGLViewer_events)
-    loop = _swig_new_instance_method(_LavaVuPython.OpenGLViewer_loop)
-    downSample = _swig_new_instance_method(_LavaVuPython.OpenGLViewer_downSample)
-    multiSample = _swig_new_instance_method(_LavaVuPython.OpenGLViewer_multiSample)
-    animateTimer = _swig_new_instance_method(_LavaVuPython.OpenGLViewer_animateTimer)
-
-    def __init__(self):
-        _LavaVuPython.OpenGLViewer_swiginit(self, _LavaVuPython.new_OpenGLViewer())
-    __swig_destroy__ = _LavaVuPython.delete_OpenGLViewer
-
-# Register OpenGLViewer in _LavaVuPython:
-_LavaVuPython.OpenGLViewer_swigregister(OpenGLViewer)
-cvar = _LavaVuPython.cvar
-version = cvar.version
-
-class DrawingObject(object):
-    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
-    __repr__ = _swig_repr
-
-    def __init__(self, *args):
-        _LavaVuPython.DrawingObject_swiginit(self, _LavaVuPython.new_DrawingObject(*args))
-    colourMap = property(_LavaVuPython.DrawingObject_colourMap_get, _LavaVuPython.DrawingObject_colourMap_set)
-    opacityMap = property(_LavaVuPython.DrawingObject_opacityMap_get, _LavaVuPython.DrawingObject_opacityMap_set)
-    getColourMap = _swig_new_instance_method(_LavaVuPython.DrawingObject_getColourMap)
-    name = _swig_new_instance_method(_LavaVuPython.DrawingObject_name)
-    opacity = property(_LavaVuPython.DrawingObject_opacity_get, _LavaVuPython.DrawingObject_opacity_set)
-    colour = property(_LavaVuPython.DrawingObject_colour_get, _LavaVuPython.DrawingObject_colour_set)
-    __swig_destroy__ = _LavaVuPython.delete_DrawingObject
-
-# Register DrawingObject in _LavaVuPython:
-_LavaVuPython.DrawingObject_swigregister(DrawingObject)
-class Model(object):
-    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
-    __repr__ = _swig_repr
-    fignames = property(_LavaVuPython.Model_fignames_get, _LavaVuPython.Model_fignames_set)
-    figures = property(_LavaVuPython.Model_figures_get, _LavaVuPython.Model_figures_set)
-    figure = property(_LavaVuPython.Model_figure_get, _LavaVuPython.Model_figure_set)
-
-    def __init__(self, session):
-        _LavaVuPython.Model_swiginit(self, _LavaVuPython.new_Model(session))
-    __swig_destroy__ = _LavaVuPython.delete_Model
-
-# Register Model in _LavaVuPython:
-_LavaVuPython.Model_swigregister(Model)
-class ColourMap(object):
-    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
-    __repr__ = _swig_repr
-    name = property(_LavaVuPython.ColourMap_name_get, _LavaVuPython.ColourMap_name_set)
-
-    def __init__(self, *args):
-        _LavaVuPython.ColourMap_swiginit(self, _LavaVuPython.new_ColourMap(*args))
-    flip = _swig_new_instance_method(_LavaVuPython.ColourMap_flip)
-    monochrome = _swig_new_instance_method(_LavaVuPython.ColourMap_monochrome)
-    getDefaultMapNames = _swig_new_static_method(_LavaVuPython.ColourMap_getDefaultMapNames)
-    getDefaultMap = _swig_new_static_method(_LavaVuPython.ColourMap_getDefaultMap)
-    __swig_destroy__ = _LavaVuPython.delete_ColourMap
-
-# Register ColourMap in _LavaVuPython:
-_LavaVuPython.ColourMap_swigregister(ColourMap)
-class GeomData(object):
-    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
-    __repr__ = _swig_repr
-    width = property(_LavaVuPython.GeomData_width_get, _LavaVuPython.GeomData_width_set)
-    height = property(_LavaVuPython.GeomData_height_get, _LavaVuPython.GeomData_height_set)
-    depth = property(_LavaVuPython.GeomData_depth_get, _LavaVuPython.GeomData_depth_set)
-    step = property(_LavaVuPython.GeomData_step_get, _LavaVuPython.GeomData_step_set)
-    type = property(_LavaVuPython.GeomData_type_get, _LavaVuPython.GeomData_type_set)
-
-    def __init__(self, draw, type):
-        _LavaVuPython.GeomData_swiginit(self, _LavaVuPython.new_GeomData(draw, type))
-    __swig_destroy__ = _LavaVuPython.delete_GeomData
-
-# Register GeomData in _LavaVuPython:
-_LavaVuPython.GeomData_swigregister(GeomData)
-class LavaVu(object):
-    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
-    __repr__ = _swig_repr
-    viewer = property(_LavaVuPython.LavaVu_viewer_get, _LavaVuPython.LavaVu_viewer_set)
-    amodel = property(_LavaVuPython.LavaVu_amodel_get, _LavaVuPython.LavaVu_amodel_set)
-    aview = property(_LavaVuPython.LavaVu_aview_get, _LavaVuPython.LavaVu_aview_set)
-    aobject = property(_LavaVuPython.LavaVu_aobject_get, _LavaVuPython.LavaVu_aobject_set)
-    binpath = property(_LavaVuPython.LavaVu_binpath_get, _LavaVuPython.LavaVu_binpath_set)
-    unprocessed = property(_LavaVuPython.LavaVu_unprocessed_get, _LavaVuPython.LavaVu_unprocessed_set)
-
-    def __init__(self, binpath, havecontext=False):
-        _LavaVuPython.LavaVu_swiginit(self, _LavaVuPython.new_LavaVu(binpath, havecontext))
-    __swig_destroy__ = _LavaVuPython.delete_LavaVu
-    destroy = _swig_new_instance_method(_LavaVuPython.LavaVu_destroy)
-    resize = _swig_new_instance_method(_LavaVuPython.LavaVu_resize)
-    run = _swig_new_instance_method(_LavaVuPython.LavaVu_run)
-    serialize = _swig_new_instance_method(_LavaVuPython.LavaVu_serialize)
-    deserialize = _swig_new_instance_method(_LavaVuPython.LavaVu_deserialize)
-    printall = _swig_new_instance_method(_LavaVuPython.LavaVu_printall)
-    loadFile = _swig_new_instance_method(_LavaVuPython.LavaVu_loadFile)
-    parseProperty = _swig_new_instance_method(_LavaVuPython.LavaVu_parseProperty)
-    parseCommands = _swig_new_instance_method(_LavaVuPython.LavaVu_parseCommands)
-    gl_version = _swig_new_instance_method(_LavaVuPython.LavaVu_gl_version)
-    image = _swig_new_instance_method(_LavaVuPython.LavaVu_image)
-    web = _swig_new_instance_method(_LavaVuPython.LavaVu_web)
-    video = _swig_new_instance_method(_LavaVuPython.LavaVu_video)
-    encodeVideo = _swig_new_instance_method(_LavaVuPython.LavaVu_encodeVideo)
-    pauseVideo = _swig_new_instance_method(_LavaVuPython.LavaVu_pauseVideo)
-    defaultModel = _swig_new_instance_method(_LavaVuPython.LavaVu_defaultModel)
-    addColourMap = _swig_new_instance_method(_LavaVuPython.LavaVu_addColourMap)
-    updateColourMap = _swig_new_instance_method(_LavaVuPython.LavaVu_updateColourMap)
-    getColourMap = _swig_new_instance_method(_LavaVuPython.LavaVu_getColourMap)
-    setColourMap = _swig_new_instance_method(_LavaVuPython.LavaVu_setColourMap)
-    colourBar = _swig_new_instance_method(_LavaVuPython.LavaVu_colourBar)
-    setState = _swig_new_instance_method(_LavaVuPython.LavaVu_setState)
-    getState = _swig_new_instance_method(_LavaVuPython.LavaVu_getState)
-    getTimeSteps = _swig_new_instance_method(_LavaVuPython.LavaVu_getTimeSteps)
-    addTimeStep = _swig_new_instance_method(_LavaVuPython.LavaVu_addTimeStep)
-    resetViews = _swig_new_instance_method(_LavaVuPython.LavaVu_resetViews)
-    addViewport = _swig_new_instance_method(_LavaVuPython.LavaVu_addViewport)
-    setObject = _swig_new_instance_method(_LavaVuPython.LavaVu_setObject)
-    createObject = _swig_new_instance_method(_LavaVuPython.LavaVu_createObject)
-    getObject = _swig_new_instance_method(_LavaVuPython.LavaVu_getObject)
-    reloadObject = _swig_new_instance_method(_LavaVuPython.LavaVu_reloadObject)
-    appendToObject = _swig_new_instance_method(_LavaVuPython.LavaVu_appendToObject)
-    loadTriangles = _swig_new_instance_method(_LavaVuPython.LavaVu_loadTriangles)
-    loadColours = _swig_new_instance_method(_LavaVuPython.LavaVu_loadColours)
-    loadLabels = _swig_new_instance_method(_LavaVuPython.LavaVu_loadLabels)
-    clearAll = _swig_new_instance_method(_LavaVuPython.LavaVu_clearAll)
-    clearObject = _swig_new_instance_method(_LavaVuPython.LavaVu_clearObject)
-    clearValues = _swig_new_instance_method(_LavaVuPython.LavaVu_clearValues)
-    clearData = _swig_new_instance_method(_LavaVuPython.LavaVu_clearData)
-    getObjectDataLabels = _swig_new_instance_method(_LavaVuPython.LavaVu_getObjectDataLabels)
-    arrayUChar = _swig_new_instance_method(_LavaVuPython.LavaVu_arrayUChar)
-    arrayUInt = _swig_new_instance_method(_LavaVuPython.LavaVu_arrayUInt)
-    arrayFloat = _swig_new_instance_method(_LavaVuPython.LavaVu_arrayFloat)
-    clearTexture = _swig_new_instance_method(_LavaVuPython.LavaVu_clearTexture)
-    setTexture = _swig_new_instance_method(_LavaVuPython.LavaVu_setTexture)
-    textureUChar = _swig_new_instance_method(_LavaVuPython.LavaVu_textureUChar)
-    textureUInt = _swig_new_instance_method(_LavaVuPython.LavaVu_textureUInt)
-    getGeometry = _swig_new_instance_method(_LavaVuPython.LavaVu_getGeometry)
-    getGeometryAt = _swig_new_instance_method(_LavaVuPython.LavaVu_getGeometryAt)
-    getBoundingBox = _swig_new_instance_method(_LavaVuPython.LavaVu_getBoundingBox)
-    geometryArrayUChar = _swig_new_instance_method(_LavaVuPython.LavaVu_geometryArrayUChar)
-    geometryArrayUInt = _swig_new_instance_method(_LavaVuPython.LavaVu_geometryArrayUInt)
-    geometryArrayFloat = _swig_new_instance_method(_LavaVuPython.LavaVu_geometryArrayFloat)
-    colourArrayFloat = _swig_new_instance_method(_LavaVuPython.LavaVu_colourArrayFloat)
-    geometryArrayViewFloat = _swig_new_instance_method(_LavaVuPython.LavaVu_geometryArrayViewFloat)
-    geometryArrayViewUInt = _swig_new_instance_method(_LavaVuPython.LavaVu_geometryArrayViewUInt)
-    geometryArrayViewUChar = _swig_new_instance_method(_LavaVuPython.LavaVu_geometryArrayViewUChar)
-    imageBuffer = _swig_new_instance_method(_LavaVuPython.LavaVu_imageBuffer)
-    imageFromFile = _swig_new_instance_method(_LavaVuPython.LavaVu_imageFromFile)
-    imageJPEG = _swig_new_instance_method(_LavaVuPython.LavaVu_imageJPEG)
-    imagePNG = _swig_new_instance_method(_LavaVuPython.LavaVu_imagePNG)
-    contour = _swig_new_instance_method(_LavaVuPython.LavaVu_contour)
-    isoSurface = _swig_new_instance_method(_LavaVuPython.LavaVu_isoSurface)
-    update = _swig_new_instance_method(_LavaVuPython.LavaVu_update)
-    close = _swig_new_instance_method(_LavaVuPython.LavaVu_close)
-    imageArray = _swig_new_instance_method(_LavaVuPython.LavaVu_imageArray)
-    imageDiff = _swig_new_instance_method(_LavaVuPython.LavaVu_imageDiff)
-    queueCommands = _swig_new_instance_method(_LavaVuPython.LavaVu_queueCommands)
-    helpCommand = _swig_new_instance_method(_LavaVuPython.LavaVu_helpCommand)
-    commandList = _swig_new_instance_method(_LavaVuPython.LavaVu_commandList)
-    propertyList = _swig_new_instance_method(_LavaVuPython.LavaVu_propertyList)
-
-# Register LavaVu in _LavaVuPython:
-_LavaVuPython.LavaVu_swigregister(LavaVu)
-rawImageWrite = _LavaVuPython.rawImageWrite
-class VideoEncoder(object):
-    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
-    __repr__ = _swig_repr
-    filename = property(_LavaVuPython.VideoEncoder_filename_get, _LavaVuPython.VideoEncoder_filename_set)
-
-    def __init__(self, fn, fps, quality=3):
-        _LavaVuPython.VideoEncoder_swiginit(self, _LavaVuPython.new_VideoEncoder(fn, fps, quality))
-    __swig_destroy__ = _LavaVuPython.delete_VideoEncoder
-    open = _swig_new_instance_method(_LavaVuPython.VideoEncoder_open)
-    close = _swig_new_instance_method(_LavaVuPython.VideoEncoder_close)
-    resize = _swig_new_instance_method(_LavaVuPython.VideoEncoder_resize)
-    display = _swig_new_instance_method(_LavaVuPython.VideoEncoder_display)
-    copyframe = _swig_new_instance_method(_LavaVuPython.VideoEncoder_copyframe)
-
-# Register VideoEncoder in _LavaVuPython:
-_LavaVuPython.VideoEncoder_swigregister(VideoEncoder)
-