snappy 3.1.1__cp39-cp39-macosx_11_0_arm64.whl → 3.2__cp39-cp39-macosx_11_0_arm64.whl

snappy/raytracing/ideal_raytracing_data.py

@@ -1,12 +1,12 @@
-from snappy.snap import t3mlite as t3m
-from snappy import Triangulation
+from ..snap import t3mlite as t3m
+from ..snap.t3mlite import simplex
+from .. import Triangulation
 
-from snappy.SnapPy import matrix, vector
-
-from snappy.snap.mcomplex_base import *
-
-from snappy.verify.cuspCrossSection import *
+from ..matrix import make_matrix, make_vector
 
+from ..snap.mcomplex_base import *
+from ..geometric_structure.cusp_neighborhood.complex_cusp_cross_section import ComplexCuspCrossSection
+from ..geometric_structure import add_r13_planes_to_tetrahedra
 from ..upper_halfspace import pgl2c_to_o13, sl2c_inverse
 from ..upper_halfspace.ideal_point import ideal_point_to_r13
 
@@ -15,8 +15,6 @@ from .upper_halfspace_utilities import *
 
 from .raytracing_data import *
 
-from math import sqrt
-
 __all__ = ['IdealRaytracingData']
 
 
@@ -25,7 +23,6 @@ class IdealRaytracingData(RaytracingData):
     Given a SnapPy manifold, computes data for the shader fragment.glsl
     to raytrace the inside view::
 
-        >>> from snappy import *
         >>> data = IdealRaytracingData.from_manifold(Manifold("m004"))
         >>> data = IdealRaytracingData.from_manifold(ManifoldHP("m004"))
 
@@ -43,19 +40,19 @@ class IdealRaytracingData(RaytracingData):
     The shader needs to know in what tetrahedron and where in the tetrahedron
     the camera is. This is encoded as pair matrix and tetrahedron index::
 
-        >>> view_state = (matrix([[ 1.0, 0.0, 0.0, 0.0],
-        ...                       [ 0.0, 1.0, 0.0, 0.0],
-        ...                       [ 0.0, 0.0, 0.0,-1.0],
-        ...                       [ 0.0, 0.0, 1.0, 0.0]]), 0, 0.0)
+        >>> view_state = (make_matrix([[ 1.0, 0.0, 0.0, 0.0],
+        ...                            [ 0.0, 1.0, 0.0, 0.0],
+        ...                            [ 0.0, 0.0, 0.0,-1.0],
+        ...                            [ 0.0, 0.0, 1.0, 0.0]]), 0, 0.0)
 
     To move/rotate the camera which might potentially put the camera
     into a different tetrahedron, the new pair can be computed as
     follows::
 
-        >>> m = matrix([[ 3.0 , 0.0 , 2.82, 0.0 ],
-        ...             [ 0.0 , 1.0 , 0.0 , 0.0 ],
-        ...             [ 2.82, 0.0 , 3.0 , 0.0 ],
-        ...             [ 0.0 , 0.0 , 0.0 , 1.0 ]])
+        >>> m = make_matrix([[ 3.0 , 0.0 , 2.82, 0.0 ],
+        ...                  [ 0.0 , 1.0 , 0.0 , 0.0 ],
+        ...                  [ 2.82, 0.0 , 3.0 , 0.0 ],
+        ...                  [ 0.0 , 0.0 , 0.0 , 1.0 ]])
         >>> view_state = data.update_view_state(view_state, m)
         >>> view_state    # doctest: +NUMERIC6
         ([     1.08997684        1e-16   0.43364676        1e-16 ]
@@ -70,8 +67,7 @@ class IdealRaytracingData(RaytracingData):
                       areas=None, insphere_scale=0.05, weights=None):
 
         if manifold.solution_type() != 'all tetrahedra positively oriented':
-            return NonGeometricRaytracingData(
-                t3m.Mcomplex(manifold))
+            return NonGeometricRaytracingData.from_manifold(manifold)
 
         num_cusps = manifold.num_cusps()
 
@@ -107,15 +103,20 @@ class IdealRaytracingData(RaytracingData):
         r.peripheral_gluing_equations = snappy_trig.gluing_equations()[
             snappy_trig.num_tetrahedra():]
 
+        r.log_shapes = [
+            tet.ShapeParameters[e].log()
+            for tet in c.mcomplex.Tetrahedra
+            for e in [ t3m.E01, t3m.E02, t3m.E03 ] ]
+
         r._add_complex_vertices()
         r._add_R13_vertices()
         r._add_O13_matrices_to_faces()
