Ejemplo n.º 1
0
    def viz_subcortical_points(self, subjects_dir=None, subject=None):
        '''
        add transparent voxel structures at the subcortical structures
        '''

        if subjects_dir is None:
            subjects_dir = os.environ['SUBJECTS_DIR']
        if subject is None:
            subject = os.environ['SUBJECT']

        structures_list = {
            'hippocampus': ([53, 17], (.69, .65, .93)),
            'amgydala': ([54, 18], (.8, .5, .29)),
            'thalamus': ([49, 10], (.318, 1, .447)),
            'caudate': ([50, 11], (1, .855, .67)),
            'putamen': ([51, 12], (0, .55, 1)),
            'insula': ([55, 19], (1, 1, 1)),
            'accumbens': ([58, 26], (1, .44, 1)),
        }

        asegf = os.path.join(subjects_dir, subject, 'mri', 'aseg.mgz')
        aseg = nib.load(asegf)
        asegd = aseg.get_data()

        for struct in structures_list:
            (strucl, strucr), color = structures_list[struct]

            for strucu in (strucl, strucr):

                strucw = np.where(asegd == strucu)

                if np.size(strucw) == 0:
                    print 'Nonne skippy %s' % struct
                    continue

                import geometry as geo
                xfm = geo.get_vox2rasxfm(asegf, stem='vox2ras-tkr')
                strucd = np.array(geo.apply_affine(np.transpose(strucw), xfm))

                print np.shape(strucd)

                src = mlab.pipeline.scalar_scatter(
                    strucd[:, 0],
                    strucd[:, 1],
                    strucd[:, 2],
                    figure=self.scene.mayavi_scene)

                mlab.pipeline.glyph(src,
                                    scale_mode='none',
                                    scale_factor=0.4,
                                    mode='sphere',
                                    opacity=1,
                                    figure=self.scene.mayavi_scene,
                                    color=color)
Ejemplo n.º 2
0
def get_orig2std(orig):
    '''
    Given an orig file, get the transformation from the orig to ras2mni.
    '''
    vox2ras = get_vox2rasxfm(orig)
    bx, by, bz = vox2ras[0:3,3]

    reorient_orig2std_mat = np.array(((1, 0, 0, bx-128),
                                      (0, 0, -1, by+128), 
                                      (0, 1, 0, bz-128),
                                      (0, 0, 0, 1)))

    return reorient_orig2std_mat
Ejemplo n.º 3
0
    def load_img(self, imgf, reorient2std=False, image_name=None):
        self._finished_plotting = False

        img = nib.load(imgf)

        aff = np.dot(
            get_orig2std(imgf) if reorient2std else np.eye(4),
            img.get_affine())
        tkr_aff = np.dot(
            reorient_orig2std_tkr_mat if reorient2std else np.eye(4),
            get_vox2rasxfm(imgf, stem='vox2ras-tkr'))

        #from nilearn.image.resampling import reorder_img

        #img = reorder_img(uimg, resample='continuous')

        xsz, ysz, zsz = img.shape

        #print 'image coordinate transform', img.get_affine()

        imgd = img.get_data()
        if reorient2std:
            imgd = np.swapaxes(imgd, 1, 2)[:,:,::-1]

        #print 'image size', imgd.shape

        if image_name is None:
            from utils import gensym
            image_name = 'image%s'%gensym()

        self.images[image_name] = (imgd, aff, tkr_aff)
        self.currently_showing_list.append(
            NullInstanceHolder(name=image_name))
        self.currently_showing = self.currently_showing_list[-1]

        self.pins[image_name] = {}
        #self.current_pin = image_name

        self.show_image(image_name)
