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

snappy/raytracing/finite_raytracing_data.py

@@ -1,9 +1,9 @@
 from snappy.snap import t3mlite as t3m
 from snappy import Triangulation
 
-from snappy.SnapPy import matrix, vector
+from ..matrix import make_matrix, make_vector
 
-from snappy.upper_halfspace import pgl2c_to_o13
+from ..upper_halfspace import pgl2c_to_o13
 
 # We could use
 #
@@ -60,7 +60,7 @@ class FiniteRaytracingData(RaytracingData):
         return r
 
     def __init__(self, hyperbolic_structure):
-        super(FiniteRaytracingData, self).__init__(
+        super().__init__(
             hyperbolic_structure.mcomplex)
 
     def _compute_matrices(self, hyperbolic_structure):
@@ -69,7 +69,7 @@ class FiniteRaytracingData(RaytracingData):
                 hyperbolic_structure, tet.Index)
 
     def _compute_tet_vertices(self):
-        c = vector(self.RF, [1, 0, 0, 0])
+        c = make_vector([1, 0, 0, 0], ring=self.RF)
 
         def _compute_vertex(tet, perm):
             m = tet.permutahedron_matrices[perm]
@@ -83,8 +83,8 @@ class FiniteRaytracingData(RaytracingData):
                 t3m.V3 : _compute_vertex(tet, (3,0,1,2)) }
 
     def _compute_edge_ends(self):
-        cs = [ vector(self.RF,[1, 1, 0, 0]),
-               vector(self.RF,[1, -1, 0, 0]) ]
+        cs = [ make_vector([1,  1, 0, 0], ring=self.RF),
+               make_vector([1, -1, 0, 0], ring=self.RF) ]
 
         def _compute_edge_ends(tet, perm):
             m = tet.permutahedron_matrices[perm]
@@ -100,12 +100,12 @@ class FiniteRaytracingData(RaytracingData):
                 t3m.E23 : _compute_edge_ends(tet, (2,3,0,1)) }
 
     def _compute_planes(self):
-        c = vector(self.RF, [0.0, 0.0, 0.0, -1.0])
+        c = make_vector([0.0, 0.0, 0.0, -1.0], ring=self.RF)
 
         def _compute_plane(tet, perm):
             m = tet.permutahedron_matrices[perm]
             v = c * pgl2c_to_o13(m)
-            return vector([-v[0], v[1], v[2], v[3]])
+            return make_vector([-v[0], v[1], v[2], v[3]])
 
         for tet in self.mcomplex.Tetrahedra:
             tet.R13_planes = {
@@ -125,7 +125,7 @@ class FiniteRaytracingData(RaytracingData):
             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)]
 
                         if abs(r13_dot(v0, v1) - (-1.0)) > 1e-6:
@@ -136,7 +136,7 @@ class FiniteRaytracingData(RaytracingData):
     def get_uniform_bindings(self):
         # self._check_consistency()
 
-        d = super(FiniteRaytracingData, self).get_uniform_bindings()
+        d = super().get_uniform_bindings()
         d['TetrahedraEdges.R13EdgeEnds'] = (
             'vec4[]',
             [ edge_end
@@ -153,15 +153,15 @@ class FiniteRaytracingData(RaytracingData):
         return d
 
     def get_compile_time_constants(self):
-        d = super(FiniteRaytracingData, self).get_compile_time_constants()
+        d = super().get_compile_time_constants()
         d[b'##finiteTrig##'] = 1
         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)
@@ -191,8 +191,8 @@ def _compute_face_pairing(tet, F):
 
 
 def _adjoint(m):
-    return matrix([[ m[1,1],-m[0,1]],
-                   [-m[1,0], m[0,0]]])
+    return make_matrix([[ m[1,1],-m[0,1]],
+                        [-m[1,0], m[0,0]]])
 
 
 _new_perm_edge_type_old_perm = [

snappy/raytracing/finite_viewer.py

@@ -65,7 +65,7 @@ class FiniteViewer(ttk.Frame):
 
         UniformDictController(
             self.widget.ui_parameter_dict, 'fov',
-            update_function=self.widget.redraw_if_initialized,
+            update_function=self.widget.draw,
             scale=self.fov_scale,
             label=self.fov_label,
             format_string='%.1f')
@@ -121,7 +121,7 @@ class FiniteViewer(ttk.Frame):
         return frame
 
     def checkbox_update(self):
-        self.widget.redraw_if_initialized()
+        self.widget.draw()
         self.focus_viewer()
 
     def create_fillings_frame(self, parent):
@@ -207,7 +207,7 @@ class FiniteViewer(ttk.Frame):
             row=row,
             left_end=0.0,
             right_end=0.35,
-            update_function=self.widget.redraw_if_initialized,
+            update_function=self.widget.draw,
             format_string='%.3f')
 
         row += 1
@@ -219,7 +219,7 @@ class FiniteViewer(ttk.Frame):
             row=row,
             left_end=0.0,
             right_end=1.35,
-            update_function=self.widget.redraw_if_initialized,
+            update_function=self.widget.draw,
             format_string='%.3f')
 
         row += 1
