snappy 3.0.3__cp38-cp38-macosx_11_0_arm64.whl → 3.2__cp38-cp38-macosx_11_0_arm64.whl

snappy/raytracing/ideal_raytracing_data.py

@@ -1,26 +1,28 @@
-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 ..matrix import make_matrix, make_vector
 
-from snappy.snap.mcomplex_base import *
-
-from snappy.verify.cuspCrossSection import *
+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
 
 from .hyperboloid_utilities import *
+from .upper_halfspace_utilities import *
 
 from .raytracing_data import *
 
-from math import sqrt
-
 __all__ = ['IdealRaytracingData']
 
+
 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"))
 
@@ -31,27 +33,27 @@ class IdealRaytracingData(RaytracingData):
         {...}
 
     The compile time constants can similarly be obtained as dictionary::
-    
+
         >>> data.get_compile_time_constants() # doctest: +ELLIPSIS
         {...}
 
     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 ]])
-        >>> view_state = data.update_view_state(view_state, m) 
+        >>> 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 ]
         [          1e-16  -1.00000000         1e-16       1e-16 ]
@@ -62,11 +64,10 @@ class IdealRaytracingData(RaytracingData):
 
     @staticmethod
     def from_manifold(manifold,
-                      areas = None, insphere_scale = 0.05, weights = None):
+                      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()
 
@@ -82,7 +83,7 @@ class IdealRaytracingData(RaytracingData):
         c = ComplexCuspCrossSection.fromManifoldAndShapes(
             manifold,
             manifold.tetrahedra_shapes('rect'),
-            one_cocycle = 'develop')
+            one_cocycle='develop')
         c.normalize_cusps()
         c.compute_translations()
         c.add_vertex_positions_to_horotriangles()
@@ -102,19 +103,20 @@ class IdealRaytracingData(RaytracingData):
         r.peripheral_gluing_equations = snappy_trig.gluing_equations()[
             snappy_trig.num_tetrahedra():]
 
-        # For debugging! Delete!
-        r.c = c
+        r.log_shapes = [
+            tet.ShapeParameters[e].log()
+            for tet in c.mcomplex.Tetrahedra
+            for e in [ t3m.E01, t3m.E02, t3m.E03 ] ]
 
-        r._add_horotriangle_heights()
         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()
 
@@ -122,13 +124,9 @@ 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_horotriangle_heights(self):
-        for tet in self.mcomplex.Tetrahedra:
-            tet.horotriangle_heights = _compute_horotriangle_heights(tet)
-
     def _add_O13_matrices_to_faces(self):
         for tet in self.mcomplex.Tetrahedra:
             tet.O13_matrices = {
@@ -137,39 +135,39 @@ class IdealRaytracingData(RaytracingData):
 
     def _add_complex_vertices(self):
         for tet in self.mcomplex.Tetrahedra:
-            z = tet.ShapeParameters[t3m.E01]
-            w = z.sqrt() + (z-1).sqrt()
-            tet.complex_vertices = {
-                t3m.V0 :       w,
-                t3m.V1 :   1 / w,
-                t3m.V2 : - 1 / w,
-                t3m.V3 : -     w }
+            tet.complex_vertices = dict(zip(
+                        t3m.ZeroSubsimplices,
+                        symmetric_vertices_for_tetrahedron(
+                            tet.ShapeParameters[t3m.E01])))
 
     def _add_R13_vertices(self):
         for tet in self.mcomplex.Tetrahedra:
             tet.R13_vertices = {
-                V: complex_to_R13_light_vector(z)
+                V: ideal_point_to_r13(z, self.RF)
                 for V, z in tet.complex_vertices.items() }
-
-    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) }
-
-    def _compute_R13_horosphere_scale_for_vertex(self, tet, V):
-        vertex = tet.Class[V]
+            tet.R13_vertex_products = {
+                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]
+        if not vertex.is_complete:
+            return 0.0
         area = self.areas[vertex.Index]
