def test_make_legend(self):
"""make_legend create a legend image given an array of ids and
colors"""
fpath = "/tmp/qiimewebfiles/area.pdf"
filename1 = "/tmp/qiimewebfiles/area_legend.pdf"
obs = make_legend(
self.sample_ids,
self.colors,
self.plot_width,
self.plot_height,
"black",
"white",
fpath,
self.generate_image_type,
self.dpi,
)
self.assertTrue(
exists(filename1),
"The png file was not created in \
the appropriate location",
)
self._paths_to_clean_up = [filename1]
def test_make_legend(self):
"""make_legend create a legend image given an array of ids and
colors"""
fpath='/tmp/qiimewebfiles/area.pdf'
filename1='/tmp/qiimewebfiles/area_legend.pdf'
obs=make_legend(self.sample_ids,self.colors,self.plot_width,\
self.plot_height,'black','white',fpath,\
self.generate_image_type,self.dpi)
self.assertTrue(exists(filename1),'The png file was not created in \
the appropriate location')
self._paths_to_clean_up = [filename1]
def main():
option_parser, opts, args = parse_command_line_parameters(**script_info)
category = opts.category
mapping_fp = opts.mapping_fp
colors_used = []
if (category and mapping_fp == None) or (category == None and mapping_fp):
option_parser.error('If coloring by a metadata category, both the '
'category and the mapping file must be supplied.')
elif mapping_fp and category:
mapping_data, mapping_headers, _ = parse_mapping_file(
open(mapping_fp, 'U'))
if category not in mapping_headers:
option_parser.error("The category supplied must exist in the "
"metadata mapping file, '%s' does not exist." %
category)
index = mapping_headers.index(category)
categories = list(set([line[index] for line in mapping_data]))
list_of_plots = []
if opts.binning is None:
ranges = []
else:
# simple ranges format validation
if opts.binning.count('[')!=opts.binning.count(']') or\
opts.binning.count('[')!=opts.binning.count(','):
raise ValueError, "The binning input has an error: '%s'; " % +\
"\nthe format should be [increment1,top_limit1][increment2,top_limit2]"
# spliting in ranges
rgn_txt = opts.binning.split('][')
# removing left [ and right ]
rgn_txt[0] = rgn_txt[0][1:]
rgn_txt[-1] = rgn_txt[-1][:-1]
# converting into int
ranges = []
max = 0
for i, r in enumerate(rgn_txt):
try:
values = map(float, r.split(','))
except ValueError:
raise ValueError, "Not a valid format for binning %s" % opts.binning
if len(values) != 2:
raise ValueError, "All ranges must have only 2 values: [%s]" % r
elif i + 1 != len(rgn_txt):
if values[0] > values[1]:
raise ValueError, "The bin value can't be greater than the max value: [%s]" % r
elif values < 0:
raise ValueError, "This value can not be negative: [%s]" % r
elif max > values[1]:
raise ValueError, "This value can not smaller than the previous one: [%s]" % r
else:
max = values[1]
ranges.append(values)
x_samples, x_distmtx = parse_distmat(open(opts.input_path_x, 'U'))
y_samples, y_distmtx = parse_distmat(open(opts.input_path_y, 'U'))
if opts.ignore_missing_samples:
ignoring_from_x = list(set(x_samples) - set(y_samples))
ignoring_from_y = list(set(y_samples) - set(x_samples))
if opts.verbose:
print '\nFrom %s we are ignoring: %s\n' % (opts.input_path_x,
ignoring_from_x)
print '\nFrom %s we are ignoring: %s\n' % (opts.input_path_y,
ignoring_from_y)
print '\nOnly using: %s\n' % (
list(set(x_samples) & set(y_samples)))
x_file = StringIO(\
filter_samples_from_distance_matrix((x_samples, x_distmtx), ignoring_from_x))
x_samples, x_distmtx = parse_distmat(x_file)
y_file = StringIO(\
filter_samples_from_distance_matrix((y_samples, y_distmtx), ignoring_from_y))
y_samples, y_distmtx = parse_distmat(y_file)
else:
if x_distmtx.shape != y_distmtx.shape:
raise ValueError, 'The distance matrices have different sizes. ' +\
'You can cancel this error by passing --ignore_missing_samples'
figure()
if category == None:
x_val, y_val, x_fit, y_fit, func_text = fit_semivariogram(
(x_samples, x_distmtx), (y_samples, y_distmtx), opts.model, ranges)
plot(x_val,
y_val,
color=opts.dot_color,
marker=opts.dot_marker,
linestyle="None",
alpha=opts.dot_alpha)
plot(x_fit,
y_fit,
linewidth=2.0,
color=opts.line_color,
alpha=opts.line_alpha)
else:
for index, single_category in enumerate(categories):
good_sample_ids = sample_ids_from_metadata_description(
open(mapping_fp), '%s:%s' % (category, single_category))
_y_samples, _y_distmtx = parse_distmat(
StringIO(
filter_samples_from_distance_matrix((y_samples, y_distmtx),
good_sample_ids,
negate=True)))
_x_samples, _x_distmtx = parse_distmat(
StringIO(
filter_samples_from_distance_matrix((x_samples, x_distmtx),
good_sample_ids,
negate=True)))
x_val, y_val, x_fit, y_fit, func_text = fit_semivariogram(
(_x_samples, _x_distmtx), (_y_samples, _y_distmtx), opts.model,
ranges)
# retrieve one of the colors the "QIIME" colors and add it to the
# list of used colors for the creation of the legends in the plot
color_only = get_qiime_hex_string_color(index)
colors_used.append(color_only)
plot(x_val,
y_val,
color=color_only,
marker=opts.dot_marker,
linestyle="None",
alpha=opts.dot_alpha)
plot(x_fit,
y_fit,
linewidth=2.0,
color=color_only,
alpha=opts.line_alpha,
label=single_category)
if opts.x_min != None and opts.x_max != None:
xlim([opts.x_min, opts.x_max])
if opts.y_min != None and opts.y_max != None:
ylim([opts.y_min, opts.y_max])
x_label = opts.x_label
y_label = opts.y_label
fig_title = '%s (%s)' % (opts.fig_title, opts.model)
xlabel(x_label)
ylabel(y_label)
if opts.print_model:
title(fig_title + ' ' + func_text)
else:
title(fig_title)
savefig(opts.output_path)
# print the legends after the figure is exported to avoid conflicts
if category:
# if there's a desired format, use that, else default it to png
_, extension = splitext(opts.output_path)
# remove the dot, else, make_legend will add it to the filename
extension = extension.replace('.', '')
if extension == '':
extension = 'png'
make_legend(categories, colors_used, 0, 0, 'black', 'white',
opts.output_path, extension, 80)
def main():
option_parser, opts, args = parse_command_line_parameters(**script_info)
category = opts.category
mapping_fp = opts.mapping_fp
colors_used = []
if (category and mapping_fp is None) or (category is None and mapping_fp):
option_parser.error('If coloring by a metadata category, both the '
'category and the mapping file must be supplied.')
elif mapping_fp and category:
mapping_data, mapping_headers, _ = parse_mapping_file(open(mapping_fp,
'U'))
if category not in mapping_headers:
option_parser.error("The category supplied must exist in the "
"metadata mapping file, '%s' does not exist." % category)
index = mapping_headers.index(category)
categories = list(set([line[index] for line in mapping_data]))
list_of_plots = []
if opts.binning is None:
ranges = []
else:
# simple ranges format validation
if opts.binning.count('[') != opts.binning.count(']') or\
opts.binning.count('[') != opts.binning.count(','):
raise ValueError("The binning input has an error: '%s'; " % +
"\nthe format should be [increment1,top_limit1][increment2,top_limit2]")
# spliting in ranges
rgn_txt = opts.binning.split('][')
# removing left [ and right ]
rgn_txt[0] = rgn_txt[0][1:]
rgn_txt[-1] = rgn_txt[-1][:-1]
# converting into int
ranges = []
max = 0
for i, r in enumerate(rgn_txt):
try:
values = map(float, r.split(','))
except ValueError:
raise ValueError(
"Not a valid format for binning %s" %
opts.binning)
if len(values) != 2:
raise ValueError(
"All ranges must have only 2 values: [%s]" %
r)
elif i + 1 != len(rgn_txt):
if values[0] > values[1]:
raise ValueError(
"The bin value can't be greater than the max value: [%s]" %
r)
elif values < 0:
raise ValueError(
"This value can not be negative: [%s]" %
r)
elif max > values[1]:
raise ValueError(
"This value can not smaller than the previous one: [%s]" %
r)
else:
max = values[1]
ranges.append(values)
x_samples, x_distmtx = parse_distmat(open(opts.input_path_x, 'U'))
y_samples, y_distmtx = parse_distmat(open(opts.input_path_y, 'U'))
if opts.ignore_missing_samples:
ignoring_from_x = list(set(x_samples) - set(y_samples))
ignoring_from_y = list(set(y_samples) - set(x_samples))
if opts.verbose:
print '\nFrom %s we are ignoring: %s\n' % (opts.input_path_x, ignoring_from_x)
print '\nFrom %s we are ignoring: %s\n' % (opts.input_path_y, ignoring_from_y)
print '\nOnly using: %s\n' % (list(set(x_samples) & set(y_samples)))
x_file = StringIO(
filter_samples_from_distance_matrix((x_samples, x_distmtx), ignoring_from_x))
x_samples, x_distmtx = parse_distmat(x_file)
y_file = StringIO(
filter_samples_from_distance_matrix((y_samples, y_distmtx), ignoring_from_y))
y_samples, y_distmtx = parse_distmat(y_file)
else:
if x_distmtx.shape != y_distmtx.shape:
raise ValueError('The distance matrices have different sizes. ' +
'You can cancel this error by passing --ignore_missing_samples')
figure()
if category is None:
x_val, y_val, x_fit, y_fit, func_text = fit_semivariogram(
(x_samples, x_distmtx), (y_samples, y_distmtx), opts.model, ranges)
plot(
x_val,
y_val,
color=opts.dot_color,
marker=opts.dot_marker,
linestyle="None",
alpha=opts.dot_alpha)
plot(
x_fit,
y_fit,
linewidth=2.0,
color=opts.line_color,
alpha=opts.line_alpha)
else:
# not all the categories that are going to be enumerated are found in
# the distance matrices i.e. the mapping file is a superset that can
# contain more samples than the distance matrices
used_categories = deepcopy(categories)
for index, single_category in enumerate(categories):
good_sample_ids = sample_ids_from_metadata_description(
open(mapping_fp), '%s:%s' % (category, single_category))
try:
_y_samples, _y_distmtx = parse_distmat(StringIO(
filter_samples_from_distance_matrix((y_samples, y_distmtx),
good_sample_ids, negate=True)))
_x_samples, _x_distmtx = parse_distmat(StringIO(
filter_samples_from_distance_matrix((x_samples, x_distmtx),
good_sample_ids, negate=True)))
except ValueError:
# no samples found for this category
used_categories.remove(single_category)
continue
x_val, y_val, x_fit, y_fit, func_text = fit_semivariogram(
(_x_samples, _x_distmtx), (_y_samples, _y_distmtx),
opts.model, ranges)
# retrieve one of the colors the "QIIME" colors and add it to the
# list of used colors for the creation of the legends in the plot
color_only = get_qiime_hex_string_color(index)
colors_used.append(color_only)
plot(x_val, y_val, color=color_only, marker=opts.dot_marker,
linestyle="None", alpha=opts.dot_alpha)
plot(x_fit, y_fit, linewidth=2.0, color=color_only,
alpha=opts.line_alpha, label=single_category)
# set plot limits if requested
x_lb, x_ub = xlim()
y_lb, y_ub = ylim()
if opts.x_min is not None:
x_lb = opts.x_min
if opts.x_max is not None:
x_ub = opts.x_max
if opts.y_min is not None:
y_lb = opts.y_min
if opts.y_max is not None:
y_ub = opts.y_max
xlim(x_lb, x_ub)
ylim(y_lb, y_ub)
x_label = opts.x_label
y_label = opts.y_label
fig_title = '%s (%s)' % (opts.fig_title, opts.model)
xlabel(x_label)
ylabel(y_label)
if opts.print_model:
title(fig_title + ' ' + func_text)
else:
title(fig_title)
savefig(opts.output_path)
# print the legends after the figure is exported to avoid conflicts
if category:
# if there's a desired format, use that, else default it to png
_, extension = splitext(opts.output_path)
# remove the dot, else, make_legend will add it to the filename
extension = extension.replace('.', '')
if extension == '':
extension = 'png'
make_legend(used_categories, colors_used, 0, 0, 'black', 'white',
opts.output_path, extension, 80)
def main():
option_parser, opts, args = parse_command_line_parameters(**script_info)
chuck_norris_joke = opts.chuck_norris_joke
coordinates_fp = opts.coordinates_fp
mapping_file_fp = opts.mapping_file_fp
category_header_name = opts.category
output_fp = opts.output_fp
# have a swell day Yoshiki from the future
if chuck_norris_joke:
o, e, _ = qiime_system_call('curl http://api.icndb.com/jokes/random')
exec 'joke = %s' % o.strip()
print joke['value']['joke']
exit(0)
coords_headers, coords_data, coords_eigenvalues, coords_percents =\
parse_coords(open(coordinates_fp, 'U'))
mapping_data, mapping_headers, _ = parse_mapping_file(open(mapping_file_fp, 'U'))
category_header_index = mapping_headers.index(category_header_name)
category_names = list(set([line[category_header_index]
for line in mapping_data]))
main_figure = plt.figure()
main_axes = main_figure.add_subplot(1, 1, 1, axisbg='black')
plt.xlabel('PC1')
plt.ylabel('PC2')
main_axes.tick_params(axis='y', colors='none')
main_axes.tick_params(axis='x', colors='none')
# sort the data!!! that way you can match make_3d_plots.py
sorted_categories = natsort(category_names)
colors_used = []
for index, category in enumerate(sorted_categories):
sample_ids_list = [line[0] for line in mapping_data if line[category_header_index] == category]
qiime_color = get_qiime_hex_string_color(index)
if len(sample_ids_list) < 3:
continue
colors_used.append(qiime_color)
indices = [coords_headers.index(sample_id) for sample_id in sample_ids_list]
points = coords_data[indices, :2]# * coords_percents[:2]
hull = ConvexHull(points)
main_axes.plot(points[:,0], points[:,1], 'o', color=qiime_color)
for simplex in hull.simplices:
main_axes.plot(points[simplex,0], points[simplex,1], 'w-')
main_axes.plot(points[hull.vertices,0], points[hull.vertices,1], '--', lw=2, color=qiime_color)
# plt.plot(points[hull.vertices[0],0], points[hull.vertices[0],1], '--', color=qiime_color)
# plt.show()
main_figure.savefig(output_fp)
name = splitext(output_fp)[0]
extension = splitext(output_fp)[1].replace('.', '')
make_legend(sorted_categories, colors_used, 0, 0, 'black', 'white', name,
extension, 80)
