def commit(self):
if len(self.selection):
cluster_ids = set()
column_ids = set()
for (ir, ic) in self.selection:
cluster_ids.add(ir)
column_ids.add(ic)
new_domain = Domain([
self.data.domain[self.columns.values[col]]
for col in column_ids
], self.data.domain.class_vars, self.data.domain.metas)
selected_data = Values([
FilterDiscrete(self.cluster_var, [self.clusters[ir]])
for ir in cluster_ids
],
conjunction=False)(self.data)
selected_data = selected_data.transform(new_domain)
annotated_data = create_annotated_table(
self.data.transform(new_domain),
np.where(np.in1d(self.data.ids, selected_data.ids, True)))
else:
selected_data = None
annotated_data = create_annotated_table(self.data, [])
if self.ca is not None and self._task is None:
table = self.ca.create_contingency_table()
else:
table = None
self.Outputs.selected_data.send(selected_data)
self.Outputs.annotated_data.send(annotated_data)
self.Outputs.contingency.send(table)
def selectionChanged(self, *args):
super().selectionChanged(*args)
rows = list({
index.row()
for index in self.selectionModel().selectedRows(0)
})
if not rows:
owwidget.Outputs.data.send(None)
return
model = self.model().tolist()
filters = [
Values([
FilterDiscrete(self._vars[col], {model[row][col]})
for col in range(len(self._vars))
]) for row in self.model().mapToSourceRows(rows)
]
data = Values(filters, conjunction=False)(owwidget.data)
annotated = create_annotated_table(owwidget.data, data.ids)
owwidget.Outputs.selected_data.send(data)
owwidget.Outputs.data.send(annotated)
def get_filtered_data(self):
if not self.data or not self.selection or not self.pivot.pivot_table:
return None
cond = []
for i, j in self.selection:
f = []
for at, val in [(self.row_feature, self.pivot.pivot_table.X[i, 0]),
(self.col_feature, j)]:
if isinstance(at, DiscreteVariable):
f.append(FilterDiscrete(at, [val]))
elif isinstance(at, ContinuousVariable):
f.append(FilterContinuous(at, FilterContinuous.Equal, val))
cond.append(Values(f))
return Values(cond, conjunction=False)(self.data)
def test_values(self):
vs = self.iris.domain.variables
f1 = FilterContinuous(vs[0], FilterContinuous.Less, 5)
f2 = FilterContinuous(vs[1], FilterContinuous.Greater, 3)
f3 = FilterDiscrete(vs[4], [2])
f12 = Values([f1, f2], conjunction=False, negate=True)
f123 = Values([f12, f3])
d12 = f12(self.iris)
d123 = f123(self.iris)
self.assertGreater(len(d12), len(d123))
self.assertTrue((d123.X[:, 0] >= 5).all())
self.assertTrue((d123.X[:, 1] <= 3).all())
self.assertTrue((d123.Y == 2).all())
self.assertEqual(len(d123),
(~((self.iris.X[:, 0] < 5) | (self.iris.X[:, 1] > 3))
& (self.iris.Y == 2)).sum())
def _gather_conditions(self):
conditions = []
attr = self.attribute
group_attr = self.group_var
for data_range in self.selection:
if attr.is_discrete:
# If some value was removed from the data (in case settings are
# loaded from a scheme), do not include the corresponding
# filter; this is appropriate since data with such value does
# not exist anyway
if not data_range.value:
condition = IsDefined([attr], negate=True)
elif data_range.value not in attr.values:
continue
else:
condition = FilterDiscrete(attr, [data_range.value])
else:
condition = FilterContinuous(attr, FilterContinuous.Between,
data_range.low, data_range.high)
if data_range.group_value:
if not data_range.group_value:
grp_filter = IsDefined([group_attr], negate=True)
elif data_range.group_value not in group_attr.values:
continue
else:
grp_filter = FilterDiscrete(group_attr,
[data_range.group_value])
condition = Values([condition, grp_filter], conjunction=True)
conditions.append(condition)
return conditions
def setUpClass(cls):
super().setUpClass()
cls.data = Table("https://datasets.biolab.si/sc/aml-1k.tab.gz")
genes_path = serverfiles.localpath_download(
"marker_genes", "panglao_gene_markers.tab")
filter_ = FilterString("Organism", FilterString.Equal, "Human")
cls.genes = Values([filter_])(Table(genes_path))
cls.iris = Table("iris")
def commit(self):
if self.data is None:
self.Outputs.selected_data.send(None)
self.Outputs.annotated_data.send(None)
self.Outputs.contingency.send(None)
return
if len(self.selection_indices):
cluster_ids = set()
gene_ids = set()
for (ir, ic) in self.selection_indices:
if not self.transpose:
cluster_ids.add(ir)
gene_ids.add(ic)
else:
cluster_ids.add(ic)
gene_ids.add(ir)
columns = self.clusters if self.transpose else [str(x) for x in self.matrix.domain.attributes]
rows = self.clusters if not self.transpose else [str(x) for x in self.matrix.domain.attributes]
new_domain = Domain([self.data.domain[columns[i]] for i in gene_ids],
self.data.domain.class_vars,
self.data.domain.metas)
selected_data = Values([FilterDiscrete(self.cluster_var, [rows[i]])
for i in cluster_ids],
conjunction=False)(self.data)
selected_data = selected_data.transform(new_domain)
annotated_data = create_annotated_table(self.data,
np.where(np.in1d(self.data.ids, selected_data.ids, True)))
else:
selected_data = None
annotated_data = create_annotated_table(self.data, [])
clusters_values = list(set(self.clusters))
table = ClusterAnalysis.contingency_table(
self.matrix,
DiscreteVariable("Gene" if self.transpose else self.cluster_var.name, clusters_values),
[str(x) for x in self.matrix.domain.attributes],
[[clusters_values.index(c)] for c in self.clusters]
)
self.Outputs.selected_data.send(selected_data)
self.Outputs.annotated_data.send(annotated_data)
self.Outputs.contingency.send(table)
def commit(self):
self.conditions = [item.filter for item in
self.box_scene.selectedItems() if item.filter]
selected, selection = None, []
if self.conditions:
selected = Values(self.conditions, conjunction=False)(self.dataset)
selection = np.in1d(
self.dataset.ids, selected.ids, assume_unique=True).nonzero()[0]
self.Outputs.selected_data.send(selected)
self.Outputs.annotated_data.send(
create_annotated_table(self.dataset, selection))
def setUpClass(cls):
super().setUpClass()
Variable._clear_all_caches()
cls._init_data()
cls.signal_name = "Reference Data"
cls.signal_data = cls.data
cls.same_input_output_domain = False
genes_path = serverfiles.localpath_download("marker_genes", "panglao_gene_markers.tab")
filter_ = FilterString("Organism", FilterString.Equal, "Human")
cls.genes = Values([filter_])(Table(genes_path))
cls.genes.attributes[TAX_ID] = "9606"
def commit(self):
if len(self.selection):
cells = []
for ir, r in enumerate(self.rows.values):
for ic, c in enumerate(self.columns.values):
if (ir, ic) in self.selection:
cells.append(
Values([
FilterDiscrete(self.rows, [r]),
FilterDiscrete(self.columns, [c])
]))
selected_data = Values(cells, conjunction=False)(self.data)
annotated_data = create_annotated_table(
self.data,
np.where(np.in1d(self.data.ids, selected_data.ids, True)))
else:
selected_data = None
annotated_data = create_annotated_table(self.data, [])
self.Outputs.contingency.send(self.table)
self.Outputs.selected_data.send(selected_data)
self.Outputs.annotated_data.send(annotated_data)
def commit(self):
conditions = self._gather_conditions()
if conditions:
selected = Values(conditions, conjunction=False)(self.dataset)
selection = np.in1d(self.dataset.ids,
selected.ids,
assume_unique=True).nonzero()[0]
else:
selected, selection = None, []
self.Outputs.selected_data.send(selected)
self.Outputs.annotated_data.send(
create_annotated_table(self.dataset, selection))
def commit(self):
if len(self.selection):
cluster_ids = set()
gene_ids = set()
for (ir, ic) in self.selection:
if not self.transpose:
cluster_ids.add(ir)
gene_ids.add(ic)
else:
cluster_ids.add(ic)
gene_ids.add(ir)
new_domain = Domain(
[self.data.domain[self.genes[i]] for i in gene_ids],
self.data.domain.class_vars, self.data.domain.metas)
selected_data = Values([
FilterDiscrete(self.cluster_var, [self.clusters[i]])
for i in cluster_ids
],
conjunction=False)(self.data)
selected_data = selected_data.transform(new_domain)
annotated_data = create_annotated_table(
self.data.transform(new_domain),
np.where(np.in1d(self.data.ids, selected_data.ids, True)))
else:
selected_data = None
annotated_data = create_annotated_table(self.data, [])
if self.matrix is not None:
table = ClusterAnalysis.contingency_table(
self.matrix,
DiscreteVariable(self.cluster_var.name,
np.array(self.clusters)),
np.array(self.genes)[self.gene_order],
self.cluster_order[..., np.newaxis])
else:
table = None
self.Outputs.selected_data.send(selected_data)
self.Outputs.annotated_data.send(annotated_data)
self.Outputs.contingency.send(table)
def commit(self):
conditions = self._gather_conditions()
if conditions:
selected = Values(conditions, conjunction=False)(self.dataset)
selection = np.in1d(
self.dataset.ids, selected.ids, assume_unique=True).nonzero()[0]
else:
selected, selection = None, []
summary = len(selected) if selected else self.info.NoOutput
details = format_summary_details(selected) if selected else ""
self.info.set_output_summary(summary, details)
self.Outputs.selected_data.send(selected)
self.Outputs.annotated_data.send(
create_annotated_table(self.dataset, selection))
def commit(self):
self.conditions = [
item.filter for item in self.box_scene.selectedItems()
if item.filter
]
selected, selection = None, []
if self.conditions:
selected = Values(self.conditions, conjunction=False)(self.dataset)
selection = [
i for i, inst in enumerate(self.dataset) if inst in selected
]
self.Outputs.selected_data.send(selected)
self.Outputs.annotated_data.send(
create_annotated_table(self.dataset, selection))
def commit(self):
self.conditions = [
item.filter for item in self.box_scene.selectedItems()
if item.filter
]
selected, selection = None, []
if self.conditions:
selected = Values(self.conditions, conjunction=False)(self.dataset)
selection = [
i for i, inst in enumerate(self.dataset) if inst in selected
]
self.send("Selected Data", selected)
self.send(ANNOTATED_DATA_SIGNAL_NAME,
create_annotated_table(self.dataset, selection))
def commit(self):
self.conditions = [item.filter for item in
self.box_scene.selectedItems() if item.filter]
selected, selection = None, []
if self.conditions:
selected = Values(self.conditions, conjunction=False)(self.dataset)
selection = np.in1d(
self.dataset.ids, selected.ids, assume_unique=True).nonzero()[0]
summary = len(selected) if selected else self.info.NoOutput
details = format_summary_details(selected) if selected else ""
self.info.set_output_summary(summary, details)
self.Outputs.selected_data.send(selected)
self.Outputs.annotated_data.send(
create_annotated_table(self.dataset, selection))
def test_reprs(self):
flid = IsDefined(negate=True)
flhc = HasClass()
flr = Random()
fld = FilterDiscrete(self.attr_disc, None)
flsv = SameValue(self.attr_disc, self.value_disc, negate=True)
flc = FilterContinuous(self.vs[0], FilterContinuous.Less, 5)
flc2 = FilterContinuous(self.vs[1], FilterContinuous.Greater, 3)
flv = Values([flc, flc2], conjunction=False, negate=True)
flvf = ValueFilter(self.attr_disc)
fls = FilterString("name", FilterString.Equal, "Aardvark", case_sensitive=False)
flsl = FilterStringList("name", ["Aardvark"], case_sensitive=False)
flrx = FilterRegex("name", "^c...$")
filters = [flid, flhc, flr, fld, flsv, flc, flv, flvf, fls, flsl, flrx]
for f in filters:
repr_str = repr(f)
new_f = eval(repr_str)
self.assertEqual(repr(new_f), repr_str)
def commit(self):
averages = None
if self.data is not None:
if self.group_var is None:
averages = self.average_table(self.data)
else:
parts = []
for value in self.group_var.values:
svfilter = SameValue(self.group_var, value)
v_table = self.average_table(svfilter(self.data))
parts.append(v_table)
# Using "None" as in OWSelectRows
# Values is required because FilterDiscrete doesn't have
# negate keyword or IsDefined method
deffilter = Values(
conditions=[FilterDiscrete(self.group_var, None)],
negate=True)
v_table = self.average_table(deffilter(self.data))
parts.append(v_table)
averages = Orange.data.Table.concatenate(parts, axis=0)
self.Outputs.averages.send(averages)
def bench_adult_filter_pre_pandas(self):
age_filter = FilterContinuous(self.adult.domain["age"],
FilterContinuous.Greater, 30)
workclass_filter = FilterDiscrete(self.adult.domain["workclass"], [0])
combined = Values([age_filter, workclass_filter])
combined(self.adult)
def __init__(self, conditions, *args):
super().__init__(*args)
self.filter = Values(conditions) if conditions else None
self.setFlag(QGraphicsItem.ItemIsSelectable)
def onDeleteWidget(self):
self.shutdown()
super().onDeleteWidget()
if __name__ == "__main__":
from Orange.projection import PCA
from orangecontrib.bioinformatics.utils import serverfiles
data_path = "https://datasets.orange.biolab.si/sc/aml-1k.tab.gz"
table_data = Table(data_path)
table_data.attributes[TAX_ID] = "9606"
ref_data = table_data[::2]
pca = PCA(n_components=2)
pca_model = pca(ref_data)
proj = pca_model(ref_data)
new_dom = Domain(
ref_data.domain.attributes, ref_data.domain.class_vars, chain(ref_data.domain.metas, proj.domain.attributes)
)
ref_data = ref_data.transform(new_dom)
genes_path = serverfiles.localpath_download("marker_genes", "panglao_gene_markers.tab")
filter_ = FilterString("Organism", FilterString.Equal, "Human")
table_genes = Values([filter_])(Table(genes_path))
table_genes.attributes[TAX_ID] = "9606"
WidgetPreview(OWAnnotateProjection).run(
set_data=ref_data, set_secondary_data=table_data[1:200:2], set_genes=table_genes
)
