lavavu-osmesa 1.9.9__cp313-cp313-manylinux_2_28_x86_64.whl

lavavu/points.py

@@ -0,0 +1,191 @@
+"""
+Warning! EXPERIMENTAL:
+ these features and functions are under development, will have bugs,
+ and may be heavily modified in the future
+
+Tools for importing and working with point clouds
+- OBJ loader, requires pywavefront
+- PLY loader, requires plyfile
+- LAS loader, requires laspy
+
+These functions ported from my viz script repo here:
+https://github.com/mivp/vizscripts/tree/master/pointcloud
+More tools can be found there, including a ptx reader which handles transformations of multiple point clouds into one coord space
+
+"""
+import numpy
+import os
+import convert
+
+def loadpointcloud(filename, subsample=1, dtype=numpy.float32, components=['x', 'y', 'z', 'red', 'green', 'blue', 'alpha']):
+    """
+    Attempt to load the passed point cloud file based
+    Pick loader based on extension
+
+    Parameters
+    ----------
+    filename, str
+        Full path to file to load
+    subsample, int
+        Subsample factor, sample every Nth point
+    dtype, numpy.dtype
+        Type of data
+    components, list
+        List of components per point
+
+    Returns
+    -------
+    vertices : array
+        numpy array x,y,z
+    colours : array
+        numpy array r,g,b or r,g,b,a
+    """
+    fn, ext = os.path.splitext(filename)
+    ext = ext.lower()
+    if ext == '.xyz':
+        #Loop over lines in input file
+        count = 0
+        V = []
+        C = []
+        with open(filename, 'r') as file:
+            for line in file:
+                #Subsample?
+                count += 1
+                if subsample > 1 and count % subsample != 1: continue
+
+                if count % 10000 == 0:
+                  print(count)
+                  sys.stdout.flush()
+
+                #Read particle position
+                data = re.split(r'[,;\s]+', line.rstrip())
+                if len(data) < 3: continue
+                x = float(data[0])
+                y = float(data[1])
+                z = float(data[2])
+
+                V.append((x, y, z))
+
+                #R,G,B[,A] colour if provided
+                if len(data) >= 7:
+                    C.append((int(data[3]), int(data[4]), int(data[5]), int(data[6])))
+                elif len(data) == 6:
+                    C.append((int(data[3]), int(data[4]), int(data[5]), 255))
+
+        V = numpy.array(V)
+        C = numpy.array(C)
+
+    elif ext == '.xyzb':
+        inbytes = os.path.getsize(filename)
+        #All floats
+        #num = inbytes / (4 * 6) # x y z r g b
+        #All floats, rgba
+        #num = inbytes / (4 * 7) # x y z r g b a
+        #All doubles, rgba
+        #num = inbytes / (8 * 7) # x y z r g b a
+        #Float vert, byte colour
+        #num = inbytes / (4 * 3 + 4) # x y z r g b a
+        sz = numpy.dtype(dtype).itemsize
+        num = inbytes // (sz * len(components))
+
+        with open(filename, 'rb') as infile:
+            print("Importing " + str(num//subsample) + " points")
+            arr = numpy.fromfile(infile, dtype='float64')
+            infile.close()
+
+            arr = arr.astype(dtype).reshape(len(arr)//len(components), len(components))
+            if subsample > 1:
+                arr = arr[::subsample]
+
+            #Convert float rgba to uint32 colour
+            colours = None
+            if len(components) > 6:
+                colours = arr[:,3:len(components)]
+                colours *= 255
+                colours = colours.astype('uint8').ravel()
+                colours = colours.view(dtype='uint32')
+
+            return (arr[:,0:3], colours)
+
+    elif ext == '.obj':
+        print("Loading OBJ")
+        import pywavefront
+        scene = pywavefront.Wavefront(filename)
+        V = numpy.array(scene.vertices)
+
+        #SubSample
+        if subsample > 1:
+            V = V[::subsample]
+            print("Subsampled:",V.shape)
+
+        verts = V[:,0:3]
+        colours = V[:,3:] * 255
+
+        #Load positions and RGB
+        print("Creating visualisation ")
+        return (verts, colours)
+
+    elif ext == '.ply':
+        print("Loading PLY")
+        from plyfile import PlyData, PlyElement       
+        plydata = PlyData.read(filename)
+        if plydata:
+            x = plydata['vertex']['x']
+            y = plydata['vertex']['y']
+            z = plydata['vertex']['z']
+            V = numpy.vstack((x,y,z)).reshape([3, -1]).transpose()
+
+            C = convert._get_PLY_colours(plydata.elements[0])
+
+            #SubSample
+            if subsample > 1:
+                V = V[::subsample]
+                if C is not None:
+                    C = C[::subsample]
+
+            return (V, C)
+
+    elif ext == '.las' or ext == '.laz':
+        print("Loading LAS")
+        import laspy
+        infile = laspy.file.File(filename, mode="r")
+        '''
+        print(infile)
+        print(infile.point_format)
+        for spec in infile.point_format:
+           print(spec.name)
+        print(infile.header)
+        print(infile.header.dataformat_id)
+
+        print(infile.header.offset)
+        print(infile.header.scale)
+        '''
+
+        #Grab all of the points from the file.
+        #point_records = infile.points
+        #print(point_records)
+        #print(point_records.shape)
+
+        #Convert colours from short to uchar
+        if infile.red.dtype == numpy.uint16:
+            R = (infile.red / 255).astype(numpy.uint8)
+            G = (infile.green / 255).astype(numpy.uint8)
+            B = (infile.blue / 255).astype(numpy.uint8)
+        else:
+            R = infile.red
+            G = infile.green
+            B = infile.blue
+
+        ss = subsample
+        if ss > 1:
+            V = numpy.array([infile.x[::ss], infile.y[::ss], infile.z[::ss]])
+            C = numpy.array([R[::ss],G[::ss],B[::ss]])
+            return (V, C)
+        else:
+            V = numpy.array([infile.x, infile.y, infile.z])
+            C = numpy.array([R,G,B])
+            return (V, C)
+
+    else:
+        print("Unknown point cloud format, extension: ", ext)
+

lavavu/server.py

@@ -0,0 +1,343 @@
+import urllib
+import os
+import threading
+import time
+import errno
+from functools import partial
+import weakref
+import base64
+import json
+import socket
+
+from socketserver import ThreadingMixIn
+from http.server import SimpleHTTPRequestHandler, HTTPServer
+from urllib.parse import unquote
+from urllib.parse import urlparse
+from urllib.parse import parse_qs
+
+"""
+HTTP Server interface
+"""
+class LVRequestHandler(SimpleHTTPRequestHandler, object):
+
+    def __init__(self, viewer_weakref, *args, **kwargs):
+        #Used with partial() to provide the viewer object
+        try:
+            self._lv = viewer_weakref
+            super(LVRequestHandler, self).__init__(*args, **kwargs)
+        except (IOError) as e:
+            pass #Just ignore IO errors on server
+            if e.errno == errno.EPIPE:
+                # EPIPE error, ignore
+                pass
+            elif e.errno == errno.EPROTOTYPE:
+                # MacOS "Protocol wrong type for socket" error, ignore
+                pass
+            else:
+                raise e
+
+    def serveResponse(self, data, datatype):
+        try:
+            #Serve provided data, with error check for SIGPIPE (broken connection)
+            self.send_response(200)
+            self.send_header('Content-type', datatype)
+            self.send_header('Access-Control-Allow-Origin', '*')
+            self.send_header('x-colab-notebook-cache-control', 'no-cache') #Colab: disable offline access cache      
+            self.end_headers()
+            if data:
+                self.wfile.write(data)
+        #This specific error sometimes occurs on windows, ConnectionError is the base class and covers a few more
+        #except (IOError,ConnectionAbortedError) as e:
+        #    if isinstance(e,ConnectionAbortedError):
+        except (IOError,ConnectionError) as e:
+            if isinstance(e,ConnectionError):
+                pass
+            elif e.errno == errno.EPIPE:
+                # EPIPE error, ignore
+                pass
+            else:
+                raise e
+
+    def do_HEAD(self):
+        self.serveResponse(None, 'text/html')
+
+    def do_POST(self):
+        #Always interpret post data as commands
+        #(can perform other actions too based on self.path later if we want)
+        data_string = self.rfile.read(int(self.headers['Content-Length']))
+        self.serveResponse(b'', 'text/plain')
+        #cmds = str(data_string, 'utf-8') #python3 only
+        try: #Python3
+            from urllib.parse import unquote
+            data_string = unquote(data_string)
+        except: #Python2
+            from urllib import unquote
+            data_string = unquote(data_string).decode('utf8')
+        cmds = str(data_string.decode('utf-8'))
+        #Run viewer commands
+        self._execute(cmds)
+
+    def do_GET(self):
+        lv = self._get_viewer()
+        parsed = urlparse(self.path)
+        query = parse_qs(parsed.query)
+
+        def img_response():
+            resp = None
+            if 'width' in query and 'height' in query:
+                resp = lv.jpeg(resolution=(int(query['width'][0]), int(query['height'][0])))
+            elif 'width' in query:
+                resp = lv.jpeg(resolution=(int(query['width'][0]), 0))
+            else:
+                resp = lv.jpeg()
+
+            #Ensure the response is valid before serving
+            if resp is not None:
+                self.serveResponse(resp, 'image/jpeg')
+
+        if self.path.find('image') > 0:
+            img_response()
+
+        elif self.path.find('command=') > 0:
+            pos1 = self.path.find('=')
+            pos2 = self.path.find('?')
+            if pos2 < 0: pos2 = len(self.path)
+            cmds = unquote(self.path[pos1+1:pos2])
+
+            #Run viewer commands
+            self._execute(cmds)
+
+            #Serve image or just respond 200
+            if self.path.find('icommand=') > 0:
+                img_response()
+            else:
+                self.serveResponse(b'', 'text/plain')
+
+        elif self.path.find('getstate') > 0:
+            state = lv.app.getState()
+            self.serveResponse(bytearray(state, 'utf-8'), 'text/plain; charset=utf-8')
+            #self.serveResponse(bytearray(state, 'utf-8'), 'text/plain')
+        elif self.path.find('connect') > 0:
+            if 'url' in query:
+                #Save first valid connection URL on the viewer
+                url = query['url'][0]
+                if len(lv._url) == 0:
+                    lv._url = url
+            uid = id(lv)
+            self.serveResponse(bytearray(str(uid), 'utf-8'), 'text/plain; charset=utf-8')
+        elif self.path.find('key=') > 0:
+            pos2 = self.path.find('&')
+            cmds = unquote(self.path[1:pos2])
+            lv.commands('key ' + cmds, True)
+            self.serveResponse(b'', 'text/plain')
+        elif self.path.find('mouse=') > 0:
+            pos2 = self.path.find('&')
+            cmds = unquote(self.path[1:pos2])
+            lv.commands('mouse ' + cmds, True)
+            self.serveResponse(b'', 'text/plain')
+        elif len(self.path) <= 1:
+            #Root requested, returns interactive view
+            w = lv.control.Window(align=None, wrapper=None)
+            code = lv.control.show(True, filename="")
+            self.serveResponse(bytearray(code, 'utf-8'), 'text/html; charset=utf-8')
+        else:
+            return SimpleHTTPRequestHandler.do_GET(self)
+
+    #Serve files from lavavu html dir
+    def translate_path(self, path):
+        lv = self._get_viewer()
+        if not os.path.exists(path):
+            #print(' - not found in cwd')
+            if path[0] == '/': path = path[1:]
+            path = os.path.join(lv.htmlpath, path)
+            if os.path.exists(path) and os.path.isfile(path):
+                #print(' - found in htmlpath')
+                return path
+            else:
+                #print(' - not found in htmlpath')
+                return SimpleHTTPRequestHandler.translate_path(self, self.path)
+        else:
+            return SimpleHTTPRequestHandler.translate_path(self, path)
+
+    #Stifle log output
+    def log_message(self, format, *args):
+        return
+
+    def _get_viewer(self):
+        #Get from weak reference, if deleted raise exception
+        lv = self._lv()
+        if not lv:
+            self._closing = True
+            raise(Exception("Viewer not found"))
+        return lv
+
+    def _execute(self, cmds):
+        lv = self._get_viewer()
+
+        if len(cmds) and cmds[0] == '_':
+            #base64 encoded commands or JSON state
+            cmds = str(base64.b64decode(cmds).decode('utf-8'))
+            #cmds = str(base64.b64decode(cmds), 'utf-8')
+
+        #Object to select can be provided in preceding angle brackets
+        selobj = None
+        if cmds[0] == '<':
+            pos = cmds.find('>')
+            selobj = lv.objects[cmds[1:pos]]
+            cmds = cmds[pos+1:]
+
+        #Execute commands via python API by preceding with '.'
+        done = False
+        if cmds[0] == '.':
+            attr = cmds.split()[0][1:]
+            pos = cmds.find(' ')
+            params = cmds[pos+1:]
+            if selobj:
+                #Call on Object
+                func = getattr(selobj, attr)
+                if func and callable(func):
+                    func(params)
+                    done = True
+            else:
+                #Call on Viewer
+                func = getattr(lv, attr)
+                if func and callable(func):
+                    func(params)
+                    done = True
+        elif cmds[0] == '$':
+            #Requests prefixed by '$' are sent
+            #from property collection controls
+            #format is $ID KEY VALUE
+            # - ID is the python id() of the properties object
+            #    All properties collections are stored on their parent
+            #    object using this id in the _collections dict
+            # - KEY is the property name key to set
+            # - VALUE is a json string containing the value to set
+            S = cmds.split()
+            target = S[0][1:]
+            if target in lv._collections:
+                #Get from _collections by id (weakref)
+                props = lv._collections[target]()
+                props[S[1]] = json.loads(S[2])
+                #Check for callback - if provided, call with updated props
+                func = getattr(props, 'callback')
+                if func and callable(func):
+                    func(props)
+
+        #Default, call via lv.commands() scripting API
+        if not done:
+            if selobj:
+                selobj.select()
+            lv.commands(cmds)
+
+#Optional thread per request version:
+class ThreadingHTTPServer(ThreadingMixIn, HTTPServer):
+    pass
+
+"""
+HTTP Server manager class
+"""
+class Server(threading.Thread):
+    def __init__(self, viewer, port=None, ipv6=False, retries=100):
+        self.host = 0
+        if port is None:
+            port = 8080
+        self._closing = False
+        #Allow viewer to be garbage collected
+        self.viewer = weakref.ref(viewer)
+        self.port = port
+        self.retries = retries
+        self.maxretries = retries
+        self.ipv6 = ipv6
+        super(Server, self).__init__()
+        self.daemon = True #Place in background so will be closed on program exit
+        self._cv = threading.Condition()
+
+    def handle(self):
+        try:
+            httpd.handle_request()
+        except (socket.exception) as e:
+            #print(str(e))
+            pass
+
+    def run(self):
+        httpd = None
+        HTTPServer.allow_reuse_address = False
+        try:
+            # We "partially apply" our first argument to get the viewer object into LVRequestHandler
+            handler = partial(LVRequestHandler, self.viewer)
+            if self.ipv6:
+                HTTPServer.address_family = socket.AF_INET6
+                hosts = ['::', 'localhost', '::1']
+                host = hosts[self.host]
+                #httpd = HTTPServer((host, self.port), handler)
+                httpd = ThreadingHTTPServer((host, self.port), handler)
+            else:
+                HTTPServer.address_family = socket.AF_INET
+                hosts = ['0.0.0.0', 'localhost', '127.0.0.1']
+                host = hosts[self.host]
+                #httpd = HTTPServer((host, self.port), handler)
+                httpd = ThreadingHTTPServer(('0.0.0.0', self.port), handler)
+
+            #print("Server running on host %s port %s" % (host, self.port))
+
+            #Sync with starting thread here to ensure server thread has initialised before it continues
+            with self._cv:
+                self._cv.notifyAll()
+
+            # Handle requests
+            #print("Using port: ", self.port)
+            # A timeout is needed for server to check periodically if closing
+            httpd.timeout = 0.05 #50 millisecond timeout
+            while self.viewer() is not None and not self._closing:
+                httpd.handle_request()
+
+        except (Exception) as e:
+            self.retries -= 1
+            if self.retries < 1:
+                print("Failed to start server, max retries reached")
+
+            #Try another port
+            if e.errno == errno.EADDRINUSE: #98
+                self.port += 1
+                #Try again
+                self.run()
+            elif e.errno == errno.EAFNOSUPPORT: #97 : Address family not supported by protocol
+                #Try next host name/address
+                self.host += 1
+                if self.host > 2:
+                    #Try again without ipv6?
+                    if self.ipv6:
+                        self.ipv6 = False
+                    else:
+                        self.ipv6 = True
+                    self.host = 0
+                #Try again
+                self.run()
+            else:
+                print("Server start failed: ",e, e.errno, self.port)
+
+def serve(viewer, port=None, ipv6=False, retries=100):
+    s = Server(viewer, port, ipv6, retries)
+    #Start the thread and wait for it to finish initialising
+    with s._cv:
+        s.start()
+        s._cv.wait()
+    return s
+
+#Ignore SIGPIPE altogether (does not apply on windows)
+import sys
+if sys.platform != 'win32':
+    from signal import signal, SIGPIPE, SIG_IGN
+    signal(SIGPIPE, SIG_IGN)
+
+"""
+Main entry point - run server and open browser interface
+"""
+if __name__ == '__main__':
+    import lavavu
+    lv = lavavu.Viewer()
+    #lv.animate(1) #Required to show viewer window and handle mouse/keyboard events there too
+    lv.browser()
+    lv._thread.join() #Wait for server to quit
+

lavavu/shaders/default.frag

@@ -0,0 +1,14 @@
+in vec4 vColour;
+
+flat in vec4 vFlatColour;
+uniform bool uFlat;
+out vec4 outColour;
+
+void main(void)
+{
+  if (uFlat)
+    outColour = vFlatColour;
+  else
+    outColour = vColour;
+}
+

lavavu/shaders/default.vert

@@ -0,0 +1,17 @@
+in vec4 aVertexPosition;
+in vec4 aVertexColour;
+in vec2 aVertexTexCoord;
+uniform mat4 uMVMatrix;
+uniform mat4 uPMatrix;
+out vec4 vColour;
+out vec2 vTexCoord;
+flat out vec4 vFlatColour;
+
+void main(void)
+{
+  gl_Position = uPMatrix * uMVMatrix * aVertexPosition;
+  vColour = aVertexColour;
+  vTexCoord = aVertexTexCoord;
+  vFlatColour = aVertexColour;
+}
+

lavavu/shaders/fontShader.frag

@@ -0,0 +1,20 @@
+in vec4 vColour;
+in vec2 vTexCoord;
+
+uniform bool uTextured;
+uniform sampler2D uTexture;
+
+out vec4 outColour;
+
+void main(void)
+{
+  vec4 fColour = vColour;
+  if (uTextured)
+  {
+    vec4 tColour = texture(uTexture, vTexCoord);
+    //Just use the alpha component (red in single component texture)
+    fColour.a = tColour.r;
+  }
+  outColour = fColour;
+}
+

lavavu/shaders/fontShader.vert

@@ -0,0 +1,18 @@
+in vec4 aVertexPosition;
+in vec2 aVertexTexCoord;
+
+uniform mat4 uMVMatrix;
+uniform mat4 uPMatrix;
+
+uniform vec4 uColour;
+
+out vec4 vColour;
+out vec2 vTexCoord;
+
+void main(void)
+{
+  gl_Position = uPMatrix * uMVMatrix * aVertexPosition;
+  vColour = uColour;
+  vTexCoord = aVertexTexCoord;
+}
+

lavavu/shaders/lineShader.frag

@@ -0,0 +1,39 @@
+in vec4 vColour;
+in vec3 vVertex;
+
+uniform float uOpacity;
+uniform float uBrightness;
+uniform float uContrast;
+uniform float uSaturation;
+uniform vec3 uClipMin;
+uniform vec3 uClipMax;
+uniform bool uOpaque;
+
+out vec4 outColour;
+
+void main(void)
+{
+  //Clip planes in X/Y/Z
+  if (any(lessThan(vVertex, uClipMin)) || any(greaterThan(vVertex, uClipMax))) discard;
+
+  vec4 colour = vColour;
+  float alpha = colour.a;
+  if (uOpacity > 0.0) alpha *= uOpacity;
+
+  //Brightness adjust
+  colour += uBrightness;
+  //Saturation & Contrast adjust
+  const vec4 LumCoeff = vec4(0.2125, 0.7154, 0.0721, 0.0);
+  vec4 AvgLumin = vec4(0.5, 0.5, 0.5, 0.0);
+  vec4 intensity = vec4(dot(colour, LumCoeff));
+  colour = mix(intensity, colour, uSaturation);
+  colour = mix(AvgLumin, colour, uContrast);
+  colour.a = alpha;
+
+  if (alpha < 0.01) discard;
+
+  if (uOpaque)
+    colour.a = 1.0;
+
+  outColour = colour;
+}

lavavu/shaders/lineShader.vert

@@ -0,0 +1,26 @@
+in vec3 aVertexPosition;
+in vec4 aVertexColour;
+uniform mat4 uMVMatrix;
+uniform mat4 uPMatrix;
+
+uniform int uPointDist;   // Scale by distance
+
+uniform vec4 uColour;
+uniform float uOpacity;
+
+out vec4 vColour;
+out vec3 vVertex;
+
+void main(void)
+{
+  vec4 mvPosition = uMVMatrix * vec4(aVertexPosition, 1.0);
+  gl_Position = uPMatrix * mvPosition;
+
+  if (uColour.a > 0.0)
+    vColour = uColour;
+  else
+    vColour = vec4(aVertexColour.rgb, aVertexColour.a*uOpacity);
+
+  vVertex = aVertexPosition.xyz;
+}
+