Esempio n. 1
0
class TetVisual(CompoundVisual):
    """ display a 3D mesh """
    def __init__(self,
                 vertices=None,
                 simplices=None,
                 vertex_colors=None,
                 edge_color=None,
                 edge_width=1,
                 markers=None,
                 marker_colors=None,
                 marker_size=1,
                 **kwargs):
        """
        a mesh visualization toolkit that can also plot edges or markers

        Parameters
        ----------

        Notes
        -----
        """
        self._mesh = MeshVisual()
        self._edge = LineVisual()
        self._edge_color = Color(edge_color)
        self._marker = MarkersVisual()
        #
        self._vertex_colors = vertex_colors

        self._update()
        # initialize visuals
        CompoundVisual.__init__(self, [self._mesh, self._edge, self._marker],
                                **kwargs)
        # set default state, 'opaque', 'translucent' or 'additive'
        self._mesh.set_gl_state(
            preset="translucent",
            blend=True,
            depth_test=False,
            cull_face=False,
            polygon_offset_fill=True,
            polygon_offset=(1, 1),
        )
        # end
        self.freeze()

        def _update(self):
            """
            update parameters to visuals
            """
            raise NotImplementedError()

        @property
        def edge_color(self):
            """ get """
            return self._edge_color

        @edge_color.setter
        def edge_color(self, edge_color):
            """ set """
            self._edge_color = Color(edge_color)
            self._update()
Esempio n. 2
0
    def __init__(self,
                 vertices,
                 faces,
                 uniform_colour=(0.5, 0.5, 1.0),
                 uniform_opacity=1.0,
                 vertex_colours=None,
                 wireframe=False,
                 wireframe_offset=None):
        """
        Creates a primitive visual based on
        :class:`vispy.visuals.mesh.MeshVisual` class.

        Parameters
        ----------
        vertices : array_like
            Vertices data.
        faces : array_like
            Faces data.
        uniform_colour : array_like, optional
            Uniform mesh colour.
        uniform_opacity : numeric, optional
            Uniform mesh opacity.
        vertex_colours : array_like, optional
            Per vertex varying colour.
        wireframe : bool, optional
            Use wireframe display.
        wireframe_offset : array_like, optional
            Wireframe offset.

        Notes
        -----
        -   `vertex_colours` argument takes precedence over `uniform_colour` if
            provided.
        -   `uniform_opacity` argument will be stacked to `vertex_colours`
            argument if the latter last dimension is equal to 3.
        """

        self._wireframe = wireframe
        self._wireframe_offset = wireframe_offset
        mode = 'lines' if self._wireframe else 'triangles'

        uniform_colour = ColorArray(uniform_colour, alpha=uniform_opacity).rgba
        if vertex_colours is not None:
            if vertex_colours.shape[-1] == 3:
                vertex_colours = np.hstack(
                    (vertex_colours,
                     np.full((vertex_colours.shape[0], 1), uniform_opacity,
                             DEFAULT_FLOAT_DTYPE)))
            else:
                vertex_colours[..., 3] = uniform_opacity

        MeshVisual.__init__(
            self,
            vertices,
            faces,
            vertex_colours,
            None,
            uniform_colour,
            mode=mode)
def test_empty_mesh_wireframe():
    """Test that an empty mesh does not cause issues with wireframe filter"""
    mesh = MeshVisual()
    wf = WireframeFilter()
    mesh.attach(wf)

    # trigger update of filter
    wf.enabled = True
Esempio n. 4
0
class TetVisual(CompoundVisual):
    """ display a 3D mesh """

    def __init__(self,
                 vertices=None, simplices=None, vertex_colors=None,
                 edge_color=None, edge_width=1,
                 markers=None, marker_colors=None, marker_size=1,
                 **kwargs):
        """
        a mesh visualization toolkit that can also plot edges or markers

        Parameters
        ----------

        Notes
        -----
        """
        self._mesh = MeshVisual()
        self._edge = LineVisual()
        self._edge_color = Color(edge_color)
        self._marker = MarkersVisual()
        #
        self._vertex_colors = vertex_colors

        self._update()
        # initialize visuals
        CompoundVisual.__init__(self,
                                [self._mesh, self._edge, self._marker],
                                **kwargs)
        # set default state, 'opaque', 'translucent' or 'additive'
        self._mesh.set_gl_state(preset='translucent',
                                blend=True,
                                depth_test=False,
                                cull_face=False,
                                polygon_offset_fill=True,
                                polygon_offset=(1, 1))
        # end
        self.freeze()

        def _update(self):
            """
            update parameters to visuals
            """
            pass

        @property
        def edge_color(self):
            """ get """
            return self._edge_color

        @edge_color.setter
        def edge_color(self, edge_color):
            """ set """
            self._edge_color = Color(edge_color)
            self._update()