@@ -231,7 +231,7 @@ class FiniteViewer(ttk.Frame):
             row=row,
             left_end=0.0,
             right_end=0.5,
-            update_function=self.widget.redraw_if_initialized)
+            update_function=self.widget.draw)
 
         return frame
 
@@ -251,7 +251,7 @@ class FiniteViewer(ttk.Frame):
             row=row,
             left_end=1,
             right_end=100,
-            update_function=self.widget.redraw_if_initialized)
+            update_function=self.widget.draw)
 
         row += 1
         UniformDictController.create_horizontal_scale(
@@ -262,7 +262,7 @@ class FiniteViewer(ttk.Frame):
             row=row,
             left_end=1.0,
             right_end=28.0,
-            update_function=self.widget.redraw_if_initialized)
+            update_function=self.widget.draw)
 
         row += 1
         UniformDictController.create_horizontal_scale(
@@ -273,7 +273,7 @@ class FiniteViewer(ttk.Frame):
             row=row,
             left_end=1.0,
             right_end=4.25,
-            update_function=self.widget.redraw_if_initialized)
+            update_function=self.widget.draw)
 
         return frame
 
@@ -295,7 +295,7 @@ class FiniteViewer(ttk.Frame):
                 row=row,
                 left_end=0.0,
                 right_end=0.25,
-                update_function=self.widget.redraw_if_initialized,
+                update_function=self.widget.draw,
                 format_string='%.3f')
             row += 1
 
@@ -307,7 +307,7 @@ class FiniteViewer(ttk.Frame):
             row=row,
             left_end=0.3,
             right_end=4.0,
-            update_function=self.widget.redraw_if_initialized)
+            update_function=self.widget.draw)
 
         row += 1
         UniformDictController.create_horizontal_scale(
@@ -318,7 +318,7 @@ class FiniteViewer(ttk.Frame):
             row=row,
             left_end=0.1,
             right_end=2.0,
-            update_function=self.widget.redraw_if_initialized)
+            update_function=self.widget.draw)
 
         row += 1
         UniformDictController.create_horizontal_scale(
@@ -329,7 +329,7 @@ class FiniteViewer(ttk.Frame):
             row=row,
             left_end=0.3,
             right_end=3.0,
-            update_function=self.widget.redraw_if_initialized)
+            update_function=self.widget.draw)
 
         return frame
 
@@ -364,7 +364,7 @@ class FiniteViewer(ttk.Frame):
             left_end=0.1,
             right_end=1.0)
 
-        label = ttk.Label(frame, text=u"Keys: \u2190\u2191\u2192\u2193xz")
+        label = ttk.Label(frame, text="Keys: \u2190\u2191\u2192\u2193xz")
         label.grid(row=row, column=3, sticky=tkinter.NSEW)
 
         row += 1
@@ -540,7 +540,7 @@ def _maximal_cusp_area(mfd):
 
 def _mouse_gestures_text():
     if sys.platform == 'darwin':
-        return u"Move: Click & Drag     Rotate: Shift-Click & Drag     Orbit: \u2318-Click & Drag"
+        return "Move: Click & Drag     Rotate: Shift-Click & Drag     Orbit: \u2318-Click & Drag"
     else:
         return "Move: Click & Drag     Rotate: Shift-Click & Drag     Orbit: Alt-Click & Drag"
 
@@ -578,7 +578,7 @@ class PerfTest:
         self.widget.view_state = self.widget.raytracing_data.update_view_state(
             self.widget.view_state, self.m)
 
-        self.widget.redraw_if_initialized()
+        self.widget.draw()
         self.widget.after(250, self.redraw)
 
 

snappy/raytracing/geodesic_tube_info.py

