def __call__(self, data):
data = self.transform_domain(data)
if "edge_jump" in data.domain:
edges = data.transform(Orange.data.Domain([data.domain["edge_jump"]]))
I_jumps = edges.X[:, 0]
else:
raise NoEdgejumpProvidedException(
'Invalid meta data: Intensity jump at edge is missing')
# order X by wavenumbers:
# xs non ordered energies
# xsind - indecies corresponding to the ordered energies
# mon = True
# X spectra as corresponding to the ordered energies
xs, xsind, mon, X = transform_to_sorted_features(data)
# for the missing data
X, nans = nan_extend_edges_and_interpolate(xs[xsind], X)
# TODO notify the user if some unknown values were interpolated
# Replace remaining NaNs (where whole rows were NaN) with
# with some values so that the function does not crash.
# Results are going to be discarded later.
nan_rows = np.isnan(X).all(axis=1)
X[nan_rows] = 1.
# do the transformation
X = self.transformed(X, xs[xsind], I_jumps)
# discard nan rows
X[nan_rows] = np.nan
# k scores are always ordered, so do not restore order
return X
def __call__(self, data):
data = self.transform_domain(data)
if "edge_jump" in data.domain:
edges = data.transform(Orange.data.Domain([data.domain["edge_jump"]]))
I_jumps = edges.X[:, 0]
else:
raise NoEdgejumpProvidedException(
'Invalid meta data: Intensity jump at edge is missing')
# order X by wavenumbers:
# xs non ordered energies
# xsind - indecies corresponding to the ordered energies
# mon = True
# X spectra as corresponding to the ordered energies
xs, xsind, mon, X = transform_to_sorted_features(data)
# for the missing data
X, nans = nan_extend_edges_and_interpolate(xs[xsind], X)
# TODO notify the user if some unknown values were interpolated
# do the transformation
X = self.transformed(X, xs[xsind], I_jumps)
# k scores are always ordered, so do not restore order
return X
def interpolate_to_data(other_xs, other_data):
# all input data needs to be interpolated (and NaNs removed)
interpolated = interp1d_with_unknowns_numpy(
other_xs, other_data, wavenumbers)
# we know that X is not NaN. same handling of reference as of X
interpolated, _ = nan_extend_edges_and_interpolate(
wavenumbers, interpolated)
return interpolated
def transformed(self, y, x):
if np.any(np.isnan(y)):
y, _ = nan_extend_edges_and_interpolate(x, y)
if self.sub == 0:
newd = y - edge_baseline(x, y)
else:
newd = edge_baseline(x, y)
return newd
def transformed(self, y, x):
if np.any(np.isnan(y)):
y, _ = nan_extend_edges_and_interpolate(x, y)
if self.sub == 0:
newd = y - edge_baseline(x, y)
else:
newd = edge_baseline(x, y)
return newd
def interpolate_extend_to(self, interpolate, wavenumbers):
"""
Interpolate data to given wavenumbers and extend the possibly
nan-edges with the nearest values.
"""
# interpolate reference to the given wavenumbers
X = interp1d_with_unknowns_numpy(getx(interpolate), interpolate.X, wavenumbers)
# we know that X is not NaN. same handling of reference as of X
X, _ = nan_extend_edges_and_interpolate(wavenumbers, X)
return X
def transformed(self, X, wavenumbers):
# about 85% of time in __call__ function is spent is lstsq
# compute average spectrum from the reference
ref_X = np.atleast_2d(spectra_mean(self.reference.X))
# interpolate reference to the data
ref_X = interp1d_with_unknowns_numpy(getx(self.reference), ref_X,
wavenumbers)
# we know that X is not NaN. same handling of reference as of X
ref_X, _ = nan_extend_edges_and_interpolate(wavenumbers, ref_X)
if self.weights:
# interpolate reference to the data
wei_X = interp1d_with_unknowns_numpy(getx(self.weights),
self.weights.X, wavenumbers)
# set whichever weights are undefined (usually at edges) to zero
wei_X[np.isnan(wei_X)] = 0
else:
wei_X = np.ones((1, len(wavenumbers)))
N = wavenumbers.shape[0]
m0 = -2.0 / (wavenumbers[0] - wavenumbers[N - 1])
c_coeff = 0.5 * (wavenumbers[0] + wavenumbers[N - 1])
M = []
for x in range(0, self.order + 1):
M.append((m0 * (wavenumbers - c_coeff))**x)
M.append(ref_X) # always add reference spectrum to the model
n_add_model = len(M)
M = np.vstack(
M
).T # M is needed below for the correction, for par estimation M_weigheted is used
M_weighted = M * wei_X.T
newspectra = np.zeros((X.shape[0], X.shape[1] + n_add_model))
for i, rawspectrum in enumerate(X):
rawspectrumW = (rawspectrum * wei_X)[0]
m = np.linalg.lstsq(M_weighted, rawspectrum)[0]
corrected = rawspectrum
for x in range(0, self.order + 1):
corrected = (corrected - (m[x] * M[:, x]))
if self.scaling:
corrected = corrected / m[self.order + 1]
corrected[np.isinf(
corrected
)] = np.nan # fix values which can be caused by zero weights
corrected = np.hstack(
(corrected, m)) # append the model parameters
newspectra[i] = corrected
return newspectra
def transformed(self, X, wavenumbers):
# wavenumber have to be input as sorted
# about 85% of time in __call__ function is spent is lstsq
# compute average spectrum from the reference
ref_X = np.atleast_2d(spectra_mean(self.reference.X))
# interpolate reference to the data
ref_X = interp1d_with_unknowns_numpy(getx(self.reference), ref_X, wavenumbers)
# we know that X is not NaN. same handling of reference as of X
ref_X, _ = nan_extend_edges_and_interpolate(wavenumbers, ref_X)
if self.weights:
# interpolate reference to the data
wei_X = interp1d_with_unknowns_numpy(getx(self.weights), self.weights.X, wavenumbers)
# set whichever weights are undefined (usually at edges) to zero
wei_X[np.isnan(wei_X)] = 0
else:
wei_X =np.ones((1,len(wavenumbers)))
N = wavenumbers.shape[0]
m0 = - 2.0 / (wavenumbers[0] - wavenumbers[N - 1])
c_coeff = 0.5 * (wavenumbers[0] + wavenumbers[N - 1])
M = []
for x in range(0, self.order+1):
M.append((m0 * (wavenumbers - c_coeff)) ** x)
M.append(ref_X) # always add reference spectrum to the model
n_add_model = len(M)
M = np.vstack(M).T # M is needed below for the correction, for par estimation M_weigheted is used
M_weighted=M*wei_X.T
newspectra = np.zeros((X.shape[0], X.shape[1] + n_add_model))
for i, rawspectrum in enumerate(X):
rawspectrumW=(rawspectrum*wei_X)[0]
m = np.linalg.lstsq(M_weighted, rawspectrum)[0]
corrected = rawspectrum
for x in range(0, self.order+1):
corrected = (corrected - (m[x] * M[:, x]))
if self.scaling:
corrected = corrected/m[self.order+1]
corrected[np.isinf(corrected)] = np.nan # fix values which can be caused by zero weights
corrected = np.hstack((corrected, m)) # append the model parameters
newspectra[i] = corrected
return newspectra
def compute_integral(self, x, y_s):
y_s = y_s - self.compute_baseline(x, y_s)
if np.any(np.isnan(y_s)):
# interpolate unknowns as trapz can not handle them
y_s, _ = nan_extend_edges_and_interpolate(x, y_s)
return np.trapz(y_s, x, axis=1)
def compute_baseline(self, x, y):
if np.any(np.isnan(y)):
y, _ = nan_extend_edges_and_interpolate(x, y)
return edge_baseline(x, y)
def compute_integral(self, x, y_s):
y_s = y_s - self.compute_baseline(x, y_s)
if np.any(np.isnan(y_s)):
# interpolate unknowns as trapz can not handle them
y_s, _ = nan_extend_edges_and_interpolate(x, y_s)
return np.trapz(y_s, x, axis=1)
def compute_baseline(self, x, y):
if np.any(np.isnan(y)):
y, _ = nan_extend_edges_and_interpolate(x, y)
return edge_baseline(x, y)
def interpolate_to_data(other_xs, other_data):
# all input data needs to be interpolated (and NaNs removed)
interpolated = interp1d_with_unknowns_numpy(other_xs, other_data, wavenumbers)
# we know that X is not NaN. same handling of reference as of X
interpolated, _ = nan_extend_edges_and_interpolate(wavenumbers, interpolated)
return interpolated
