vispy 0.15.0__cp313-cp313-macosx_11_0_arm64.whl

vispy/geometry/isocurve.py

@@ -0,0 +1,175 @@
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+# Copyright (c) Vispy Development Team. All Rights Reserved.
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+# -----------------------------------------------------------------------------
+
+from __future__ import division
+
+import numpy as np
+
+
+def isocurve(data, level, connected=False, extend_to_edge=False):
+    """
+    Generate isocurve from 2D data using marching squares algorithm.
+
+    Parameters
+    ----------
+    data : ndarray
+        2D numpy array of scalar values
+    level : float
+        The level at which to generate an isosurface
+    connected : bool
+        If False, return a single long list of point pairs
+        If True, return multiple long lists of connected point 
+        locations. (This is slower but better for drawing 
+        continuous lines)
+    extend_to_edge : bool
+        If True, extend the curves to reach the exact edges of 
+        the data. 
+    """    
+    # This function is SLOW; plenty of room for optimization here.
+
+    if extend_to_edge:
+        d2 = np.empty((data.shape[0]+2, data.shape[1]+2), dtype=data.dtype)
+        d2[1:-1, 1:-1] = data
+        d2[0, 1:-1] = data[0]
+        d2[-1, 1:-1] = data[-1]
+        d2[1:-1, 0] = data[:, 0]
+        d2[1:-1, -1] = data[:, -1]
+        d2[0, 0] = d2[0, 1]
+        d2[0, -1] = d2[1, -1]
+        d2[-1, 0] = d2[-1, 1]
+        d2[-1, -1] = d2[-1, -2]
+        data = d2
+
+    side_table = [
+        [],
+        [0, 1],
+        [1, 2],
+        [0, 2],
+        [0, 3],
+        [1, 3],
+        [0, 1, 2, 3],
+        [2, 3],
+        [2, 3],
+        [0, 1, 2, 3],
+        [1, 3],
+        [0, 3],
+        [0, 2],
+        [1, 2],
+        [0, 1],
+        []
+    ]
+
+    edge_key = [
+        [(0, 1), (0, 0)],
+        [(0, 0), (1, 0)],
+        [(1, 0), (1, 1)],
+        [(1, 1), (0, 1)]
+    ]
+
+    level = float(level)
+    lines = []
+
+    # mark everything below the isosurface level
+    mask = data < level
+
+    # make four sub-fields and compute indexes for grid cells
+    index = np.zeros([x-1 for x in data.shape], dtype=np.ubyte)
+    fields = np.empty((2, 2), dtype=object)
+    slices = [slice(0, -1), slice(1, None)]
+    for i in [0, 1]:
+        for j in [0, 1]:
+            fields[i, j] = mask[slices[i], slices[j]]
+            vertIndex = i+2*j
+            index += (fields[i, j] * 2**vertIndex).astype(np.ubyte)
+
+    # add lines
+    for i in range(index.shape[0]):                 # data x-axis
+        for j in range(index.shape[1]):             # data y-axis     
+            sides = side_table[index[i, j]]
+            for side_idx in range(0, len(sides), 2):  # faces for this grid cell
+                edges = sides[side_idx:side_idx+2]
+                pts = []
+                for m in [0, 1]:      # points in this face
+                    # p1, p2 are points at either side of an edge
+                    p1 = edge_key[edges[m]][0] 
+                    p2 = edge_key[edges[m]][1]
+                    # v1 and v2 are the values at p1 and p2
+                    v1 = data[i+p1[0], j+p1[1]] 
+                    v2 = data[i+p2[0], j+p2[1]]
+                    f = (level-v1) / (v2-v1)
+                    fi = 1.0 - f
+                    # interpolate between corners
+                    p = (p1[0]*fi + p2[0]*f + i + 0.5, 
+                         p1[1]*fi + p2[1]*f + j + 0.5)
+                    if extend_to_edge:
+                        # check bounds
+                        p = (min(data.shape[0]-2, max(0, p[0]-1)),
+                             min(data.shape[1]-2, max(0, p[1]-1)))
+                    if connected:
+                        gridKey = (i + (1 if edges[m] == 2 else 0), 
+                                   j + (1 if edges[m] == 3 else 0), 
+                                   edges[m] % 2)
+                        # give the actual position and a key identifying the 
+                        # grid location (for connecting segments)
+                        pts.append((p, gridKey))
+                    else:
+                        pts.append(p)
+
+                lines.append(pts)
+
+    if not connected:
+        return lines
+
+    # turn disjoint list of segments into continuous lines
+
+    points = {}  # maps each point to its connections
+    for a, b in lines:
+        if a[1] not in points:
+            points[a[1]] = []
+        points[a[1]].append([a, b])
+        if b[1] not in points:
+            points[b[1]] = []
+        points[b[1]].append([b, a])
+
+    # rearrange into chains
+    for k in list(points.keys()):
+        try:
+            chains = points[k]
+        except KeyError:  # already used this point elsewhere
+            continue
+        for chain in chains:
+            x = None
+            while True:
+                if x == chain[-1][1]:
+                    break  # nothing left to do on this chain
+
+                x = chain[-1][1]
+                if x == k:
+                    # chain has looped; we're done and can ignore the opposite
+                    # chain
+                    break
+                y = chain[-2][1]
+                connects = points[x]
+                for conn in connects[:]:
+                    if conn[1][1] != y:
+                        chain.extend(conn[1:])
+                del points[x]
+            if chain[0][1] == chain[-1][1]:
+                # looped chain; no need to continue the other direction
+                chains.pop()
+                break
+
+    # extract point locations 
+    lines = []
+    for chain in points.values():
+        if len(chain) == 2:
+            # join together ends of chain
+            chain = chain[1][1:][::-1] + chain[0]
+        else:
+            chain = chain[0]
+        lines.append([pt[0] for pt in chain])
+
+    return lines  # a list of pairs of points

