def test_plot_functions():
# This is only a smoke test
mp.use('svg', warn=False)
import pylab as pl
pl.switch_backend('svg')
data = np.zeros((20, 20, 20))
data[3:-3, 3:-3, 3:-3] = 1
img = nibabel.Nifti1Image(data, mni_affine)
ortho_slicer = plot_anat(img, dim=True)
# Test saving with empty plot
z_slicer = plot_anat(anat_img=False, display_mode='z')
ortho_slicer.savefig(tempfile.TemporaryFile())
z_slicer = plot_anat(display_mode='z')
ortho_slicer.savefig(tempfile.TemporaryFile())
z_slicer.add_edges(img, color='c')
for func in [
plot_anat, plot_img, plot_stat_map, plot_epi, plot_glass_brain
]:
ortho_slicer = func(img, cut_coords=(80, -120, -60))
# Saving forces a draw, and thus smoke-tests the axes locators
ortho_slicer.savefig(tempfile.TemporaryFile())
ortho_slicer.add_edges(img, color='c')
# Smoke test coordinate finder, with and without mask
masked_img = nibabel.Nifti1Image(np.ma.masked_equal(data, 0),
mni_affine)
func(masked_img, display_mode='x')
func(img, display_mode='y')
out = func(img, output_file=tempfile.TemporaryFile(suffix='.png'))
assert_true(out is None)
pl.close('all')
def reason_pylab():
from .utils import deliver_image
def _canvas_deliver(canvas):
tf = tempfile.TemporaryFile()
canvas.print_png(tf)
tf.seek(0)
img_data = base64.b64encode(tf.read())
tf.close()
deliver_image(img_data)
def reason_draw_if_interactive():
if matplotlib.is_interactive():
figManager = Gcf.get_active()
if figManager is not None:
_canvas_deliver(figManager.canvas)
def reason_show(mainloop = True):
# We ignore mainloop here
for manager in Gcf.get_all_fig_managers():
_canvas_deliver(manager.canvas)
# Matplotlib has very nice backend overriding.
# We should really use that. This is just a hack.
import matplotlib
matplotlib.use("agg") # Hotfix for when we import pylab below
new_agg = imp.new_module("reason_agg")
import matplotlib.backends.backend_agg as bagg
new_agg.__dict__.update(bagg.__dict__)
new_agg.__dict__.update(
{'show': reason_show,
'draw_if_interactive': reason_draw_if_interactive})
sys.modules["reason_agg"] = new_agg
bagg.draw_if_interactive = reason_draw_if_interactive
from matplotlib._pylab_helpers import Gcf
matplotlib.rcParams["backend"] = "module://reason_agg"
import pylab
pylab.switch_backend("module://reason_agg")
def test_plot_anat():
# This is only a smoke test
mp.use('svg', warn=False)
import pylab as pl
pl.switch_backend('svg')
data = np.zeros((20, 20, 20))
data[3:-3, 3:-3, 3:-3] = 1
img = nibabel.Nifti1Image(data, mni_affine)
ortho_slicer = plot_anat(img, dim=True)
ortho_slicer = plot_anat(img, cut_coords=(80, -120, -60))
# Saving forces a draw, and thus smoke-tests the axes locators
pl.savefig(tempfile.TemporaryFile())
ortho_slicer.edge_map(img, color='c')
# Test saving with empty plot
z_slicer = plot_anat(anat_img=False, slicer='z')
pl.savefig(tempfile.TemporaryFile())
z_slicer = plot_anat(slicer='z')
pl.savefig(tempfile.TemporaryFile())
z_slicer.edge_map(img, color='c')
# Smoke test coordinate finder, with and without mask
masked_img = nibabel.Nifti1Image(np.ma.masked_equal(data, 0),
mni_affine)
plot_img(masked_img, slicer='x')
plot_img(img, slicer='y')
def test_demo_plot_map():
# This is only a smoke test
mp.use("svg", warn=False)
import pylab as pl
pl.switch_backend("svg")
demo_plot_map()
def test_plot_anat():
# This is only a smoke test
mp.use('svg', warn=False)
import pylab as pl
pl.switch_backend('svg')
data = np.zeros((20, 20, 20))
data[3:-3, 3:-3, 3:-3] = 1
ortho_slicer = plot_anat(data, mni_sform, dim=True)
ortho_slicer = plot_anat(data, mni_sform, cut_coords=(80, -120, -60))
# Saving forces a draw, and thus smoke-tests the axes locators
pl.savefig(tempfile.TemporaryFile())
pl.close()
ortho_slicer.edge_map(data, mni_sform, color='c')
# Test saving with empty plot
z_slicer = plot_anat(anat=False, slicer='z')
pl.savefig(tempfile.TemporaryFile())
pl.close()
z_slicer = plot_anat(slicer='z')
pl.savefig(tempfile.TemporaryFile())
pl.close()
z_slicer.edge_map(data, mni_sform, color='c')
# Smoke test coordinate finder, with and without mask
plot_map(np.ma.masked_equal(data, 0), mni_sform, slicer='x')
plot_map(data, mni_sform, slicer='y')
def test_replace_inside():
# This is only a smoke test
mp.use("svg", warn=False)
import pylab as pl
pl.switch_backend("svg")
replace_inside(pl.cm.jet, pl.cm.hsv, 0.2, 0.8)
def main(config, display = False):
"""
Main part of the script
"""
# uncomment the following line if you have no display access
if display == False:
plt.switch_backend('agg')
else:
None
assert os.path.isfile(config), "Cannot find the config file!"
# tries to create a folder in the same dir as the .config
# if it fails, creates in the current directory
outputFolder = create_output_folder(config)
recovClsDict = get_recov_cls_dict(config)
if checkDens2Kappa(config) == False:
inputClsDict = get_input_cls_dict(config, recovClsDict)
else:
inputClsDict = Dens2KappaUsed(config, recovClsDict)
plot_recov_vs_input(recovClsDict, inputClsDict, outputFolder, display)
def stdan(path, tday):
#f = open('/home/larry/l1304/workspace/finopt/data/mds_files/std/std20151005.txt')
pylab.switch_backend(
'agg'
) # switch to agg backend that support writing in non-main threads
f = open(join(path, '%s.txt' % tday))
l = f.readlines()
m = map(lambda x: (x.split(',')), l)
q = filter(
lambda y: y[0] in ['HSI-20151029-0--FUT-HKD-102'] and y[1] >
'2015-10-06 08:55:34', m)
n = filter(lambda y: float(y[3]) > 21500.0, q)
p = map(lambda y: float(y[2]) if float(y[2]) < 15.0 else 0.0, n)
yy = map(lambda y: float(y[3]), n)
xx = map(lambda x: datetime.strptime(x[1], '%Y-%m-%d %H:%M:%S.%f'), n)
print len(p), len(yy)
pylab.figure(figsize=(20, 10))
pylab.figure(1)
pylab.subplot(211)
pylab.plot(xx, yy, 'g-')
pylab.subplot(212)
pylab.plot(xx, p, 'ro')
#pylab.axis(['20150930', '20151001', 20000, 22000])
pylab.show()
pylab.savefig('%s/std-%s.png' % (path, tday))
pylab.close()
def test_plot_functions():
# This is only a smoke test
mp.use('svg', warn=False)
import pylab as pl
pl.switch_backend('svg')
data = np.zeros((20, 20, 20))
data[3:-3, 3:-3, 3:-3] = 1
img = nibabel.Nifti1Image(data, mni_affine)
ortho_slicer = plot_anat(img, dim=True)
# Test saving with empty plot
z_slicer = plot_anat(anat_img=False, display_mode='z')
ortho_slicer.savefig(tempfile.TemporaryFile())
z_slicer = plot_anat(display_mode='z')
ortho_slicer.savefig(tempfile.TemporaryFile())
z_slicer.add_edges(img, color='c')
for func in [plot_anat, plot_img, plot_stat_map,
plot_epi, plot_glass_brain]:
ortho_slicer = func(img, cut_coords=(80, -120, -60))
# Saving forces a draw, and thus smoke-tests the axes locators
ortho_slicer.savefig(tempfile.TemporaryFile())
ortho_slicer.add_edges(img, color='c')
# Smoke test coordinate finder, with and without mask
masked_img = nibabel.Nifti1Image(np.ma.masked_equal(data, 0),
mni_affine)
func(masked_img, display_mode='x')
func(img, display_mode='y')
out = func(img, output_file=tempfile.TemporaryFile(suffix='.png'))
assert_true(out is None)
pl.close('all')
def test_plots(do_plot=False):
''' Basic plots '''
if not do_plot:
pl.switch_backend('agg') # Plot but don't show
pop = sp.Pop(n=5000) # default parameters, 5k people
fig1 = pop.plot_people() # equivalent to cv.Sim.people.plot()
fig2 = pop.plot_contacts() # equivalent to sp.plot_contact_matrix(popdict)
return [fig1, fig2]
def test_demo_plot_map():
# This is only a smoke test
mp.use('svg', warn=False)
import pylab as pl
pl.switch_backend('svg')
demo_plot_map()
# Test the black background code path
demo_plot_map(black_bg=True)
def test_demo_plot_map():
# This is only a smoke test
mp.use('svg', warn=False)
import pylab as pl
pl.switch_backend('svg')
demo_plot_map()
# Test the black background code path
demo_plot_map(black_bg=True)
def test_replace_inside():
# This is only a smoke test
mp.use('svg', warn=False)
import pylab as pl
pl.switch_backend('svg')
replace_inside(pl.cm.jet, pl.cm.hsv, .2, .8)
# We also test with gnuplot, which is defined using function
replace_inside(pl.cm.gnuplot, pl.cm.gnuplot2, .2, .8)
def test_plot_functions():
# This is only a smoke test
mp.use('template', warn=False)
import pylab as pl
pl.switch_backend('template')
data_positive = np.zeros((7, 7, 3))
data_positive[1:-1, 2:-1, 1:] = 1
data_negative = -data_positive
rng = np.random.RandomState(42)
data_heterogeneous = data_positive * rng.randn(*data_positive.shape)
img_positive = nibabel.Nifti1Image(data_positive, mni_affine)
img_negative = nibabel.Nifti1Image(data_negative, mni_affine)
img_heterogeneous = nibabel.Nifti1Image(data_heterogeneous, mni_affine)
# Test saving with empty plot
ax = pl.subplot(111, rasterized=True)
z_slicer = plot_anat(anat_img=False, display_mode='z', axes=ax)
z_slicer = plot_anat(display_mode='z', axes=ax)
z_slicer.add_edges(img_positive, color='c')
z_slicer.savefig(tempfile.TemporaryFile())
pl.close()
for img in [img_positive, img_negative, img_heterogeneous]:
ortho_slicer = plot_anat(img, dim=True)
ortho_slicer.savefig(tempfile.TemporaryFile())
pl.close()
for func in [
plot_anat, plot_img, plot_stat_map, plot_epi, plot_glass_brain,
partial(plot_stat_map, symmetric_cbar=True),
partial(plot_stat_map, symmetric_cbar=False),
partial(plot_stat_map, symmetric_cbar=False, vmax=10),
partial(plot_stat_map, symmetric_cbar=True, vmax=10),
partial(plot_stat_map, colorbar=False)
]:
ax = pl.subplot(111, rasterized=True)
ortho_slicer = func(img, cut_coords=(80, -120, -60), axes=ax)
# Saving forces a draw, and thus smoke-tests the axes locators
ortho_slicer.savefig(tempfile.TemporaryFile())
ortho_slicer.add_edges(img, color='c')
pl.close()
# Smoke test coordinate finder, with and without mask
masked_img = nibabel.Nifti1Image(
np.ma.masked_equal(img.get_data(), 0), mni_affine)
ax = pl.subplot(111, rasterized=True)
func(masked_img, display_mode='x', axes=ax)
pl.close()
ax = pl.subplot(111, rasterized=True)
func(img, display_mode='y', axes=ax)
pl.close()
ax = pl.subplot(111, rasterized=True)
out = func(img,
output_file=tempfile.TemporaryFile(suffix='.png'),
axes=ax)
assert_true(out is None)
pl.close()
def test_plot_img_with_resampling():
import pylab as pl
pl.switch_backend('template')
data = MNI152TEMPLATE.get_data()[:5, :5, :5]
affine = np.array([[1., -1., 0., 0.], [1., 1., 0., 0.], [0., 0., 1., 0.],
[0., 0., 0., 1.]])
img = nibabel.Nifti1Image(data, affine)
display = plot_img(img)
display.add_overlay(img)
def test_plot_map_with_auto_cut_coords():
import pylab as pl
pl.switch_backend('svg')
data = np.zeros((20, 20, 20))
data[3:-3, 3:-3, 3:-3] = 1
for slicer in 'xyz':
plot_map(data, np.eye(4), cut_coords=None, slicer=slicer,
black_bg=True)
def test_plot_anat():
# This is only a smoke test
mp.use('svg', warn=False)
import pylab as pl
pl.switch_backend('svg')
ortho_slicer = plot_anat()
data = np.zeros((100, 100, 100))
data[3:-3, 3:-3, 3:-3] = 1
ortho_slicer.edge_map(data, mni_sform, color='c')
def test_demo_ortho_slicer():
# This is only a smoke test
# conditioned on presence of MNI templated
if not find_mni_template():
raise nose.SkipTest("MNI Template is absent for the smoke test")
mp.use('svg')
import pylab as pl
pl.switch_backend('svg')
demo_ortho_slicer()
def test_demo_ortho_slicer():
# This is only a smoke test
# conditioned on presence of MNI templated
if not find_mni_template():
raise nose.SkipTest("MNI Template is absent for the smoke test")
mp.use('svg', warn=False)
import pylab as pl
pl.switch_backend('svg')
demo_ortho_slicer()
def test_plot_img_with_auto_cut_coords():
import pylab as pl
pl.switch_backend('svg')
data = np.zeros((20, 20, 20))
data[3:-3, 3:-3, 3:-3] = 1
img = nibabel.Nifti1Image(data, np.eye(4))
for slicer in 'xyz':
plot_img(img, cut_coords=None, slicer=slicer, black_bg=True)
def test_plot_img_with_auto_cut_coords():
import pylab as pl
pl.switch_backend('svg')
data = np.zeros((20, 20, 20))
data[3:-3, 3:-3, 3:-3] = 1
img = nibabel.Nifti1Image(data, np.eye(4))
for slicer in 'xyz':
plot_img(img, cut_coords=None, slicer=slicer, black_bg=True)
def test_demo_ortho_slicer():
# This is only a smoke test
# conditioned on presence of MNI templated
mp.use('svg', warn=False)
import pylab as pl
pl.switch_backend('svg')
pl.clf()
oslicer = OrthoSlicer(cut_coords=(0, 0, 0))
img = load_mni152_template()
oslicer.add_overlay(img, cmap=pl.cm.gray)
def set_matplotlib_global(key, value):
''' Set a global option for Matplotlib -- not for users '''
import pylab as pl
if value: # Don't try to reset any of these to a None value
if key == 'font_size': pl.rc('font', size=value)
elif key == 'font_family': pl.rc('font', family=value)
elif key == 'dpi': pl.rc('figure', dpi=value)
elif key == 'backend': pl.switch_backend(value)
else: raise sc.KeyNotFoundError(f'Key {key} not found')
return
def test_replace_inside():
# This is only a smoke test
mp.use('svg', warn=False)
import pylab as pl
pl.switch_backend('svg')
replace_inside(pl.cm.jet, pl.cm.hsv, .2, .8)
# We also test with gnuplot, which is defined using function
if hasattr(pl.cm, 'gnuplot'):
# gnuplot is only in recent version of MPL
replace_inside(pl.cm.gnuplot, pl.cm.gnuplot2, .2, .8)
def test_demo_ortho_slicer():
# This is only a smoke test
mp.use('svg', warn=False)
import pylab as pl
pl.switch_backend('svg')
pl.clf()
oslicer = OrthoSlicer(cut_coords=(0, 0, 0))
img = load_mni152_template()
oslicer.add_overlay(img, cmap=pl.cm.gray)
oslicer.close()
def test_demo_ortho_slicer():
# This is only a smoke test
mp.use('template', warn=False)
import pylab as pl
pl.switch_backend('template')
pl.clf()
oslicer = OrthoSlicer(cut_coords=(0, 0, 0))
img = load_mni152_template()
oslicer.add_overlay(img, cmap=pl.cm.gray)
oslicer.close()
def test_demo_plot_roi():
# This is only a smoke test
mp.use('svg', warn=False)
import pylab as pl
pl.switch_backend('svg')
demo_plot_roi()
# Test the black background code path
demo_plot_roi(black_bg=True)
out = demo_plot_roi(output_file=tempfile.TemporaryFile(suffix='.png'))
assert_true(out is None)
def test_demo_ortho_projector():
# This is only a smoke test
mp.use('svg', warn=False)
import pylab as pl
pl.switch_backend('svg')
pl.clf()
img = load_mni152_template()
oprojector = OrthoProjector.init_with_figure(img=img)
oprojector.add_overlay(img, cmap=pl.cm.gray)
oprojector.savefig(tempfile.TemporaryFile())
oprojector.close()
def test_plot_map_empty():
# Test that things don't crash when we give a map with nothing above
# threshold
# This is only a smoke test
mp.use('svg', warn=False)
import pylab as pl
pl.switch_backend('svg')
data = np.zeros((20, 20, 20))
plot_anat(data, mni_sform)
plot_map(data, mni_sform, slicer='y', threshold=1)
pl.close('all')
def test_demo_plot_roi():
# This is only a smoke test
mp.use('svg', warn=False)
import pylab as pl
pl.switch_backend('svg')
demo_plot_roi()
# Test the black background code path
demo_plot_roi(black_bg=True)
out = demo_plot_roi(output_file=tempfile.TemporaryFile(suffix='.png'))
assert_true(out is None)
def test_plot_map_empty():
# Test that things don't crash when we give a map with nothing above
# threshold
# This is only a smoke test
mp.use('svg', warn=False)
import pylab as pl
pl.switch_backend('svg')
data = np.zeros((20, 20, 20))
plot_anat(data, mni_sform)
plot_map(data, mni_sform, slicer='y', threshold=1)
pl.close('all')
def test_demo_ortho_projector():
# This is only a smoke test
mp.use('template', warn=False)
import pylab as pl
pl.switch_backend('template')
pl.clf()
img = load_mni152_template()
oprojector = OrthoProjector.init_with_figure(img=img)
oprojector.add_overlay(img, cmap=pl.cm.gray)
oprojector.savefig(tempfile.TemporaryFile())
oprojector.close()
def test_plot_map_with_auto_cut_coords():
import pylab as pl
pl.switch_backend('svg')
data = np.zeros((20, 20, 20))
data[3:-3, 3:-3, 3:-3] = 1
for slicer in 'xyz':
plot_map(data,
np.eye(4),
cut_coords=None,
slicer=slicer,
black_bg=True)
def test_plot_img_empty():
# Test that things don't crash when we give a map with nothing above
# threshold
# This is only a smoke test
mp.use('svg', warn=False)
import pylab as pl
pl.switch_backend('svg')
data = np.zeros((20, 20, 20))
img = nibabel.Nifti1Image(data, mni_affine)
plot_anat(img)
plot_img(img, slicer='y', threshold=1)
pl.close('all')
def test_stacked_slicer():
# Test stacked slicers, like the XSlicer
mp.use('svg', warn=False)
import pylab as pl
pl.switch_backend('svg')
pl.clf()
img = load_mni152_template()
slicer = XSlicer.init_with_figure(img=img, cut_coords=3)
slicer.add_overlay(img, cmap=pl.cm.gray)
# Forcing a layout here, to test the locator code
slicer.savefig(tempfile.TemporaryFile())
slicer.close()
def test_plot_img_with_auto_cut_coords():
import pylab as pl
pl.switch_backend('template')
data = np.zeros((20, 20, 20))
data[3:-3, 3:-3, 3:-3] = 1
img = nibabel.Nifti1Image(data, np.eye(4))
for display_mode in 'xyz':
plot_img(img,
cut_coords=None,
display_mode=display_mode,
black_bg=True)
def test_stacked_slicer():
# Test stacked slicers, like the XSlicer
mp.use('template', warn=False)
import pylab as pl
pl.switch_backend('template')
pl.clf()
img = load_mni152_template()
slicer = XSlicer.init_with_figure(img=img, cut_coords=3)
slicer.add_overlay(img, cmap=pl.cm.gray)
# Forcing a layout here, to test the locator code
slicer.savefig(tempfile.TemporaryFile())
slicer.close()
def test_plot_img_empty():
# Test that things don't crash when we give a map with nothing above
# threshold
# This is only a smoke test
mp.use('svg', warn=False)
import pylab as pl
pl.switch_backend('svg')
data = np.zeros((20, 20, 20))
img = nibabel.Nifti1Image(data, mni_affine)
plot_anat(img)
plot_img(img, slicer='y', threshold=1)
pl.close('all')
def test_demo_ortho_slicer():
# This is only a smoke test
# conditioned on presence of MNI templated
if not find_mni_template():
raise nose.SkipTest("MNI Template is absent for the smoke test")
mp.use('svg', warn=False)
import pylab as pl
pl.switch_backend('svg')
pl.clf()
oslicer = OrthoSlicer(cut_coords=(0, 0, 0))
img, _ = _AnatCache.get_anat()
oslicer.add_overlay(img, cmap=pl.cm.gray)
def detect_trend(x1, y1, num_points_ahead, ric):
z4 = polyfit(x1, y1, 3)
p4 = poly1d(z4) # construct the polynomial
#print y1
z5 = polyfit(x1, y1, 4)
p5 = poly1d(z5)
extrap_y_max_limit = len(x1) * 2 # 360 days
x2 = linspace(
0, extrap_y_max_limit,
50) # 0, 160, 100 means 0 - 160 with 100 data points in between
pylab.switch_backend(
'agg'
) # switch to agg backend that support writing in non-main threads
pylab.plot(x1, y1, 'o', x2, p4(x2), '-g', x2, p5(x2), '-b')
pylab.legend(['%s to fit' % ric, '4th degree poly', '5th degree poly'])
#pylab.axis([0,160,0,10])
#
pylab.axis([
0, len(x1) * 1.1,
min(y1) * 0.997,
max(y1) * 1.002
]) # first pair tells the x axis boundary, 2nd pair y axis boundary
# compute the slopes of each set of data points
# sr - slope real contains the slope computed from real data points from d to d+5 days
# s4 - slope extrapolated by applying 4th degree polynomial
y_arraysize = len(y1)
# s4, intercept, r_value, p_value, std_err = stats.linregress(range(0,num_points_ahead), [p4(i) for i in range(y_arraysize,y_arraysize + num_points_ahead )])
# s5, intercept, r_value, p_value, std_err = stats.linregress(range(0,num_points_ahead), [p5(i) for i in range(y_arraysize,y_arraysize + num_points_ahead )])
s4, intercept, r_value, p_value, std_err = stats.linregress(x1, y1)
s5, intercept, r_value, p_value, std_err = stats.linregress(x1, y1)
rc = (1.0 if s4 > 0.0 else 0.0, 1.0 if s5 > 0.0 else 0.0)
print s4, s5, rc, y_arraysize
#pylab.show()
pylab.savefig('../data/extrapolation/%s-%s.png' % (ric, time))
pylab.close()
d = Q.value
q = RedisQueue(d['qname'], d['namespace'], d['host'], d['port'],
d['db'])
q.put((time, y1, s4, s5))
if abs(s4) > Threshold.value:
d = Q.value
q = RedisQueue(d['alert_bot_q'][1], d['alert_bot_q'][0], d['host'],
d['port'], d['db'])
q.put('%s %0.2f %0.2f' % (ric, s4, s5))
return rc
def test_plot_connectome():
import pylab as pl
pl.switch_backend('template')
node_color = ['green', 'blue', 'k', 'cyan']
# symmetric up to 1e-3 relative tolerance
adjacency_matrix = np.array([[1., -2., 0.3, 0.], [-2.002, 1, 0., 0.],
[0.3, 0., 1., 0.], [0., 0., 0., 1.]])
node_coords = np.arange(3 * 4).reshape(4, 3)
args = adjacency_matrix, node_coords
kwargs = dict(edge_threshold=0.38,
title='threshold=0.38',
node_size=10,
node_color=node_color)
plot_connectome(*args, **kwargs)
# node_coords not an array but a list of tuples
plot_connectome(adjacency_matrix, map(tuple, node_coords.tolist()),
**kwargs)
# saving to file
with tempfile.NamedTemporaryFile(suffix='.png') as fp:
display = plot_connectome(*args, output_file=fp.name, **kwargs)
assert_true(display is None)
assert_true(os.path.isfile(fp.name) and os.path.getsize(fp.name) > 0)
# with node_kwargs, edge_kwargs and edge_cmap arguments
plot_connectome(*args,
edge_threshold='70%',
node_size=[10, 20, 30, 40],
node_color=np.zeros((4, 3)),
edge_cmap='RdBu',
node_kwargs={'marker': 'v'},
edge_kwargs={'linewidth': 4})
# masked array support
masked_adjacency_matrix = np.ma.masked_array(
adjacency_matrix,
np.abs(adjacency_matrix) < 0.5)
plot_connectome(masked_adjacency_matrix, node_coords, **kwargs)
# sparse matrix support
sparse_adjacency_matrix = sparse.coo_matrix(adjacency_matrix)
plot_connectome(sparse_adjacency_matrix, node_coords, **kwargs)
def test_plot_anat():
# This is only a smoke test
mp.use("svg", warn=False)
import pylab as pl
pl.switch_backend("svg")
data = np.zeros((20, 20, 20))
data[3:-3, 3:-3, 3:-3] = 1
ortho_slicer = plot_anat(data, mni_sform, dim=True)
ortho_slicer = plot_anat(data, mni_sform, cut_coords=(80, -120, -60))
# Saving forces a draw, and thus smoke-tests the axes locators
pl.savefig(tempfile.TemporaryFile())
ortho_slicer.edge_map(data, mni_sform, color="c")
z_slicer = plot_anat(slicer="z")
pl.savefig(tempfile.TemporaryFile())
z_slicer.edge_map(data, mni_sform, color="c")
# Smoke test coordinate finder, with and without mask
plot_map(np.ma.masked_equal(data, 0), mni_sform, slicer="x")
plot_map(data, mni_sform, slicer="y")
def kullback_leibler(samples1, samples2, show=False, savename="kullback_leibler_comparison.png"):
"""Generic function to calculate the relative entropy of two histograms.
"""
p1, bins1 = np.histogram(samples1, bins=50, normed=1)
x = (bins1[1:]+bins1[:-1])/2
p2, bins2 = np.histogram(samples2, bins=bins1, normed=1)
integrand = np.log(p1/p2)*p1
kl = np.trapz(np.log(p1/p2)*p1, x)
if show:
import pylab as plt
plt.switch_backend("agg")
plt.hist(samples1, alpha=0.4, color="purple", bins=50, normed=1)
plt.hist(samples2, alpha=0.4, color="steelblue", bins=50, normed=1)
plt.plot(x,p1, "-", lw=2.5, color="purple")
plt.plot(x,p2, "--", lw=2.5, color="steelblue")
plt.title("$KL[p_1, p_2]=%3.3f$"%kl)
plt.savefig("/home/samuroff/shear_pipeline/plot_dump/%s"%savename)
print("KL=",kl)
return kl
def reason_pylab():
from .utils import deliver_image
def _canvas_deliver(canvas):
tf = tempfile.TemporaryFile()
canvas.print_png(tf)
tf.seek(0)
img_data = base64.b64encode(tf.read())
tf.close()
deliver_image(img_data)
def reason_draw_if_interactive():
if matplotlib.is_interactive():
figManager = Gcf.get_active()
if figManager is not None:
_canvas_deliver(figManager.canvas)
def reason_show(mainloop=True):
# We ignore mainloop here
for manager in Gcf.get_all_fig_managers():
_canvas_deliver(manager.canvas)
# Matplotlib has very nice backend overriding.
# We should really use that. This is just a hack.
import matplotlib
matplotlib.use("agg") # Hotfix for when we import pylab below
new_agg = imp.new_module("reason_agg")
import matplotlib.backends.backend_agg as bagg
new_agg.__dict__.update(bagg.__dict__)
new_agg.__dict__.update({
'show': reason_show,
'draw_if_interactive': reason_draw_if_interactive
})
sys.modules["reason_agg"] = new_agg
bagg.draw_if_interactive = reason_draw_if_interactive
from matplotlib._pylab_helpers import Gcf
matplotlib.rcParams["backend"] = "module://reason_agg"
import pylab
pylab.switch_backend("module://reason_agg")
def likelihood_cornerplot(self, names, colour="purple", kde=None, plots=None, lims=[], contours=True, blind=True, ls="-",fill=False, alpha=0.2, overplot=[], label='none', include=[True]*20):
plt.style.use("y1a1")
plt.switch_backend("pdf")
npar = len(names)
naxis = npar
ipanel = 0
print("Will make corner plot of %d parameters"%npar)
for i,name1 in enumerate(names):
fullname1 = "%s--%s"%(sections[name1], name1)
for j, name2 in enumerate(names):
ipanel += 1
fullname2 = "%s--%s"%(sections[name2], name2)
if j>i: continue
plt.subplot(naxis,naxis,ipanel, aspect="auto")
print(i, j, fullname1, fullname2)
self.choose_panel_contents(i,j, fullname1, fullname2, colour=colour, kde=kde, plots=plots, contours=contours, ls=ls, overplot=overplot, fill=fill, alpha=alpha, label=label, include=include)
plt.yticks(visible=False)
plt.xticks(visible=False)
if (j==0) and (i!=0):
if not blind: plt.yticks(np.arange(lims[0][0], lims[0][1], 1)[::2][1:],visible=True, fontsize=10)
plt.ylabel(labels[name1], fontsize=18)
if i==naxis-1:
if not blind: plt.xticks(np.arange(lims[1][0], lims[1][1], 1)[::2][1:],visible=True, fontsize=10)
plt.xlabel(labels[name2], fontsize=18)
if len(lims)>0 and (i!=j):
plt.xlim(lims[j][0], lims[j][1])
plt.ylim(lims[i][0], lims[i][1])
if i==j:
plt.xlim(lims[j][0], lims[j][1])
plt.axhline(0,color="k", ls=":", alpha=0.5)
plt.axvline(0,color="k", ls=":", alpha=0.5)
plt.subplots_adjust(hspace=0, wspace=0)
def savefig(fname,figsize,fig=None,**kwargs):
"""
force saving figure with a given size, useful when using tiling wm;
if fname is a list, it saves multiple files, for example [todel.pdf,todel.png]
"""
if isinstance(fname,str): fname = (fname,)
if fig is None: fig = plt.gcf()
old_bkg = plt.get_backend()
old_inter = plt.isinteractive()
try:
plt.switch_backend("cairo")
old_height = fig.get_figheight()
old_width = fig.get_figwidth()
fig.set_figwidth ( figsize[0] )
fig.set_figheight( figsize[1] )
[ fig.savefig(f,**kwargs) for f in fname ]
plt.switch_backend(old_bkg)
finally:
plt.switch_backend(old_bkg)
plt.interactive(old_inter)
import numpy as np
import galsim
import astropy.table as tb
from py3shape import structs
import math
import pylab as plt
plt.switch_backend("agg")
import fitsio
import glob, argparse, os
import tools.shapes as s
import py3shape as p3s
from py3shape import utils
from tools.im3shape import basic as i3s
import tools.diagnostics as di
class mcmc_toy_model:
def __init__(self):
print "Toy model to illustrate neighbour bias."
def get_realisation(self, samples, icent, ineigh, ireal):
print "-------------------------------------------------"
print "Generating Realisation %d" % ireal
print "-------------------------------------------------"
self.params["fc"] = samples["flux"][icent]
self.params["fn"] = samples["neighbour_flux"][icent]
self.params["dgn"] = samples["nearest_neighbour_pixel_dist"][icent]
self.params["Rc"] = samples["hlr"][icent]
self.params["Rn"] = samples["neighbour_hlr"][icent]
self.params["psf_size"] = samples["psf_size"][icent]
import numpy as np
import pylab as pl
pl.switch_backend('agg')
from mpl_toolkits.axes_grid1 import make_axes_locatable
from scipy.ndimage.filters import gaussian_filter1d
from run import *
from sys import exit
import os
if not os.path.exists("../data/fig"):
os.makedirs("../data/fig")
os.chdir('../data/')
#---------------------------------------#
def sigma2fwhm(sigma):
return sigma * np.sqrt(8 * np.log(2))
#---------------------------------------#
def fwhm2sigma(fwhm):
return fwhm / np.sqrt(8 * np.log(2))
#---------------------------------------#
nc = len(node_coupling)
ns = len(std_noise)
fig2, ax = pl.subplots(1, figsize=(8, 5))
from cycler import cycler
NUM_COLORS = len(range(0, ns, 3))
stat.py
Used to create plots of execution times.
Stronly inspired by http://stackoverflow.com/a/16598291/4620080
Author: Martin Storgaard and Konstantinos Mampentzidis
"""
from pylab import plot, show, savefig, xlim, figure, \
hold, ylim, legend, boxplot, setp, axes, \
title, ylabel, xlabel, subplots_adjust, suptitle, switch_backend
from utils import get_test_cases, get_test_case
from sys import argv
import numpy as np
switch_backend('TKAgg')
# Built-in colors: Blue, Green, Red,
# Cyan, Magenta, Yellow and Black
colors = "bgrcmyk"
# Number of algorithms to be plotted
num_algs = 2
#
if len(argv) != 2:
print "Use ./stat.py [query | del | ins] to generate graphs"
exit()
reading = argv[1]
plural = ""
if reading == "query":
plural = "queries"
elif reading == "del":
# emacs: -*- mode: python; py-indent-offset: 4; indent-tabs-mode: nil -*-
# vi: set ft=python sts=4 ts=4 sw=4 et:
import tempfile
import numpy as np
from nose import SkipTest
try:
import matplotlib as mp
# Make really sure that we don't try to open an Xserver connection.
mp.use('svg', warn=False)
import pylab as pl
pl.switch_backend('svg')
except ImportError:
raise SkipTest('Could not import matplotlib')
from ..activation_maps import demo_plot_map, plot_anat, plot_map
from ..anat_cache import mni_sform, _AnatCache
def test_demo_plot_map():
# This is only a smoke test
mp.use('svg', warn=False)
import pylab as pl
pl.switch_backend('svg')
demo_plot_map()
# Test the black background code path
demo_plot_map(black_bg=True)
import numpy as np
import os
import pylab as plt
plt.switch_backend('pdf')
plt.style.use('y1a1')
import tools.emcee as mc
from chainconsumer import ChainConsumer
from matplotlib import rcParams
rcParams['xtick.major.size'] = 3.5
rcParams['xtick.minor.size'] = 1.7
rcParams['ytick.major.size'] = 3.5
rcParams['ytick.minor.size'] = 1.7
rcParams['xtick.direction'] = 'in'
rcParams['ytick.direction'] = 'in'
print('Loading chains...')
base = '/Users/hattifattener/Documents/y3cosmicshear/chains/'
c0 = mc.chain(
'/Volumes/groke/work/chains/y3/real/final_paper_chains/chain_1x2pt_lcdm_SR_maglim.txt'
)
#chain_1x2pt_lcdm.txt')
c1 = np.genfromtxt(base + '/external/lensing/HSC_Y1_LCDM_post_fid.txt',
names=True)
c2 = mc.chain(
'/Volumes/groke/work/chains/y3/real/final_paper_chains/chain_1x2agg_ML.txt'
)
#mc.chain('/Volumes/groke/work/chains/y1/fiducial/all/out_all-1x2pt-NG.txt')
c3 = mc.chain(
'''
Created on Oct 29, 2013
@author: leal
'''
import nxs
import time
import numpy as np
import pylab as plt
plt.switch_backend('macosx')
#import matplotlib.pyplot as plt
from matplotlib import cm
from matplotlib.colors import LogNorm
partial_time = time.time()
start_time = time.time()
def timeit():
global partial_time
now = time.time()
diff_total = now - start_time
diff_partial = now - partial_time
partial_time = time.time()
print '**** Time: last: %dm %ds :: total: %dm %ds' % (int(diff_partial // 60),
int(diff_partial % 60), int(diff_total // 60), int(diff_total % 60))
class NexusReader(object):
'''
Functions to a read a nexus file
"""
Copied from despotic/examples/gmcChem and modified
"""
from __future__ import print_function
import matplotlib
import pylab as pl
pl.switch_backend('Qt4Agg')
from astropy import units as u
from astropy import constants
import paths
from paths import fpath
from astropy.utils.console import ProgressBar
import pprint
# Import the despotic library and the NL99 network; also import numpy
from despotic import cloud
import despotic
import os
import numpy as np
# Use the Milky Way GMC file as a base
gmc=cloud('cloud.desp')
from despotic.chemistry import NL99
# gmc.setChemEq(network=NL99)
def turb_heating_generator(lengthscale=1*u.pc, turbulence=True):
def turb_heating(cloud, lengthscale=lengthscale):
""" Turbulent heating rate depends on cloud linewidth
(sigma_nonthermal) and driving scale of the turbulence
DESPOTIC wants units of erg/s/H (per hydrogen), so the turbulent
print "Failed to create PNG for %s. (%s)" % (filename, str(e))
html += "<td>Failed to create PNG"
thtml += "<td>Failed to create PNG"
if options.crash:
raise
try:
svg_filename = filename[:-2] + "svg"
f.canvas.print_svg("./output/" + svg_filename, dpi=f.dpi)
html += "<td><img src='%s' width='%dpx' height='%dpx' />" % (svg_filename, w, h)
except Exception, e:
print "Failed to create SVG for %s. (%s)" % (filename, str(e))
html += "<td>Failed to create SVG"
if options.crash:
raise
switch_backend('module://mplh5canvas.backend_h5canvas')
html += "</tr>"
thtml += "</tr>"
print "Finished processing files..."
html += "</table><script> var total_plots = " + str(count) + "; "
pi = """
function connect() {
s = new WebSocket("ws://192.168.184.1:8123");
}
function put_images() {
for (var i=0; i<total_plots+1;i++) {
try {
s.send(document.getElementById("name_"+i).innerText.split(".py")[0] + ".png " + document.getElementById("canvas_"+i).toDataURL());
} catch (err) {}
import numpy as np
import tools.nbc as cal
import tools.shapes as s
import tools.diagnostics as di
import tools.plots as pl
import fitsio as fi
import pylab as plt
import os, yaml, argparse
plt.switch_backend("agg")
def main(args):
im3shape_columns = ["e1", "e2", "mean_psf_e1_sky", "mean_psf_e2_sky", "mean_psf_fwhm", "snr", "mean_rgpp_rp", "radius", "coadd_objects_id", "mean_flux", "n_exposure", "stamp_size", "info_flag", "is_bulge", "tilename"]
truth_columns = ['DES_id', 'cosmos_ident', 'cosmos_photoz', 'sextractor_pixel_offset', 'true_g1', 'true_g2', 'intrinsic_e1', 'intrinsic_e2', 'ra', 'dec', 'hlr', 'mag', 'flux']
# Load the y1 data
if args.calculate or args.catalogue:
y1v2 = s.shapecat(res=config["i3s_dir"])
y1v2.load(truth=False, prune=True, cols=[im3shape_columns,truth_columns])
y1v2.res=y1v2.res[y1v2.res["info_flag"]==0]
# And the simulation results
if args.calculate:
if ".fits" not in config["hoopoe_dir"]:
hoopoe = s.shapecat(res="%s/bord-fits/main"%config["hoopoe_dir"] ,truth="%s/truth"%config["hoopoe_dir"])
hoopoe.load(truth=True, cols=[im3shape_columns,truth_columns])
else:
hoopoe = s.shapecat(res=config["hoopoe_dir"], truth=config["hoopoe_dir"] )
# emacs: -*- mode: python; py-indent-offset: 4; indent-tabs-mode: nil -*-
# vi: set ft=python sts=4 ts=4 sw=4 et:
import tempfile
import numpy as np
from nose import SkipTest
try:
import matplotlib as mp
# Make really sure that we don't try to open an Xserver connection.
mp.use("svg", warn=False)
import pylab as pl
pl.switch_backend("svg")
except ImportError:
raise SkipTest("Could not import matplotlib")
from ..activation_maps import demo_plot_map, plot_anat, plot_map
from ..anat_cache import mni_sform, _AnatCache
def test_demo_plot_map():
# This is only a smoke test
mp.use("svg", warn=False)
import pylab as pl
pl.switch_backend("svg")
demo_plot_map()
