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

snappy/ptolemy/utilities.py

@@ -1,18 +1,19 @@
 import re
 
 ###########################################
-### Methods to prepare and quote ASCII text
+#   Methods to prepare and quote ASCII text
+
 
 def _break_line_iterator(line, line_length):
     for i in range(0, len(line), line_length):
-        yield line[i:i+line_length]
+        yield line[i:i + line_length]
 
 
-def break_long_lines(text, line_length = 76):
+def break_long_lines(text, line_length=76):
     """
     Break lines in ASCII text text longer than line_length by inserting
     newline characters preceded by backslash (thus the resulting lines might
-    be one character longer than ling_length).
+    be one character longer than line_length).
 
     The reverse operation is join_long_lines, so
     join_long_lines(break_long_lines(text)) is always returning text as long as
@@ -43,28 +44,29 @@ def break_long_lines(text, line_length = 76):
     def split_ending_backslash(line):
         if len(line) > 0 and line[-1] == '\\':
             return line[:-1], '\\\\\n'
-        else:
-            return line, ''
+        return line, ''
 
     def process_line(line):
         line_without, ending_backslash = split_ending_backslash(line)
-        
+
         return ('\\\n'.join(_break_line_iterator(line_without, line_length)) +
                 ending_backslash)
 
-    return '\n'.join([process_line(line) for line in text.split('\n')])
+    return '\n'.join(process_line(line) for line in text.split('\n'))
+
 
 def join_long_lines(text):
     """
     Deletes all backslash newline sequences. Inverse of break_long_lines.
     """
+    return text.replace('\\\n', '')
 
-    return text.replace('\\\n','')
 
 def join_long_lines_deleting_whitespace(text):
     """
     Similar to join_long_lines, but also deletes whitespace following a
     backslash newline sequence.
+
     Programs such as magma break long integers by introducing a backslash
     newline sequence and inserting extra whitespace for formatting.
     join_long_lines_deleting_whitespace can be used to undo this and parse
@@ -75,8 +77,7 @@ def join_long_lines_deleting_whitespace(text):
     >>> join_long_lines_deleting_whitespace("    1234\\\\\\n    5678").strip()
     '12345678'
     """
-
-    return re.sub(r'\\\n\s*','', text)
+    return re.sub(r'\\\n\s*', '', text)
 
 
 def quote_ascii_text(text):
@@ -84,10 +85,11 @@ def quote_ascii_text(text):
     Put the text in double quotes after escapes newlines, backslashes and
     double quotes. Giving the result of quote_ascii_text to eval should give
     the original string back if the string contained only ASCII characters.
+
     Similarly, giving the result of quote_ascii_text to magma's print,
     should give the original string back (magma's print might wrap long lines
     though).
-    
+
     >>> text = 'Backslash:\\, Newline:\n, Quote: "'
     >>> quote_ascii_text(text)
     '"Backslash:\\\\, Newline:\\n, Quote: \\""'
@@ -104,20 +106,22 @@ def quote_ascii_text(text):
             return '\\"'
         return char
 
-    return '"' + ''.join([process_char(c) for c in text]) + '"'
+    return '"' + ''.join(process_char(c) for c in text) + '"'
+
 
 ##########################################################################
-### Iterators going through all tuples of integers with a certain property
+#   Iterators going through all tuples of integers with a certain property
 
 def _lists_with_fixed_sum_iterator(N, l):
     if l == 1:
-        yield [ N ]
+        yield [N]
     else:
         for i in range(N + 1):
-            for j in _lists_with_fixed_sum_iterator(N-i, l-1):
+            for j in _lists_with_fixed_sum_iterator(N - i, l - 1):
                 yield [i] + j
 
-def tuples_with_fixed_sum_iterator(N, l, skipVertices = False):
+
+def tuples_with_fixed_sum_iterator(N, l, skipVertices=False):
     """
     Iterates through all l-tuples of non-negative integers summing up to N in
     lexicographic order. If skipVertices is True, N-tuples containing N, i.e.,