-        r._add_R13_planes_to_faces()
+        add_r13_planes_to_tetrahedra(c.mcomplex)
         r._add_R13_horosphere_scales_to_vertices()
         r._add_cusp_to_tet_matrices()
         r._add_margulis_tube_ends()
         r._add_inspheres()
-        r._add_log_holonomies()
+        r._add_to_standard_torus_matrices()
 
         r._add_cusp_triangle_vertex_positions()
 
@@ -123,7 +124,7 @@ class IdealRaytracingData(RaytracingData):
         return r
 
     def __init__(self, mcomplex, snappy_manifold):
-        super(IdealRaytracingData, self).__init__(mcomplex)
+        super().__init__(mcomplex)
         self.snappy_manifold = snappy_manifold
 
     def _add_O13_matrices_to_faces(self):
@@ -134,12 +135,10 @@ class IdealRaytracingData(RaytracingData):
 
     def _add_complex_vertices(self):
         for tet in self.mcomplex.Tetrahedra:
-            tet.complex_vertices = {
-                v : vert
-                for v, vert in zip(
+            tet.complex_vertices = dict(zip(
                         t3m.ZeroSubsimplices,
                         symmetric_vertices_for_tetrahedron(
-                            tet.ShapeParameters[t3m.E01])) }
+                            tet.ShapeParameters[t3m.E01])))
 
     def _add_R13_vertices(self):
         for tet in self.mcomplex.Tetrahedra:
@@ -147,19 +146,9 @@ class IdealRaytracingData(RaytracingData):
                 V: ideal_point_to_r13(z, self.RF)
                 for V, z in tet.complex_vertices.items() }
             tet.R13_vertex_products = {
-                v0 | v1 : r13_dot(pt0, pt1)
-                for v0, pt0 in tet.R13_vertices.items()
-                for v1, pt1 in tet.R13_vertices.items()
-                if v0 != v1 }
-
-    def _add_R13_planes_to_faces(self):
-        for tet in self.mcomplex.Tetrahedra:
-            planes = make_tet_planes(
-                [ tet.R13_vertices[v]
-                  for v in t3m.ZeroSubsimplices])
-            tet.R13_planes = {
-                F : plane
-                for F, plane in zip(t3m.TwoSubsimplices, planes) }
+                e: r13_dot(tet.R13_vertices[simplex.Head[e]],
+                           tet.R13_vertices[simplex.Tail[e]])
+                for e in simplex.OneSubsimplices }
 
     def _compute_R13_horosphere_scale_for_vertex(self, tet, V0):
         vertex = tet.Class[V0]
@@ -215,48 +204,75 @@ class IdealRaytracingData(RaytracingData):
 
             tet.cosh_sqr_inradius = tmp.cosh() ** 2
 
-    def _add_log_holonomies_to_cusp(self, cusp, shapes):
+    def _add_to_standard_torus_matrix(self, cusp):
         i = cusp.Index
 
         if cusp.is_complete:
             m_param, l_param = cusp.Translations
         else:
-            m_param, l_param = [
-                sum(shape * expo
-                    for shape, expo
-                    in zip(shapes, self.peripheral_gluing_equations[2 * i + j]))
-                for j in range(2) ]
+            m_param, l_param = (
+                sum(log_shape * expo
+                    for log_shape, expo
+                    in zip(self.log_shapes, self.peripheral_gluing_equations[2 * i + j]))
+                for j in range(2) )
 
         a, c = m_param.real(), m_param.imag()
         b, d = l_param.real(), l_param.imag()
 
         det = a*d - b * c
-        cusp.mat_log = matrix([[d,-b], [-c, a]]) / det
+        cusp.to_standard_torus_matrix = make_matrix([[d,-b], [-c, a]]) / det
 
         if cusp.is_complete:
             cusp.margulisTubeRadiusParam = 0.0
         else:
