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

snappy/raytracing/gui_utilities.py

@@ -1,70 +1,77 @@
-import sys, tkinter
+import sys
+import tkinter
 from tkinter import ttk
 from .zoom_slider import Slider
 import time
 
 if sys.platform == 'linux':
-    label_pad, slider_stick = (4, 0), tkinter.EW
+    label_pad, slider_stick = (4, 0, 20, 0), tkinter.EW
 else:
     label_pad, slider_stick = 0, tkinter.NSEW
 
+
 class UniformDictController:
     @staticmethod
     def create_horizontal_scale(container, uniform_dict, key,
-                                row, left_end, right_end, update_function = None,
-                                column = 0,
-                                title = None,
-                                format_string = None,
-                                index = None, component_index = None):
+                                row, left_end, right_end, update_function=None,
+                                column=0,
+                                columnspan=1,
+                                title=None,
+                                format_string=None,
+                                index=None, component_index=None):
         if title:
-            title_label = ttk.Label(container, text = title, padding=label_pad)
-            title_label.grid(row = row, column = column, sticky=tkinter.NE)
+            title_label = ttk.Label(container, text=title, padding=label_pad)
+            title_label.grid(row=row, column=column, sticky=tkinter.NE)
             column += 1
 
-        scale = Slider(master = container,
-                       left_end = left_end,
-                       right_end = right_end)
-        scale.grid(row = row, column = column, sticky = slider_stick)
-        column += 1
+        scale = Slider(container=container,
+                       left_end=left_end,
+                       right_end=right_end)
+        scale.grid(row=row, column=column, columnspan=columnspan,
+                   sticky=slider_stick, padx=10)
+        column += columnspan
         value_label = ttk.Label(container, padding=label_pad)
-        value_label.grid(row = row, column = column, sticky = tkinter.NW)
+        value_label.grid(row=row, column=column, sticky=tkinter.NW, padx=20)
 
         if title:
             title_label.grid_configure(sticky=tkinter.N, pady=4)
 
         return UniformDictController(
-            uniform_dict, key, scale = scale, label = value_label,
-            update_function = update_function,
-            format_string = format_string,
-            index = index, component_index = component_index)
+            uniform_dict, key, scale=scale, label=value_label,
+            update_function=update_function,
+            format_string=format_string,
+            index=index, component_index=component_index)
 
     @staticmethod
     def create_checkbox(container, uniform_dict, key,
-                        row, update_function = None,
-                        column = 0,
-                        text = '',
-                        index = None,
-                        component_index = None):
+                        row, update_function=None,
+                        column=0,
+                        text='',
+                        index=None,
+                        component_index=None,
+                        gridargs = {}):
         checkbox = ttk.Checkbutton(container, takefocus=0)
-        checkbox.grid(row = row, column = column)
-        checkbox.configure(text = text)
+        checkbox.grid(row=row, column=column, **gridargs)
+        checkbox.configure(text=text)
 
         return UniformDictController(
-            uniform_dict, key, checkbox = checkbox,
-            update_function = update_function,
-            index = index, component_index = component_index)
+            uniform_dict, key, checkbox=checkbox,
+            update_function=update_function,
+            index=index, component_index=component_index)
 
     def __init__(self, uniform_dict, key,
-                 scale = None, label = None, checkbox = None,
-                 update_function = None,
-                 format_string = None,
-                 index = None, component_index = None):
+                 scale=None, label=None, checkbox=None,
+                 radio_buttons=None,
+                 update_function=None,
+                 format_string=None,
+                 index=None, component_index=None):
 
         self.uniform_dict = uniform_dict
         self.key = key
         self.scale = scale
         self.label = label
         self.checkbox = checkbox
+        self.radio_buttons = radio_buttons
         self.update_function = update_function
         self.index = index
         self.component_index = component_index
@@ -77,7 +84,7 @@ class UniformDictController:
                 raise Exception("int/float uniform does not support index")
         elif self.uniform_type == 'float[]':
             self.scalar_type = 'float'