@@ -129,47 +133,45 @@ def tuples_with_fixed_sum_iterator(N, l, skipVertices = False):
     [(0, 1, 1), (1, 0, 1), (1, 1, 0)]
 
     """
-
     for i in _lists_with_fixed_sum_iterator(N, l):
-        if not (skipVertices and (N in i)):
+        if not (skipVertices and N in i):
             yield tuple(i)
 
-def triples_with_fixed_sum_iterator(N, skipVertices = False):
+
+def triples_with_fixed_sum_iterator(N, skipVertices=False):
     """
     Similar to tuples_with_fixed_sum_iterator for triples.
 
     >>> list(triples_with_fixed_sum_iterator(2, skipVertices = True))
     [(0, 1, 1), (1, 0, 1), (1, 1, 0)]
     """
+    return tuples_with_fixed_sum_iterator(N, 3, skipVertices=skipVertices)
 
-    return tuples_with_fixed_sum_iterator(N, 3, skipVertices = skipVertices)
-
-def quadruples_with_fixed_sum_iterator(N, skipVertices = False):
 
+def quadruples_with_fixed_sum_iterator(N, skipVertices=False):
     """
     Similar to tuples_with_fixed_sum_iterator for quadruples.
 
     >>> list(quadruples_with_fixed_sum_iterator(2, skipVertices = True))
     [(0, 0, 1, 1), (0, 1, 0, 1), (0, 1, 1, 0), (1, 0, 0, 1), (1, 0, 1, 0), (1, 1, 0, 0)]
     """
+    return tuples_with_fixed_sum_iterator(N, 4, skipVertices=skipVertices)
 
-    return tuples_with_fixed_sum_iterator(N, 4, skipVertices = skipVertices)
 
 ############################################################################
-### A subclass of Python list such that calling a method calls the method on
-### every object in the list.
-
-def _flatten(l, depth = 1):
+#   A subclass of Python list such that calling a method calls the method on
+#   every object in the list.
 
+def _flatten(l, depth=1):
     """
     Flatten a list or subclass of list. It will flatten the
     list until the given depth.
+
     >>> _flatten([0, [1, 2], [[3, 4], 5]], depth = 1)
     [0, 1, 2, [3, 4], 5]
     >>> _flatten([0, [1, 2], [[3, 4], 5]], depth = 2)
     [0, 1, 2, 3, 4, 5]
     """
-
     if depth == 0:
         return l
 
@@ -182,12 +184,12 @@ def _flatten(l, depth = 1):
             result.append(e)
 
     if isinstance(l, MethodMappingList):
-        return type(l)(result, p = l)
+        return type(l)(result, p=l)
 
     return result
 
+
 class MethodMappingList(list):
-    
     """
     Like a list but allows calling a method on it means that it is called
     for all its elements.
@@ -197,7 +199,7 @@ class MethodMappingList(list):
     [(2-1j), (3-2j), (4-2j)]
 
     This can be nested:
-    
+
     >>> b = MethodMappingList([1+1j, a])
     >>> b.conjugate()
     [(1-1j), [(2-1j), (3-2j), (4-2j)]]
@@ -206,24 +208,22 @@ class MethodMappingList(list):
 
     >>> b.flatten()
     [(1+1j), (2+1j), (3+2j), (4+2j)]
-    
+
     """
 
-    def __init__(self, l = [], p = None):
-        super(MethodMappingList, self).__init__(l)
+    def __init__(self, l=[], p=None):
+        super().__init__(l)
 
     def __call__(self, *args, **kwargs):
-        
         return type(self)([elt(*args, **kwargs) for elt in self],
-                          p = self)
+                          p=self)
 
     def __getattr__(self, attr):
-
         return type(self)([getattr(e, attr) for e in self],
-                          p = self)
+                          p=self)
 
-    def flatten(self, depth = 1):
-        return _flatten(self, depth = depth)
+    def flatten(self, depth=1):
+        return _flatten(self, depth=depth)
 
 
 def _test():
@@ -233,6 +233,4 @@ def _test():
     ...     if not join_long_lines(break_long_lines(text, i)) == text:
     ...         raise Exception("Test failure")
     """
-
     pass
-    