@@ -1,91 +1,121 @@
-from ..drilling import compute_geodesic_info
-from ..drilling.geodesic_tube import GeodesicTube
-from ..drilling.line import distance_r13_lines
+from ..tiling.iter_utils import IteratorCache
+from ..tiling.tile import Tile
+
+from ..hyperboloid.distances import distance_r13_lines
+
+from ..geometric_structure.geodesic.geodesic_start_point_info import compute_geodesic_start_point_info
+from ..geometric_structure.geodesic.tiles_for_geodesic import compute_tiles_for_geodesic
 
 from ..snap.t3mlite import simplex # type: ignore
 
+from typing import Sequence
+
+# Do not draw line segments of geodesic that are fully within a tube
+# about a core curve of this radius.
+avoid_core_curve_tube_radius = 0.1
+
+def tiles_up_to_core_curve(tiles : Sequence[Tile]) -> Sequence[Tile]:
+    """
+    Only develop tube until the radius is 98% of the distance to
+    a core curve
+    """
+
+    min_dist_to_core_curve = 1e50
+
+    for tile in tiles:
+        if (tile.lower_bound_distance > 0.0001 and
+            not tile.lower_bound_distance < min_dist_to_core_curve * 0.98):
+            break
+
+        for v in simplex.ZeroSubsimplices:
+            tet = tile.lifted_tetrahedron.tet
+            core_curve = tet.core_curves.get(v, None)
+            if core_curve is None:
+                continue
+
+            dist_to_core_curve = distance_r13_lines(
+                core_curve.r13_line, tile.inverse_lifted_geometric_object)
+
+            # We already drop the pieces that are too close to a core curve.
+            min_dist_to_core_curve = min(
+                min_dist_to_core_curve, dist_to_core_curve)
+
+        tile.dist_to_core_curve = min_dist_to_core_curve
+
+        yield tile
+
+class GeodesicLinePieces:
+    def __init__(self,
+                 tets_and_end_points,
+                 covered_radius,
+                 dist_to_core_curve):
+        self.tets_and_end_points = tets_and_end_points
+        self.covered_radius = covered_radius
+        self.dist_to_core_curve = dist_to_core_curve
 
 class GeodesicTubeInfo:
     def __init__(self, mcomplex, word, index, is_primitive=None):
         # Compute GeodesicTube
-        self.geodesic_info = compute_geodesic_info(mcomplex, word)
-
-        if not self.geodesic_info.core_curve_cusp:
-            self.geodesic_tube = GeodesicTube(mcomplex, self.geodesic_info)
+        self.geodesic_start_point_info = compute_geodesic_start_point_info(mcomplex, word)
+
+        for tet in mcomplex.Tetrahedra:
+            for v, core_curve in tet.core_curves.items():
+                tet.Class[v].core_curve_tube_radius = mcomplex.RF(avoid_core_curve_tube_radius)
+
+        if not self.geodesic_start_point_info.core_curve_cusp:
+            self.tiles = IteratorCache(
+                tiles_up_to_core_curve(
+                    compute_tiles_for_geodesic(
+                        mcomplex,
+                        self.geodesic_start_point_info,
+                        avoid_core_curves=True,
+                        for_raytracing=True)))
+            self._tiles_to_cover = []
 
         # Compute complex length from trace
-        t = self.geodesic_info.trace
+        t = self.geodesic_start_point_info.trace
         self.complex_length = _normalize_complex_length(2 * (t / 2).arccosh())
 
         self.words = [ word ]
         self.index = index
 
         RF = t.real().parent()
-        self.dist_to_core_curve = RF(1e50)
-
-        # Caches enough pieces so that we can compare tetrahedra.
-        self._pieces_covering_geodesic = []
 
         self._is_primitive = is_primitive
 
-    def compute_tets_and_R13_endpoints_and_radius_for_tube(self, radius):
-
-        # Only develop tube until the radius is 98% of the distance to
-        # a core curve
-        while True:
-            safe_radius = self.dist_to_core_curve * 0.98
-            if radius > safe_radius:
-                # Stop. Tube is about to intersect a core curve.
-                radius = safe_radius
-                break
-
-            if self.geodesic_tube.covered_radius() > radius:
-                # Done. We covered the tube.
-                break
-
-            self.geodesic_tube._add_next_piece()
-
-            # Get last piece. Compute distance of lifted geodesic to
-            # to core curves.
-            piece = self.geodesic_tube.pieces[-1]
-            for v in simplex.ZeroSubsimplices:
-                core_curve = piece.tet.core_curves.get(v, None)
-                if core_curve:
-                    d = distance_r13_lines(
-                        core_curve.r13_line,
-                        piece.lifted_geodesic)
-
-                    if d < self.dist_to_core_curve:
-                        self.dist_to_core_curve = d
+    def compute_line_pieces(self, radius) -> GeodesicLinePieces:
 
