def _run_interface(self, runtime):
import matplotlib
matplotlib.use("Agg")
import pylab as plt
wra_img = nib.load(self.inputs.wra_img)
canonical_img = nib.load(self.inputs.canonical_img)
title = self.inputs.title
mean_wraimg = image.mean_img(wra_img)
if title != "":
filename = title.replace(" ", "_") + ".pdf"
else:
filename = "plot.pdf"
fig = plotting.plot_anat(
mean_wraimg, title="wrafunc & canonical single subject", cut_coords=range(-40, 40, 10), display_mode="z"
)
fig.add_edges(canonical_img)
fig.savefig(filename)
fig.close()
self._plot = filename
runtime.returncode = 0
return runtime
def check_mask_coverage(epi,brainmask):
from os.path import abspath
from nipype import config, logging
config.enable_debug_mode()
logging.update_logging(config)
from nilearn import plotting
from nipype.interfaces.nipy.preprocess import Trim
trim = Trim()
trim.inputs.in_file = epi
trim.inputs.end_index = 1
trim.inputs.out_file = 'epi_vol1.nii.gz'
trim.run()
epi_vol = abspath('epi_vol1.nii.gz')
maskcheck_filename='maskcheck.png'
display = plotting.plot_anat(epi_vol, display_mode='ortho',
draw_cross=False,
title = 'brainmask coverage')
display.add_contours(brainmask,levels=[.5], colors='r')
display.savefig(maskcheck_filename)
display.close()
maskcheck_file = abspath(maskcheck_filename)
return(maskcheck_file)
def plot_artifact(image_path, figsize=(20, 20), vmax=None, cut_coords=None, display_mode='ortho',
size=None):
import nilearn.plotting as nplt
fig = plt.figure(figsize=figsize)
nplt_disp = nplt.plot_anat(
image_path, display_mode=display_mode, cut_coords=cut_coords,
vmax=vmax, figure=fig, annotate=False)
if size is None:
size = figsize[0] * 6
bg_color = 'k'
fg_color = 'w'
ax = fig.gca()
ax.text(
.1, .95, 'L',
transform=ax.transAxes,
horizontalalignment='left',
verticalalignment='top',
size=size,
bbox=dict(boxstyle="square,pad=0", ec=bg_color, fc=bg_color, alpha=1),
color=fg_color)
ax.text(
.9, .95, 'R',
transform=ax.transAxes,
horizontalalignment='right',
verticalalignment='top',
size=size,
bbox=dict(boxstyle="square,pad=0", ec=bg_color, fc=bg_color),
color=fg_color)
return nplt_disp, ax
def plot_segmentation(anat_file, segmentation, out_file,
**kwargs):
from nilearn.plotting import plot_anat
vmax = None
if kwargs.get('saturate', False):
import nibabel as nb
import numpy as np
vmax = np.percentile(nb.load(anat_file).get_data().reshape(-1),
70)
disp = plot_anat(
anat_file,
display_mode=kwargs.get('display_mode', 'ortho'),
cut_coords=kwargs.get('cut_coords', 8),
title=kwargs.get('title'),
vmax=vmax)
disp.add_contours(
segmentation,
levels=kwargs.get('levels', [1]),
colors=kwargs.get('colors', 'r'))
disp.savefig(out_file)
disp.close()
disp = None
return out_file
def plot_segmentation(anat_file, segmentation, out_file,
**kwargs):
from nilearn.plotting import plot_anat
vmax = kwargs.get('vmax')
vmin = kwargs.get('vmin')
if kwargs.get('saturate', False):
vmax = np.percentile(nb.load(anat_file).get_data().reshape(-1), 70)
if vmax is None and vmin is None:
vmin = np.percentile(nb.load(anat_file).get_data().reshape(-1), 10)
vmax = np.percentile(nb.load(anat_file).get_data().reshape(-1), 99)
disp = plot_anat(
anat_file,
display_mode=kwargs.get('display_mode', 'ortho'),
cut_coords=kwargs.get('cut_coords', 8),
title=kwargs.get('title'),
vmax=vmax, vmin=vmin)
disp.add_contours(
segmentation,
levels=kwargs.get('levels', [1]),
colors=kwargs.get('colors', 'r'))
disp.savefig(out_file)
disp.close()
disp = None
return out_file
def _run_interface(self, runtime):
import matplotlib
matplotlib.use('Agg')
import nibabel as nib
from nilearn import plotting, datasets, image
from nipype.interfaces.base import isdefined
import numpy as np
import pylab as plt
import os
wra_img = nib.load(self.inputs.wra_img)
canonical_img = nib.load(self.inputs.canonical_img)
title = self.inputs.title
mean_wraimg = image.mean_img(wra_img)
if title != "":
filename = title.replace(" ", "_")+".pdf"
else:
filename = "plot.pdf"
fig = plotting.plot_anat(mean_wraimg, title="wrafunc & canonical single subject", cut_coords=range(-40, 40, 10), display_mode='z')
fig.add_edges(canonical_img)
fig.savefig(filename)
fig.close()
self._plot = filename
runtime.returncode=0
return runtime
def _plot_anat_with_contours(image, segs=None, compress='auto',
**plot_params):
nsegs = len(segs or [])
plot_params = plot_params or {}
# plot_params' values can be None, however they MUST NOT
# be None for colors and levels from this point on.
colors = plot_params.pop('colors', None) or []
levels = plot_params.pop('levels', None) or []
missing = nsegs - len(colors)
if missing > 0: # missing may be negative
colors = colors + color_palette("husl", missing)
colors = [[c] if not isinstance(c, list) else c
for c in colors]
if not levels:
levels = [[0.5]] * nsegs
# anatomical
display = plot_anat(image, **plot_params)
# remove plot_anat -specific parameters
plot_params.pop('display_mode')
plot_params.pop('cut_coords')
plot_params['linewidths'] = 0.5
for i in reversed(range(nsegs)):
plot_params['colors'] = colors[i]
display.add_contours(segs[i], levels=levels[i],
**plot_params)
svg = extract_svg(display, compress=compress)
display.close()
return svg
def make_anat_image(nifti_file,png_img_file=None):
"""Make anat image"""
nifti_file = str(nifti_file)
brain = plot_anat(nifti_file)
if png_img_file:
brain.savefig(png_img_file)
plt.close('all')
return brain
def anatomical_overlay(in_file, overlay_file, out_file):
import os.path
import matplotlib as mpl
mpl.use('Agg')
from nilearn.plotting import plot_anat as plot_anat
mask_display = plot_anat(in_file)
mask_display.add_edges(overlay_file)
mask_display.dim = -1
# mask_display.add_contours(overlay_file)
# mask_display.add_overlay(overlay_file)
mask_display.title(out_file, x=0.01, y=0.99, size=15, color=None,
bgcolor=None, alpha=1)
mask_display.savefig(out_file)
return os.path.abspath(out_file)
def plot_image(input_files, output_directory, edge_file=None,
overlay_file=None,
contour_file=None, name=None, overlay_cmap=None):
""" Plot image with edge/overlay/contour on top (useful for checking
registration).
<unit>
<input name="input_files" type="['List_File', 'File']" desc="An image
or a list of image to be displayed."/>
<input name="output_directory" type="Directory" description="The
destination folder."/>
<input name="edge_file" type="File" description="The target image
to extract the edges from."/>
<input name="overlay_file" type="File" description="The target image
to extract the overlay from."/>
<input name="contour_file" type="File" description="The target image
to extract the contour from."/>
<input name="name" type="Str" description="The name of the plot."/>
<input name="overlay_cmap" type="Str" description="The color map to
use: 'cold_hot' or 'blue_red' or None."/>
<output name="snap_file" type="File" description="A pdf snap of the
image."/>
</unit>
"""
input_file = input_files[0]
# Check the input images exist on the file system
for in_file in [input_file, edge_file, overlay_file, contour_file]:
if in_file is not None and not os.path.isfile(in_file):
raise ValueError("'{0}' is not a valid filename.".format(in_file))
# Create the 'snap_file' location
snap_file = os.path.join(
output_directory, os.path.basename(input_file).split(".")[0] + ".pdf")
# Create the plot
display = plotting.plot_anat(input_file, title=name or "")
if edge_file is not None:
display.add_edges(edge_file)
if overlay_file is not None:
cmap = plotting.cm.__dict__.get(
overlay_cmap, plotting.cm.alpha_cmap((1, 1, 0)))
display.add_overlay(overlay_file, cmap=cmap)
if contour_file is not None:
display.add_contours(contour_file, alpha=0.6, filled=True,
linestyles="solid")
display.savefig(snap_file)
display.close()
return snap_file
def create_coreg_plot(epi,anat):
import os
from nipype import config, logging
config.enable_debug_mode()
logging.update_logging(config)
from nilearn import plotting
coreg_filename='coregistration.png'
display = plotting.plot_anat(epi, display_mode='ortho',
draw_cross=False,
title = 'coregistration to anatomy')
display.add_edges(anat)
display.savefig(coreg_filename)
display.close()
coreg_file = os.path.abspath(coreg_filename)
return(coreg_file)
def edges_overlay(input_file, template_file, prefix="e", output_directory=None):
""" Plot image outline on top of another image (useful for checking
registration)
<unit>
<input name="input_file" type="File" desc="An image to display."/>
<input name="template_file" type="File" desc="The target image to
extract the edges from."/>
<input name="prefix" type="String" desc="the prefix of the result
file."/>
<input name="output_directory" type="Directory" desc="The destination
folder." optional="True"/>
<output name="edges_file" type="File" desc="A snap with two overlayed
images."/>
</unit>
"""
# Check the input images exist on the file system
for in_file in [input_file, template_file]:
if not os.path.isfile(in_file):
raise ValueError("'{0}' is not a valid filename.".format(in_file))
# Check that the outdir is valid
if output_directory is not None:
if not os.path.isdir(output_directory):
raise ValueError("'{0}' is not a valid directory.".format(output_directory))
else:
output_directory = os.path.dirname(input_file)
# Create the plot
display = plotting.plot_anat(input_file, title="Overlay")
display.add_edges(template_file)
edges_file = os.path.join(output_directory, prefix + os.path.basename(input_file).split(".")[0] + ".pdf")
display.savefig(edges_file)
display.close()
return edges_file
fieldmap_pa = join(raw_nifti_dir, scanInfo.loc['se_fieldmap_pa']['scanName'])
ref_epi = join(raw_nifti_dir, scanInfo.loc[last_scan]['scanName'])
# run topup
get_ipython().system("{join(codedir, 'prep_unwarpFiles.sh')} {outdir} {fieldmap_ap} {fieldmap_pa}
{acqparams_file} {config_file} {ref_epi}")
# MAKE FIELDMAP FIGURES ----------------------------------------------
# Original SE maps
fieldmap = join(outdir, 'concat_fieldmaps.nii.gz')
print('saving images of original SE maps...')
for i in range(3):
plot_title = 'orig_se_ap_' + str(i)
plotting.plot_anat(image.index_img(fieldmap,i), dim=-1, title=plot_title,
output_file = join(fm_outdir, plot_title + '.png'))
for i in range(3,6):
plot_title = 'orig_se_pa_' + str(i)
plotting.plot_anat(image.index_img(fieldmap,i), dim=-1, title=plot_title,
output_file = join(fm_outdir, plot_title + '.png'))
# Corrected SE maps
fieldmap = join(outdir, 'topup_iout.nii.gz')
print('saving images of corrected SE maps...')
for i in range(3):
plot_title = 'corr_se_ap_' + str(i)
plotting.plot_anat(image.index_img(fieldmap,i), dim=-1, title=plot_title,
output_file = join(fm_outdir, plot_title + '.png'))
for i in range(3,6):
plot_title = 'corr_se_pa_' + str(i)
plotting.plot_anat(image.index_img(fieldmap,i), dim=-1, title=plot_title,
# view.open_in_browser()
###############################################################################
# Plotting statistical maps in a glass brain with function `plot_glass_brain`
# ---------------------------------------------------------------------------
#
# Now, the t-map image is mapped on glass brain representation where glass
# brain is always a fixed background template
plotting.plot_glass_brain(stat_img, title='plot_glass_brain', threshold=3)
###############################################################################
# Plotting anatomical images with function `plot_anat`
# -----------------------------------------------------
#
# Visualizing anatomical image of haxby dataset
plotting.plot_anat(haxby_anat_filename, title="plot_anat")
###############################################################################
# Plotting ROIs (here the mask) with function `plot_roi`
# -------------------------------------------------------
#
# Visualizing ventral temporal region image from haxby dataset overlaid on
# subject specific anatomical image with coordinates positioned automatically on
# region of interest (roi)
plotting.plot_roi(haxby_mask_filename,
bg_img=haxby_anat_filename,
title="plot_roi")
###############################################################################
# Plotting EPI image with function `plot_epi`
# ---------------------------------------------
def plot_denoise(lowb_nii,
highb_nii,
div_id,
plot_params=None,
highb_plot_params=None,
order=('z', 'x', 'y'),
cuts=None,
estimate_brightness=False,
label=None,
lowb_contour=None,
highb_contour=None,
compress='auto',
overlay=None,
overlay_params=None):
"""
Plot the foreground and background views.
Default order is: axial, coronal, sagittal
Updated version from sdcflows
"""
plot_params = plot_params or {}
highb_plot_params = highb_plot_params or {}
# Use default MNI cuts if none defined
if cuts is None:
raise NotImplementedError
# Do the low-b image first
out_files = []
if estimate_brightness:
plot_params = robust_set_limits(
lowb_nii.get_fdata(dtype='float32').reshape(-1), plot_params)
# Plot each cut axis for low-b
for i, mode in enumerate(list(order)):
plot_params['display_mode'] = mode
plot_params['cut_coords'] = cuts[mode]
if i == 0:
plot_params['title'] = label + ": low-b"
else:
plot_params['title'] = None
# Generate nilearn figure
display = plot_anat(lowb_nii, **plot_params)
if lowb_contour is not None:
display.add_contours(lowb_contour, linewidths=1)
svg = extract_svg(display, compress=compress)
display.close()
# Find and replace the figure_1 id.
xml_data = etree.fromstring(svg)
find_text = etree.ETXPath("//{%s}g[@id='figure_1']" % SVGNS)
find_text(xml_data)[0].set('id', '%s-%s-%s' % (div_id, mode, uuid4()))
svg_fig = SVGFigure()
svg_fig.root = xml_data
out_files.append(svg_fig)
# Plot each cut axis for high-b
if estimate_brightness:
highb_plot_params = robust_set_limits(
highb_nii.get_fdata(dtype='float32').reshape(-1),
highb_plot_params)
for i, mode in enumerate(list(order)):
highb_plot_params['display_mode'] = mode
highb_plot_params['cut_coords'] = cuts[mode]
if i == 0:
highb_plot_params['title'] = label + ': high-b'
else:
highb_plot_params['title'] = None
# Generate nilearn figure
display = plot_anat(highb_nii, **highb_plot_params)
if highb_contour is not None:
display.add_contours(highb_contour, linewidths=1)
svg = extract_svg(display, compress=compress)
display.close()
# Find and replace the figure_1 id.
xml_data = etree.fromstring(svg)
find_text = etree.ETXPath("//{%s}g[@id='figure_1']" % SVGNS)
find_text(xml_data)[0].set('id', '%s-%s-%s' % (div_id, mode, uuid4()))
svg_fig = SVGFigure()
svg_fig.root = xml_data
out_files.append(svg_fig)
return out_files
# Create a memory context
from nipype.caching import Memory
mem = Memory('/tmp/no_workflow')
# Give the paths to spm
paths = ['/i2bm/local/spm12-standalone-6472/spm12_mcr/spm12/']
# Compute mean functional
from procasl import preprocessing
average = mem.cache(preprocessing.Average)
out_average = average(in_file='/tmp/func.nii')
mean_func = out_average.outputs.mean_file
# Coregister anat to mean functional
from nipype.interfaces import spm
coregister = mem.cache(spm.Coregister)
out_coregister = coregister(
target=mean_func,
source='/tmp/anat.nii',
write_interp=3)
# Check coregistration
import matplotlib.pylab as plt
from nilearn import plotting
figure = plt.figure(figsize=(5, 4))
display = plotting.plot_anat(mean_func, figure=figure,
title='anat edges on mean functional')
display.add_edges(out_coregister.outputs.coregistered_source)
figure.suptitle('Impact of tagging correction')
plt.show()
# plotting slices for finer alignment
# e.g. parieto-occipital sulcus
def add_brain_schematics(display):
for axes in display.axes.values():
kwargs = {'alpha': 0.5, 'linewidth': 1, 'edgecolor': 'orange'}
object_bounds = glass_brain.plot_brain_schematics(axes.ax,
axes.direction,
**kwargs)
axes.add_object_bounds(object_bounds)
# side
display = plotting.plot_anat(display_mode='x', cut_coords=[-2])
add_brain_schematics(display)
# top
display = plotting.plot_anat(display_mode='z', cut_coords=[20])
add_brain_schematics(display)
# front
display = plotting.plot_anat(display_mode='y', cut_coords=[-20])
add_brain_schematics(display)
# all in one
display = plotting.plot_anat(display_mode='ortho', cut_coords=(-2, -20, 20))
add_brain_schematics(display)
# Plot multiple slices
def regular(args):
# Initialize extractor
if glob(os.path.join(args.outdir, '*')) != []:
raise Exception("The dir '{0}' is not empty!".format(args.outdir))
try:
# get an tmp dir change dir
tmpdir = tempfile.mkdtemp()
prevdir = os.getcwd()
os.chdir(tmpdir)
#
ImageFilePath = args.image
work_in = os.path.basename(ImageFilePath)
OutDirPath = args.outdir
# base/XX/model02/XX_bfc.nii.gz -> cropped
tmp_cropped = 'fov_cropped'
# create cropped volume
cmd = ['fsl5.0-robustfov',
'-i', ImageFilePath,
'-m', tmp_cropped]
print ">>> ", os.getcwd(), " <<<", " ".join(cmd)
results = subprocess.check_call(cmd)
# get cropped xfromation
cmd = ['fsl5.0-robustfov',
'-i', ImageFilePath,
'-r', tmp_cropped]
print ">>> ", os.getcwd(), " <<<", " ".join(cmd)
results = subprocess.check_call(cmd)
# apply xfromation to get the file cropped in working dir and remain
# in native referential
cmd = ['fsl5.0-flirt',
'-in', tmp_cropped,
'-ref', ImageFilePath,
'-init', tmp_cropped,
'-applyxfm',
'-out', work_in ]
print ">>> ", os.getcwd(), " <<<", " ".join(cmd)
results = subprocess.check_call(cmd)
# perform bet extraction and mask transcoding in float32
mask_bet = work_in.replace('bfc', 'bfc_betmask')
mask_bin = mask_bet.replace('betmask', 'betmask_mask')
cmd = ['fsl5.0-bet', work_in, mask_bet, '-m', '-S', '-R']
print ">>> ", os.getcwd(), " <<<", " ".join(cmd)
results = subprocess.check_call(cmd)
print ">>> ", os.getcwd(), " <<<", "Convert bet mask in float image: ",mask_bin
nimg = ni.load(mask_bin)
ni.save(ni.Nifti1Image(nimg.get_data().astype('float32'),
affine=nimg.get_affine()),
mask_bin)
# performe fast segmentation
# --out flag does not seem to work : ugly workaround ...
cmd = ['fsl5.0-fast',
' -t 1 -n 3 ',
mask_bet]
print ">>> ", os.getcwd(), " <<<", " ".join(cmd)
results = subprocess.check_call(cmd)
# rename_fns = unique(glob('*seg*') + glob('*pve*')).tolist()
# for rename_fn in rename_fns:
# shutil.move(rename_fn,
# rename_fn.replace('betmask',
# work_in.replace('.nii.gz', '')))
# rename_fns = unique(glob('*betmask*')).tolist()
# for rename_fn in rename_fns:
# shutil.move(rename_fn,
# rename_fn.replace('betmask',
# '{}_betmask'.format(work_in.replace('.nii.gz', '')))
# QC : pdf sheet
bg = ni.load(work_in.replace('.nii.gz', '_betmask_pveseg.nii.gz'))
# image axial
display = plotting.plot_anat(bg, title="FAST segmentation",
display_mode = 'z',
cut_coords = 20)
display.savefig('{}_pveseg.pdf'.format(work_in.replace('.nii.gz', '')))
display.close()
# affine registration -in betmask -ref MNI_brain_1mm
cmd = [
'fsl5.0-flirt',
'-dof', '12',
'-omat', 'nat2mni',
'-in', mask_bet,
'-ref', MNI_BRAIN
]
print ">>> ", os.getcwd(), " <<<", " ".join(cmd)
results = subprocess.check_call(cmd)
#invert Xformation
cmd = [
'fsl5.0-convert_xfm',
'-omat', 'mni2nat',
'-inverse', 'nat2mni'
]
print ">>> ", os.getcwd(), " <<<", " ".join(cmd)
results = subprocess.check_call(cmd)
tmp_cropped = 'fov_cropped'
# create a 40 mm height hat box in mni
mni = ni.load(MNI_BRAIN)
hat_data = mni.get_data()
hat_data[hat_data < 800] = 0
_, _, zmax = hat_data.shape
hat_data[:, :, 121:zmax] = 0
hat_data[:, :, 0:79] = 0
hat_data[hat_data != 0] = 1
ni.save(ni.Nifti1Image(hat_data, affine=mni.get_affine()),
'hatbox.nii.gz')
#
cmd = ['fsl5.0-flirt',
'-applyxfm',
'-init', 'mni2nat',
'-ref', ImageFilePath,
'-in', 'hatbox.nii.gz',
'-out', 'native_hatbox.nii.gz'
]
print ">>> ", os.getcwd(), " <<<", " ".join(cmd)
results = subprocess.check_call(cmd)
hat_box = ni.load('native_hatbox.nii.gz')
hat_data = hat_box.get_data()
hat_data[hat_data != 0] = 1
ni.save(ni.Nifti1Image(hat_data, affine=hat_box.get_affine()),
'native_hatbox.nii.gz')
# create QC for hat_box steps
bg = ni.load('native_hatbox.nii.gz')
display = plotting.plot_anat(
ni.load(ImageFilePath),
title="T1 Gado with hatbox contours",
display_mode = 'z',
cut_coords = 10)
display.add_overlay(bg, threshold=0)
display.savefig("QC_axial_hatbox.pdf")
display.close()
display = plotting.plot_anat(
ni.load(ImageFilePath),
title="T1 Gado with hatbox contours",
display_mode = 'x',
cut_coords = 10)
display.add_overlay(bg, threshold=0)
display.savefig("QC_sagital_hatbox.pdf")
display.close()
# move selected files
flist = unique(glob('*'))
for f in flist:
shutil.move(f, OutDirPath)
except Exception:
print 'model03_mni registration/segmentation FAILED:\n%s', traceback.format_exc()
# finale housekeeping
os.chdir(prevdir)
shutil.rmtree(tmpdir)
get_tmaps=True)
localizer_anat_filename = localizer_dataset.anats[1]
localizer_cmap_filename = localizer_dataset.cmaps[1]
localizer_tmap_filename = localizer_dataset.tmaps[1]
###############################################################################
# demo the different plotting functions
# Plotting statistical maps
plotting.plot_stat_map(localizer_cmap_filename, bg_img=localizer_anat_filename,
threshold=3, title="plot_stat_map",
cut_coords=(36, -27, 66))
# Plotting glass brain
plotting.plot_glass_brain(localizer_tmap_filename, title='plot_glass_brain',
threshold=3)
# Plotting anatomical maps
plotting.plot_anat(haxby_anat_filename, title="plot_anat")
# Plotting ROIs (here the mask)
plotting.plot_roi(haxby_mask_filename, bg_img=haxby_anat_filename,
title="plot_roi")
# Plotting EPI haxby
mean_haxby_img = image.mean_img(haxby_func_filename)
plotting.plot_epi(mean_haxby_img, title="plot_epi")
import matplotlib.pyplot as plt
plt.show()
def plotAnatomyExternal(self):
plotting.plot_anat(self.anatomy_location, title='Anatomy')
plt.show()
from mne.simulation import simulate_evoked
from mne.forward import make_forward_dipole
# evoked=evoked_full
evoked_full = evoked.copy()
evoked.crop(0.14, 0.16)
# Fit a dipole
dip = mne.fit_dipole(evoked, cov, bem, trans)[0]
# Plot the result in 3D brain with the MRI image.
dip.plot_locations(trans, mri_partic, subjects_dir=mri_dir, mode='orthoview')
#plot on scan
mni_pos = mne.head_to_mni(dip.pos, mri_head_t=trans,subject=mri_partic, subjects_dir=mri_dir)
mri_pos = mne.head_to_mri(dip.pos, mri_head_t=trans,subject=mri_partic, subjects_dir=mri_dir)
t1_fname = mri_dir+'\\'+ mri_partic+ '\\mri\\T1.mgz'
fig_T1 = plot_anat(t1_fname, cut_coords=mri_pos[0], title='Dipole loc.')
# #plot on standard
# from nilearn.datasets import load_mni152_template
# template = load_mni152_template()
# fig_template = plot_anat(template, cut_coords=mni_pos[0],title='Dipole loc. (MNI Space)')
#plot fied predicted by dipole with max goodness of fit, compare to data and take diff
fwd_dip, stc_dip = make_forward_dipole(dip, bem, evoked.info, trans)
pred_evoked = simulate_evoked(fwd_dip, stc_dip, evoked.info, cov=None, nave=np.inf)
# find time point with highest goodness of fit (gof)
best_idx = np.argmax(dip.gof)
best_time = dip.times[best_idx]
print('Highest GOF %0.1f%% at t=%0.1f ms with confidence volume %0.1f cm^3'
% (dip.gof[best_idx], best_time * 1000,
dip.conf['vol'][best_idx] * 100 ** 3))
reg_func_file = path_fmri + subjectID + "/ants/epi2braints.nii.gz"
t1_file = "/shared/nonrestricted/connectome/Subjects/" + subjectID + \
"/T1w/T1w_acpc_dc_restore_brain_2.00.nii.gz"
if os.path.exists(reg_func_file) and os.path.exists(t1_file):
try:
reg_func = nibabel.load(reg_func_file)
first_vol = image.index_img(reg_func, 0)
t1 = nibabel.load(t1_file)
except:
print("{}: Error reading image".format(subjectID))
continue
struct = plotting.plot_anat(t1, title = subjectID)
struct.add_edges(first_vol)
struct.savefig("reports/" + subjectID + "/epi2struct.png")
epi2struct = "reports/" + subjectID + "/epi2struct.png "
subjects_as_string += epi2struct
else:
print("{}: Missing image".format(subjectID))
#break
# Creates a pdf of functional images overlaid on T1 for all subjects
os.system("convert " + subjects_as_string + " reports/missing_subs_epi2struct.pdf")
print([[lab, np.sum(mask_clustlabels_arr == lab)] for lab in labels])
#[[1, 95], [2, 179484], [3, 28], [4, 24], [5, 49], [6, 35], [7, 56], [8, 23], [9, 48], [10, 50], [11, 425], [12, 68], [13, 22], [14, 79], [15, 151], [16, 33], [17, 78], [18, 54], [19, 308], [20, 22], [21, 29], [22, 118], [23, 125], [24, 122], [25, 48], [26, 51], [27, 266], [28, 31], [29, 129], [30, 58], [31, 187287], [32, 27], [33, 24], [34, 39], [35, 29], [36, 68], [37, 30], [38, 21], [39, 83], [40, 324], [41, 122], [42, 108], [43, 37], [44, 48], [45, 106], [46, 24], [47, 63], [48, 47], [49, 263], [50, 37], [51, 46], [52, 23], [53, 76], [54, 43], [55, 22], [56, 68], [57, 70], [58, 34]]
assert mask_arr.sum() == 371278
nibabel.Nifti1Image(mask_arr.astype(int), affine=ref_img.affine).to_filename(
os.path.join(ANALYSIS_DATA_PATH, "mask.nii.gz"))
# Plot mask
mask_img = nibabel.Nifti1Image(mask_arr.astype(float), affine=ref_img.affine)
nslices = 8
fig = plt.figure(figsize=(19.995, 11.25))
ax = fig.add_subplot(311)
plotting.plot_anat(mask_img,
display_mode='z',
cut_coords=nslices,
figure=fig,
axes=ax)
ax = fig.add_subplot(312)
plotting.plot_anat(mask_img,
display_mode='y',
cut_coords=nslices,
figure=fig,
axes=ax)
ax = fig.add_subplot(313)
plotting.plot_anat(mask_img,
display_mode='x',
cut_coords=nslices,
figure=fig,
axes=ax)
plt.savefig(os.path.join(ANALYSIS_DATA_PATH, "mask.png"))
from nipype.caching import Memory
cache_directory = "/tmp"
mem = Memory("/tmp")
os.chdir(cache_directory)
# Compute mean functional
from procasl import preprocessing
average = mem.cache(preprocessing.Average)
out_average = average(in_file=heroes["raw ASL"][0])
mean_func = out_average.outputs.mean_image
# Coregister anat to mean functional
from nipype.interfaces import spm
coregister = mem.cache(spm.Coregister)
out_coregister = coregister(target=mean_func, source=raw_anat, write_interp=3)
# Check coregistration
import matplotlib.pylab as plt
from nilearn import plotting
for anat, label in zip([raw_anat, out_coregister.outputs.coregistered_source], ["native", "coregistered"]):
figure = plt.figure(figsize=(5, 4))
display = plotting.plot_anat(
anat, figure=figure, display_mode="z", cut_coords=(-66,), title=label + " anat edges on mean functional"
)
display.add_edges(mean_func)
plotting.show()
# First, we plot a network of index=4 without region extraction (left plot)
img = image.index_img(components_img, 4)
coords = plotting.find_xyz_cut_coords(img)
display = plotting.plot_stat_map(img,
cut_coords=coords,
colorbar=False,
title='Showing one specific network')
# Now, we plot (right side) same network after region extraction to show that
# connected regions are nicely seperated.
# Each brain extracted region is identified as separate color.
# For this, we take the indices of the all regions extracted related to original
# network given as 4.
regions_indices_of_map3 = np.where(np.array(regions_index) == 4)
display = plotting.plot_anat(cut_coords=coords,
title='Extracted regions in one specific network')
# Now add as an overlay by looping over all the regions of index 4
# color list is random (you can choose your own color)
color_list = [[0., 1., 0.29, 1.], [0., 1., 0.54, 1.], [0., 1., 0.78, 1.],
[0., 0.96, 1., 1.], [0., 0.73, 1., 1.], [0., 0.47, 1., 1.],
[0., 0.22, 1., 1.], [0.01, 0., 1., 1.], [0.26, 0., 1., 1.]]
for each_index_of_map3, color in zip(regions_indices_of_map3[0], color_list):
display.add_overlay(image.index_img(regions_extracted_img,
each_index_of_map3),
cmap=plotting.cm.alpha_cmap(color))
plotting.show()
def rescue(args):
# Initialize extractor
try:
# get an tmp dir change dir
tmpdir = tempfile.mkdtemp()
prevdir = os.getcwd()
os.chdir(tmpdir)
#
ImageFilePath = (args.image).replace('model02', 'model03')
OutDirPath = args.outdir
#
atlas_im = '/neurospin/radiomics/studies/metastasis/base/187962757123/model02/187962757123_enh-gado_T1w_bfc.nii.gz'
atlas_nat2mni = '/neurospin/radiomics/studies/metastasis/base/187962757123/model03/nat2mni'
# intermediate path
cmd = ['fsl5.0-flirt',
'-in', ImageFilePath,
'-ref', atlas_im,
'-dof', '12',
'-omat', 'image2atlas']
print ">>> ", os.getcwd(), " <<<", " ".join(cmd)
results = subprocess.check_call(cmd)
cmd = ['fsl5.0-convert_xfm',
'-omat', 'nat2mni',
'-concat', atlas_nat2mni, 'image2atlas']
print ">>> ", os.getcwd(), " <<<", " ".join(cmd)
results = subprocess.check_call(cmd)
#invert Xformation
cmd = [
'fsl5.0-convert_xfm',
'-omat', 'mni2nat',
'-inverse', 'nat2mni'
]
print ">>> ", os.getcwd(), " <<<", " ".join(cmd)
results = subprocess.check_call(cmd)
cmd = ['fsl5.0-flirt',
'-applyxfm',
'-init', 'mni2nat',
'-ref', ImageFilePath,
'-in', os.path.join(os.path.dirname(ImageFilePath), 'hatbox.nii.gz'),
'-out', 'native_hatbox.nii.gz'
]
print ">>> ", os.getcwd(), " <<<", " ".join(cmd)
results = subprocess.check_call(cmd)
hat_box = ni.load('native_hatbox.nii.gz')
hat_data = hat_box.get_data()
hat_data[hat_data != 0] = 1
ni.save(ni.Nifti1Image(hat_data, affine=hat_box.get_affine()),
'native_hatbox.nii.gz')
# create QC for hat_box steps
bg = ni.load('native_hatbox.nii.gz')
display = plotting.plot_anat(
ni.load(ImageFilePath),
title="T1 Gado with hatbox contours",
display_mode = 'z',
cut_coords = 10)
display.add_overlay(bg, threshold=0)
display.savefig("QC_axial_hatbox.pdf")
display.close()
display = plotting.plot_anat(
ni.load(ImageFilePath),
title="T1 Gado with hatbox contours",
display_mode = 'x',
cut_coords = 10)
display.add_overlay(bg, threshold=0)
display.savefig("QC_sagital_hatbox.pdf")
display.close()
# move selected files
flist = ['image2atlas', 'mni2nat',
'nat2mni', 'native_hatbox.nii.gz', 'QC_axial_hatbox.pdf',
'QC_sagital_hatbox.pdf']
for f in flist:
if os.path.exists(os.path.join(OutDirPath, f)):
os.remove(os.path.join(OutDirPath, f))
for f in flist:
shutil.move(f, OutDirPath)
except Exception:
print 'model03_mni rescue registration/segmentation FAILED:\n%s', traceback.format_exc()
# finale housekeeping
os.chdir(prevdir)
shutil.rmtree(tmpdir)
group_means = math_img(
'img * (np.sum(img!=0, axis=-1)>=(img.shape[-1]/2.))[..., None]',
img=group_means)
# Create tsnr mean map
group_img = math_img('np.mean(img, axis=-1)', img=group_means)
group_img.to_filename('%s/group_tsnr%s.nii.gz' % (res_path, method))
# Plot figure
display = plot_anat(
group_img,
display_mode='xz',
cut_coords=[-20, 10],
colorbar=False,
cmap='Spectral_r',
threshold=350,
vmin=350,
vmax=1400,
dim=1,
annotate=False,
draw_cross=False,
black_bg=True,
)
img_tmp = nb.load(template_gm)
display.savefig('%s/group_tsnr%s_%s.svg' % (res_path, postfix, method))
tsnr_values.append([method, group_img.get_data()])
# Plot histograms of voxel distribution above threshold
sns.set_style('darkgrid')
plt.style.use('seaborn-colorblind')
threshold = 1
img=group_means)
# Create standard deviation map
group_img = math_img('np.std(img, axis=-1)', img=group_means)
group_img.to_filename('%s/group_stdev_%s.nii.gz' % (res_path, method))
# Plot figure
fig = plt.figure(figsize=(4, 4))
display = plot_anat(
group_img,
display_mode='yz',
cut_coords=[-10, 10],
colorbar=False,
cmap='Spectral_r',
threshold=150,
vmin=150,
vmax=500,
#title=method,
dim=1,
annotate=False,
draw_cross=False,
black_bg=True,
figure=fig,
)
img_tmp = nb.load(template_gm)
img_tmp = new_img_like(img_tmp, (img_tmp.get_data() >= 0.05).astype('int'),
copy_header=True)
display.add_contours(img_tmp, color='w')
fig.savefig('%s/group_stdev_%s.svg' % (res_path, method))
stdev_values.append([method, group_img.get_data()])
plotting.plot_stat_map(localizer_cmap_filename,
display_mode='yx',
cut_coords=(-27, 36),
title="display_mode='yx', cut_coords=(-27, 36)")
plotting.plot_stat_map(localizer_cmap_filename,
display_mode='yz',
cut_coords=(-27, 60),
title="display_mode='yz', cut_coords=(-27, 60)")
###############################################################################
# demo display objects with add_ methods
mean_haxby_img = image.mean_img(haxby_func_filename)
# Plot T1 outline on top of the mean EPI (useful for checking coregistration)
display = plotting.plot_anat(mean_haxby_img, title="add_edges")
display.add_edges(haxby_anat_filename)
# Plotting outline of the mask on top of the EPI
display = plotting.plot_anat(mean_haxby_img,
title="add_contours",
cut_coords=(28, -34, -22))
display.add_contours(haxby_mask_filename, levels=[0.5], colors='r')
###############################################################################
# demo saving plots to file
plotting.plot_stat_map(localizer_cmap_filename,
title='Using plot_stat_map output_file',
output_file='plot_stat_map.png')
anat_img = nibabel.load(anat_filename)
# Accessing image data and affine #############################################
anat_data = anat_img.get_data()
print 'anat_data has shape:', anat_data.shape
anat_affine = anat_img.get_affine()
print 'anat_affine:\n', anat_affine
# Using image in nilearn functions ############################################
from nilearn import image
# functions containing 'img' can take either a filename or an image as input
smooth_anat_img = image.smooth_img(anat_filename, 6)
smooth_anat_img = image.smooth_img(anat_img, 6)
# Visualization ###############################################################
from nilearn import plotting
cut_coords = (0, 0, 0)
plotting.plot_anat(anat_filename, cut_coords=cut_coords,
title='Anatomy image')
plotting.plot_anat(smooth_anat_img,
cut_coords=cut_coords,
title='Smoothed anatomy image')
# Saving image to file ########################################################
smooth_anat_img.to_filename('smooth_anat_img.nii.gz')
# Showing plots ###############################################################
import matplotlib.pyplot as plt
plt.show()
# # .. note:: In this tutorial, we load the data using a data downloading # function. To input your own data, you will need to provide # a list of paths to your own files in the ``subject_data`` variable. # These should abide to the Brain Imaging Data Structure (BIDS) # organization. from nistats.datasets import fetch_spm_auditory subject_data = fetch_spm_auditory() print(subject_data.func) # print the list of names of functional images ############################################################################### # We can display the first functional image and the subject's anatomy: from nilearn.plotting import plot_stat_map, plot_anat, plot_img, show plot_img(subject_data.func[0]) plot_anat(subject_data.anat) ############################################################################### # Next, we concatenate all the 3D EPI image into a single 4D image, # then we average them in order to create a background # image that will be used to display the activations: from nilearn.image import concat_imgs, mean_img fmri_img = concat_imgs(subject_data.func) mean_img = mean_img(fmri_img) ############################################################################### # Specifying the experimental paradigm # ------------------------------------ # # We must now provide a description of the experiment, that is, define the
# Plot regions extracted for only one specific network
# ----------------------------------------------------
# First, we plot a network of index=4 without region extraction (left plot)
from nilearn import image
img = image.index_img(components_img, 4)
coords = plotting.find_xyz_cut_coords(img)
display = plotting.plot_stat_map(img, cut_coords=coords, colorbar=False,
title='Showing one specific network')
################################################################################
# Now, we plot (right side) same network after region extraction to show that
# connected regions are nicely seperated.
# Each brain extracted region is identified as separate color.
# For this, we take the indices of the all regions extracted related to original
# network given as 4.
regions_indices_of_map3 = np.where(np.array(regions_index) == 4)
display = plotting.plot_anat(cut_coords=coords,
title='Regions from this network')
# Add as an overlay all the regions of index 4
colors = 'rgbcmyk'
for each_index_of_map3, color in zip(regions_indices_of_map3[0], colors):
display.add_overlay(image.index_img(regions_extracted_img, each_index_of_map3),
cmap=plotting.cm.alpha_cmap(color))
plotting.show()
def openAnatomy(self):
file = self.onOpen([('NIFTI files', '*.nii.gz'), ('All files', '*')])
print("anatomy file: " + file)
plotting.plot_anat(file, title='Anatomy')
plt.show()
# for the conversion we use our estimated transformation matrix and the
# MEG coordinates extracted from the raw file. `subjects` and `subjects_dir`
# are used internally, to point to the T1-weighted MRI file: `t1_mgh_fname`
mri_pos = head_to_mri(pos=pos,
subject='sample',
mri_head_t=estim_trans,
subjects_dir=op.join(data_path, 'subjects'))
# Our MRI written to BIDS, we got `anat_dir` from our `write_anat` function
t1_nii_fname = op.join(anat_dir, 'sub-01_ses-01_T1w.nii.gz')
# Plot it
fig, axs = plt.subplots(3, 1)
for point_idx, label in enumerate(('LPA', 'NAS', 'RPA')):
plot_anat(t1_nii_fname,
axes=axs[point_idx],
cut_coords=mri_pos[point_idx, :],
title=label)
plt.show()
###############################################################################
# We can deface the MRI for anonymization by passing ``deface=True``.
t1w_bids_path = write_anat(
t1w=t1_mgh_fname, # path to the MRI scan
bids_path=bids_path,
raw=raw, # the raw MEG data file connected to the MRI
trans=trans, # our transformation matrix
deface=True,
overwrite=True,
verbose=True # this will print out the sidecar file
)
anat_dir = t1w_bids_path.directory
# Import image processing tool for basic processing of functional brain image from nilearn import image # Compute voxel-wise mean functional image across time dimension. Now we have # functional image in 3D assigned in mean_haxby_img mean_haxby_img = image.mean_img(haxby_func_filename) ######################################## # Now let us see how to use `add_edges`, method useful for checking # coregistration by overlaying anatomical image as edges (red) on top of # mean functional image (background), both being of same subject. # First, we call the `plot_anat` plotting function, with a background image # as first argument, in this case the mean fMRI image. display = plotting.plot_anat(mean_haxby_img, title="add_edges") # We are now able to use add_edges method inherited in plotting object named as # display. First argument - anatomical image and by default edges will be # displayed as red 'r', to choose different colors green 'g' and blue 'b'. display.add_edges(haxby_anat_filename) ######################################## # Plotting outline of the mask (red) on top of the mean EPI image with # `add_contours`. This method is useful for region specific interpretation # of brain images # As seen before, we call the `plot_anat` function with a background image # as first argument, in this case again the mean fMRI image and argument # `cut_coords` as list for manual cut with coordinates pointing at masked # brain regions
group_means = math_img(
'img * (np.sum(img!=0, axis=-1)>=(img.shape[-1]/2.))[..., None]',
img=group_means)
# Create tsnr mean map
group_img = math_img('np.mean(img, axis=-1)', img=group_means)
group_img.to_filename('%s/group_tsnr%s.nii.gz' % (res_path, method))
# Plot figure
display = plot_anat(
group_img,
display_mode='xz',
cut_coords=[-20, 10],
colorbar=False,
cmap='magma',
threshold=800,
vmin=800,
vmax=3200,
dim=1,
annotate=False,
draw_cross=False,
black_bg=True,
)
img_tmp = nb.load(template_gm)
display.savefig('%s/group_tsnr_%s.svg' % (res_path, method))
tsnr_values.append([method, group_img.get_data()])
# Plot histograms of voxel distribution above threshold
sns.set_style('darkgrid')
plt.style.use('seaborn-colorblind')
threshold = 1
def _nilearn_display(input_file, edge_file, overlay_file, contour_file,
name, overlay_cmap, cut_coords, display_mode,
lowerbound, upperbound, figsize):
""" Create a nice dispaly with nilearn.
"""
# Monkey patch the 'find_cut_coords' class method in case of int
# 'cut_coords'
if isinstance(cut_coords, numbers.Number):
def monkeypatch(cls):
def decorator(func):
setattr(cls, func.__name__, types.MethodType(func, cls))
return func
return decorator
@monkeypatch(plotting.displays.SLICERS[display_mode])
def find_cut_coords(cls, img=None, threshold=None, cut_coords=None):
""" Instanciate the slicer and find cut coordinates.
"""
# Fig size
cls._default_figsize = list(figsize)
# Translation
direction = cls._direction
n_cuts = cut_coords
# Misc
if direction not in "xyz":
raise ValueError(
"'direction' must be one of 'x', 'y', or 'z'. Got '%s'" % (
direction))
affine = img.get_affine()
# Compute slice location in physical space
cut_coords = numpy.unique(
numpy.linspace(lowerbound, upperbound, n_cuts, dtype=int))
return plotting.find_cuts._transform_cut_coords(
cut_coords, direction, affine)
else:
plotting.displays.SLICERS[display_mode]._default_figsize = list(
figsize)
# Create the renderer
display = plotting.plot_anat(
input_file, title=name or "", cut_coords=cut_coords,
display_mode=display_mode)
if edge_file is not None:
display.add_edges(edge_file)
if overlay_file is not None:
# Create a custom discrete colormap
norm = None
if isinstance(overlay_cmap, numpy.ndarray):
cmap = colors.ListedColormap(overlay_cmap.tolist())
# cmap.set_over((1., 0., 0., 1.))
# cmap.set_under((1., 0., 0., 1.))
bounds = numpy.asarray(range(overlay_cmap.shape[0] + 1)) - 0.5
norm = BoundaryNorm(bounds, cmap.N)
# m = cm.ScalarMappable(cmap=cmap, norm=norm)
# print(m.to_rgba(41), m.to_rgba(214))
elif overlay_cmap in dir(plotting.cm):
cmap = getattr(plotting.cm, overlay_cmap)
elif overlay_cmap in dir(cm):
cmap = cm.get_cmap(overlay_cmap)
# Default
else:
cmap = plotting.cm.alpha_cmap((1, 1, 0))
display.add_overlay(overlay_file, cmap=cmap, norm=norm)
if contour_file is not None:
display.add_contours(contour_file, alpha=0.6, filled=True,
linestyles="solid")
return display
# Build the mean image because we have no anatomic data
from nilearn import image
func_filename = haxby_dataset.func[0]
mean_img = image.mean_img(func_filename)
z_slice = -24
from nilearn.image.resampling import coord_transform
affine = mean_img.get_affine()
_, _, k_slice = coord_transform(0, 0, z_slice, linalg.inv(affine))
k_slice = np.round(k_slice)
fig = plt.figure(figsize=(4, 5.4), facecolor='k')
from nilearn.plotting import plot_anat, show
display = plot_anat(mean_img,
display_mode='z',
cut_coords=[z_slice],
figure=fig)
mask_vt_filename = haxby_dataset.mask_vt[0]
mask_house_filename = haxby_dataset.mask_house[0]
mask_face_filename = haxby_dataset.mask_face[0]
display.add_contours(mask_vt_filename,
contours=1,
antialiased=False,
linewidths=4.,
levels=[0],
colors=['red'])
display.add_contours(mask_house_filename,
contours=1,
antialiased=False,
linewidths=4.,
levels=[0],
def plot_registration(anat_nii, div_id, plot_params=None,
order=('z', 'x', 'y'), cuts=None,
estimate_brightness=False, label=None, contour=None,
compress='auto'):
"""
Plots the foreground and background views
Default order is: axial, coronal, sagittal
"""
plot_params = {} if plot_params is None else plot_params
# Use default MNI cuts if none defined
if cuts is None:
raise NotImplementedError # TODO
out_files = []
if estimate_brightness:
plot_params = robust_set_limits(anat_nii.get_data().reshape(-1),
plot_params)
# FreeSurfer ribbon.mgz
ribbon = contour is not None and np.array_equal(
np.unique(contour.get_data()), [0, 2, 3, 41, 42])
if ribbon:
contour_data = contour.get_data() % 39
white = nlimage.new_img_like(contour, contour_data == 2)
pial = nlimage.new_img_like(contour, contour_data >= 2)
# Plot each cut axis
for i, mode in enumerate(list(order)):
plot_params['display_mode'] = mode
plot_params['cut_coords'] = cuts[mode]
if i == 0:
plot_params['title'] = label
else:
plot_params['title'] = None
# Generate nilearn figure
display = plot_anat(anat_nii, **plot_params)
if ribbon:
kwargs = {'levels': [0.5], 'linewidths': 0.5}
display.add_contours(white, colors='b', **kwargs)
display.add_contours(pial, colors='r', **kwargs)
elif contour is not None:
display.add_contours(contour, colors='b', levels=[0.5],
linewidths=0.5)
svg = extract_svg(display, compress=compress)
display.close()
# Find and replace the figure_1 id.
try:
xml_data = etree.fromstring(svg)
except etree.XMLSyntaxError as e:
NIWORKFLOWS_LOG.info(e)
return
find_text = etree.ETXPath("//{%s}g[@id='figure_1']" % SVGNS)
find_text(xml_data)[0].set('id', '%s-%s-%s' % (div_id, mode, uuid4()))
svg_fig = SVGFigure()
svg_fig.root = xml_data
out_files.append(svg_fig)
return out_files
def nilearn_snapshot(inputfile,
outdir,
overlayfile=None,
basename="nilearn_snap",
mask_alpha=50,
cmap=None,
mask_cmap=None,
dr=None,
mask_dr=None,
black_bg=True):
""" Create a tri-view snapshot with one overlay.
Parameters
----------
inputfile: str
path to the input image to snap.
outdir: str
directoy where to output.
overlayfile: str, default None
path to the image to overlay.
basename: str, default 'nilearn_snap'
basename without extension of the output snapshot.
mask_alpha: int, default 50
a overlay alpha value (0-100).
cmap: str, default None
a valid nilearn color map for the input file.
mask_cmap: str, default None
a valid nilearn color map for the mask file.
dr: 2-uplet, default None
athe display range (LO, HI) for the input file.
mask_dr: 2-uplet, default None
athe display range (LO, HI) for the mask file.
black_bg: bool, default True
If True, the background of the image is set to be black
Return
------
snap: str
path to the output snapshot: <outdir>/<basename>.png
"""
# Display the image
kwargs = {}
if cmap is not None:
try:
kwargs["cmap"] = getattr(plotting.cm, cmap)
except:
raise ValueError("Invalid color map '{0}'.".format(cmap))
if dr is not None:
kwargs["vmin"] = dr[0]
kwargs["vmax"] = dr[1]
display = plotting.plot_anat(inputfile,
black_bg=black_bg,
draw_cross=False,
**kwargs)
# Add the overlay
if overlayfile is not None:
kwargs = {}
if mask_cmap is not None:
try:
kwargs["cmap"] = getattr(plotting.cm, mask_cmap)
except:
raise ValueError("Invalid color map '{0}'.".format(mask_cmap))
if mask_dr is not None:
kwargs["vmin"] = mask_dr[0]
kwargs["vmax"] = mask_dr[1]
if mask_alpha is not None:
kwargs["alpha"] = mask_alpha / 100.
display.add_overlay(inputfile, **kwargs)
# Save the result
snap = os.path.join(outdir, basename + ".png")
display.savefig(snap)
display.close()
return snap
import os
import numpy as np
import nibabel as nib
import matplotlib.pyplot as plt
from nilearn.plotting import plot_anat
# Directory where your data set resides.
dataDir = '/tmp/Data/ds102'
# reading in the T1 image data array
f_sMRI = os.path.join(dataDir, 'sub-26/anat/sub-26_T1w.nii.gz')
sMRI = nib.load(f_sMRI)
X_sMRI = sMRI.get_data()
# displaying image
plot_anat(f_sMRI, display_mode='ortho', dim=-1, draw_cross=True, annotate=True)
# average intensity in the x-direction
avgX_X_sMRI = X_sMRI.mean(axis=0)
# showing the resulting image
plt.imshow(np.rot90(avgX_X_sMRI), cmap='gray')
plt.axis('off')
###############################################################################
# Apply transformations and plot
# morph img data
img_sdr_affine = mapping.transform(affine.transform(img))
# make transformed ndarray a nifti
img_vol_sdr_affine = nib.Nifti1Image(img_sdr_affine, affine=t1_s_grid2world)
# save morphed grid
nib.save(img_vol_sdr_affine, 'lcmv_inverse_fsavg.nii.gz')
# plot result
imgs = [img_vol_first, img_vol_first, nib.load('lcmv_inverse_fsavg.nii.gz')]
t1_imgs = [t1_m_img, t1_s_img, t1_s_img]
titles = [
'subject brain', 'fsaverage brian', 'fsaverage brian\nmorphed source'
]
saveas = [
'lcmv_subject.png', 'lcmv_fsaverage.png', 'lcmv_fsaverage_morphed.png'
]
for img, t1_img, title, fname in zip(imgs, t1_imgs, titles, saveas):
display = plot_anat(t1_img, display_mode='x', title=title)
display.add_overlay(img)
display.savefig(fname)
display.close()
path = opj(folder, path)
#print path, display_mode, cut_coords
data = nb.load(path).get_data().flatten()
data = sorted(data[~np.isnan(data)])
vmax = data[int(len(data) * 0.99)]
#print vmax
#title = names of plotted files
title = ' <- edges: '.join([
e.split()[0].split('/')[-1].split('.nii.gz')[0] for e in elements
])
display = plotting.plot_anat(path,
vmin=0,
vmax=vmax,
display_mode=display_mode,
cut_coords=int(cut_coords),
title=title)
#print elements
for element in elements[1:]:
#print
path = element.split()[0]
path = opj(folder, path)
#print element, 'path = ', path
#display.add_edges(path)
verb = verbs.pop(0)
#print verb
if verb == 'add_contours':
display.add_contours(path, levels=[0.5, 6500], colors='r')
display.add_contours(path, levels=[5000], colors='g')
def plot_registration(anat_nii,
div_id,
plot_params=None,
order=('z', 'x', 'y'),
cuts=None,
estimate_brightness=False,
label=None,
contour=None,
compress='auto'):
"""
Plot the foreground and background views.
Default order is: axial, coronal, sagittal
"""
from uuid import uuid4
from lxml import etree
from nilearn.plotting import plot_anat
from svgutils.transform import SVGFigure
from niworkflows.viz.utils import robust_set_limits, extract_svg, SVGNS
plot_params = plot_params or {}
# Use default MNI cuts if none defined
if cuts is None:
raise NotImplementedError # TODO
out_files = []
if estimate_brightness:
plot_params = robust_set_limits(anat_nii.get_data().reshape(-1),
plot_params)
# Plot each cut axis
for i, mode in enumerate(list(order)):
plot_params['display_mode'] = mode
plot_params['cut_coords'] = cuts[mode]
if i == 0:
plot_params['title'] = label
else:
plot_params['title'] = None
# Generate nilearn figure
display = plot_anat(anat_nii, **plot_params)
if contour is not None:
display.add_contours(contour,
colors='g',
levels=[0.5],
linewidths=0.5)
svg = extract_svg(display, compress=compress)
display.close()
# Find and replace the figure_1 id.
xml_data = etree.fromstring(svg)
find_text = etree.ETXPath("//{%s}g[@id='figure_1']" % SVGNS)
find_text(xml_data)[0].set('id', '%s-%s-%s' % (div_id, mode, uuid4()))
svg_fig = SVGFigure()
svg_fig.root = xml_data
out_files.append(svg_fig)
return out_files
# Affine registration
# -------------------
from sammba.registration import anats_to_common
affine_register = anats_to_common(retest.anat, write_dir, caching=True)
##############################################################################
# We set caching to True, so that this step computations are not restarted.
# The paths to the registered images can be accessed easilly
registered_anats = affine_register.registered
print(registered_anats)
##############################################################################
# Visalize results
# ----------------
# We plot the edges of one individual anat on top of the average image
from nilearn import plotting, image
average_img = image.mean_img(registered_anats)
display = plotting.plot_anat(average_img, dim=-1.8, title='affine register')
display.add_edges(registered_anats[0])
plotting.show()
##############################################################################
# Visualize pipeline steps
# -------------------------
from sammba.registration import create_pipeline_graph
graph_file = os.path.join(write_dir, 'affine_registration_graph')
create_pipeline_graph('anats_to_common_affine', graph_file)
localizer = datasets.fetch_localizer_contrasts(["left vs right button press"],
n_subjects=4,
get_anats=True)
###############################################################################
# demo the different plotting function
# Plotting statistical maps
plotting.plot_stat_map(localizer.cmaps[3], bg_img=localizer.anats[3],
threshold=3, title="plot_stat_map",
cut_coords=(36, -27, 66))
# Plotting anatomical maps
plotting.plot_anat(haxby.anat[0], title="plot_anat")
# Plotting ROIs (here the mask)
plotting.plot_roi(haxby.mask_vt[0], bg_img=haxby.anat[0], title="plot_roi")
# Plotting EPI haxby
mean_haxby_img = image.mean_img(haxby.func[0])
plotting.plot_epi(mean_haxby_img, title="plot_epi")
###############################################################################
# demo the different display_mode
plotting.plot_stat_map(localizer.cmaps[3], display_mode='ortho',
cut_coords=(36, -27, 60),
title="display_mode='ortho', cut_coords=(36, -27, 60)")
# # .. note:: In this tutorial, we load the data using a data downloading # function. To input your own data, you will need to provide # a list of paths to your own files in the ``subject_data`` variable. # These should abide to the Brain Imaging Data Structure (BIDS) # organization. from nistats.datasets import fetch_spm_auditory subject_data = fetch_spm_auditory() print(subject_data.func) # print the list of names of functional images ############################################################################### # We can display the first functional image and the subject's anatomy: from nilearn.plotting import plot_stat_map, plot_anat, plot_img, show plot_img(subject_data.func[0]) plot_anat(subject_data.anat) ############################################################################### # Next, we concatenate all the 3D EPI image into a single 4D image, # then we average them in order to create a background # image that will be used to display the activations: from nilearn.image import concat_imgs, mean_img fmri_img = concat_imgs(subject_data.func) mean_img = mean_img(fmri_img) ############################################################################### # Specifying the experimental paradigm # ------------------------------------ # # We must now provide a description of the experiment, that is, define the
# Loop through all the slices in this dimension
for i in np.arange(img_reslice.shape[dim_lookup_dict[axis]], dtype='float'):
# Test to see if there is anything worth showing in the image
# If the anat image (img) is empty then don't make a picture
if slice_dict[axis](i, img).mean() == 0.0:
continue
# Get the co-ordinate you want
coord = coord_transform_dict[axis](i, img_reslice)
# Make the image
slicer = plotting.plot_anat(img_reslice,
threshold=None,
cmap=cmap,
display_mode=axis,
black_bg=black_bg,
annotate=annotate,
draw_cross=draw_cross,
cut_coords=(coord,))
# Add the overlay if given
if not overlay_file is None:
slicer.add_overlay(overlay_img_reslice, cmap=overlay_cmap)
# Save the png file
output_file = os.path.join(pngs_dir,
'{}_{:03.0f}{}.png'.format(label_lookup_dict[axis],
i,
overlay_name))
slicer.savefig(output_file, dpi=dpi)
"""
Docstring.
"""
from nidata.multimodal import MyConnectome2015Dataset
# runs the member function 'fetch' from the class 'Laumann2015Dataset'
dataset = MyConnectome2015Dataset().fetch(data_types=['functional'],
session_ids=range(2, 13))
print(dataset)
from nilearn.plotting import plot_anat
from nilearn.image import index_img
from matplotlib import pyplot as plt
plot_anat(index_img(dataset['functional'][0], 0))
plt.show()
subject = 'sample'
mni_pos = dip.to_mni(subject=subject, trans=fname_trans,
subjects_dir=subjects_dir)
mri_pos = dip.to_mri(subject=subject, trans=fname_trans,
subjects_dir=subjects_dir)
# Find an anatomical label for the best fitted dipole
best_dip_idx = dip.gof.argmax()
label = dip.to_volume_labels(fname_trans, subject=subject,
subjects_dir=subjects_dir,
aseg='aparc.a2009s+aseg')[best_dip_idx]
# Draw dipole position on MRI scan and add anatomical label from parcellation
t1_fname = op.join(subjects_dir, subject, 'mri', 'T1.mgz')
fig_T1 = plot_anat(t1_fname, cut_coords=mri_pos[0],
title=f'Dipole location: {label}')
try:
template = load_mni152_template(resolution=1)
except TypeError: # in nilearn < 0.8.1 this did not exist
template = load_mni152_template()
fig_template = plot_anat(template, cut_coords=mni_pos[0],
title='Dipole loc. (MNI Space)')
# %%
# Calculate and visualise magnetic field predicted by dipole with maximum GOF
# and compare to the measured data, highlighting the ipsilateral (right) source
fwd, stc = make_forward_dipole(dip, fname_bem, evoked.info, fname_trans)
pred_evoked = simulate_evoked(fwd, stc, evoked.info, cov=None, nave=np.inf)
# find time point with highest GOF to plot
# Build the mean image because we have no anatomic data
from nilearn import image
func_filename = haxby_dataset.func[0]
mean_img = image.mean_img(func_filename)
z_slice = -24
from nilearn.image.resampling import coord_transform
affine = mean_img.get_affine()
_, _, k_slice = coord_transform(0, 0, z_slice,
linalg.inv(affine))
k_slice = round(k_slice)
fig = plt.figure(figsize=(4, 5.4), facecolor='k')
from nilearn.plotting import plot_anat
display = plot_anat(mean_img, display_mode='z', cut_coords=[z_slice],
figure=fig)
mask_vt_filename = haxby_dataset.mask_vt[0]
mask_house_filename = haxby_dataset.mask_house[0]
mask_face_filename = haxby_dataset.mask_face[0]
display.add_contours(mask_vt_filename, contours=1, antialiased=False,
linewidths=4., levels=[0], colors=['red'])
display.add_contours(mask_house_filename, contours=1, antialiased=False,
linewidths=4., levels=[0], colors=['blue'])
display.add_contours(mask_face_filename, contours=1, antialiased=False,
linewidths=4., levels=[0], colors=['limegreen'])
# We generate a legend using the trick described on
# http://matplotlib.sourceforge.net/users/legend_guide.httpml#using-proxy-artist
from matplotlib.patches import Rectangle
p_v = Rectangle((0, 0), 1, 1, fc="red")
p_h = Rectangle((0, 0), 1, 1, fc="blue")
# Compute voxel-wise mean functional image across time dimension. Now we have # functional image in 3D assigned in mean_haxby_img mean_haxby_img = image.mean_img(haxby_func_filename) ######################################## # Showing how to use `add_edges` # ------------------------------ # Now let us see how to use `add_edges`, method useful for checking # coregistration by overlaying anatomical image as edges (red) on top of # mean functional image (background), both being of same subject. # First, we call the `plot_anat` plotting function, with a background image # as first argument, in this case the mean fMRI image. display = plotting.plot_anat(mean_haxby_img, title="add_edges") # We are now able to use add_edges method inherited in plotting object named as # display. First argument - anatomical image and by default edges will be # displayed as red 'r', to choose different colors green 'g' and blue 'b'. display.add_edges(haxby_anat_filename) ######################################## # How to use `add_contours` # ------------------------- # Plotting outline of the mask (red) on top of the mean EPI image with # `add_contours`. This method is useful for region specific interpretation # of brain images # As seen before, we call the `plot_anat` function with a background image # as first argument, in this case again the mean fMRI image and argument
# is a 'nibabel' object. It has data, and an affine
anat_data = smooth_anat_img.get_data()
print('anat_data has shape: %s' % str(anat_data.shape))
anat_affine = smooth_anat_img.get_affine()
print('anat_affineaffine:\n%s' % anat_affine)
# Finally, it can be passed to nilearn function
smooth_anat_img = image.smooth_img(smooth_anat_img, 3)
#########################################################################
# Visualization
from nilearn import plotting
cut_coords = (0, 0, 0)
# Like all functions in nilearn, plotting can be given filenames
plotting.plot_anat(anat_filename, cut_coords=cut_coords,
title='Anatomy image')
# Or nibabel objects
plotting.plot_anat(smooth_anat_img,
cut_coords=cut_coords,
title='Smoothed anatomy image')
#########################################################################
# Saving image to file
smooth_anat_img.to_filename('smooth_anat_img.nii.gz')
#########################################################################
# Finally, showing plots when used inside a terminal
plotting.show()
def plot_image(input_file, edge_file=None, overlay_file=None, contour_file=None,
snap_file=None, name=None, overlay_cmap=None,
cut_coords=None):
""" Plot image with edge/overlay/contour on top (useful for checking
registration).
Parameters
----------
input_file: str (mandatory)
An image to display.
outline_file: str (optional, default None)
The target image to extract the edges from.
snap_file: str (optional, default None)
The destination file: if not specified will be the 'input_file'
name with a 'png' extension.
name: str (optional, default None)
The name of the plot.
overlay_cmap: str (optional, default None)
The color map to use: 'cold_hot' or 'blue_red' or None,
or a N*4 array with values in 0-1 (r, g, b, a).
cut_coords: 3-uplet (optional, default None)
The MNI coordinates of the point where the cut is performed.
If None is given, the cuts is calculated automaticaly.
Returns
-------
snap_file: str
A pdf snap of the image.
"""
# Check the input images exist on the file system
for in_file in [input_file, edge_file, overlay_file, contour_file]:
if in_file is not None and not os.path.isfile(in_file):
raise ValueError("'{0}' is not a valid filename.".format(in_file))
# Check that the snap_file has been specified
if snap_file is None:
snap_file = input_file.split(".")[0] + ".png"
# Create the plot
display = plotting.plot_anat(input_file, title=name or "",
cut_coords=cut_coords)
if edge_file is not None:
display.add_edges(edge_file)
if overlay_file is not None:
# Create a custom discrete colormap
if isinstance(overlay_cmap, numpy.ndarray):
cmap = colors.LinearSegmentedColormap.from_list(
"my_colormap", overlay_cmap)
#cmap, _ = colors.from_levels_and_colors(
# range(overlay_cmap.shape[0] + 1), overlay_cmap)
# This is probably a matplotlib colormap
elif overlay_cmap in dir(plotting.cm):
cmap = getattr(plotting.cm, overlay_cmap)
# Default
else:
cmap = plotting.cm.alpha_cmap((1, 1, 0))
display.add_overlay(overlay_file, cmap=cmap)
if contour_file is not None:
display.add_contours(contour_file, alpha=0.6, filled=True,
linestyles="solid")
display.savefig(snap_file)
display.close()
return snap_file
>>> def show_slices(slices):
... """ Function to display row of image slices """
... fig, axes = plt.subplots(1, len(slices))
... for i, slice in enumerate(slices):
... axes[i].imshow(slice.T, cmap="gray", origin="lower")
>>>
#遍历序列和下标 enumerate
for i,value in enumerate(some_array)
#显示图像
slice0 = img_data[2,:,:]
slice1 = img_data[:,2,:]
slice2 = img_data[:,:,3]
([slice0,slice2,slice2])
#或者使用nilearn提供的方法
from nilearn import plotting
cut_coords = [2,2,2]
plotting.plot_anat(img,cut_coords=cut_coords,title='标题')
#直接将某个矩阵保存成图像
from scipy.misc import imsave
imsave("aa1.png",slice1)
#在nilearn中，一个3-D图像的list可以当作一个4-D图像
# In MRI coordinates and in MNI coordinates (template brain)
trans = mne.read_trans(fname_trans)
subject = 'sample'
mni_pos = mne.head_to_mni(dip.pos,
mri_head_t=trans,
subject=subject,
subjects_dir=subjects_dir)
mri_pos = mne.head_to_mri(dip.pos,
mri_head_t=trans,
subject=subject,
subjects_dir=subjects_dir)
t1_fname = op.join(subjects_dir, subject, 'mri', 'T1.mgz')
fig = plot_anat(t1_fname, cut_coords=mri_pos[0], title='Dipole loc.')
template = load_mni152_template()
fig = plot_anat(template,
cut_coords=mni_pos[0],
title='Dipole loc. (MNI Space)')
###############################################################################
# Calculate and visualise magnetic field predicted by dipole with maximum GOF
# and compare to the measured data, highlighting the ipsilateral (right) source
fwd, stc = make_forward_dipole(dip, fname_bem, evoked.info, fname_trans)
pred_evoked = simulate_evoked(fwd, stc, evoked.info, cov=None, nave=np.inf)
# find time point with highest GOF to plot
best_idx = np.argmax(dip.gof)
best_time = dip.times[best_idx]
# We will dive deeper into affine transformations in the preprocessing tutorial.
# ## Plotting Data with Nilearn
# There are many useful tools from the [nilearn](https://nilearn.github.io/index.html) library to help manipulate and visualize neuroimaging data. See their [documentation](https://nilearn.github.io/plotting/index.html#different-plotting-functions) for an example.
#
# In this section, we will explore a few of their different plotting functions, which can work directly with nibabel instances.
# In[32]:
get_ipython().run_line_magic('matplotlib', 'inline')
from nilearn.plotting import view_img, plot_glass_brain, plot_anat, plot_epi
# In[33]:
plot_anat(data)
# Nilearn plotting functions are very flexible and allow us to easily customize our plots
# In[34]:
plot_anat(data, draw_cross=False, display_mode='z')
# try to get more information how to use the function with `?` and try to add different commands to change the plot.
#
# nilearn also has a neat interactive viewer called `view_img` for examining images directly in the notebook.
# In[35]:
view_img(data)
colorbar=True,
annotate=False,
draw_cross=False)
############################################################################
# .. image:: ../_static/tissue_classification2.png
#############################################################################
############################################################################
# MGDM also creates an image which represents for each voxel the distance to
# its nearest border. It is useful to assess where partial volume effects
# may occur
if not skip_plots:
plotting.plot_anat(mgdm_results['distance'],
vmin=0,
vmax=20,
annotate=False,
draw_cross=False,
colorbar=True)
############################################################################
# .. image:: ../_static/tissue_classification3.png
#############################################################################
#############################################################################
# If the example is not run in a jupyter notebook, render the plots:
if not skip_plots:
plotting.show()
#############################################################################
# References
# -----------
functional.
"""
# Create a memory context
from nipype.caching import Memory
mem = Memory('/tmp')
# Compute mean functional
from procasl import preprocessing
average = mem.cache(preprocessing.Average)
out_average = average(in_file='/tmp/func.nii')
mean_func = out_average.outputs.mean_file
# Coregister anat to mean functional
from nipype.interfaces import spm
coregister = mem.cache(spm.Coregister)
out_coregister = coregister(
target=mean_func,
source='/tmp/anat.nii',
write_interp=3)
# Check coregistration
import matplotlib.pylab as plt
from nilearn import plotting
figure = plt.figure(figsize=(5, 4))
display = plotting.plot_anat(mean_func, figure=figure, display_mode='z',
cut_coords=(-7, 32),
title='anat edges on mean functional')
display.add_edges(out_coregister.outputs.coregistered_source)
figure.suptitle('Impact of tagging correction')
plt.show()
# First, we plot a network of index=4 without region extraction (left plot)
from nilearn import image
img = image.index_img(components_img, 1)
coords = plotting.find_xyz_cut_coords(img)
display = plotting.plot_stat_map(img,
cut_coords=coords,
colorbar=False,
title='Showing one specific network')
################################################################################
# Now, we plot (right side) same network after region extraction to show that
# connected regions are nicely seperated.
# Each brain extracted region is identified as separate color.
# For this, we take the indices of the all regions extracted related to original
# network given as 4.
regions_indices_of_map3 = np.where(np.array(regions_index) == 1)
display = plotting.plot_anat(cut_coords=coords,
title='Regions from this network')
# Add as an overlay all the regions of index 4
colors = 'rgbcmyk'
for each_index_of_map3, color in zip(regions_indices_of_map3[0], colors):
display.add_overlay(image.index_img(regions_extracted_img,
each_index_of_map3),
cmap=plotting.cm.alpha_cmap(color))
plotting.show()
