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

snappy/raytracing/pack.py

@@ -0,0 +1,22 @@
+def pack_tet_data(prefix, tets_to_data):
+    result = {}
+
+    offset = 0
+    offsets = [ offset ]
+
+    for data in tets_to_data:
+        for datum in data:
+            if result:
+                for k, (t, v) in datum.items():
+                    result[prefix + k][1].append(v)
+            else:
+                for k, (t, v) in datum.items():
+                    result[prefix + k] = (t + '[]', [ v ])
+        offset += len(data)
+        offsets.append(offset)
+
+    result[prefix + 'Offsets'] = ('int[]', offsets)
+
+    return result, offset
+
+                

snappy/raytracing/raytracing_data.py

@@ -1,12 +1,17 @@
 from snappy.snap import t3mlite as t3m
 from snappy.snap.mcomplex_base import *
-from snappy.SnapPy import matrix
 
 from .hyperboloid_utilities import *
 
+from ..matrix import make_matrix
+
 __all__ = ['RaytracingData']
 
+
 class RaytracingData(McomplexEngine):
+    def is_valid(self):
+        return True
+
     def add_weights(self, weights):
         for tet in self.mcomplex.Tetrahedra:
             tet.Weights = {
@@ -15,18 +20,18 @@ class RaytracingData(McomplexEngine):
 
     def get_uniform_bindings(self):
         d = {}
-        d['otherTetNums'] = (
+        d['TetrahedraCombinatorics.otherTetNums'] = (
             'int[]',
             [ tet.Neighbor[F].Index
               for tet in self.mcomplex.Tetrahedra
               for F in t3m.TwoSubsimplices ])
 
-        d['otherFaceNums'] = (
+        d['TetrahedraCombinatorics.otherFaceNums'] = (
             'int[]',
             [ tet.Gluing[F][f]
               for tet in self.mcomplex.Tetrahedra
               for f, F in enumerate(t3m.TwoSubsimplices) ])
-        
+
         d['TetrahedraBasics.SO13tsfms'] = (
             'mat4[]',
             [ tet.O13_matrices[F]
@@ -45,19 +50,19 @@ class RaytracingData(McomplexEngine):
               for tet in self.mcomplex.Tetrahedra
               for V in t3m.ZeroSubsimplices ])
 
-        d['face_color_indices'] = (
+        d['Colors.face_color_indices'] = (
             'int[]',
             [ tet.Class[F].Index
               for tet in self.mcomplex.Tetrahedra
               for F in t3m.TwoSubsimplices ])
 
-        d['edge_color_indices'] = (
+        d['Colors.edge_color_indices'] = (
             'int[]',
             [ tet.Class[E].Index
               for tet in self.mcomplex.Tetrahedra
               for E in t3m.OneSubsimplices ])
 
-        d['vertex_color_indices'] = (
+        d['Colors.vertex_color_indices'] = (
             'int[]',
             [ tet.Class[V].Index
               for tet in self.mcomplex.Tetrahedra
@@ -70,7 +75,7 @@ class RaytracingData(McomplexEngine):
               for F in t3m.TwoSubsimplices ])
 
         return d
-    
+
     def get_compile_time_constants(self):
         d = {}
         d[b'##num_tets##'] = len(self.mcomplex.Tetrahedra)
@@ -78,37 +83,44 @@ class RaytracingData(McomplexEngine):
         d[b'##num_edges##'] = len(self.mcomplex.Edges)
         return d
 
-
-    def update_view_state(self, boost_tet_num_and_weight,
-                          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]])):
+    def update_view_state(self,
+                          boost_tet_num_and_weight,
+                          m=make_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]])):
         boost, tet_num, weight = boost_tet_num_and_weight
 
-        boost = matrix(boost, ring = self.RF)
-        m = matrix(m, ring = self.RF)
+        boost = make_matrix(boost, ring=self.RF)
+        m     = make_matrix(m,     ring=self.RF)
+
+        boost, tet, weight = _graph_trace(
+            boost * m, self.mcomplex.Tetrahedra[tet_num], weight)
+
+        return boost, tet.Index, weight
+
+def _graph_trace(boost, tet, weight):
+
+    boost = O13_orthonormalise(boost)
+
+    entry_face = 0
 
