snappy 3.1.1__cp38-cp38-win_amd64.whl → 3.2__cp38-cp38-win_amd64.whl

snappy/ptolemy/solutionsToPrimeIdealGroebnerBasis.py

@@ -18,12 +18,12 @@ from ..pari import pari
 
 # This is broken down in three steps.
 
-# Step 1: Split into extensions and assingments
+# Step 1: Split into extensions and assignments
 #    extensions, assignments = extensions_and_assignments(polys)
 
 # Split the list of polynomials into two lists, the first list
 # contains triples (poly, var, degree) forming a tower of
-# field extensons and the second group is a dictionary assigning
+# field extensions and the second group is a dictionary assigning
 # all remaining variables polynomials in the variables in the tower.
 
 # Example:
@@ -151,12 +151,12 @@ def update_assignments_and_merge(assignments, d):
     variables = sorted(set(
             sum([poly.variables() for poly in assignments.values()], [])))
 
-    monomial_to_value = { (): pari(1) }
+    monomial_to_value = {(): pari(1)}
 
     for var in variables:
         max_degree = max([poly.degree(var) for poly in assignments.values()])
 
-        old_keys = list(monomial_to_value.keys())
+        old_keys = list(monomial_to_value)
 
         v = d[var]
         power_of_v = pari(1)
@@ -180,8 +180,8 @@ def update_assignments_and_merge(assignments, d):
             [eval_monomial(m) for m in poly.get_monomials()],
             pari(0))
 
-    new_assignments = dict([(key, substitute(poly))
-                            for key, poly in assignments.items()])
+    new_assignments = {key: substitute(poly)
+                            for key, poly in assignments.items()}
 
     # Merge all the assignments of variables
     new_assignments.update(d)
@@ -227,9 +227,9 @@ def _process_extensions(extensions):
         # The new number field is again in x but the assignments
         # are assigning polynomials in the old x.
         # Need to update.
-        ext_assignments = dict(
-            [(key, poly.substitute({'x' : old_x_in_new_x}))
-             for key, poly in ext_assignments.items()])
+        ext_assignments = {
+            key: poly.substitute({'x' : old_x_in_new_x})
+             for key, poly in ext_assignments.items()}
 
         # And compute what the root of the last polynomial was
         # to assign it.

snappy/ptolemy/test.py

@@ -13,20 +13,25 @@
 # python test.py --compute
 
 from snappy import Manifold, pari, ptolemy
+from snappy import ptolemy
 from snappy.ptolemy import solutions_from_magma, Flattenings, parse_solutions
 from snappy.ptolemy.processFileBase import get_manifold
 from snappy.ptolemy import __path__ as ptolemy_paths
 from snappy.ptolemy.coordinates import PtolemyCannotBeCheckedError
-from snappy.sage_helper import _within_sage, doctest_modules
+from snappy.sage_helper import _within_sage
+from snappy.testing import doctest_modules
 from snappy.pari import pari
 import bz2
 import os
 import sys
+import doctest
+import traceback
 
 if _within_sage:
     from sage.misc.sage_eval import sage_eval
 
 test_regina = '--regina' in sys.argv
+compute_solutions = '--compute' in sys.argv
 
 base_path = ptolemy_paths[0]
 if test_regina:
@@ -208,7 +213,8 @@ def testSolutionsForManifold(M, N, solutions, baseline_cvolumes=None,
 def testComputeSolutionsForManifold(manifold, N,
                                     compute_solutions=False,
                                     baseline_cvolumes=None,
-                                    expect_non_zero_dimensional=None):
+                                    expect_non_zero_dimensional=None,
+                                    print_info=True):
 
     varieties = manifold.ptolemy_variety(N, obstruction_class="all_original")
 
@@ -226,10 +232,10 @@ def testComputeSolutionsForManifold(manifold, N,
                              baseline_cvolumes, expect_non_zero_dimensional)
 
     if manifold.name() == 't00000':
