snappy 3.2__cp313-cp313-macosx_11_0_arm64.whl

snappy/raytracing/geodesic_tube_info.py

@@ -0,0 +1,174 @@
+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_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_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._is_primitive = is_primitive
+
+    def compute_line_pieces(self, radius) -> GeodesicLinePieces:
+
+        tets_and_end_points = []
+
+        for tile in self.tiles:
+            if tile.lower_bound_distance > radius:
+                break
+            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 GeodesicLinePieces(
+            tets_and_end_points,
+            tile.lower_bound_distance,
+            tile.dist_to_core_curve)
+
+    def _get_pieces_covering_geodesic(self):
+        if not self._tiles_to_cover:
+            for tile in self.tiles:
+                if tile.lower_bound_distance > 0:
+                    break
+                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_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:
+                return self_cusp.Index == other_cusp.Index
+            return False
+
+        # What if we have a geodesic in the 2-skeleton.
+        # We should ask snappy.drilling for the two tetrahedra adjacent to
+        # a face.
+        piece = self._get_pieces_covering_geodesic()[0]
+        point = piece.inverse_lifted_geometric_object.points[0]
+        for other_piece in other._get_pieces_covering_geodesic():
+            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
+
+    def is_primitive(self):
+        if self._is_primitive is None:
+            self._is_primitive = self._is_primitive_uncached()
+        return self._is_primitive
+
+    def _is_primitive_uncached(self):
+        pieces = self._get_pieces_covering_geodesic()
+        for i, piece0 in enumerate(pieces):
+            for j, piece1 in enumerate(pieces):
+                if i < j:
+                    if piece0.lifted_tetrahedron.tet == piece1.lifted_tetrahedron.tet:
+                        if _are_parallel_light_vectors(
+                                piece0.inverse_lifted_geometric_object.points[0],
+                                piece1.inverse_lifted_geometric_object.points[0],
+                                1e-5):
+                            return False
+        return True
+
+
+def _normalize_complex_length(z):
+    imag = z.imag()
+
+    CF = z.parent()
+    RF = imag.parent()
+
+    two_pi = RF("6.283185307179586476925286766559005768394338798750")
+    I = CF("I")
+
+    n = (imag / two_pi - RF("0.00000001")).round()
+
+    return z - n * two_pi * I
+
+
+def _are_parallel_light_vectors(a, b, epsilon):
+    for i in range(1, 4):
+        if not abs(a[i]/a[0]-b[i]/b[0]) < epsilon:
+            return False
+    return True

snappy/raytracing/geodesics.py