-        boost = O13_orthonormalize(boost * m)
+    for i in range(100):
+        pos = boost.transpose()[0]
 
-        entry_F = -1
+        signed_dist, face = max(
+            [ (r13_dot(pos, tet.R13_planes[face]), face)
+              for face in t3m.TwoSubsimplices ])
 
-        for i in range(100):
-            pos = boost.transpose()[0]
-            tet = self.mcomplex.Tetrahedra[tet_num]
+        if face == entry_face:
+            break
+        if signed_dist < 0.0000001:
+            break
 
-            amount, F = max(
-                [ (R13_dot(pos, tet.R13_planes[F]), F)
-                  for F in t3m.TwoSubsimplices ])
+        boost      = O13_orthonormalise(tet.O13_matrices[face] * boost)
+        weight    += tet.Weights[face]
+        entry_face = tet.Gluing[face].image(face)
+        tet        = tet.Neighbor[face]
 
-            if F == entry_F:
-                break
-            if amount < 0.0000001:
-                break
-            
-            boost = O13_orthonormalize(tet.O13_matrices[F] * boost)
-            tet_num = tet.Neighbor[F].Index
-            entry_F = tet.Gluing[F].image(F)
-            weight += tet.Weights[F]
+    return boost, tet, weight
 
-        return boost, tet_num, weight

snappy/raytracing/raytracing_view.py

@@ -1,54 +1,25 @@
-from __future__ import print_function
-
 from .hyperboloid_utilities import *
 from .ideal_raytracing_data import *
 from .finite_raytracing_data import *
 from .hyperboloid_navigation import *
+from .geodesics import Geodesics
+from .eyeball import Eyeball
+from .eyeball import eyeball_type_none, eyeball_type_paper_plane
 from . import shaders
 
-from snappy.CyOpenGL import SimpleImageShaderWidget
+from ..CyOpenGL import SimpleImageShaderWidget
 
-from snappy.SnapPy import vector, matrix
+from ..matrix import make_vector, make_matrix
 
 import math