snappy/raytracing/__init__.py

@@ -0,0 +1,64 @@
+from ..exceptions import NonorientableManifoldError
+from . import cohomology_fractal
+
+try:
+    from ..gui import ViewerWindow
+    from .inside_viewer import InsideViewer
+except ImportError as e:
+    InsideViewer = None
+    _importErrorRaytracing = str(e)
+
+from typing import Sequence
+
+def inside_view(self, cohomology_class=None, geodesics : Sequence[str]=[]):
+    r"""
+    Show raytraced inside view of hyperbolic manifold. See
+    `images <https://im.icerm.brown.edu/portfolio/snappy-views/>`_
+    and `demo video <https://youtu.be/CAERhmUCkRs>`_.
+
+        >>> M = Manifold("m004")
+        >>> M.inside_view() #doctest: +CYMODERNOPENGL
+
+    Or show the cohomology fractal:
+
+        >>> M = Manifold("m004")
+        >>> M.inside_view(cohomology_class = 0) #doctest: +CYMODERNOPENGL
+
+    The cohomology class in :math:`H^2(M, \partial M; \mathbb{R})` producing the
+    cohomology fractal can be specified as a cocycle or using an automatically
+    computed basis (of, say, length ``n``). Thus, ``cohomology_class`` can be
+    one of the following.
+
+    - An integer ``i`` between 0 and ``n`` - 1 to pick the ``i``-th basis
+      vector.
+    - An array of length ``n`` specifying the cohomology class as linear
+      combination of basis vectors.
+    - A weight for each face of each tetrahedron.
+
+    Geodesics can be specified as words in the unsimplified fundamental group:
+
+        >>> M = Manifold("m004")
+        >>> M.inside_view(geodesics=['a', 'bC']) #doctest: +CYMODERNOPENGL
+
+    """
+
+    if InsideViewer is None:
+        raise RuntimeError("Raytraced inside view not imported; "
+        "Tk or CyOpenGL is probably missing "
+        "(original error : %s)" % _importErrorRaytracing)
+
+    if not self.is_orientable():
+        raise NonorientableManifoldError("Manifold.inside_view", self)
+
+    weights, cohomology_basis, cohomology_class = (
+        cohomology_fractal.compute_weights_basis_class(
+            self, cohomology_class))
+
+    return ViewerWindow(
+        InsideViewer,
+        self,
+        title="Inside view of %s" % self.name(),
+        weights=weights,
+        cohomology_basis=cohomology_basis,
+        cohomology_class=cohomology_class,
+        geodesics=geodesics)

snappy/raytracing/additional_horospheres.py

@@ -0,0 +1,64 @@
+"""
+from snappy import *; from snappy.raytracing.additional_horospheres import *
+
+M=Manifold("t10879")
+M=CubicalOrientableCuspedCensus[0]
+v = M.inside_view()
+a=AdditionalHorospheres(M)
+v.view.widget.additional_structures['horospheres'] = a; v.view.widget._update_shader()
+
+"""
+
+from ..geometric_structure.cusp_neighborhood.tiles_for_cusp_neighborhood import mcomplex_for_tiling_cusp_neighborhoods
+from .pack import pack_tet_data
+from .upper_halfspace_utilities import add_coordinate_transform_to_mcomplex
+
+class AdditionalHorospheres:
+    def __init__(self, manifold):
+
+        self.mcomplex = mcomplex_for_tiling_cusp_neighborhoods(
+            manifold, bits_prec = 53, verified = False)
+        add_coordinate_transform_to_mcomplex(self.mcomplex)
+
+        self.num_tetrahedra = manifold.num_tetrahedra()
+        self.RF = manifold.tetrahedra_shapes('rect')[0].real().parent()
+        self.cusp_areas = [ 1.0 for v in self.mcomplex.Vertices ]
+
+        self._num = 0
+
+        self.compute_bindings()
+        
+    def get_compile_time_defs(self):
+        if self._num > 0:
+            num = max(100, self._num)
+        else:
+            num = 0
+
+        return { 'num_additional_horospheres' : num }
+
+    def get_uniform_bindings(self):
+        return self._uniform_bindings
+
+    def compute_bindings(self):
+
+        tets_to_data = [ [] for i in range(self.num_tetrahedra) ]
+
+        for cusp_index, v in enumerate(self.mcomplex.Vertices):
+            scale = (self.RF(self.cusp_areas[cusp_index]) / v.cusp_area).sqrt()
+
+            d = scale.log()
+
+            for tile in v.tiles():
+                if tile.lower_bound_distance > d:
+                    break
+
+                tet = tile.lifted_tetrahedron.tet
+                
+                s = (
+                    tet.to_coordinates_in_symmetric_tet * tile.inverse_lifted_geometric_object.defining_vec) / scale
+
+                tets_to_data[tet.Index].append(
+                    { 'Vec' : ('vec4', s),
+                      'CuspIndex' : ('int', cusp_index) })
+                
+        self._uniform_bindings, self._num = pack_tet_data('additionalHorospheres.horosphere', tets_to_data)

