def __call__(self, data):
# creates function for transforming data
common = _EMSC(self.reference, self.badspectra, self.weights, self.order,
self.scaling, data.domain)
# takes care of domain column-wise, by above transformation function
atts = [a.copy(compute_value=EMSCFeature(i, common))
for i, a in enumerate(data.domain.attributes)]
model_metas = []
n_badspec = len(self.badspectra) if self.badspectra is not None else 0
used_names = set([var.name for var in data.domain.variables + data.domain.metas])
if self.output_model:
i = len(data.domain.attributes)
for o in range(self.order+1):
n = get_unique_names(used_names, "EMSC parameter " + str(o))
model_metas.append(
Orange.data.ContinuousVariable(name=n,
compute_value=EMSCModel(i, common)))
i += 1
for o in range(n_badspec):
n = get_unique_names(used_names, "EMSC parameter bad spec " + str(o))
model_metas.append(
Orange.data.ContinuousVariable(name=n,
compute_value=EMSCModel(i, common)))
i += 1
n = get_unique_names(used_names, "EMSC scaling parameter")
model_metas.append(
Orange.data.ContinuousVariable(name=n,
compute_value=EMSCModel(i, common)))
domain = Orange.data.Domain(atts, data.domain.class_vars,
data.domain.metas + tuple(model_metas))
return data.from_table(domain, data)
def commit(self):
map_data = None
if self.data and self.xpoints is not None and self.ypoints is not None \
and self.xpoints * self.ypoints == len(self.data):
used_names = [
var.name
for var in self.data.domain.variables + self.data.domain.metas
]
xmeta = Orange.data.ContinuousVariable.make(
get_unique_names(used_names, "X"))
ymeta = Orange.data.ContinuousVariable.make(
get_unique_names(used_names, "Y"))
# add new variables for X and Y dimension ot the data domain
metas = self.data.domain.metas + (xmeta, ymeta)
domain = Orange.data.Domain(self.data.domain.attributes,
self.data.domain.class_vars, metas)
map_data = Orange.data.Table(domain, self.data)
map_data[:,
xmeta] = np.tile(np.arange(self.xpoints),
len(self.data) // self.xpoints).reshape(
-1, 1)
map_data[:, ymeta] = np.repeat(np.arange(self.ypoints),
len(self.data) //
self.ypoints).reshape(-1, 1)
self.Outputs.map.send(map_data)
def __call__(self, data):
# creates function for transforming data
common = _ME_EMSC(reference=self.reference,
weights=self.weights,
ncomp=self.ncomp,
alpha0=self.alpha0,
gamma=self.gamma,
maxNiter=self.maxNiter,
fixedNiter=self.fixedNiter,
positiveRef=self.positiveRef,
domain=data.domain)
# takes care of domain column-wise, by above transformation function
atts = [
a.copy(compute_value=ME_EMSCFeature(i, common))
for i, a in enumerate(data.domain.attributes)
]
model_metas = []
n_badspec = self.ncomp
# Check if function knows about bad spectra
used_names = set(
[var.name for var in data.domain.variables + data.domain.metas])
if self.output_model:
i = len(data.domain.attributes)
for o in range(1):
n = get_unique_names(used_names, "EMSC parameter " + str(o))
model_metas.append(
Orange.data.ContinuousVariable(name=n,
compute_value=ME_EMSCModel(
i, common)))
i += 1
for o in range(n_badspec):
n = get_unique_names(used_names,
"EMSC parameter bad spec " + str(o))
model_metas.append(
Orange.data.ContinuousVariable(name=n,
compute_value=ME_EMSCModel(
i, common)))
i += 1
n = get_unique_names(used_names, "EMSC scaling parameter")
model_metas.append(
Orange.data.ContinuousVariable(name=n,
compute_value=ME_EMSCModel(
i, common)))
i += 1
n = get_unique_names(used_names, "Number of iterations")
model_metas.append(
Orange.data.ContinuousVariable(name=n,
compute_value=ME_EMSCModel(
i, common)))
i += 1
n = get_unique_names(used_names, "RMSE")
model_metas.append(
Orange.data.ContinuousVariable(name=n,
compute_value=ME_EMSCModel(
i, common)))
domain = Orange.data.Domain(atts, data.domain.class_vars,
data.domain.metas + tuple(model_metas))
return data.from_table(domain, data)
def commit(self):
map_data = None
if self.data and self.xpoints is not None and self.ypoints is not None \
and self.xpoints * self.ypoints == len(self.data):
used_names = [var.name for var in self.data.domain.variables + self.data.domain.metas]
xmeta = Orange.data.ContinuousVariable.make(get_unique_names(used_names, "X"))
ymeta = Orange.data.ContinuousVariable.make(get_unique_names(used_names, "Y"))
# add new variables for X and Y dimension ot the data domain
metas = self.data.domain.metas + (xmeta, ymeta)
domain = Orange.data.Domain(self.data.domain.attributes, self.data.domain.class_vars, metas)
map_data = Orange.data.Table(domain, self.data)
map_data[:, xmeta] = np.tile(np.arange(self.xpoints), len(self.data)//self.xpoints).reshape(-1, 1)
map_data[:, ymeta] = np.repeat(np.arange(self.ypoints), len(self.data)//self.ypoints).reshape(-1, 1)
self.Outputs.map.send(map_data)
def commit(self):
if self.embedding is not None:
names = get_unique_names(
[v.name for v in self.data.domain.variables],
["mds-x", "mds-y"])
output = embedding = Orange.data.Table.from_numpy(
Orange.data.Domain([
ContinuousVariable(names[0]),
ContinuousVariable(names[1])
]), self.embedding)
else:
output = embedding = None
if self.embedding is not None and self.data is not None:
domain = self.data.domain
domain = Orange.data.Domain(
domain.attributes, domain.class_vars,
domain.metas + embedding.domain.attributes)
output = self.data.transform(domain)
output.metas[:, -2:] = embedding.X
selection = self.graph.get_selection()
if output is not None and len(selection) > 0:
selected = output[selection]
else:
selected = None
if self.graph.selection is not None and np.max(
self.graph.selection) > 1:
annotated = create_groups_table(output, self.graph.selection)
else:
annotated = create_annotated_table(output, selection)
self.Outputs.selected_data.send(selected)
self.Outputs.annotated_data.send(annotated)
def commit(self):
if self.embedding is not None:
names = get_unique_names([v.name for v in self.data.domain.variables],
["mds-x", "mds-y"])
output = embedding = Orange.data.Table.from_numpy(
Orange.data.Domain([ContinuousVariable(names[0]), ContinuousVariable(names[1])]),
self.embedding
)
else:
output = embedding = None
if self.embedding is not None and self.data is not None:
domain = self.data.domain
domain = Orange.data.Domain(domain.attributes,
domain.class_vars,
domain.metas + embedding.domain.attributes)
output = self.data.transform(domain)
output.metas[:, -2:] = embedding.X
selection = self.graph.get_selection()
if output is not None and len(selection) > 0:
selected = output[selection]
else:
selected = None
if self.graph.selection is not None and np.max(self.graph.selection) > 1:
annotated = create_groups_table(output, self.graph.selection)
else:
annotated = create_annotated_table(output, selection)
self.Outputs.selected_data.send(selected)
self.Outputs.annotated_data.send(annotated)
def test_get_unique_names(self):
names = [
"charlie", "bravo", "charlie (2)", "charlie (3)", "bravo (2)",
"charlie (4)", "bravo (3)"
]
self.assertEqual(get_unique_names(names, ["bravo", "charlie"]),
["bravo (5)", "charlie (5)"])
def __call__(self, data):
common = _IntegrateCommon(data.domain)
atts = []
if self.limits:
methods = self.methods
if not isinstance(methods, Iterable):
methods = [methods] * len(self.limits)
names = self.names
if not names:
names = [" - ".join("{0}".format(e) for e in l) for l in self.limits]
# no names in data should be repeated
used_names = [var.name for var in data.domain.variables + data.domain.metas]
for i, n in enumerate(names):
n = get_unique_names(used_names, n)
names[i] = n
used_names.append(n)
for limits, method, name in zip(self.limits, methods, names):
atts.append(Orange.data.ContinuousVariable(
name=name,
compute_value=method(limits, common)))
if not self.metas:
domain = Orange.data.Domain(atts, data.domain.class_vars,
metas=data.domain.metas)
else:
domain = Orange.data.Domain(data.domain.attributes, data.domain.class_vars,
metas=data.domain.metas + tuple(atts))
return data.from_table(domain, data)
def __call__(self, data):
# creates function for transforming data
common = _EMSC(self.reference, self.badspectra, self.weights,
self.order, self.scaling, data.domain)
# takes care of domain column-wise, by above transformation function
atts = [
a.copy(compute_value=EMSCFeature(i, common))
for i, a in enumerate(data.domain.attributes)
]
model_metas = []
n_badspec = len(self.badspectra) if self.badspectra is not None else 0
used_names = set(
[var.name for var in data.domain.variables + data.domain.metas])
if self.output_model:
i = len(data.domain.attributes)
for o in range(self.order + 1):
n = get_unique_names(used_names, "EMSC parameter " + str(o))
model_metas.append(
Orange.data.ContinuousVariable(name=n,
compute_value=EMSCModel(
i, common)))
i += 1
for o in range(n_badspec):
n = get_unique_names(used_names,
"EMSC parameter bad spec " + str(o))
model_metas.append(
Orange.data.ContinuousVariable(name=n,
compute_value=EMSCModel(
i, common)))
i += 1
n = get_unique_names(used_names, "EMSC scaling parameter")
model_metas.append(
Orange.data.ContinuousVariable(name=n,
compute_value=EMSCModel(
i, common)))
domain = Orange.data.Domain(atts, data.domain.class_vars,
data.domain.metas + tuple(model_metas))
return data.from_table(domain, data)
def _setup_plot(self):
self._clear_plot()
if self.data is None:
return
self.__replot_requested = False
names = get_unique_names(
[
v.name for v in chain(self.data.domain.variables,
self.data.domain.metas)
],
[
"{}-x".format(self.Variable_name[self.placement]),
"{}-y".format(self.Variable_name[self.placement]),
],
)
self.variable_x = ContinuousVariable(names[0])
self.variable_y = ContinuousVariable(names[1])
if self.placement in [self.Placement.Circular, self.Placement.LDA]:
variables = list(self.model_selected)
elif self.placement == self.Placement.Projection:
variables = self.model_selected[:] + self.model_other[:]
elif self.placement == self.Placement.PCA:
variables = [
var for var in self.data.domain.attributes if var.is_continuous
]
if not variables:
self.graph.new_data(None)
return
if self.placement == self.Placement.PCA:
valid_mask, ec, axes = self._get_pca()
variables = self._pca.orig_domain.attributes
else:
valid_mask, ec, axes = self.prepare_plot_data(variables)
self.plotdata.variables = variables
self.plotdata.valid_mask = valid_mask
self.plotdata.embedding_coords = ec
self.plotdata.axes = axes
if any(e is None for e in (valid_mask, ec, axes)):
return
if not sum(valid_mask):
self.Error.no_valid_data()
self.graph.new_data(None, None)
return
self.Error.no_valid_data.clear()
self._anchor_circle(variables=variables)
self._plot()
def _setup_plot(self):
self._clear_plot()
if self.data is None:
return
self.__replot_requested = False
names = get_unique_names([v.name for v in chain(self.data.domain.variables,
self.data.domain.metas)],
["{}-x".format(self.Variable_name[self.placement]),
"{}-y".format(self.Variable_name[self.placement])])
self.variable_x = ContinuousVariable(names[0])
self.variable_y = ContinuousVariable(names[1])
if self.placement in [self.Placement.Circular, self.Placement.LDA]:
variables = list(self.model_selected)
elif self.placement == self.Placement.Projection:
variables = self.model_selected[:] + self.model_other[:]
elif self.placement == self.Placement.PCA:
variables = [var for var in self.data.domain.attributes if var.is_continuous]
if not variables:
self.graph.new_data(None)
return
if self.placement == self.Placement.PCA:
valid_mask, ec, axes = self._get_pca()
variables = self._pca.orig_domain.attributes
else:
valid_mask, ec, axes = self.prepare_plot_data(variables)
self.plotdata.variables = variables
self.plotdata.valid_mask = valid_mask
self.plotdata.embedding_coords = ec
self.plotdata.axes = axes
if any(e is None for e in (valid_mask, ec, axes)):
return
if not sum(valid_mask):
self.Error.no_valid_data()
self.graph.new_data(None, None)
return
self.Error.no_valid_data.clear()
self._anchor_circle(variables=variables)
self._plot()
def test_get_unique_names(self):
names = ["charlie", "bravo", "charlie (2)", "charlie (3)", "bravo (2)", "charlie (4)",
"bravo (3)"]
self.assertEqual(get_unique_names(names, ["bravo", "charlie"]),
["bravo (5)", "charlie (5)"])
def _get_projection_variables(self):
domain = self.data.domain
names = get_unique_names(
[v.name for v in domain.variables + domain.metas],
self.embedding_variables_names)
return ContinuousVariable(names[0]), ContinuousVariable(names[1])