-
-# We could use
-#
-# from ..sage_helper import _within_sage
-#
-# but then dev/GLSLManifoldInsideView.py cannot be used for
-# debugging anymore.
-
-try:
-    import sage.all
-    _within_sage = True
-except:
-    _within_sage = False
-    import decorator
-
-if _within_sage:
-    from sage.all import RealField, ComplexField
-    RF = RealField()
-    CF = ComplexField()
-else:
-    from snappy.number import Number as RF
-    from snappy.number import Number as CF
-
-__all__ = ['RaytracingView', 'NonorientableUnsupportedError']
-
-class NonorientableUnsupportedError(RuntimeError):
-    def __init__(self, mfd):
-        RuntimeError.__init__(
-            self,
-            ("Inside view for non-orientable manifolds such as %s is not "
-             "supported yet.") % mfd.name())
+__all__ = ['RaytracingView']
 
 _constant_uniform_bindings = {
     'multiScreenShot' : ('int', 0),
     'tile' : ('vec2', [0.0, 0.0]),
     'numTiles' : ('vec2', [1.0, 1.0]),
 
-    'gradientThreshholds' : ('float[]', [0.0, 0.25, 0.45, 0.75, 1.0]),
+    'gradientThresholds' : ('float[]', [0.0, 0.25, 0.45, 0.75, 1.0]),
     'gradientColours' : ('vec3[]', [[1.0, 1.0, 1.0],
                                     [0.86, 0.92, 0.78],
                                     [0.25, 0.70, 0.83],
@@ -84,6 +55,7 @@ _max_linear_camera_speed = 2.0
 # here.
 _max_depth_for_orbiting = 0.9998
 
+
 class RaytracingView(SimpleImageShaderWidget, HyperboloidNavigation):
     def __init__(self,
                  trig_type,
@@ -91,10 +63,17 @@ class RaytracingView(SimpleImageShaderWidget, HyperboloidNavigation):
                  weights,          # Weights for tet faces
                  cohomology_basis, # Each entry are weights for the tet faces
                  cohomology_class, # Number for each entry in basis specifying superposition
-                 master,
+                 geodesics,
+                 container,
                  *args,
                  **kwargs):
 
+        SimpleImageShaderWidget.__init__(
+            self, container,
+            *args, **kwargs)
+
+        self.set_textures(shaders.get_texture_paths())
+
         self.trig_type = trig_type
 
         # The view can be driven in two modes:
@@ -111,11 +90,9 @@ class RaytracingView(SimpleImageShaderWidget, HyperboloidNavigation):
         has_weights = bool(weights or cohomology_class)
 
         self.ui_uniform_dict = {
-            'maxSteps' : ['int', 99 if has_weights else 20],
+            'maxSteps' : ['int', 99 if has_weights else 40],
             'maxDist' : ['float', 6.5 if has_weights else 17.0],
             'subpixelCount': ['int', 1],
-            'fov': ['float', 90],
-            'edgeThickness' : ['float', 0.0000001],
 
             'contrast' : ['float', 0.1 if has_weights else 0.5],
             'noGradient' : ['bool', False],
@@ -124,16 +101,25 @@ class RaytracingView(SimpleImageShaderWidget, HyperboloidNavigation):
             'lightFalloff' : ['float', 1.65],
             'brightness' : ['float', 1.9],
 
-            'showElevation' : ['bool', False]
+            'showElevation' : ['bool', False],
+            'desaturate_edges' : ['bool', False],
+            'viewScale' : ['float', 1.0],
+            'perspectiveType' : ['int', 0],
+            'crosshairs' : ['bool', False]
             }
 
         self.ui_parameter_dict = {
-            'insphere_scale' : ['float', 0.0 if has_weights else 0.05],
+            'insphere_scale' : ['float', 0.0 ],
             'cuspAreas' : ['float[]', manifold.num_cusps() * [ 0.0 if has_weights else 1.0 ]],
+            'edgeThickness' : ['float', 0.0],
             'edgeTubeRadius' : ['float', 0.0 if has_weights else
-                                (0.05 if trig_type == 'finite' else 0.08)],
+                                (0.025 if trig_type == 'finite' else 0.0)],
             'vertexRadius' : ['float', 0.0 if has_weights else 0.25],
-            'perspectiveType' : ['bool', False]
+            'geodesicTubeRadii' : ['float[]', []],
+            'geodesicTubeEnables' : ['bool[]', []],
+            'eyeballSize' : ['float', 0.5],
+            'freezeEyeball' : ['bool', False],
+            'eyeballType' : ['int', eyeball_type_none if has_weights else eyeball_type_paper_plane]
             }
 
         if cohomology_class:
@@ -147,21 +133,26 @@ class RaytracingView(SimpleImageShaderWidget, HyperboloidNavigation):
                 raise Exception(
                     "Expected cohomology_class when given cohomology_basis")
 
+        self.compile_time_constants = {}
+        self.compile_time_defs = {}
+
         self.manifold = manifold
 
+        self.additional_structures = {}
+
         self._unguarded_initialize_raytracing_data()
 
-        self.num_tets = len(self.raytracing_data.mcomplex.Tetrahedra)
+        if self.trig_type == 'ideal':
+            self.additional_structures['geodesics'] = (
+                Geodesics(manifold, geodesics))
+            self.resize_geodesic_params(enable=True)
+            self._update_geodesic_data()
 
-        shader_source, uniform_block_names_sizes_and_offsets = (
-            shaders.get_triangulation_shader_source_and_ubo_descriptors(
-                    self.raytracing_data.get_compile_time_constants()))
+        self.geodesics_disabled_edges = False
+        if geodesics:
+            self.disable_edges_for_geodesics()
 
-        SimpleImageShaderWidget.__init__(
-            self, master,
-            shader_source,
-            uniform_block_names_sizes_and_offsets,
-            *args, **kwargs)
+        self._update_shader()
 
         # Use distance view for now
         self.view = 1
@@ -170,12 +161,22 @@ class RaytracingView(SimpleImageShaderWidget, HyperboloidNavigation):
 
         HyperboloidNavigation.__init__(self)
 
+    def reset_geodesics(self):
+        self.geodesics = Geodesics(self.manifold, [])
+        self.ui_parameter_dict['geodesicTubeRadii'][1] = []
+        self.ui_parameter_dict['geodesicTubeEnables'][1] = []
+        self._update_geodesic_data()
+
     def get_uniform_bindings(self, width, height):
         boost, tet_num, current_weight = self.view_state
 
         result = _merge_dicts(
             _constant_uniform_bindings,
             self.manifold_uniform_bindings,
+            _merge_dicts(
+                *(additional_structure.get_uniform_bindings()
+                  for additional_structure
+                  in self.additional_structures.values())),
             {
                 'currentWeight' : ('float', current_weight),
                 'screenResolution' : ('vec2', [width, height]),
@@ -183,11 +184,11 @@ class RaytracingView(SimpleImageShaderWidget, HyperboloidNavigation):
                 'currentTetIndex' : ('int', tet_num),
                 'viewMode' : ('int', self.view),
                 'edgeTubeRadiusParam' :
-                    ('float', math.cosh(self.ui_parameter_dict['edgeTubeRadius'][1] / 2.0) ** 2 / 2.0),
+                    ('float', math.cosh(self.ui_parameter_dict['edgeTubeRadius'][1]) ** 2 / 2.0),
+                'edgeThicknessParam' :
+                    ('float', math.sinh(self.ui_parameter_dict['edgeThickness'][1]) ** 2),
                 'vertexSphereRadiusParam' :
-                    ('float', math.cosh(self.ui_parameter_dict['vertexRadius'][1])),
-                'perspectiveType' :
-                    ('int', int(self.ui_parameter_dict['perspectiveType'][1]))
+                    ('float', math.cosh(self.ui_parameter_dict['vertexRadius'][1]) ** 2)
             },
             self.ui_uniform_dict
             )
@@ -197,15 +198,7 @@ class RaytracingView(SimpleImageShaderWidget, HyperboloidNavigation):
         return result
 
     def _initialize_raytracing_data(self):
-        if self.manifold.solution_type() in [
-            'all tetrahedra positively oriented',
-            'contains negatively oriented tetrahedra' ]:
-            self._unguarded_initialize_raytracing_data()
-        else:
-            try:
-                self._unguarded_initialize_raytracing_data()
-            except:
-                pass
+        self._unguarded_initialize_raytracing_data()
 
     def _unguarded_initialize_raytracing_data(self):
         weights = self.weights
@@ -220,71 +213,94 @@ class RaytracingView(SimpleImageShaderWidget, HyperboloidNavigation):
         if self.trig_type == 'finite':
             self.raytracing_data = FiniteRaytracingData.from_triangulation(
                 self.manifold,
-                weights = weights)
+                weights=weights)
         else:
             self.raytracing_data = IdealRaytracingData.from_manifold(
                 self.manifold,
-                areas = self.ui_parameter_dict['cuspAreas'][1],
-                insphere_scale = self.ui_parameter_dict['insphere_scale'][1],
-                weights = weights)
-        
+                areas=self.ui_parameter_dict['cuspAreas'][1],
+                insphere_scale=self.ui_parameter_dict['insphere_scale'][1],
+                weights=weights)
+            if self.raytracing_data.is_valid():
+                self.additional_structures['eyeball'] = (
+                    Eyeball(self))
+            else:
+                if 'eyeball' in self.additional_structures:
+                    del self.additional_structures['eyeball']
+
         self.manifold_uniform_bindings = (
             self.raytracing_data.get_uniform_bindings())
 
