bspy 3.0.1__py3-none-any.whl → 4.1__py3-none-any.whl

bspy/splineOpenGLFrame.py

@@ -1,17 +1,18 @@
+from collections import namedtuple
 import numpy as np
-import tkinter as tk
 from OpenGL.GL import *
+from OpenGL.GLU import *
+from bspy.manifold import Manifold
 import OpenGL.GL.shaders as shaders
 try:
     from pyopengltk import OpenGLFrame
 except ImportError:
     from tkinter import Frame as OpenGLFrame
-from bspy import DrawableSpline
-from bspy.drawableSpline import _set_color
+from bspy import Spline
 
 class SplineOpenGLFrame(OpenGLFrame):
     """
-    A tkinter `OpenGLFrame` with shaders to display a `DrawableSpline`.
+    A tkinter `OpenGLFrame` with shaders to display a `Spline`.
     """
 
     ROTATE = 1
@@ -24,6 +25,24 @@ class SplineOpenGLFrame(OpenGLFrame):
     MsPerFrame = 50 # Update every 20th of a second
     """Milliseconds per frame when animating or flying."""
 
+    maxOrder = 9
+    """Maximum order for drawable splines."""
+    maxCoefficients = 120
+    """Maximum number of coefficients for drawable splines."""
+    maxKnots = maxCoefficients + maxOrder
+    """Maximum number of knots for drawable splines."""
+    _maxFloats = 4 + 2 * maxKnots + 4 * maxCoefficients * maxCoefficients
+    """Maximum total number of floats for drawable splines."""
+
+    HULL = (1 << 0)
+    """Option to draw the convex hull of the spline (the coefficients). Off by default."""
+    SHADED = (1 << 1)
+    """Option to draw the spline shaded (only useful for nInd >= 2). On by default."""
+    BOUNDARY = (1 << 2)
+    """Option to draw the boundary of the spline in the line color (only useful for nInd >= 2). On by default."""
+    ISOPARMS = (1 << 3)
+    """Option to draw the lines of constant knot values of the spline in the line color (only useful for nInd >= 2). Off by default."""
+
     computeBSplineCode = """
         void ComputeBSpline(in int offset, in int order, in int n, in int knot, in float u, 
             out float uBSpline[{maxOrder}], out float duBSpline[{maxOrder}])
@@ -941,6 +960,48 @@ class SplineOpenGLFrame(OpenGLFrame):
                 discard;
         }
     """
+
+    trimmedSurfaceFragmentShaderCode = """
+        #version 410 core
+     
+        flat in SplineInfo
+        {
+            int uOrder, vOrder;
+            int uN, vN;
+            int uKnot, vKnot;
+            float uFirst, vFirst;
+            float uSpan, vSpan;
+            float u, v;
+            float uInterval, vInterval;
+        } inData;
+        in vec3 worldPosition;
+        in vec3 splineColor;
+        in vec3 normal;
+        in vec2 parameters;
+        in vec2 pixelPer;
+
+        uniform vec4 uFillColor;
+        uniform vec4 uLineColor;
+        uniform vec3 uLightDirection;
+        uniform int uOptions;
+        uniform sampler2D uTrimTextureMap;
+
+        out vec4 color;
+     
+        void main()
+        {
+        	vec2 tex = vec2((parameters.x - inData.uFirst) / inData.uSpan, (parameters.y - inData.vFirst) / inData.vSpan);
+            float specular = pow(abs(dot(normal, normalize(uLightDirection + worldPosition / length(worldPosition)))), 25.0);
+            bool line = (uOptions & (1 << 2)) > 0 && (pixelPer.x * (parameters.x - inData.uFirst) < 1.5 || pixelPer.x * (inData.uFirst + inData.uSpan - parameters.x) < 1.5);
+            line = line || ((uOptions & (1 << 2)) > 0 && (pixelPer.y * (parameters.y - inData.vFirst) < 1.5 || pixelPer.y * (inData.vFirst + inData.vSpan - parameters.y) < 1.5));
+            line = line || ((uOptions & (1 << 3)) > 0 && pixelPer.x * (parameters.x - inData.u) < 1.5);
+            line = line || ((uOptions & (1 << 3)) > 0 && pixelPer.y * (parameters.y - inData.v) < 1.5);
+            color = line ? uLineColor : ((uOptions & (1 << 1)) > 0 ? vec4(splineColor, uFillColor.a) : vec4(0.0, 0.0, 0.0, 0.0));
+            color.rgb = (0.3 + 0.5 * abs(dot(normal, uLightDirection)) + 0.2 * specular) * color.rgb;
+            if (color.a * texture(uTrimTextureMap, tex).r == 0.0)
+                discard;
+        }
+    """
  
     def __init__(self, *args, eye=(0.0, 0.0, 3.0), center=(0.0, 0.0, 0.0), up=(0.0, 1.0, 0.0), draw_func=None, **kw):
         OpenGLFrame.__init__(self, *args, **kw)
@@ -955,6 +1016,9 @@ class SplineOpenGLFrame(OpenGLFrame):
         self.origin = None
         self.button = None
         self.mode = self.ROTATE
+        
+        self.computeBSplineCode = self.computeBSplineCode.format(maxOrder=self.maxOrder)
+        self.computeSurfaceSamplesCode = self.computeSurfaceSamplesCode.format(maxOrder=self.maxOrder)
 
         self.SetBackgroundColor(0.0, 0.2, 0.2)
 
@@ -967,6 +1031,68 @@ class SplineOpenGLFrame(OpenGLFrame):
         self.bind("<MouseWheel>", self.MouseWheel)
         self.bind("<Unmap>", self.Unmap)
 