-        testMatrixMethods(manifold, solutions)
+        testMatrixMethods(manifold, solutions, print_info=print_info)
 
 
-def testMatrixMethods(manifold, solutions):
+def testMatrixMethods(manifold, solutions, print_info=True):
 
     def matrix_is_diagonal(m):
         return (
@@ -241,7 +247,8 @@ def testMatrixMethods(manifold, solutions):
         return matrix_is_diagonal(m) and (
             m[0][0] + 1 == 0 or m[0][0] - 1 == 0)
 
-    print("Testing matrix methods...")
+    if print_info:
+        print("Testing matrix methods...")
 
     G = manifold.fundamental_group(simplify_presentation=True)
     Graw = manifold.fundamental_group(simplify_presentation=False)
@@ -302,9 +309,14 @@ def test_flattenings_from_tetrahedra_shapes_of_manifold():
 
     from snappy import OrientableCuspedCensus
 
-    for M in (list(OrientableCuspedCensus()[0:10]) +
-              list(OrientableCuspedCensus()[10000:10010])):
+    for M_database in (list(OrientableCuspedCensus()[0:10]) +
+                       list(OrientableCuspedCensus()[10000:10010])):
 
+        # The manifold returned by OrientableCuspedCensus is
+        # a SnapPy.Manifold, not a snappy.Manifold (as is overridden
+        # in python/test.py).
+        M = Manifold(M_database)
+        
         flattening = Flattenings.from_tetrahedra_shapes_of_manifold(M)
         flattening.check_against_manifold(M, epsilon=1e-80)
 
@@ -447,7 +459,7 @@ def testComputeSolutionsForManifoldGeneralizedObstructionClass(
         manifold, N, baseline_volumes, baseline_dimensions)
 
 
-def testGeneralizedObstructionClass(compute_solutions):
+def testGeneralizedObstructionClass(compute_solutions, print_info = True):
 
     vols = [
         pari('0'),
@@ -484,7 +496,8 @@ def testGeneralizedObstructionClass(compute_solutions):
 
     for manifold, N, vols, dims in test_cases:
 
-        print("Checking for", manifold.name(), "N = %d" % N)
+        if print_info:
+            print("Checking for", manifold.name(), "N = %d" % N)
 
         testComputeSolutionsForManifoldGeneralizedObstructionClass(
             manifold, N, compute_solutions, vols, dims)
@@ -647,7 +660,7 @@ def testNumericalSolutions():
     check_volumes(allCVolumes, expected_cvolumes)
 
 
-def testGeometricRep(compute_solutions):
+def testGeometricRep(compute_solutions, print_info=False):
 
     from snappy.ptolemy import geometricRep
 
@@ -657,13 +670,14 @@ def testGeometricRep(compute_solutions):
     else:
         from urllib.request import pathname2url
         url = pathname2url(os.path.abspath(testing_files_directory))
-        sol = geometricRep.retrieve_geometric_solution(M, data_url=url)
+        sol = geometricRep.retrieve_geometric_solution(
+            M, data_url=url, verbose = print_info)
 
     # Make sure this is of type Ptolemy
     sol['c_0011_2']
 
     assert any(
-        [ abs(vol - 2.9441064867) < 1e-9 for vol in sol.volume_numerical()])
+        abs(vol - 2.9441064867) < 1e-9 for vol in sol.volume_numerical())
 
 
 def testSageCommandLine():
@@ -809,79 +823,66 @@ def test_num_obstruction_class_match():
         for i in range(2,6):
             assert len(M.ptolemy_generalized_obstruction_classes(i)) == len(N.ptolemy_generalized_obstruction_classes(i))
 
+def run_ptolemy_tests_raising_exceptions(print_info=True):
+    if print_info:
+        print("Testing in sage:", _within_sage)
 
-modules = [ptolemy.component, ptolemy.coordinates, ptolemy.manifoldMethods,
-           ptolemy.matrix, ptolemy.polynomial, ptolemy.processMagmaFile,
-           ptolemy.ptolemyObstructionClass, ptolemy.ptolemyVariety,
-           ptolemy.ptolemyVariety, ptolemy.processFileBase, ptolemy.processRurFile,
-           ptolemy.rur, ptolemy.utilities]
-if test_regina:
-    modules.append(ptolemy.reginaWrapper)
-
-
-def run_doctests(verbose=False, print_info=True):
-    return doctest_modules(modules, verbose, print_info)
-
-
-def main(verbose=False, doctest=True):
-    print("Testing in sage:", _within_sage)
-
-    print("Testing in regina:", test_regina)
-
-    if doctest:
-        print("Running doctests...")
-        run_doctests(verbose)
-        print()
+        print("Testing in regina:", test_regina)
 
     if test_regina:
-        print("Testing that regina agrees with snappy obstruction classes")
+        if print_info:
+            print("Testing that regina agrees with snappy obstruction classes")
         test_num_obstruction_class_match()
 
     if not test_regina:
-        print("Testing Flattenings.from_tetrahedra_shapes_of_manifold...")
+        if print_info:
+            print("Testing Flattenings.from_tetrahedra_shapes_of_manifold...")
 
         test_flattenings_from_tetrahedra_shapes_of_manifold()
 
-    compute_solutions = False
-
-    if '--compute' in sys.argv:
-        compute_solutions = True
-
     if test_regina and not compute_solutions:
         print("regina testing requires --compute")
         sys.exit(1)
 
     old_precision = pari.set_real_precision(100)
 
-    print("Testing induced representation...")
+    if print_info:
+        print("Testing induced representation...")
 
     test_induced_representation()
 
-    print("Testing induced SL(4,C) representation...")
+    if print_info:
+        print("Testing induced SL(4,C) representation...")
 
     test_induced_sl4_representation()
 
-    print("Running manifold tests for generalized obstruction class...")
+    if print_info:
+        print("Running manifold tests for generalized obstruction class...")
 
-    testGeneralizedObstructionClass(compute_solutions)
+    testGeneralizedObstructionClass(compute_solutions, print_info=print_info)
 
     if not test_regina:
-        print("Testing RUR for m052__sl3_c0.rur")
+        if print_info:
+            print("Testing RUR for m052__sl3_c0.rur")
 
         testMapleLikeRur()
 
-    print("Testing numerical solution retrieval method...")
+    if print_info:
+        print("Testing numerical solution retrieval method...")
 
     testNumericalSolutions()
 
-    print("Testing geometricRep...")
-    testGeometricRep(compute_solutions)
+    if print_info:
+        print("Testing geometricRep...")
+    testGeometricRep(compute_solutions, print_info=print_info)
 
     if _within_sage:
-        print("Testing in sage command line...")
+        if print_info:
+            print("Testing in sage command line...")
         testSageCommandLine()
 
-    print("Running manifold tests...")
+    if print_info:
+        print("Running manifold tests...")
 
     # Test for a non-hyperbolic manifold
 
@@ -1068,14 +1069,58 @@ def main(verbose=False, doctest=True):
 
     for manifold, N, cvols, expect_non_zero_dim in test_cases:
 
-        print("Checking for", manifold.name(), "N = %d" % N)
+        if print_info:
+            print("Checking for", manifold.name(), "N = %d" % N)
 
         testComputeSolutionsForManifold(
             manifold, N,
             compute_solutions=compute_solutions,
             baseline_cvolumes=cvols,
-            expect_non_zero_dimensional=expect_non_zero_dim)
+            expect_non_zero_dimensional=expect_non_zero_dim,
+            print_info=print_info)
 
