snappy 3.1__cp39-cp39-win_amd64.whl → 3.2__cp39-cp39-win_amd64.whl

snappy/raytracing/raytracing_view.py

@@ -3,23 +3,16 @@ 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
-__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),
@@ -79,6 +72,8 @@ class RaytracingView(SimpleImageShaderWidget, HyperboloidNavigation):
             self, container,
             *args, **kwargs)
 
+        self.set_textures(shaders.get_texture_paths())
+
         self.trig_type = trig_type
 
         # The view can be driven in two modes:
@@ -95,10 +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],
-            'edgeThickness' : ['float', 0.0000001],
 
             'contrast' : ['float', 0.1 if has_weights else 0.5],
             'noGradient' : ['bool', False],
@@ -110,17 +104,22 @@ class RaytracingView(SimpleImageShaderWidget, HyperboloidNavigation):
             'showElevation' : ['bool', False],
             'desaturate_edges' : ['bool', False],
             'viewScale' : ['float', 1.0],
-            'perspectiveType' : ['int', 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.025 if trig_type == 'finite' else 0.04)],
+                                (0.025 if trig_type == 'finite' else 0.0)],
             'vertexRadius' : ['float', 0.0 if has_weights else 0.25],
             'geodesicTubeRadii' : ['float[]', []],
-            'geodesicTubeEnables' : ['bool[]', []]
+            '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:
@@ -135,18 +134,17 @@ class RaytracingView(SimpleImageShaderWidget, HyperboloidNavigation):
                     "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()
 
-        if self.trig_type == 'finite':
-            # Geodesics in finite triangulations are not yet
-            # supported.
-            self.geodesics = None
-            self.geodesics_uniform_bindings = {}
-        else:
-            self.geodesics = Geodesics(manifold, geodesics)
+        if self.trig_type == 'ideal':
+            self.additional_structures['geodesics'] = (
+                Geodesics(manifold, geodesics))
             self.resize_geodesic_params(enable=True)
             self._update_geodesic_data()
 
@@ -175,7 +173,10 @@ class RaytracingView(SimpleImageShaderWidget, HyperboloidNavigation):
         result = _merge_dicts(
             _constant_uniform_bindings,
             self.manifold_uniform_bindings,
-            self.geodesics_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]),
@@ -184,6 +185,8 @@ class RaytracingView(SimpleImageShaderWidget, HyperboloidNavigation):
                 'viewMode' : ('int', self.view),
                 'edgeTubeRadiusParam' :
                     ('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]) ** 2)
             },
@@ -195,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 Exception:
-                pass
+        self._unguarded_initialize_raytracing_data()
 
     def _unguarded_initialize_raytracing_data(self):
         weights = self.weights
@@ -225,14 +220,30 @@ class RaytracingView(SimpleImageShaderWidget, HyperboloidNavigation):
                 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):
@@ -263,7 +274,7 @@ class RaytracingView(SimpleImageShaderWidget, HyperboloidNavigation):
             # Camera is assumed to be at origin.
             dist = RF(depth).arctanh()
             # Reimplemented from get_ray_eye_space
-            dir = vector([RF(scaled_x), RF(scaled_y), RF(-1)])
+            dir = make_vector([RF(scaled_x), RF(scaled_y), RF(-1)])
 
         else:
             if perspective_type == 1:
@@ -274,22 +285,22 @@ class RaytracingView(SimpleImageShaderWidget, HyperboloidNavigation):
                 # 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 = vector(
+                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(
-                    vector([RF(1.0), RF(2.0 * x), RF(2.0 * y), RF(0.0)]))
-                ray_end = vector([pt[0],pt[1],pt[2],RF(-depth)])
+                    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 = vector([ray_end[1], ray_end[2], ray_end[3]])
+            dir = make_vector([ray_end[1], ray_end[2], ray_end[3]])
 
         # Normalize direction
         dir = dir.normalized()
@@ -316,7 +327,7 @@ class RaytracingView(SimpleImageShaderWidget, HyperboloidNavigation):
             speed)
 
     def resize_geodesic_params(self, enable=False):
-        num = (len(self.geodesics.geodesic_tube_infos) -
+        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 ]
@@ -325,18 +336,14 @@ class RaytracingView(SimpleImageShaderWidget, HyperboloidNavigation):
         self.ui_parameter_dict['geodesicTubeEnables'][1][index] = True
 
     def _update_geodesic_data(self):