-            if index is None or not component_index is None:
+            if index is None or component_index is not None:
                 raise Exception("Need to specify index for float[] uniform")
         elif self.uniform_type == 'vec2[]':
             self.scalar_type = 'float'
@@ -87,6 +94,10 @@ class UniformDictController:
             self.scalar_type = 'bool'
             if not (index is None and component_index is None):
                 raise Exception("int/float uniform does not support index")
+        elif self.uniform_type == 'bool[]':
+            self.scalar_type = 'bool'
+            if index is None or component_index is not None:
+                raise Exception("Need to specify index for bool[] uniform")
         else:
             raise Exception("Unsupported uniform type %s" % self.uniform_type)
 
@@ -102,8 +113,14 @@ class UniformDictController:
             self.scale.set_callback(self.scale_command)
         if self.checkbox:
             self.checkbox_var = tkinter.BooleanVar()
-            self.checkbox.configure(variable = self.checkbox_var)
-            self.checkbox.configure(command = self.check_command)
+            self.checkbox.configure(variable=self.checkbox_var)
+            self.checkbox.configure(command=self.check_command)
+        if self.radio_buttons:
+            self.radio_var = tkinter.IntVar()
+            for radio_button in self.radio_buttons:
+                radio_button.configure(variable=self.radio_var)
+                radio_button.configure(command=self.radio_command)
+
         self.update()
 
     def get_value(self):
@@ -118,6 +135,8 @@ class UniformDictController:
                 self.uniform_dict[self.key][1][self.index][self.component_index])
         if self.uniform_type == 'bool':
             return bool(self.uniform_dict[self.key][1])
+        if self.uniform_type == 'bool[]':
+            return bool(self.uniform_dict[self.key][1][self.index])
 
     def set_value(self, value):
         if self.uniform_type == 'int':
@@ -131,23 +150,30 @@ class UniformDictController:
                 float(value))
         elif self.uniform_type == 'bool':
             self.uniform_dict[self.key][1] = bool(value)
+        elif self.uniform_type == 'bool[]':
+            self.uniform_dict[self.key][1][self.index] = bool(value)
 
     def update_scale(self):
         if self.scale:
-            self.scale.set_value(value = self.get_value())
+            self.scale.set_value(value=self.get_value())
 
     def update_label(self):
         if self.label:
-            self.label.configure(text = self.format_string % self.get_value())
+            self.label.configure(text=self.format_string % self.get_value())
 
     def update_checkbox(self):
         if self.checkbox:
             self.checkbox_var.set(self.get_value())
 
+    def update_radiobuttons(self):
+        if self.radio_buttons:
+            self.radio_var.set(self.get_value())
+
     def update(self):
         self.update_scale()
         self.update_label()
         self.update_checkbox()
+        self.update_radiobuttons()
 
     def scale_command(self, value):
         self.set_value(value)
@@ -160,12 +186,29 @@ class UniformDictController:
         if self.update_function:
             self.update_function()
 
+    def radio_command(self):
+        self.set_value(self.radio_var.get())
+        if self.update_function:
+            self.update_function()
+
+
 class FpsLabelUpdater:
     def __init__(self, label):
         self.label = label
         self.num_iterations = 0
         self.total_time = 0.0
         self.last_time = time.time()
+        self._visible = False
+        self._text = '-fps (-ms)'
+
+    def set_visible(self, visible):
+        if self._visible == visible:
+            return
+        self._visible = visible
+        if visible:
+            self.label.configure(text = self._text)
+        else:
+            self.label.configure(text = '')
 
     def __call__(self, t):
         self.num_iterations += 1
@@ -174,8 +217,77 @@ class FpsLabelUpdater:
             current_time = time.time()
             fps = self.num_iterations / (current_time - self.last_time)
             time_ms = 1000 * self.total_time / self.num_iterations
-
-            self.label.configure(text = '%.1ffps (%dms)' % (fps, time_ms))
+            self._text = '%.1ffps (%dms)' % (fps, time_ms)
+            if self._visible:
+                self.label.configure(text=self._text)
             self.last_time = current_time
             self.num_iterations = 0
             self.total_time = 0.0