snappy/raytracing/additional_len_spec_choices.py

@@ -0,0 +1,63 @@
+"""
+from snappy import *; from snappy.raytracing.additional_len_spec_choices import *
+
+M=Manifold("t10879")
+M=CubicalOrientableCuspedCensus[0]
+v = M.inside_view()
+a=AdditionalLenSpecChoices(M)
+v.view.widget.additional_structures['lenSpec'] = a; v.view.widget._update_shader()
+
+"""
+
+from ..len_spec import mcomplex_for_len_spec
+
+from .pack import pack_tet_data
+from .upper_halfspace_utilities import add_coordinate_transform_to_mcomplex
+from ..snap.t3mlite import simplex
+
+class AdditionalLenSpecChoices:
+    def __init__(self, manifold):
+
+        self.mcomplex = mcomplex_for_len_spec(
+            manifold, bits_prec = 53, verified = False)
+        add_coordinate_transform_to_mcomplex(self.mcomplex)
+
+        self._num = 0
+
+        self.compute_bindings()
+
+    def get_compile_time_defs(self):
+        if self._num > 0:
+            num = max(100, self._num)
+        else:
+            num = 0
+
+        return { 'num_additional_horospheres' : num,
+                 'has_edge_midpoints' : 1}
+
+    def get_uniform_bindings(self):
+        return self._uniform_bindings
+
+    def compute_bindings(self):
+        self._uniform_bindings, self._num = pack_tet_data(
+            'additionalHorospheres.horosphere',
+            self._get_data())
+        self._uniform_bindings['edgeMidpoints.edgeMidpointVec'] = (
+            'vec4[]', [ tet.to_coordinates_in_symmetric_tet * tet.spine_points[e]
+                        for tet in self.mcomplex.Tetrahedra
+                        for e in simplex.OneSubsimplices ])
+        self._uniform_bindings['edgeMidpointRadiusParam'] = (
+            'float', 1.002)
+
+    def _get_data(self):
+        return [ [ _data_for_vert(tet, v) for v in simplex.ZeroSubsimplices ]
+                 for tet in self.mcomplex.Tetrahedra ]
+
+def _data_for_vert(tet, v):
+    return {
+        'Vec' :(
+            'vec4',
+            tet.to_coordinates_in_symmetric_tet * tet.R13_vertices[v]),
+        'CuspIndex' : (
+            'int',
+            tet.Class[v].Index) }

snappy/raytracing/cohomology_fractal.py

@@ -12,6 +12,7 @@ faces). Some helpers convert weights stored per face class to weights
 stored per face per tetrahedron.
 """
 
+
 def face_var_name_to_index(var_name):
     """
     Convert variable name to index in array of weights.
@@ -27,32 +28,33 @@ def face_var_name_to_index(var_name):
             "Variable name '%s' for face class invalid" % var_name)
     return 4 * int(tet_index) + int(face_index)
 
+
 def value_for_face_class(weights, face_class):
     """
     Given weights per face per tetrahedron and a face_class as encoded
     by the ptolemy module, extract the weight for that face_class and
     perform consistency check.
     """
