lavavu 1.8.84__cp38-cp38-macosx_11_0_arm64.whl → 1.9.5__cp38-cp38-macosx_11_0_arm64.whl

lavavu/shaders/triShader.frag

@@ -22,25 +22,10 @@ uniform vec3 uClipMax;
 uniform bool uOpaque;
 uniform vec4 uLight;
 
-#ifdef WEBGL
-#define outColour gl_FragColor
-#define texture(a,b) texture2D(a,b)
-
-//Before OpenGL 3+ we need our own isnan function
-bool isnan3(vec3 val)
-{
-  if (!(val.x < 0.0 || 0.0 < val.x || val.x == 0.0)) return true;
-  if (!(val.y < 0.0 || 0.0 < val.y || val.y == 0.0)) return true;
-  if (!(val.z < 0.0 || 0.0 < val.z || val.z == 0.0)) return true;
-  return false;
-}
-
-#else
 #define isnan3(v) any(isnan(v))
 flat in vec4 vFlatColour;
 uniform bool uFlat;
 out vec4 outColour;
-#endif
 
 uniform bool uCalcNormal;
 
@@ -69,10 +54,8 @@ void main(void)
   if (any(lessThan(vVertex, uClipMin)) || any(greaterThan(vVertex, uClipMax))) discard;
 
   vec4 fColour = vColour;
-#ifndef WEBGL
   if (uFlat)
     fColour = vFlatColour;
