snappy 3.3__cp310-cp310-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl

snappy/geometric_structure/geodesic/tiles_for_geodesic.py

@@ -0,0 +1,128 @@
+from .canonical_representatives import canonical_representatives_for_line
+from .geodesic_start_point_info import GeodesicStartPointInfo
+from .avoid_core_curves import replace_piece_in_core_curve_tube
+from .line import R13LineWithMatrix
+
+from ...matrix import make_identity_matrix
+from ...tiling.tile import Tile, compute_tiles
+from ...tiling.lifted_tetrahedron import LiftedTetrahedron
+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.")
+
+    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_for_line(
+            mcomplex, geodesic.line, for_raytracing = for_raytracing),
+        initial_lifted_tetrahedra=geodesic.lifted_tetrahedra,
+        replace_lifted_tetrahedron_function=replace_lifted_tetrahedron_function,
+        verified=mcomplex.verified)
+
+def compute_tiles_for_core_curve(mcomplex : Mcomplex,
+                                 core_curve : int
+                                 ) -> Sequence[Tile]:
+    vertex = mcomplex.Vertices[core_curve]
+    corner = vertex.Corners[0]
+    tet = corner.Tetrahedron
+    line : R13LineWithMatrix = tet.core_curves[corner.Subsimplex]
+
+    initial_lifted_tetrahedron = LiftedTetrahedron(
+        tet, make_identity_matrix(ring=mcomplex.RF, n=4))
+
+    return compute_tiles(
+        geometric_object=line.r13_line,
+        visited_lifted_tetrahedra = _lifted_tetrahedron_set_for_line(
+            mcomplex, line),
+        initial_lifted_tetrahedra = [ initial_lifted_tetrahedron ],
+        verified=mcomplex.verified)
+
+def _lifted_tetrahedron_set_for_line(
+        mcomplex : Mcomplex,
+        line : R13LineWithMatrix,
+        for_raytracing : bool = False
+    ) -> LiftedTetrahedronSet:
+
+    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
+
+    return get_lifted_tetrahedron_set(
+        base_point=mcomplex.R13_baseTetInCenter,
+        canonical_representatives_function=(
+            canonical_representatives_for_line(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)
+
+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

@@ -0,0 +1,121 @@
+# -*- coding: utf-8 -*-
+import os
+import sys
+import time
+import tempfile
+import tkinter as Tk_
+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 plink.ipython_tools import IPythonTkRoot
+from . import filedialog
+
+    
+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()}
+
+
+class SnapPyStyle:
+    def __init__(self):
+        self.ttk_style = ttk_style = ttk.Style()
+        # The windowBG, groupBG and subgroupBG colors can be used to match Tk objects to
+        # Ttk containers.
+        if sys.platform == 'darwin':
+            try:
+                # check if our Tk supports the new semantic colors
+                test = Tk_._default_root.winfo_rgb('systemWindowBackgroundColor1')
+                self.windowBG = 'systemWindowBackgroundColor'
+                self.groupBG = 'systemWindowBackgroundColor1'
+                self.subgroupBG = 'systemWindowBackgroundColor2'
+            except:
+                # These will be wrong in dark mode.
+                self.windowBG = '#ededed'
+                self.groupBG = '#e5e5e5'
+                self.subgroupBG = '#dddddd'
+        else:
+            self.windowBG = ttk_style.lookup('TLabelframe', 'background')
+            self.groupBG = self.subgroupBG = self.windowBG
+
+        self.font = ttk_style.lookup('TLabel', 'font')
+        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, self.root, class_='snappy')
+        self.protocol("WM_DELETE_WINDOW", self.close)
+        self.title(string=kwargs.pop('title', ''))
+        self.view = view_class(self, *args, **kwargs)
+        self.view.pack(expand=True, fill=Tk_.BOTH)
+        self.update_idletasks()
+
+    def __repr__(self):
+        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.withdraw()
+        return root
+
+    def save_image(self):
+        """
+        Helper for the save_image menu command of a ViewerWindow.
+        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
+        savefile = filedialog.asksaveasfile(
+            parent=self,
+            mode='wb',
+            title='Save Image As PNG Image File',
+            defaultextension='.png',
+            filetypes=[
+                ("PNG image files", "*.png *.PNG", ""),
+                ("All files", "")])
+        if savefile:
+            view.widget.save_image_window_resolution(savefile)
+
+    def close(self, event=None):
+        if hasattr(self.view, 'delete_resource'):
+            self.view.delete_resource()
+        self.view = None
+        self.destroy()
+
+    def add_help(self):
+        pass
+
+    def edit_actions(self):
+        return {}
+
+    def test(self):
+        print('Testing viewer for %s' % self.title())
+        time.sleep(0.5)
+        if hasattr(self.view, 'test'):
+            if not self.view.winfo_ismapped():
+                self.view.wait_visibility()
+            self.update()
+            time.sleep(0.5)
+            self.view.focus_force()
+            self.view.test()
+            time.sleep(0.5)
+            self.close()