+    def update_shader_and_redraw(self):
+        self._update_shader()
+        self.draw()
+        
     def recompute_raytracing_data_and_redraw(self):
         self._initialize_raytracing_data()
         self.fix_view_state()
-        self.redraw_if_initialized()
+        self.draw()
+
+    def recompute_raytracing_data_update_shader_and_redraw(self):
+        self._initialize_raytracing_data()
+        self._update_shader()
+        self.fix_view_state()
+        self.draw()
 
     def compute_translation_and_inverse_from_pick_point(
                 self, size, frag_coord, depth):
 
+        RF = self.raytracing_data.RF
+
         # Depth value emitted by shader is tanh(distance from camera)
 
         # Limit the maximal depth for orbiting to avoid numeric issues
         depth = min(depth, _max_depth_for_orbiting)
 
-        fov = self.ui_uniform_dict['fov'][1]
-        isIdeal = self.ui_parameter_dict['perspectiveType'][1]
+        view_scale = self.ui_uniform_dict['viewScale'][1]
+        perspective_type = self.ui_uniform_dict['perspectiveType'][1]
 
         # Reimplement functionality from fragment shader
 
-        # See get_ray_eye_space
-        fov_scale = 2.0 * math.tan(fov / 360.0 * math.pi)
-
         # Reimplement computation of xy from fragment coordinate