-        if (not vertex.is_complete) or area < 1e-6:
+        if area < 1e-6:
             return 0.0
 
-        horosphere_point = _compute_R13_point_on_horosphere_for_vertex(tet, V)
-        
-        return - 1.0 / (R13_dot(tet.R13_vertices[V], horosphere_point)
-                          * area.sqrt())
+        V1, V2, _ = t3m.VerticesOfFaceCounterclockwise[t3m.comp(V0)]
+
+        cusp_length = tet.horotriangles[V0].get_real_lengths()[V0 | V1 | V2]
+
+        scale_for_unit_length = (
+            -2 * tet.R13_vertex_products[V1 | V2] / (
+                tet.R13_vertex_products[V0 | V1] *
+                tet.R13_vertex_products[V0 | V2])).sqrt()
+
+        return scale_for_unit_length / (cusp_length * area.sqrt())
 
     def _add_R13_horosphere_scales_to_vertices(self):
         for tet in self.mcomplex.Tetrahedra:
@@ -186,7 +184,7 @@ class IdealRaytracingData(RaytracingData):
     def _add_cusp_to_tet_matrices(self):
         for tet in self.mcomplex.Tetrahedra:
             m = [ (V, _compute_cusp_to_tet_and_inverse_matrices(tet, V, i))
-                  for i, V in enumerate(t3m.ZeroSubsimplices) ]  
+                  for i, V in enumerate(t3m.ZeroSubsimplices) ]
             tet.cusp_to_tet_matrices = {
                 V : m1 for V, (m1, m2) in m }
             tet.tet_to_cusp_matrices = {
@@ -206,68 +204,80 @@ 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)
-
-    def _check_consistency(self):
-        for tet in self.mcomplex.Tetrahedra:
-            for F in t3m.TwoSubsimplices:
-                for V in t3m.ZeroSubsimplices:
-                    if V & F:
-                        v0 = tet.O13_matrices[F] * 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:
-                            print("PROBLEM")
+            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):
-        # self._check_consistency()
+        # _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
             for tet in self.mcomplex.Tetrahedra ]
 
-        horotriangleHeights = [
-            tet.horotriangle_heights
-            for tet in self.mcomplex.Tetrahedra ]
-
         horosphere_scales = [
             tet.R13_horosphere_scales[V]
             for tet in self.mcomplex.Tetrahedra
@@ -276,17 +286,17 @@ class IdealRaytracingData(RaytracingData):
         margulisTubeTails = [
             tet.margulisTubeEnds[V][0]
             for tet in self.mcomplex.Tetrahedra
-            for V in t3m.ZeroSubsimplices ]            
+            for V in t3m.ZeroSubsimplices ]
 
         margulisTubeHeads = [
             tet.margulisTubeEnds[V][1]
             for tet in self.mcomplex.Tetrahedra
-            for V in t3m.ZeroSubsimplices ]            
+            for V in t3m.ZeroSubsimplices ]
 
         margulisTubeRadiusParams = [
             tet.Class[V].margulisTubeRadiusParam
             for tet in self.mcomplex.Tetrahedra
-            for V in t3m.ZeroSubsimplices ]            
+            for V in t3m.ZeroSubsimplices ]
 
         cusp_to_tet_matrices = [
             tet.cusp_to_tet_matrices[V]
@@ -315,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 ]
 
@@ -337,36 +347,64 @@ class IdealRaytracingData(RaytracingData):
         d['cuspTranslations'] = ('mat2[]', cusp_translations)
         d['logAdjustments'] = ('vec2[]', logAdjustments)
         d['cuspTriangleVertexPositions'] = ('mat3x2[]', cuspTriangleVertexPositions)
-        d['horotriangleHeights'] = ('vec3[]', horotriangleHeights)
-        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)
 