+
+
+class ScrollableFrame(ttk.Frame):
+    # From https://blog.teclado.com/tkinter-scrollable-frames/
+
+    def __init__(self, container, *args, **kwargs):
+        super().__init__(container, *args, **kwargs)
+        self.header = header = ttk.Frame(self)
+        header.pack(anchor="sw")
+        self.canvas = canvas = tkinter.Canvas(self)
+        self.scrollbar = scrollbar = ttk.Scrollbar(self, orient="vertical",
+            command=canvas.yview)
+        self.scrollable_frame = ttk.Frame(canvas)
+        self.scrollable_frame.bind("<Configure>", self.resize)
+        canvas.create_window((0, 0), window=self.scrollable_frame, anchor="nw")
+        canvas.configure(yscrollcommand=self.set_scrollbar)
+        canvas.pack(side="left", fill="both", expand=True, anchor="nw", pady=10)
+        scrollbar.pack(side="right", fill="y", anchor="nw", pady=10)
+        scrollbar.is_visible = True
+        self.num_columns = 0
+        self.has_mouse = False
+        self.bind('<Enter>', self.mouse_in)
+        self.bind('<Leave>', self.mouse_out)
+        self.bind_all('<MouseWheel>', self.mouse_wheel)
+
+    def headings(self, columninfo):
+        for heading, column, weight, span in columninfo:
+            self.num_columns = max(self.num_columns, 1 + column)
+            self.header.columnconfigure(column, weight=weight)
+            self.scrollable_frame.columnconfigure(column, weight=weight)
+            ttk.Label(self.header, text=heading).grid(row=0,
+                column=column, columnspan=span)
+
+    def set_widths(self):
+        for n in range(self.num_columns):
+            header_width = self.header.grid_bbox(n, 0, n, 0)[2]
+            column_width = self.scrollable_frame.grid_bbox(n, 0, n, 0)[2]
+            width = max(header_width, column_width, 40)
+            self.header.columnconfigure(n, minsize=width)
+            self.scrollable_frame.columnconfigure(n, minsize=width)
+
+    def set_scrollbar(self, low, high):
+        if float(low) <= 0.0 and float(high) >= 1.0:
+            self.scrollbar.pack_forget()
+            self.scrollbar.is_visible = False
+        else:
+            self.scrollbar.pack(side="right", fill="y", anchor="nw", pady=10)
+            self.scrollbar.is_visible = True
+        self.scrollbar.set(low, high)
+
+    def resize(self, event=None):
+        self.set_widths()
+        self.update_idletasks()
+        self.canvas.configure(scrollregion=self.canvas.bbox("all"))
+
+    def mouse_in(self, event=None):
+        self.has_mouse = True
+
+    def mouse_out(self, event=None):
+        self.has_mouse = False
+
+    def mouse_wheel(self, event=None):
+        if not self.has_mouse or not self.scrollbar.is_visible:
+            return
+        low, high = self.scrollbar.get()
+        delta = event.delta
+        # We might need a scale factor for Windows.
+        self.canvas.yview_scroll(-delta, "units")

snappy/raytracing/hyperboloid_navigation.py

@@ -1,5 +1,5 @@
 from .hyperboloid_utilities import *
-import math
+from ..matrix import matrix
 import time
 import sys
 import tempfile
@@ -7,55 +7,75 @@ import png
 
 __all__ = ['HyperboloidNavigation']
 
+
 def _move_left(rot_amount, trans_amount):
+    RF = trans_amount.parent()
     return unit_3_vector_and_distance_to_O13_hyperbolic_translation(
-        [ -1.0,  0.0,  0.0 ], trans_amount) # a
+        [ RF(-1), RF(0), RF(0) ], trans_amount) # a
+
 
 def _move_right(rot_amount, trans_amount):
+    RF = trans_amount.parent()
     return unit_3_vector_and_distance_to_O13_hyperbolic_translation(
-        [ +1.0,  0.0,  0.0 ], trans_amount) # d
+        [ RF(+1), RF(0), RF(0) ], trans_amount) # d
+
 
 def _move_up(rot_amount, trans_amount):
