Exemple #1
0
    def __init__(self, view=None, transform=None, **kwargs):

        self.view = view

        # Add a 3D cube to show us the unit cube. The 1.001 factor is to make
        # sure that the grid lines are not 'hidden' by volume renderings on the
        # front side due to numerical precision.
        vertices, filled_indices, outline_indices = create_cube()
        self.axis = scene.visuals.Mesh(vertices['position'],
                                       outline_indices,
                                       parent=self.view.scene,
                                       color=kwargs['axis_color'],
                                       mode='lines')

        self.axis.transform = transform

        self.xax = Axis(pos=[[-1.0, 0], [1.0, 0]],
                        tick_direction=(0, -1),
                        parent=self.view.scene,
                        axis_label='X',
                        anchors=['center', 'middle'],
                        **kwargs)

        self.yax = Axis(pos=[[0, -1.0], [0, 1.0]],
                        tick_direction=(-1, 0),
                        parent=self.view.scene,
                        axis_label='Y',
                        anchors=['center', 'middle'],
                        **kwargs)

        self.zax = Axis(pos=[[0, -1.0], [0, 1.0]],
                        tick_direction=(-1, 0),
                        parent=self.view.scene,
                        axis_label='Z',
                        anchors=['center', 'middle'],
                        **kwargs)

        self.xtr = STTransform()
        self.xtr = self.xtr.as_matrix()
        self.xtr.rotate(45, (1, 0, 0))
        self.xtr.translate((0, -1., -1.))

        self.ytr = STTransform()
        self.ytr = self.ytr.as_matrix()
        self.ytr.rotate(-45, (0, 1, 0))
        self.ytr.translate((-1, 0, -1.))

        self.ztr = STTransform()
        self.ztr = self.ztr.as_matrix()
        self.ztr.rotate(45, (0, 1, 0))
        self.ztr.rotate(90, (1, 0, 0))
        self.ztr.translate((-1, -1, 0.))

        self.xax.transform = ChainTransform(transform, self.xtr)
        self.yax.transform = ChainTransform(transform, self.ytr)
        self.zax.transform = ChainTransform(transform, self.ztr)
Exemple #2
0
 def _remove_layer(self, event):
     """When a layer is removed, remove its parent."""
     layer = event.item
     vispy_layer = self.layer_to_visual[layer]
     vispy_layer.node.transforms = ChainTransform()
     vispy_layer.node.parent = None
     del self.layer_to_visual[layer]