-            slope = 2 * self.areas[i] / abs(det)
-
-            x = (slope ** 2 / (slope ** 2 + 1)).sqrt()
-            y = (1 / (slope ** 2 + 1)).sqrt()
-            rSqr = 1 + (x ** 2 + (1 - y) ** 2) / (2 * y)
-            cusp.margulisTubeRadiusParam = 0.25 * (1.0 + rSqr)
-
-    def _add_log_holonomies(self):
-        shapes = [
-            tet.ShapeParameters[e].log()
-            for tet in self.mcomplex.Tetrahedra
-            for e in [ t3m.E01, t3m.E02, t3m.E03 ] ]
-
-        for cusp, cusp_info in zip(self.mcomplex.Vertices,
-                                   self.snappy_manifold.cusp_info()):
-            self._add_log_holonomies_to_cusp(cusp, shapes)
+            area_ratio = self.areas[i] / abs(det)
+
+            # Imagine a cone above 0 in the upper half space model with slope s
+            # that is, it intersects the plane at Euclidean height 1 in a circle
+            # of Euclidean radius s.
+            #
+            # Let C be the boundary of the upper half space without infinity.
+            # Consider a small rectangle with lengths dtheta and dr in C using
+            # polar coordinates.
+            # The intersection of extrusion of this rectangle with the
+            # boundary of the cone is spanned by two tangent vectors with
+            # Euclidean lengths
+            #
+            # r * dtheta and sqrt(1 + 1/s^2) * dr.
+            #
+            # The corresponding hyperbolic lengths are
+            #
+            # r / (r/s) * dtheta and sqrt(1 + 1/s^2) / (r/s) * dr
+            #
+            # Thus, the area of the intersection is
+            #
+            # dA = s * sqrt(1 + s^2) * dtheta * dr/r
+            #
+            # If m and l are the log lifts of the the holonomies of the
+            # meridian and longitudes in C^*, then we get for the area
+            #
+            # A = s * sqrt(1 + s^2) * (m wedge l)
+            #
+            # Recall that s = sinh R where R is the hyperbolic radius of the
+            # tube. The tube parameter we need to compute the intersection with
+            # a geodesic (in the shader) is given by T = cosh(R)^2/2.
+            #
+            # Letting A_0 = A / (m wedge l), we have
+            # A_0 = sinh R * cosh R = 1/2 sinh(2 * R)
+            # R = 1/2 arcsinh(A_0)
+            # T = 1/4 (1 + sqrt(1 + 4 * A_0^2))
+
+            a = 1 + 4 * area_ratio ** 2
+            cusp.margulisTubeRadiusParam = (1 + a.sqrt()) / 4
+
+    def _add_to_standard_torus_matrices(self):
+        for cusp in self.mcomplex.Vertices:
+            self._add_to_standard_torus_matrix(cusp)
 
     def get_uniform_bindings(self):
         # _check_consistency(self.mcomplex)
 
-        d = super(IdealRaytracingData, self).get_uniform_bindings()
+        d = super().get_uniform_bindings()
 
         orientations = [
             +1 if tet.ShapeParameters[t3m.E01].imag() > 0 else -1
@@ -309,8 +325,8 @@ class IdealRaytracingData(RaytracingData):
             for V in t3m.ZeroSubsimplices
             ]
 
-        mat_logs = [
-            tet.Class[V].mat_log
+        toStandardTorusMatrices = [
+            tet.Class[V].to_standard_torus_matrix
             for tet in self.mcomplex.Tetrahedra
             for V in t3m.ZeroSubsimplices ]
 
@@ -331,23 +347,24 @@ class IdealRaytracingData(RaytracingData):
         d['cuspTranslations'] = ('mat2[]', cusp_translations)
         d['logAdjustments'] = ('vec2[]', logAdjustments)
         d['cuspTriangleVertexPositions'] = ('mat3x2[]', cuspTriangleVertexPositions)
-        d['matLogs'] = ('mat2[]', mat_logs)
+        d['toStandardTorusMatrices'] = ('mat2[]', toStandardTorusMatrices)
         d['insphereRadiusParams'] = ('float[]', insphereRadiusParams)
         d['isNonGeometric'] = ('bool', isNonGeometric)
         d['nonGeometricTexture'] = ('int', 0)
+        d['eyeTexture'] = ('int', 1)
 
         return d
 
     def get_compile_time_constants(self):
-        d = super(IdealRaytracingData, self).get_compile_time_constants()
+        d = super().get_compile_time_constants()
         d[b'##finiteTrig##'] = 0
         return d
 
     def initial_view_state(self):
-        boost = matrix([[1.0,0.0,0.0,0.0],
-                        [0.0,1.0,0.0,0.0],
-                        [0.0,0.0,1.0,0.0],
-                        [0.0,0.0,0.0,1.0]])
+        boost = make_matrix([[1.0,0.0,0.0,0.0],
+                             [0.0,1.0,0.0,0.0],
+                             [0.0,0.0,1.0,0.0],
+                             [0.0,0.0,0.0,1.0]])
         tet_num = 0
         weight = 0.0
         return (boost, tet_num, weight)
@@ -366,15 +383,28 @@ class IdealRaytracingData(RaytracingData):
                  0.0)),
             _cusp_view_scale(tet, subsimplex, area))
 
-
 class NonGeometricRaytracingData(McomplexEngine):