Esempio n. 5
0
    def __init__(self,
                 mu,
                 cov,
                 std=2.,
                 cols=15,
                 rows=15,
                 depth=15,
                 subdivisions=3,
                 method='latitude',
                 vertex_colors=None,
                 face_colors=None,
                 color=(0.5, 0.5, 1, 1),
                 edge_color=None,
                 **kwargs):

        mesh = create_sphere(rows,
                             cols,
                             depth,
                             radius=std,
                             subdivisions=subdivisions,
                             method=method)

        # Take the spherical mesh and project through the covariance, like you do
        #  when sampling a multivariate gaussian.
        # https://en.wikipedia.org/wiki/Multivariate_normal_distribution#Drawing_values_from_the_distribution
        A = np.linalg.cholesky(cov)
        verts = mesh.get_vertices()
        verts2 = np.matmul(A[None, :, :], verts[:, :, None])
        verts3 = verts2 + mu[None, :, None]
        mesh.set_vertices(np.squeeze(verts3))

        self._mesh = MeshVisual(vertices=mesh.get_vertices(),
                                faces=mesh.get_faces(),
                                vertex_colors=vertex_colors,
                                face_colors=face_colors,
                                color=color)
        if edge_color:
            self._border = MeshVisual(vertices=mesh.get_vertices(),
                                      faces=mesh.get_edges(),
                                      color=edge_color,
                                      mode='lines')
        else:
            self._border = MeshVisual()

        CompoundVisual.__init__(self, [self._mesh, self._border], **kwargs)
        self.mesh.set_gl_state(polygon_offset_fill=True,
                               polygon_offset=(1, 1),
                               depth_test=True)
    def __init__(self, data=None, level=None, vertex_colors=None,
                 face_colors=None, color=(0.5, 0.5, 1, 1), **kwargs):
        self._data = None
        self._level = level
        self._vertex_colors = vertex_colors
        self._face_colors = face_colors
        self._color = Color(color)

        # We distinguish between recomputing and just changing the visual
        # properties - in the latter case we don't recompute the faces.
        self._vertices_cache = None
        self._faces_cache = None
        self._recompute = True
        self._update_meshvisual = True

        MeshVisual.__init__(self, **kwargs)
        if data is not None:
            self.set_data(data)
    def _update_mesh_visual(self):

        if self._data is None or self._level is None:
            return False

        if self._recompute:
            self._vertices_cache, self._faces_cache = isosurface(np.ascontiguousarray(self._data),
                                                                 self._level)
            self._recompute = False
            self._update_meshvisual = True

        if self._update_meshvisual:
            MeshVisual.set_data(self,
                                vertices=self._vertices_cache,
                                faces=self._faces_cache,
                                vertex_colors=self._vertex_colors,
                                face_colors=self._face_colors,
                                color=self._color)
            self._update_meshvisual = False
Esempio n. 8
0
    def _update_mesh_visual(self):

        if self._data is None or self._level is None:
            return False

        if self._recompute:
            self._vertices_cache, self._faces_cache = isosurface(
                np.ascontiguousarray(self._data), self._level)
            self._recompute = False
            self._update_meshvisual = True

        if self._update_meshvisual:
            MeshVisual.set_data(self,
                                vertices=self._vertices_cache,
                                faces=self._faces_cache,
                                vertex_colors=self._vertex_colors,
                                face_colors=self._face_colors,
                                color=self._color)
            self._update_meshvisual = False
Esempio n. 9
0
    def __init__(self,
                 data=None,
                 level=None,
                 vertex_colors=None,
                 face_colors=None,
                 color=(0.5, 0.5, 1, 1),
                 **kwargs):
        self._data = None
        self._level = level
        self._vertex_colors = vertex_colors
        self._face_colors = face_colors
        self._color = Color(color)

        # We distinguish between recomputing and just changing the visual
        # properties - in the latter case we don't recompute the faces.
        self._vertices_cache = None
        self._faces_cache = None
        self._recompute = True
        self._update_meshvisual = True

        MeshVisual.__init__(self, **kwargs)
        if data is not None:
            self.set_data(data)
Esempio n. 10
0
    def __init__(self, radius=1.0, directions=None, colors=None):

        # Convert spherical to cartesian
        points = np.array([util.tp2xyz(*x) for x in directions])

        # Create mesh
        import scipy.spatial
        ch = scipy.spatial.ConvexHull(points)
        mesh = MeshData(vertices=ch.points, faces=ch.simplices)

        self._mesh = MeshVisual(vertices=mesh.get_vertices(),
                                faces=mesh.get_faces(),
                                vertex_colors=colors)

        CompoundVisual.__init__(self, [self._mesh])
        self.mesh.set_gl_state(depth_test=True)
Esempio n. 11
0
 def draw(self):
     MeshVisual.draw(self)
     if self._wireframe and self._wireframe_offset:
         set_state(polygon_offset=self._wireframe_offset,
                   polygon_offset_fill=True)
Esempio n. 12
0
 def draw(self, transforms):
     self._update_mesh_visual()
     return MeshVisual.draw(self, transforms)
Esempio n. 13
0
 def _prepare_draw(self, view):
     self._update_mesh_visual()
     return MeshVisual._prepare_draw(self, view)
Esempio n. 14
0
 def draw(self, transforms):
     self._update_mesh_visual()
     return MeshVisual.draw(self, transforms)
Esempio n. 15
0
 def _prepare_draw(self, view):
     self._update_mesh_visual()
     return MeshVisual._prepare_draw(self, view)
Esempio n. 16
0
 def draw(self, transforms):
     MeshVisual.draw(self, transforms)
     if self.__wireframe and self.__wireframe_offset:
         set_state(polygon_offset=self.__wireframe_offset,
                   polygon_offset_fill=True)