-        success = self.geodesics.set_enables_and_radii_and_update(
+        return self.additional_structures['geodesics'].set_enables_and_radii_and_update(
             self.ui_parameter_dict['geodesicTubeEnables'][1],
             self.ui_parameter_dict['geodesicTubeRadii'][1])
-        self.geodesics_uniform_bindings = (
-            self.geodesics.get_uniform_bindings())
-
-        return success
 
     def update_geodesic_data_and_redraw(self):
         success = self._update_geodesic_data()
         self._update_shader()
-        self.redraw_if_initialized()
+        self.draw()
         return success
 
     def disable_edges_for_geodesics(self):
@@ -355,32 +362,30 @@ class RaytracingView(SimpleImageShaderWidget, HyperboloidNavigation):
         return True
 
     def _update_shader(self):
-        if self.geodesics:
-            geodesic_compile_time_constants = (
-                self.geodesics.get_compile_time_constants())
-        else:
-            geodesic_compile_time_constants = {
-                b'##num_geodesic_segments##' : 0
-            }
+        compile_time_defs = _merge_dicts(
+            *(additional_structure.get_compile_time_defs()
+              for additional_structure
+              in self.additional_structures.values()))
 
-        compile_time_constants = _merge_dicts(
-            self.raytracing_data.get_compile_time_constants(),
-            geodesic_compile_time_constants)
+        compile_time_constants = (
+            self.raytracing_data.get_compile_time_constants())
 
-        if compile_time_constants == self.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_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() }
 
@@ -398,10 +403,10 @@ def _check_matrices_equal(m1, m2):
 
 
 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())
 

snappy/raytracing/shaders/__init__.py

@@ -2,6 +2,10 @@ import os
 
 from . import __path__ as _base_path
 
+def get_texture_paths():
+    return [ os.path.join(_base_path[0], name)
+             for name in ['NonGeometric.png',
+                          'Eye.png'] ]
 
 def _replace_compile_time_constants(shader_source, constants_dict):
     for name, value in constants_dict.items():
@@ -13,7 +17,9 @@ def _replace_compile_time_constants(shader_source, constants_dict):
 _triangulation_shader_source = None
 
 
-def get_triangulation_shader_source_and_ubo_descriptors(constants_dict):
+def get_triangulation_shader_source_and_ubo_descriptors(
+        constants_dict,
+        defs_dict = {}):
 
     global _triangulation_shader_source
 
@@ -25,8 +31,23 @@ def get_triangulation_shader_source_and_ubo_descriptors(constants_dict):
         _triangulation_shader_source,
         constants_dict)
 
+    if defs_dict:
+        header, footer = src.split(b'\n', 1)
+        def_block = (
+            '\n\n'
+            '// { Compile time defines\n')
+        for k, v in sorted(defs_dict.items()):
+            def_block += '#define %s' % k
+            if not v is None:
+                def_block += ' %r' % v
+            def_block += '\n'
+        def_block += '// } Compile time defines\n\n'
+        src = header + def_block.encode() + footer
+
+    num_geodesic_segments = defs_dict.get('num_geodesic_segments', 0)
+    num_additional_horospheres = defs_dict.get('num_additional_horospheres', 0)
+    num_eyeballs = defs_dict.get('num_eyeballs', 0)
     num_tets = constants_dict[b'##num_tets##']
-    num_geodesic_segments = constants_dict[b'##num_geodesic_segments##']
 
     uniform_block_names_sizes_and_offsets = [
         ('TetrahedraCombinatorics',
@@ -60,6 +81,21 @@ def get_triangulation_shader_source_and_ubo_descriptors(constants_dict):
            'geodesicHeads': 16 * num_geodesic_segments,
            'geodesicIndex': (16 + 16) * num_geodesic_segments,
            'geodesicTubeRadiusParam': (16 + 16 + 16) * num_geodesic_segments,
-           'geodesicOffsets': (16 + 16 + 16 + 16) * num_geodesic_segments }) ]
+           'geodesicOffsets': (16 + 16 + 16 + 16) * num_geodesic_segments }),
+        ('eyeballs',
+         (16 + 64 + 64) * num_eyeballs + 16 * (num_tets + 1),
+         { 'eyeballPositions' : 0,
+           'eyeballInvEmbeddings' : 16 * num_eyeballs,
+           'eyeballEmbeddings' : (16 + 64) * num_eyeballs,
+           'eyeballOffsets' : (16 + 64 + 64) * num_eyeballs }),
+        ('additionalHorospheres',
+         (16 + 16) * num_additional_horospheres + 16 * (num_tets + 1),
+         { 'horosphereVec': 0,
+           'horosphereCuspIndex': 16 * num_additional_horospheres,
+           'horosphereOffsets' : (16 + 16) * num_additional_horospheres}),
+        ('edgeMidpoints',
+         16 * 6 * num_tets,
+         { 'edgeMidpointVec': 0 })
+         ]
 
     return src, uniform_block_names_sizes_and_offsets