@@ -0,0 +1,246 @@
+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 ..matrix import make_matrix # type: ignore
+
+import traceback
+
+class LengthSpectrumError(RuntimeError):
+    pass
+
+class Geodesics:
+    def __init__(self, manifold, words):
+        """
+
+        >>> M = Manifold("o9_00000")
+        >>> g = Geodesics(M, ["b", "c"])
+        >>> g.set_enables_and_radii_and_update([True, True], [0.3, 0.4])
+        True
+        >>> b = g.get_uniform_bindings()
+        >>> len(b['geodesics.geodesicHeads'][1])
+        31
+        >>> len(b['geodesics.geodesicOffsets'][1])
+        10
+        """
+
+        self.manifold = manifold
+        self.mcomplex = None
+
+        self.geodesic_tube_infos = [
+            GeodesicTubeInfo(
+                self.get_mcomplex(),
+                word,
+                index)
+            for index, word in enumerate(words) ]
+
+        self.num_tetrahedra = manifold.num_tetrahedra()
+        self.RF = manifold.tetrahedra_shapes('rect')[0].real().parent()
+
+        self._uniform_bindings = {}
+        self._num = 0
+
+    def set_enables_and_radii_and_update(self, enables, radii):
+
+        # Returns false when a tube was so big that it was intersecting
+        # a core curve and it had to be shrunk.
+
+        success = True
+
+        if not self.geodesic_tube_infos:
+            return success
+
+        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)
+
+                line_pieces : GeodesicLinePieces = (
+                    geodesic_tube.compute_line_pieces(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
+
+                # 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
+
+                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(
+                        {'Heads' : ('vec4', head),
+                         'Tails' : ('vec4', tail),
+                         'Index' : ('int', i),
+                         'TubeRadiusParam' : ('float', radius_param)})
+
+        self._uniform_bindings, self._num = pack_tet_data(
+            'geodesics.geodesic', tets_to_data)
+
+        return success
+
+    def get_uniform_bindings(self):
+        return self._uniform_bindings
+
+    def get_compile_time_defs(self):
+        if self._num > 0:
+            num = max(100, self._num)
+        else:
+            num = 0
+
+        return { 'num_geodesic_segments' : num }
+
+    def add_length_spectrum(self, l):
+
+        try:
+            L = self.manifold.length_spectrum(
+                l, grouped=False, include_words=True)
+        except RuntimeError as e:
+            raise LengthSpectrumError(*e.args) from e
+
+        exception = None
+
+        num_original = len(self.geodesic_tube_infos)
+
+        for g in L:
+            try:
+                self.add_word(g['word'], is_primitive=True)
+            except Exception as e:
+                traceback.print_exc()
+                print("Geodesic is ", dict(g))
+                exception = e
+
+        if exception:
+            raise exception
+
+        return len(self.geodesic_tube_infos) > num_original
+
+    def add_word(self, word, is_primitive=None):
+        geodesic_tube_info = GeodesicTubeInfo(
+            self.get_mcomplex(),
+            word,
+            index=len(self.geodesic_tube_infos),
+            is_primitive=is_primitive)
+
+        for i, other in enumerate(self.geodesic_tube_infos):
+            if other == geodesic_tube_info:
+                if word not in other.words:
+                    other.words.append(word)
+                return i
+
+        self.geodesic_tube_infos.append(geodesic_tube_info)
+
+        return len(self.geodesic_tube_infos) - 1
+
+    def geodesics_sorted_by_length(self):
+        return sorted(self.geodesic_tube_infos,
+                      key=compute_geodesic_tube_info_key)
+
+    def get_mcomplex(self):
+        if self.mcomplex is None:
+            self.mcomplex = Mcomplex(self.manifold)
+            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
+
+    return (int(l.real() * 1e5),
+            int(abs(l.imag() * 1e5)), # Pair complex conjugate lengths
+            l.imag() > 1e-5, # Making the one with negative imag part first
+            geodesic_tube_info.index)
+
+
+def _hsv2rgb_helper(hue, saturation, value, x):
+    p = abs(((hue + x / 3.0) % 1.0) * 6.0 - 3.0)
+    c = min(max(p - 1.0, 0.0), 1.0)
+    return value * (1.0 + saturation * (c - 1.0))
+
+
+def hsv2rgb(hue, saturation, value):
+    """
+    Reimplementation of hsv2rgb from fragment.glsl.
+    """
+
+    return [ _hsv2rgb_helper(hue, saturation, value, x)
+             for x in [ 0.0, 2.0, 1.0 ] ]
+
+
+def geodesic_index_to_color(i):
+    """
+    Reimplementation of object_type_geodesic_tube case of
+    material_params from fragment.glsl.
+    """
+
+    golden_angle_by_2_pi = 0.3819660112501051
+
+    return hsv2rgb(golden_angle_by_2_pi * i + 0.1, 1.0, 1.0)
+
+

snappy/raytracing/geodesics_window.py

@@ -0,0 +1,258 @@
+import sys
+import tkinter
+from tkinter import ttk
+
+from .gui_utilities import UniformDictController, ScrollableFrame
+from .tooltip import ToolTip
+from .geodesics import geodesic_index_to_color, LengthSpectrumError
+from ..geometric_structure.geodesic.exceptions import WordAppearsToBeParabolic
+from ..SnapPy import word_as_list # type: ignore
+
+
+class GeodesicsWindow(tkinter.Toplevel):
+    checkbox_column = 0
+    color_column = 1
+    words_column = 2
+    length_column = 3
+    radius_column = 5
+    view_column = 7
+
+    headings = (
+        # (text, column, weight, span)
+        ('Show', checkbox_column, 0, 1),
+        ('Color', color_column, 0, 1),
+        ('Word(s)', words_column, 0, 1),
+        ('Complex length', length_column, 0, 2),
+        ('Radius', radius_column, 0, 1),
+        ('    ', 6, 0, 1),
+        ('View', view_column, 0, 1))
+
+    def __init__(self, inside_viewer, *args, **kwards):
+        # Disable the minimize button when we get to use Tk 8.7
+        tkinter.Toplevel.__init__(self, class_='snappy')
+        if sys.platform == 'darwin' and tkinter.TkVersion > 8.6:
+            self.wm_attributes('-stylemask', ('titled', 'closable'))
+        self.title('Geodesics in %s' % inside_viewer.widget.manifold)
+
+        self.inside_viewer = inside_viewer
+        self.raytracing_view = inside_viewer.widget
+
+        self.frame = ttk.Frame(self)
+        self.frame.pack(expand=True, fill=tkinter.BOTH)
+        self.frame.columnconfigure(0, weight=1)
+
+        top_frame = ttk.Frame(self.frame)
+        top_frame.pack()
+
+        left_top_frame = ttk.Frame(top_frame)
+        left_top_frame.pack(side=tkinter.LEFT, padx=20)
+
+        self.length_var = tkinter.StringVar(value=1.1)
+
+        self.length_box = ttk.Spinbox(
+            left_top_frame,
+            from_=0.2, to=20.0, increment=0.2,
+            textvariable=self.length_var,
+            width=4)
+        self.length_box.grid(row=0, column=0)
+        self.length_box.bind('<Return>', self.add_length_spectrum)
+        self.length_box.focus_set()
+
+        self.length_button = ttk.Button(
+            left_top_frame,
+            text="Add up to length",
+            command=self.add_length_spectrum)
+        self.length_button.grid(row=0, column=1)
+
+        right_top_frame = ttk.Frame(top_frame)
+        right_top_frame.pack(side=tkinter.LEFT, padx=20)
+
+        self.word_entry = ttk.Entry(right_top_frame)
+        self.word_entry.grid(row=0, column=0)
+        self.word_entry.bind('<Return>', self.add_word)
+        self.word_button = ttk.Button(
+            right_top_frame, text="Add word", command=self.add_word)
+        self.word_button.grid(row=0, column=1)
+
+        self.status_label = ttk.Label(
+            self.frame, text=_default_status_msg)
+        self.status_label.pack()
+
+        self.scrollable_frame = ScrollableFrame(self.frame)
+        self.scrollable_frame.pack(fill="y", anchor="n", expand=True)
+
+        self.geodesics_frame = self.scrollable_frame.scrollable_frame
+        self.populate_geodesics_frame()
+        self.scrollable_frame.headings(self.headings)
+
+    def _geodesics(self):
+        return self.raytracing_view.additional_structures['geodesics']
+
+    def populate_geodesics_frame(self):
+        for widget in self.geodesics_frame.grid_slaves():
+            widget.destroy()
+
+        row = 0
+
+        for geodesic in self._geodesics().geodesics_sorted_by_length():
+            if not geodesic.geodesic_start_point_info.core_curve_cusp:
+                UniformDictController.create_checkbox(
+                    self.geodesics_frame,
+                    self.raytracing_view.ui_parameter_dict,
+                    key='geodesicTubeEnables',
+                    index=geodesic.index,
+                    row=row,
+                    column=self.checkbox_column,
+                    update_function=self.geodesic_checkbox_clicked)
+
+            text = ', '.join(geodesic.words)
+            if not geodesic.is_primitive():
+                text += ' (not primitive)'
+
+            l = ttk.Label(self.geodesics_frame, text=text)
+            l.grid(row=row, column=self.words_column)
+
+            l = ttk.Label(self.geodesics_frame,
+                          text='%.8f' % geodesic.complex_length.real())
+            l.grid(row=row, column=self.length_column)
+
+            im_length = geodesic.complex_length.imag()
+            abs_im_length = im_length.abs()
+
+            if abs_im_length > 1e-10:
+                s = '+' if im_length > 0 else '-'
+
+                l = ttk.Label(self.geodesics_frame,
+                              text=s + ' %.8f * I' % abs_im_length)
+                l.grid(row=row, column=self.length_column + 1)
+
+            color = geodesic_index_to_color(geodesic.index)
+
+            if geodesic.geodesic_start_point_info.core_curve_cusp:
+                cusp_index = geodesic.geodesic_start_point_info.core_curve_cusp.Index
+                l = tkinter.Label(self.geodesics_frame,
+                                  text="Cusp %d" % cusp_index)
+            else:
+                l = tkinter.Label(self.geodesics_frame,
+                                  text="Color",
+                                  fg=color_to_tkinter(color),
+                                  bg=color_to_tkinter(color))
+            l.grid(row=row, column=self.color_column, padx=5)
+
+            if geodesic.geodesic_start_point_info.core_curve_cusp:
+                l = tkinter.Label(self.geodesics_frame,
+                                  text="Use Cusp areas tab")
+                l.grid(row=row, column=self.radius_column, padx=5)
+            else:
+                scale = UniformDictController.create_horizontal_scale(
+                    self.geodesics_frame,
+                    self.raytracing_view.ui_parameter_dict,
+                    key='geodesicTubeRadii',
+                    index=geodesic.index,
+                    row=row,
+                    column=self.radius_column,
+                    left_end=0.0,
+                    right_end=1.0,
+                    update_function=self.update_geodesic_data,
+                    format_string='%.3f')
+
+                # Need to color Scale - but the following code fails.
+                # scale.configure(background = color_to_tkinter(color))
+
+            if not geodesic.geodesic_start_point_info.core_curve_cusp:
+                btn = ttk.Button(
+                    self.geodesics_frame,
+                    text='View',
+                    takefocus=0,
+                    command=lambda i=geodesic.index: self.view_geodesic(i))
+                ToolTip(btn,
+                        msg="Move camera onto geodesic looking down the geodesic")
+                btn.grid(row=row, column=self.view_column)
+
+            row += 1
+        self.scrollable_frame.set_widths()
+
+    def update_geodesic_data(self):
+        success = self.raytracing_view.update_geodesic_data_and_redraw()
+        if success:
+            self.status_label.configure(text=_default_status_msg,
+                                        foreground='')
+        else:
+            self.status_label.configure(
+                text=('Geodesic tube intersects core curve. Dropping '
+                      'pieces/limiting size.'),
+                foreground='red')
+
+    def add_length_spectrum(self, *args, **kwargs):
+        self.status_label.configure(text=_default_status_msg, foreground='')
+
+        try:
+            if not self._geodesics().add_length_spectrum(
+                    float(self.length_box.get())):
+                self.status_label.configure(text='No new geodesics found.',
+                                            foreground='')
+        except LengthSpectrumError as e:
+            self.status_label.configure(
+                text=' '.join(e.args), foreground='red')
+            return
+        except Exception as e:
+            self.status_label.configure(
+                text='An error has occurred. See terminal for details.',
+                foreground='red')
+
+        self.raytracing_view.resize_geodesic_params()
+
+        self.populate_geodesics_frame()
+
+    def add_word(self, *args, **kwargs):
+        word = self.word_entry.get()
+
+        if len(word) == 0:
+            self.status_label.configure(text="Word is empty",
+                                        foreground='red')
+            return
+
+        try:
+            n = self._geodesics().get_mcomplex().num_generators
+            word_as_list(word, n)
+        except ValueError:
+            self.status_label.configure(text=word + " contains non-generators",
+                                        foreground='red')
+            return
+
+        try:
+            index = self._geodesics().add_word(word)
+        except WordAppearsToBeParabolic:
+            self.status_label.configure(text=word + " is parabolic",
+                                        foreground='red')
+            return
+
+        self.status_label.configure(text=_default_status_msg,
+                                    foreground='')
+
+        self.raytracing_view.resize_geodesic_params()
+        self.raytracing_view.enable_geodesic(index)
+        if self.raytracing_view.disable_edges_for_geodesics():
+            self.inside_viewer.update_edge_and_insphere_controllers()
+
+        self.update_geodesic_data()
+
+        self.populate_geodesics_frame()
+
+    def geodesic_checkbox_clicked(self):
+        if self.raytracing_view.disable_edges_for_geodesics():
+            self.inside_viewer.update_edge_and_insphere_controllers()
+        self.update_geodesic_data()
+
+    def view_geodesic(self, i):
+        self.raytracing_view.view_state = (
+            self.raytracing_view.raytracing_data.update_view_state(
+                self._geodesics().view_state_for_geodesic(i)))
+        self.inside_viewer.set_perspective_type_and_view_scale(1, 1.0)
+
+def color_to_tkinter(color):
+    return "#%.3x%.3x%.3x" % tuple([min(max(int(x * 4095), 0), 4095)
+                                    for x in color])
+
+
+_default_status_msg = "Words are in unsimplified fundamental group Manifold.fundamental_group(False)"