snappy 3.2__cp313-cp313-macosx_11_0_arm64.whl

snappy/raytracing/test.py

@@ -0,0 +1,29 @@
+from snappy import testing
+import snappy
+
+from snappy import raytracing
+import snappy.raytracing.geodesic_tube_info
+import snappy.raytracing.geodesics
+import snappy.raytracing.ideal_raytracing_data
+import snappy.raytracing.upper_halfspace_utilities
+
+modules = [
+    raytracing.cohomology_fractal,
+    raytracing.geodesic_tube_info,
+    raytracing.geodesics,
+    raytracing.ideal_raytracing_data,
+    raytracing.upper_halfspace_utilities
+]
+
+def run_doctests(verbose=False, print_info=True):
+    globs = {'Manifold'  : snappy.Manifold,
+             'ManifoldHP': snappy.ManifoldHP}
+    return testing.doctest_modules(modules,
+                                   verbose=verbose,
+                                   print_info=print_info,
+                                   extraglobs=globs)
+
+run_doctests.__name__ = raytracing.__name__
+
+if __name__ == '__main__':
+    testing.run_doctests_as_main(run_doctests)

snappy/raytracing/tooltip.py

@@ -0,0 +1,146 @@
+"""
+Module defining the ToolTip widget
+
+From https://github.com/gnikit/tkinter-tooltip
+"""
+
+import time
+import tkinter as tk
+from typing import Callable
+
+# This code is based on Tucker Beck's implementation licensed under an MIT License
+# Original code: http://code.activestate.com/recipes/576688-tooltip-for-tkinter/
+
+
+class ToolTip(tk.Toplevel):
+    """
+    Creates a ToolTip (pop-up) widget for tkinter
+    """
+
+    def __init__(
+        self,
+        widget: tk.Widget,
+        msg = None, # : str | Callable
+        delay: float = 1.0,
+        follow: bool = True,
+        refresh: float = 1.0,
+        x_offset: int = +10,
+        y_offset: int = +10,
+        parent_kwargs: dict = {"bg": "black", "padx": 1, "pady": 1},
+        **message_kwargs,
+    ):
+        """Create a ToolTip. Allows for `**kwargs` to be passed on both
+            the parent frame and the ToolTip message
+
+        Parameters
+        ----------
+        widget : tk.Widget
+            The widget this ToolTip is assigned to
+        msg : `Union[str, Callable]`, optional
+            A string message (can be dynamic) assigned to the ToolTip.
+            Alternatively, it can be set to a function thatreturns a string,
+            by default None
+        delay : `float`, optional
+            Delay in seconds before the ToolTip appears, by default 0.0
+        follow : `bool`, optional
+            ToolTip follows motion, otherwise hides, by default True
+        refresh : `float`, optional
+            Refresh rate in seconds for strings and functions when mouse is
+            stationary and inside the widget, by default 1.0
+        x_offset : `int`, optional
+            x-coordinate offset for the ToolTip, by default +10
+        y_offset : `int`, optional
+            y-coordinate offset for the ToolTip, by default +10
+        parent_kwargs : `dict`, optional
+            Optional kwargs to be passed into the parent frame,
+            by default `{"bg": "black", "padx": 1, "pady": 1}`
+        **message_kwargs : tkinter `**kwargs` passed directly into the ToolTip
+        """
+        self.widget = widget
+        # ToolTip should have the same parent as the widget unless stated
+        # otherwise in the `parent_kwargs`
+        tk.Toplevel.__init__(self, **parent_kwargs)
+        self.withdraw()  # Hide initially in case there is a delay
+        # Disable ToolTip's title bar
+        self.overrideredirect(True)
+
+        # StringVar instance for msg string|function
+        self.msgVar = tk.StringVar()
+        # This can be a string or a function
+        # Do not bother doing any sort of checks here since it sometimes results
+        # into multiple spawn-hide calls being made when swapping between tooltips
+        self.msg = msg
+        self.delay = delay
+        self.follow = follow
+        self.refresh = refresh
+        self.x_offset = x_offset
+        self.y_offset = y_offset
+        # visibility status of the ToolTip inside|outside|visible
+        self.status = "outside"
+        self.last_moved = 0
+        # use Message widget to host ToolTip
+        tk.Message(self, textvariable=self.msgVar, aspect=1000, **message_kwargs).grid()
+        # Add bindings to the widget without overriding the existing ones
+        self.widget.bind("<Enter>", self.on_enter, add="+")
+        self.widget.bind("<Leave>", self.on_leave, add="+")
+        self.widget.bind("<Motion>", self.on_enter, add="+")
+        self.widget.bind("<ButtonPress>", self.on_leave, add="+")
+
+    def on_enter(self, event) -> None:
+        """
+        Processes motion within the widget including entering and moving.
+        """
+        self.last_moved = time.time()
+
+        # Set the status as inside for the very first time
+        if self.status == "outside":
+            self.status = "inside"
+
+        # If the follow flag is not set, motion within the widget will
+        # make the ToolTip disappear
+        if not self.follow:
+            self.status = "inside"
+            self.withdraw()
+
+        # Offsets the ToolTip using the coordinates od an event as an origin
+        self.geometry(f"+{event.x_root + self.x_offset}+{event.y_root + self.y_offset}")
+
+        # Time is integer and in milliseconds
+        self.after(int(self.delay * 1000), self._show)
+
+    def on_leave(self, event=None) -> None:
+        """
+        Hides the ToolTip.
+        """
+        self.status = "outside"
+        self.withdraw()
+
+    def _show(self) -> None:
+        """
+        Displays the ToolTip.
+
+        Recursively queues `_show` in the scheduler every `self.refresh` seconds
+        """
+        if self.status == "inside" and time.time() - self.last_moved > self.delay:
+            self.status = "visible"
+
+        if self.status == "visible":
+            # Update the string with the latest function call
+            # Try and call self.msg as a function, if msg is not callable try and
+            # set it as a normal string if that fails throw an error
+            try:
+                self.msgVar.set(self.msg())
+            except TypeError:
+                # Intentionally do not check if msg is str, can be a list of str
+                self.msgVar.set(self.msg)
+            except:
+                raise (
+                    "Error: ToolTip `msg` must be a string or string returning "
+                    + f"function instead `msg` of type {type(self.msg)} was input"
+                )
+            self.deiconify()
+
+            # Recursively call _show to update ToolTip with the newest value of msg
+            # This is a race condition which only exits when upon a binding change
+            # that in turn changes the `status` to outside
+            self.after(int(self.refresh * 1000), self._show)