+def run_ptolemy_tests(verbose=False, print_info=True):
+    try:
+        run_ptolemy_tests_raising_exceptions(
+            print_info=print_info)
+        return doctest.TestResults(failed=0, attempted=1)
+    except Exception as e:
+        print()
+        print("FAILED TEST in Ptolemy. Exception is:")
+        traceback.print_exc()
+        print()
+        return doctest.TestResults(failed=1, attempted=1)
+
+run_ptolemy_tests.__name__ = ptolemy.__name__ + ' (non-doc tests)'
+
+modules = [ptolemy.component,
+           ptolemy.coordinates,
+           ptolemy.manifoldMethods,
+           ptolemy.matrix,
+           ptolemy.polynomial,
+           ptolemy.processFileBase,
+           ptolemy.processMagmaFile,
+           ptolemy.processRurFile,
+           ptolemy.ptolemyObstructionClass,
+           ptolemy.ptolemyVariety,
+           ptolemy.rur,
+           ptolemy.utilities]
+if test_regina:
+    modules.append(ptolemy.reginaWrapper)
+
+def run_doctests(verbose=False, print_info=True):
+    return doctest_modules(
+        modules,
+        verbose=verbose, print_info=print_info)
+
+run_doctests.__name__ = ptolemy.__name__
 
 if __name__ == '__main__':