-#endif
   float alpha = fColour.a;
   if (uTextured && vTexCoord.x > -1.0) //Null texcoord (-1,-1)
   {

lavavu/shaders/triShader.vert

@@ -2,9 +2,7 @@ in vec3 aVertexPosition;
 in vec3 aVertexNormal;
 in vec4 aVertexColour;
 in vec2 aVertexTexCoord;
-#ifndef WEBGL
 flat out vec4 vFlatColour;
-#endif
 
 uniform mat4 uMVMatrix;
 uniform mat4 uPMatrix;
@@ -34,9 +32,7 @@ void main(void)
     vColour = aVertexColour;
 
   vTexCoord = aVertexTexCoord;
-#ifndef WEBGL
   vFlatColour = vColour;
-#endif
   vVertex = aVertexPosition;
 
   //Head light, lightPos=(0,0,0) - vPosEye

lavavu/shaders/volumeShader.frag

@@ -6,17 +6,10 @@
  * https://www.gnu.org/licenses/lgpl.html
  * (volume shader from sharevol https://github.com/OKaluza/sharevol)
  */
-#ifdef WEBGL
-uniform sampler2D uVolume;
-#define NO_DEPTH_WRITE
-#define outColour gl_FragColor
-#define texture(a,b) texture2D(a,b)
-#else
 //Included dynamically before compile in WebGL mode...
 const int maxSamples = 2048;
 uniform sampler3D uVolume;
 out vec4 outColour;
-#endif
 
 const float depthT = 0.99; //Transmissivity threshold below which depth write applied
 
@@ -63,63 +56,7 @@ vec3 bbMax;
 float interpolate_tricubic_fast(vec3 coord);
 #endif
 
-#ifdef WEBGL
-
-vec2 islices = vec2(1.0 / slices.x, 1.0 / slices.y);
-float maxslice = slices.x * slices.y - 1.0;
-//Clamp to a bit before halfway for the edge voxels
-vec2 cmin = vec2(0.55/(slices.x*slices.y), 0.55/(slices.x*slices.y));
-vec2 cmax = vec2(1.0, 1.0) - cmin;
-
-float sample(vec3 pos)
-{
-  //Get z slice index and position between two slices
-  float Z = pos.z * maxslice;
-  float slice = floor(Z); //Index of first slice
-  Z = fract(Z);
-  //Edge case at z min (possible with tricubic filtering)
-  if (int(slice) < 0)
-  {
-    slice = 0.0;
-    Z = 0.0;
-  }
-  //Edge case at z max
-  else if (int(slice) > int(maxslice)-1)
-  {
-    slice = maxslice-1.0;
-    Z = 1.0;
-  }
-  //Only start interpolation with next Z slice 1/3 from edges at first & last z slice
-  //(this approximates how 3d texture volume is sampled at edges with linear filtering
-  // due to edge sample being included in weighted average twice)
-  // - min z slice
-  else if (int(slice) == 0)
-  {
-    Z = max(0.0, (Z-0.33) * 1.5);
-  }
-  // - max z slice
-  else if (int(slice) == int(maxslice)-1)
-  {
-    Z = min(1.0, Z*1.5);
-  }
-
-  //X & Y coords of sample scaled to slice size
-  //(Clamp range at borders to prevent bleeding between tiles due to linear filtering)
-  vec2 sampleOffset = clamp(pos.xy, cmin, cmax) * islices;
-  //Offsets in 2D texture of given slice indices
-  //(add offsets to scaled position within slice to get sample positions)
-  float A = slice * islices.x;
-  float B = (slice+1.0) * islices.x;
-  vec2 z1offset = vec2(fract(A), floor(A) / slices.y) + sampleOffset;
-  vec2 z2offset = vec2(fract(B), floor(B) / slices.y) + sampleOffset;
-
-  //Interpolate the final value by position between slices [0,1]
-  return mix(texture2D(uVolume, z1offset).x, texture2D(uVolume, z2offset).x, Z);
-}
-
-#else
 #define sample(pos) (texture(uVolume, pos).x)
-#endif
 
 float tex3D(vec3 pos)
 {

lavavu/tracers.py

@@ -1,124 +1,194 @@
 """
-Warning! EXPERIMENTAL:
- these features and functions are under development, will have bugs,
- and may be heavily modified in the future
-
 Tracer particles in a vector field
-Uses a KDTree to find nearest vector to advect the particles
 
-- Requires scipy.spatial
+- Requires scipy.interpolate
 """
 import numpy
 import os
 import sys
 import random
-import math
-from scipy import spatial
-
-#Necessary? for large trees, detect?
-#sys.setrecursionlimit(10000)
+from scipy.interpolate import RegularGridInterpolator
 
-class TracerState(object):
-    def __init__(self, verts, N=5000):
-        self.tree = spatial.cKDTree(verts)
-        self.tracers = None
-        self.steps = [0]*N
-        self.values = None
-        self.positions = None
-        self.velocities = None
-
-def trace_particles(state, verts, vecs, N=5000, limit=0.5, speed=1.0, noise=0.0, height=None):
+def random_particles(count, lowerbound=[0,0,0], upperbound=[1,1,1], dims=3):
     """
-    Take a list of tracer vertices and matching velocity grid points (verts) & vectors (vecs)
-    For each tracer
-
-    - find the nearest velocity grid point
-    - if within max dist: Multiply position by velocity vector
-    - otherwise: Generate a new start position for tracer
-
-    Parameters
-    ----------
-    state : TracerState
-        Object returned from first call, pass None on first pass
-    verts : array or list
-        vertices of the vector field
-    vecs : array or list
-        vector values of the vector field
-    N : int
-        Number of particles to seed
-    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
-    speed : float
-        Speed multiplier, scaling factor for the velocity taken from the vector values
-    noise : float
-        A noise factor, if set a random value is generated, multiplied by noise factor
-        and added to each new position
-    height : float
-        A fixed height value, all positions will be given this height as their Z component
-
-    Returns
-    -------
-    TracerState
-        Object to hold the tracer state and track particles
-        Pass this as first paramter on subsequent calls
+    Return an array of *count* 3d vertices of random particle positions
+    Minimum and maximum values defined by lowerbound and upperbound
     """
+    p = [None] * dims
+    for c in range(dims):
+        if lowerbound[c] == upperbound[c]:
+            p[c] = numpy.zeros(shape=(count)) + lowerbound[c]
+        else:
+            p[c] = numpy.random.uniform(low=lowerbound[c], high=upperbound[c], size=count)
+
+    return numpy.stack(p).T
 
-    #KDstate.tree for finding nearest velocity grid point
-    if state is None:
-        state = TracerState(verts, N)
-
-    lastid = 0
-    def rand_vert():
-        #Get a random velocity grid point
-        lastid = random.randint(0, len(verts)-1)
-        pos = verts[lastid]
-        #Generate some random noise to offset
-        noise3 = numpy.array((0.,0.,0.))
-        if noise > 0.0:
-            noise3 = numpy.random.rand(3) * noise
-        #Fixed height?
-        if height:
-            noise3[2] = height
-        #Return the sum
-        return pos + noise3
-
-    if state.positions is None:
-        state.positions = numpy.zeros(shape=(N,3))
-        state.velocities = numpy.zeros(shape=(N,3))
-        state.values = numpy.zeros(shape=(N))
-        for i in range(N):
-            state.positions[i] = rand_vert()
-            state.steps[i] = 0
-            state.values[i] = numpy.linalg.norm(vecs[lastid])
-
-    #Query all tracer state.positions
-    q = state.tree.query(state.positions, k=1)
-    for r in range(len(q[0])):
-        #print("result, distance, point")
-        #print(r, q[0][r], state.tree.data[q[1][r]], state.positions[r])
-
-        #Increasing random chance as steps exceed 5 of a new start pos
-        if random.randint(0,state.steps[r]) > 5:
-            #Pick a new random grid vertex to start from
-            #(Must be farther away than distance criteria)
-            old = numpy.array(state.positions[r])
-            while True:
-                state.positions[r] = rand_vert() 
-                if numpy.linalg.norm(state.positions[r]-old) > limit:
-                    break
-            state.steps[r] = 0
-            state.values[r] = numpy.linalg.norm(vecs[lastid])
+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, viewer=None):
+        """
+        Seed random particles into a vector field and trace their positions
+
+        Parameters
+        ----------
+        grid : list of coord arrays for each dimension as expected by RegularGridInterpolator,
+            or a numpy array of 2d or 3d vertices, which will be converted before being sent to the interpolator
+            Object returned from first call, pass None on first pass
+        count : int
+            Number of particles to seed and track
+        lowerbound : optional minimum vertex point defining particle bounding box,
+            if not provided will be taken from grid lower corner
+        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
+        age : int
+            Minimum particle age in steps after which particle can be deleted and respawned, defaults to 4
+        respawn : float
+            Probability of respawning, after age reached, default 0.2 ==> 1 in 5 chance of deletion
+        speed_multiply : float
+            Speed multiplier, scaling factor for the velocity taken from the vector values
+        height : float
+            A fixed height value, all positions will be given this height as their Z component
+        viewer : lavavu.Viewer
+            Viewer object for plotting functions
+        """
+        if len(grid) == 2:
+            self.gridx = grid[0]
+            self.gridy = grid[1]
+            self.gridz = numpy.array((height, height))
+            self.dims = 2
+        elif len(grid) == 3:
+            self.gridx = grid[0]
+            self.gridy = grid[1]
+            self.gridz = grid[2]
+            self.dims = 3
+        elif isinstance(grid, numpy.ndarray) and grid.shape[1] == 3:
+            self.gridx = grid[::,0]
+            self.gridy = grid[::,1]
+            self.gridz = grid[::,2]
+            self.dims = 3
+        elif isinstance(grid, numpy.ndarray) and grid.shape[1] == 2:
+            self.gridx = grid[::,0]
+            self.gridy = grid[::,1]
+            self.gridz = numpy.array((height, height))
+            self.dims = 2
         else:
-            #Index of nearest grid point is in q[1][r]
-            #Lookup vector at this index, multiply by position to get delta and add
-            state.velocities[r] = vecs[q[1][r]] #Store velocity
-            state.positions[r] += speed * vecs[q[1][r]]
-            #Increment step tracking
-            state.steps[r] += 1
-            state.values[r] = numpy.linalg.norm(vecs[q[1][r]])
-
-    return state
+            raise(ValueError('Grid needs to be array of 2d/3d vertices, or arrays of vertex coords (x, y, [z])'))
+
+        self.count = count
+        if lowerbound is None:
+            lowerbound = (self.gridx[0], self.gridy[0], self.gridz[0])
+        if upperbound is None:
+            upperbound = (self.gridx[-1], self.gridy[-1], self.gridz[-1])
+        self.positions = random_particles(self.count, lowerbound, upperbound, self.dims)
+        self.old_pos = numpy.zeros_like(self.positions)
+        self.lowerbound = lowerbound
+        self.upperbound = upperbound
+        self.velocities = None
+        self.steps = [0]*count
+        self.speed = numpy.zeros(shape=(count))
+        self.ages = numpy.zeros(shape=(count))
+        self.interp = None
+        if limit is None:
+            limit = 0.1 * (abs(self.gridx[-1] - self.gridx[0]) + abs(self.gridy[-1] - self.gridy[0]))
+        self.limit = limit
+        self.age = age
+        self.respawn_chance = respawn_chance
+        self.speed_multiply = speed_multiply
+        self.height = height
+
+        self.lv = viewer
+        self.points = None
+        self.arrows = None
+        self.tracers = None
+
+
+    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
+
+        self.ages[r] = 0
+        self.positions[r] = pos
+
+    def update(self, vectors=None):
+        #Interpolate velocity at all positions,
+        #If vectors not passed, will use previous values
+        if vectors is not None:
+            if self.dims == 2:
+                self.interp = RegularGridInterpolator((self.gridx, self.gridy), vectors, bounds_error=False, fill_value=0.0)
+            else:
+                self.interp = RegularGridInterpolator((self.gridx, self.gridy, self.gridz), vectors, bounds_error=False, fill_value=0.0)
+
+        if self.interp is None:
+            raise(ValueError("No velocity grid, must pass vectors for first call of update()"))
+
+        self.velocities = self.interp(self.positions)
+        self.old_pos = numpy.copy(self.positions)
+
+        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])):
+                self.respawn(r)
+            else:
+                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
+
+        if self.lv:
+            positions = self.positions
+            if self.dims == 2 and self.height != 0:
+                #Convert to 3d and set z coord to height
+                shape = list(positions.shape)
+                shape[-1] = 3
+                positions = numpy.zeros(shape)
+                positions[::,0:2] = self.positions
+                positions[::,2] = numpy.array([self.height] * shape[0])
+            if self.points:
+                self.points.vertices(positions)
+                if len(self.points["colourmap"]):
+                    self.points.values(self.speed)
+            if self.arrows:
+                self.arrows.vectors(self.velocities)
+                self.arrows.vertices(positions)
+                if len(self.arrows["colourmap"]):
+                    self.arrows.values(self.speed)
+
+            if self.tracers:
+                self.tracers.vertices(positions)
+                if len(self.tracers["colourmap"]):
+                    self.tracers.values(self.speed)
+
+    def plot_points(self, **kwargs):
+        if self.lv is not None and self.points is None:
+            self.points = self.lv.points('tracer_points', **kwargs)
+
+    def plot_arrows(self, **kwargs):
+        if self.lv is not None and self.arrows is None:
+            self.arrows = self.lv.vectors('tracer_arrows', **kwargs)
+
+    def plot_tracers(self, **kwargs):
+        if self.lv is not None and self.tracers is None:
+            self.tracers = self.lv.tracers('tracers', dims=self.count, limit=self.limit, **kwargs)
 