snappy/raytracing/upper_halfspace_utilities.py

@@ -0,0 +1,98 @@
+from ..matrix import make_matrix
+from ..upper_halfspace.ideal_point import Infinity
+from ..upper_halfspace import pgl2c_to_o13, sl2c_inverse
+
+from ..snap.t3mlite import simplex
+from ..snap.t3mlite import Mcomplex
+
+def symmetric_vertices_for_tetrahedron(z):
+    """
+    Given a tetrahedron shape, returns four (ideal) points spanning
+    a tetrahedron of that shape.
+
+    The points are in C subset C union { Infinity } regarded as
+    boundary of the upper half space model.
+
+    Duplicates initial_tetrahedron(... centroid_at_origin = true)
+    in choose_generators.c.
+    """
+
+    w = z.sqrt() + (z - 1).sqrt()
+    return [ w, 1/w, -1/w, -w ]
+
+
+def pgl2_matrix_taking_0_1_inf_to_given_points(z0, z1, zinf):
+    if z0 == Infinity:
+        CF = z1.parent()
+        m = zinf - z1
+        return make_matrix([[ -zinf, m ],
+                            [ -1, 0 ]], ring=CF)
+
+    if z1 == Infinity:
+        CF = zinf.parent()
+        return make_matrix([[ -zinf, z0 ],
+                            [ -1, 1  ]], ring=CF)
+
+    if zinf == Infinity:
+        CF = z0.parent()
+        l = z0 - z1
+        return make_matrix([[ -l, z0 ],
+                            [  0, 1  ]], ring=CF)
+
+    l = z0 - z1
+    m = zinf - z1
+
+    return make_matrix([[ -l * zinf, m * z0 ],
+                        [ -l, m      ]])
+
+
+def are_sl_matrices_close(m1, m2, epsilon=1e-5):
+    """
+    Compute whether two matrices are the same up to given epsilon.
+    """
+
+    for i in range(2):
+        for j in range(2):
+            if abs(m1[i,j] - m2[i,j]) > epsilon:
+                return False
+    return True
+
+
+def are_psl_matrices_close(m1, m2, epsilon=1e-5):
+    """
+    Compute whether two matrices are the same up to given epsilon
+    and multiplying by -Identity.
+    """
+    return (
+        are_sl_matrices_close(m1, m2, epsilon) or
+        are_sl_matrices_close(m1, -m2, epsilon))
+
+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))
+
+def add_coordinate_transform_to_mcomplex(mcomplex : Mcomplex):
+    """
+    Most places in SnapPy/SnapPea kernel develop the tetrahedra
+    so that they form a fundamental domain - so that pairing
+    matrices are the identity for faces that are internal to the
+    fundamental domain.
+
+    However, for the raytracing shader, we pick the vertices of each
+    tetrahedron so that the center is at the origin.
+
+    Compute the matrix that can take structures in the coordinate
+    system native to SnapPy/SnapPea kernel to the coordinate system
+    used by the raytracing shader.
+
+    """
+    for tet in 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))