-    def __init__(self, mcomplex):
-        super(NonGeometricRaytracingData, self).__init__(mcomplex)
+    @staticmethod
+    def from_manifold(manifold):
+        mcomplex = t3m.Mcomplex(manifold)
+        r = NonGeometricRaytracingData(mcomplex, manifold)
+        z = manifold.tetrahedra_shapes('rect')[0]
+        r.RF = z.real().parent()
+        return r
+
+    def __init__(self, mcomplex, manifold):
+        super().__init__(mcomplex)
+        self.manifold = manifold
+
+    def is_valid(self):
+        return False
 
     def get_compile_time_constants(self):
         return {
             b'##num_tets##' : len(self.mcomplex.Tetrahedra),
-            b'##num_cusps##' : len(self.mcomplex.Vertices)
+            b'##num_cusps##' : len(self.mcomplex.Vertices),
+            b'##num_edges##' : len(self.mcomplex.Edges),
+            b'##finiteTrig##' : 0,
             }
 
     def get_uniform_bindings(self):
@@ -385,24 +415,23 @@ class NonGeometricRaytracingData(McomplexEngine):
                 ('int', 0)}
 
     def initial_view_state(self):
-        boost = matrix([[1.0,0.0,0.0,0.0],
-                        [0.0,1.0,0.0,0.0],
-                        [0.0,0.0,1.0,0.0],
-                        [0.0,0.0,0.0,1.0]])
+        boost = make_matrix([[1.0,0.0,0.0,0.0],
+                             [0.0,1.0,0.0,0.0],
+                             [0.0,0.0,1.0,0.0],
+                             [0.0,0.0,0.0,1.0]])
         tet_num = 0
         weight = 0.0
         return (boost, tet_num, weight)
 
     def update_view_state(self, boost_tet_num_and_weight,
-                          m=matrix([[1.0, 0.0, 0.0, 0.0],
-                                      [0.0, 1.0, 0.0, 0.0],
-                                      [0.0, 0.0, 1.0, 0.0],
-                                      [0.0, 0.0, 0.0, 1.0]])):
+                          m=make_matrix([[1.0, 0.0, 0.0, 0.0],
+                                         [0.0, 1.0, 0.0, 0.0],
+                                         [0.0, 0.0, 1.0, 0.0],
+                                         [0.0, 0.0, 0.0, 1.0]])):
         boost, tet_num, weight = boost_tet_num_and_weight
         boost = boost * m
         return boost, tet_num, weight
 
-
 def _pgl2_matrix_for_face(tet, F):
     gluing = tet.Gluing[F]
     other_tet = tet.Neighbor[F]
@@ -444,7 +473,7 @@ def _compute_cusp_triangle_vertex_positions(tet, V, i):
         log_z0 = CF(0)
 
         # Inverting matrix here since SageMath screws up :(
-        translations_to_ml = matrix([[d,-b], [-c, a]]) / (a*d - b * c)
+        translations_to_ml = make_matrix([[d,-b], [-c, a]]) / (a*d - b * c)
 
         vertex_positions = [ translations_to_ml * complex_to_pair(z)
                              for z in vertex_positions ]
@@ -486,7 +515,7 @@ def _compute_margulis_tube_ends(tet, vertex):
     if tet.Class[vertex].is_complete:
         return [(0.0, 0.0, 0.0, 0.0), (0.0, 0.0, 0.0, 0.0)]
 
-    return [ tet.cusp_to_tet_matrices[vertex] * vector([1.0, x, 0.0, 0.0])
+    return [ tet.cusp_to_tet_matrices[vertex] * make_vector([1.0, x, 0.0, 0.0])
              for x in [-1.0, 1.0] ]
 
 
@@ -515,10 +544,11 @@ def _cusp_view_matrix(tet, subsimplex, area):
     factor_to_move_inside = 1.0001
     rotation = l_translation / abs(l_translation)
     scale = factor_to_move_inside/area.sqrt()
-    borel_transform = matrix([[ scale*rotation, translation ],
-                              [     0, 1 ]], ring=CF)
+    borel_transform = make_matrix([[ scale*rotation, translation ],
+                                   [              0,   1 ]],
+                                  ring=CF)
 
-    base_camera_matrix = matrix(
+    base_camera_matrix = make_matrix(
         [[ 1, 0, 0, 0],
          [ 0, 0, 0, 1],
          [ 0, 1, 0, 0],
@@ -555,7 +585,7 @@ def _check_consistency(mcomplex):
         for F in t3m.TwoSubsimplices:
             for V in t3m.ZeroSubsimplices:
                 if V & F:
-                    v0 = tet.O13_matrices[F] * vector(tet.R13_vertices[V])
+                    v0 = tet.O13_matrices[F] * make_vector(tet.R13_vertices[V])
                     v1 = tet.Neighbor[F].R13_vertices[tet.Gluing[F].image(V)]
                     err = r13_dot(v0, v1)
                     if err > 1e-10 or err < -1e-10: