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

snappy/geometric_structure/geodesic/tiles_for_geodesic.py

@@ -0,0 +1,101 @@
+from .canonical_keys import canonical_keys_function_for_line
+from .geodesic_start_point_info import GeodesicStartPointInfo
+from .avoid_core_curves import replace_piece_in_core_curve_tube
+
+from ...tiling.tile import Tile, compute_tiles
+from ...tiling.lifted_tetrahedron_set import (LiftedTetrahedronSet,
+                                              get_lifted_tetrahedron_set)
+
+from ...snap.t3mlite import Mcomplex # type: ignore
+
+from typing import Sequence
+
+def compute_tiles_for_geodesic(mcomplex : Mcomplex,
+                               geodesic : GeodesicStartPointInfo,
+                               avoid_core_curves : bool = False,
+                               for_raytracing : bool = False
+                               ) -> Sequence[Tile]:
+    """
+    Computes all GeodesicPiece's needed to cover a tube about the
+    given closed geodesic in the given manifold. The geodesic cannot be
+    a core curve of a filled cusp.
+
+    A GeodesicTube is constructed from a triangulation with a suitable
+    geometric structure and a suitable GeodesicStartPointInfo object.
+
+    To add the necessary geometric structure to a triangulation, call
+    add_r13_geometry and add_r13_planes_to_tetrahedra.
+
+    The GeodesicStartPointInfo object needs to be constructed with a line and
+    GeodesicStartPointInfo.find_tet_or_core_curve be called on it.
+
+    Calling GeodesicStartPointInfo.add_pieces_for_radius will then add the
+    necessary pieces to GeodesicStartPointInfo.pieces to cover the tube of the
+    given radius.
+    """
+
+    if geodesic.core_curve_cusp is not None:
+        raise ValueError(
+            "Cannot tile a tube about a geodesic that is a core curve.")
+
+    if geodesic.line is None:
+        raise ValueError(
+            "Tiling a tube about a geodesic expected GeodesicStartPointInfo with valid "
+            "line.")
+
+    if not geodesic.lifted_tetrahedra:
+        raise ValueError(
+            "Tiling a tube about a geodesic expected GeodesicStartPointInfo with valid "
+            "lifted_tetrahedra.")
+
+    min_neg_prod_distinct = (mcomplex.baseTetInRadius/2).cosh()
+
+    if mcomplex.verified:
+        max_neg_prod_equal = min_neg_prod_distinct
+    else:
+        max_neg_prod_equal = min(
+            min_neg_prod_distinct, 1 + _compute_prod_epsilon(mcomplex.RF))
+        if for_raytracing:
+            min_neg_prod_distinct = max_neg_prod_equal
+
+    lifted_tetrahedron_set : LiftedTetrahedronSet = (
+        get_lifted_tetrahedron_set(
+            base_point=mcomplex.R13_baseTetInCenter,
+            canonical_keys_function=(
+                canonical_keys_function_for_line(geodesic.line)),
+            act_on_base_point_by_inverse=False,
+            max_neg_prod_equal=max_neg_prod_equal,
+            min_neg_prod_distinct=min_neg_prod_distinct,
+            verified=mcomplex.verified))
+
+    if avoid_core_curves:
+        replace_lifted_tetrahedron_function = replace_piece_in_core_curve_tube
+    else:
+        replace_lifted_tetrahedron_function = None
+
+    return compute_tiles(
+        geometric_object=geodesic.line.r13_line,
+        visited_lifted_tetrahedra=lifted_tetrahedron_set,
+        initial_lifted_tetrahedra=geodesic.lifted_tetrahedra,
+        replace_lifted_tetrahedron_function=replace_lifted_tetrahedron_function,
+        verified=mcomplex.verified)
+
+def _compute_prod_epsilon(RF):
+    p = RF.precision()
+
+    # We try to be a factor of at least several magnitudes smaller than
+    # 1/_compute_epsilon_inverse(RF) in hyperboloid_dict.py.
+    #
+    # This factor will even grow larger as the precision increases.
+    #
+    # That way, we will hopefully fail in _equality_predicate
+    # in hyperboloid_dict rather than failing by not hashing together
+    # lifted tetrahedra that should be the same but are not recognised
+    # as such because of numerical error.
+
+    result = RF(1e-6)
+    if p > 53:
+        result *= RF(0.5) ** ((p - 53) / 2)
+
+    return result
+    

snappy/geometric_structure/test.py

@@ -0,0 +1,22 @@
+from snappy import testing
+import snappy
+
+from snappy import geometric_structure
+
+modules = [
+    geometric_structure.cusp_neighborhood.cusp_cross_section_base,
+    geometric_structure.cusp_neighborhood.real_cusp_cross_section,
+    geometric_structure.cusp_neighborhood.complex_cusp_cross_section
+]
+
+def run_doctests(verbose=False, print_info=True):
+    globs = {'Manifold': snappy.Manifold}
+    return testing.doctest_modules(modules,
+                                   verbose=verbose,
+                                   print_info=print_info,
+                                   extraglobs=globs)
+
+run_doctests.__name__ = geometric_structure.__name__
+
+if __name__ == '__main__':
+    testing.run_doctests_as_main(run_doctests)

snappy/gui.py

@@ -1,25 +1,24 @@
 # -*- coding: utf-8 -*-
-from __future__ import unicode_literals
-import os, sys, time, tempfile, png
+import os
+import sys
+import time
+import tempfile
 import tkinter as Tk_
-from tkinter import ttk as ttk
+from tkinter import ttk
+from tkinter.ttk import Spinbox
 from tkinter.font import Font, families as font_families
 from tkinter.simpledialog import Dialog, SimpleDialog
-from tkinter.messagebox import askyesno
-
 from plink.ipython_tools import IPythonTkRoot
 from . import filedialog
-from .ppm_to_png import convert_ppm_to_png
 
-if sys.version_info.major < 3 or sys.version_info.minor < 7:
-    class Spinbox(ttk.Entry):
-        def __init__(self, master=None, **kw):
-            ttk.Entry.__init__(self, master, "ttk::spinbox", **kw)
+    
+def nominal_font_dict(tk_font):
+    """
+    Like Font.actual() but not messed up by GNOME scaling factors on
+    Linux.
+    """
+    return {key:tk_font.cget(key) for key in tk_font.actual()}
 
-        def set(self, value):
-            self.tk.call(self._w, "set", value)
-else:
-    Spinbox = ttk.Spinbox
 
 class SnapPyStyle:
     def __init__(self):
@@ -41,15 +40,27 @@ class SnapPyStyle:
         else:
             self.windowBG = ttk_style.lookup('TLabelframe', 'background')
             self.groupBG = self.subgroupBG = self.windowBG
+
         self.font = ttk_style.lookup('TLabel', 'font')
-        self.font_info = fi = Font(font=self.font).actual()
-        fi['size'] = abs(fi['size']) # Why would the size be negative???
+        if self.font == '':
+            self.font = 'TkDefaultFont'
+        # TLabel.font and TLabelframe.Label.font differ in Tk 9.0 (at
+        # least on macOS).  We restore the Tk 8.6 behavior.
+        self.ttk_style.configure('TLabelframe.Label',
+                                 font=self.font)
+        self.font_info = fi = nominal_font_dict(Font(font=self.font))
+        fi['size'] = int(str(fi['size']))
+        # On linux the treeview rows are too small, at least with hi-dpi displays.
+        if sys.platform == 'linux':
+            default_font = Font(name='TkDefaultFont', exists=True)
+            line_height = default_font.metrics()['linespace']
+            self.ttk_style.configure('Treeview', rowheight=line_height)
 
 class ViewerWindow(Tk_.Toplevel):
     def __init__(self, view_class, *args, **kwargs):
         window_type = kwargs.pop('window_type', 'untyped')
         self.root = kwargs.pop('root', self._get_root(window_type))
-        Tk_.Toplevel.__init__(self, master=self.root, class_='snappy')
+        Tk_.Toplevel.__init__(self, self.root, class_='snappy')
         self.protocol("WM_DELETE_WINDOW", self.close)
         self.title(string=kwargs.pop('title', ''))
         self.view = view_class(self, *args, **kwargs)
@@ -57,19 +68,19 @@ class ViewerWindow(Tk_.Toplevel):
         self.update_idletasks()
 
     def __repr__(self):
-        return 'New window: %s\n'%self.title()
+        return 'New window: %s\n' % self.title()
 
     def _get_root(self, window_type):
         if Tk_._default_root:
             return Tk_._default_root
-        root = IPythonTkRoot(window_type = window_type)
+        root = IPythonTkRoot(window_type=window_type)
         root.withdraw()
         return root
 
-    def _togl_save_image(self):
+    def save_image(self):
         """
         Helper for the save_image menu command of a ViewerWindow.
-        It expects to be passed the view Frame (not the master Toplevel)
+        It expects to be passed the view Frame (not the parent Toplevel)
         and it saves a PNG image of the current state of the view.
         """
         view = self.view
