def compute(iso_images_sparse, sf_ints):
np.seterr(invalid='ignore') # to ignore division by zero warnings
diff = len(sf_ints) - len(iso_images_sparse)
iso_imgs = [
empty_matrix if img is None else img.toarray()
for img in iso_images_sparse + [None] * diff
]
iso_imgs_flat = [img.flat[:][sample_area_mask] for img in iso_imgs]
if img_gen_conf['do_preprocessing']:
for img in iso_imgs_flat:
smoothing.hot_spot_removal(img)
m = ImgMetrics(metrics)
if len(iso_imgs) > 0:
m.map['spectral'] = isotope_pattern_match(iso_imgs_flat, sf_ints)
m.map['spatial'] = isotope_image_correlation(iso_imgs_flat,
weights=sf_ints[1:])
moc = measure_of_chaos(iso_imgs[0], img_gen_conf['nlevels'])
m.map['chaos'] = 0 if np.isclose(moc, 1.0) else moc
m.map['total_iso_ints'] = [img.sum() for img in iso_imgs]
m.map['min_iso_ints'] = [img.min() for img in iso_imgs]
m.map['max_iso_ints'] = [img.max() for img in iso_imgs]
return m.to_tuple()
def compute(iso_images_sparse, sf_ints):
diff = len(sf_ints) - len(iso_images_sparse)
iso_imgs = [empty_matrix if img is None else img.toarray()
for img in iso_images_sparse + [None] * diff]
iso_imgs_flat = [img.flat[:][sample_area_mask] for img in iso_imgs]
if img_gen_conf['do_preprocessing']:
for img in iso_imgs_flat:
smoothing.hot_spot_removal(img)
measures = ImgMeasures(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0)
if len(iso_imgs) > 0:
measures.pattern_match = isotope_pattern_match(iso_imgs_flat, sf_ints)
measures.image_corr = isotope_image_correlation(iso_imgs_flat, weights=sf_ints[1:])
moc = measure_of_chaos(iso_imgs[0], img_gen_conf['nlevels'])
measures.chaos = 0 if np.isclose(moc, 1.0) else moc
measures.image_corr_01, measures.image_corr_02, measures.image_corr_03, measures.image_corr_12, \
measures.image_corr_13, measures.image_corr_23 = isotope_image_correlation_sd(iso_imgs_flat)
measures.snr = snr_img(iso_imgs[0])
measures.percent_0s = percent_zero(iso_imgs[0])
measures.peak_int_diff_0, measures.peak_int_diff_1, measures.peak_int_diff_2, measures.peak_int_diff_3 = spectra_int_diff(iso_imgs_flat, sf_ints)
measures.quart_1, measures.quart_2, measures.quart_3 = quartile_pxl(iso_imgs[0])
measures.ratio_peak_01, measures.ratio_peak_02, measures.ratio_peak_03, measures.ratio_peak_12, \
measures.ratio_peak_13, measures.ratio_peak_23 = ratio_peaks(iso_imgs_flat)
measures.percentile_10, measures.percentile_20, measures.percentile_30, measures.percentile_40, \
measures.percentile_50, measures.percentile_60, measures.percentile_70, measures.percentile_80, \
measures.percentile_90 = decile_pxl(iso_imgs[0])
return measures.to_tuple()
def compute(iso_images_sparse, sf_ints):
diff = len(sf_ints) - len(iso_images_sparse)
iso_imgs = [
empty_matrix if img is None else img.toarray()
for img in iso_images_sparse + [None] * diff
]
iso_imgs_flat = [img.flat[:][sample_area_mask] for img in iso_imgs]
if img_gen_conf['do_preprocessing']:
for img in iso_imgs_flat:
smoothing.hot_spot_removal(img)
measures = ImgMeasures(0, 0, 0)
if len(iso_imgs) > 0:
measures.pattern_match = isotope_pattern_match(
iso_imgs_flat, sf_ints)
measures.image_corr = isotope_image_correlation(
iso_imgs_flat, weights=sf_ints[1:])
moc = measure_of_chaos(iso_imgs[0], img_gen_conf['nlevels'])
measures.chaos = 0 if np.isclose(moc, 1.0) else moc
return measures.to_tuple()
def compute(iso_images_sparse, sf_ints):
np.seterr(invalid='ignore') # to ignore division by zero warnings
diff = len(sf_ints) - len(iso_images_sparse)
iso_imgs = [empty_matrix if img is None else img.toarray()
for img in iso_images_sparse + [None] * diff]
iso_imgs_flat = [img.flat[:][sample_area_mask] for img in iso_imgs]
if img_gen_conf['do_preprocessing']:
for img in iso_imgs_flat:
smoothing.hot_spot_removal(img)
m = ImgMetrics(metrics)
if len(iso_imgs) > 0:
m.map['spectral'] = isotope_pattern_match(iso_imgs_flat, sf_ints)
m.map['spatial'] = isotope_image_correlation(iso_imgs_flat, weights=sf_ints[1:])
moc = measure_of_chaos(iso_imgs[0], img_gen_conf['nlevels'])
m.map['chaos'] = 0 if np.isclose(moc, 1.0) else moc
m.map['total_iso_ints'] = [img.sum() for img in iso_imgs]
m.map['min_iso_ints'] = [img.min() for img in iso_imgs]
m.map['max_iso_ints'] = [img.max() for img in iso_imgs]
return m.to_tuple()
def compute(iso_images_sparse, formula_ints):
np.seterr(invalid='ignore') # to ignore division by zero warnings
m = METRICS.copy()
if len(iso_images_sparse) > 0:
iso_imgs = [
img.toarray() if img is not None else empty_matrix
for img in iso_images_sparse
]
iso_imgs_flat = [
img.flatten()[sample_area_mask_flat] for img in iso_imgs
]
iso_imgs_flat = iso_imgs_flat[:len(formula_ints)]
if img_gen_config.get('do_preprocessing', False):
for img in iso_imgs_flat:
smoothing.hot_spot_removal(img)
m['spectral'] = isotope_pattern_match(iso_imgs_flat, formula_ints)
if m['spectral'] > 0:
m['spatial'] = isotope_image_correlation(
iso_imgs_flat, weights=formula_ints[1:])
if m['spatial'] > 0:
moc = measure_of_chaos(iso_imgs[0],
img_gen_config.get('nlevels', 30))
m['chaos'] = 0 if np.isclose(moc, 1.0) else moc
if m['chaos'] > 0:
m['msm'] = m['chaos'] * m['spatial'] * m['spectral']
m['total_iso_ints'] = [img.sum() for img in iso_imgs]
m['min_iso_ints'] = [img.min() for img in iso_imgs]
m['max_iso_ints'] = [img.max() for img in iso_imgs]
metrics = OrderedDict((k, replace_nan(v)) for k, v in m.items())
return metrics
def spatial_metric(iso_imgs_flat, n_spectra, intensities, v1_impl=False):
"""Reimplementation of pyImagingMSpec.image_measures.isotope_image_correlation supporting
a variable denominator when calculating the corrcoef (to compensate for the removed zero-valued
pixels). This allows it to work on images that have had empty areas removed, without impacting
the results, which can improve speed significantly.
This returns values that can be very slightly different from the original pyImagingMSpec due to
floating point imprecision, but the results never seemed to differ by more than 0.0000001.
Specify v1_impl=True to use the original pyImagingMSpec implementation.
"""
if v1_impl:
# Ignore div-by-zero / NaN errors - they're handled internally
with np.errstate(divide='ignore', invalid='ignore'):
if np.sum(intensities[1:]) == 0:
return 0
else:
return isotope_image_correlation(iso_imgs_flat,
weights=intensities[1:])
if (len(iso_imgs_flat) < 2 or np.count_nonzero(iso_imgs_flat[0]) < 2
or np.sum(intensities[1:]) == 0):
return 0
iso_imgs_flat = iso_imgs_flat[:, iso_imgs_flat.any(axis=0)]
iso_correlation = spatial_corr(iso_imgs_flat, n_spectra, None)
try:
# coerce between [0 1]
return np.clip(np.average(iso_correlation, weights=intensities[1:]), 0,
1)
except TypeError as exc:
raise ValueError(
"Number of images is not equal to the number of weights + 1"
) from exc
def plot_images(ion_datacube,iso_spect,iso_max,q_val=99,c_map='hot'):
import numpy as np
import matplotlib.pyplot as plt
from pyImagingMSpec.image_measures import measure_of_chaos, isotope_image_correlation, isotope_pattern_match
from pyImagingMSpec import smoothing as im_smoothing
for ii in range(0, iso_max):
# hot-spot removal
xic = ion_datacube.xic[ii]
im_smoothing.hot_spot_removal(xic, q_val) # updated in place
im = ion_datacube.xic_to_image(ii)
#im = im_smoothing.median(im, size=3)
ion_datacube.xic[ii] = ion_datacube.image_to_xic(im)
measure_value_score = measure_of_chaos(
ion_datacube.xic_to_image(0), 30)
# 3. Score correlation with monoiso
if len(iso_spect[1]) > 1:
iso_correlation_score = isotope_image_correlation(
ion_datacube.xic, weights=iso_spect[1][1:])
else: # only one isotope peak, so correlation doesn't make sense
iso_correlation_score = 1
iso_ratio_score = isotope_pattern_match(ion_datacube.xic,iso_spect[1])
msm_score = measure_value_score*iso_correlation_score*iso_ratio_score
ax = [ plt.subplot2grid((2, 4), (0, 0)),
plt.subplot2grid((2, 4), (0, 1)),
plt.subplot2grid((2, 4), (0, 2)),
plt.subplot2grid((2, 4), (0, 3)),
plt.subplot2grid((2, 4), (1, 0), colspan=4, rowspan=1)
]
for a in ax:
a.cla()
# plot images
for ii in range(0,iso_max):
im = ion_datacube.xic_to_image(ii)
ax[ii].imshow(im,cmap=c_map,interpolation='nearest')
ax[ii].set_title('m/z: {:3.4f}'.format(iso_spect[0][ii]))
ax[ii].set_xticks([],[])
ax[ii].set_yticks([],[])
# plot spectrum
notnull=ion_datacube.xic_to_image(0)>0
data_spect = [np.sum(ion_datacube.xic_to_image(ii)[notnull]) for ii in range(0,iso_max)]
data_spect = data_spect / np.linalg.norm(data_spect)
iso_spect[1] = iso_spect[1]/np.linalg.norm(iso_spect[1])
markerline, stemlines, baseline = ax[4].stem(iso_spect[0][0:iso_max],iso_spect[1][0:iso_max],'g')
plt.title("moc: {:3.5f} spat: {:3.5f} spec: {:3.5f} msm: {:3.5f}".format(measure_value_score,iso_correlation_score,iso_ratio_score,msm_score))
plt.setp(stemlines, linewidth=2, color='g') # set stems colors
plt.setp(markerline, 'markerfacecolor', 'g','markeredgecolor','g') # make points
markerline, stemlines, baseline = ax[4].stem(iso_spect[0][0:iso_max],data_spect,'r')
plt.setp(stemlines, linewidth=2, color='r') # set stems colors
plt.setp(markerline, 'markerfacecolor', 'r','markeredgecolor','r') # make points
#plot proxy artist
proxies=[]
h, = plt.plot(iso_spect[0][0],[0],'-g')
proxies.append(h)
h, = plt.plot(iso_spect[0][0],[0],'-r')
proxies.append(h)
ax[4].legend(proxies,('predicted pattern','data pattern'), numpoints=1)
return ax
def run_search(config, IMS_dataset, sum_formulae, adducts, mz_list):
import time
from pyImagingMSpec import image_measures
### Runs the main pipeline
# Get sum formula and predicted m/z peaks for molecules in database
ppm = config['image_generation']['ppm'] # parts per million - a measure of how accuracte the mass spectrometer is
nlevels = config['image_generation']['nlevels'] # parameter for measure of chaos
do_preprocessing = config['image_generation']['do_preprocessing']
interp = config['image_generation']['smooth']
measure_value_score = {}
iso_correlation_score = {}
iso_ratio_score = {}
t0 = time.time()
t_el = 0
for adduct in adducts:
print 'searching -> {}'.format(adduct)
for ii,sum_formula in enumerate(sum_formulae):
if sum_formula not in mz_list:
print 'mssing sf: {}'.format(sum_formula)
continue
if adduct not in mz_list[sum_formula]:
# adduct may not be present if it would make an impossible formula, is there a better way to handle this?
# this hack is also used for fdr calculations
# print '{} adduct not found for {}'.format(adduct, sum_formula)
continue
if time.time() - t_el > 10.:
t_el = time.time()
print '{:3.2f} done in {:3.0f} seconds'.format(float(ii)/len(sum_formulae),time.time()-t0)
# Allocate dicts if required
if not sum_formula in measure_value_score:
measure_value_score[sum_formula] = {}
if not sum_formula in iso_correlation_score:
iso_correlation_score[sum_formula] = {}
if not sum_formula in iso_ratio_score:
iso_ratio_score[sum_formula] = {}
try:
# 1. Generate ion images
mzs = mz_list[sum_formula][adduct][0] #+ 5*mz_list[sum_formula][adduct][0]*1e-6
ion_datacube = IMS_dataset.get_ion_image(mzs, ppm) # for each spectrum, sum the intensity of all peaks within tol of mz_list
if do_preprocessing:
apply_image_processing(config,ion_datacube) #currently just supports hot-spot removal
# 2. Spatial Chaos
measure_value_score[sum_formula][adduct] = image_measures.measure_of_chaos(
ion_datacube.xic_to_image(0), nlevels)
if measure_value_score[sum_formula][adduct] == 1:
measure_value_score[sum_formula][adduct] = 0
# 3. Score correlation with monoiso
if len(mz_list[sum_formula][adduct][1]) > 1:
iso_correlation_score[sum_formula][adduct] = image_measures.isotope_image_correlation(
ion_datacube.xic, weights=mz_list[sum_formula][adduct][1][1:])
else: # only one isotope peak, so correlation doesn't make sense
iso_correlation_score[sum_formula][adduct] = 1
# 4. Score isotope ratio
iso_ratio_score[sum_formula][adduct] = image_measures.isotope_pattern_match(ion_datacube.xic,
mz_list[sum_formula][
adduct][1])
except KeyError as e:
print str(e)
print "bad key in: \"{}\" \"{}\" ".format(sum_formula, adduct)
output_results(config, measure_value_score, iso_correlation_score, iso_ratio_score, sum_formulae, [adduct], mz_list)
return measure_value_score, iso_correlation_score, iso_ratio_score
def plot_images(ion_datacube, iso_spect, iso_max, q_val=99, c_map='hot'):
import numpy as np
import matplotlib.pyplot as plt
from pyImagingMSpec.image_measures import measure_of_chaos, isotope_image_correlation, isotope_pattern_match
from pyImagingMSpec import smoothing as im_smoothing
for ii in range(0, iso_max):
# hot-spot removal
xic = ion_datacube.xic[ii]
im_smoothing.hot_spot_removal(xic, q_val) # updated in place
im = ion_datacube.xic_to_image(ii)
#im = im_smoothing.median(im, size=3)
ion_datacube.xic[ii] = ion_datacube.image_to_xic(im)
measure_value_score = measure_of_chaos(ion_datacube.xic_to_image(0), 30)
# 3. Score correlation with monoiso
if len(iso_spect[1]) > 1:
iso_correlation_score = isotope_image_correlation(
ion_datacube.xic, weights=iso_spect[1][1:])
else: # only one isotope peak, so correlation doesn't make sense
iso_correlation_score = 1
iso_ratio_score = isotope_pattern_match(ion_datacube.xic, iso_spect[1])
msm_score = measure_value_score * iso_correlation_score * iso_ratio_score
ax = [
plt.subplot2grid((2, 4), (0, 0)),
plt.subplot2grid((2, 4), (0, 1)),
plt.subplot2grid((2, 4), (0, 2)),
plt.subplot2grid((2, 4), (0, 3)),
plt.subplot2grid((2, 4), (1, 0), colspan=4, rowspan=1)
]
for a in ax:
a.cla()
# plot images
for ii in range(0, iso_max):
im = ion_datacube.xic_to_image(ii)
ax[ii].imshow(im, cmap=c_map, interpolation='nearest')
ax[ii].set_title('m/z: {:3.4f}'.format(iso_spect[0][ii]))
ax[ii].set_xticks([], [])
ax[ii].set_yticks([], [])
# plot spectrum
notnull = ion_datacube.xic_to_image(0) > 0
data_spect = [
np.sum(ion_datacube.xic_to_image(ii)[notnull])
for ii in range(0, iso_max)
]
data_spect = data_spect / np.linalg.norm(data_spect)
iso_spect[1] = iso_spect[1] / np.linalg.norm(iso_spect[1])
markerline, stemlines, baseline = ax[4].stem(iso_spect[0][0:iso_max],
iso_spect[1][0:iso_max], 'g')
plt.title("moc: {:3.5f} spat: {:3.5f} spec: {:3.5f} msm: {:3.5f}".format(
measure_value_score, iso_correlation_score, iso_ratio_score,
msm_score))
plt.setp(stemlines, linewidth=2, color='g') # set stems colors
plt.setp(markerline, 'markerfacecolor', 'g', 'markeredgecolor',
'g') # make points
markerline, stemlines, baseline = ax[4].stem(iso_spect[0][0:iso_max],
data_spect, 'r')
plt.setp(stemlines, linewidth=2, color='r') # set stems colors
plt.setp(markerline, 'markerfacecolor', 'r', 'markeredgecolor',
'r') # make points
#plot proxy artist
proxies = []
h, = plt.plot(iso_spect[0][0], [0], '-g')
proxies.append(h)
h, = plt.plot(iso_spect[0][0], [0], '-r')
proxies.append(h)
ax[4].legend(proxies, ('predicted pattern', 'data pattern'), numpoints=1)
return ax