-        x = (frag_coord[0] - 0.5 * size[0]) / size[0]
-        y = (frag_coord[1] - 0.5 * size[1]) / size[0]
+        x = (frag_coord[0] - 0.5 * size[0]) / min(size[0], size[1])
+        y = (frag_coord[1] - 0.5 * size[1]) / min(size[0], size[1])
 
         # Reimplement get_ray_eye_space to determine end point of
         # ray. The end point is encoded as pair distance to origin
         # direction to origin.
-        if isIdeal:
-            scaled_x = 0.5 * fov_scale * x
-            scaled_y = 0.5 * fov_scale * y
-
-            # Use "parabolic transformation magic by Saul"
-            # to determine the start point and direction of ray.
-            # Then compute end point using depth value.
-            foo = 0.5 * (scaled_x * scaled_x + scaled_y * scaled_y)
-            rayEnd = R13_normalise(
-                vector([RF((foo + 1.0)        + depth * foo),
-                        RF( scaled_x          + depth * scaled_x),
-                        RF( scaled_y          + depth * scaled_y),
-                        RF( foo               + depth * (foo - 1.0))]))
-
-            # Distance of rayEnd from origin
-            dist = math.acosh(rayEnd[0])
-            # Direction from origin to rayEnd
-            dir = vector([rayEnd[1], rayEnd[2], rayEnd[3]])
-        else:
-            scaled_x = fov_scale * x
-            scaled_y = fov_scale * y
+        if perspective_type == 0:
+            scaled_x = 2.0 * view_scale * x
+            scaled_y = 2.0 * view_scale * y
 
             # Camera is assumed to be at origin.
-            dist = math.atanh(depth)
+            dist = RF(depth).arctanh()
             # Reimplemented from get_ray_eye_space
-            dir = vector([RF(scaled_x), RF(scaled_y), RF(-1.0)])
+            dir = make_vector([RF(scaled_x), RF(scaled_y), RF(-1)])
+
+        else:
+            if perspective_type == 1:
+                scaled_x = view_scale * x
+                scaled_y = view_scale * y
+
+                # Use "parabolic transformation magic by Saul"
+                # to determine the start point and direction of ray.
+                # Then compute end point using depth value.
+                r2 = 0.5 * (scaled_x * scaled_x + scaled_y * scaled_y)
+                ray_end = make_vector(
+                    [RF((r2 + 1.0) + depth * r2),
+                     RF( scaled_x + depth * scaled_x),
+                     RF( scaled_y + depth * scaled_y),
+                     RF( r2 + depth * (r2 - 1.0))])
+            else:
+                pt = R13_normalise(
+                    make_vector([RF(1.0), RF(2.0 * x), RF(2.0 * y), RF(0.0)]))
+                ray_end = make_vector([pt[0],pt[1],pt[2],RF(-depth)])
+
+            ray_end = R13_normalise(ray_end)
+
+            # Distance of ray_end from origin
+            dist = ray_end[0].arccosh()
+            # Direction from origin to ray_end
+            dir = make_vector([ray_end[1], ray_end[2], ray_end[3]])
 
         # Normalize direction
         dir = dir.normalized()
@@ -293,7 +309,7 @@ class RaytracingView(SimpleImageShaderWidget, HyperboloidNavigation):
         #
         # Do this by using a concentric circle in the Poincare disk
         # model
-        poincare_dist = math.tanh(dist / 2.0)
+        poincare_dist = (dist / 2).tanh()
         hyp_circumference_up_to_constant = (
             poincare_dist / (1.0 - poincare_dist * poincare_dist))
 