-    
+
     sgn, power, repr0, repr1 = face_class
 
     # Weight for one representative of face class
     val0 = weights[face_var_name_to_index(repr0)]
     # Weight for other representative of face class
     val1 = weights[face_var_name_to_index(repr1)]
-    
+
     # Check weights match
     if abs(val0 - sgn * val1) > 1e-6:
         raise ValueError("Weights for identified faces do not match")
 
     return val0
 
+
 def check_weights_valid(trig, weights):
     """
     Given a SnapPy triangulation and weights per face per tetrahedron,
     check they are consistent across glued faces and form a 2-cocycle.
 
-        >>> from snappy import Manifold
         >>> check_weights_valid(Manifold("m015"), [1, 0, 0, 0, -1, 0, 0, 1, -1, 0, 0, 0])
         >>> check_weights_valid(Manifold("m004"), [0, 1, 0, 1, 0, 0, -1, -2])
         Traceback (most recent call last):
@@ -72,6 +74,7 @@ def check_weights_valid(trig, weights):
         [ value_for_face_class(weights, face_class)
           for face_class in face_classes ])
 
+
 def check_face_class_weights_valid(trig, weights):
     """
     Given a SnapPy triangulation and weights per face class, check they
@@ -84,6 +87,7 @@ def check_face_class_weights_valid(trig, weights):
         if abs(total) > 1e-6:
             raise ValueError("Weights are not a 2-cocycle.")
 
+
 def compute_signs_and_face_class_indices(trig):
     """
     An array helpful to convert weights per face class to weights per
@@ -99,13 +103,13 @@ def compute_signs_and_face_class_indices(trig):
         result[face_var_name_to_index(repr1)] = (sgn, i)
     return result
 
+
 def rational_cohomology_basis(trig):
     """
     Given a SnapPy triangulation, give 2-cocycles encoded as weights
     per face per tetrahedron that generate the second rational cohomology
     group.
 
-        >>> from snappy import Manifold
         >>> rational_cohomology_basis(Manifold("m125"))
         [[-1, -4, -2, 0, 1, 0, 0, 0, 0, 4, 1, 2, -1, 0, 0, 0], [0, 5, 2, 0, 0, 0, 0, 1, 0, -5, 0, -2, 0, 0, 0, -1]]
 
@@ -135,12 +139,12 @@ def rational_cohomology_basis(trig):
           for sgn, index in signs_and_face_class_indices ]
         for two_cocycle in rational_two_cocycles ]
 