{lavavu-1.8.84.dist-info → lavavu-1.9.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lavavu
-Version: 1.8.84
+Version: 1.9.5
 Summary: Python interface to LavaVu OpenGL 3D scientific visualisation utilities
 Author-email: Owen Kaluza <owen@kaluza.id.au>
 License: ### Licensing
@@ -215,13 +215,15 @@ License-File: LICENSE.md
 Requires-Dist: numpy>=1.18
 Requires-Dist: aiohttp
 Requires-Dist: jupyter-server-proxy
+Requires-Dist: matplotlib
+Requires-Dist: numpy-quaternion
 
 ![# logo](http://owen.kaluza.id.au/Slides/2017-08-15/LavaVu.png)
 
 [![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.8.84)
+[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/lavavu/LavaVu/1.9.5)
 
 A scientific visualisation tool with a python interface for fast and flexible visual analysis.
 
@@ -229,11 +231,12 @@ Documentation available here [LavaVu Documentation](https://lavavu.github.io/Doc
 
 ![examplevis](http://owen.kaluza.id.au/Slides/2017-08-15/combined.png)
 
-LavaVu development is supported by the [Monash Immersive Visualisation Plaform](http://monash.edu.au/mivp) and the Simulation, Analysis & Modelling component of the [NCRIS AuScope](http://www.auscope.org.au/ncris/) capability.
+LavaVu development is supported by [ACCESS-NRI](https://www.access-nri.org.au/).
+Prior development was funded by the Monash Immersive Visualisation Plaform at [Monash eResearch](https://www.monash.edu/researchinfrastructure/eresearch) and the Simulation, Analysis & Modelling component of the [NCRIS AuScope](http://www.auscope.org.au/ncris/) capability.
 
 The acronym stands for: lightweight, automatable  visualisation and analysis viewing utility, but "lava" is also a reference to its primary application as a viewer for geophysical simulations. It was also chosen to be unique enough to find the repository with google.
 
-The project started in the gLucifer<sup>1</sup> framework for visualising geodynamics simulations. The OpenGL visualisation module was separated from the simulation and sampling libraries and became a more general purpose visualisation tool. gLucifer continues as a set of sampling tools for Underworld simulations as part of the [Underworld2](https://github.com/underworldcode/underworld2/) code. LavaVu provides the rendering library for creating 2d and 3d visualisations to view this sampled data, inline within interactive IPython notebooks and offline through saved visualisation databases and images/movies.
+The project started as a replacement rendering library for the gLucifer<sup>1</sup> framework, visualising geodynamics simulations. The new OpenGL visualisation code was re-implemented as a more general purpose visualisation tool. gLucifer continues as a set of sampling tools for Underworld simulations as part of the [Underworld2](https://github.com/underworldcode/underworld2/) code. LavaVu provides the rendering library for creating 2d and 3d visualisations to view this sampled data, inline within interactive Jupyter notebooks and offline through saved visualisation databases and images/movies.
 
 As a standalone tool it is a scriptable 3D visualisation tool capable of producing publication quality high res images and video output from time varying data sets along with HTML5 3D visualisations in WebGL.
 Rendering features include correctly and efficiently rendering large numbers of opaque and transparent points and surfaces and volume rendering by GPU ray-marching. There are also features for drawing vector fields and tracers (streamlines).
@@ -241,12 +244,11 @@ Rendering features include correctly and efficiently rendering large numbers of
 Control is via python and a set of simple verbose scripting commands along with mouse/keyboard interaction.
 GUI components can be generated for use from a web browser via the python "control" module and a built in web server.
 
+Widgets for interactive use in the Jupyter notebook environment allow use for remote visualisation, eg: on supercomputing environments.
+
 A native data format called GLDB is used to store and visualisations in a compact single file, using SQLite for storage and fast loading. A small number of other data formats are supported for import (OBJ surfaces, TIFF stacks etc). 
 Further data import formats are supported with python scripts, with the numpy interface allowing rapid loading and manipulation of data.
 
-A CAVE2 virtual reality mode is provided by utilising Omegalib (http://github.com/uic-evl/omegalib) to allow use in Virtual Reality and Immersive Visualisation facilities, such as the CAVE2 at Monash, see (https://github.com/mivp/LavaVR).
-Side-by-side and quad buffer stereoscopic 3D support is also provided for other 3D displays.
-
 ### This repository ###
 
 This is the public source code repository for all development on the project.
@@ -257,13 +259,10 @@ Development happens in the "master" branch with stable releases tagged, so if yo
 It's now in the python package index, so you can install with *pip*:
 
 ```
-pip install --user lavavu
+python -m pip install lavavu
 ```
 
-> If you don't have pip available, you can try `sudo easy_install pip` or just install [Anaconda](https://www.anaconda.com/download), which comes with pip and a whole lot of other useful packages for scientific work with python. Once in anaconda `pip install lavavu` will install the package.
-
-> Currently no binaries are provided and the installer needs to compile the library, so on Linux you may need some developer tools and headers first, eg: for Ubuntu:
-`sudo apt install build-essential libgl1-mesa-dev libx11-dev zlib1g-dev`
+> Currently binary wheels are provided for Linux x86_64, MacOS x86_64 and ARM64 and Windows x86_64. 
 
 To try it out:
 
@@ -280,7 +279,12 @@ Alternatively, clone this repository with *git* and build from source:
 ```
   git clone https://github.com/lavavu/LavaVu
   cd LavaVu
+  python -m pip install .
+```
+or 
+```
   make -j4
+
 ```
 
 If all goes well the viewer will be built, try running with:
@@ -289,14 +293,14 @@ If all goes well the viewer will be built, try running with:
 ### Dependencies ###
 
 * OpenGL and Zlib, present on most systems, headers may need to be installed
-* To use with python requires python 2.7+ and NumPy
-* For video output, requires: libavcodec, libavformat, libavutil, libswscale (from FFmpeg / libav)
+* To use with python requires python 3.6+ and NumPy
+* For video output, requires: PyAV or for built in encoding, libavcodec, libavformat, libavutil, libswscale (from FFmpeg / libav)
 * To build the python interface from source requires swig (http://www.swig.org/)
 
 ### Who do I talk to? ###
 
 * Report bugs/issues here on github: https://github.com/lavavu/LavaVu/issues
-* Contact developer: Owen Kaluza (at) monash.edu
+* Contact developer: Owen Kaluza (at) anu.edu.au
 
 For further documentation / examples, see the online documentation
 * https://lavavu.github.io/Documentation

{lavavu-1.8.84.dist-info → lavavu-1.9.5.dist-info}/RECORD

@@ -1,17 +1,23 @@
-lavavu/lavavu.py,sha256=B_n4pude411uaNukrugiM3JUdKgWvhW3q6UxfFCoFxs,208383
+lavavu-1.9.5.dist-info/LICENSE.md,sha256=EhfNgC6BYh5gDEaq4tcrN3S0wbO4CtJO46botJnCF8c,8603
+lavavu-1.9.5.dist-info/RECORD,,
+lavavu-1.9.5.dist-info/WHEEL,sha256=9FabR3Kab7Nb3lO5nBQWtZc544XJ0hYCmiQC2RH2bHM,107
+lavavu-1.9.5.dist-info/entry_points.txt,sha256=LC2qXR6EMe45Cb7zGAF99R9HFrAECP6Qkp_YuG6HZB0,44
+lavavu-1.9.5.dist-info/top_level.txt,sha256=JptS0k1nlBumjLs_0hITr3_XUJhxqvKBXD2jGho3E3A,7
+lavavu-1.9.5.dist-info/METADATA,sha256=nMfJlUStgvgfQ-Tk_nLAsJovku-9X9P5RkZePVYnFTg,17855
+lavavu/lavavu.py,sha256=FX4KuzAW_-JZqG976lZUHkw-_j6Due8l2Z8W4ZBToxU,218332
 lavavu/vutils.py,sha256=6Vm_xl1bp9mWlfk7jgLDwbRw-tdE_oxin77YkLel3_4,5437
 lavavu/dict.json,sha256=lsZEHc7Bb6_lt7tkSBQMgkq7AEn_2hnhWzzdokmvIY8,52729
 lavavu/server.py,sha256=L-_yPCbNfwYxJCPjDQtr_lxPnDp4oMNVFyxXhBERYrQ,12468
 lavavu/points.py,sha256=jRRtA6CrcA46Y2jUJmkxnIiVoMC5a14xEd_ojhmjhz4,5871
 lavavu/LavaVuPython.py,sha256=ixhceiAr0gGGfCe3d2cY0IIgS4hbgoYJGa_RfgAmmrU,33207
-lavavu/tracers.py,sha256=0dB6v9Jg5G-IeZxiVFvbPoTycGvyAQBtgyEAZUmq4XU,4257
+lavavu/tracers.py,sha256=-NwdBAj5vYWmLt4NE0gWl36SQShQhICR7vBE4rzNOFI,8488
 lavavu/convert.py,sha256=tbYRjLE2l1hI4d6tsW41Lia1JXmrWSc0-JAYCiMrjys,35516
-lavavu/control.py,sha256=C5fLZeeNazRODDlWyWhKINry86uW7jAu3x_MvmrKeO8,66434
+lavavu/control.py,sha256=s32rtLPXXYtxpeXd6-iHdupmaMTJ3KhK6Vq-CLjf9OQ,66755
 lavavu/__init__.py,sha256=JroZQiUbuVN7ifixk2zNDGlyLGaM8bqfRbw4D_F9qIQ,191
 lavavu/amalgamate.py,sha256=Xloq1IZ4VUvYiROzQtwKcQIWC65c7EZrdiGVhZdolL8,586
 lavavu/aserver.py,sha256=SfFvLeDTcx1XtS8fY_HIrDmh3q9HicCBRSAriY5yyOE,12003
 lavavu/font.bin,sha256=fvi5zkvmq6gh9v3jXedBVuxNJWKmHtbjECzv6eT9wb4,225360
-lavavu/_LavaVuPython.cpython-38-darwin.so,sha256=rIuv0E2xUzQH9yYq7oLsV7gXm51r8UXtHqKSPAnig1k,3842400
+lavavu/_LavaVuPython.cpython-38-darwin.so,sha256=QhPLdik_gSDxODzoDV8ysLHRSwlFmXCf03BC-_B4i_8,3927280
 lavavu/__main__.py,sha256=EbDetijCjyoiNxmExqnDGoRVs996tSVave5DML9zuMY,235
 lavavu/html/control.css,sha256=PVLwmle00ciEckUV5ZIRmI3Whxhl7-mlVexnyyxoU70,3259
 lavavu/html/control.js,sha256=oV24eJZ0vfuCxF3fO60eeJSkNFJ9hUkSCThHGJS1Wvc,11652
@@ -27,27 +33,23 @@ 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=FtI5i_Fw4DPfDfJyY6OnphZmyAmqFW1Mc14I6ouG9nM,1522
+lavavu/html/webview.html,sha256=aUS6ZlGmrsZ4TkKv1-zKV_g_QQezWxL4DN0-ALnAOZs,1521
 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=WCli3UYcQ7frjNq0aAXNALu33iNiN8lpTYwKZ7pUcn4,21501
 lavavu/html/baseviewer.js,sha256=u3UhC1At6rMBKmcQ7d2DXTRxQ20wsQkc4lqA-7sL7i4,9567
-lavavu/shaders/volumeShader.frag,sha256=CIFSfwI8xVZ0ALme2QPMcXWl5yB55WCGnfJZ1Led6TU,16120
-lavavu/shaders/pointShader.vert,sha256=rnEa8PfIK3kFtFg04Ataf10aWsjEkh1URY2ipV1xTMY,1235
-lavavu/shaders/lineShader.frag,sha256=aCmOWC20fHinR32p6LZPdCZP6abn-K1V2slbJ_5NoVA,945
-lavavu/shaders/fontShader.frag,sha256=DXAzO7kS36TBzYMJW0XqFiQQTTc4jFedGiUkLjelYKs,444
-lavavu/shaders/triShader.frag,sha256=pG6eWiVgtHB8cSHyB8W3SHrc7-mLqaCRlZaHZfsEKhc,5007
-lavavu/shaders/default.vert,sha256=9J5Oqg8ns711fSNeQTtdA7ENb2sfonx0KGh1QfHp5Ws,317
-lavavu/shaders/triShader.vert,sha256=pJXftq7IiqiGe7NTMmuBUMDs4OZc9TD8lNJ4q-8B57Q,1120
-lavavu/shaders/lineShader.vert,sha256=6kJQcfu3eqaj910_KdaklVRvYxNbeu0ZbpDEOxRVde0,522
+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
+lavavu/shaders/lineShader.frag,sha256=2PQBMcb149jVKnsBhTvU1vf94x91O0kAdOBTSs8OpGY,888
+lavavu/shaders/fontShader.frag,sha256=clgomy2lu-1u7w0GwFd0BNU_L3-SkYt8zv03N5ciJug,351
+lavavu/shaders/triShader.frag,sha256=SkPatq2s7Osa5o7U3lg-7We8ldY0oHZHCLuQjRY4Vgk,4601
+lavavu/shaders/default.vert,sha256=3xKybexF39UGsESMLQQcqHlE1MgLCDEXUMLz4sr5blQ,352
+lavavu/shaders/triShader.vert,sha256=H7rTS-WO5QiT9uP1ClhufQM8minSWknJ9UvKAEVnzRU,1078
+lavavu/shaders/lineShader.vert,sha256=5HDJMphXW438yMc0I2NtBdnvF6uXrOUac9hjk3S7mfk,501
 lavavu/shaders/fontShader.vert,sha256=yCBmRugaPUeUQUdIh62-AK_5KELiJqVS2M82iyIqPwo,290
-lavavu/shaders/pointShader.frag,sha256=T1PA9Z6FiE66rS2sAmmFIbYM2VqEkLBycxV-sx3nACY,3384
+lavavu/shaders/pointShader.frag,sha256=3zREBdsimlL9fAXBPjhzomGaFUWmlG_QYkhwMTVURHQ,3291
 lavavu/shaders/volumeShader.vert,sha256=uGdQjGqi7V5kE6V7nxymfugtU4cbf6u570xBy13RgmY,78
-lavavu/shaders/default.frag,sha256=xCkYz8QriRlnAr-NtenZSIWI_liSxv9jz3Lp5immK9k,258
-lavavu-1.8.84.dist-info/LICENSE.md,sha256=EhfNgC6BYh5gDEaq4tcrN3S0wbO4CtJO46botJnCF8c,8603
-lavavu-1.8.84.dist-info/RECORD,,
-lavavu-1.8.84.dist-info/WHEEL,sha256=7_oe0rMIEoZOpgBhth1WRv0SCKz8pdiUZgyT0NjKRv8,107
-lavavu-1.8.84.dist-info/entry_points.txt,sha256=LC2qXR6EMe45Cb7zGAF99R9HFrAECP6Qkp_YuG6HZB0,44
-lavavu-1.8.84.dist-info/top_level.txt,sha256=JptS0k1nlBumjLs_0hITr3_XUJhxqvKBXD2jGho3E3A,7
-lavavu-1.8.84.dist-info/METADATA,sha256=MFufiRsa4bX84GlDYNKdHy3uH7jsoAK4xCJu-jUjkHE,18237
+lavavu/shaders/default.frag,sha256=5XLYVfLwzN0sFT3aMYGmxbyquA_cmndp55YCOuy1t4E,180

{lavavu-1.8.84.dist-info → lavavu-1.9.5.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.3.0)
+Generator: setuptools (75.3.2)
 Root-Is-Purelib: false
 Tag: cp38-cp38-macosx_11_0_arm64