Ejemplo n.º 4
0
def coronal_slice(elecs, start=None, end=None, outfile=None, 
    subjects_dir=None,
    subject=None, reorient2std=True, dpi=150, size=(200,200),
    title=None): 
    '''
    create an image of a coronal slice which serves as a guesstimate of a
    depth lead inserted laterally and nonvaryingly in the Y axis

    plot the electrodes from the lead overlaid on the slice in the X and Z
    directions

    Paramaters
    ----------
    elecs : List( Electrode )
        list of electrode objects forming this depth lead
    start : Electrode
        Electrode object at one end of the depth lead
    end : Electrode
        Electrode object at the other end of the depth lead
    outfile : Str
        Filename to save the image to
    subjects_dir : Str | None
        The freesurfer subjects_dir. If this is None, it is assumed to be the
        $SUBJECTS_DIR environment variable. If this folder is not writable,
        the program will crash.
    subject : Str | None
        The freesurfer subject. If this is None, it is assumed to be the
        $SUBJECT environment variable.
    reorient2std : Bool
        Apply a matrix to rotate orig.mgz to the standard MNI orientation
        emulating fslreorient2std. Pretty much always true here.
    dpi : Int
        Dots per inch of output image
    size : Tuple
        Specify a 2-tuple to control the image size, default is (200,200)
    title : Str
        Specify a matplotlib title
    '''
    print 'creating coronal slice with start electrodes %s' % str(start)

    subjdir_subj = get_subjects_dir( subjects_dir=subjects_dir,
                                     subject=subject )
    orig = os.path.join(subjdir_subj, 'mri', 'orig.mgz')

    x_size, y_size, z_size = nib.load(orig).shape

    # vox2ras and ras2vox shouldnt have different procedures for 
    # getting the different dimensions. the matrix showing those
    # dimensions has the correct dimensions by inversion beforehand
    # in the complex 3-way case
    vox2ras = get_vox2rasxfm(orig, stem='vox2ras')
    ras2vox = np.linalg.inv(vox2ras)

    ras2vox[0:3,3] = (x_size/2, y_size/2, z_size/2)

    rd, ad, sd = get_std_orientation(ras2vox)

#    rd, = np.where(np.abs(ras2vox[:,0]) == np.max(np.abs(ras2vox[:,0])))
#    ad, = np.where(np.abs(ras2vox[:,1]) == np.max(np.abs(ras2vox[:,1])))
#    sd, = np.where(np.abs(ras2vox[:,2]) == np.max(np.abs(ras2vox[:,2])))

    r_size = [x_size, y_size, z_size][rd]
    a_size = [x_size, y_size, z_size][ad]
    s_size = [x_size, y_size, z_size][sd]

    #starty = pd.map_cursor( start.asras(), pd.current_affine, invert=True)[1]
    #endy = pd.map_cursor( end.asras(), pd.current_affine, invert=True )[1]
    #midy = (starty+endy)/2
    #pd.move_cursor(128, midy, 128)

    electrodes = np.squeeze([apply_affine([e.asras()], ras2vox) 
        for e in elecs])
    #electrodes = np.array([pd.map_cursor(e.asras(), ras2vox,
    #    invert=True) for e in elecs])

    vol = np.transpose( nib.load(orig).get_data(), (rd, ad, sd) )
    
    if start is not None and end is not None:
        start_coord = np.squeeze(apply_affine([start.asras()], ras2vox))
        end_coord = np.squeeze(apply_affine([end.asras()], ras2vox))

        if start_coord[rd] == end_coord[rd]:
            raise ValueError('This lead has no variation in the X axis. It shouldnt be displayed coronally')
        
        slice = np.zeros((s_size, r_size))
        
        m = (start_coord[ad]-end_coord[ad])/(start_coord[rd]-end_coord[rd])
        b = start_coord[ad]-m*start_coord[rd]

        rnew = np.arange(r_size)
        anew = m*rnew+b
        alower = np.floor(anew)
        afrac = np.mod(anew, 1)

        try:
            for rvox in rnew:
                slice[:, rvox] = (vol[rvox, alower[rvox], :] * 
                    (1-afrac[rvox])+vol[rvox, alower[rvox]+1, :] *
                    afrac[rvox])
        except IndexError:
            raise ValueError('This lead has minimal variation in the X axis. It shouldnt be displayed coronally')

    else:
        slice_nr = np.mean(electrodes[:,ad])
        slice = vol[:, slice_nr, :].T
    
    vox2pix = np.zeros((2,4))
    vox2pix[0, rd] = 1
    vox2pix[1, sd] = 1
    ras2pix = np.dot(vox2pix, ras2vox)

    pix = np.dot(ras2pix, 
        np.transpose([np.append(e.asras(), 1) for e in elecs]))

    #add data to coronal plane
    import pylab as pl

    fig = pl.figure()

    pl.imshow(slice, cmap='gray')
    pl.scatter(pix[0,:], pix[1,:], s=10, c='red', edgecolor='yellow',
        linewidths=0.4)

    if title is not None:
        pl.title(title)

    pl.axis('off')
    #pl.show()

    if outfile is not None:
        pl.savefig(outfile, dpi=dpi)

    return fig