snappy 3.0.3__cp38-cp38-macosx_11_0_arm64.whl → 3.2__cp38-cp38-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

@@ -1,5 +1,6 @@
-import sys, os, tkinter as tk
-import tkinter
+import sys
+import os
+import tkinter as tk
 from tkinter import ttk
 
 if sys.platform == 'linux':
@@ -16,20 +17,20 @@ class Slider(ttk.Scale):
     Subclass of ttk.Scale which makes clicking on the track cause the
     knob to move to the click point.
     """
-    def __init__(self, master, left_end, right_end,
-                 orient = tkinter.HORIZONTAL):
+    def __init__(self, container, left_end, right_end,
+                 orient=tk.HORIZONTAL):
         ttk.Scale.__init__(self,
-                           master = master,
-                           from_ = self._slider_left_end,
-                           to = self._slider_right_end,
-                           value = 2.0,
-                           orient = orient,
+                           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.configure(command=self._command)
         self.bind('<Button-1>', self._handle_mouse)
 
     def set_callback(self, callback):
@@ -40,7 +41,7 @@ class Slider(ttk.Scale):
         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)
+        self.configure(value=slider_value)
 
     def _command(self, slider_value):
         if self.callback:
@@ -72,6 +73,7 @@ class Slider(ttk.Scale):
             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
@@ -82,9 +84,9 @@ class ZoomSlider(ttk.Frame):
     min_span = 0.05
     max_span = 100
 
-    def __init__(self, master, left_end, right_end, label_text=None, on_change=None):
+    def __init__(self, container, left_end, right_end, label_text=None, on_change=None):
         self._build_icons()
-        ttk.Frame.__init__(self, master)
+        ttk.Frame.__init__(self, container)
         self.left_end = left_end
         self.right_end = right_end
         self.on_change = on_change
@@ -106,7 +108,7 @@ class ZoomSlider(ttk.Frame):
 
         padding_cheat = -6 if (sys.platform == 'darwin') else 0
 
-        if not label_text is None:
+        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)
@@ -151,11 +153,11 @@ class ZoomSlider(ttk.Frame):
         r_p = frac * r + (1.0 - frac) * l
 
         if value < l_p:
-            self.slider.left_end  = value - (1.0 - frac) * length
+            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.left_end = value - frac * length
             self.slider.right_end = value + (1.0 - frac) * length
 
         self.slider.set_value(value)
@@ -165,22 +167,22 @@ class ZoomSlider(ttk.Frame):
     def _build_icons(self):
         if sys.platform == 'darwin':
             try:
-                self.compress_icon=tk.Image('nsimage', source='NSExitFullScreenTemplate',
+                self.compress_icon = tk.Image('nsimage', source='NSExitFullScreenTemplate',
                                             width=18, height=18)
-                self.expand_icon=tk.Image('nsimage', source='NSEnterFullScreenTemplate',
+                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,
+                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,
+                self.expand_icon = tk.Image('photo', width=18, height=18,
                     file=os.path.join(os.path.dirname(__file__), 'outward18.png'))
         else:
-            suffix = 'gif' if tkinter.TkVersion < 8.6 else 'png'
-            self.compress_icon=tk.Image('photo', width=18, height=18,
+            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,
+            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):
@@ -198,11 +200,11 @@ class ZoomSlider(ttk.Frame):
         num_digits = _num_digits(r - l)
 
         format_str1 = '%%.%df' % (num_digits + 1)
-        format_str2 = '%%.%df' %  num_digits
+        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)
+        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()
 
@@ -234,7 +236,7 @@ class ZoomSlider(ttk.Frame):
         if r - l < self.min_span:
             return
 
-        self.slider.left_end  = 0.25 * (3.0 * l + r)
+        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)
@@ -247,11 +249,12 @@ class ZoomSlider(ttk.Frame):
         if r - l > self.max_span:
             return
 
-        self.slider.left_end  = 0.5 * (3.0 * l - r)
+        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:

snappy/raytracing/zoom_slider/test.py

@@ -1,5 +1,6 @@
 from . import tk, Slider, ZoomSlider
 
+
 def test_widget(window=None):
     if window is None:
         window = tk.Toplevel()
@@ -12,6 +13,7 @@ def test_widget(window=None):
     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)