+    @staticmethod
+    def compute_color_vector(r, g=None, b=None, a=None):
+        """
+        Return an float32 array with the specified color.
+
+        Parameters
+        ----------
+        r : `float`, `int` or array-like of floats or ints
+            The red value [0, 1] as a float, [0, 255] as an int, or the rgb or rgba value as floats or ints (default).
+        
+        g: `float` or `int`
+            The green value [0, 1] as a float or [0, 255] as an int.
+        
+        b: `float` or `int`
+            The blue value [0, 1] as a float or [0, 255] as an int.
+        
+        a: `float`, `int`, or None
+            The alpha value [0, 1] as a float or [0, 255] as an int. If `None` then alpha is set to 1.
+
+        Returns
+        -------
+        color : `numpy.array`
+            The specified color as an array of 4 float32 values between 0 and 1.
+        """
+        if isinstance(r, (int, np.integer)):
+            red = float(r) / 255.0
+            green = red
+            blue = red
+            alpha = 1.0
+        elif np.isscalar(r):
+            red = r
+            green = red
+            blue = red
+            alpha = 1.0
+        elif isinstance(r[0], (int, np.integer)):
+            red = float(r[0]) / 255.0
+            green = float(r[1]) / 255.0
+            blue = float(r[2]) / 255.0
+            alpha = float(r[3]) / 255.0 if len(r) >= 4 else 1.0
+        else:
+            red = r[0]
+            green = r[1]
+            blue = r[2]
+            alpha = r[3] if len(r) >= 4 else 1.0
+
+        if isinstance(g, (int, np.integer)):
+            green = float(g) / 255.0
+        elif np.isscalar(g):
+            green = g
+
+        if isinstance(b, (int, np.integer)):
+            blue = float(b) / 255.0
+        elif np.isscalar(b):
+            blue = b
+
+        if isinstance(a, (int, np.integer)):
+            alpha = float(a) / 255.0
+        elif np.isscalar(a):
+            alpha = a
+        
+        return np.array((red, green, blue, alpha), np.float32)
+
     def SetDefaultView(self, eye, center, up):
         """
         Set the default view values used when resetting the view.
@@ -994,7 +1120,7 @@ class SplineOpenGLFrame(OpenGLFrame):
         a: `float`, `int`, or None
             The alpha value [0, 1] as a float or [0, 255] as an int. If `None` then alpha is set to 1.
         """
-        self.backgroundColor = _set_color(r, g, b, a)
+        self.backgroundColor = self.compute_color_vector(r, g, b, a)
         if self.glInitialized:
             glClearColor(self.backgroundColor[0], self.backgroundColor[1], self.backgroundColor[2], self.backgroundColor[3])
     
@@ -1035,13 +1161,38 @@ class SplineOpenGLFrame(OpenGLFrame):
         #print("GL_SHADING_LANGUAGE_VERSION: ", glGetString(GL_SHADING_LANGUAGE_VERSION))
         #print("GL_MAX_TESS_GEN_LEVEL: ", glGetIntegerv(GL_MAX_TESS_GEN_LEVEL))
 
+        # Set up frameBuffer into which we draw surface trims.    
+        self.frameBuffer = glGenFramebuffers(1)
+        glBindFramebuffer(GL_FRAMEBUFFER, self.frameBuffer)
+
+        # Create the texture buffer for surface trims.
+        self.trimTextureBuffer = glGenTextures(1)
+        glActiveTexture(GL_TEXTURE1)
+        glBindTexture(GL_TEXTURE_2D, self.trimTextureBuffer)
+        glPixelStorei(GL_UNPACK_ALIGNMENT, 1)
+        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER)
+        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER)
+        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
+        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)
+        glTexImage2D(GL_TEXTURE_2D, 0, GL_RED, 512, 512, 0, GL_RED, GL_UNSIGNED_BYTE, None)
+        glActiveTexture(GL_TEXTURE0)
+
+        # Attach trim texture buffer to framebuffer and validate framebuffer.
+        glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, self.trimTextureBuffer, 0)
+        glDrawBuffers(1, (GL_COLOR_ATTACHMENT0,))
+        if glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE:
+            raise ValueError("Framebuffer incomplete")
+        
+        # Set framebuffer back to default.
+        glBindFramebuffer(GL_FRAMEBUFFER, 0)
+
         # Set up GL texture buffer for spline data
         self.splineDataBuffer = glGenBuffers(1)
         self.splineTextureBuffer = glGenTextures(1)
         glBindBuffer(GL_TEXTURE_BUFFER, self.splineDataBuffer)
         glBindTexture(GL_TEXTURE_BUFFER, self.splineTextureBuffer)
         glTexBuffer(GL_TEXTURE_BUFFER, GL_R32F, self.splineDataBuffer)
-        glBufferData(GL_TEXTURE_BUFFER, 4 * DrawableSpline._maxFloats, None, GL_STATIC_READ)
+        glBufferData(GL_TEXTURE_BUFFER, 4 * self._maxFloats, None, GL_STATIC_READ)
 
         # Set light direction
         self.lightDirection = np.array((0.63960218, 0.63960218, 0.42640144), np.float32)
@@ -1053,13 +1204,12 @@ class SplineOpenGLFrame(OpenGLFrame):
         glBufferData(GL_ARRAY_BUFFER, 4 * 4, np.array([0,0,0,0], np.float32), GL_STATIC_DRAW)
 
         # Compile shaders and link programs
-        self.computeBSplineCode = self.computeBSplineCode.format(maxOrder=DrawableSpline.maxOrder)
-        self.computeSurfaceSamplesCode = self.computeSurfaceSamplesCode.format(maxOrder=DrawableSpline.maxOrder)
         try:
             # Must create CurveProgram first, because it checks and potentially resets tessellationEnabled flag.
             self.curveProgram = CurveProgram(self)