snappy/raytracing/view_scale_controller.py

@@ -0,0 +1,98 @@
+import math
+
+_parameter_interval = [
+    (20.0,120.0),    # material: field of view
+    (-2.5,2.5),      # ideal: log of scale
+    None ]           # hyperideal
+
+_scale_function = [
+    lambda parameter: math.tan(parameter / 360.0 * math.pi),
+    lambda parameter: math.exp(parameter),
+    None ]
+
+_inverse_scale_function = [
+    lambda scale: math.atan(scale) * 360.0 / math.pi,
+    lambda scale: math.log(scale),
+    None ]
+
+
+class ViewScaleController:
+    def __init__(self,
+                 uniform_dict,
+                 scale,
+                 label0,
+                 label1,
+                 update_function):
+        self.uniform_dict = uniform_dict
+        self.scale = scale
+        self.label0 = label0
+        self.label1 = label1
+        self.update_function = update_function
+
+        self.update()
+
+        self.scale.set_callback(self.scale_command)
+
+    def scale_command(self, value):
+        perspective_type = self.uniform_dict['perspectiveType'][1]
+        parameter_interval = _parameter_interval[perspective_type]
+        if not parameter_interval:
+            return
+
+        parameter = _linear_remap(
+            value,
+            (self.scale.left_end, self.scale.right_end),
+            parameter_interval)
+
+        self.uniform_dict['viewScale'][1] = float(
+            _scale_function[perspective_type](parameter))
+        self.update_label()
+        self.update_function()
+
+    def update_label(self):
+        perspective_type = self.uniform_dict['perspectiveType'][1]
+
+        if perspective_type == 0:
+            view_scale = self.uniform_dict['viewScale'][1]
+            fov = _inverse_scale_function[perspective_type](view_scale)
+            self.label0.configure(text='FOV:')
+            self.label1.configure(text='%.1f' % fov)
+        elif perspective_type == 1:
+            view_scale = self.uniform_dict['viewScale'][1]
+            self.label0.configure(text='Euclidean length:')
+            if view_scale > 1.0:
+                self.label1.configure(text='%.1f' % view_scale)
+            elif view_scale > 0.1:
+                self.label1.configure(text='%.2f' % view_scale)
+            else:
+                self.label1.configure(text='%.3f' % view_scale)
+        else:
+            self.label0.configure(text='')
+            self.label1.configure(text='')
+
+    def update_scale(self):
+        perspective_type = self.uniform_dict['perspectiveType'][1]
+        parameter_interval = _parameter_interval[perspective_type]
+        if not parameter_interval:
+            self.scale.state(("disabled",))
+            return
+
+        self.scale.state(("!disabled",))
+        view_scale = self.uniform_dict['viewScale'][1]
+        parameter = _inverse_scale_function[perspective_type](view_scale)
+
+        self.scale.set_value(
+            _linear_remap(
+                parameter,
+                parameter_interval,
+                (self.scale.left_end, self.scale.right_end)))
+
+    def update(self):
+        self.update_label()
+        self.update_scale()
+
+
+def _linear_remap(v, src_interval, dst_interval):
+    l0, r0 = src_interval
+    l1, r1 = dst_interval
+    return l1 + (r1 - l1) / (r0 - l0) * (v - l0)

snappy/raytracing/zoom_slider/__init__.py