-        result = []
+        tets_and_end_points = []
 
-        for piece in self.geodesic_tube.pieces:
-            if piece.lower_bound > radius:
+        for tile in self.tiles:
+            if tile.lower_bound_distance > radius:
                 break
-            result.append(
-                (piece.tet.Index,
-                 [ piece.tet.to_coordinates_in_symmetric_tet * pt
-                   for pt in piece.lifted_geodesic.points] ))
+            tet = tile.lifted_tetrahedron.tet
+            tets_and_end_points.append(
+                (tet.Index,
+                 [ tet.to_coordinates_in_symmetric_tet * pt
+                   for pt in tile.inverse_lifted_geometric_object.points] ))
 
-        return result, radius
+        return GeodesicLinePieces(
+            tets_and_end_points,
+            tile.lower_bound_distance,
+            tile.dist_to_core_curve)
 
     def _get_pieces_covering_geodesic(self):
-        if not self._pieces_covering_geodesic:
-            self.geodesic_tube.add_pieces_for_radius(0)
-            for piece in self.geodesic_tube.pieces:
-                if piece.lower_bound > 0:
+        if not self._tiles_to_cover:
+            for tile in self.tiles:
+                if tile.lower_bound_distance > 0:
                     break
-                self._pieces_covering_geodesic.append(piece)
-        return self._pieces_covering_geodesic
+                self._tiles_to_cover.append(tile)
+        return self._tiles_to_cover
 
     def __eq__(self, other):
         diff = _normalize_complex_length(self.complex_length - other.complex_length)
         if not abs(diff) < 1e-3:
             return False
 
-        self_cusp = self.geodesic_info.core_curve_cusp
-        other_cusp = other.geodesic_info.core_curve_cusp
+        self_cusp = self.geodesic_start_point_info.core_curve_cusp
+        other_cusp = other.geodesic_start_point_info.core_curve_cusp
 
         if self_cusp or other_cusp:
             if self_cusp and other_cusp:
@@ -96,10 +126,10 @@ class GeodesicTubeInfo:
         # We should ask snappy.drilling for the two tetrahedra adjacent to
         # a face.
         piece = self._get_pieces_covering_geodesic()[0]
-        point = piece.lifted_geodesic.points[0]
+        point = piece.inverse_lifted_geometric_object.points[0]
         for other_piece in other._get_pieces_covering_geodesic():
-            if piece.tet == other_piece.tet:
-                for other_point in other_piece.lifted_geodesic.points:
+            if piece.lifted_tetrahedron.tet == other_piece.lifted_tetrahedron.tet:
+                for other_point in other_piece.inverse_lifted_geometric_object.points:
                     if _are_parallel_light_vectors(point, other_point, 1e-5):
                         return True
         return False
@@ -114,10 +144,10 @@ class GeodesicTubeInfo:
         for i, piece0 in enumerate(pieces):
             for j, piece1 in enumerate(pieces):
                 if i < j:
-                    if piece0.tet == piece1.tet:
+                    if piece0.lifted_tetrahedron.tet == piece1.lifted_tetrahedron.tet:
                         if _are_parallel_light_vectors(
-                                piece0.lifted_geodesic.points[0],
-                                piece1.lifted_geodesic.points[0],
+                                piece0.inverse_lifted_geometric_object.points[0],
+                                piece1.inverse_lifted_geometric_object.points[0],
                                 1e-5):
                             return False
         return True

snappy/raytracing/geodesics.py

@@ -1,21 +1,26 @@
-from .geodesic_tube_info import GeodesicTubeInfo
-from .upper_halfspace_utilities import *
-
-from ..drilling.geometric_structure import add_r13_geometry
-from ..drilling.geodesic_tube import add_structures_necessary_for_tube
+from .geodesic_tube_info import (GeodesicTubeInfo,
+                                 GeodesicLinePieces,
+                                 avoid_core_curve_tube_radius)
+from .pack import pack_tet_data
+from .upper_halfspace_utilities import add_coordinate_transform_to_mcomplex
+from .hyperboloid_utilities import O13_orthonormalise
+
+from ..geometric_structure import (add_r13_geometry,
+                                   add_filling_information)
+from ..geometric_structure.geodesic.add_core_curves import add_r13_core_curves
+from ..tiling.triangle import add_triangles_to_tetrahedra
 from ..snap.t3mlite import Mcomplex, simplex