-            self.surface3Program = SurfaceProgram(self, 3, "", "", "", "splineColor = uFillColor.rgb;")
-            self.surface4Program = SurfaceProgram(self, 4,
+            self.surface3Program = SurfaceProgram(self, False, 3, "", "", "", "splineColor = uFillColor.rgb;")
+            self.trimmedSurface3Program = SurfaceProgram(self, True, 3, "", "", "", "splineColor = uFillColor.rgb;")
+            self.surface4Program = SurfaceProgram(self, False, 4,
                 """
                     vec4 kVec = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
                     vec3 pVec;
@@ -1073,7 +1223,27 @@ class SplineOpenGLFrame(OpenGLFrame):
                     pVec = abs(fract(uFillColor.xxx + kVec.xyz) * 6.0 - kVec.www);
                     splineColor = uFillColor.z * mix(kVec.xxx, clamp(pVec - kVec.xxx, 0.0, 1.0), splineColor.r);
                 """)
-            self.surface6Program = SurfaceProgram(self, 6, "", "splineColor = vec3(0.0, 0.0, 0.0);",
+            self.trimmedSurface4Program = SurfaceProgram(self, True, 4,
+                """
+                    vec4 kVec = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
+                    vec3 pVec;
+                """, "splineColor = vec3(0.0, 0.0, 0.0);",
+                """
+                    splineColor.r += uBSpline[uB] * vBSpline[vB] * texelFetch(uSplineData, i+3).x;
+                """,
+                # Taken from http://lolengine.net/blog/2013/07/27/rgb-to-hsv-in-glsl
+                # uFillColor is passed in as HSV
+                """
+                    pVec = abs(fract(uFillColor.xxx + kVec.xyz) * 6.0 - kVec.www);
+                    splineColor = uFillColor.z * mix(kVec.xxx, clamp(pVec - kVec.xxx, 0.0, 1.0), splineColor.r);
+                """)
+            self.surface6Program = SurfaceProgram(self, False, 6, "", "splineColor = vec3(0.0, 0.0, 0.0);",
+                """
+                    splineColor.r += uBSpline[uB] * vBSpline[vB] * texelFetch(uSplineData, i+3).x;
+                    splineColor.g += uBSpline[uB] * vBSpline[vB] * texelFetch(uSplineData, i+4).x;
+                    splineColor.b += uBSpline[uB] * vBSpline[vB] * texelFetch(uSplineData, i+5).x;
+                """, "")
+            self.trimmedSurface6Program = SurfaceProgram(self, True, 6, "", "splineColor = vec3(0.0, 0.0, 0.0);",
                 """
                     splineColor.r += uBSpline[uB] * vBSpline[vB] * texelFetch(uSplineData, i+3).x;
                     splineColor.g += uBSpline[uB] * vBSpline[vB] * texelFetch(uSplineData, i+4).x;
@@ -1089,6 +1259,7 @@ class SplineOpenGLFrame(OpenGLFrame):
             print(badLine)
             quit()
 
+        # Set default draw parameters.
         glUseProgram(0)
         glEnable( GL_DEPTH_TEST )
         glClearColor(self.backgroundColor[0], self.backgroundColor[1], self.backgroundColor[2], self.backgroundColor[3])
@@ -1106,7 +1277,7 @@ class SplineOpenGLFrame(OpenGLFrame):
         defaultAnchorDistance = np.linalg.norm(self.defaultEye - self.defaultCenter)
         clipDistance = defaultAnchorDistance / np.sqrt(3.0)
         near = 0.01 * defaultAnchorDistance / 3.0
-        far = defaultAnchorDistance + clipDistance
+        far = 3.0 * defaultAnchorDistance
         top = clipDistance * near / defaultAnchorDistance # Choose frustum that displays [-clipDistance,clipDistance] in y for z = -defaultAnchorDistance
         glFrustum(-top*xExtent, top*xExtent, -top, top, near, far)
         #glOrtho(-xExtent, xExtent, -1.0, 1.0, -1.0, 1.0)
@@ -1117,8 +1288,11 @@ class SplineOpenGLFrame(OpenGLFrame):
 
         self.curveProgram.ResetBounds(self)
         self.surface3Program.ResetBounds(self)
+        self.trimmedSurface3Program.ResetBounds(self)
         self.surface4Program.ResetBounds(self)
+        self.trimmedSurface4Program.ResetBounds(self)
         self.surface6Program.ResetBounds(self)
+        self.trimmedSurface6Program.ResetBounds(self)
 
         glUseProgram(0)
         glMatrixMode(GL_MODELVIEW)
@@ -1290,6 +1464,488 @@ class SplineOpenGLFrame(OpenGLFrame):
         self.eye = self.anchorPosition + self.anchorDistance * self.look
         self.Update()
 
+    @staticmethod
+    def make_drawable(spline):
+        """
+        Ensure a `Spline` can be drawn in a `SplineOpenGLFrame`. Converts 1D splines into 3D drawable curves, 
+        2D splines into drawable surfaces (y-axis hold amplitude), and 3D splines into drawable solids.
+
+        Spline surfaces and solids with more than 3 dependent variables will have their added dimensions rendered 
+        as colors (up to 6 dependent variables are supported).
+        """
+        if not(isinstance(spline, Spline)): raise ValueError("Invalid spline")
+        if spline.nInd > 3: raise ValueError("Spline must have no more than 3 independent variables")
+        if spline.nDep > 6: raise ValueError("Spline must have no more than 6 dependent variables")
+
+        if not hasattr(spline, "cache"):
+            spline.cache = {}
+        
+        if not "knots32" in spline.cache:
+            knotList = [knots.astype(np.float32, copy=False) for knots in spline.knots]
+            spline.cache["knots32"] = knotList  # Shaders expect float32 knots
+
+        if not "coefs32" in spline.cache:
+            nDep = 3
+            if spline.nInd >= 2 and spline.nDep > 3:
+                nDep = 4 if spline.nDep == 4 else 6 # No nDep of 5
+            
+            coefs = np.zeros((nDep, *spline.nCoef), np.float32)
+            if spline.nInd == 1:
+                if spline.nDep == 1:
+                    graph = spline.graph()
+                    coefs[0] = graph.coefs[0]
+                    coefs[1] = graph.coefs[1]
+                else:
+                    coefs[:min(spline.nDep, 3)] = spline.coefs[:min(spline.nDep, 3)]
+            elif spline.nInd == 2:
+                if spline.nDep == 1:
+                    graph = spline.graph()
+                    coefs[0] = graph.coefs[0]
+                    coefs[1] = graph.coefs[2]
+                    coefs[2] = graph.coefs[1]
+                else:
+                    coefs[:spline.nDep] = spline.coefs
+                    # For dimensions above three, rescale dependent variables to [0, 1].
+                    for i in range(3, spline.nDep):
+                        minCoef = coefs[i].min()
+                        rangeCoef = coefs[i].max() - minCoef
+                        if rangeCoef > 1.0e-8:
+                            coefs[i] = (coefs[i] - minCoef) / rangeCoef
+                        else:
+                            coefs[i] = max(0.0, min(1.0, minCoef))
+            elif spline.nInd == 3:
+                if spline.nDep == 1:
+                    graph = spline.graph()
+                    coefs[0] = graph.coefs[0]
+                    coefs[1] = graph.coefs[3]
+                    coefs[2] = graph.coefs[1]
+                    coefs[3] = graph.coefs[2]
+                else:
+                    coefs[:spline.nDep] = spline.coefs
+                    # For dimensions above three, rescale dependent variables to [0, 1].
+                    for i in range(3, spline.nDep):
+                        minCoef = coefs[i].min()
+                        rangeCoef = coefs[i].max() - minCoef
+                        if rangeCoef > 1.0e-8:
+                            coefs[i] = (coefs[i] - minCoef) / rangeCoef
+                        else:
+                            coefs[i] = max(0.0, min(1.0, minCoef))
+            else:
+                raise ValueError("Can't convert to drawable spline.")
+        
+            spline.cache["coefs32"] = coefs.T # Shaders expect transpose of float32 coefs
+    
+        if not "fillColor" in spline.metadata:
+            spline.metadata["fillColor"] = np.array((0.0, 1.0, 0.0, 1.0), np.float32)
+        if not "lineColor" in spline.metadata:
+            spline.metadata["lineColor"] = np.array((0.0, 0.0, 0.0, 1.0) if spline.nInd > 1 else (1.0, 1.0, 1.0, 1.0), np.float32)
+        if not "options" in spline.metadata:
+            spline.metadata["options"] = SplineOpenGLFrame.SHADED | SplineOpenGLFrame.BOUNDARY
+        if not "animate" in spline.metadata:
+            spline.metadata["animate"] = None
+
+    @staticmethod
+    def tessellate2DSolid(solid):
+        """
+        Returns an array of triangles that tessellate the given 2D solid
+        """
+        assert solid.dimension == 2
+        assert solid.containsInfinity == False
+
+        # First, collect all manifold contour endpoints, accounting for slight numerical error.
+        class Endpoint:
+            def __init__(self, curve, t, clockwise, isStart, otherEnd=None):
+                self.curve = curve
+                self.t = t
+                self.xy = curve.manifold.evaluate((t,))
+                self.clockwise = clockwise
+                self.isStart = isStart
+                self.otherEnd = otherEnd
+                self.connection = None
+        endpoints = []
+        for curve in solid.boundaries:
+            curve.domain.boundaries.sort(key=lambda boundary: (boundary.manifold.evaluate(0.0), -boundary.manifold.normal(0.0)))
+            leftB = 0
+            rightB = 0
+            boundaryCount = len(curve.domain.boundaries)
+            while leftB < boundaryCount:
+                if curve.domain.boundaries[leftB].manifold.normal(0.0) < 0.0:
+                    leftPoint = curve.domain.boundaries[leftB].manifold.evaluate(0.0)[0]
+                    while rightB < boundaryCount:
+                        rightPoint = curve.domain.boundaries[rightB].manifold.evaluate(0.0)[0]
+                        if leftPoint - Manifold.minSeparation < rightPoint and curve.domain.boundaries[rightB].manifold.normal(0.0) > 0.0:
+                            t = curve.manifold.tangent_space(leftPoint)[:,0]
+                            n = curve.manifold.normal(leftPoint)
+                            clockwise = t[0] * n[1] - t[1] * n[0] > 0.0
+                            ep1 = Endpoint(curve, leftPoint, clockwise, rightPoint >= leftPoint)
+                            ep2 = Endpoint(curve, rightPoint, clockwise, rightPoint < leftPoint, ep1)
+                            ep1.otherEnd = ep2
+                            endpoints.append(ep1)
+                            endpoints.append(ep2)
+                            leftB = rightB
+                            rightB += 1
+                            break
+                        rightB += 1
+                leftB += 1
+
+        # Second, collect all valid pairings of endpoints (normal not flipped between segments).
+        Connection = namedtuple('Connection', ('distance', 'ep1', 'ep2'))
+        connections = []
+        for i, ep1 in enumerate(endpoints[:-1]):
+            for ep2 in endpoints[i+1:]:
+                if (ep1.clockwise == ep2.clockwise and ep1.isStart != ep2.isStart) or \
+                    (ep1.clockwise != ep2.clockwise and ep1.isStart == ep2.isStart):
+                    connections.append(Connection(np.linalg.norm(ep1.xy - ep2.xy), ep1, ep2))
+
+        # Third, only keep closest pairings (prune the rest).
+        connections.sort(key=lambda connection: -connection.distance)
+        while connections:
+            connection = connections.pop()
+            connection.ep1.connection = connection.ep2
+            connection.ep2.connection = connection.ep1
+            connections = [c for c in connections if c.ep1 is not connection.ep1 and c.ep1 is not connection.ep2 and \
+                    c.ep2 is not connection.ep1 and c.ep2 is not connection.ep2]
+            
+        # Fourth, set up GLUT to tesselate the solid.
+        tess = gluNewTess()
+        gluTessProperty(tess, GLU_TESS_WINDING_RULE, GLU_TESS_WINDING_ODD)
+        vertices = []
+        def beginCallback(type=None):
+            vertices = []
+        def edgeFlagDataCallback(flag, polygonData):
+            pass # Forces triangulation of polygons rather than triangle fans or strips
+        def vertexCallback(vertex, otherData=None):
+            vertices.append(vertex[:2])
+        def combineCallback(vertex, neighbors, neighborWeights, outData=None):
+            outData = vertex
+            return outData
+        def endCallback():
+            pass
+        gluTessCallback(tess, GLU_TESS_BEGIN, beginCallback)
+        gluTessCallback(tess, GLU_TESS_EDGE_FLAG_DATA, edgeFlagDataCallback)
+        gluTessCallback(tess, GLU_TESS_VERTEX, vertexCallback)
+        gluTessCallback(tess, GLU_TESS_COMBINE, combineCallback)
+        gluTessCallback(tess, GLU_TESS_END, endCallback)
+
+        # Fifth, trace the contours from pairing to pairing, using GLUT to tesselate the interior.
+        gluTessBeginPolygon(tess, 0)
+        while endpoints:
+            start = endpoints[0]
+            if not start.isStart:
+                start = start.otherEnd
+            # Run backwards until you hit start again or hit an end.
+            if start.connection is not None:
+                originalStart = start
+                next = start.connection
+                start = None
+                while next is not None and start is not originalStart:
+                    start = next.otherEnd
+                    next = start.connection
+            # Run forwards submitting vertices for the contour.
+            next = start
+            gluTessBeginContour(tess)
+            while next is not None:
+                endpoints.remove(next)
+                endpoints.remove(next.otherEnd)
+                subdivisions = max(int(abs(next.otherEnd.t - next.t) / 0.1), 20) if isinstance(next.curve.manifold, Spline) else 2
+                for t in np.linspace(next.t, next.otherEnd.t, subdivisions):
+                    xy = next.curve.manifold.evaluate((t,))
+                    vertex = (*xy, 0.0)
+                    gluTessVertex(tess, vertex, vertex)
+                next = next.otherEnd.connection
+                if next is start:
+                    break
+            gluTessEndContour(tess)
+        gluTessEndPolygon(tess)
+        gluDeleteTess(tess)
+        return np.array(vertices, np.float32)
+
+    def _DrawPoints(self, spline, drawCoefficients):
+        """
+        Draw spline points for an nInd == 0 or order == 1 spline within a `SplineOpenGLFrame`. The self will call this method for you.
+        """
+        glColor4fv(spline.metadata["lineColor"])
+        glBegin(GL_POINTS)
+        if spline.nInd == 0:
+            glVertex3fv(drawCoefficients)
+        else:
+            for point in drawCoefficients:
+                glVertex3fv(point)
+        glEnd()
+
+    def _DrawCurve(self, spline, drawCoefficients):
+        """
+        Draw a spline curve (nInd == 1) within a `SplineOpenGLFrame`. The self will call this method for you.
+        """
+        if spline.metadata["options"] & self.HULL:
+            glColor3f(0.0, 0.0, 1.0)
+            glBegin(GL_LINE_STRIP)
+            for point in drawCoefficients:
+                glVertex3f(point[0], point[1], point[2])
+            glEnd()
+
+        program = self.curveProgram
+        glUseProgram(program.curveProgram)
+        glUniform4fv(program.uCurveLineColor, 1, spline.metadata["lineColor"])
+        glBindBuffer(GL_TEXTURE_BUFFER, self.splineDataBuffer)
+        offset = 0
+        size = 4 * 2
+        glBufferSubData(GL_TEXTURE_BUFFER, offset, size, np.array((spline.order[0], spline.nCoef[0]), np.float32))
+        offset += size
+        knots = spline.cache["knots32"]
+        size = 4 * len(knots[0])
+        glBufferSubData(GL_TEXTURE_BUFFER, offset, size, knots[0])
+        offset += size
+        size = 3 * 4 * spline.nCoef[0]
+        drawCoefficients = drawCoefficients[..., :3]
+        glBufferSubData(GL_TEXTURE_BUFFER, offset, size, drawCoefficients)
+        glEnableVertexAttribArray(program.aCurveParameters)
+        if self.tessellationEnabled:
+            glPatchParameteri(GL_PATCH_VERTICES, 1)
+            glDrawArraysInstanced(GL_PATCHES, 0, 1, spline.nCoef[0] - spline.order[0] + 1)
+        else:
+            glDrawArraysInstanced(GL_POINTS, 0, 1, spline.nCoef[0] - spline.order[0] + 1)
+            glFlush() # Old graphics card
+        glDisableVertexAttribArray(program.aCurveParameters)
+        glUseProgram(0)
+
+    @staticmethod
+    def ConvertRGBToHSV(r, g, b, a):
+        # Taken from http://lolengine.net/blog/2013/07/27/rgb-to-hsv-in-glsl
+        K = 0.0
+        if g < b:
+            tmp = g
+            g = b
+            b = tmp
+            K = -1.0
+        if r < g:
+            tmp = r
+            r = g
+            g = tmp
+            K = -2.0 / 6.0 - K
+        chroma = r - min(g, b)
+        return np.array((abs(K + (g - b) / (6.0 * chroma + 1e-20)), chroma / (r + 1e-20), r, a), np.float32)
+    
+    def _DrawSurface(self, spline, drawCoefficients):
+        """
+        Draw a spline surface (nInd == 2) within a `SplineOpenGLFrame`.
+        """
+        if spline.metadata["options"] & self.HULL:
+            glColor3f(0.0, 0.0, 1.0)
+            for pointList in drawCoefficients:
+                glBegin(GL_LINE_STRIP)
+                for point in pointList:
+                    glVertex3f(point[0], point[1], point[2])
+                glEnd()
+
+        fillColor = spline.metadata["fillColor"]
+        if spline.nDep <= 3:
+            nDep = 3
+            program = self.trimmedSurface3Program if "trim" in spline.cache else self.surface3Program
+        elif spline.nDep == 4:
+            nDep = 4
+            program = self.trimmedSurface4Program if "trim" in spline.cache else self.surface4Program
+            program = self.surface4Program
+            fillColor = self.ConvertRGBToHSV(fillColor[0], fillColor[1], fillColor[2], fillColor[3])
+        elif spline.nDep <= 6:
+            nDep = 6
+            program = self.trimmedSurface6Program if "trim" in spline.cache else self.surface6Program
+        else:
+            raise ValueError("Can't draw surface.")
+        
+        useBlending = fillColor[3] < 1.0
+        if useBlending:
+            glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
+            glEnable( GL_BLEND )
+            glDisable( GL_DEPTH_TEST )
+
+        glUseProgram(program.surfaceProgram)
+        glUniform4fv(program.uSurfaceFillColor, 1, fillColor)
+        glUniform4fv(program.uSurfaceLineColor, 1, spline.metadata["lineColor"])
+        glUniform1i(program.uSurfaceOptions, spline.metadata["options"])
+        glBindBuffer(GL_TEXTURE_BUFFER, self.splineDataBuffer)
+        offset = 0
+        size = 4 * 4
+        glBufferSubData(GL_TEXTURE_BUFFER, offset, size, np.array((spline.order[0], spline.order[1], spline.nCoef[0], spline.nCoef[1]), np.float32))
+        offset += size
+        knots = spline.cache["knots32"]
+        size = 4 * len(knots[0])
+        glBufferSubData(GL_TEXTURE_BUFFER, offset, size, knots[0])
+        offset += size
+        size = 4 * len(knots[1])
+        glBufferSubData(GL_TEXTURE_BUFFER, offset, size, knots[1])
+        offset += size
+        size = nDep * 4 * spline.nCoef[0] * spline.nCoef[1]
+        glBufferSubData(GL_TEXTURE_BUFFER, offset, size, drawCoefficients)
+        glEnableVertexAttribArray(program.aSurfaceParameters)
+        if self.tessellationEnabled:
+            glPatchParameteri(GL_PATCH_VERTICES, 1)
+            glDrawArraysInstanced(GL_PATCHES, 0, 1, (spline.nCoef[0] - spline.order[0] + 1) * (spline.nCoef[1] - spline.order[1] + 1))
+        else:
+            glDrawArraysInstanced(GL_POINTS, 0, 1, (spline.nCoef[0] - spline.order[0] + 1) * (spline.nCoef[1] - spline.order[1] + 1))
+            glFlush() # Old graphics card
+        glDisableVertexAttribArray(program.aSurfaceParameters)
+        glUseProgram(0)
+        if useBlending:
+            glDisable( GL_BLEND )
+            glEnable( GL_DEPTH_TEST )
+    
+    def _DrawSolid(self, spline, drawCoefficients):
+        """
+        Draw a spline solid (nInd == 3) within a `SplineOpenGLFrame`.
+        """
+        if spline.metadata["options"] & self.HULL:
+            glColor3f(0.0, 0.0, 1.0)
+            for pointSet in drawCoefficients:
+                for pointList in pointSet:
+                    glBegin(GL_LINE_STRIP)
+                    for point in pointList:
+                        glVertex3f(point[0], point[1], point[2])
+                    glEnd()
+
+        fillColor = spline.metadata["fillColor"].copy()
+        lineColor = spline.metadata["lineColor"].copy()
+        if spline.nDep <= 3:
+            nDep = 3
+            program = self.trimmedSurface3Program if "trim" in spline.cache else self.surface3Program
+        elif spline.nDep == 4:
+            nDep = 4
+            program = self.trimmedSurface4Program if "trim" in spline.cache else self.surface4Program
+            program = self.surface4Program
+            fillColor = self.ConvertRGBToHSV(fillColor[0], fillColor[1], fillColor[2], fillColor[3])
+        elif spline.nDep <= 6:
+            nDep = 6
+            program = self.trimmedSurface6Program if "trim" in spline.cache else self.surface6Program
+        else:
+            raise ValueError("Can't draw surface.")
+        fillColor[3] *= 0.5
+        lineColor[3] *= 0.5
+        knots = spline.cache["knots32"]
+
+        def _DrawBoundarySurface(axis, index):
+            fullSlice = slice(None)
+            if axis == 0:
+                i1 = 1
+                i2 = 2
+                coefSlice = (fullSlice, fullSlice, index, fullSlice)
+            elif axis == 1:
+                i1 = 0
+                i2 = 2
+                coefSlice = (fullSlice, index, fullSlice, fullSlice)
+            else:
+                i1 = 0
+                i2 = 1
+                coefSlice = (index, fullSlice, fullSlice, fullSlice)
+
+            glBindBuffer(GL_TEXTURE_BUFFER, self.splineDataBuffer)
+            offset = 0
+            size = 4 * 4
+            glBufferSubData(GL_TEXTURE_BUFFER, offset, size, np.array((spline.order[i1], spline.order[i2], spline.nCoef[i1], spline.nCoef[i2]), np.float32))
+            offset += size
+            size = 4 * len(knots[i1])
+            glBufferSubData(GL_TEXTURE_BUFFER, offset, size, knots[i1])
+            offset += size
+            size = 4 * len(knots[i2])
+            glBufferSubData(GL_TEXTURE_BUFFER, offset, size, knots[i2])
+            offset += size
+            size = nDep * 4 * spline.nCoef[i1] * spline.nCoef[i2]
+            glBufferSubData(GL_TEXTURE_BUFFER, offset, size, drawCoefficients[coefSlice])
+            glEnableVertexAttribArray(program.aSurfaceParameters)
+            if self.tessellationEnabled:
+                glPatchParameteri(GL_PATCH_VERTICES, 1)
+                glDrawArraysInstanced(GL_PATCHES, 0, 1, (spline.nCoef[i1] - spline.order[i1] + 1) * (spline.nCoef[i2] - spline.order[i2] + 1))
+            else:
+                glDrawArraysInstanced(GL_POINTS, 0, 1, (spline.nCoef[i1] - spline.order[i1] + 1) * (spline.nCoef[i2] - spline.order[i2] + 1))
+                glFlush() # Old graphics card
+            glDisableVertexAttribArray(program.aSurfaceParameters)
+
+        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
+        glEnable( GL_BLEND )
+        glDisable( GL_DEPTH_TEST )
+        glUseProgram(program.surfaceProgram)
+        glUniform4fv(program.uSurfaceFillColor, 1, fillColor)
+        glUniform4fv(program.uSurfaceLineColor, 1, lineColor)
+        glUniform1i(program.uSurfaceOptions, spline.metadata["options"])
+
+        _DrawBoundarySurface(0, 0)
+        _DrawBoundarySurface(0, -1)
+        _DrawBoundarySurface(1, 0)
+        _DrawBoundarySurface(1, -1)
+        _DrawBoundarySurface(2, 0)
+        _DrawBoundarySurface(2, -1)
+
+        glUseProgram(0)
+        glDisable( GL_BLEND )
+        glEnable( GL_DEPTH_TEST )
+
+    def DrawSpline(self, spline, transform):
+        """
+        Draw a spline within a `SplineOpenGLFrame`.
+        """
+        # Fill trim stencil.
+        if "trim" in spline.cache:
+            # Draw trim tessellation into trim texture framebuffer.
+            glBindFramebuffer(GL_FRAMEBUFFER, self.frameBuffer)
+            glDisable(GL_DEPTH_TEST)
+            glViewport(0,0,512,512)
+            glClearColor(0.0, 0.0, 0.0, 1.0)
+            glClear(GL_COLOR_BUFFER_BIT)
+            glMatrixMode(GL_PROJECTION)
+            glLoadIdentity()
+            bounds = spline.domain()
+            glOrtho(bounds[0, 0], bounds[0, 1], bounds[1, 0], bounds[1, 1], -1.0, 1.0)
+            glColor3f(1.0, 0.0, 0.0)
+            glBegin(GL_TRIANGLES)
+            for vertex in spline.cache["trim"]:
+                glVertex2fv(vertex)
+            glEnd()
+            glFlush()
+            # Reset view for main framebuffer.
+            glBindFramebuffer(GL_FRAMEBUFFER, 0)
+            glEnable(GL_DEPTH_TEST)
+            glViewport(0, 0, self.width, self.height)
+            glClearColor(self.backgroundColor[0], self.backgroundColor[1], self.backgroundColor[2], self.backgroundColor[3])
+            glMatrixMode(GL_PROJECTION)
+            glLoadMatrixf(self.projection)
+            glMatrixMode(GL_MODELVIEW)
+
+        # Retrieve transposed float32 coefficients.
+        coefs = spline.cache["coefs32"]
+
+        # Contract spline if it's animating.
+        nInd = spline.metadata["animate"]
+        if nInd is not None:
+            # Contraction value is set to cycle every 10 seconds (10000 ms).
+            u1 = spline.knots[nInd][spline.order[nInd] - 1]
+            u2 = spline.knots[nInd][spline.nCoef[nInd]]
+            u = u1 + 0.49999 * (u2 - u1) * (1.0 - np.cos(2.0 * np.pi * self.frameCount * self.MsPerFrame / 10000))
+            # Contract spline.
+            knots = spline.cache["knots32"]
+            ix, bValues = spline.bspline_values(None, knots[nInd], spline.order[nInd], u)
+            coefs = np.moveaxis(coefs, spline.nInd - nInd - 1, -1) # Account for transpose
+            coefs = coefs[..., ix - spline.order[nInd]:ix] @ bValues
+            knots = [knots[i] for i in range(spline.nInd) if i != nInd]
+            spline = type(spline)(spline.nInd - 1, coefs.shape[-1], 
+                [spline.order[i] for i in range(spline.nInd) if i != nInd],
+                [spline.nCoef[i] for i in range(spline.nInd) if i != nInd],
+                knots, coefs.T, spline.metadata)
+            spline.cache = {"knots32": knots, "coefs32": coefs}
+
+        # Transform coefs by view transform.
+        drawCoefficients = np.empty(coefs.shape, np.float32)
+        drawCoefficients[..., :3] = coefs[..., :3] @ transform[:3,:3] + transform[3,:3]
+        drawCoefficients[..., 3:] = coefs[..., 3:]
+
+        # Draw spline.
+        if spline.nInd == 0 or spline.order[0] == 1:
+            self._DrawPoints(spline, drawCoefficients)
+        elif spline.nInd == 1:
+            self._DrawCurve(spline, drawCoefficients)
+        elif spline.nInd == 2:
+            self._DrawSurface(spline, drawCoefficients)
+        elif spline.nInd == 3:
+            self._DrawSolid(spline, drawCoefficients)
+
 class CurveProgram:
     """ Compile curve program """
     def __init__(self, frame):
@@ -1306,7 +1962,7 @@ class CurveProgram:
                 curveTCShader, 
                 shaders.compileShader(frame.curveTEShaderCode.format(
                     computeBSplineCode=frame.computeBSplineCode,
-                    maxOrder=DrawableSpline.maxOrder), GL_TESS_EVALUATION_SHADER), 
+                    maxOrder=frame.maxOrder), GL_TESS_EVALUATION_SHADER), 
                 shaders.compileShader(frame.curveFragmentShaderCode, GL_FRAGMENT_SHADER))
         else:
             self.curveProgram = shaders.compileProgram(
@@ -1315,7 +1971,7 @@ class CurveProgram:
                     computeSampleRateCode=frame.computeSampleRateCode,
                     computeCurveSamplesCode=frame.computeCurveSamplesCode,
                     computeBSplineCode=frame.computeBSplineCode,
-                    maxOrder=DrawableSpline.maxOrder), GL_GEOMETRY_SHADER), 
+                    maxOrder=frame.maxOrder), GL_GEOMETRY_SHADER), 
                 shaders.compileShader(frame.curveFragmentShaderCode, GL_FRAGMENT_SHADER))
 
         glUseProgram(self.curveProgram)
@@ -1338,8 +1994,12 @@ class CurveProgram:
 
 class SurfaceProgram:
     """ Compile surface program """
-    def __init__(self, frame, nDep, splineColorDeclarations, initializeSplineColor, computeSplineColor, postProcessSplineColor):
+    def __init__(self, frame, trimmed, nDep, splineColorDeclarations, initializeSplineColor, computeSplineColor, postProcessSplineColor):
         if frame.tessellationEnabled:
+            if trimmed:
+                compiledFragmentShader = shaders.compileShader(frame.trimmedSurfaceFragmentShaderCode, GL_FRAGMENT_SHADER)
+            else:
+                compiledFragmentShader = shaders.compileShader(frame.surfaceFragmentShaderCode, GL_FRAGMENT_SHADER)
             self.surfaceProgram = shaders.compileProgram(
                 shaders.compileShader(frame.surfaceVertexShaderCode, GL_VERTEX_SHADER), 
                 shaders.compileShader(frame.surfaceTCShaderCode.format(
@@ -1353,8 +2013,8 @@ class SurfaceProgram:
                     initializeSplineColor=initializeSplineColor,
                     computeSplineColor=computeSplineColor,
                     postProcessSplineColor=postProcessSplineColor,
-                    maxOrder=DrawableSpline.maxOrder), GL_TESS_EVALUATION_SHADER), 
-                shaders.compileShader(frame.surfaceFragmentShaderCode, GL_FRAGMENT_SHADER),
+                    maxOrder=frame.maxOrder), GL_TESS_EVALUATION_SHADER), 
+                compiledFragmentShader,
                 validate = False)
         else:
             self.surfaceProgram = shaders.compileProgram(
@@ -1368,9 +2028,10 @@ class SurfaceProgram:
                     initializeSplineColor=initializeSplineColor,
                     computeSplineColor=computeSplineColor,
                     postProcessSplineColor=postProcessSplineColor,
-                    maxOrder=DrawableSpline.maxOrder), GL_GEOMETRY_SHADER), 
+                    maxOrder=frame.maxOrder), GL_GEOMETRY_SHADER), 
                 shaders.compileShader(frame.surfaceSimpleFragmentShaderCode, GL_FRAGMENT_SHADER))
 
+        # Initialize program parameters.
         glUseProgram(self.surfaceProgram)
         self.aSurfaceParameters = glGetAttribLocation(self.surfaceProgram, "aParameters")
         glBindBuffer(GL_ARRAY_BUFFER, frame.parameterBuffer)
@@ -1384,7 +2045,10 @@ class SurfaceProgram:
         self.uSurfaceOptions = glGetUniformLocation(self.surfaceProgram, 'uOptions')
         self.uSurfaceSplineData = glGetUniformLocation(self.surfaceProgram, 'uSplineData')
         glUniform1i(self.uSurfaceSplineData, 0) # GL_TEXTURE0 is the spline buffer texture
-    
+        if trimmed and frame.tessellationEnabled:
+            self.uTrimTextureMap = glGetUniformLocation(self.surfaceProgram, 'uTrimTextureMap')
+            glUniform1i(self.uTrimTextureMap, 1) # GL_TEXTURE1 is the trim texture map
+
     def ResetBounds(self, frame):
         """Reset bounds and other frame configuration for surface program"""
         glUseProgram(self.surfaceProgram)