vispy/geometry/isosurface.py

@@ -0,0 +1,465 @@
+import numpy as np
+
+_data_cache = None
+
+
+def isosurface(data, level):
+    """
+    Generate isosurface from volumetric data using marching cubes algorithm.
+    See Paul Bourke, "Polygonising a Scalar Field"  
+    (http://paulbourke.net/geometry/polygonise/)
+
+    *data*   3D numpy array of scalar values
+    *level*  The level at which to generate an isosurface
+
+    Returns an array of vertex coordinates (Nv, 3) and an array of 
+    per-face vertex indexes (Nf, 3)    
+    """
+    # For improvement, see:
+    # 
+    # Efficient implementation of Marching Cubes' cases with topological 
+    # guarantees.
+    # Thomas Lewiner, Helio Lopes, Antonio Wilson Vieira and Geovan Tavares.
+    # Journal of Graphics Tools 8(2): pp. 1-15 (december 2003)
+
+    (face_shift_tables, edge_shifts, 
+     edge_table, n_table_faces) = _get_data_cache()
+
+    # mark everything below the isosurface level
+    mask = data < level
+
+    # Because we make use of the strides data attribute below, we have to make 
+    # sure that the data is contiguous (which it won't be if the user did 
+    # data.transpose() for example). Note that this doesn't copy the data if it 
+    # is already contiguous.
+    data = np.ascontiguousarray(data)
+
+    # make eight sub-fields and compute indexes for grid cells
+    index = np.zeros([x-1 for x in data.shape], dtype=np.ubyte)
+    fields = np.empty((2, 2, 2), dtype=object)
+    slices = [slice(0, -1), slice(1, None)]
+    for i in [0, 1]:
+        for j in [0, 1]:
+            for k in [0, 1]:
+                fields[i, j, k] = mask[slices[i], slices[j], slices[k]]
+                # this is just to match Bourk's vertex numbering scheme:
+                vertIndex = i - 2*j*i + 3*j + 4*k
+                index += (fields[i, j, k] * 2**vertIndex).astype(np.ubyte)
+
+    # Generate table of edges that have been cut
+    cut_edges = np.zeros([x+1 for x in index.shape]+[3], dtype=np.uint32)
+    edges = edge_table[index]
+    for i, shift in enumerate(edge_shifts[:12]):        
+        slices = [slice(shift[j], cut_edges.shape[j]+(shift[j]-1)) 
+                  for j in range(3)]
+        cut_edges[slices[0], slices[1], slices[2], shift[3]] += edges & 2**i
+
+    # for each cut edge, interpolate to see where exactly the edge is cut and 
+    # generate vertex positions
+    m = cut_edges > 0
+    vertex_inds = np.argwhere(m)  # argwhere is slow!
+    vertexes = vertex_inds[:, :3].astype(np.float32).copy()
+    dataFlat = data.reshape(data.shape[0]*data.shape[1]*data.shape[2])
+
+    # re-use the cut_edges array as a lookup table for vertex IDs
+    cut_edges[vertex_inds[:, 0], 
+              vertex_inds[:, 1], 
+              vertex_inds[:, 2], 
+              vertex_inds[:, 3]] = np.arange(vertex_inds.shape[0])
+
+    for i in [0, 1, 2]:
+        vim = vertex_inds[:, 3] == i
+        vi = vertex_inds[vim, :3]
+        vi_flat = (vi * (np.array(data.strides[:3]) // 
+                         data.itemsize)[np.newaxis, :]).sum(axis=1)
+        v1 = dataFlat[vi_flat]
+        v2 = dataFlat[vi_flat + data.strides[i]//data.itemsize]
+        vertexes[vim, i] += (level-v1) / (v2-v1)
+
+    # compute the set of vertex indexes for each face. 
+
+    # This works, but runs a bit slower.
+    # all cells with at least one face:
+    # cells = np.argwhere((index != 0) & (index != 255))  
+    # cellInds = index[cells[:, 0], cells[:, 1], cells[:, 2]]
+    # verts = faceTable[cellInds]
+    # mask = verts[..., 0, 0] != 9
+    # we now have indexes into cut_edges:
+    # verts[...,:3] += cells[:, np.newaxis, np.newaxis,:]
+    # verts = verts[mask]
+    # and these are the vertex indexes we want:
+    # faces = cut_edges[verts[..., 0], verts[..., 1], verts[..., 2], 
+    #                  verts[..., 3]]  
+
+    # To allow this to be vectorized efficiently, we count the number of faces 
+    # in each grid cell and handle each group of cells with the same number 
+    # together.
+
+    # determine how many faces to assign to each grid cell
+    n_faces = n_table_faces[index]
+    tot_faces = n_faces.sum()
+    faces = np.empty((tot_faces, 3), dtype=np.uint32)
+    ptr = 0
+
+    # this helps speed up an indexing operation later on
+    cs = np.array(cut_edges.strides)//cut_edges.itemsize
+    cut_edges = cut_edges.flatten()
+
+    # this, strangely, does not seem to help.
+    # ins = np.array(index.strides)/index.itemsize
+    # index = index.flatten()
+
+    for i in range(1, 6):
+        # expensive:
+        # all cells which require i faces  (argwhere is expensive)
+        cells = np.argwhere(n_faces == i)  
+        if cells.shape[0] == 0:
+            continue
+        # index values of cells to process for this round:
+        cellInds = index[cells[:, 0], cells[:, 1], cells[:, 2]]
+
+        # expensive:
+        verts = face_shift_tables[i][cellInds]
+        # we now have indexes into cut_edges:
+        verts[..., :3] += (cells[:, np.newaxis,
+                                 np.newaxis, :]).astype(np.uint16)
+        verts = verts.reshape((verts.shape[0]*i,)+verts.shape[2:])
+
+        # expensive:
+        verts = (verts * cs[np.newaxis, np.newaxis, :]).sum(axis=2)
+        vert_inds = cut_edges[verts]
+        nv = vert_inds.shape[0]
+        faces[ptr:ptr+nv] = vert_inds  # .reshape((nv, 3))
+        ptr += nv
+
+    return vertexes, faces
+
+
+def _get_data_cache():
+    # Precompute lookup tables on the first run
+
+    global _data_cache
+
+    if _data_cache is None:
+        # map from grid cell index to edge index.
+        # grid cell index tells us which corners are below the isosurface,
+        # edge index tells us which edges are cut by the isosurface.
+        # (Data stolen from Bourk; see above.)
+        edge_table = np.array([
+            0x0, 0x109, 0x203, 0x30a, 0x406, 0x50f, 0x605, 0x70c, 0x80c, 0x905, 0xa0f, 0xb06, 0xc0a,
+            0xd03, 0xe09, 0xf00, 0x190, 0x99, 0x393, 0x29a, 0x596, 0x49f, 0x795, 0x69c, 0x99c, 0x895, 
+            0xb9f, 0xa96, 0xd9a, 0xc93, 0xf99, 0xe90, 0x230, 0x339, 0x33, 0x13a, 0x636, 0x73f, 0x435, 
+            0x53c, 0xa3c, 0xb35, 0x83f, 0x936, 0xe3a, 0xf33, 0xc39, 0xd30, 0x3a0, 0x2a9, 0x1a3, 0xaa, 
+            0x7a6, 0x6af, 0x5a5, 0x4ac, 0xbac, 0xaa5, 0x9af, 0x8a6, 0xfaa, 0xea3, 0xda9, 0xca0, 0x460, 
+            0x569, 0x663, 0x76a, 0x66, 0x16f, 0x265, 0x36c, 0xc6c, 0xd65, 0xe6f, 0xf66, 0x86a, 0x963, 
+            0xa69, 0xb60, 0x5f0, 0x4f9, 0x7f3, 0x6fa, 0x1f6, 0xff, 0x3f5, 0x2fc, 0xdfc, 0xcf5, 0xfff, 
+            0xef6, 0x9fa, 0x8f3, 0xbf9, 0xaf0, 0x650, 0x759, 0x453, 0x55a, 0x256, 0x35f, 0x55, 0x15c, 
+            0xe5c, 0xf55, 0xc5f, 0xd56, 0xa5a, 0xb53, 0x859, 0x950, 0x7c0, 0x6c9, 0x5c3, 0x4ca, 0x3c6, 
+            0x2cf, 0x1c5, 0xcc, 0xfcc, 0xec5, 0xdcf, 0xcc6, 0xbca, 0xac3, 0x9c9, 0x8c0, 0x8c0, 0x9c9, 
+            0xac3, 0xbca, 0xcc6, 0xdcf, 0xec5, 0xfcc, 0xcc, 0x1c5, 0x2cf, 0x3c6, 0x4ca, 0x5c3, 0x6c9, 
+            0x7c0, 0x950, 0x859, 0xb53, 0xa5a, 0xd56, 0xc5f, 0xf55, 0xe5c, 0x15c, 0x55, 0x35f, 0x256, 
+            0x55a, 0x453, 0x759, 0x650, 0xaf0, 0xbf9, 0x8f3, 0x9fa, 0xef6, 0xfff, 0xcf5, 0xdfc, 0x2fc, 
+            0x3f5, 0xff, 0x1f6, 0x6fa, 0x7f3, 0x4f9, 0x5f0, 0xb60, 0xa69, 0x963, 0x86a, 0xf66, 0xe6f, 
+            0xd65, 0xc6c, 0x36c, 0x265, 0x16f, 0x66, 0x76a, 0x663, 0x569, 0x460, 0xca0, 0xda9, 0xea3, 
+            0xfaa, 0x8a6, 0x9af, 0xaa5, 0xbac, 0x4ac, 0x5a5, 0x6af, 0x7a6, 0xaa, 0x1a3, 0x2a9, 0x3a0, 
+            0xd30, 0xc39, 0xf33, 0xe3a, 0x936, 0x83f, 0xb35, 0xa3c, 0x53c, 0x435, 0x73f, 0x636, 0x13a, 
+            0x33, 0x339, 0x230, 0xe90, 0xf99, 0xc93, 0xd9a, 0xa96, 0xb9f, 0x895, 0x99c, 0x69c, 0x795, 
+            0x49f, 0x596, 0x29a, 0x393, 0x99, 0x190, 0xf00, 0xe09, 0xd03, 0xc0a, 0xb06, 0xa0f, 0x905, 
+            0x80c, 0x70c, 0x605, 0x50f, 0x406, 0x30a, 0x203, 0x109, 0x0], dtype=np.uint16)
+
+        # Table of triangles to use for filling each grid cell.
+        # Each set of three integers tells us which three edges to
+        # draw a triangle between.
+        # (Data stolen from Bourk; see above.)
+        triTable = [
+            [],
+            [0, 8, 3],
+            [0, 1, 9],
+            [1, 8, 3, 9, 8, 1],
+            [1, 2, 10],
+            [0, 8, 3, 1, 2, 10],
+            [9, 2, 10, 0, 2, 9],
+            [2, 8, 3, 2, 10, 8, 10, 9, 8],
+            [3, 11, 2],
+            [0, 11, 2, 8, 11, 0],
+            [1, 9, 0, 2, 3, 11],
+            [1, 11, 2, 1, 9, 11, 9, 8, 11],
+            [3, 10, 1, 11, 10, 3],
+            [0, 10, 1, 0, 8, 10, 8, 11, 10],
+            [3, 9, 0, 3, 11, 9, 11, 10, 9],
+            [9, 8, 10, 10, 8, 11],
+            [4, 7, 8],
+            [4, 3, 0, 7, 3, 4],
+            [0, 1, 9, 8, 4, 7],
+            [4, 1, 9, 4, 7, 1, 7, 3, 1],
+            [1, 2, 10, 8, 4, 7],
+            [3, 4, 7, 3, 0, 4, 1, 2, 10],
+            [9, 2, 10, 9, 0, 2, 8, 4, 7],
+            [2, 10, 9, 2, 9, 7, 2, 7, 3, 7, 9, 4],
+            [8, 4, 7, 3, 11, 2],
+            [11, 4, 7, 11, 2, 4, 2, 0, 4],
+            [9, 0, 1, 8, 4, 7, 2, 3, 11],
+            [4, 7, 11, 9, 4, 11, 9, 11, 2, 9, 2, 1],
+            [3, 10, 1, 3, 11, 10, 7, 8, 4],
+            [1, 11, 10, 1, 4, 11, 1, 0, 4, 7, 11, 4],
+            [4, 7, 8, 9, 0, 11, 9, 11, 10, 11, 0, 3],
+            [4, 7, 11, 4, 11, 9, 9, 11, 10],
+            [9, 5, 4],
+            [9, 5, 4, 0, 8, 3],
+            [0, 5, 4, 1, 5, 0],
+            [8, 5, 4, 8, 3, 5, 3, 1, 5],
+            [1, 2, 10, 9, 5, 4],
+            [3, 0, 8, 1, 2, 10, 4, 9, 5],
+            [5, 2, 10, 5, 4, 2, 4, 0, 2],
+            [2, 10, 5, 3, 2, 5, 3, 5, 4, 3, 4, 8],
+            [9, 5, 4, 2, 3, 11],
+            [0, 11, 2, 0, 8, 11, 4, 9, 5],
+            [0, 5, 4, 0, 1, 5, 2, 3, 11],
+            [2, 1, 5, 2, 5, 8, 2, 8, 11, 4, 8, 5],
+            [10, 3, 11, 10, 1, 3, 9, 5, 4],
+            [4, 9, 5, 0, 8, 1, 8, 10, 1, 8, 11, 10],
+            [5, 4, 0, 5, 0, 11, 5, 11, 10, 11, 0, 3],
+            [5, 4, 8, 5, 8, 10, 10, 8, 11],
+            [9, 7, 8, 5, 7, 9],
+            [9, 3, 0, 9, 5, 3, 5, 7, 3],
+            [0, 7, 8, 0, 1, 7, 1, 5, 7],
+            [1, 5, 3, 3, 5, 7],
+            [9, 7, 8, 9, 5, 7, 10, 1, 2],
+            [10, 1, 2, 9, 5, 0, 5, 3, 0, 5, 7, 3],
+            [8, 0, 2, 8, 2, 5, 8, 5, 7, 10, 5, 2],
+            [2, 10, 5, 2, 5, 3, 3, 5, 7],
+            [7, 9, 5, 7, 8, 9, 3, 11, 2],
+            [9, 5, 7, 9, 7, 2, 9, 2, 0, 2, 7, 11],
+            [2, 3, 11, 0, 1, 8, 1, 7, 8, 1, 5, 7],
+            [11, 2, 1, 11, 1, 7, 7, 1, 5],
+            [9, 5, 8, 8, 5, 7, 10, 1, 3, 10, 3, 11],
+            [5, 7, 0, 5, 0, 9, 7, 11, 0, 1, 0, 10, 11, 10, 0],
+            [11, 10, 0, 11, 0, 3, 10, 5, 0, 8, 0, 7, 5, 7, 0],
+            [11, 10, 5, 7, 11, 5],
+            [10, 6, 5],
+            [0, 8, 3, 5, 10, 6],
+            [9, 0, 1, 5, 10, 6],
+            [1, 8, 3, 1, 9, 8, 5, 10, 6],
+            [1, 6, 5, 2, 6, 1],
+            [1, 6, 5, 1, 2, 6, 3, 0, 8],
+            [9, 6, 5, 9, 0, 6, 0, 2, 6],
+            [5, 9, 8, 5, 8, 2, 5, 2, 6, 3, 2, 8],
+            [2, 3, 11, 10, 6, 5],
+            [11, 0, 8, 11, 2, 0, 10, 6, 5],
+            [0, 1, 9, 2, 3, 11, 5, 10, 6],
+            [5, 10, 6, 1, 9, 2, 9, 11, 2, 9, 8, 11],
+            [6, 3, 11, 6, 5, 3, 5, 1, 3],
+            [0, 8, 11, 0, 11, 5, 0, 5, 1, 5, 11, 6],
+            [3, 11, 6, 0, 3, 6, 0, 6, 5, 0, 5, 9],
+            [6, 5, 9, 6, 9, 11, 11, 9, 8],
+            [5, 10, 6, 4, 7, 8],
+            [4, 3, 0, 4, 7, 3, 6, 5, 10],
+            [1, 9, 0, 5, 10, 6, 8, 4, 7],
+            [10, 6, 5, 1, 9, 7, 1, 7, 3, 7, 9, 4],
+            [6, 1, 2, 6, 5, 1, 4, 7, 8],
+            [1, 2, 5, 5, 2, 6, 3, 0, 4, 3, 4, 7],
+            [8, 4, 7, 9, 0, 5, 0, 6, 5, 0, 2, 6],
+            [7, 3, 9, 7, 9, 4, 3, 2, 9, 5, 9, 6, 2, 6, 9],
+            [3, 11, 2, 7, 8, 4, 10, 6, 5],
+            [5, 10, 6, 4, 7, 2, 4, 2, 0, 2, 7, 11],
+            [0, 1, 9, 4, 7, 8, 2, 3, 11, 5, 10, 6],
+            [9, 2, 1, 9, 11, 2, 9, 4, 11, 7, 11, 4, 5, 10, 6],
+            [8, 4, 7, 3, 11, 5, 3, 5, 1, 5, 11, 6],
+            [5, 1, 11, 5, 11, 6, 1, 0, 11, 7, 11, 4, 0, 4, 11],
+            [0, 5, 9, 0, 6, 5, 0, 3, 6, 11, 6, 3, 8, 4, 7],
+            [6, 5, 9, 6, 9, 11, 4, 7, 9, 7, 11, 9],
+            [10, 4, 9, 6, 4, 10],
+            [4, 10, 6, 4, 9, 10, 0, 8, 3],
+            [10, 0, 1, 10, 6, 0, 6, 4, 0],
+            [8, 3, 1, 8, 1, 6, 8, 6, 4, 6, 1, 10],
+            [1, 4, 9, 1, 2, 4, 2, 6, 4],
+            [3, 0, 8, 1, 2, 9, 2, 4, 9, 2, 6, 4],
+            [0, 2, 4, 4, 2, 6],
+            [8, 3, 2, 8, 2, 4, 4, 2, 6],
+            [10, 4, 9, 10, 6, 4, 11, 2, 3],
+            [0, 8, 2, 2, 8, 11, 4, 9, 10, 4, 10, 6],
+            [3, 11, 2, 0, 1, 6, 0, 6, 4, 6, 1, 10],
+            [6, 4, 1, 6, 1, 10, 4, 8, 1, 2, 1, 11, 8, 11, 1],
+            [9, 6, 4, 9, 3, 6, 9, 1, 3, 11, 6, 3],
+            [8, 11, 1, 8, 1, 0, 11, 6, 1, 9, 1, 4, 6, 4, 1],
+            [3, 11, 6, 3, 6, 0, 0, 6, 4],
+            [6, 4, 8, 11, 6, 8],
+            [7, 10, 6, 7, 8, 10, 8, 9, 10],
+            [0, 7, 3, 0, 10, 7, 0, 9, 10, 6, 7, 10],
+            [10, 6, 7, 1, 10, 7, 1, 7, 8, 1, 8, 0],
+            [10, 6, 7, 10, 7, 1, 1, 7, 3],
+            [1, 2, 6, 1, 6, 8, 1, 8, 9, 8, 6, 7],
+            [2, 6, 9, 2, 9, 1, 6, 7, 9, 0, 9, 3, 7, 3, 9],
+            [7, 8, 0, 7, 0, 6, 6, 0, 2],
+            [7, 3, 2, 6, 7, 2],
+            [2, 3, 11, 10, 6, 8, 10, 8, 9, 8, 6, 7],
+            [2, 0, 7, 2, 7, 11, 0, 9, 7, 6, 7, 10, 9, 10, 7],
+            [1, 8, 0, 1, 7, 8, 1, 10, 7, 6, 7, 10, 2, 3, 11],
+            [11, 2, 1, 11, 1, 7, 10, 6, 1, 6, 7, 1],
+            [8, 9, 6, 8, 6, 7, 9, 1, 6, 11, 6, 3, 1, 3, 6],
+            [0, 9, 1, 11, 6, 7],
+            [7, 8, 0, 7, 0, 6, 3, 11, 0, 11, 6, 0],
+            [7, 11, 6],
+            [7, 6, 11],
+            [3, 0, 8, 11, 7, 6],
+            [0, 1, 9, 11, 7, 6],
+            [8, 1, 9, 8, 3, 1, 11, 7, 6],
+            [10, 1, 2, 6, 11, 7],
+            [1, 2, 10, 3, 0, 8, 6, 11, 7],
+            [2, 9, 0, 2, 10, 9, 6, 11, 7],
+            [6, 11, 7, 2, 10, 3, 10, 8, 3, 10, 9, 8],
+            [7, 2, 3, 6, 2, 7],
+            [7, 0, 8, 7, 6, 0, 6, 2, 0],
+            [2, 7, 6, 2, 3, 7, 0, 1, 9],
+            [1, 6, 2, 1, 8, 6, 1, 9, 8, 8, 7, 6],
+            [10, 7, 6, 10, 1, 7, 1, 3, 7],
+            [10, 7, 6, 1, 7, 10, 1, 8, 7, 1, 0, 8],
+            [0, 3, 7, 0, 7, 10, 0, 10, 9, 6, 10, 7],
+            [7, 6, 10, 7, 10, 8, 8, 10, 9],
+            [6, 8, 4, 11, 8, 6],
+            [3, 6, 11, 3, 0, 6, 0, 4, 6],
+            [8, 6, 11, 8, 4, 6, 9, 0, 1],
+            [9, 4, 6, 9, 6, 3, 9, 3, 1, 11, 3, 6],
+            [6, 8, 4, 6, 11, 8, 2, 10, 1],
+            [1, 2, 10, 3, 0, 11, 0, 6, 11, 0, 4, 6],
+            [4, 11, 8, 4, 6, 11, 0, 2, 9, 2, 10, 9],
+            [10, 9, 3, 10, 3, 2, 9, 4, 3, 11, 3, 6, 4, 6, 3],
+            [8, 2, 3, 8, 4, 2, 4, 6, 2],
+            [0, 4, 2, 4, 6, 2],
+            [1, 9, 0, 2, 3, 4, 2, 4, 6, 4, 3, 8],
+            [1, 9, 4, 1, 4, 2, 2, 4, 6],
+            [8, 1, 3, 8, 6, 1, 8, 4, 6, 6, 10, 1],
+            [10, 1, 0, 10, 0, 6, 6, 0, 4],
+            [4, 6, 3, 4, 3, 8, 6, 10, 3, 0, 3, 9, 10, 9, 3],
+            [10, 9, 4, 6, 10, 4],
+            [4, 9, 5, 7, 6, 11],
+            [0, 8, 3, 4, 9, 5, 11, 7, 6],
+            [5, 0, 1, 5, 4, 0, 7, 6, 11],
+            [11, 7, 6, 8, 3, 4, 3, 5, 4, 3, 1, 5],
+            [9, 5, 4, 10, 1, 2, 7, 6, 11],
+            [6, 11, 7, 1, 2, 10, 0, 8, 3, 4, 9, 5],
+            [7, 6, 11, 5, 4, 10, 4, 2, 10, 4, 0, 2],
+            [3, 4, 8, 3, 5, 4, 3, 2, 5, 10, 5, 2, 11, 7, 6],
+            [7, 2, 3, 7, 6, 2, 5, 4, 9],
+            [9, 5, 4, 0, 8, 6, 0, 6, 2, 6, 8, 7],
+            [3, 6, 2, 3, 7, 6, 1, 5, 0, 5, 4, 0],
+            [6, 2, 8, 6, 8, 7, 2, 1, 8, 4, 8, 5, 1, 5, 8],
+            [9, 5, 4, 10, 1, 6, 1, 7, 6, 1, 3, 7],
+            [1, 6, 10, 1, 7, 6, 1, 0, 7, 8, 7, 0, 9, 5, 4],
+            [4, 0, 10, 4, 10, 5, 0, 3, 10, 6, 10, 7, 3, 7, 10],
+            [7, 6, 10, 7, 10, 8, 5, 4, 10, 4, 8, 10],
+            [6, 9, 5, 6, 11, 9, 11, 8, 9],
+            [3, 6, 11, 0, 6, 3, 0, 5, 6, 0, 9, 5],
+            [0, 11, 8, 0, 5, 11, 0, 1, 5, 5, 6, 11],
+            [6, 11, 3, 6, 3, 5, 5, 3, 1],
+            [1, 2, 10, 9, 5, 11, 9, 11, 8, 11, 5, 6],
+            [0, 11, 3, 0, 6, 11, 0, 9, 6, 5, 6, 9, 1, 2, 10],
+            [11, 8, 5, 11, 5, 6, 8, 0, 5, 10, 5, 2, 0, 2, 5],
+            [6, 11, 3, 6, 3, 5, 2, 10, 3, 10, 5, 3],
+            [5, 8, 9, 5, 2, 8, 5, 6, 2, 3, 8, 2],
+            [9, 5, 6, 9, 6, 0, 0, 6, 2],
+            [1, 5, 8, 1, 8, 0, 5, 6, 8, 3, 8, 2, 6, 2, 8],
+            [1, 5, 6, 2, 1, 6],
+            [1, 3, 6, 1, 6, 10, 3, 8, 6, 5, 6, 9, 8, 9, 6],
+            [10, 1, 0, 10, 0, 6, 9, 5, 0, 5, 6, 0],
+            [0, 3, 8, 5, 6, 10],
+            [10, 5, 6],
+            [11, 5, 10, 7, 5, 11],
+            [11, 5, 10, 11, 7, 5, 8, 3, 0],
+            [5, 11, 7, 5, 10, 11, 1, 9, 0],
+            [10, 7, 5, 10, 11, 7, 9, 8, 1, 8, 3, 1],
+            [11, 1, 2, 11, 7, 1, 7, 5, 1],
+            [0, 8, 3, 1, 2, 7, 1, 7, 5, 7, 2, 11],
+            [9, 7, 5, 9, 2, 7, 9, 0, 2, 2, 11, 7],
+            [7, 5, 2, 7, 2, 11, 5, 9, 2, 3, 2, 8, 9, 8, 2],
+            [2, 5, 10, 2, 3, 5, 3, 7, 5],
+            [8, 2, 0, 8, 5, 2, 8, 7, 5, 10, 2, 5],
+            [9, 0, 1, 5, 10, 3, 5, 3, 7, 3, 10, 2],
+            [9, 8, 2, 9, 2, 1, 8, 7, 2, 10, 2, 5, 7, 5, 2],
+            [1, 3, 5, 3, 7, 5],
+            [0, 8, 7, 0, 7, 1, 1, 7, 5],
+            [9, 0, 3, 9, 3, 5, 5, 3, 7],
+            [9, 8, 7, 5, 9, 7],
+            [5, 8, 4, 5, 10, 8, 10, 11, 8],
+            [5, 0, 4, 5, 11, 0, 5, 10, 11, 11, 3, 0],
+            [0, 1, 9, 8, 4, 10, 8, 10, 11, 10, 4, 5],
+            [10, 11, 4, 10, 4, 5, 11, 3, 4, 9, 4, 1, 3, 1, 4],
+            [2, 5, 1, 2, 8, 5, 2, 11, 8, 4, 5, 8],
+            [0, 4, 11, 0, 11, 3, 4, 5, 11, 2, 11, 1, 5, 1, 11],
+            [0, 2, 5, 0, 5, 9, 2, 11, 5, 4, 5, 8, 11, 8, 5],
+            [9, 4, 5, 2, 11, 3],
+            [2, 5, 10, 3, 5, 2, 3, 4, 5, 3, 8, 4],
+            [5, 10, 2, 5, 2, 4, 4, 2, 0],
+            [3, 10, 2, 3, 5, 10, 3, 8, 5, 4, 5, 8, 0, 1, 9],
+            [5, 10, 2, 5, 2, 4, 1, 9, 2, 9, 4, 2],
+            [8, 4, 5, 8, 5, 3, 3, 5, 1],
+            [0, 4, 5, 1, 0, 5],
+            [8, 4, 5, 8, 5, 3, 9, 0, 5, 0, 3, 5],
+            [9, 4, 5],
+            [4, 11, 7, 4, 9, 11, 9, 10, 11],
+            [0, 8, 3, 4, 9, 7, 9, 11, 7, 9, 10, 11],
+            [1, 10, 11, 1, 11, 4, 1, 4, 0, 7, 4, 11],
+            [3, 1, 4, 3, 4, 8, 1, 10, 4, 7, 4, 11, 10, 11, 4],
+            [4, 11, 7, 9, 11, 4, 9, 2, 11, 9, 1, 2],
+            [9, 7, 4, 9, 11, 7, 9, 1, 11, 2, 11, 1, 0, 8, 3],
+            [11, 7, 4, 11, 4, 2, 2, 4, 0],
+            [11, 7, 4, 11, 4, 2, 8, 3, 4, 3, 2, 4],
+            [2, 9, 10, 2, 7, 9, 2, 3, 7, 7, 4, 9],
+            [9, 10, 7, 9, 7, 4, 10, 2, 7, 8, 7, 0, 2, 0, 7],
+            [3, 7, 10, 3, 10, 2, 7, 4, 10, 1, 10, 0, 4, 0, 10],
+            [1, 10, 2, 8, 7, 4],
+            [4, 9, 1, 4, 1, 7, 7, 1, 3],
+            [4, 9, 1, 4, 1, 7, 0, 8, 1, 8, 7, 1],
+            [4, 0, 3, 7, 4, 3],
+            [4, 8, 7],
+            [9, 10, 8, 10, 11, 8],
+            [3, 0, 9, 3, 9, 11, 11, 9, 10],
+            [0, 1, 10, 0, 10, 8, 8, 10, 11],
+            [3, 1, 10, 11, 3, 10],
+            [1, 2, 11, 1, 11, 9, 9, 11, 8],
+            [3, 0, 9, 3, 9, 11, 1, 2, 9, 2, 11, 9],
+            [0, 2, 11, 8, 0, 11],
+            [3, 2, 11],
+            [2, 3, 8, 2, 8, 10, 10, 8, 9],
+            [9, 10, 2, 0, 9, 2],
+            [2, 3, 8, 2, 8, 10, 0, 1, 8, 1, 10, 8],
+            [1, 10, 2],
+            [1, 3, 8, 9, 1, 8],
+            [0, 9, 1],
+            [0, 3, 8],
+            []
+        ]
+
+        # maps edge ID (0-11) to (x, y, z) cell offset and edge ID (0-2)
+        edge_shifts = np.array([
+            [0, 0, 0, 0],   
+            [1, 0, 0, 1],
+            [0, 1, 0, 0],
+            [0, 0, 0, 1],
+            [0, 0, 1, 0],
+            [1, 0, 1, 1],
+            [0, 1, 1, 0],
+            [0, 0, 1, 1],
+            [0, 0, 0, 2],
+            [1, 0, 0, 2],
+            [1, 1, 0, 2],
+            [0, 1, 0, 2],
+            # [9, 9, 9, 9] fake
+            # don't use ubyte here! This value gets added to cell index later; 
+            # will need the extra precision.
+        ], dtype=np.uint16) 
+        n_table_faces = np.array([len(f)/3 for f in triTable], dtype=np.ubyte)
+        face_shift_tables = [None]
+        for i in range(1, 6):
+            # compute lookup table of index: vertexes mapping
+            faceTableI = np.zeros((len(triTable), i*3), dtype=np.ubyte)
+            faceTableInds = np.argwhere(n_table_faces == i)[:, 0]
+            faceTableI[faceTableInds] = np.array([triTable[j] for j in
+                                                  faceTableInds])
+            faceTableI = faceTableI.reshape((len(triTable), i, 3))
+            face_shift_tables.append(edge_shifts[faceTableI])
+
+        _data_cache = (face_shift_tables, edge_shifts, edge_table, 
+                       n_table_faces)
+
+    return _data_cache