+
 def compute_weights_basis_class(trig, cohomology_class):
     """
     Convenience method to quickly access cohomology classes for
     M.inside_view().
 
-        >>> from snappy import Manifold
         >>> compute_weights_basis_class(Manifold("m004"), None)
         (None, None, None)
         >>> compute_weights_basis_class(Manifold("m003"), [1, 0, 0, 1, -1, 0, 0, -1])
@@ -176,7 +180,7 @@ def compute_weights_basis_class(trig, cohomology_class):
         basis = rational_cohomology_basis(trig)
         if len(as_list) == len(basis):
             return None, basis, as_list
-        
+
         raise ValueError(
             ("Expected array of length %d or %d either assigning one number "
              "for each basis vector of the second rational cohomology group "

snappy/raytracing/eyeball.py

@@ -0,0 +1,123 @@
+from ..hyperboloid import o13_inverse
+from ..hyperboloid.point import R13Point
+
+from ..tiling.tile import compute_tiles
+from ..tiling.lifted_tetrahedron import LiftedTetrahedron
+from ..tiling.lifted_tetrahedron_set import (LiftedTetrahedronSet,
+                                             get_lifted_tetrahedron_set)
+from ..tiling.triangle import add_triangles_to_tetrahedra
+
+from ..matrix import make_matrix, make_vector
+
+from ..matrix import matrix
+
+import math
+
+eyeball_type_none = 0
+eyeball_type_paper_plane = 1
+eyeball_type_eyeball = 2
+
+_max_num_eyeballs = 40
+
+class Eyeball:
+    def __init__(self, raytracing_view):
+        self.raytracing_view = raytracing_view
+
+        self.mcomplex = self.raytracing_view.raytracing_data.mcomplex
+        self.num_tetrahedra = len(self.mcomplex.Tetrahedra)
+
+        self._added_triangles = False
+
+        self.view_state = None
+
+    def _enabled(self):
+        return (
+            self.raytracing_view.ui_parameter_dict['eyeballSize'][1] > 0 and
+            self.raytracing_view.ui_parameter_dict['eyeballType'][1] > eyeball_type_none)
+
+    def get_compile_time_defs(self):
+        if not self._enabled():
+            return {}
+
+        d = { 'num_eyeballs' : _max_num_eyeballs,
+              'eyeball_type' : self.raytracing_view.ui_parameter_dict['eyeballType'][1]}
+
+        return d
+
+    def get_uniform_bindings(self):
+        if not self._enabled():
+            return {}
+
+        if not self._added_triangles:
+            add_triangles_to_tetrahedra(self.mcomplex)
+            self._added_triangles = True
+
+        if self.view_state is None or (
+                not self.raytracing_view.ui_parameter_dict['freezeEyeball'][1]):
+            self.view_state = self.raytracing_view.view_state
+
+        boost, tet_num, current_weight = self.view_state
+
+        RF = self.raytracing_view.raytracing_data.RF
+        
+        boost = make_matrix(boost, ring=RF)
+
+        base_point = make_vector([b[0] for b in boost])
+
+        eyeballRadius = self.raytracing_view.ui_parameter_dict['eyeballSize'][1]
+        if self.raytracing_view.ui_parameter_dict['eyeballType'][1] == eyeball_type_eyeball:
+            eyeballRadius = eyeballRadius / 2.0
+        tets_to_data = [ [] for i in range(self.num_tetrahedra) ]
+
+        initial_lifted_tetrahedron = LiftedTetrahedron(
+            self.mcomplex.Tetrahedra[tet_num], matrix.identity(RF, 4))
+
+        cut_off = RF(1.0 + 1e-5)
+
+        lifted_tetrahedron_set : LiftedTetrahedronSet = (
+            get_lifted_tetrahedron_set(
+                base_point=base_point,
+                act_on_base_point_by_inverse=True,
+                max_neg_prod_equal=cut_off,
+                min_neg_prod_distinct=cut_off,
+                canonical_keys_function=None,
+                verified=False))
+
+        for i, tile in enumerate(
+                compute_tiles(
+                    geometric_object=R13Point(base_point),
+                    visited_lifted_tetrahedra=lifted_tetrahedron_set,
+                    initial_lifted_tetrahedra=[ initial_lifted_tetrahedron ],
+                    verified=False)):
+
+            if i == _max_num_eyeballs:
+                break
+            if tile.lower_bound_distance > eyeballRadius:
+                break
+
+            m = o13_inverse(boost) * tile.lifted_tetrahedron.o13_matrix
+
+            tets_to_data[tile.lifted_tetrahedron.tet.Index].append((
+                tile.inverse_lifted_geometric_object.point,
+                m,
+                o13_inverse(m)))
+        
+        eyeballPositions = []
+        eyeballInvEmbeddings = []
+        eyeballEmbeddings = []
+        eyeballOffsets = []
+
+        for data in tets_to_data:
+            eyeballOffsets.append(len(eyeballPositions))
+            for eyeballPosition, eyeballInvEmbedding, eyeballEmbedding in data:
+                eyeballPositions.append(eyeballPosition)
+                eyeballInvEmbeddings.append(eyeballInvEmbedding)
+                eyeballEmbeddings.append(eyeballEmbedding)
+        eyeballOffsets.append(len(eyeballPositions))
+
+        return {
+            'eyeballRadius' : ('float', eyeballRadius),
+            'eyeballs.eyeballPositions' : ('vec4[]', eyeballPositions),
+            'eyeballs.eyeballInvEmbeddings' : ('mat4[]', eyeballInvEmbeddings),
+            'eyeballs.eyeballEmbeddings' : ('mat4[]', eyeballEmbeddings),
+            'eyeballs.eyeballOffsets' : ('int[]', eyeballOffsets) }