-    main()
+    verbose = '-v' in sys.argv[1:] or '--verbose' in sys.argv[1:]
+
+    result = run_doctests(verbose=verbose, print_info=True)
+    if result.failed:
+        sys.exit(result.failed)
+
+    result = run_ptolemy_tests(verbose=verbose, print_info=True)
+    sys.exit(result.failed)

snappy/ptolemy/utilities.py

@@ -212,7 +212,7 @@ class MethodMappingList(list):
     """
 
     def __init__(self, l=[], p=None):
-        super(MethodMappingList, self).__init__(l)
+        super().__init__(l)
 
     def __call__(self, *args, **kwargs):
         return type(self)([elt(*args, **kwargs) for elt in self],

snappy/raytracing/__init__.py

@@ -0,0 +1,64 @@
+from ..exceptions import NonorientableManifoldError
+from . import cohomology_fractal
+
+try:
+    from ..gui import ViewerWindow
+    from .inside_viewer import InsideViewer
+except ImportError as e:
+    InsideViewer = None
+    _importErrorRaytracing = str(e)
+
+from typing import Sequence
+
+def inside_view(self, cohomology_class=None, geodesics : Sequence[str]=[]):
+    r"""
+    Show raytraced inside view of hyperbolic manifold. See
+    `images <https://im.icerm.brown.edu/portfolio/snappy-views/>`_
+    and `demo video <https://youtu.be/CAERhmUCkRs>`_.
+
+        >>> M = Manifold("m004")
+        >>> M.inside_view() #doctest: +CYMODERNOPENGL
+
+    Or show the cohomology fractal:
+
+        >>> M = Manifold("m004")
+        >>> M.inside_view(cohomology_class = 0) #doctest: +CYMODERNOPENGL
+
+    The cohomology class in :math:`H^2(M, \partial M; \mathbb{R})` producing the
+    cohomology fractal can be specified as a cocycle or using an automatically
+    computed basis (of, say, length ``n``). Thus, ``cohomology_class`` can be
+    one of the following.
+
+    - An integer ``i`` between 0 and ``n`` - 1 to pick the ``i``-th basis
+      vector.
+    - An array of length ``n`` specifying the cohomology class as linear
+      combination of basis vectors.
+    - A weight for each face of each tetrahedron.
+
+    Geodesics can be specified as words in the unsimplified fundamental group:
+
+        >>> M = Manifold("m004")
+        >>> M.inside_view(geodesics=['a', 'bC']) #doctest: +CYMODERNOPENGL
+
+    """
+
+    if InsideViewer is None:
+        raise RuntimeError("Raytraced inside view not imported; "
+        "Tk or CyOpenGL is probably missing "
+        "(original error : %s)" % _importErrorRaytracing)
+
+    if not self.is_orientable():
+        raise NonorientableManifoldError("Manifold.inside_view", self)
+
+    weights, cohomology_basis, cohomology_class = (
+        cohomology_fractal.compute_weights_basis_class(
+            self, cohomology_class))
+
+    return ViewerWindow(
+        InsideViewer,
+        self,
+        title="Inside view of %s" % self.name(),
+        weights=weights,
+        cohomology_basis=cohomology_basis,
+        cohomology_class=cohomology_class,
+        geodesics=geodesics)

snappy/raytracing/additional_horospheres.py

@@ -0,0 +1,64 @@
+"""
+from snappy import *; from snappy.raytracing.additional_horospheres import *
+
+M=Manifold("t10879")
+M=CubicalOrientableCuspedCensus[0]
+v = M.inside_view()
+a=AdditionalHorospheres(M)
+v.view.widget.additional_structures['horospheres'] = a; v.view.widget._update_shader()
+
+"""
+
+from ..geometric_structure.cusp_neighborhood.tiles_for_cusp_neighborhood import mcomplex_for_tiling_cusp_neighborhoods
+from .pack import pack_tet_data
+from .upper_halfspace_utilities import add_coordinate_transform_to_mcomplex
+
+class AdditionalHorospheres:
+    def __init__(self, manifold):
+
+        self.mcomplex = mcomplex_for_tiling_cusp_neighborhoods(
+            manifold, bits_prec = 53, verified = False)
+        add_coordinate_transform_to_mcomplex(self.mcomplex)
+
+        self.num_tetrahedra = manifold.num_tetrahedra()
+        self.RF = manifold.tetrahedra_shapes('rect')[0].real().parent()
+        self.cusp_areas = [ 1.0 for v in self.mcomplex.Vertices ]
+
+        self._num = 0
+
+        self.compute_bindings()
+        
+    def get_compile_time_defs(self):
+        if self._num > 0:
+            num = max(100, self._num)
+        else:
+            num = 0
+
+        return { 'num_additional_horospheres' : num }
+
+    def get_uniform_bindings(self):
+        return self._uniform_bindings
+
+    def compute_bindings(self):
+
+        tets_to_data = [ [] for i in range(self.num_tetrahedra) ]
+
+        for cusp_index, v in enumerate(self.mcomplex.Vertices):
+            scale = (self.RF(self.cusp_areas[cusp_index]) / v.cusp_area).sqrt()
+
+            d = scale.log()
+
+            for tile in v.tiles():
+                if tile.lower_bound_distance > d:
+                    break
+
+                tet = tile.lifted_tetrahedron.tet
+                
+                s = (
+                    tet.to_coordinates_in_symmetric_tet * tile.inverse_lifted_geometric_object.defining_vec) / scale
+
+                tets_to_data[tet.Index].append(
+                    { 'Vec' : ('vec4', s),
+                      'CuspIndex' : ('int', cusp_index) })
+                
+        self._uniform_bindings, self._num = pack_tet_data('additionalHorospheres.horosphere', tets_to_data)

snappy/raytracing/additional_len_spec_choices.py

@@ -0,0 +1,63 @@
+"""
+from snappy import *; from snappy.raytracing.additional_len_spec_choices import *
+
+M=Manifold("t10879")
+M=CubicalOrientableCuspedCensus[0]
+v = M.inside_view()
+a=AdditionalLenSpecChoices(M)
+v.view.widget.additional_structures['lenSpec'] = a; v.view.widget._update_shader()
+
+"""
+
+from ..len_spec import mcomplex_for_len_spec
+
+from .pack import pack_tet_data
+from .upper_halfspace_utilities import add_coordinate_transform_to_mcomplex
+from ..snap.t3mlite import simplex
+
+class AdditionalLenSpecChoices:
+    def __init__(self, manifold):
+
+        self.mcomplex = mcomplex_for_len_spec(
+            manifold, bits_prec = 53, verified = False)
+        add_coordinate_transform_to_mcomplex(self.mcomplex)
+
+        self._num = 0
+
+        self.compute_bindings()
+
+    def get_compile_time_defs(self):
+        if self._num > 0:
+            num = max(100, self._num)
+        else:
+            num = 0
+
+        return { 'num_additional_horospheres' : num,
+                 'has_edge_midpoints' : 1}
+
+    def get_uniform_bindings(self):
+        return self._uniform_bindings
+
+    def compute_bindings(self):
+        self._uniform_bindings, self._num = pack_tet_data(
+            'additionalHorospheres.horosphere',
+            self._get_data())
+        self._uniform_bindings['edgeMidpoints.edgeMidpointVec'] = (
+            'vec4[]', [ tet.to_coordinates_in_symmetric_tet * tet.spine_points[e]
+                        for tet in self.mcomplex.Tetrahedra
+                        for e in simplex.OneSubsimplices ])
+        self._uniform_bindings['edgeMidpointRadiusParam'] = (
+            'float', 1.002)
+
+    def _get_data(self):
+        return [ [ _data_for_vert(tet, v) for v in simplex.ZeroSubsimplices ]
+                 for tet in self.mcomplex.Tetrahedra ]
+
+def _data_for_vert(tet, v):
+    return {
+        'Vec' :(
+            'vec4',
+            tet.to_coordinates_in_symmetric_tet * tet.R13_vertices[v]),
+        'CuspIndex' : (
+            'int',
+            tet.Class[v].Index) }

snappy/raytracing/cohomology_fractal.py

@@ -55,7 +55,6 @@ def check_weights_valid(trig, weights):
     Given a SnapPy triangulation and weights per face per tetrahedron,
     check they are consistent across glued faces and form a 2-cocycle.
 
-        >>> from snappy import Manifold
         >>> check_weights_valid(Manifold("m015"), [1, 0, 0, 0, -1, 0, 0, 1, -1, 0, 0, 0])
         >>> check_weights_valid(Manifold("m004"), [0, 1, 0, 1, 0, 0, -1, -2])
         Traceback (most recent call last):
@@ -111,7 +110,6 @@ def rational_cohomology_basis(trig):
     per face per tetrahedron that generate the second rational cohomology
     group.
 
-        >>> from snappy import Manifold
         >>> rational_cohomology_basis(Manifold("m125"))
         [[-1, -4, -2, 0, 1, 0, 0, 0, 0, 4, 1, 2, -1, 0, 0, 0], [0, 5, 2, 0, 0, 0, 0, 1, 0, -5, 0, -2, 0, 0, 0, -1]]
 
@@ -147,7 +145,6 @@ def compute_weights_basis_class(trig, cohomology_class):
     Convenience method to quickly access cohomology classes for
     M.inside_view().
 
-        >>> from snappy import Manifold
         >>> compute_weights_basis_class(Manifold("m004"), None)
         (None, None, None)
         >>> compute_weights_basis_class(Manifold("m003"), [1, 0, 0, 1, -1, 0, 0, -1])

snappy/raytracing/eyeball.py

@@ -0,0 +1,123 @@
+from ..hyperboloid import o13_inverse
+from ..hyperboloid.point import R13Point
+
+from ..tiling.tile import compute_tiles
+from ..tiling.lifted_tetrahedron import LiftedTetrahedron
+from ..tiling.lifted_tetrahedron_set import (LiftedTetrahedronSet,
+                                             get_lifted_tetrahedron_set)
+from ..tiling.triangle import add_triangles_to_tetrahedra
+
+from ..matrix import make_matrix, make_vector
+
+from ..matrix import matrix
+
+import math
+
+eyeball_type_none = 0
+eyeball_type_paper_plane = 1
+eyeball_type_eyeball = 2
+
+_max_num_eyeballs = 40
+
+class Eyeball:
+    def __init__(self, raytracing_view):
+        self.raytracing_view = raytracing_view
+
+        self.mcomplex = self.raytracing_view.raytracing_data.mcomplex
+        self.num_tetrahedra = len(self.mcomplex.Tetrahedra)
+
+        self._added_triangles = False
+
+        self.view_state = None
+
+    def _enabled(self):
+        return (
+            self.raytracing_view.ui_parameter_dict['eyeballSize'][1] > 0 and
+            self.raytracing_view.ui_parameter_dict['eyeballType'][1] > eyeball_type_none)
+
+    def get_compile_time_defs(self):
+        if not self._enabled():
+            return {}
+
+        d = { 'num_eyeballs' : _max_num_eyeballs,
+              'eyeball_type' : self.raytracing_view.ui_parameter_dict['eyeballType'][1]}
+
+        return d
+
+    def get_uniform_bindings(self):
+        if not self._enabled():
+            return {}
+
+        if not self._added_triangles:
+            add_triangles_to_tetrahedra(self.mcomplex)
+            self._added_triangles = True
+
+        if self.view_state is None or (
+                not self.raytracing_view.ui_parameter_dict['freezeEyeball'][1]):
+            self.view_state = self.raytracing_view.view_state
+
+        boost, tet_num, current_weight = self.view_state
+
+        RF = self.raytracing_view.raytracing_data.RF
+        
+        boost = make_matrix(boost, ring=RF)
+
+        base_point = make_vector([b[0] for b in boost])
+
+        eyeballRadius = self.raytracing_view.ui_parameter_dict['eyeballSize'][1]
+        if self.raytracing_view.ui_parameter_dict['eyeballType'][1] == eyeball_type_eyeball:
+            eyeballRadius = eyeballRadius / 2.0
+        tets_to_data = [ [] for i in range(self.num_tetrahedra) ]
+
+        initial_lifted_tetrahedron = LiftedTetrahedron(
+            self.mcomplex.Tetrahedra[tet_num], matrix.identity(RF, 4))
+
+        cut_off = RF(1.0 + 1e-5)
+
+        lifted_tetrahedron_set : LiftedTetrahedronSet = (
+            get_lifted_tetrahedron_set(
+                base_point=base_point,
+                act_on_base_point_by_inverse=True,
+                max_neg_prod_equal=cut_off,
+                min_neg_prod_distinct=cut_off,
+                canonical_keys_function=None,
+                verified=False))
+
+        for i, tile in enumerate(
+                compute_tiles(
+                    geometric_object=R13Point(base_point),
+                    visited_lifted_tetrahedra=lifted_tetrahedron_set,
+                    initial_lifted_tetrahedra=[ initial_lifted_tetrahedron ],
+                    verified=False)):
+
+            if i == _max_num_eyeballs:
+                break
+            if tile.lower_bound_distance > eyeballRadius:
+                break
+
+            m = o13_inverse(boost) * tile.lifted_tetrahedron.o13_matrix
+
+            tets_to_data[tile.lifted_tetrahedron.tet.Index].append((
+                tile.inverse_lifted_geometric_object.point,
+                m,
+                o13_inverse(m)))
+        
+        eyeballPositions = []
+        eyeballInvEmbeddings = []
+        eyeballEmbeddings = []
+        eyeballOffsets = []
+
+        for data in tets_to_data:
+            eyeballOffsets.append(len(eyeballPositions))
+            for eyeballPosition, eyeballInvEmbedding, eyeballEmbedding in data:
+                eyeballPositions.append(eyeballPosition)
+                eyeballInvEmbeddings.append(eyeballInvEmbedding)
+                eyeballEmbeddings.append(eyeballEmbedding)
+        eyeballOffsets.append(len(eyeballPositions))
+
+        return {
+            'eyeballRadius' : ('float', eyeballRadius),
+            'eyeballs.eyeballPositions' : ('vec4[]', eyeballPositions),
+            'eyeballs.eyeballInvEmbeddings' : ('mat4[]', eyeballInvEmbeddings),
+            'eyeballs.eyeballEmbeddings' : ('mat4[]', eyeballEmbeddings),
+            'eyeballs.eyeballOffsets' : ('int[]', eyeballOffsets) }