@@ -77,20 +88,12 @@ class ViewerWindow(Tk_.Toplevel):
             parent=self,
             mode='wb',
             title='Save Image As PNG Image File',
-            defaultextension = '.png',
-            filetypes = [
+            defaultextension='.png',
+            filetypes=[
                 ("PNG image files", "*.png *.PNG", ""),
                 ("All files", "")])
-        view.widget.redraw_if_initialized()
         if savefile:
-            _, ppm_file_name = tempfile.mkstemp(suffix='.ppm')
-            PI = Tk_.PhotoImage()
-            view.widget.tk.call(view.widget._w, 'takephoto', PI.name)
-            PI.write(ppm_file_name, format='ppm')
-            with open(ppm_file_name, 'rb') as ppm_file:
-                convert_ppm_to_png(ppm_file, savefile)
-            savefile.close()
-            os.remove(ppm_file_name)
+            view.widget.save_image_window_resolution(savefile)
 
     def close(self, event=None):
         if hasattr(self.view, 'delete_resource'):
@@ -98,9 +101,6 @@ class ViewerWindow(Tk_.Toplevel):
         self.view = None
         self.destroy()
 
-    def save_image(self):
-        self._togl_save_image()
-
     def add_help(self):
         pass
 
@@ -108,7 +108,7 @@ class ViewerWindow(Tk_.Toplevel):
         return {}
 
     def test(self):
-        print('Testing viewer for %s'%self.title())
+        print('Testing viewer for %s' % self.title())
         time.sleep(0.5)
         if hasattr(self.view, 'test'):
             if not self.view.winfo_ismapped():

snappy/horoviewer.py

@@ -1,24 +1,26 @@
 #!/usr/bin/env python
-from builtins import range
 from .gui import *
 from .CyOpenGL import (HoroballScene, OpenGLOrthoWidget,
                        GetColor, cyglSetStandardLighting)
 from plink.ipython_tools import IPythonTkRoot
-import os, sys
+import os
+import sys
+
 
 class HoroballViewer(ttk.Frame):
-    def __init__(self, master, nbhd=None, which_cusp=0, cutoff=None,
+    def __init__(self, parent, nbhd=None, which_cusp=0, cutoff=None,
                  title='Horoball Viewer',
-                 prefs={'cusp_horoballs' : True,
-                        'cusp_triangulation' : True,
-                        'cusp_ford_domain' : True,
-                        'cusp_labels' : True,
-                        'cusp_parallelogram' : True,
-                        'cusp_cutoff' : '0.1000'},
+                 settings={'cusp_horoballs' : True,
+                           'cusp_triangulation' : True,
+                           'cusp_ford_domain' : True,
+                           'cusp_labels' : True,
+                           'cusp_parallelogram' : True,
+                           'cusp_cutoff' : '0.1000'},
                  bgcolor=None,
                  main_window=None):
-        self.prefs = prefs
-        ttk.Frame.__init__(self, master)
+        self.settings = settings
+        ttk.Frame.__init__(self, parent)
+        self.parent = parent
         self.nbhd = nbhd
         self.empty = (self.nbhd is None)
         self.mouse_x = 0
@@ -26,7 +28,7 @@ class HoroballViewer(ttk.Frame):
         self.menubar = None
         self.main_window = main_window
         if cutoff is None:
-            self.cutoff = float(prefs['cusp_cutoff'])
+            self.cutoff = float(settings['cusp_cutoff'])
         else:
             self.cutoff = float(cutoff)
         self.which_cusp = which_cusp
@@ -38,15 +40,15 @@ class HoroballViewer(ttk.Frame):
         self.style = style = SnapPyStyle()
         self.bgcolor = bgcolor if bgcolor else style.groupBG
         self.pgram_var = pgram_var = Tk_.IntVar(self,
-            value=prefs['cusp_parallelogram'])
+            value=settings['cusp_parallelogram'])
         self.Ford_var = Ford_var = Tk_.IntVar(self,
-            value=prefs['cusp_ford_domain'])
+            value=settings['cusp_ford_domain'])
         self.tri_var = tri_var = Tk_.IntVar(self,
-            value=prefs['cusp_triangulation'])
+            value=settings['cusp_triangulation'])
         self.horo_var = horo_var = Tk_.IntVar(self,
-            value=prefs['cusp_horoballs'])
+            value=settings['cusp_horoballs'])
         self.label_var = label_var = Tk_.IntVar(self,
-            value=prefs['cusp_labels'])
+            value=settings['cusp_labels'])
         self.flip_var = flip_var = Tk_.BooleanVar(self)
         self.columnconfigure(0, weight=1)
         self.rowconfigure(1, weight=1)