-from ..upper_halfspace import pgl2c_to_o13, sl2c_inverse
+from ..matrix import make_matrix # type: ignore
 
+import traceback
 
 class LengthSpectrumError(RuntimeError):
     pass
 
-
 class Geodesics:
     def __init__(self, manifold, words):
         """
 
-        >>> from snappy import Manifold
         >>> M = Manifold("o9_00000")
         >>> g = Geodesics(M, ["b", "c"])
         >>> g.set_enables_and_radii_and_update([True, True], [0.3, 0.4])
@@ -40,11 +45,8 @@ class Geodesics:
         self.num_tetrahedra = manifold.num_tetrahedra()
         self.RF = manifold.tetrahedra_shapes('rect')[0].real().parent()
 
-        self.data_heads = []
-        self.data_tails = []
-        self.data_indices = []
-        self.data_radius_params = []
-        self.data_offsets = (self.num_tetrahedra + 1) * [ 0 ]
+        self._uniform_bindings = {}
+        self._num = 0
 
     def set_enables_and_radii_and_update(self, enables, radii):
 
@@ -56,58 +58,55 @@ class Geodesics:
         if not self.geodesic_tube_infos:
             return success
 
-        self.data_heads = []
-        self.data_tails = []
-        self.data_indices = []
-        self.data_radius_params = []
-        self.data_offsets = []
-
         tets_to_data = [ [] for i in range(self.num_tetrahedra) ]
 
+        a_radius = self.RF(avoid_core_curve_tube_radius)
+
         for i, (enable, radius, geodesic_tube) in enumerate(
                 zip(enables, radii, self.geodesic_tube_infos)):
             if enable:
                 radius = self.RF(radius)
 
-                tets_and_endpoints, safe_radius = (
-                    geodesic_tube.compute_tets_and_R13_endpoints_and_radius_for_tube(radius))
+                line_pieces : GeodesicLinePieces = (
+                    geodesic_tube.compute_line_pieces(radius))
 
-                if safe_radius < radius:
+                if (line_pieces.covered_radius < radius or
+                    line_pieces.dist_to_core_curve < radius or
+                    line_pieces.dist_to_core_curve < a_radius):
                     success = False
 
-                radius_param = safe_radius.cosh() ** 2 / 2
+                # A user can always force the tube to have this radius.
+                # Even though it might be incomplete at that point.
+                min_user_radius = 0.1
 
-                for tet, endpoints in tets_and_endpoints:
+                effective_radius = min(
+                    radius,
+                    max(line_pieces.covered_radius, self.RF(min_user_radius)))
+
+                radius_param = effective_radius.cosh() ** 2 / 2
+
+                for tet, (head, tail) in line_pieces.tets_and_end_points:
                     tets_to_data[tet].append(
-                        (endpoints, i, radius_param))
+                        {'Heads' : ('vec4', head),
+                         'Tails' : ('vec4', tail),
+                         'Index' : ('int', i),
+                         'TubeRadiusParam' : ('float', radius_param)})
 
-        for data in tets_to_data:
-            self.data_offsets.append(len(self.data_heads))
-            for (head, tail), i, radius_param in data:
-                self.data_heads.append(head)
-                self.data_tails.append(tail)
-                self.data_indices.append(i)
-                self.data_radius_params.append(radius_param)
-        self.data_offsets.append(len(self.data_heads))
+        self._uniform_bindings, self._num = pack_tet_data(
+            'geodesics.geodesic', tets_to_data)
 
         return success
 
     def get_uniform_bindings(self):
-        return {
-            'geodesics.geodesicHeads' : ('vec4[]', self.data_heads),
-            'geodesics.geodesicTails' : ('vec4[]', self.data_tails),
-            'geodesics.geodesicIndex' : ('int[]', self.data_indices),
-            'geodesics.geodesicTubeRadiusParam' : ('float[]', self.data_radius_params),
-            'geodesics.geodesicOffsets' : ('int[]', self.data_offsets) }
-
-    def get_compile_time_constants(self):
-        if self.data_heads:
-            num = max(100, len(self.data_heads))
+        return self._uniform_bindings
+
+    def get_compile_time_defs(self):
+        if self._num > 0:
+            num = max(100, self._num)
         else:
             num = 0
 
-        return {
-            b'##num_geodesic_segments##' : num }
+        return { 'num_geodesic_segments' : num }
 
     def add_length_spectrum(self, l):
 
@@ -125,8 +124,8 @@ class Geodesics:
             try:
                 self.add_word(g['word'], is_primitive=True)
             except Exception as e:
-                print(dict(g))
-                print(e)
+                traceback.print_exc()
+                print("Geodesic is ", dict(g))
                 exception = e
 
         if exception:
@@ -158,21 +157,57 @@ class Geodesics:
     def get_mcomplex(self):
         if self.mcomplex is None:
             self.mcomplex = Mcomplex(self.manifold)
-            add_r13_geometry(self.mcomplex,
-                             self.manifold)
-            add_structures_necessary_for_tube(self.mcomplex)
-
-            for tet in self.mcomplex.Tetrahedra:
-                z = tet.ShapeParameters[simplex.E01]
-                vert0 = [ tet.ideal_vertices[v]
-                          for v in simplex.ZeroSubsimplices[:3]]
-                vert1 = symmetric_vertices_for_tetrahedron(z)[:3]
-                tet.to_coordinates_in_symmetric_tet = (
-                    o13_matrix_taking_ideal_vertices_to_ideal_vertices(
-                        vert0, vert1))
+            add_r13_geometry(
+                self.mcomplex, self.manifold)
+            add_filling_information(
+                self.mcomplex, self.manifold)
+            add_r13_core_curves(
+                self.mcomplex, self.manifold)
+            add_triangles_to_tetrahedra(self.mcomplex)
+            add_coordinate_transform_to_mcomplex(self.mcomplex)
 
         return self.mcomplex
 
+    def view_state_for_geodesic(self, index):
+        geodesic_start_point_info = self.geodesic_tube_infos[index].geodesic_start_point_info
+        p0, p1 = geodesic_start_point_info.line.r13_line.points
+
+        ring = p0[0].parent()
+
+        # Rotate the camera so that it is looking down the x-Axis
+        r = make_matrix([[1, 0, 0, 0],
+                         [0, 0, 0, 1],
+                         [0, 1, 0, 0],
+                         [0, 0, 1, 0]],
+                        ring=ring)
+
+        # Create a transform that takes the origin to a point on the
+        # geodesic and takes the tangent vector at the origin parallel
+        # to the x-Axis to a vector tangent to the geodesic.
+        #
+        # Note that the orthonormalisation processes the columns from left
+        # to right. This is exactly what we want.
+        #
+        g = O13_orthonormalise(
+            make_matrix(
+                [ p0 + p1,        # (Projective) point on the geodesic.
+                                  # Orthonormalisation just normalizes it
+                                  # so that it is on the hyperboloid.
+                  p0 - p1,        # Direction of geodesic.
+                                  # Orthonormalisation just projects it into
+                                  # the tangent space of the hyperboloid
+                                  # at the above point and normalizes it.
+                  [ 0, 1, 0, 0],  # Some other vectors so that
+                  [ 0, 0, 1, 0]], # orthonormalisation produces a camera frame.
+                ring=ring).transpose())
+
+        # Change coordinate system used for computation of geodesics
+        # to the one used by the raytracing code.
+        tet_index = 0
+        tet = self.get_mcomplex().Tetrahedra[tet_index]
+        c = tet.to_coordinates_in_symmetric_tet
+
+        return c * g * r, tet_index, 0.0
 
 def compute_geodesic_tube_info_key(geodesic_tube_info):
     l = geodesic_tube_info.complex_length
@@ -209,8 +244,3 @@ def geodesic_index_to_color(i):
     return hsv2rgb(golden_angle_by_2_pi * i + 0.1, 1.0, 1.0)
 
 
-def o13_matrix_taking_ideal_vertices_to_ideal_vertices(verts0, verts1):
-    m1 = pgl2_matrix_taking_0_1_inf_to_given_points(*verts0)
-    m2 = pgl2_matrix_taking_0_1_inf_to_given_points(*verts1)
-
-    return pgl2c_to_o13(m2 * sl2c_inverse(m1))