+    RF = trans_amount.parent()
     return unit_3_vector_and_distance_to_O13_hyperbolic_translation(
-        [  0.0, +1.0,  0.0 ], trans_amount) # e
+        [  RF(0), RF(+1), RF(0) ], trans_amount) # e
+
 
 def _move_down(rot_amount, trans_amount):
+    RF = trans_amount.parent()
     return unit_3_vector_and_distance_to_O13_hyperbolic_translation(
-        [  0.0, -1.0,  0.0 ], trans_amount) # c
+        [  RF(0), RF(-1), RF(0) ], trans_amount) # c
+
 
 def _move_forward(rot_amount, trans_amount):
+    RF = trans_amount.parent()
     return unit_3_vector_and_distance_to_O13_hyperbolic_translation(
-        [  0.0,  0.0, -1.0 ], trans_amount) # w
+        [  RF(0), RF(0), RF(-1) ], trans_amount) # w
+
 
 def _move_backward(rot_amount, trans_amount):
+    RF = trans_amount.parent()
     return unit_3_vector_and_distance_to_O13_hyperbolic_translation(
-        [  0.0,  0.0, +1.0 ], trans_amount) # s
+        [  RF(0), RF(0), RF(+1) ], trans_amount) # s
+
 
 def _turn_left(rot_amount, trans_amount):
     return O13_y_rotation(-rot_amount)
 
+
 def _turn_right(rot_amount, trans_amount):
     return O13_y_rotation(rot_amount)
 
+
 def _turn_up(rot_amount, trans_amount):
     return O13_x_rotation(-rot_amount)
 
+
 def _turn_down(rot_amount, trans_amount):
     return O13_x_rotation(rot_amount)
 
+
 def _turn_cw(rot_amount, trans_amount): # x
     return O13_z_rotation(-rot_amount)
 
+
 def _turn_ccw(rot_amount, trans_amount): # z
     return O13_z_rotation(rot_amount)
 
+
 def _add_cursor_keys(d):
-    d['left']  = _turn_left
+    d['left'] = _turn_left
     d['right'] = _turn_right
-    d['up']    = _turn_up
-    d['down']  = _turn_down
+    d['up'] = _turn_up
+    d['down'] = _turn_down
     return d
 
+
 _keymappings = {
     'QWERTY' : _add_cursor_keys(
         { 'a' : _move_left,
@@ -117,6 +137,7 @@ _ignore_key_release_time_s = 0.005
 
 _viewModes = [ 'Weight', 'Distance', 'Tet Num' ]
 
+
 class HyperboloidNavigation:
     """
     A mixin class for a Tk widget that binds some key and mouse events
@@ -124,17 +145,18 @@ class HyperboloidNavigation:
 
     This is a mixin class and some other class in the class hierarchy
     is expected to provide the following attributes and methods:
-        - self.raytracing_data has to be an instance of, e.g.,
-          IdealRaytracingData. This is needed to update data
-          such as the view matrix 
-          using self.raytracing_data.update_view_state(...).
-        - self.redraw_if_initialized() to redraw.
-        - self.read_depth_value(x, y) to return the depth value at a pixel.
-          It is used for orbiting about that point.
-        - self.compute_translation_and_inverse_from_pick_point(size, xy, depth)
-          returning the SO(1,3)-matrices for conjugating to orbit with a certain
-          speed about the point with frag coord xy and depth given a viewport of
-          size size.
+
+    - self.raytracing_data has to be an instance of, e.g.,
+      IdealRaytracingData. This is needed to update data
+      such as the view matrix
+      using self.raytracing_data.update_view_state(...).
+    - self.draw() to redraw.
+    - self.read_depth_value(x, y) to return the depth value at a pixel.
+      It is used for orbiting about that point.
+    - self.compute_translation_and_inverse_from_pick_point(size, xy, depth)
+      returning the SO(1,3)-matrices for conjugating to orbit with a certain
+      speed about the point with frag coord xy and depth given a viewport of
+      size size.
 
     The mixin class will provide the attribute self.view_state (e.g.,
     pair of view matrix and tetrahedron we are in).
@@ -164,7 +186,7 @@ class HyperboloidNavigation:
         self.view_state = self.raytracing_data.initial_view_state()
 
         self.cursor = _default_cursor
-        self.configure(cursor = self.cursor)
+        self.configure(cursor=self.cursor)
 
         # Parameters controlling navigation in the same format that
         # get_uniform_binding returns..
@@ -230,10 +252,7 @@ class HyperboloidNavigation:
         t = time.time()
 
         # Compute the matrix to update the view
-        m = matrix([[1.0,0.0,0.0,0.0],
-                    [0.0,1.0,0.0,0.0],
-                    [0.0,0.0,1.0,0.0],
-                    [0.0,0.0,0.0,1.0]])
+        m = matrix.identity(self.raytracing_data.RF, 4)
 
         # Is there any key event that needs processing so we need to
         # redraw.
@@ -282,11 +301,12 @@ class HyperboloidNavigation:
                     last_and_release[0] = t
 
             # If there is key press time we need to account for
-            if not dT is None:
+            if dT is not None:
+                RF = m.base_ring()
                 # Compute effect on view matrix
                 m = m * self.keymapping[k](
-                    dT * self.navigation_dict['rotationVelocity'][1],
-                    dT * self.navigation_dict['translationVelocity'][1])
+                    RF(dT * self.navigation_dict['rotationVelocity'][1]),
+                    RF(dT * self.navigation_dict['translationVelocity'][1]))
                 any_key = True
 
         if not any_key:
@@ -298,7 +318,7 @@ class HyperboloidNavigation:
             self.view_state, m)
 
         # Redraw
-        self.redraw_if_initialized()
+        self.draw()
 
         # And schedule another call of this function.
         # If we don't leave Tk a couple of milliseconds in between,
@@ -319,7 +339,7 @@ class HyperboloidNavigation:
             self.cursor = _default_cursor
 
         if not self.mouse_mode:
-            self.configure(cursor = self.cursor)
+            self.configure(cursor=self.cursor)
 
     def tkKeyPress(self, event):
         if self.mouse_mode:
@@ -330,7 +350,7 @@ class HyperboloidNavigation:
 
         cursor = _cursor_mappings.get(k)
         if cursor:
-            self.configure(cursor = cursor)
+            self.configure(cursor=cursor)
 
         last_and_release = self.key_to_last_accounted_and_release_time.get(k)
         if last_and_release:
@@ -364,7 +384,7 @@ class HyperboloidNavigation:
             self.view = (self.view + 1) % 3
             print("Color for rays that have not hit geometry:",
                   _viewModes[self.view])
-            self.redraw_if_initialized()
+            self.draw()
 
         if event.keysym == 'p':
             from snappy.CyOpenGL import get_gl_string
@@ -382,9 +402,9 @@ class HyperboloidNavigation:
 
             width = 1000
             height = 1000
-            
+
             f = tempfile.NamedTemporaryFile(
-                suffix = '.png', delete = False)
+                suffix='.png', delete=False)
 
             self.save_image(width, height, f)
 
@@ -397,7 +417,7 @@ class HyperboloidNavigation:
             if last or release:
                 return
 
-        self.configure(cursor = _default_move_cursor)
+        self.configure(cursor=_default_move_cursor)
 
         self.mouse_pos_when_pressed = (event.x, event.y)
         self.view_state_when_pressed = self.view_state
@@ -432,10 +452,7 @@ class HyperboloidNavigation:
         self.last_mouse_pos = (event.x, event.y)
         self.view_state_when_pressed = self.view_state
 
-        self.orbit_rotation = 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]])
+        self.orbit_rotation = matrix.identity(self.raytracing_data.RF, 4)
 
         self.mouse_mode = 'orbit'
 
@@ -444,8 +461,10 @@ class HyperboloidNavigation:
             delta_x = event.x - self.last_mouse_pos[0]
             delta_y = event.y - self.last_mouse_pos[1]
 
-            angle_x = delta_x * self.orbit_speed * 0.01
-            angle_y = delta_y * self.orbit_speed * 0.01
+            RF = self.raytracing_data.RF
+
+            angle_x = RF(delta_x * self.orbit_speed * 0.01)
+            angle_y = RF(delta_y * self.orbit_speed * 0.01)
 
             m = O13_y_rotation(angle_x) * O13_x_rotation(angle_y)
             self.orbit_rotation = self.orbit_rotation * m
@@ -456,24 +475,31 @@ class HyperboloidNavigation:
 
             self.last_mouse_pos = (event.x, event.y)
         elif self.mouse_mode == 'move':
-            delta_x = event.x - self.mouse_pos_when_pressed[0]
-            delta_y = event.y - self.mouse_pos_when_pressed[1]
+            RF = self.raytracing_data.RF
+
+            delta_x = RF(event.x - self.mouse_pos_when_pressed[0])
+            delta_y = RF(event.y - self.mouse_pos_when_pressed[1])
 
-            amt = math.sqrt(delta_x ** 2 + delta_y ** 2)
+            amt = (delta_x ** 2 + delta_y ** 2).sqrt()
 
             if amt == 0:
                 self.view_state = self.view_state_when_pressed
             else:
                 m = unit_3_vector_and_distance_to_O13_hyperbolic_translation(
-                    [-delta_x / amt, delta_y / amt, 0.0], amt * 0.01)
+                    [-delta_x / amt, delta_y / amt, RF(0)], amt * RF(0.01))
 
                 self.view_state = self.raytracing_data.update_view_state(
                     self.view_state_when_pressed, m)
         elif self.mouse_mode == 'rotate':
+            RF = self.raytracing_data.RF
+
             delta_x = event.x - self.mouse_pos_when_pressed[0]
             delta_y = event.y - self.mouse_pos_when_pressed[1]
 
-            m = O13_y_rotation(-delta_x * 0.01) * O13_x_rotation(-delta_y * 0.01)
+            angle_x = RF(-delta_x * 0.01)
+            angle_y = RF(-delta_y * 0.01)
+
+            m = O13_y_rotation(angle_x) * O13_x_rotation(angle_y)
 
             self.view_state = self.raytracing_data.update_view_state(
                 self.view_state, m)
@@ -482,13 +508,13 @@ class HyperboloidNavigation:
         else:
             return
 
-        self.redraw_if_initialized()
+        self.draw()
 
     def tkButtonRelease1(self, event):
         self.mouse_mode = None
-        self.configure(cursor = self.cursor)
+        self.configure(cursor=self.cursor)
 
-    def setup_keymapping(self, keyboard = 'QWERTY'):
+    def setup_keymapping(self, keyboard='QWERTY'):
         self.keymapping = _keymappings[keyboard]
 
         # Key (e.g., 'w', 'a', ...) to pair of time stamps.
@@ -502,5 +528,29 @@ class HyperboloidNavigation:
             for k in self.keymapping
         }
 
-    def apply_prefs(self, prefs):
-        self.setup_keymapping(prefs.get('keyboard', 'QWERTY'))
+    def apply_settings(self, settings):
+        self.setup_keymapping(settings.get('keyboard', 'QWERTY'))
+
+    def _start_flight_for_debugging_hitch(self):
+        """
+        On Mac OS, there is a hitch when flying. It is subtle, but when
+        keeping, say the w key pressed, every second or so there a brief
+        moment where we are not moving.
+
+        I couldn't figure out whether this is due to how we are processing
+        the key events or already a problem with calling self.after from
+        within the redraw code.
+
+        This function initiates a flight to isolate the problem to the
+        latter.
+
+        To use it, do:
+            >>> M = Manifold("m004") # doctest: +SKIP
+            >>> v = M.inside_view()
+            >>> v.view.widget._start_flight_for_debugging_hitch()
+
+        """
+
+        self.key_to_last_accounted_and_release_time['w'][0] = time.time()
+        self.schedule_process_key_events_and_redraw(1)
+