@@ -55,7 +57,7 @@ class HoroballViewer(ttk.Frame):
         self.bottomframe = bottomframe = ttk.Frame(self)
         self.widget = widget = OpenGLOrthoWidget(master=bottomframe,
             width=600, height=500, fovy=3.0, depth=1, double=True, swapinterval=0,
-            help = """
+            help="""
 Use the mouse to drag the scene relative to the fundamental parallelogram.
 
 Use the sliders to adjust the sizes of the horoballs. Color coding indicates who bumps whom.
@@ -76,7 +78,7 @@ Use the View Options to select which components of the scene are drawn.
             widget.set_background(1.0,1.0,1.0)
         widget.autospin_allowed = 0
         cyglSetStandardLighting()
-        option_frame= ttk.Frame(top_frame)
+        option_frame = ttk.Frame(top_frame)
         view_button = ttk.Menubutton(option_frame, text='View Options')
         self.view_menu = view_menu = Tk_.Menu(view_button, tearoff=0)
         view_menu.add_checkbutton(label='parallelogram', command=self.view_check,
@@ -92,13 +94,13 @@ Use the View Options to select which components of the scene are drawn.
         view_button.config(menu=view_menu)
         view_button.grid(row=0, column=0, columnspan=2, sticky=Tk_.W, padx=0, pady=0)
         flip_button = ttk.Checkbutton(option_frame, text='Flip',
-                                      variable = self.flip_var,
+                                      variable=self.flip_var,
                                       takefocus=False,
                                       command=self.flip)
         flip_button.grid(row=1, column=0, sticky=Tk_.W, padx=0, pady=0)
         self.cutoff_label = ttk.Label(option_frame, text='Cutoff: ')
         self.cutoff_var = cutoff_var = Tk_.StringVar(self,
-            value='%.4f'%self.cutoff)
+            value='%.4f' % self.cutoff)
         self.cutoff_entry = ttk.Entry(option_frame, width=6, takefocus=False,
                                       textvariable=cutoff_var)
         self.cutoff_entry.bind('<Return>', self.set_cutoff)
@@ -144,27 +146,27 @@ Use the View Options to select which components of the scene are drawn.
         self.scene = HoroballScene(nbhd, pgram_var, Ford_var, tri_var,
             horo_var, label_var, flipped=self.flip_var.get(), cutoff=self.cutoff,
             which_cusp=self.which_cusp,togl_widget=self.widget)
-        self.widget.redraw_impl = self.scene.draw
-        if isinstance(master, Tk_.Toplevel):
-            master.config(menu=self.menubar)
+        self.widget.draw_projection_impl = self.scene.draw
+        if isinstance(parent, Tk_.Toplevel):
+            parent.config(menu=self.menubar)
             # hacks needed on Sierra
             self.after(20, self.configure_sliders)
             self.after(50, self.rebuild)
         else:
             self.configure_sliders()
 
-    def apply_prefs(self, prefs):
-        for key in self.prefs:
-            value = prefs.get(key, 'missing')
+    def apply_settings(self, settings):
+        for key in self.settings:
+            value = settings.get(key, 'missing')
             if value != 'missing':
-                self.prefs[key] = value
-        self.pgram_var.set(prefs['cusp_parallelogram'])
-        self.Ford_var.set(prefs['cusp_ford_domain'])
-        self.tri_var.set(prefs['cusp_triangulation'])
-        self.horo_var.set(prefs['cusp_horoballs'])
-        self.label_var.set(prefs['cusp_labels'])
-        self.cutoff = float(prefs['cusp_cutoff'])
-        self.cutoff_var.set('%.4f'%self.cutoff)
+                self.settings[key] = value
+        self.pgram_var.set(settings['cusp_parallelogram'])
+        self.Ford_var.set(settings['cusp_ford_domain'])
+        self.tri_var.set(settings['cusp_triangulation'])
+        self.horo_var.set(settings['cusp_horoballs'])
+        self.label_var.set(settings['cusp_labels'])
+        self.cutoff = float(settings['cusp_cutoff'])
+        self.cutoff_var.set('%.4f' % self.cutoff)
         self.rebuild()
 
     def view_check(self):
@@ -172,7 +174,7 @@ Use the View Options to select which components of the scene are drawn.
             self.widget.set_background(0.3, 0.3, 0.4)
         else:
             self.widget.set_background(1.0, 1.0, 1.0)
-        self.widget.redraw_if_initialized()
+        self.widget.redraw()
 
     def build_sliders(self):
         nbhd = self.nbhd
@@ -206,7 +208,7 @@ Use the View Options to select which components of the scene are drawn.
                 tie_button.grid(row=n+1, column=1)
                 self.tie_buttons.append(tie_button)
             R, G, B, A = GetColor(nbhd.original_index(n))
-            self.cusp_colors.append('#%.3x%.3x%.3x'%(
+            self.cusp_colors.append('#%.3x%.3x%.3x' % (
                 int(R*4095), int(G*4095), int(B*4095)))
             self.cusp_vars.append(Tk_.IntVar(self))
             self.slider_frames.append(Tk_.Frame(self.slider_frame, borderwidth=0))
@@ -229,7 +231,7 @@ Use the View Options to select which components of the scene are drawn.
             volume_label.grid(row=n+1, column=3, sticky=Tk_.W)
             self.volume_labels.append(volume_label)
 
-    def new_scene (self, new_nbhd):
+    def new_scene(self, new_nbhd):
         self.nbhd = new_nbhd
         self.empty = (self.nbhd is None)
         self.set_ties()
@@ -262,7 +264,7 @@ Use the View Options to select which components of the scene are drawn.
             flipped=self.flip_var.get(), cutoff=self.cutoff,
             which_cusp=self.which_cusp, togl_widget=self.widget)
         assert(self.scene is not None)
-        self.widget.redraw_impl = self.scene.draw
+        self.widget.draw_projection_impl = self.scene.draw
         self.configure_sliders()
         self.rebuild()
 
@@ -276,7 +278,7 @@ Use the View Options to select which components of the scene are drawn.
         flipped = self.flip_var.get()
         self.scene.flip(flipped)
         self.widget.flipped = flipped
-        self.widget.redraw_if_initialized()
+        self.widget.redraw()
 
     def configure_sliders(self):
         nbhd = self.nbhd
@@ -294,7 +296,7 @@ Use the View Options to select which components of the scene are drawn.
             # print stop, length, disp position
             self.cusp_sliders[n].set(position)
             self.slider_frames[n].config(background=stopper_color)
-            self.volume_labels[n].config(text='%.4f'%nbhd.volume(n))
+            self.volume_labels[n].config(text='%.4f' % nbhd.volume(n))
             self.cusp_sliders[n].config(length=length,
                                         command=self.update_radius)
         self.update_idletasks()
@@ -311,17 +313,17 @@ Use the View Options to select which components of the scene are drawn.
 
     # Subclasses may override this, e.g. if they use a help menu.
     def add_help(self):
-        help = Button(self.top_frame, text = 'Help', width = 4,
+        help = Button(self.top_frame, text='Help', width=4,
                       borderwidth=0, highlightthickness=0,
-                      background=self.bgcolor, command = self.widget.help)
+                      background=self.bgcolor, command=self.widget.help)
         help.grid(row=0, column=5, sticky=E, pady=3)
         self.top_frame.columnconfigure(5, weight=1)
 
-  # Subclasses may override this to provide menus.
+    # Subclasses may override this to provide menus.
     def build_menus(self):
         pass
 
-  # Subclasses may override this to update menus, e.g. when embedded in a larger window.
+    # Subclasses may override this to update menus, e.g. when embedded in a larger window.
     def update_menus(self, menubar):
         pass
 
@@ -329,7 +331,7 @@ Use the View Options to select which components of the scene are drawn.
         self.destroy()
 
     def redraw(self):
-        self.widget.redraw_if_initialized()
+        self.widget.redraw()
 
     def set_zoom(self, x):
         fovy = 1.0 + (100.0-float(x))/15.0
@@ -340,14 +342,14 @@ Use the View Options to select which components of the scene are drawn.
         else:
             self.update_idletasks()
             self.after(50, self.set_zoom, x)
-        self.widget.redraw_if_initialized()
+        self.widget.redraw()
 
     def rebuild(self, full_list=True):
         self.set_ties()
         self.configure_sliders()
         self.widget.make_current()
         self.scene.build_scene(which_cusp=self.which_cusp, full_list=full_list)
-        self.widget.redraw_if_initialized()
+        self.widget.redraw()
 
     def start_radius(self, event):
         self.cusp_moving = True