@@ -0,0 +1,263 @@
+import sys
+import os
+import tkinter as tk
+from tkinter import ttk
+
+if sys.platform == 'linux':
+    label_pad = (4, 0)
+else:
+    label_pad = 0
+
+
+class Slider(ttk.Scale):
+    _slider_left_end = 1.0
+    _slider_right_end = 100.0
+
+    """
+    Subclass of ttk.Scale which makes clicking on the track cause the
+    knob to move to the click point.
+    """
+    def __init__(self, container, left_end, right_end,
+                 orient=tk.HORIZONTAL):
+        ttk.Scale.__init__(self,
+                           master=container,
+                           from_=self._slider_left_end,
+                           to=self._slider_right_end,
+                           value=2.0,
+                           orient=orient,
+                           takefocus=0)
+        self.left_end = left_end
+        self.right_end = right_end
+        self.orient = orient
+        self.callback = None
+        self.configure(command=self._command)
+        self.bind('<Button-1>', self._handle_mouse)
+
+    def set_callback(self, callback):
+        self.callback = callback
+
+    def set_value(self, value):
+        length = self.right_end - self.left_end
+        slider_length = self._slider_right_end - self._slider_left_end
+        v = (value - self.left_end) / length
+        slider_value = v * slider_length + self._slider_left_end
+        self.configure(value=slider_value)
+
+    def _command(self, slider_value):
+        if self.callback:
+            length = self.right_end - self.left_end
+            slider_length = self._slider_right_end - self._slider_left_end
+            v = (float(slider_value) - self._slider_left_end) / slider_length
+            value = v * length + self.left_end
+
+            self.callback(value)
+
+    def _handle_mouse(self, event):
+        """
+        Override the standard mouse event handler which moves the knob
+        by 1.0, regardless of the size of the range, when the mouse
+        click is in the trough.  This implements the standard behavior
+        -- moving the knob to the click point.
+        """
+        part = self.identify(event.x, event.y)
+        orientation = str(self.cget('orient'))
+        if (part == 'Scale.trough'):
+            length = self.right_end - self.left_end
+            slider_length = self._slider_right_end - self._slider_left_end
+            if orientation == tk.HORIZONTAL:
+                fraction = float(event.x) / float(self.winfo_width())
+            else:
+                fraction = float(event.y) / float(self.winfo_height())
+            if self.callback:
+                self.callback(length * fraction + self.left_end)
+            self.set(slider_length * fraction + self._slider_left_end)
+            return 'break'
+
+
+class ZoomSlider(ttk.Frame):
+    """
+    A compound widget containing a Slider, labels and two buttons that
+    expand or contract the range of values by a factor of 2.  The nonneg
+    option can be set to ensure that the range remains nonnegative. This
+    widget assumes that from < to.
+    """
+    min_span = 0.05
+    max_span = 100
+
+    def __init__(self, container, left_end, right_end, label_text=None, on_change=None):
+        self._build_icons()
+        ttk.Frame.__init__(self, container)
+        self.left_end = left_end
+        self.right_end = right_end
+        self.on_change = on_change
+        self.slider = Slider(self, left_end, right_end)
+        self.slider.set_callback(self._slider_callback)
+
+        style_args = ( { 'style':'Toolbutton' }
+                       if (sys.platform == 'darwin')
+                       else {})
+
+        self.compresser = ttk.Button(self,
+                                     image=self.compress_icon,
+                                     command=self.zoom_in,
+                                     **style_args)
+        self.expander = ttk.Button(self,
+                                   image=self.expand_icon,
+                                   command=self.zoom_out,
+                                   **style_args)
+
+        padding_cheat = -6 if (sys.platform == 'darwin') else 0
+
+        if label_text is not None:
+            self.title_label = ttk.Label(self, text=label_text, padding=label_pad)
+            col_base = 1
+            self.columnconfigure(0, weight=0)
+            self.title_label.grid(row=0, column=0, sticky=tk.W)
+        else:
+            self.title_lable = None
+            col_base = 0
+
+        self.min_label = ttk.Label(self, text='min', padding=(0, padding_cheat, 0, 0))
+        self.max_label = ttk.Label(self, text='max', padding=(0, padding_cheat, 0, 0))
+        self.value_label = ttk.Label(self, width=6, padding=(8, 0))
+        self.columnconfigure(col_base + 0, weight=0)
+        self.columnconfigure(col_base + 1, weight=0)
+        self.columnconfigure(col_base + 2, weight=1)
+        self.columnconfigure(col_base + 3, weight=0)
+        self.compresser.grid(row=0, column=col_base, sticky=tk.S)
+        self.expander.grid(row=0, column=col_base + 1, sticky=tk.S)
+        self.slider.grid(row=0, column=col_base + 2, sticky=tk.EW, padx=(6, 0))
+        self.value_label.grid(row=0, column=col_base + 3, sticky=tk.W)
+        self.min_label.grid(row=1, column=col_base + 2, sticky=tk.NW)
+        self.max_label.grid(row=1, column=col_base + 2, sticky=tk.NE)
+        self.slider.bind('<MouseWheel>', self._handle_wheel)
+        self.slider.bind('<Shift-Button-1>', self._reset)
+
+        self.current_value = left_end
+
+        self.callback = None
+
+        self._update_labels()
+
+    def set_callback(self, callback):
+        self.callback = callback
+
+    def set_value(self, value):
+        frac = 0.8
+
+        l = self.slider.left_end
+        r = self.slider.right_end
+
+        length = r - l
+        l_p = frac * l + (1.0 - frac) * r
+        r_p = frac * r + (1.0 - frac) * l
+
+        if value < l_p:
+            self.slider.left_end = value - (1.0 - frac) * length
+            self.slider.right_end = value + frac * length
+
+        if value > r_p:
+            self.slider.left_end = value - frac * length
+            self.slider.right_end = value + (1.0 - frac) * length
+
+        self.slider.set_value(value)
+        self.current_value = value
+        self._update_labels()
+
+    def _build_icons(self):
+        if sys.platform == 'darwin':
+            try:
+                self.compress_icon = tk.Image('nsimage', source='NSExitFullScreenTemplate',
+                                            width=18, height=18)
+                self.expand_icon = tk.Image('nsimage', source='NSEnterFullScreenTemplate',
+                                            width=18, height=18)
+            except tk.TclError:
+                self.compress_icon = tk.Image('photo', width=18, height=18,
+                    file=os.path.join(os.path.dirname(__file__), 'inward18.png'))
+
+                self.expand_icon = tk.Image('photo', width=18, height=18,
+                    file=os.path.join(os.path.dirname(__file__), 'outward18.png'))
+        else:
+            suffix = 'gif' if tk.TkVersion < 8.6 else 'png'
+            self.compress_icon = tk.Image('photo', width=18, height=18,
+                file=os.path.join(os.path.dirname(__file__), 'inward18.' + suffix))
+
+            self.expand_icon = tk.Image('photo', width=18, height=18,
+                file=os.path.join(os.path.dirname(__file__), 'outward18.' + suffix))
+
+    def _slider_callback(self, value):
+        self.current_value = value
+        self._update_labels()
+        if self.callback:
+            self.callback(value)
+        if self.on_change:
+            self.on_change()
+
+    def _update_labels(self):
+        l = self.slider.left_end
+        r = self.slider.right_end
+
+        num_digits = _num_digits(r - l)
+
+        format_str1 = '%%.%df' % (num_digits + 1)
+        format_str2 = '%%.%df' % num_digits
+
+        self.value_label.configure(text=format_str1 % self.current_value)
+        self.min_label.configure(text=format_str2 % l)
+        self.max_label.configure(text=format_str2 % r)
+        if self.on_change:
+            self.on_change()
+
+    def _reset(self, event):
+
+        self.slider.left_end = self.left_end
+        self.slider.right_end = self.right_end
+        self.set_value(self.current_value)
+
+    def _handle_wheel(self, event):
+        delta = event.delta
+        if delta < 0:
+            self.compresser.state(['pressed'])
+            while(delta < 0):
+                self.zoom_in()
+                delta += 1
+            self.after(200, lambda :self.compresser.state(['!pressed']))
+        elif delta > 0:
+            self.expander.state(['pressed'])
+            while(delta > 0):
+                self.zoom_out()
+                delta -= 1
+            self.after(200, lambda :self.expander.state(['!pressed']))
+
+    def zoom_in(self):
+        l = self.slider.left_end
+        r = self.slider.right_end
+
+        if r - l < self.min_span:
+            return
+
+        self.slider.left_end = 0.25 * (3.0 * l + r)
+        self.slider.right_end = 0.25 * (3.0 * r + l)
+
+        self.set_value(self.current_value)
+        self._update_labels()
+
+    def zoom_out(self):
+        l = self.slider.left_end
+        r = self.slider.right_end
+
+        if r - l > self.max_span:
+            return
+
+        self.slider.left_end = 0.5 * (3.0 * l - r)
+        self.slider.right_end = 0.5 * (3.0 * r - l)
+        self.slider.set_value(self.current_value)
+        self._update_labels()
+
+
+def _num_digits(x):
+    r = 1
+    while x < 1 and r < 7:
+        x *= 10.0
+        r += 1
+    return r

snappy/raytracing/zoom_slider/test.py

@@ -0,0 +1,20 @@
+from . import tk, Slider, ZoomSlider
+
+
+def test_widget(window=None):
+    if window is None:
+        window = tk.Toplevel()
+    window.title('ZoomSliders')
+    tk.Label(window, text='', width=70).pack()
+    slider = Slider(window, from_=0.0, to=1.0)
+    slider.pack(expand=True, fill=tk.X, padx=10)
+    zoom_slider = ZoomSlider(window, from_=0.0, to=1.0)
+    zoom_slider.pack(expand=True, fill=tk.X)
+    pos_slider = ZoomSlider(window, from_=0.0, to=1.0, nonneg=True)
+    pos_slider.pack(expand=True, fill=tk.X, side='bottom')
+
+
+if __name__ == '__main__':
+    win = tk.Tk()
+    test_widget(win)
+    win.mainloop()