+    def cusp_view_state_and_scale(self, which_cusp):
+        vert = self.mcomplex.Vertices[which_cusp]
+        corner = vert.Corners[0]
+        tet = corner.Tetrahedron
+        subsimplex = corner.Subsimplex
+        area = self.areas[which_cusp]
+
+        return (
+            self.update_view_state(
+                (_cusp_view_matrix(tet, subsimplex, area),
+                 corner.Tetrahedron.Index,
+                 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):
@@ -377,30 +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 _matrix_taking_0_1_inf_to_given_points(z0, z1, zinf):
-    l = z1   - z0
-    m = zinf - z1
-        
-    return matrix([[ l * zinf, m * z0 ],
-                   [ l,        m      ]])
-
 def _pgl2_matrix_for_face(tet, F):
     gluing = tet.Gluing[F]
     other_tet = tet.Neighbor[F]
@@ -412,18 +443,20 @@ def _pgl2_matrix_for_face(tet, F):
         other_tet.complex_vertices[gluing.image(V)]
         for V in t3m.ZeroSubsimplices
         if V & F ]
-        
-    m1 = _matrix_taking_0_1_inf_to_given_points(*verts)
-    m2 = _matrix_taking_0_1_inf_to_given_points(*other_verts)
-    
-    return m2 * _adjoint(m1)
+
+    m1 = pgl2_matrix_taking_0_1_inf_to_given_points(*verts)
+    m2 = pgl2_matrix_taking_0_1_inf_to_given_points(*other_verts)
+
+    return m2 * sl2c_inverse(m1)
+
 
 def _o13_matrix_for_face(tet, F):
-    return GL2C_to_O13(_pgl2_matrix_for_face(tet, F))
+    return pgl2c_to_o13(_pgl2_matrix_for_face(tet, F))
+
 
 def _compute_cusp_triangle_vertex_positions(tet, V, i):
 
-    z  = tet.ShapeParameters[t3m.E01]
+    z = tet.ShapeParameters[t3m.E01]
     CF = z.parent()
 
     triangle = tet.horotriangles[V]
@@ -440,8 +473,8 @@ 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 ]
 
@@ -453,63 +486,107 @@ def _compute_cusp_triangle_vertex_positions(tet, V, i):
 
     return log_z0, vertex_positions
 
-def _compute_horotriangle_heights(tet):
-    z  = tet.ShapeParameters[t3m.E01]
-    CF = z.parent()
-
-    z0 = CF(0)
-    z1 = CF(1)
-    z2 = z
-    return [ height_euclidean_triangle(z0, z1, z2),
-             height_euclidean_triangle(z1, z2, z0),
-             height_euclidean_triangle(z2, z0, z1) ]
-
-def _compute_R13_point_on_horosphere_for_vertex(tet, V0):
-    V1, V2, V3 = t3m.VerticesOfFaceCounterclockwise[t3m.comp(V0)]
-
-    cusp_length = tet.horotriangles[V0].get_real_lengths()[V0 | V1 | V2]
-    pts  = [ tet.complex_vertices[V] for V in [V0, V1, V2]]
-    
-    pts[1] = 1.0 / (pts[1] - pts[0])
-    pts[2] = 1.0 / (pts[2] - pts[0])
-
-    base_length = abs(pts[2] - pts[1])
-    
-    horosphere_height = cusp_length / base_length
-
-    return complex_and_height_to_R13_time_vector(pts[0], horosphere_height)
-
-def _adjoint(m):
-    return matrix([[ m[1,1], -m[0,1]],
-                   [-m[1,0],  m[0,0]]], ring = m[0,0].parent())
 
 def _compute_cusp_to_tet_and_inverse_matrices(tet, vertex, i):
     trig = tet.horotriangles[vertex]
 
     otherVerts = [ t3m.ZeroSubsimplices[(i + j) % 4] for j in range(1, 4) ]
 
-    tet_vertices  = [ tet.complex_vertices[v] for v in otherVerts ]
+    tet_vertices = [ tet.complex_vertices[v] for v in otherVerts ]
 
     cusp_vertices = [ trig.vertex_positions[vertex | v]
                       for v in otherVerts ]