@@ -310,12 +326,73 @@ class RaytracingView(SimpleImageShaderWidget, HyperboloidNavigation):
                 dir, -dist),
             speed)
 
+    def resize_geodesic_params(self, enable=False):
+        num = (len(self.additional_structures['geodesics'].geodesic_tube_infos) -
+               len(self.ui_parameter_dict['geodesicTubeRadii'][1]))
+        self.ui_parameter_dict['geodesicTubeRadii'][1] += num * [ 0.02 ]
+        self.ui_parameter_dict['geodesicTubeEnables'][1] += num * [ enable ]
+
+    def enable_geodesic(self, index):
+        self.ui_parameter_dict['geodesicTubeEnables'][1][index] = True
+
+    def _update_geodesic_data(self):
+        return self.additional_structures['geodesics'].set_enables_and_radii_and_update(
+            self.ui_parameter_dict['geodesicTubeEnables'][1],
+            self.ui_parameter_dict['geodesicTubeRadii'][1])
+
+    def update_geodesic_data_and_redraw(self):
+        success = self._update_geodesic_data()
+        self._update_shader()
+        self.draw()
+        return success
+
+    def disable_edges_for_geodesics(self):
+        # Only do once
+        if self.geodesics_disabled_edges:
+            return False
+
+        self.geodesics_disabled_edges = True
+
+        self.ui_uniform_dict['desaturate_edges'][1] = True
+        self.ui_parameter_dict['edgeTubeRadius'][1] = 0.0
+        self.ui_parameter_dict['insphere_scale'][1] = 0.0
+
+        self._initialize_raytracing_data()
+
+        return True
+
+    def _update_shader(self):
+        compile_time_defs = _merge_dicts(
+            *(additional_structure.get_compile_time_defs()
+              for additional_structure
+              in self.additional_structures.values()))
+
+        compile_time_constants = (
+            self.raytracing_data.get_compile_time_constants())
+
+        if (compile_time_constants == self.compile_time_constants and
+            compile_time_defs == self.compile_time_defs):
+            return
+
+        self.compile_time_constants = compile_time_constants
+        self.compile_time_defs = compile_time_defs
+
+        shader_source, uniform_block_names_sizes_and_offsets = (
+            shaders.get_triangulation_shader_source_and_ubo_descriptors(
+                compile_time_constants,
+                compile_time_defs))
+
+        self.set_fragment_shader_source(
+            shader_source,
+            uniform_block_names_sizes_and_offsets)
+
 def _merge_dicts(*dicts):
     return { k : v for d in dicts for k, v in d.items() }
 
 ##########################################################################
 # Consistency checks
 
+
 def _check_matrices_equal(m1, m2):
     for i in range(4):
         for j in range(4):
@@ -324,24 +401,28 @@ def _check_matrices_equal(m1, m2):
                 print("Matrix not zero as expected")
                 return
 
+
 def _check_matrix_o13(m):
-    s = matrix([[-1, 0,0,0],
-                [0, 1, 0, 0],
-                [0, 0, 1, 0],
-                [0, 0, 0, 1]])
+    s = make_matrix([[-1, 0,0,0],
+                     [0, 1, 0, 0],
+                     [0, 0, 1, 0],
+                     [0, 0, 0, 1]])
 
     _check_matrices_equal(s, m * s * m.transpose())
 
+
 def _matrix4_vec(m, p):
     return [sum([ m[i][j] * p[j] for j in range(4)])
             for i in range(4) ]
 
-def _diff(v1, v2, label = ''):
+
+def _diff(v1, v2, label=''):
     a = sum([(x - y)**2 for x, y in zip(v1, v2) ])
 
     if a > 1e-10:
         print("DIFF!!!", label, v1, v2)
 
+
 def _check_consistency(d):
     planes = d['TetrahedraBasics.planes'][1]
     otherTetNums = d['otherTetNums'][1]
@@ -358,7 +439,7 @@ def _check_consistency(d):
 #                        print("Bad plane equation")
 
     for i in range(len(planes)):
-        if abs(R13_dot(planes[i], planes[i]) - 1) > 1e-10:
+        if abs(r13_dot(planes[i], planes[i]) - 1) > 1e-10:
             print("Plane vec not normalized")
 
         plane = [-x for x in planes[i]]