Exemple #3
0
    def __init__(self):
        app.Canvas.__init__(self, keys='interactive', size=(800, 550))

        self.meshes = []
        self.rotation = AffineTransform()

        # Generate some data to work with
        global mdata
        mdata = create_sphere(20, 40, 1.0)

        # Mesh with pre-indexed vertices, uniform color
        self.meshes.append(visuals.MeshVisual(meshdata=mdata, color='r'))

        ## Mesh with pre-indexed vertices, per-face color
        ##   Because vertices are pre-indexed, we get a different color
        ##   every time a vertex is visited, resulting in sharp color
        ##   differences between edges.
        verts = mdata.get_vertices(indexed='faces')
        nf = verts.size // 9
        fcolor = np.ones((nf, 3, 4), dtype=np.float32)
        fcolor[..., 0] = np.linspace(1, 0, nf)[:, np.newaxis]
        fcolor[..., 1] = np.random.normal(size=nf)[:, np.newaxis]
        fcolor[..., 2] = np.linspace(0, 1, nf)[:, np.newaxis]
        mesh = visuals.MeshVisual(vertices=verts, face_colors=fcolor)
        self.meshes.append(mesh)

        ## Mesh with unindexed vertices, per-vertex color
        ##   Because vertices are unindexed, we get the same color
        ##   every time a vertex is visited, resulting in no color differences
        ##   between edges.
        verts = mdata.get_vertices()
        faces = mdata.get_faces()
        nv = verts.size // 3
        vcolor = np.ones((nv, 4), dtype=np.float32)
        vcolor[:, 0] = np.linspace(1, 0, nv)
        vcolor[:, 1] = np.random.normal(size=nv)
        vcolor[:, 2] = np.linspace(0, 1, nv)
        self.meshes.append(visuals.MeshVisual(verts, faces, vcolor))
        self.meshes.append(
            visuals.MeshVisual(verts, faces, vcolor, shading='flat'))
        self.meshes.append(
            visuals.MeshVisual(verts, faces, vcolor, shading='smooth'))

        # Lay out meshes in a grid
        grid = (3, 3)
        s = 300. / max(grid)
        for i, mesh in enumerate(self.meshes):
            x = 800. * (i % grid[0]) / grid[0] + 400. / grid[0] - 2
            y = 800. * (i // grid[1]) / grid[1] + 400. / grid[1] + 2
            transform = ChainTransform([
                STTransform(translate=(x, y), scale=(s, s, 1)), self.rotation
            ])
            tr_sys = visuals.transforms.TransformSystem(self)
            tr_sys.visual_to_document = transform
            mesh.tr_sys = tr_sys

        self.show()

        self.timer = app.Timer(connect=self.rotate)
        self.timer.start(0.016)
Exemple #4
0
def _remove(event):
    """When a layer is removed, remove its viewer."""
    layers = event.source
    layer = event.item
    layer._order = 0
    layer._node.transforms = ChainTransform()
    layer._node.parent = None
Exemple #5
0
def niimg_to_transform(vol, hdr, as_bgd=True, vol_bgd=None, hdr_bgd=None):
    """Get transformations of nii.gz files for cross-sections.

    Parameters
    ----------
    vol : array_like
        3D volume data.
    hdr : array_like
        Array of transformation of shape (4, 4).
    as_bgd : bool | True
        Specify if the volume is a background image or have to be considered as
        an activation image.
    vol_bgd : array_like | None
        Volume data if `as_bgd` is True.
    hdr_bgd : array_like | None
        Transformation array if `as_bgd` is True.

    Returns
    -------
    sg_tf : ChainTransform
        Transformation of sagittal view
    cr_tf : ChainTransform
        Transformation of coronal view
    ax_tf : ChainTransform
        Transformation of axial view
    """
    # Get transformation variables
    sh_img, diag_img, tr_img = _niimg_var(vol, hdr)
    # Get the normalization transformation depending if the volume is an image
    # background or an activation image
    if as_bgd:  # Background image
        sg_norm, cr_norm, ax_norm = _niimg_norm(sh_img - 1, diag_img, tr_img)
    else:       # Activation image
        sh_bgd, diag_bgd, tr_bgd = _niimg_var(vol_bgd, hdr_bgd)
        sg_norm, cr_norm, ax_norm = _niimg_norm(sh_bgd - 1, diag_bgd, tr_bgd)
    # Get MNI and rotation transformations
    sg_mni, cr_mni, ax_mni = _niimg_mni(hdr)
    sg_rot, cr_rot, ax_rot = _niimg_rot()
    # Build the chain of transformation
    sg_tf = ChainTransform([sg_norm, sg_rot, sg_mni])
    cr_tf = ChainTransform([cr_norm, cr_rot, cr_mni])
    ax_tf = ChainTransform([ax_norm, ax_rot, ax_mni])
    return sg_tf, cr_tf, ax_tf
Exemple #6
0
    def _on_display_change(self):
        parent = self.node.parent
        self.node.transforms = ChainTransform()
        self.node.parent = None

        if self.layer.dims.ndisplay == 2:
            self.node = Compound([Markers(), Markers(), Line()])
        else:
            self.node = Compound([Markers(), Markers()])
        self.node.parent = parent
        self._reset_base()
Exemple #7
0
    def _remove_layer(self, event):
        """When a layer is removed, remove its parent.

        Parameters
        ----------
        event : qtpy.QtCore.QEvent
            Event from the Qt context.
        """
        layer = event.item
        vispy_layer = self.layer_to_visual[layer]
        vispy_layer.node.transforms = ChainTransform()
        vispy_layer.node.parent = None
        del self.layer_to_visual[layer]
Exemple #8
0
    def _remove_layer(self, event):
        """When a layer is removed, remove its parent.

        Parameters
        ----------
        event : napari.utils.event.Event
            The napari event that triggered this method.
        """
        layer = event.value
        vispy_layer = self.layer_to_visual[layer]
        vispy_layer.node.transforms = ChainTransform()
        vispy_layer.node.parent = None
        del vispy_layer
        self._reorder_layers(None)
    def _on_display_change(self):
        parent = self.node.parent
        self.node.transforms = ChainTransform()
        self.node.parent = None

        if self.layer.dims.ndisplay == 2:
            self.node = Compound([Markers(), Markers(), Line()])
        else:
            self.node = Markers()

        self.node.parent = parent
        self.layer._update_dims()
        self.layer._set_view_slice()
        self.reset()
Exemple #10
0
    def _remove_layer(self, event):
        """When a layer is removed, remove its parent.

        Parameters
        ----------
        event : napari.utils.event.Event
            The napari event that triggered this method.
        """
        layer = event.item
        vispy_layer = self.layer_to_visual[layer]
        self.canvas.events.draw.disconnect(vispy_layer.on_draw)
        vispy_layer.node.transforms = ChainTransform()
        vispy_layer.node.parent = None
        del vispy_layer
        self._reorder_layers(None)
Exemple #11
0
    def __init__(self):
        app.Canvas.__init__(self, keys='interactive')

        n = 10000
        pos = 0.25 * np.random.randn(n, 2).astype(np.float32)
        color = np.random.uniform(0, 1, (n, 3)).astype(np.float32)
        size = np.random.uniform(2, 12, (n, 1)).astype(np.float32)

        self.points = MarkerVisual(pos=pos, color=color, size=size)
        
        self.panzoom = STTransform(scale=(1, 0.2), translate=(0, 500))
        w2 = (self.size[0]/2, self.size[1]/2)
        self.transform = ChainTransform([self.panzoom,
                                         STTransform(scale=w2, translate=w2),
                                         LogTransform(base=(0, 2, 0))])

        self.tr_sys = TransformSystem(self)
        self.tr_sys.visual_to_document = self.transform
Exemple #12
0
    def __init__(self):
        app.Canvas.__init__(self, keys='interactive')
        ps = self.pixel_scale

        n = 10000
        pos = 0.25 * np.random.randn(n, 2).astype(np.float32)
        color = np.random.uniform(0, 1, (n, 3)).astype(np.float32)
        size = np.random.uniform(2*ps, 12*ps, (n, 1)).astype(np.float32)

        self.points = MarkerVisual(pos=pos, color=color, size=size)

        self.panzoom = STTransform(scale=(1, 0.2), translate=(0, 500))
        w2 = (self.size[0]/2, self.size[1]/2)
        self.transform = ChainTransform([self.panzoom,
                                         STTransform(scale=w2, translate=w2),
                                         LogTransform(base=(0, 2, 0))])

        self.tr_sys = TransformSystem(self)
        self.tr_sys.visual_to_document = self.transform

        gloo.set_state(blend=True,
                       blend_func=('src_alpha', 'one_minus_src_alpha'))
Exemple #13
0
def vpnormalize(obj, dist=1.):
    """Get the vispy transformation for normalizing objects.

    Parameters
    ----------
    obj : tuple
        The ndarray of the object to rescale. Must be a (..., 2) or (..., 3).
    dist : float | 1.
        The final rescaling value.

    Returns
    -------
    normalize : vispy.transformations
        VisPy transformation to normalize.
    """
    # Prepare the transformation chain :
    t = ChainTransform()
    # Recenter the object :
    t.prepend(vprecenter(obj))
    # Rescale :
    t.prepend(vprescale(obj, dist))
    return t
Exemple #14
0
    def __init__(self):
        app.Canvas.__init__(self, keys='interactive', size=(800, 550))

        self.meshes = []
        self.rotation = MatrixTransform()

        # Generate some data to work with
        global mdata
        mdata = create_sphere(20, 40, 1.0)

        # Mesh with pre-indexed vertices, uniform color
        self.meshes.append(visuals.MeshVisual(meshdata=mdata, color='b'))

        # Mesh with pre-indexed vertices, per-face color
        # Because vertices are pre-indexed, we get a different color
        # every time a vertex is visited, resulting in sharp color
        # differences between edges.
        rng = np.random.RandomState(0)
        verts = mdata.get_vertices(indexed='faces')
        nf = verts.size // 9
        fcolor = np.ones((nf, 3, 4), dtype=np.float32)
        fcolor[..., 0] = np.linspace(1, 0, nf)[:, np.newaxis]
        fcolor[..., 1] = rng.randn(nf, 1)
        fcolor[..., 2] = np.linspace(0, 1, nf)[:, np.newaxis]
        mesh = visuals.MeshVisual(vertices=verts, face_colors=fcolor)
        self.meshes.append(mesh)

        # Mesh with unindexed vertices, per-vertex color
        # Because vertices are unindexed, we get the same color
        # every time a vertex is visited, resulting in no color differences
        # between edges.
        verts = mdata.get_vertices()
        faces = mdata.get_faces()
        nv = verts.size // 3
        vcolor = np.ones((nv, 4), dtype=np.float32)
        vcolor[:, 0] = np.linspace(1, 0, nv)
        vcolor[:, 1] = rng.randn(nv)
        vcolor[:, 2] = np.linspace(0, 1, nv)
        self.meshes.append(visuals.MeshVisual(verts, faces, vcolor))
        self.meshes.append(
            visuals.MeshVisual(verts, faces, vcolor, shading='flat'))
        self.meshes.append(
            visuals.MeshVisual(verts, faces, vcolor, shading='smooth'))

        # Mesh with color indexed into a colormap
        verts = mdata.get_vertices(None)
        faces = mdata.get_faces()
        values = rng.randn(len(verts))
        mesh = visuals.MeshVisual(vertices=verts,
                                  faces=faces,
                                  vertex_values=values,
                                  shading='smooth')
        mesh.clim = [-1, 1]
        mesh.cmap = 'viridis'
        mesh.shininess = 0.01
        self.meshes.append(mesh)

        # Lay out meshes in a grid
        grid = (3, 3)
        s = 300. / max(grid)
        for i, mesh in enumerate(self.meshes):
            x = 800. * (i % grid[0]) / grid[0] + 400. / grid[0] - 2
            y = 800. * (i // grid[1]) / grid[1] + 400. / grid[1] + 2
            transform = ChainTransform([
                STTransform(translate=(x, y), scale=(s, s, s)), self.rotation
            ])
            mesh.transform = transform
            mesh.transforms.scene_transform = STTransform(scale=(1, 1, 0.01))

        self.show()

        self.timer = app.Timer(connect=self.rotate)
        self.timer.start(0.016)
Exemple #15
0
    def __init__(self):
        app.Canvas.__init__(self, keys='interactive')

        self.meshes = []
        self.rotation = AffineTransform()

        # Generate some data to work with
        global mdata
        mdata = create_sphere(20, 40, 1.0)

        # Mesh with pre-indexed vertices, uniform color
        verts = mdata.get_vertices(indexed='faces')
        mesh = ModularMesh(pos=verts, color=(1, 0, 0, 1))
        self.meshes.append(mesh)

        # Mesh with pre-indexed vertices, per-face color
        #   Because vertices are pre-indexed, we get a different color
        #   every time a vertex is visited, resulting in sharp color
        #   differences between edges.
        nf = verts.size // 9
        fcolor = np.ones((nf, 3, 4), dtype=np.float32)
        fcolor[..., 0] = np.linspace(1, 0, nf)[:, np.newaxis]
        fcolor[..., 1] = np.random.normal(size=nf)[:, np.newaxis]
        fcolor[..., 2] = np.linspace(0, 1, nf)[:, np.newaxis]
        mesh = ModularMesh(pos=verts, color=fcolor)
        self.meshes.append(mesh)

        # Mesh with unindexed vertices, per-vertex color
        #   Because vertices are unindexed, we get the same color
        #   every time a vertex is visited, resulting in no color differences
        #   between edges.
        verts = mdata.get_vertices()
        faces = mdata.get_faces()
        nv = verts.size // 3
        vcolor = np.ones((nv, 4), dtype=np.float32)
        vcolor[:, 0] = np.linspace(1, 0, nv)
        vcolor[:, 1] = np.random.normal(size=nv)
        vcolor[:, 2] = np.linspace(0, 1, nv)
        mesh = ModularMesh(pos=verts, faces=faces, color=vcolor)
        self.meshes.append(mesh)

        # Mesh colored by vertices + grid contours
        mesh = ModularMesh(pos=verts, faces=faces)
        mesh.color_components = [
            VertexColorComponent(vcolor),
            GridContourComponent(spacing=(0.13, 0.13, 0.13))
        ]
        self.meshes.append(mesh)

        # Phong shaded mesh
        mesh = ModularMesh(pos=verts, faces=faces)
        normal_comp = VertexNormalComponent(mdata)
        mesh.color_components = [
            VertexColorComponent(vcolor),
            GridContourComponent(spacing=(0.1, 0.1, 0.1)),
            ShadingComponent(normal_comp,
                             lights=[((-1, 1, -1), (1.0, 1.0, 1.0))],
                             ambient=0.2)
        ]
        self.meshes.append(mesh)

        # Phong shaded mesh, flat faces
        mesh = ModularMesh(pos=mdata.get_vertices(indexed='faces'))
        normal_comp = VertexNormalComponent(mdata, smooth=False)
        mesh.color_components = [
            VertexColorComponent(vcolor[mdata.get_faces()]),
            GridContourComponent(spacing=(0.1, 0.1, 0.1)),
            ShadingComponent(normal_comp,
                             lights=[((-1, 1, -1), (1.0, 1.0, 1.0))],
                             ambient=0.2)
        ]
        self.meshes.append(mesh)

        # Lay out meshes in a grid
        grid = (3, 3)
        s = 300. / max(grid)
        for i, mesh in enumerate(self.meshes):
            x = 800. * (i % grid[0]) / grid[0] + 400. / grid[0] - 2
            y = 800. * (i // grid[1]) / grid[1] + 400. / grid[1] + 2
            mesh.transform = ChainTransform([
                STTransform(translate=(x, y), scale=(s, s, 1)), self.rotation
            ])
            mesh.tr_sys = visuals.transforms.TransformSystem(self)
            mesh.tr_sys.visual_to_document = mesh.transform

        self.size = (800, 800)
        self.show()

        self.timer = app.Timer(connect=self.rotate)
        self.timer.start(0.016)