-    
+
     if not tet.Class[vertex].is_complete:
         z0 = cusp_vertices[0]
         cusp_vertices = [ z / z0 for z in cusp_vertices ]
 
-    std_to_tet = _matrix_taking_0_1_inf_to_given_points(*tet_vertices)
-    cusp_to_std = _adjoint(_matrix_taking_0_1_inf_to_given_points(*cusp_vertices))
+    std_to_tet = pgl2_matrix_taking_0_1_inf_to_given_points(*tet_vertices)
+    cusp_to_std = sl2c_inverse(
+        pgl2_matrix_taking_0_1_inf_to_given_points(*cusp_vertices))
 
     return (
-        GL2C_to_O13(         std_to_tet * cusp_to_std),
-        GL2C_to_O13(_adjoint(std_to_tet * cusp_to_std)))
+        pgl2c_to_o13(         std_to_tet * cusp_to_std),
+        pgl2c_to_o13(sl2c_inverse(std_to_tet * cusp_to_std)))
+
 
 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] ]
 
-    
+
+def _cusp_view_matrix(tet, subsimplex, area):
+    # Complex numbers encoding translation of horosphere corresponding
+    # to meridian and longitude. Here, the horosphere maps to the
+    # boundary of a cusp neighborhood with area one.
+    m_translation, l_translation = tet.Class[subsimplex].Translations
+
+    CF = m_translation.parent()
+    RF = m_translation.real().parent()
+
+    # Let us work in the upper halfspace model
+    #         H^3 = { z + tj : z in C, t > 0 }
+    # and with coordinates such that:
+    # 1. The camera we start with is at jand looking down.
+    # 2. The above horosphere is horizontal.
+    # 3. The meridian and longitude act by the PSL(2,Z)-matrix
+    #    [[1, z], [0, 1]] where z = m_translation or z = l_translation,
+    #    respectively.
+
+    translation = (m_translation + l_translation) / 2
+
+    # A small factor to move the camera a little bit into the cusp neighborhood
+    # to avoid z-Fighting.
+    factor_to_move_inside = 1.0001
+    rotation = l_translation / abs(l_translation)
+    scale = factor_to_move_inside/area.sqrt()
+    borel_transform = make_matrix([[ scale*rotation, translation ],
+                                   [              0,   1 ]],
+                                  ring=CF)
+
+    base_camera_matrix = make_matrix(
+        [[ 1, 0, 0, 0],
+         [ 0, 0, 0, 1],
+         [ 0, 1, 0, 0],
+         [ 0, 0, 1, 0]], ring=RF)
+
+    # Apply necessary pre and post O13-transforms to the transform
+    # in the upper halfspace we computed above.
+    o13_matrix = (
+        tet.cusp_to_tet_matrices[subsimplex] *
+        pgl2c_to_o13(borel_transform) *
+        base_camera_matrix)
+
+    return o13_matrix
+
+
+def _cusp_view_scale(tet, subsimplex, area):
+    # Complex numbers encoding translation of horosphere corresponding
+    # to meridian and longitude. Here, the horosphere maps to the
+    # boundary of a cusp neighborhood with area one.
+    m_translation, l_translation = tet.Class[subsimplex].Translations
+
+    real_l_translation = abs(l_translation)
+    m_translation = m_translation * abs(l_translation) / l_translation
+
+    t = max(real_l_translation + m_translation.real(),
+            real_l_translation - m_translation.real(),
+            m_translation.imag())
+
+    return area.sqrt() * t
+
+
+def _check_consistency(mcomplex):
+    for tet in mcomplex.Tetrahedra:
+        for F in t3m.TwoSubsimplices:
+            for V in t3m.ZeroSubsimplices:
+                if V & F:
+                    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:
+                        print("PROBLEM", v0, v1)