def __init__(self):
super().__init__()
RecentPathsWComboMixin.__init__(self)
self.loaded_file = ""
vbox = gui.vBox(self.controlArea, "Distance File", addSpace=True)
box = gui.hBox(vbox)
self.file_combo.setMinimumWidth(300)
box.layout().addWidget(self.file_combo)
self.file_combo.activated[int].connect(self.select_file)
button = gui.button(box, self, '...', callback=self.browse_file)
button.setIcon(self.style().standardIcon(QtGui.QStyle.SP_DirOpenIcon))
button.setSizePolicy(
QtGui.QSizePolicy.Maximum, QtGui.QSizePolicy.Fixed)
button = gui.button(
box, self, "Reload", callback=self.reload, default=True)
button.setIcon(self.style().standardIcon(QtGui.QStyle.SP_BrowserReload))
button.setSizePolicy(QtGui.QSizePolicy.Fixed, QtGui.QSizePolicy.Fixed)
box = gui.vBox(self.controlArea, "Info", addSpace=True)
self.infoa = gui.widgetLabel(box, 'No data loaded.')
self.warnings = gui.widgetLabel(box, ' ')
#Set word wrap, so long warnings won't expand the widget
self.warnings.setWordWrap(True)
self.warnings.setSizePolicy(
QtGui.QSizePolicy.Ignored, QtGui.QSizePolicy.MinimumExpanding)
self.set_file_list()
QtCore.QTimer.singleShot(0, self.open_file)
def __init__(self):
super().__init__()
self.data = None
self.preprocessors = None
box = gui.widgetBox(self.controlArea, "Learner/Predictor Name")
gui.lineEdit(box, self, "learner_name")
box = gui.widgetBox(self.controlArea, "Regularization")
box = gui.radioButtons(
box, self, "reg_type",
btnLabels=["No regularization", "Ridge regression",
"Lasso regression"],
callback=self._reg_type_changed)
gui.separator(box)
self.alpha_box = box2 = gui.widgetBox(box, margin=0)
gui.widgetLabel(box2, "Regularization strength")
self.alpha_slider = gui.hSlider(
box2, self, "alpha_index",
minValue=0, maxValue=len(self.alphas) - 1,
callback=self._alpha_changed, createLabel=False)
box3 = gui.widgetBox(box, orientation="horizontal")
box3.layout().setAlignment(Qt.AlignCenter)
self.alpha_label = gui.widgetLabel(box3, "")
self._set_alpha_label()
gui.auto_commit(self.controlArea, self, "autosend", "Apply",
checkbox_label="Apply on every change")
self.layout().setSizeConstraint(QLayout.SetFixedSize)
self.alpha_slider.setEnabled(self.reg_type != self.OLS)
self.commit()
def __init__(self, parent=None):
super().__init__(parent)
self.train_data = None
self.test_data = None
#: An Ordered dictionary with current inputs and their testing
#: results.
self.learners = OrderedDict()
sbox = gui.widgetBox(self.controlArea, "Sampling")
rbox = gui.radioButtons(
sbox, self, "resampling", callback=self._param_changed
)
gui.appendRadioButton(rbox, "Cross validation")
ibox = gui.indentedBox(rbox)
gui.spin(ibox, self, "k_folds", 2, 50, label="Number of folds:",
callback=self.kfold_changed)
gui.appendRadioButton(rbox, "Leave one out")
gui.appendRadioButton(rbox, "Random sampling")
ibox = gui.indentedBox(rbox)
gui.spin(ibox, self, "n_repeat", 2, 50, label="Repeat train/test",
callback=self.bootstrap_changed)
gui.widgetLabel(ibox, "Relative training set size:")
gui.hSlider(ibox, self, "sample_p", minValue=1, maxValue=100,
ticks=20, vertical=False, labelFormat="%d %%",
callback=self.bootstrap_changed)
gui.appendRadioButton(rbox, "Test on train data")
gui.appendRadioButton(rbox, "Test on test data")
rbox.layout().addSpacing(5)
gui.button(rbox, self, "Apply", callback=self.apply)
self.cbox = gui.widgetBox(self.controlArea, "Target class")
self.class_selection_combo = gui.comboBox(self.cbox, self, "class_selection",
items=[],
callback=self._select_class,
sendSelectedValue=True, valueType=str)
gui.rubber(self.controlArea)
self.view = QTreeView(
rootIsDecorated=False,
uniformRowHeights=True,
wordWrap=True,
editTriggers=QTreeView.NoEditTriggers
)
header = self.view.header()
header.setResizeMode(QHeaderView.ResizeToContents)
header.setDefaultAlignment(Qt.AlignCenter)
header.setStretchLastSection(False)
self.result_model = QStandardItemModel()
self.view.setModel(self.result_model)
self.view.setItemDelegate(ItemDelegate())
self._update_header()
box = gui.widgetBox(self.mainArea, "Evaluation Results")
box.layout().addWidget(self.view)
def _setup_layout(self):
self.controlArea.setMinimumWidth(self.controlArea.sizeHint().width())
self.layout().setSizeConstraint(QLayout.SetFixedSize)
widget_box = widgetBox(self.controlArea, 'Info')
self.input_data_info = widgetLabel(widget_box, self._NO_DATA_INFO_TEXT)
self.connection_info = widgetLabel(widget_box, "")
widget_box = widgetBox(self.controlArea, 'Settings')
self.cb_image_attr = comboBox(
widget=widget_box,
master=self,
value='cb_image_attr_current_id',
label='Image attribute:',
orientation=Qt.Horizontal,
callback=self._cb_image_attr_changed
)
self.auto_commit_widget = auto_commit(
widget=self.controlArea,
master=self,
value='_auto_apply',
label='Apply',
checkbox_label='Auto Apply',
commit=self.commit
)
def __init__(self):
super().__init__()
self.data = None
"""The LazyTable that will be send."""
# GUI: as simple as possible for now
box = gui.widgetBox(self.controlArea, "SAMP Info")
self.infoa = gui.widgetLabel(widget=box, label='SAMP status unknown.')
box_input_catalog = gui.widgetBox(box, orientation=0)
self.input_catalog_text = gui.widgetLabel(widget=box_input_catalog , label='Catalog')
self.input_catalog = gui.lineEdit(widget=box_input_catalog , master=self, value='catalog_of_interest')
#self.resize(100,50)
self.button_disconnect = gui.button(self.controlArea, self, "&Disconnect", callback=self.disconnect_samp, default=False)
self.button_connect = gui.button(self.controlArea, self, "&Connect", callback=self.connect_samp, default=False)
self.button_disconnect.setHidden(True)
#gui.button(self.controlArea, self, "&Pull Rows", callback=self.pull_rows, default=False)
gui.button(self.controlArea, self, "&Set Table", callback=self.we_have_a_new_table, default=False)
# Create a SAMP client and connect to HUB.
# Do not make the client in __init__ because this does not allow
# the client to disconnect and reconnect again.
self.samp_client = None
self.connect_samp()
def add_main_layout(self):
box = gui.hBox(self.controlArea, "Regularization")
gui.radioButtons(box, self, "reg_type",
btnLabels=self.REGULARIZATION_TYPES,
callback=self._reg_type_changed)
gui.separator(box, 20, 20)
self.alpha_box = box2 = gui.vBox(box, margin=10)
gui.widgetLabel(box2, "Regularization strength:")
self.alpha_slider = gui.hSlider(
box2, self, "alpha_index",
minValue=0, maxValue=len(self.alphas) - 1,
callback=self._alpha_changed, createLabel=False)
box3 = gui.hBox(box2)
box3.layout().setAlignment(Qt.AlignCenter)
self.alpha_label = gui.widgetLabel(box3, "")
self._set_alpha_label()
gui.separator(box2, 10, 10)
box4 = gui.vBox(box2, margin=0)
gui.widgetLabel(box4, "Elastic net mixing:")
box5 = gui.hBox(box4)
gui.widgetLabel(box5, "L1")
self.l1_ratio_slider = gui.hSlider(
box5, self, "l1_ratio", minValue=0.01, maxValue=0.99,
intOnly=False, ticks=0.1, createLabel=False, width=120,
step=0.01, callback=self._l1_ratio_changed)
gui.widgetLabel(box5, "L2")
self.l1_ratio_label = gui.widgetLabel(
box4, "",
sizePolicy=(QSizePolicy.MinimumExpanding, QSizePolicy.Fixed))
self.l1_ratio_label.setAlignment(Qt.AlignCenter)
def __init__(self):
super().__init__()
self.data = None
self.file_att = None # attribute with image file names
self.origin = None # origin of image files
box = gui.widgetBox(self.controlArea, "Info")
self.info_a = gui.widgetLabel(box, "No data on input.")
self.info_b = gui.widgetLabel(box, "")
box = gui.widgetBox(self.controlArea, "Server Token")
gui.lineEdit(box, self, "token", "Token: ",
controlWidth=250, orientation=Qt.Horizontal,
enterPlaceholder=True, callback=self.token_name_changed)
gui.button(
box, self, "Get Token",
callback=self.open_server_token_page,
autoDefault=False
)
self.controlArea.setMinimumWidth(self.controlArea.sizeHint().width())
self.layout().setSizeConstraint(QtGui.QLayout.SetFixedSize)
self.commit_box = gui.auto_commit(
self.controlArea, self, "auto_commit", label="Commit",
checkbox_label="Commit on change"
)
self.commit_box.setEnabled(False)
self.profiler = ImageProfiler(token=self.token)
if self.token:
self.profiler.set_token(self.token)
self.set_info()
def __init__(self):
super().__init__()
self.data = None
self.reference = None
box = gui.vBox(self.controlArea, "Info")
self.data_info_label = gui.widgetLabel(box, self._data_info_default)
self.ref_info_label = gui.widgetLabel(box, self._ref_info_default)
box = gui.vBox(self.controlArea, "Settings")
self.distance_combo = gui.comboBox(
box, self, "distance_index", orientation=Qt.Horizontal,
label="Distance: ", items=[d[0] for d in METRICS],
callback=self.settings_changed)
check_box = gui.hBox(box)
self.exclude_ref_label = gui.label(
check_box, self, "Exclude references:")
self.exclude_ref_check = gui.checkBox(
check_box, self, "exclude_reference", label="",
callback=self.settings_changed)
box = gui.vBox(self.controlArea, "Output")
self.nn_spin = gui.spin(
box, self, "n_neighbors", label="Neighbors:", step=1, spinType=int,
minv=0, maxv=100, callback=self.settings_changed)
box = gui.hBox(self.controlArea, True)
self.apply_button = gui.auto_commit(box, self, "auto_apply", "&Apply",
box=False, commit=self.apply)
def __init__(self):
# pylint: disable=missing-docstring
super().__init__()
self.data = self.discrete_data = None
self.attrs = []
self.input_features = None
self.areas = []
self.selection = set()
self.attr_box = gui.hBox(self.mainArea)
self.domain_model = DomainModel(valid_types=DomainModel.PRIMITIVE)
combo_args = dict(
widget=self.attr_box, master=self, contentsLength=12,
callback=self.update_attr, sendSelectedValue=True, valueType=str,
model=self.domain_model)
fixed_size = (QSizePolicy.Fixed, QSizePolicy.Fixed)
gui.comboBox(value="attr_x", **combo_args)
gui.widgetLabel(self.attr_box, "\u2715", sizePolicy=fixed_size)
gui.comboBox(value="attr_y", **combo_args)
self.vizrank, self.vizrank_button = SieveRank.add_vizrank(
self.attr_box, self, "Score Combinations", self.set_attr)
self.vizrank_button.setSizePolicy(*fixed_size)
self.canvas = QGraphicsScene()
self.canvasView = ViewWithPress(
self.canvas, self.mainArea, handler=self.reset_selection)
self.mainArea.layout().addWidget(self.canvasView)
self.canvasView.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.canvasView.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
def __init__(self):
super().__init__()
# GUI
box = gui.widgetBox(self.controlArea, "Info")
self.infoa = gui.widgetLabel(box, 'No data on input yet, waiting to get something.')
self.infob = gui.widgetLabel(box, '')
def __init__(self):
super().__init__()
self.data = None
self._effective_data = None
self._matrix = None
self._silhouette = None
self._labels = None
self._silplot = None
gui.comboBox(
self.controlArea, self, "distance_idx", box="Distance",
items=[name for name, _ in OWSilhouettePlot.Distances],
orientation=Qt.Horizontal, callback=self._invalidate_distances)
box = gui.vBox(self.controlArea, "Cluster Label")
self.cluster_var_cb = gui.comboBox(
box, self, "cluster_var_idx", addSpace=4,
callback=self._invalidate_scores)
gui.checkBox(
box, self, "group_by_cluster", "Group by cluster",
callback=self._replot)
self.cluster_var_model = itemmodels.VariableListModel(parent=self)
self.cluster_var_cb.setModel(self.cluster_var_model)
box = gui.vBox(self.controlArea, "Bars")
gui.widgetLabel(box, "Bar width:")
gui.hSlider(
box, self, "bar_size", minValue=1, maxValue=10, step=1,
callback=self._update_bar_size, addSpace=6)
gui.widgetLabel(box, "Annotations:")
self.annotation_cb = gui.comboBox(
box, self, "annotation_var_idx", callback=self._update_annotations)
self.annotation_var_model = itemmodels.VariableListModel(parent=self)
self.annotation_var_model[:] = ["None"]
self.annotation_cb.setModel(self.annotation_var_model)
ibox = gui.indentedBox(box, 5)
self.ann_hidden_warning = warning = gui.widgetLabel(
ibox, "(increase the width to show)")
ibox.setFixedWidth(ibox.sizeHint().width())
warning.setVisible(False)
gui.rubber(self.controlArea)
gui.separator(self.buttonsArea)
box = gui.vBox(self.buttonsArea, "Output")
# Thunk the call to commit to call conditional commit
gui.checkBox(box, self, "add_scores", "Add silhouette scores",
callback=lambda: self.commit())
gui.auto_commit(
box, self, "auto_commit", "Commit",
auto_label="Auto commit", box=False)
# Ensure that the controlArea is not narrower than buttonsArea
self.controlArea.layout().addWidget(self.buttonsArea)
self.scene = QtGui.QGraphicsScene()
self.view = QtGui.QGraphicsView(self.scene)
self.view.setRenderHint(QtGui.QPainter.Antialiasing, True)
self.view.setAlignment(Qt.AlignTop | Qt.AlignLeft)
self.mainArea.layout().addWidget(self.view)
def __init__(self, parent, rgbColors):
super().__init__(parent)
self.setCaption("Palette Editor")
self.setLayout(QVBoxLayout(self))
self.layout().setMargin(4)
hbox = gui.widgetBox(self, "Information" , orientation = 'horizontal')
gui.widgetLabel(hbox, '<p align="center">You can reorder colors in the list using the<br>buttons on the right or by dragging and dropping the items.<br>To change a specific color double click the item in the list.</p>')
hbox = gui.widgetBox(self, 1, orientation = 'horizontal')
self.discListbox = gui.listBox(hbox, self, enableDragDrop = 1)
vbox = gui.widgetBox(hbox, orientation = 'vertical')
buttonUPAttr = gui.button(vbox, self, "", callback = self.moveAttrUP, tooltip="Move selected colors up")
buttonDOWNAttr = gui.button(vbox, self, "", callback = self.moveAttrDOWN, tooltip="Move selected colors down")
buttonUPAttr.setIcon(QIcon(os.path.join(self.widgetDir, "icons/Dlg_up3.png")))
buttonUPAttr.setSizePolicy(QSizePolicy(QSizePolicy.Fixed , QSizePolicy.Expanding))
buttonUPAttr.setMaximumWidth(30)
buttonDOWNAttr.setIcon(QIcon(os.path.join(self.widgetDir, "icons/Dlg_down3.png")))
buttonDOWNAttr.setSizePolicy(QSizePolicy(QSizePolicy.Fixed , QSizePolicy.Expanding))
buttonDOWNAttr.setMaximumWidth(30)
self.connect(self.discListbox, QtCore.SIGNAL("itemDoubleClicked ( QListWidgetItem *)"), self.changeDiscreteColor)
box = gui.widgetBox(self, 1, orientation = "horizontal")
gui.button(box, self, "OK", self.accept)
gui.button(box, self, "Cancel", self.reject)
self.discListbox.setIconSize(QtCore.QSize(25, 25))
for ind, (r,g,b) in enumerate(rgbColors):
item = QListWidgetItem(ColorPixmap(QColor(r,g,b), 25), "Color %d" % (ind+1))
item.rgbColor = (r,g,b)
self.discListbox.addItem(item)
self.resize(300, 300)
def __init__(self):
super().__init__()
# sets self.curvePoints, self.steps equidistant points from
# 1/self.steps to 1
self.updateCurvePoints()
# [start-snippet-2]
self.scoring = [
("Classification Accuracy", Orange.evaluation.scoring.CA),
("AUC", Orange.evaluation.scoring.AUC),
("Precision", Orange.evaluation.scoring.Precision),
("Recall", Orange.evaluation.scoring.Recall)
]
# [end-snippet-2]
#: input data on which to construct the learning curve
self.data = None
#: A {input_id: Learner} mapping of current learners from input channel
self.learners = OrderedDict()
#: A {input_id: List[Results]} mapping of input id to evaluation
#: results list, one for each curve point
self.results = OrderedDict()
#: A {input_id: List[float]} mapping of input id to learning curve
#: point scores
self.curves = OrderedDict()
# GUI
box = gui.widgetBox(self.controlArea, "Info")
self.infoa = gui.widgetLabel(box, 'No data on input.')
self.infob = gui.widgetLabel(box, 'No learners.')
gui.separator(self.controlArea)
box = gui.widgetBox(self.controlArea, "Evaluation Scores")
gui.comboBox(box, self, "scoringF",
items=[x[0] for x in self.scoring],
callback=self._invalidate_curves)
gui.separator(self.controlArea)
box = gui.widgetBox(self.controlArea, "Options")
gui.spin(box, self, 'folds', 2, 100, step=1,
label='Cross validation folds: ', keyboardTracking=False,
callback=lambda:
self._invalidate_results() if self.commitOnChange else None
)
gui.spin(box, self, 'steps', 2, 100, step=1,
label='Learning curve points: ', keyboardTracking=False,
callback=[self.updateCurvePoints,
lambda: self._invalidate_results() if self.commitOnChange else None])
gui.checkBox(box, self, 'commitOnChange', 'Apply setting on any change')
self.commitBtn = gui.button(box, self, "Apply Setting",
callback=self._invalidate_results,
disabled=True)
gui.rubber(self.controlArea)
# table widget
self.table = gui.table(self.mainArea,
selectionMode=QTableWidget.NoSelection)
def __init__(self):
super().__init__()
self.data = None
self.reference = None
self.distances = None
box = gui.vBox(self.controlArea, "Info")
self.data_info_label = gui.widgetLabel(box, "")
self.reference_info_label = gui.widgetLabel(box, "")
self._set_label_text("data")
self._set_label_text("reference")
box = gui.vBox(self.controlArea, box=True)
gui.comboBox(
box, self, "distance_index", orientation=Qt.Horizontal,
label="Distance: ", items=[d[0] for d in METRICS],
callback=self.recompute)
gui.spin(
box, self, "n_neighbors", label="Number of neighbors:",
step=1, spinType=int, minv=0, maxv=100, callback=self.apply)
gui.checkBox(
box, self, "exclude_reference",
label="Exclude rows (equal to) references",
callback=self.apply)
self.apply_button = gui.auto_commit(
self.controlArea, self, "auto_apply", "&Apply", commit=self.apply)
def __init__(self):
super().__init__()
self.data = None
self.input_features = None
self.attrs = []
self.attr_box = gui.hBox(self.mainArea)
model = VariableListModel()
model.wrap(self.attrs)
self.attrXCombo = gui.comboBox(
self.attr_box, self, value="attrX", contentsLength=12,
callback=self.change_attr, sendSelectedValue=True, valueType=str)
self.attrXCombo.setModel(model)
gui.widgetLabel(self.attr_box, "\u2715").\
setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.attrYCombo = gui.comboBox(
self.attr_box, self, value="attrY", contentsLength=12,
callback=self.change_attr, sendSelectedValue=True, valueType=str)
self.attrYCombo.setModel(model)
self.canvas = QGraphicsScene()
self.canvasView = ViewWithPress(self.canvas, self.mainArea,
handler=self.reset_selection)
self.mainArea.layout().addWidget(self.canvasView)
self.canvasView.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.canvasView.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
box = gui.hBox(self.mainArea)
box.layout().addWidget(self.graphButton)
box.layout().addWidget(self.report_button)
def __init__(self):
super().__init__()
self.data = {} # key: id, value: ExampleTable
self.dist_color = QtGui.QColor(*self.dist_color_RGB)
self.locale = QtCore.QLocale()
info_box = gui.widgetBox(self.controlArea, "Info")
self.info_ex = gui.widgetLabel(info_box, 'No data on input.', )
self.info_ex.setWordWrap(True)
self.info_attr = gui.widgetLabel(info_box, ' ')
self.info_attr.setWordWrap(True)
self.info_class = gui.widgetLabel(info_box, ' ')
self.info_class.setWordWrap(True)
self.info_meta = gui.widgetLabel(info_box, ' ')
self.info_meta.setWordWrap(True)
gui.separator(info_box)
gui.button(info_box, self, "Restore Original Order",
callback=self.reset_sort_clicked,
tooltip="Show rows in the original order")
info_box.setMinimumWidth(200)
gui.separator(self.controlArea)
box = gui.widgetBox(self.controlArea, "Variables")
self.c_show_attribute_labels = gui.checkBox(
box, self, "show_attribute_labels",
"Show variable labels (if present)",
callback=self.c_show_attribute_labels_clicked)
self.c_show_attribute_labels.setEnabled(True)
gui.checkBox(box, self, "show_distributions",
'Visualize continuous values',
callback=self.cb_show_distributions)
gui.checkBox(box, self, "color_by_class", 'Color by instance classes',
callback=self.cb_show_distributions)
gui.button(box, self, "Set colors", self.set_colors,
tooltip="Set the background color and color palette")
gui.separator(self.controlArea)
selection_box = gui.widgetBox(self.controlArea, "Selection")
self.send_button = gui.button(selection_box, self, "Send selections",
self.commit, default=True)
cb = gui.checkBox(selection_box, self, "auto_commit",
"Commit on any change", callback=self.commit_if)
gui.setStopper(self, self.send_button, cb, "selectionChangedFlag",
self.commit)
gui.rubber(self.controlArea)
dlg = self.create_color_dialog()
self.discPalette = dlg.getDiscretePalette("discPalette")
# GUI with tabs
self.tabs = gui.tabWidget(self.mainArea)
self.tabs.sizeHint = lambda: QtCore.QSize(600,500)
self.id2table = {} # key: widget id, value: table
self.table2id = {} # key: table, value: widget id
self.tabs.currentChanged.connect(self.tab_clicked)
self.selectionChangedFlag = False
def __init__(self, parent=None):
super().__init__(parent)
self.inputs = OrderedDict()
self.dist_color = QtGui.QColor(*self.dist_color_RGB)
info_box = gui.widgetBox(self.controlArea, "Info")
self.info_ex = gui.widgetLabel(info_box, 'No data on input.', )
self.info_ex.setWordWrap(True)
self.info_attr = gui.widgetLabel(info_box, ' ')
self.info_attr.setWordWrap(True)
self.info_class = gui.widgetLabel(info_box, ' ')
self.info_class.setWordWrap(True)
self.info_meta = gui.widgetLabel(info_box, ' ')
self.info_meta.setWordWrap(True)
gui.separator(info_box)
gui.button(info_box, self, "Restore Original Order",
callback=self.restore_order,
tooltip="Show rows in the original order",
autoDefault=False)
info_box.setMinimumWidth(200)
gui.separator(self.controlArea)
box = gui.widgetBox(self.controlArea, "Variables")
self.c_show_attribute_labels = gui.checkBox(
box, self, "show_attribute_labels",
"Show variable labels (if present)",
callback=self._on_show_variable_labels_changed)
gui.checkBox(box, self, "show_distributions",
'Visualize continuous values',
callback=self._on_distribution_color_changed)
gui.checkBox(box, self, "color_by_class", 'Color by instance classes',
callback=self._on_distribution_color_changed)
gui.button(box, self, "Set colors", self.set_colors, autoDefault=False,
tooltip="Set the background color and color palette")
box = gui.widgetBox(self.controlArea, "Selection")
gui.checkBox(box, self, "select_rows", "Select full rows",
callback=self._on_select_rows_changed)
gui.rubber(self.controlArea)
gui.auto_commit(self.controlArea, self, "auto_commit",
"Send Selected Rows", "Auto send is on")
dlg = self.create_color_dialog()
self.discPalette = dlg.getDiscretePalette("discPalette")
# GUI with tabs
self.tabs = gui.tabWidget(self.mainArea)
self.tabs.currentChanged.connect(self._on_current_tab_changed)
copy = QtGui.QAction("Copy", self, shortcut=QtGui.QKeySequence.Copy,
triggered=self.copy)
self.addAction(copy)
def __init__(self):
super().__init__()
self.data = None
self.groups = None
self.CVSettings = (self.stratified, self.numberOfFolds)
infoBox = gui.widgetBox(self.controlArea, "Information")
self.dataInfoLabel = gui.widgetLabel(infoBox, 'No data on input.')
self.outputInfoLabel = gui.widgetLabel(infoBox, ' ')
optionsBox = gui.widgetBox(self.controlArea, "Options")
le = gui.lineEdit(optionsBox, self, "randomSeed", "Random seed: ",
orientation=0, controlWidth=60,
validator=QtGui.QIntValidator())
s = le.sizeHint().height() - 2
b = gui.toolButton(le.box, self, width=s, height=s,
callback=lambda: le.setText(""))
b.setIcon(b.style().standardIcon(b.style().SP_DialogCancelButton))
gui.rubber(le.box)
gui.checkBox(optionsBox, self, "stratified", "Stratified, if possible")
sampling = gui.radioButtons(
self.controlArea, self, "samplingType", box="Sampling type",
addSpace=True)
gui.appendRadioButton(sampling, "Random Sampling:")
indRndSmpl = gui.indentedBox(sampling)
sizeType = gui.radioButtons(
indRndSmpl, self, "sampleSizeType",
callback=lambda: self.chooseSampling(0))
gui.appendRadioButton(sizeType, "Sample size:", insertInto=indRndSmpl)
self.sampleSizeSpin = gui.spin(
gui.indentedBox(indRndSmpl), self, "sampleSizeNumber",
1, 1000000000, callback=[lambda: self.chooseSampling(0),
lambda: self.chooseSizeType(0)])
gui.appendRadioButton(sizeType, "Sample proportions:",
insertInto=indRndSmpl)
gui.hSlider(gui.indentedBox(indRndSmpl), self,
"sampleSizePercentage",
minValue=1, maxValue=100, ticks=10, labelFormat="%d%%",
callback=[lambda: self.chooseSampling(0),
lambda: self.chooseSizeType(1)])
gui.appendRadioButton(sampling, "Cross Validation:")
crossValidIndent = gui.indentedBox(sampling)
gui.spin(
crossValidIndent, self, "numberOfFolds", 2, 100,
label="Number of folds:",
callback=[self.updateSelectedFoldSpin,
lambda: self.chooseSampling(1)])
self.selectedFoldSpin = gui.spin(
crossValidIndent, self, "selectedFold", 1, 100,
label="Selected fold:",
callback=[self.updateSelectedFoldSpin,
lambda: self.chooseSampling(1)])
gui.button(self.controlArea, self, "Sample Data",
callback=self.sendData)
def _insert_warning_bar(self):
self.warning_bar = gui.hBox(self, spacing=0)
self.warning_icon = gui.widgetLabel(self.warning_bar, "")
self.warning_label = gui.widgetLabel(self.warning_bar, "")
self.warning_label.setStyleSheet("padding-top: 5px")
self.warning_bar.setSizePolicy(QSizePolicy.Ignored, QSizePolicy.Maximum)
gui.rubber(self.warning_bar)
self.warning_bar.setVisible(False)
def __init__(self):
super().__init__()
# data
self.dataA = None
self.dataB = None
# GUI
w = QtGui.QWidget(self)
self.controlArea.layout().addWidget(w)
grid = QtGui.QGridLayout()
grid.setContentsMargins(0, 0, 0, 0)
w.setLayout(grid)
# attribute A selection
boxAttrA = gui.widgetBox(
self, self.tr("Attribute A"), addToLayout=False)
grid.addWidget(boxAttrA, 0, 0)
self.attrViewA = QtGui.QListView(
selectionMode=QtGui.QListView.SingleSelection
)
self.attrModelA = itemmodels.VariableListModel()
self.attrViewA.setModel(self.attrModelA)
self.attrViewA.selectionModel().selectionChanged.connect(
self._selectedAttrAChanged)
boxAttrA.layout().addWidget(self.attrViewA)
# attribute B selection
boxAttrB = gui.widgetBox(
self, self.tr("Attribute B"), addToLayout=False)
grid.addWidget(boxAttrB, 0, 1)
self.attrViewB = QtGui.QListView(
selectionMode=QtGui.QListView.SingleSelection
)
self.attrModelB = itemmodels.VariableListModel()
self.attrViewB.setModel(self.attrModelB)
self.attrViewB.selectionModel().selectionChanged.connect(
self._selectedAttrBChanged)
boxAttrB.layout().addWidget(self.attrViewB)
# info A
boxDataA = gui.widgetBox(
self, self.tr("Data A Input"), addToLayout=False)
grid.addWidget(boxDataA, 1, 0)
self.infoBoxDataA = gui.widgetLabel(boxDataA, self.dataInfoText(None))
# info B
boxDataB = gui.widgetBox(
self, self.tr("Data B Input"), addToLayout=False)
grid.addWidget(boxDataB, 1, 1)
self.infoBoxDataB = gui.widgetLabel(boxDataB, self.dataInfoText(None))
# resize
self.resize(400, 500)
def __init__(self):
super().__init__()
self.old_purge_classes = True
self.conditions = []
self.last_output_conditions = None
self.data = None
self.data_desc = self.match_desc = self.nonmatch_desc = None
box = gui.widgetBox(self.controlArea, 'Conditions', stretch=100)
self.cond_list = QtGui.QTableWidget(box)
box.layout().addWidget(self.cond_list)
self.cond_list.setShowGrid(False)
self.cond_list.setSelectionMode(QtGui.QTableWidget.NoSelection)
self.cond_list.setColumnCount(3)
self.cond_list.setRowCount(0)
self.cond_list.verticalHeader().hide()
self.cond_list.horizontalHeader().hide()
self.cond_list.resizeColumnToContents(0)
self.cond_list.horizontalHeader().setResizeMode(
QtGui.QHeaderView.Stretch)
self.cond_list.viewport().setBackgroundRole(QtGui.QPalette.Window)
box2 = gui.widgetBox(box, orientation="horizontal")
self.add_button = gui.button(box2, self, "Add condition",
callback=self.add_row)
self.add_all_button = gui.button(box2, self, "Add all variables",
callback=self.add_all)
self.remove_all_button = gui.button(box2, self, "Remove all",
callback=self.remove_all)
gui.rubber(box2)
info = gui.widgetBox(self.controlArea, '', orientation="horizontal")
box_data_in = gui.widgetBox(info, 'Data In')
# self.data_in_rows = gui.widgetLabel(box_data_in, " ")
self.data_in_variables = gui.widgetLabel(box_data_in, " ")
gui.rubber(box_data_in)
box_data_out = gui.widgetBox(info, 'Data Out')
self.data_out_rows = gui.widgetLabel(box_data_out, " ")
# self.dataOutAttributesLabel = gui.widgetLabel(box_data_out, " ")
gui.rubber(box_data_out)
box = gui.widgetBox(self.controlArea, orientation="horizontal")
box_setting = gui.widgetBox(box, 'Purging')
self.cb_pa = gui.checkBox(
box_setting, self, "purge_attributes", "Remove unused features",
callback=self.conditions_changed)
gui.separator(box_setting, height=1)
self.cb_pc = gui.checkBox(
box_setting, self, "purge_classes", "Remove unused classes",
callback=self.conditions_changed)
gui.auto_commit(box, self, "auto_commit", label="Commit",
checkbox_label="Commit on change")
self.set_data(None)
self.resize(600, 400)
def __init__(self):
super().__init__()
self.old_purge_classes = True
self.conditions = []
self.last_output_conditions = None
box = gui.widgetBox(self.controlArea, 'Conditions', stretch=100)
self.cond_list = QtGui.QTableWidget(box)
box.layout().addWidget(self.cond_list)
self.cond_list.setShowGrid(False)
self.cond_list.setSelectionMode(QtGui.QTableWidget.NoSelection)
self.cond_list.setColumnCount(3)
self.cond_list.setRowCount(0)
self.cond_list.verticalHeader().hide()
self.cond_list.horizontalHeader().hide()
self.cond_list.resizeColumnToContents(0)
self.cond_list.horizontalHeader().setResizeMode(
QtGui.QHeaderView.Stretch)
self.cond_list.viewport().setBackgroundRole(QtGui.QPalette.Window)
box2 = gui.widgetBox(box, orientation="horizontal")
self.add_button = gui.button(box2, self, "Add condition",
callback=self.add_row)
self.add_all_button = gui.button(box2, self, "Add all variables",
callback=self.add_all)
self.remove_all_button = gui.button(box2, self, "Remove all",
callback=self.remove_all)
gui.rubber(box2)
info = gui.widgetBox(self.controlArea, '', orientation="horizontal")
box_data_in = gui.widgetBox(info, 'Data In')
# self.data_in_rows = gui.widgetLabel(box_data_in, " ")
self.data_in_variables = gui.widgetLabel(box_data_in, " ")
gui.rubber(box_data_in)
box_data_out = gui.widgetBox(info, 'Data Out')
self.data_out_rows = gui.widgetLabel(box_data_out, " ")
# self.dataOutAttributesLabel = gui.widgetLabel(box_data_out, " ")
gui.rubber(box_data_out)
box = gui.widgetBox(self.controlArea, orientation="horizontal")
box_setting = gui.widgetBox(box, 'Purging')
cb = gui.checkBox(box_setting, self, "purge_attributes",
"Remove unused values/features",
callback=self.on_purge_change)
self.purgeClassesCB = gui.checkBox(
gui.indentedBox(box_setting, sep=gui.checkButtonOffsetHint(cb)),
self, "purge_classes", "Remove unused classes",
callback=self.on_purge_change)
box_commit = gui.widgetBox(box, 'Commit')
gui.checkBox(box_commit, self, "update_on_change", "Commit on change")
gui.button(box_commit, self, "Commit", self.output_data, default=True)
self.set_data(None)
self.resize(600, 400)
def _setup_layout(self):
self.controlArea.setMinimumWidth(self.controlArea.sizeHint().width())
self.layout().setSizeConstraint(QLayout.SetFixedSize)
widget_box = widgetBox(self.controlArea, 'Info')
self.input_data_info = widgetLabel(widget_box, self._NO_DATA_INFO_TEXT)
self.connection_info = widgetLabel(widget_box, "")
widget_box = widgetBox(self.controlArea, 'Settings')
self.cb_image_attr = comboBox(
widget=widget_box,
master=self,
value='cb_image_attr_current_id',
label='Image attribute:',
orientation=Qt.Horizontal,
callback=self._cb_image_attr_changed
)
self.cb_embedder = comboBox(
widget=widget_box,
master=self,
value='cb_embedder_current_id',
label='Embedder:',
orientation=Qt.Horizontal,
callback=self._cb_embedder_changed
)
names = [EMBEDDERS_INFO[e]['name'] +
(" (local)" if EMBEDDERS_INFO[e].get("is_local") else "")
for e in self.embedders]
self.cb_embedder.setModel(VariableListModel(names))
if not self.cb_embedder_current_id < len(self.embedders):
self.cb_embedder_current_id = 0
self.cb_embedder.setCurrentIndex(self.cb_embedder_current_id)
current_embedder = self.embedders[self.cb_embedder_current_id]
self.embedder_info = widgetLabel(
widget_box,
EMBEDDERS_INFO[current_embedder]['description']
)
self.auto_commit_widget = auto_commit(
widget=self.controlArea,
master=self,
value='_auto_apply',
label='Apply',
commit=self.commit
)
self.cancel_button = QPushButton(
'Cancel',
icon=self.style().standardIcon(QStyle.SP_DialogCancelButton),
)
self.cancel_button.clicked.connect(self.cancel)
hbox = hBox(self.controlArea)
hbox.layout().addWidget(self.cancel_button)
self.cancel_button.setDisabled(True)
def __init__(self):
super().__init__()
self.data = None
self.preprocessors = None
box = gui.widgetBox(self.controlArea, "Learner/Predictor Name")
gui.lineEdit(box, self, "learner_name")
box = gui.widgetBox(self.controlArea, "Regularization",
orientation="horizontal")
gui.radioButtons(
box, self, "reg_type",
btnLabels=["No regularization", "Ridge regression (L2)",
"Lasso regression (L1)", "Elastic net regression"],
callback=self._reg_type_changed)
gui.separator(box, 20, 20)
self.alpha_box = box2 = gui.widgetBox(box, margin=0)
gui.widgetLabel(box2, "Regularization strength")
self.alpha_slider = gui.hSlider(
box2, self, "alpha_index",
minValue=0, maxValue=len(self.alphas) - 1,
callback=self._alpha_changed, createLabel=False)
box3 = gui.widgetBox(box2, orientation="horizontal")
box3.layout().setAlignment(Qt.AlignCenter)
self.alpha_label = gui.widgetLabel(box3, "")
self._set_alpha_label()
gui.separator(box2, 10, 10)
box4 = gui.widgetBox(box2, margin=0)
gui.widgetLabel(box4, "Elastic net mixing")
box5 = gui.widgetBox(box4, orientation="horizontal")
gui.widgetLabel(box5, "L1")
self.l1_ratio_slider = gui.hSlider(
box5, self, "l1_ratio", minValue=0.01, maxValue=1,
intOnly=False, ticks=0.1, createLabel=False,
step=0.01, callback=self._l1_ratio_changed)
gui.widgetLabel(box5, "L2")
box5 = gui.widgetBox(box4, orientation="horizontal")
box5.layout().setAlignment(Qt.AlignCenter)
self.l1_ratio_label = gui.widgetLabel(box5, "")
self._set_l1_ratio_label()
auto_commit = gui.auto_commit(
self.controlArea, self, "autosend",
"Apply", auto_label="Apply on change")
gui.separator(box, 20)
auto_commit.layout().addWidget(self.report_button)
self.report_button.setMinimumWidth(150)
self.layout().setSizeConstraint(QLayout.SetFixedSize)
self.alpha_slider.setEnabled(self.reg_type != self.OLS)
self.l1_ratio_slider.setEnabled(self.reg_type == self.Elastic)
self.commit()
def __init__(self, parent=None, windowTitle="Color Palette List",
**kwargs):
super().__init__(parent, windowTitle=windowTitle, **kwargs)
self.setLayout(QVBoxLayout())
self.layout().setMargin(0)
sa = QScrollArea(
horizontalScrollBarPolicy=Qt.ScrollBarAlwaysOff,
verticalScrollBarPolicy=Qt.ScrollBarAlwaysOn
)
sa.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
sa.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOn)
self.layout().addWidget(sa)
space = QWidget(self)
space.setLayout(QVBoxLayout())
sa.setWidget(space)
sa.setWidgetResizable(True)
self.buttons = []
self.setMinimumWidth(400)
box = gui.widgetBox(space, "Information", addSpace=True)
gui.widgetLabel(
box,
'<p align="center">This dialog shows a list of predefined '
'color palettes <br>from colorbrewer.org that can be used '
'in Orange.<br/>You can select a palette by clicking on it.</p>'
)
box = gui.widgetBox(space, "Default Palette", addSpace=True)
butt = _ColorButton(
DefaultRGBColors, flat=True, toolTip="Default color palette",
clicked=self._buttonClicked
)
box.layout().addWidget(butt)
self.buttons.append(butt)
for type in ["Qualitative", "Spectral", "Diverging", "Sequential", "Pastels"]:
colorGroup = colorbrewer.colorSchemes.get(type.lower(), {})
if colorGroup:
box = gui.widgetBox(space, type + " Palettes", addSpace=True)
items = sorted(colorGroup.items())
for key, colors in items:
butt = _ColorButton(colors, self, toolTip=key, flat=True,
clicked=self._buttonClicked)
box.layout().addWidget(butt)
self.buttons.append(butt)
buttons = QDialogButtonBox(
QDialogButtonBox.Cancel, rejected=self.reject
)
self.layout().addWidget(buttons)
self.selectedColors = None
def __init__(self):
super().__init__()
self.data = None # type: Optional[Table]
self.template_domain = None # type: Optional[Domain]
self.transformed_info = describe_data(None) # type: OrderedDict
info_box = gui.widgetBox(self.controlArea, "Info")
self.input_label = gui.widgetLabel(info_box, "")
self.template_label = gui.widgetLabel(info_box, "")
self.output_label = gui.widgetLabel(info_box, "")
self.set_input_label_text()
self.set_template_label_text()
def insert_message_bar(self):
"""Insert message bar into the widget.
This method must be called at the appropriate place in the widget
layout setup by any widget that is using this mixin."""
self.message_bar = gui.hBox(self, spacing=0)
self.message_icon = gui.widgetLabel(self.message_bar, "")
self.message_label = gui.widgetLabel(self.message_bar, "")
self.message_label.setStyleSheet("padding-top: 5px")
self.message_bar.setSizePolicy(QSizePolicy.Ignored, QSizePolicy.Maximum)
gui.rubber(self.message_bar)
self.message_bar.setVisible(False)
def __init__(self):
super().__init__()
self.data = None
self.preprocessor = None
self.transformed_data = None
info_box = gui.widgetBox(self.controlArea, "Info")
self.input_label = gui.widgetLabel(info_box, "")
self.preprocessor_label = gui.widgetLabel(info_box, "")
self.output_label = gui.widgetLabel(info_box, "")
self.set_input_label_text()
self.set_preprocessor_label_text()
def __init__(self):
super().__init__()
self.domain = None
self.graph = None
self.auto_items = None
self.filename = '(none)'
self.dataname = '(none)'
self.edgesname = '(none)'
#GUI
self.controlArea.layout().setMargin(4)
self.box = gui.widgetBox(self.controlArea, box="Graph File", orientation="vertical")
hb = gui.widgetBox(self.box, orientation="horizontal")
self.filecombo = gui.comboBox(hb, self, "filename")
self.filecombo.setMinimumWidth(250)
button = gui.button(hb, self, '...', callback=self.browseNetFile, disabled=0)
button.setIcon(self.style().standardIcon(QStyle.SP_DirOpenIcon))
button.setSizePolicy(QSizePolicy.Maximum, QSizePolicy.Fixed)
gui.checkBox(self.box, self, "auto_table", "Build graph data table automatically", callback=lambda: self.selectNetFile(self.filecombo.currentIndex()))
self.databox = gui.widgetBox(self.controlArea, box="Vertices Data File", orientation="horizontal")
self.datacombo = gui.comboBox(self.databox, self, "dataname")
self.datacombo.setMinimumWidth(250)
button = gui.button(self.databox, self, '...', callback=self.browseDataFile, disabled=0)
button.setIcon(self.style().standardIcon(QStyle.SP_DirOpenIcon))
button.setSizePolicy(QSizePolicy.Maximum, QSizePolicy.Fixed)
self.edgesbox = gui.widgetBox(self.controlArea, box="Edges Data File", orientation="horizontal")
self.edgescombo = gui.comboBox(self.edgesbox, self, "edgesname")
self.edgescombo.setMinimumWidth(250)
button = gui.button(self.edgesbox, self, '...', callback=self.browseEdgesFile, disabled=0)
button.setIcon(self.style().standardIcon(QStyle.SP_DirOpenIcon))
button.setSizePolicy(QSizePolicy.Maximum, QSizePolicy.Fixed)
# info
box = gui.widgetBox(self.controlArea, "Info")
self.infoa = gui.widgetLabel(box, 'No data loaded.')
self.infob = gui.widgetLabel(box, ' ')
self.infoc = gui.widgetLabel(box, ' ')
self.infod = gui.widgetLabel(box, ' ')
gui.rubber(self.controlArea)
self.resize(150, 100)
# connecting GUI to code
self.connect(self.filecombo, SIGNAL('activated(int)'), self.selectNetFile)
self.connect(self.datacombo, SIGNAL('activated(int)'), self.selectDataFile)
self.connect(self.edgescombo, SIGNAL('activated(int)'), self.selectEdgesFile)
self.setFileLists()
self.openFile(self.recentFiles[0])
def __init__(self):
super().__init__()
self._inputs = OrderedDict()
self.__pending_selected_rows = self.selected_rows
self.selected_rows = None
self.__pending_selected_cols = self.selected_cols
self.selected_cols = None
self.dist_color = QColor(*self.dist_color_RGB)
info_box = gui.vBox(self.controlArea, "Info")
self.info_ex = gui.widgetLabel(info_box, 'No data on input.', )
self.info_ex.setWordWrap(True)
self.info_attr = gui.widgetLabel(info_box, ' ')
self.info_attr.setWordWrap(True)
self.info_class = gui.widgetLabel(info_box, ' ')
self.info_class.setWordWrap(True)
self.info_meta = gui.widgetLabel(info_box, ' ')
self.info_meta.setWordWrap(True)
info_box.setMinimumWidth(200)
gui.separator(self.controlArea)
box = gui.vBox(self.controlArea, "Variables")
self.c_show_attribute_labels = gui.checkBox(
box, self, "show_attribute_labels",
"Show variable labels (if present)",
callback=self._on_show_variable_labels_changed)
gui.checkBox(box, self, "show_distributions",
'Visualize numeric values',
callback=self._on_distribution_color_changed)
gui.checkBox(box, self, "color_by_class", 'Color by instance classes',
callback=self._on_distribution_color_changed)
box = gui.vBox(self.controlArea, "Selection")
gui.checkBox(box, self, "select_rows", "Select full rows",
callback=self._on_select_rows_changed)
gui.rubber(self.controlArea)
reset = gui.button(
None, self, "Restore Original Order", callback=self.restore_order,
tooltip="Show rows in the original order", autoDefault=False)
self.buttonsArea.layout().insertWidget(0, reset)
gui.auto_commit(self.buttonsArea, self, "auto_commit",
"Send Selected Rows", "Send Automatically")
# GUI with tabs
self.tabs = gui.tabWidget(self.mainArea)
self.tabs.currentChanged.connect(self._on_current_tab_changed)
def __init__(self, parent=None):
widget.OWWidget.__init__(self, parent)
self.min_value, self.max_value = \
self.thresholds.get(self.Scores[self.score_index][0], (1, 0))
#: Input data set
self.data = None
#: Current target group selection
self.targets = []
#: The computed scores
self.scores = None
#: The computed scores from label permutations
self.nulldist = None
self.__scores_future = self.__scores_state = None
self.__in_progress = False
self.test_f = {
OWDifferentialExpression.LowTail: test_low,
OWDifferentialExpression.HighTail: test_high,
OWDifferentialExpression.TwoTail: test_two_tail,
}
self.histogram = Histogram(enableMouse=False,
enableMenu=False,
background="w")
self.histogram.enableAutoRange(enable=False)
self.histogram.getPlotItem().hideButtons() # hide auto range button
self.histogram.getViewBox().setMouseEnabled(False, False)
self.histogram.selectionChanged.connect(
self.__on_histogram_plot_selection_changed)
self.histogram.selectionEdited.connect(self._invalidate_selection)
self.mainArea.layout().addWidget(self.histogram)
box = gui.widgetBox(self.controlArea, "Info")
self.dataInfoLabel = gui.widgetLabel(box, "No data on input.\n")
self.dataInfoLabel.setWordWrap(True)
self.selectedInfoLabel = gui.widgetLabel(box, "\n")
box1 = gui.widgetBox(self.controlArea, "Scoring Method")
gui.comboBox(
box1,
self,
"score_index",
items=[sm[0] for sm in self.Scores],
callback=[self.on_scoring_method_changed, self.update_scores])
box = gui.widgetBox(self.controlArea, "Target Labels")
self.label_selection_widget = guiutils.LabelSelectionWidget(self)
self.label_selection_widget.setMaximumHeight(150)
box.layout().addWidget(self.label_selection_widget)
self.label_selection_widget.groupChanged.connect(
self.on_label_activated)
self.label_selection_widget.groupSelectionChanged.connect(
self.on_target_changed)
box = gui.widgetBox(self.controlArea, "Selection")
box.layout().setSpacing(0)
self.max_value_spin = gui.doubleSpin(box,
self,
"max_value",
minv=-1e6,
maxv=1e6,
step=1e-6,
label="Upper threshold:",
callback=self.update_boundary,
callbackOnReturn=True)
self.low_value_spin = gui.doubleSpin(box,
self,
"min_value",
minv=-1e6,
maxv=1e6,
step=1e-6,
label="Lower threshold:",
callback=self.update_boundary,
callbackOnReturn=True)
check = gui.checkBox(box,
self,
"compute_null",
"Compute null distribution",
callback=self.update_scores)
perm_spin = gui.spin(box,
self,
"permutations_count",
minv=1,
maxv=50,
label="Permutations:",
callback=self.update_scores,
callbackOnReturn=True)
check.disables.append(perm_spin)
box1 = gui.widgetBox(box, orientation='horizontal')
pval_spin = gui.doubleSpin(box1,
self,
"alpha_value",
minv=2e-7,
maxv=1.0,
step=1e-7,
label="α-value:")
pval_select = gui.button(box1,
self,
"Select",
callback=self.select_p_best,
autoDefault=False)
check.disables.append(pval_spin)
check.disables.append(pval_select)
check.makeConsistent()
box1 = gui.widgetBox(box, orientation='horizontal')
gui.spin(box1, self, "n_best", 0, 10000, step=1, label="Best Ranked:")
gui.button(box1,
self,
"Select",
callback=self.select_n_best,
autoDefault=False)
box = gui.widgetBox(self.controlArea, "Output")
acbox = gui.auto_commit(box, self, "auto_commit", "Commit", box=None)
acbox.button.setDefault(True)
gui.checkBox(box,
self,
"add_scores_to_output",
"Add gene scores to output",
callback=self._invalidate_selection)
gui.rubber(self.controlArea)
self.on_scoring_method_changed()
self._executor = concurrent.ThreadExecutor()
def set_new_values(self, oper_combo, adding_all, selected_values=None):
def remove_children():
for child in box.children()[1:]:
box.layout().removeWidget(child)
child.setParent(None)
def add_textual(contents):
le = gui.lineEdit(box, self, None)
if contents:
le.setText(contents)
le.setMaximumWidth(60)
le.setAlignment(Qt.Qt.AlignRight)
le.editingFinished.connect(self.conditions_changed)
return le
def add_numeric(contents):
le = add_textual(contents)
le.setValidator(OWSelectData.QDoubleValidatorEmpty())
return le
var = self.data.domain[oper_combo.attr_combo.currentText()]
box = self.cond_list.cellWidget(oper_combo.row, 2)
if selected_values is not None:
lc = list(selected_values) + ["", ""]
lc = [str(x) for x in lc[:2]]
else:
lc = ["", ""]
if box and vartype(var) == box.var_type:
lc = self._get_lineedit_contents(box) + lc
oper = oper_combo.currentIndex()
if oper == oper_combo.count() - 1:
self.cond_list.removeCellWidget(oper_combo.row, 2)
elif isinstance(var, DiscreteVariable):
combo = QtGui.QComboBox()
combo.addItems([""] + var.values)
if lc[0]:
combo.setCurrentIndex(int(lc[0]))
else:
combo.setCurrentIndex(0)
combo.var_type = vartype(var)
self.cond_list.setCellWidget(oper_combo.row, 2, combo)
combo.currentIndexChanged.connect(self.conditions_changed)
else:
box = gui.widgetBox(self,
orientation="horizontal",
addToLayout=False)
box.var_type = vartype(var)
self.cond_list.setCellWidget(oper_combo.row, 2, box)
if isinstance(var, ContinuousVariable):
box.controls = [add_numeric(lc[0])]
if oper > 5:
gui.widgetLabel(box, " and ")
box.controls.append(add_numeric(lc[1]))
gui.rubber(box)
elif isinstance(var, StringVariable):
box.controls = [add_textual(lc[0])]
if oper in [6, 7]:
gui.widgetLabel(box, " and ")
box.controls.append(add_textual(lc[1]))
else:
box.controls = []
if not adding_all:
self.conditions_changed()
def __init__(self):
super().__init__()
#: Input data table
self.data = None # type: Optional[Orange.data.Table]
#: A dict mapping input ids to PredictorSlot
self.predictors = OrderedDict() # type: Dict[object, PredictorSlot]
#: A class variable (prediction target)
self.class_var = None # type: Optional[Orange.data.Variable]
#: List of (discrete) class variable's values
self.class_values = [] # type: List[str]
box = gui.vBox(self.controlArea, "Info")
self.infolabel = gui.widgetLabel(
box, "No data on input.\nPredictors: 0\nTask: N/A")
self.infolabel.setMinimumWidth(150)
gui.button(box,
self,
"Restore Original Order",
callback=self._reset_order,
tooltip="Show rows in the original order")
self.classification_options = box = gui.vBox(self.controlArea,
"Show",
spacing=-1,
addSpace=False)
gui.checkBox(box,
self,
"show_predictions",
"Predicted class",
callback=self._update_prediction_delegate)
b = gui.checkBox(box,
self,
"show_probabilities",
"Predicted probabilities for:",
callback=self._update_prediction_delegate)
ibox = gui.indentedBox(box,
sep=gui.checkButtonOffsetHint(b),
addSpace=False)
gui.listBox(ibox,
self,
"selected_classes",
"class_values",
callback=self._update_prediction_delegate,
selectionMode=QListWidget.MultiSelection,
addSpace=False)
gui.checkBox(box,
self,
"draw_dist",
"Draw distribution bars",
callback=self._update_prediction_delegate)
box = gui.vBox(self.controlArea, "Data View")
gui.checkBox(box,
self,
"show_attrs",
"Show full dataset",
callback=self._update_column_visibility)
box = gui.vBox(self.controlArea, "Output", spacing=-1)
self.checkbox_class = gui.checkBox(box,
self,
"output_attrs",
"Original data",
callback=self.commit)
self.checkbox_class = gui.checkBox(box,
self,
"output_predictions",
"Predictions",
callback=self.commit)
self.checkbox_prob = gui.checkBox(box,
self,
"output_probabilities",
"Probabilities",
callback=self.commit)
gui.rubber(self.controlArea)
self.splitter = QSplitter(
orientation=Qt.Horizontal,
childrenCollapsible=False,
handleWidth=2,
)
self.dataview = TableView(
verticalScrollBarPolicy=Qt.ScrollBarAlwaysOn,
horizontalScrollBarPolicy=Qt.ScrollBarAlwaysOn,
horizontalScrollMode=QTableView.ScrollPerPixel,
selectionMode=QTableView.NoSelection,
focusPolicy=Qt.StrongFocus)
self.predictionsview = TableView(
verticalScrollBarPolicy=Qt.ScrollBarAlwaysOff,
horizontalScrollBarPolicy=Qt.ScrollBarAlwaysOn,
horizontalScrollMode=QTableView.ScrollPerPixel,
selectionMode=QTableView.NoSelection,
focusPolicy=Qt.StrongFocus,
sortingEnabled=True,
)
self.predictionsview.setItemDelegate(PredictionsItemDelegate())
self.dataview.verticalHeader().hide()
dsbar = self.dataview.verticalScrollBar()
psbar = self.predictionsview.verticalScrollBar()
psbar.valueChanged.connect(dsbar.setValue)
dsbar.valueChanged.connect(psbar.setValue)
self.dataview.verticalHeader().setDefaultSectionSize(22)
self.predictionsview.verticalHeader().setDefaultSectionSize(22)
self.dataview.verticalHeader().sectionResized.connect(
lambda index, _, size: self.predictionsview.verticalHeader(
).resizeSection(index, size))
self.splitter.addWidget(self.predictionsview)
self.splitter.addWidget(self.dataview)
self.mainArea.layout().addWidget(self.splitter)
def __init__(self):
OWWidget.__init__(self)
ConcurrentWidgetMixin.__init__(self)
# ATTRIBUTES #
self.target_database = ENTREZ_ID
# input data
self.input_data = None
self.input_genes = None
self.tax_id = None
self.column_candidates = []
# input options
self.organisms = []
# gene matcher
self.gene_matcher = None
# progress bar
self.progress_bar = None
self._timer = QTimer()
self._timer.timeout.connect(self._apply_filter)
self._timer.setSingleShot(True)
# GUI SECTION #
# Control area
self.info_box = widgetLabel(
widgetBox(self.controlArea, "Info", addSpace=True),
'No data on input.\n')
organism_box = vBox(self.controlArea, 'Organism')
self.organism_select_combobox = comboBox(
organism_box,
self,
'selected_organism',
callback=self.on_input_option_change)
self.get_available_organisms()
self.organism_select_combobox.setCurrentIndex(self.selected_organism)
box = widgetBox(self.controlArea, 'Gene IDs in the input data')
self.gene_columns_model = itemmodels.DomainModel(
valid_types=(StringVariable, DiscreteVariable))
self.gene_column_combobox = comboBox(
box,
self,
'selected_gene_col',
label='Stored in data column',
model=self.gene_columns_model,
sendSelectedValue=True,
callback=self.on_input_option_change,
)
self.attr_names_checkbox = checkBox(
box,
self,
'use_attr_names',
'Stored as feature (column) names',
disables=[(-1, self.gene_column_combobox)],
callback=self.on_input_option_change,
)
self.gene_column_combobox.setDisabled(bool(self.use_attr_names))
output_box = vBox(self.controlArea, 'Output')
# separator(output_box)
# output_box.layout().addWidget(horizontal_line())
# separator(output_box)
self.exclude_radio = checkBox(output_box,
self,
'exclude_unmatched',
'Exclude unmatched genes',
callback=self.commit)
self.replace_radio = checkBox(output_box,
self,
'replace_id_with_symbol',
'Replace feature IDs with gene names',
callback=self.commit)
auto_commit(self.controlArea,
self,
"auto_commit",
"&Commit",
box=False)
rubber(self.controlArea)
# Main area
self.filter = lineEdit(self.mainArea,
self,
'search_pattern',
'Filter:',
callbackOnType=True,
callback=self.handle_filter_callback)
# rubber(self.radio_group)
self.mainArea.layout().addWidget(self.filter)
# set splitter
self.splitter = QSplitter()
self.splitter.setOrientation(Qt.Vertical)
self.table_model = GeneInfoModel()
self.table_view = QTableView()
self.table_view.setAlternatingRowColors(True)
self.table_view.viewport().setMouseTracking(True)
self.table_view.setSortingEnabled(True)
self.table_view.setShowGrid(False)
self.table_view.verticalHeader().hide()
# self.table_view.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
self.unknown_model = UnknownGeneInfoModel()
self.unknown_view = QTableView()
self.unknown_view.setModel(self.unknown_model)
self.unknown_view.verticalHeader().hide()
self.unknown_view.setShowGrid(False)
self.unknown_view.setSelectionMode(QAbstractItemView.NoSelection)
self.unknown_view.horizontalHeader().setSectionResizeMode(
QHeaderView.Stretch)
self.splitter.addWidget(self.table_view)
self.splitter.addWidget(self.unknown_view)
self.splitter.setStretchFactor(0, 90)
self.splitter.setStretchFactor(1, 10)
self.mainArea.layout().addWidget(self.splitter)
def set_new_values(self, oper_combo, adding_all, selected_values=None):
# def remove_children():
# for child in box.children()[1:]:
# box.layout().removeWidget(child)
# child.setParent(None)
def add_textual(contents):
le = gui.lineEdit(box,
self,
None,
sizePolicy=QSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding))
if contents:
le.setText(contents)
le.setAlignment(Qt.AlignRight)
le.editingFinished.connect(self.conditions_changed)
return le
def add_numeric(contents):
le = add_textual(contents)
le.setValidator(OWSelectRows.QDoubleValidatorEmpty())
return le
box = self.cond_list.cellWidget(oper_combo.row, 2)
lc = ["", ""]
oper = oper_combo.currentIndex()
attr_name = oper_combo.attr_combo.currentText()
if attr_name in self.AllTypes:
vtype = self.AllTypes[attr_name]
var = None
else:
var = self.data.domain[attr_name]
var_idx = self.data.domain.index(attr_name)
vtype = vartype(var)
if selected_values is not None:
lc = list(selected_values) + ["", ""]
lc = [str(x) if vtype != 4 else x for x in lc[:2]]
if box and vtype == box.var_type:
lc = self._get_lineedit_contents(box) + lc
if oper_combo.currentText().endswith(" defined"):
label = QLabel()
label.var_type = vtype
self.cond_list.setCellWidget(oper_combo.row, 2, label)
elif var is not None and var.is_discrete:
if oper_combo.currentText().endswith(" one of"):
if selected_values:
lc = list(selected_values)
button = DropDownToolButton(self, var, lc)
button.var_type = vtype
self.cond_list.setCellWidget(oper_combo.row, 2, button)
else:
combo = ComboBoxSearch()
combo.addItems(("", ) + var.values)
if lc[0]:
combo.setCurrentIndex(int(lc[0]))
else:
combo.setCurrentIndex(0)
combo.var_type = vartype(var)
self.cond_list.setCellWidget(oper_combo.row, 2, combo)
combo.currentIndexChanged.connect(self.conditions_changed)
else:
box = gui.hBox(self, addToLayout=False)
box.var_type = vtype
self.cond_list.setCellWidget(oper_combo.row, 2, box)
if vtype == 2: # continuous:
box.controls = [add_numeric(lc[0])]
if oper > 5:
gui.widgetLabel(box, " and ")
box.controls.append(add_numeric(lc[1]))
elif vtype == 3: # string:
box.controls = [add_textual(lc[0])]
if oper in [6, 7]:
gui.widgetLabel(box, " and ")
box.controls.append(add_textual(lc[1]))
elif vtype == 4: # time:
def invalidate_datetime():
if w_:
if w.dateTime() > w_.dateTime():
w_.setDateTime(w.dateTime())
if w.format == (1, 1):
w.calendarWidget.timeedit.setTime(w.time())
w_.calendarWidget.timeedit.setTime(w_.time())
elif w.format == (1, 1):
w.calendarWidget.timeedit.setTime(w.time())
def datetime_changed():
self.conditions_changed()
invalidate_datetime()
datetime_format = (var.have_date, var.have_time)
column = self.data[:, var_idx]
w = DateTimeWidget(self, column, datetime_format)
w.set_datetime(lc[0])
box.controls = [w]
box.layout().addWidget(w)
w.dateTimeChanged.connect(datetime_changed)
if oper > 5:
gui.widgetLabel(box, " and ")
w_ = DateTimeWidget(self, column, datetime_format)
w_.set_datetime(lc[1])
box.layout().addWidget(w_)
box.controls.append(w_)
invalidate_datetime()
w_.dateTimeChanged.connect(datetime_changed)
else:
w_ = None
else:
box.controls = []
if not adding_all:
self.conditions_changed()
def set_new_values(self, oper_combo, adding_all, selected_values=None):
# def remove_children():
# for child in box.children()[1:]:
# box.layout().removeWidget(child)
# child.setParent(None)
def add_textual(contents):
le = gui.lineEdit(box,
self,
None,
sizePolicy=QSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding))
if contents:
le.setText(contents)
le.setAlignment(Qt.AlignRight)
le.editingFinished.connect(self.conditions_changed)
return le
def add_numeric(contents):
le = add_textual(contents)
le.setValidator(OWSelectRows.QDoubleValidatorEmpty())
return le
def add_datetime(contents):
le = add_textual(contents)
le.setValidator(QRegExpValidator(QRegExp(TimeVariable.REGEX)))
return le
box = self.cond_list.cellWidget(oper_combo.row, 2)
lc = ["", ""]
oper = oper_combo.currentIndex()
attr_name = oper_combo.attr_combo.currentText()
if attr_name in self.AllTypes:
vtype = self.AllTypes[attr_name]
var = None
else:
var = self.data.domain[attr_name]
vtype = vartype(var)
if selected_values is not None:
lc = list(selected_values) + ["", ""]
lc = [str(x) for x in lc[:2]]
if box and vtype == box.var_type:
lc = self._get_lineedit_contents(box) + lc
if oper_combo.currentText().endswith(" defined"):
label = QLabel()
label.var_type = vtype
self.cond_list.setCellWidget(oper_combo.row, 2, label)
elif var is not None and var.is_discrete:
if oper_combo.currentText().endswith(" one of"):
if selected_values:
lc = [x for x in list(selected_values)]
button = DropDownToolButton(self, var, lc)
button.var_type = vtype
self.cond_list.setCellWidget(oper_combo.row, 2, button)
else:
combo = ComboBoxSearch()
combo.addItems(("", ) + var.values)
if lc[0]:
combo.setCurrentIndex(int(lc[0]))
else:
combo.setCurrentIndex(0)
combo.var_type = vartype(var)
self.cond_list.setCellWidget(oper_combo.row, 2, combo)
combo.currentIndexChanged.connect(self.conditions_changed)
else:
box = gui.hBox(self, addToLayout=False)
box.var_type = vtype
self.cond_list.setCellWidget(oper_combo.row, 2, box)
if vtype in (2, 4): # continuous, time:
validator = add_datetime if isinstance(
var, TimeVariable) else add_numeric
box.controls = [validator(lc[0])]
if oper > 5:
gui.widgetLabel(box, " and ")
box.controls.append(validator(lc[1]))
elif vtype == 3: # string:
box.controls = [add_textual(lc[0])]
if oper in [6, 7]:
gui.widgetLabel(box, " and ")
box.controls.append(add_textual(lc[1]))
else:
box.controls = []
if not adding_all:
self.conditions_changed()
def __init__(self):
super().__init__()
self.data = None
self.n_inliers = self.n_outliers = None
box = gui.vBox(self.controlArea, "Information")
self.data_info_label = gui.widgetLabel(box, self.data_info_default)
self.in_out_info_label = gui.widgetLabel(box, self.in_out_info_default)
box = gui.vBox(self.controlArea, "Outlier Detection Method")
detection = gui.radioButtons(box, self, "outlier_method")
gui.appendRadioButton(detection,
"One class SVM with non-linear kernel (RBF)")
ibox = gui.indentedBox(detection)
tooltip = "An upper bound on the fraction of training errors and a " \
"lower bound of the fraction of support vectors"
gui.widgetLabel(ibox, 'Nu:', tooltip=tooltip)
self.nu_slider = gui.hSlider(ibox,
self,
"nu",
minValue=1,
maxValue=100,
ticks=10,
labelFormat="%d %%",
callback=self.nu_changed,
tooltip=tooltip)
self.gamma_spin = gui.spin(ibox,
self,
"gamma",
label="Kernel coefficient:",
step=1e-2,
spinType=float,
minv=0.01,
maxv=10,
callback=self.gamma_changed)
gui.separator(detection, 12)
self.rb_cov = gui.appendRadioButton(detection, "Covariance estimator")
ibox = gui.indentedBox(detection)
self.l_cov = gui.widgetLabel(ibox, 'Contamination:')
self.cont_slider = gui.hSlider(ibox,
self,
"cont",
minValue=0,
maxValue=100,
ticks=10,
labelFormat="%d %%",
callback=self.cont_changed)
ebox = gui.hBox(ibox)
self.cb_emp_cov = gui.checkBox(ebox,
self,
"empirical_covariance",
"Support fraction:",
callback=self.empirical_changed)
self.support_fraction_spin = gui.spin(
ebox,
self,
"support_fraction",
step=1e-1,
spinType=float,
minv=0.1,
maxv=10,
callback=self.support_fraction_changed)
gui.separator(detection, 12)
gui.button(self.buttonsArea,
self,
"Detect Outliers",
callback=self.commit)
self.layout().setSizeConstraint(QLayout.SetFixedSize)
def __init__(self):
super().__init__()
self._inputs = OrderedDict()
self.__pending_selected_rows = self.selected_rows
self.selected_rows = None
self.__pending_selected_cols = self.selected_cols
self.selected_cols = None
self.dist_color = QColor(*self.dist_color_RGB)
info_box = gui.vBox(self.controlArea, "Info")
self.info_ex = gui.widgetLabel(
info_box,
'No data on input.',
)
self.info_ex.setWordWrap(True)
self.info_attr = gui.widgetLabel(info_box, ' ')
self.info_attr.setWordWrap(True)
self.info_class = gui.widgetLabel(info_box, ' ')
self.info_class.setWordWrap(True)
self.info_meta = gui.widgetLabel(info_box, ' ')
self.info_meta.setWordWrap(True)
info_box.setMinimumWidth(200)
gui.separator(self.controlArea)
box = gui.vBox(self.controlArea, "Variables")
self.c_show_attribute_labels = gui.checkBox(
box,
self,
"show_attribute_labels",
"Show variable labels (if present)",
callback=self._on_show_variable_labels_changed)
gui.checkBox(box,
self,
"show_distributions",
'Visualize numeric values',
callback=self._on_distribution_color_changed)
gui.checkBox(box,
self,
"color_by_class",
'Color by instance classes',
callback=self._on_distribution_color_changed)
box = gui.vBox(self.controlArea, "Selection")
gui.checkBox(box,
self,
"select_rows",
"Select full rows",
callback=self._on_select_rows_changed)
gui.rubber(self.controlArea)
reset = gui.button(None,
self,
"Restore Original Order",
callback=self.restore_order,
tooltip="Show rows in the original order",
autoDefault=False)
self.buttonsArea.layout().insertWidget(0, reset)
gui.auto_send(self.buttonsArea, self, "auto_commit")
# GUI with tabs
self.tabs = gui.tabWidget(self.mainArea)
self.tabs.currentChanged.connect(self._on_current_tab_changed)
def __init__(self):
super().__init__()
#: The input data
self.data = None # type: Optional[Orange.data.Table]
#: Data after any applied pre-processing step
self._effective_data = None # type: Optional[Orange.data.Table]
#: Distance matrix computed from _effective_data
self._matrix = None # type: Optional[Orange.misc.DistMatrix]
#: An bool mask (size == len(data)) indicating missing group/cluster
#: assignments
self._mask = None # type: Optional[numpy.ndarray]
#: An array of cluster/group labels for instances with valid group
#: assignment
self._labels = None # type: Optional[numpy.ndarray]
#: An array of silhouette scores for instances with valid group
#: assignment
self._silhouette = None # type: Optional[numpy.ndarray]
self._silplot = None # type: Optional[SilhouettePlot]
gui.comboBox(self.controlArea,
self,
"distance_idx",
box="Distance",
items=[name for name, _ in OWSilhouettePlot.Distances],
orientation=Qt.Horizontal,
callback=self._invalidate_distances)
box = gui.vBox(self.controlArea, "Cluster Label")
self.cluster_var_cb = gui.comboBox(box,
self,
"cluster_var_idx",
addSpace=4,
callback=self._invalidate_scores)
gui.checkBox(box,
self,
"group_by_cluster",
"Group by cluster",
callback=self._replot)
self.cluster_var_model = itemmodels.VariableListModel(parent=self)
self.cluster_var_cb.setModel(self.cluster_var_model)
box = gui.vBox(self.controlArea, "Bars")
gui.widgetLabel(box, "Bar width:")
gui.hSlider(box,
self,
"bar_size",
minValue=1,
maxValue=10,
step=1,
callback=self._update_bar_size,
addSpace=6)
gui.widgetLabel(box, "Annotations:")
self.annotation_cb = gui.comboBox(box,
self,
"annotation_var_idx",
callback=self._update_annotations)
self.annotation_var_model = itemmodels.VariableListModel(parent=self)
self.annotation_var_model[:] = ["None"]
self.annotation_cb.setModel(self.annotation_var_model)
ibox = gui.indentedBox(box, 5)
self.ann_hidden_warning = warning = gui.widgetLabel(
ibox, "(increase the width to show)")
ibox.setFixedWidth(ibox.sizeHint().width())
warning.setVisible(False)
gui.rubber(self.controlArea)
gui.separator(self.buttonsArea)
box = gui.vBox(self.buttonsArea, "Output")
# Thunk the call to commit to call conditional commit
gui.checkBox(box,
self,
"add_scores",
"Add silhouette scores",
callback=lambda: self.commit())
gui.auto_commit(box,
self,
"auto_commit",
"Commit",
auto_label="Auto commit",
box=False)
# Ensure that the controlArea is not narrower than buttonsArea
self.controlArea.layout().addWidget(self.buttonsArea)
self.scene = QGraphicsScene()
self.view = QGraphicsView(self.scene)
self.view.setRenderHint(QPainter.Antialiasing, True)
self.view.setAlignment(Qt.AlignTop | Qt.AlignLeft)
self.mainArea.layout().addWidget(self.view)
def __init__(self):
super().__init__()
self.__pending_selection = self.selection
self._optimizer = None
self._optimizer_thread = None
self.stop_optimization = False
self.data = self.cont_x = None
self.cells = self.member_data = None
self.selection = None
self.colors = self.thresholds = self.bin_labels = None
box = gui.vBox(self.controlArea, box="SOM")
shape = gui.comboBox(
box, self, "", items=("Hexagonal grid", "Square grid"))
shape.setCurrentIndex(1 - self.hexagonal)
box2 = gui.indentedBox(box, 10)
auto_dim = gui.checkBox(
box2, self, "auto_dimension", "Set dimensions automatically",
callback=self.on_auto_dimension_changed)
self.manual_box = box3 = gui.hBox(box2)
spinargs = dict(
value="", widget=box3, master=self, minv=5, maxv=100, step=5,
alignment=Qt.AlignRight)
spin_x = gui.spin(**spinargs)
spin_x.setValue(self.size_x)
gui.widgetLabel(box3, "×")
spin_y = gui.spin(**spinargs)
spin_y.setValue(self.size_y)
gui.rubber(box3)
self.manual_box.setEnabled(not self.auto_dimension)
initialization = gui.comboBox(
box, self, "initialization",
items=("Initialize with PCA", "Random initialization",
"Replicable random"))
start = gui.button(
box, self, "Restart", callback=self.restart_som_pressed,
sizePolicy=(QSizePolicy.MinimumExpanding, QSizePolicy.Fixed))
self.opt_controls = self.OptControls(
shape, auto_dim, spin_x, spin_y, initialization, start)
box = gui.vBox(self.controlArea, "Color")
gui.comboBox(
box, self, "attr_color",
callback=self.on_attr_color_change,
model=DomainModel(placeholder="(Same color)",
valid_types=DomainModel.PRIMITIVE))
gui.checkBox(
box, self, "pie_charts", label="Show pie charts",
callback=self.on_pie_chart_change)
gui.checkBox(
box, self, "size_by_instances", label="Size by number of instances",
callback=self.on_attr_size_change)
gui.rubber(self.controlArea)
self.scene = QGraphicsScene(self)
self.view = SomView(self.scene)
self.view.setMinimumWidth(400)
self.view.setMinimumHeight(400)
self.view.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.view.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.view.setRenderHint(QPainter.Antialiasing)
self.view.selection_changed.connect(self.on_selection_change)
self.view.selection_moved.connect(self.on_selection_move)
self.view.selection_mark_changed.connect(self.on_selection_mark_change)
self.mainArea.layout().addWidget(self.view)
self.elements = None
self.grid = None
self.grid_cells = None
self.legend = None
def __init__(self):
super().__init__()
self.dataset = None
# The Information Box
self.infoBox = gui.widgetBox(self.controlArea, "Info", spacing=1)
self.infoa = gui.widgetLabel(
self.infoBox, 'No data on input yet, waiting to get something.')
self.infob = gui.widgetLabel(self.infoBox, '')
self.infoc = gui.widgetLabel(self.infoBox, '')
gui.radioButtons(self.infoBox, self, 'num_layers', btnLabels=('1', '2', '3', '4'), \
label = 'Number of Layers: ', orientation='horizontal', callback = self.updateLayer)
# The Layer Box: provides all the options for all 4 layers
self.layerBox = gui.widgetBox(self.controlArea, "Layer Options", spacing=1, \
orientation='horizontal')
self.layerBox1 = gui.widgetBox(self.layerBox, spacing=1)
self.layerBox2 = gui.widgetBox(self.layerBox, spacing=1)
self.box = []
for i in range(4):
if (i < 2):
self.box.append(
gui.widgetBox(self.layerBox1, 'Layer ' + str(i + 1)))
else:
self.box.append(
gui.widgetBox(self.layerBox2, 'Layer ' + str(i + 1)))
gui.spin(self.box[i], self, 'neuron_lyr' + str(i+1), minv=1, maxv=50, step=1, \
label='Neurons in hidden Layer ' + str(i+1) + ': ')
combo = gui.comboBox(self.box[i], self, 'activation_lyr' + str(i+1), \
label = 'Activation of Layer ' + str(i+1) + ':', \
items=('sigmoid', 'tanh', 'linear'))
self.box[i].setDisabled(True)
self.layerBox.setDisabled(True)
# The Options Box: gives some general options to configure the network
self.optionsBox = gui.widgetBox(self.controlArea, "General Options", \
orientation='vertical', spacing=1)
self.generalBox = gui.widgetBox(self.optionsBox,
orientation='horizontal',
spacing=1)
self.optionsBox1 = gui.widgetBox(self.generalBox, spacing=1)
self.optionsBox2 = gui.widgetBox(self.generalBox, spacing=1)
gui.spin(self.optionsBox1, self, 'learning_rate', minv=0.01, maxv=1.0, \
step=0.01, label='Learning Rate: ', spinType=float)
combo = gui.comboBox(self.optionsBox1, self, 'activation_out', \
label = 'Ouput Layer Activation: ', orientation='horizontal', items=('sigmoid', 'tanh', 'linear'))
gui.spin(self.optionsBox1, self, 'validation', minv=0.01, maxv=0.2, \
step=0.01, label='Validation Split: ', spinType=float)
gui.spin(self.optionsBox2, self, 'iteration_val', minv=1, maxv=100, \
step=1, label='Iterations: ')
combo = gui.comboBox(self.optionsBox2, self, 'loss_function', label = 'Loss Function: ', \
orientation='horizontal', items=('Mean Squared Error', 'Mean Squared Log Error', \
'Categorical Cross-Entropy', 'Poisson'))
self.batch_spin = gui.spin(self.optionsBox2, self, 'batchsize', minv=1, maxv=300, \
step=1, label='Batch Size: ')
# The GUI for the Progress Bar
self.progress = QtGui.QProgressBar(self.optionsBox)
gui.miscellanea(self.progress, None, self.optionsBox)
# The GUI for checkbox of normalizing the data
gui.checkBox(self.optionsBox,
self,
'checkbox_val',
label='Normalize Data')
self.buttonBox = gui.widgetBox(self.optionsBox, spacing=1)
# The GUI for the apply button
self.apply_button = gui.button(self.buttonBox, self, "Apply", callback = self.apply, \
default=False, autoDefault=False)
# The GUI for the save button
self.save_button = gui.button(self.buttonBox, self, "Save", callback = self.save, \
default=False, autoDefault=False)
self.optionsBox.setDisabled(True)
def __init__(
self,
parent=None,
):
super().__init__(self, parent)
self.selectionChangedFlag = False
self.__initialized = False
self.initfuture = None
self.itemsfuture = None
self.infoLabel = gui.widgetLabel(
gui.widgetBox(self.controlArea, "Info", addSpace=True),
"Initializing\n")
self.organisms = None
self.organismBox = gui.widgetBox(self.controlArea,
"Organism",
addSpace=True)
self.organismComboBox = gui.comboBox(
self.organismBox,
self,
"organism_index",
callback=self._onSelectedOrganismChanged)
# For now only support one alt source, with a checkbox
# In the future this can be extended to multiple selections
self.altSourceCheck = gui.checkBox(self.organismBox,
self,
"useAltSource",
"Show information from dictyBase",
callback=self.onAltSourceChange)
self.altSourceCheck.hide()
box = gui.widgetBox(self.controlArea, "Gene names", addSpace=True)
self.geneAttrComboBox = gui.comboBox(box,
self,
"gene_attr",
"Gene attribute",
callback=self.updateInfoItems)
self.geneAttrComboBox.setEnabled(not self.useAttr)
cb = gui.checkBox(box,
self,
"useAttr",
"Use attribute names",
callback=self.updateInfoItems)
cb.toggled[bool].connect(self.geneAttrComboBox.setDisabled)
gui.auto_commit(self.controlArea, self, "auto_commit", "Commit")
# A label for dictyExpress link (Why oh god why???)
self.dictyExpressBox = gui.widgetBox(self.controlArea, "Dicty Express")
self.linkLabel = gui.widgetLabel(self.dictyExpressBox, "")
self.linkLabel.setOpenExternalLinks(False)
self.linkLabel.linkActivated.connect(self.onDictyExpressLink)
self.dictyExpressBox.hide()
gui.rubber(self.controlArea)
gui.lineEdit(self.mainArea,
self,
"search_string",
"Filter",
callbackOnType=True,
callback=self.searchUpdate)
self.treeWidget = QTreeView(self.mainArea,
selectionMode=QTreeView.ExtendedSelection,
rootIsDecorated=False,
uniformRowHeights=True,
sortingEnabled=True)
self.treeWidget.setItemDelegate(
gui.LinkStyledItemDelegate(self.treeWidget))
self.treeWidget.viewport().setMouseTracking(True)
self.mainArea.layout().addWidget(self.treeWidget)
box = gui.widgetBox(self.mainArea, "", orientation="horizontal")
gui.button(box, self, "Select Filtered", callback=self.selectFiltered)
gui.button(box,
self,
"Clear Selection",
callback=self.treeWidget.clearSelection)
self.geneinfo = []
self.cells = []
self.row2geneinfo = {}
self.data = None
# : (# input genes, # matches genes)
self.matchedInfo = 0, 0
self.setBlocking(True)
self.executor = ThreadExecutor(self)
self.progressBarInit()
task = Task(
function=partial(taxonomy.ensure_downloaded,
callback=methodinvoke(self, "advance", ())))
task.resultReady.connect(self.initialize)
task.exceptionReady.connect(self._onInitializeError)
self.initfuture = self.executor.submit(task)
def __init__(self):
super().__init__()
self.old_purge_classes = True
self.conditions = []
self.last_output_conditions = None
self.data = None
self.data_desc = self.match_desc = self.nonmatch_desc = None
box = gui.vBox(self.controlArea, 'Conditions', stretch=100)
self.cond_list = QTableWidget(box,
showGrid=False,
selectionMode=QTableWidget.NoSelection)
box.layout().addWidget(self.cond_list)
self.cond_list.setColumnCount(4)
self.cond_list.setRowCount(0)
self.cond_list.verticalHeader().hide()
self.cond_list.horizontalHeader().hide()
for i in range(3):
self.cond_list.horizontalHeader().setSectionResizeMode(
i, QHeaderView.Stretch)
self.cond_list.horizontalHeader().resizeSection(3, 30)
self.cond_list.viewport().setBackgroundRole(QPalette.Window)
box2 = gui.hBox(box)
gui.rubber(box2)
self.add_button = gui.button(box2,
self,
"Add Condition",
callback=self.add_row)
self.add_all_button = gui.button(box2,
self,
"Add All Variables",
callback=self.add_all)
self.remove_all_button = gui.button(box2,
self,
"Remove All",
callback=self.remove_all)
gui.rubber(box2)
boxes = gui.widgetBox(self.controlArea, orientation=QGridLayout())
layout = boxes.layout()
layout.setColumnStretch(0, 1)
layout.setColumnStretch(1, 1)
box_data = gui.vBox(boxes, 'Data', addToLayout=False)
self.data_in_variables = gui.widgetLabel(box_data, " ")
self.data_out_rows = gui.widgetLabel(box_data, " ")
layout.addWidget(box_data, 0, 0)
box_setting = gui.vBox(boxes, 'Purging', addToLayout=False)
self.cb_pa = gui.checkBox(box_setting,
self,
"purge_attributes",
"Remove unused features",
callback=self.conditions_changed)
gui.separator(box_setting, height=1)
self.cb_pc = gui.checkBox(box_setting,
self,
"purge_classes",
"Remove unused classes",
callback=self.conditions_changed)
layout.addWidget(box_setting, 0, 1)
self.report_button.setFixedWidth(120)
gui.rubber(self.buttonsArea.layout())
layout.addWidget(self.buttonsArea, 1, 0)
acbox = gui.auto_commit(None,
self,
"auto_commit",
label="Send",
orientation=Qt.Horizontal,
checkbox_label="Send automatically")
layout.addWidget(acbox, 1, 1)
self.set_data(None)
self.resize(600, 400)
def __init__(self):
super().__init__()
self.stats = []
self.dataset = None
self.posthoc_lines = []
self.label_txts = self.mean_labels = self.boxes = self.labels = \
self.label_txts_all = self.attr_labels = self.order = []
self.p = -1.0
self.scale_x = self.scene_min_x = self.scene_width = 0
self.label_width = 0
self.attrs = VariableListModel()
view = gui.listView(
self.controlArea, self, "attribute", box="Variable",
model=self.attrs, callback=self.attr_changed)
view.setMinimumSize(QSize(30, 30))
# Any other policy than Ignored will let the QListBox's scrollbar
# set the minimal height (see the penultimate paragraph of
# http://doc.qt.io/qt-4.8/qabstractscrollarea.html#addScrollBarWidget)
view.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Ignored)
gui.separator(view.box, 6, 6)
self.cb_order = gui.checkBox(
view.box, self, "order_by_importance",
"Order by relevance",
tooltip="Order by 𝜒² or ANOVA over the subgroups",
callback=self.apply_sorting)
self.group_vars = DomainModel(
placeholder="None", separators=False,
valid_types=Orange.data.DiscreteVariable)
self.group_view = view = gui.listView(
self.controlArea, self, "group_var", box="Subgroups",
model=self.group_vars, callback=self.grouping_changed)
view.setEnabled(False)
view.setMinimumSize(QSize(30, 30))
# See the comment above
view.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Ignored)
# TODO: move Compare median/mean to grouping box
# The vertical size policy is needed to let only the list views expand
self.display_box = gui.vBox(
self.controlArea, "Display",
sizePolicy=(QSizePolicy.Minimum, QSizePolicy.Maximum),
addSpace=False)
gui.checkBox(self.display_box, self, "show_annotations", "Annotate",
callback=self.display_changed)
self.compare_rb = gui.radioButtonsInBox(
self.display_box, self, 'compare',
btnLabels=["No comparison", "Compare medians", "Compare means"],
callback=self.layout_changed)
# The vertical size policy is needed to let only the list views expand
self.stretching_box = box = gui.vBox(
self.controlArea, box="Display",
sizePolicy=(QSizePolicy.Minimum, QSizePolicy.Fixed))
self.stretching_box.sizeHint = self.display_box.sizeHint
gui.checkBox(
box, self, 'stretched', "Stretch bars",
callback=self.display_changed)
gui.checkBox(
box, self, 'show_labels', "Show box labels",
callback=self.display_changed)
gui.rubber(box)
gui.auto_commit(self.controlArea, self, "auto_commit",
"Send Selection", "Send Automatically")
gui.vBox(self.mainArea, addSpace=True)
self.box_scene = QGraphicsScene()
self.box_scene.selectionChanged.connect(self.commit)
self.box_view = QGraphicsView(self.box_scene)
self.box_view.setRenderHints(QPainter.Antialiasing |
QPainter.TextAntialiasing |
QPainter.SmoothPixmapTransform)
self.box_view.viewport().installEventFilter(self)
self.mainArea.layout().addWidget(self.box_view)
e = gui.hBox(self.mainArea, addSpace=False)
self.infot1 = gui.widgetLabel(e, "<center>No test results.</center>")
self.mainArea.setMinimumWidth(600)
self.stats = self.dist = self.conts = []
self.is_continuous = False
self.update_display_box()
def __init__(self):
super().__init__()
self.data = None # type: Optional[Table]
self.clusterings = {}
self.__executor = ThreadExecutor(parent=self)
self.__task = None # type: Optional[Task]
layout = QGridLayout()
bg = gui.radioButtonsInBox(
self.controlArea,
self,
"optimize_k",
orientation=layout,
box="Number of Clusters",
callback=self.update_method,
)
layout.addWidget(
gui.appendRadioButton(bg, "Fixed:", addToLayout=False), 1, 1)
sb = gui.hBox(None, margin=0)
gui.spin(sb,
self,
"k",
minv=2,
maxv=30,
controlWidth=60,
alignment=Qt.AlignRight,
callback=self.update_k)
gui.rubber(sb)
layout.addWidget(sb, 1, 2)
layout.addWidget(gui.appendRadioButton(bg, "From", addToLayout=False),
2, 1)
ftobox = gui.hBox(None)
ftobox.layout().setContentsMargins(0, 0, 0, 0)
layout.addWidget(ftobox, 2, 2)
gui.spin(ftobox,
self,
"k_from",
minv=2,
maxv=29,
controlWidth=60,
alignment=Qt.AlignRight,
callback=self.update_from)
gui.widgetLabel(ftobox, "to")
gui.spin(ftobox,
self,
"k_to",
minv=3,
maxv=30,
controlWidth=60,
alignment=Qt.AlignRight,
callback=self.update_to)
gui.rubber(ftobox)
box = gui.vBox(self.controlArea, "Initialization")
gui.comboBox(box,
self,
"smart_init",
items=[m[0] for m in self.INIT_METHODS],
callback=self.invalidate)
layout = QGridLayout()
gui.widgetBox(box, orientation=layout)
layout.addWidget(gui.widgetLabel(None, "Re-runs: "), 0, 0,
Qt.AlignLeft)
sb = gui.hBox(None, margin=0)
layout.addWidget(sb, 0, 1)
gui.lineEdit(sb,
self,
"n_init",
controlWidth=60,
valueType=int,
validator=QIntValidator(),
callback=self.invalidate)
layout.addWidget(gui.widgetLabel(None, "Maximum iterations: "), 1, 0,
Qt.AlignLeft)
sb = gui.hBox(None, margin=0)
layout.addWidget(sb, 1, 1)
gui.lineEdit(sb,
self,
"max_iterations",
controlWidth=60,
valueType=int,
validator=QIntValidator(),
callback=self.invalidate)
self.apply_button = gui.auto_commit(self.buttonsArea,
self,
"auto_commit",
"Apply",
box=None,
commit=self.commit)
gui.rubber(self.controlArea)
box = gui.vBox(self.mainArea, box="Silhouette Scores")
self.mainArea.setVisible(self.optimize_k)
self.table_model = ClusterTableModel(self)
table = self.table_view = QTableView(self.mainArea)
table.setModel(self.table_model)
table.setSelectionMode(QTableView.SingleSelection)
table.setSelectionBehavior(QTableView.SelectRows)
table.setItemDelegate(gui.ColoredBarItemDelegate(self, color=Qt.cyan))
table.selectionModel().selectionChanged.connect(self.select_row)
table.setMaximumWidth(200)
table.horizontalHeader().setStretchLastSection(True)
table.horizontalHeader().hide()
table.setShowGrid(False)
box.layout().addWidget(table)
def __init__(self):
super().__init__()
self.results = None
self.scores = None
self.classifier_names = []
self.colors = []
self.line = None
self._last_score_value = -1
box = gui.vBox(self.controlArea, box="Settings")
self.target_cb = gui.comboBox(box,
self,
"target_index",
label="Target:",
orientation=Qt.Horizontal,
callback=self.target_index_changed,
contentsLength=8,
searchable=True)
gui.checkBox(box,
self,
"display_rug",
"Show rug",
callback=self._on_display_rug_changed)
gui.checkBox(box,
self,
"fold_curves",
"Curves for individual folds",
callback=self._replot)
self.classifiers_list_box = gui.listBox(
self.controlArea,
self,
"selected_classifiers",
"classifier_names",
box="Classifier",
selectionMode=QListWidget.ExtendedSelection,
sizePolicy=(QSizePolicy.Preferred, QSizePolicy.Preferred),
sizeHint=QSize(150, 40),
callback=self._on_selection_changed)
box = gui.vBox(self.controlArea, "Metrics")
combo = gui.comboBox(box,
self,
"score",
items=(metric.name for metric in Metrics),
callback=self.score_changed)
self.explanation = gui.widgetLabel(box,
wordWrap=True,
fixedWidth=combo.sizeHint().width())
self.explanation.setContentsMargins(8, 8, 0, 0)
font = self.explanation.font()
font.setPointSizeF(0.85 * font.pointSizeF())
self.explanation.setFont(font)
gui.radioButtons(box,
self,
value="output_calibration",
btnLabels=("Sigmoid calibration",
"Isotonic calibration"),
label="Output model calibration",
callback=self.commit.deferred)
self.info_box = gui.widgetBox(self.controlArea, "Info")
self.info_label = gui.widgetLabel(self.info_box)
gui.auto_apply(self.buttonsArea, self, "auto_commit")
self.plotview = pg.GraphicsView(background="w")
axes = {
"bottom": AxisItem(orientation="bottom"),
"left": AxisItem(orientation="left")
}
self.plot = pg.PlotItem(enableMenu=False, axisItems=axes)
self.plot.parameter_setter = ParameterSetter(self.plot)
self.plot.setMouseEnabled(False, False)
self.plot.hideButtons()
for axis_name in ("bottom", "left"):
axis = self.plot.getAxis(axis_name)
axis.setPen(pg.mkPen(color=0.0))
# Remove the condition (that is, allow setting this for bottom
# axis) when pyqtgraph is fixed
# Issue: https://github.com/pyqtgraph/pyqtgraph/issues/930
# Pull request: https://github.com/pyqtgraph/pyqtgraph/pull/932
if axis_name != "bottom": # remove if when pyqtgraph is fixed
axis.setStyle(stopAxisAtTick=(True, True))
self.plot.setRange(xRange=(0.0, 1.0), yRange=(0.0, 1.0), padding=0.05)
self.plotview.setCentralItem(self.plot)
self.mainArea.layout().addWidget(self.plotview)
self._set_explanation()
VisualSettingsDialog(self, self.plot.parameter_setter.initial_settings)
def __init__(self, parent=None):
super().__init__(parent)
self.taxids = taxonomy.common_taxids()
self.current_taxid_index = self.taxids.index(self.taxid)
self.data = None
self.geneinfo = None
self.nettask = None
self._invalidated = False
box = gui.widgetBox(self.controlArea, "Info")
self.info = gui.widgetLabel(box, "No data on input\n")
box = gui.widgetBox(self.controlArea, "Organism")
self.organism_cb = gui.comboBox(box,
self,
"current_taxid_index",
items=map(taxonomy.name, self.taxids),
callback=self._update_organism)
box = gui.widgetBox(self.controlArea, "Genes")
self.genes_cb = gui.comboBox(box,
self,
"gene_var_index",
callback=self._update_query_genes)
self.varmodel = itemmodels.VariableListModel()
self.genes_cb.setModel(self.varmodel)
gui.checkBox(box,
self,
"use_attr_names",
"Use attribute names",
callback=self._update_query_genes)
box = gui.widgetBox(self.controlArea, "Network")
gui.comboBox(box,
self,
"network_source",
items=[s.name for s in SOURCES],
callback=self._on_source_db_changed)
gui.checkBox(box,
self,
"include_neighborhood",
"Include immediate gene neighbors",
callback=self.invalidate)
self.score_spin = gui.doubleSpin(box,
self,
"min_score",
0.0,
1.0,
step=0.001,
label="Minimal edge score",
callback=self.invalidate)
self.score_spin.setEnabled(SOURCES[self.network_source].score_filter)
box = gui.widgetBox(self.controlArea, "Commit")
gui.button(box, self, "Retrieve", callback=self.commit, default=True)
self.setSizePolicy(QtGui.QSizePolicy.Fixed, QtGui.QSizePolicy.Fixed)
self.layout().setSizeConstraint(QtGui.QLayout.SetFixedSize)
self.executor = ThreadExecutor()
def __init__(self):
super().__init__()
self.data = None
self.dataset = None
self.annotated_data = None
# GUI
infobox = gui.widgetBox(self.controlArea, "Info")
self.infoa = gui.widgetLabel(infobox, "No data on input yet, waiting to get something.")
self.infob = gui.widgetLabel(infobox, "")
self.infoc = gui.widgetLabel(infobox, "")
self.infod = gui.widgetLabel(infobox, "")
self.optionsBox = gui.widgetBox(self.controlArea, "OPTICS Options")
gui.spin(
self.optionsBox,
self,
"minimum_samples",
minv=1,
maxv=100,
step=1,
label="Core point neighbors ",
callback=self._min_samples_changed
)
gui.comboBox(
self.optionsBox,
self,
"metric_methode",
orientation=Qt.Horizontal,
label="Distance metric: ",
items=[d[0] for d in OPTICS_METRICS],
callback=self._metric_changed
)
gui.doubleSpin(
self.optionsBox,
self,
"xi_value",
minv=(0.000),
maxv=(0.999),
step=(0.001),
label="Minimum steepness: ",
callback=self._xi_changed
)
gui.comboBox(
self.optionsBox,
self,
"algorithm_base",
orientation=Qt.Horizontal,
label="neighborhood algorithm: ",
items=[d[0] for d in OPTICS_ALGORITHM],
callback=self._algorithm_changed
)
self.optionsBox.setDisabled(True)
gui.auto_apply(self.controlArea, self, "auto_commit")
gui.rubber(self.controlArea)
self.controlArea.layout().addStretch()
self.plot = SliderGraph(
x_axis_label="Ordering of the points as processed by OPTICS",
y_axis_label="Reachability distance (epsilon distance)",
callback=self._on_changed
)
self.mainArea.layout().addWidget(self.plot)
def __init__(self):
super().__init__()
self.data = None
self.samplingBox = [None, None]
self.sampleSizeBox = [None, None]
self.cvBox = [None, None]
box = gui.widgetBox(self.controlArea, "Information")
self.dataInfoLabel = gui.widgetLabel(box, 'No data on input.')
self.outputInfoLabel = gui.widgetLabel(box, ' ')
form = QtGui.QGridLayout()
box = gui.widgetBox(self.controlArea, "Options", orientation=form)
cb = gui.checkBox(box, self, "stratified", "Stratified (if possible)",
callback=self.settingsChanged, addToLayout=False)
form.addWidget(cb, 0, 0)
cb = gui.checkBox(box, self, "useSeed", "Random seed:",
callback=self.settingsChanged, addToLayout=False)
spin = gui.spin(box, self, "seed", minv=0, maxv=2 ** 31 - 1,
callback=self.settingsChanged, addToLayout=False)
spin.setEnabled(self.useSeed)
cb.toggled[bool].connect(spin.setEnabled)
form.addWidget(cb, 1, 0)
form.addWidget(spin, 1, 1)
box = gui.widgetBox(self.controlArea, self.tr("Sampling Type"))
sampling = gui.radioButtons(box, self, "samplingType",
callback=self.samplingTypeChanged)
gui.appendRadioButton(sampling, "Random Sampling:")
self.samplingBox[0] = ibox = gui.indentedBox(sampling)
ibox.setEnabled(self.samplingType == OWDataSampler.RandomSampling)
ibox = gui.radioButtons(ibox, self, "sampleSizeType",
callback=self.sampleSizeTypeChanged)
gui.checkBox(ibox, self, "replacement", "With replacement",
callback=self.settingsChanged)
gui.appendRadioButton(ibox, "Sample size:")
self.sampleSizeSpin = gui.spin(
gui.indentedBox(ibox), self, "sampleSizeNumber",
minv=1, maxv=2 ** 31 - 1, callback=self.settingsChanged
)
self.sampleSizeSpin.setEnabled(self.sampleSizeType == self.Fixed)
gui.appendRadioButton(ibox, "Sample proportions:")
self.sampleSizePercentageSlider = gui.hSlider(
gui.indentedBox(ibox), self,
"sampleSizePercentage",
minValue=1, maxValue=100, ticks=10, labelFormat="%d%%",
callback=self.settingsChanged
)
self.sampleSizePercentageSlider.setEnabled(
self.sampleSizeType == self.Ratio)
self.sampleSizeBox = [self.sampleSizeSpin,
self.sampleSizePercentageSlider]
gui.appendRadioButton(sampling, "Cross Validation:")
self.samplingBox[1] = ibox = gui.indentedBox(sampling, addSpace=True)
ibox.setEnabled(self.samplingType == OWDataSampler.CrossValidation)
form = QtGui.QFormLayout(
formAlignment=Qt.AlignLeft | Qt.AlignTop,
labelAlignment=Qt.AlignLeft,
fieldGrowthPolicy=QtGui.QFormLayout.AllNonFixedFieldsGrow
)
bbox = gui.radioButtons(ibox, self, "cvType", orientation=form,
callback=self.cvTypeChanged)
bbox.setContentsMargins(1, 1, 1, 1)
kfold_rb = gui.appendRadioButton(bbox, "K-Fold:", insertInto=None,
addToLayout=False)
loo_rb = gui.appendRadioButton(bbox, "Leave one out", insertInto=None,
addToLayout=False)
kfold_spin = gui.spin(ibox, self, "numberOfFolds", 2, 100,
addToLayout=False,
callback=self.numberOfFoldsChanged)
kfold_spin.setEnabled(self.cvType == self.KFold)
form.addRow(kfold_rb, kfold_spin)
form.addRow(loo_rb)
self.cvBox = [kfold_spin]
self.selectedFoldSpin = gui.spin(
ibox, self, "selectedFold", 1, 100,
addToLayout=False)
form.addRow(QtGui.QLabel("Selected fold:"), self.selectedFoldSpin)
gui.button(self.controlArea, self, "Sample Data",
callback=self.commit)
self.layout().setSizeConstraint(QtGui.QLayout.SetFixedSize)
def _init_ui(self):
namesBox = gui.vBox(self.controlArea, "Names")
hbox = gui.hBox(namesBox, margin=0, spacing=0)
gui.lineEdit(hbox, self, "attr1", "Variable X: ",
controlWidth=80, orientation=Qt.Horizontal,
callback=self._attr_name_changed)
gui.separator(hbox, 21)
hbox = gui.hBox(namesBox, margin=0, spacing=0)
attr2 = gui.lineEdit(hbox, self, "attr2", "Variable Y: ",
controlWidth=80, orientation=Qt.Horizontal,
callback=self._attr_name_changed)
gui.separator(hbox)
gui.checkBox(hbox, self, "hasAttr2", '', disables=attr2,
labelWidth=0,
callback=self.set_dimensions)
gui.separator(namesBox)
gui.widgetLabel(namesBox, "Labels")
self.classValuesView = listView = gui.ListViewWithSizeHint(
preferred_size=(-1, 30))
listView.setModel(self.class_model)
itemmodels.select_row(listView, 0)
namesBox.layout().addWidget(listView)
self.addClassLabel = QAction(
"+", self,
toolTip="Add new class label",
triggered=self.add_new_class_label
)
self.removeClassLabel = QAction(
unicodedata.lookup("MINUS SIGN"), self,
toolTip="Remove selected class label",
triggered=self.remove_selected_class_label
)
actionsWidget = itemmodels.ModelActionsWidget(
[self.addClassLabel, self.removeClassLabel], self
)
actionsWidget.layout().addStretch(10)
actionsWidget.layout().setSpacing(1)
namesBox.layout().addWidget(actionsWidget)
tBox = gui.vBox(self.controlArea, "Tools", addSpace=True)
buttonBox = gui.hBox(tBox)
toolsBox = gui.widgetBox(buttonBox, orientation=QGridLayout())
self.toolActions = QActionGroup(self)
self.toolActions.setExclusive(True)
self.toolButtons = []
for i, (name, tooltip, tool, icon) in enumerate(self.TOOLS):
action = QAction(
name, self,
toolTip=tooltip,
checkable=tool.checkable,
icon=QIcon(icon),
)
action.triggered.connect(partial(self.set_current_tool, tool))
button = QToolButton(
iconSize=QSize(24, 24),
toolButtonStyle=Qt.ToolButtonTextUnderIcon,
sizePolicy=QSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.Fixed)
)
button.setDefaultAction(action)
self.toolButtons.append((button, tool))
toolsBox.layout().addWidget(button, i / 3, i % 3)
self.toolActions.addAction(action)
for column in range(3):
toolsBox.layout().setColumnMinimumWidth(column, 10)
toolsBox.layout().setColumnStretch(column, 1)
undo = self.undo_stack.createUndoAction(self)
redo = self.undo_stack.createRedoAction(self)
undo.setShortcut(QKeySequence.Undo)
redo.setShortcut(QKeySequence.Redo)
self.addActions([undo, redo])
self.undo_stack.indexChanged.connect(lambda _: self.invalidate())
gui.separator(tBox)
indBox = gui.indentedBox(tBox, sep=8)
form = QFormLayout(
formAlignment=Qt.AlignLeft,
labelAlignment=Qt.AlignLeft,
fieldGrowthPolicy=QFormLayout.AllNonFixedFieldsGrow
)
indBox.layout().addLayout(form)
slider = gui.hSlider(
indBox, self, "brushRadius", minValue=1, maxValue=100,
createLabel=False
)
form.addRow("Radius:", slider)
slider = gui.hSlider(
indBox, self, "density", None, minValue=1, maxValue=100,
createLabel=False
)
form.addRow("Intensity:", slider)
self.btResetToInput = gui.button(
tBox, self, "Reset to Input Data", self.reset_to_input)
self.btResetToInput.setDisabled(True)
gui.auto_commit(self.left_side, self, "autocommit",
"Send")
# main area GUI
viewbox = PaintViewBox(enableMouse=False)
self.plotview = pg.PlotWidget(background="w", viewBox=viewbox)
self.plotview.sizeHint = lambda: QSize(200, 100) # Minimum size for 1-d painting
self.plot = self.plotview.getPlotItem()
axis_color = self.palette().color(QPalette.Text)
axis_pen = QPen(axis_color)
tickfont = QFont(self.font())
tickfont.setPixelSize(max(int(tickfont.pixelSize() * 2 // 3), 11))
axis = self.plot.getAxis("bottom")
axis.setLabel(self.attr1)
axis.setPen(axis_pen)
axis.setTickFont(tickfont)
axis = self.plot.getAxis("left")
axis.setLabel(self.attr2)
axis.setPen(axis_pen)
axis.setTickFont(tickfont)
if not self.hasAttr2:
self.plot.hideAxis('left')
self.plot.hideButtons()
self.plot.setXRange(0, 1, padding=0.01)
self.mainArea.layout().addWidget(self.plotview)
# enable brush tool
self.toolActions.actions()[0].setChecked(True)
self.set_current_tool(self.TOOLS[0][2])
self.set_dimensions()
def __init__(self):
super().__init__()
self.rf_model = None
self.forest = None
self.instances = None
self.color_palette = None
# CONTROL AREA
# Tree info area
box_info = gui.widgetBox(self.controlArea, 'Forest')
self.ui_info = gui.widgetLabel(box_info)
# Display controls area
box_display = gui.widgetBox(self.controlArea, 'Display')
# maxValue is set to a wide three-digit number to probably ensure the
# proper label width. The maximum is later set to match the tree depth
self.ui_depth_slider = gui.hSlider(box_display,
self,
'depth_limit',
label='Depth',
ticks=False,
maxValue=900) # type: QSlider
self.ui_target_class_combo = gui.comboBox(box_display,
self,
'target_class_index',
label='Target class',
orientation=Qt.Horizontal,
items=[],
contentsLength=8,
searchable=True)
self.ui_size_calc_combo = gui.comboBox(
box_display,
self,
'size_calc_idx',
label='Size',
orientation=Qt.Horizontal,
items=list(zip(*self.SIZE_CALCULATION))[0],
contentsLength=8,
)
self.ui_zoom_slider = gui.hSlider(
box_display,
self,
'zoom',
label='Zoom',
ticks=False,
minValue=100,
maxValue=400,
createLabel=False,
intOnly=False,
) # type: QSlider
# Stretch to fit the rest of the unsused area
gui.rubber(self.controlArea)
self.controlArea.setSizePolicy(QSizePolicy.Preferred,
QSizePolicy.Expanding)
# MAIN AREA
self.forest_model = PythagoreanForestModel(parent=self)
self.forest_model.update_item_size(self.zoom)
self.ui_depth_slider.valueChanged.connect(
self.forest_model.update_depth)
self.ui_target_class_combo.currentIndexChanged.connect(
self.forest_model.update_target_class)
self.ui_zoom_slider.valueChanged.connect(
self.forest_model.update_item_size)
self.ui_size_calc_combo.currentIndexChanged.connect(
self.forest_model.update_size_calc)
self.list_delegate = PythagorasTreeDelegate(parent=self)
self.list_view = ClickToClearSelectionListView(parent=self)
self.list_view.setWrapping(True)
self.list_view.setFlow(QListView.LeftToRight)
self.list_view.setResizeMode(QListView.Adjust)
self.list_view.setModel(self.forest_model)
self.list_view.setItemDelegate(self.list_delegate)
self.list_view.setSpacing(2)
self.list_view.setSelectionMode(QListView.SingleSelection)
self.list_view.selectionModel().selectionChanged.connect(self.commit)
self.list_view.setUniformItemSizes(True)
self.mainArea.layout().addWidget(self.list_view)
self.resize(800, 500)
# Clear to set sensible default values
self.clear()
def __init__(self, parent=None):
super().__init__(parent)
self.selectionChangedFlag = False
#
# GUI
#
self.info = gui.widgetLabel(gui.widgetBox(self.controlArea, "Info"),
"Waiting for input\n")
self.imageAttrCB = gui.comboBox(
self.controlArea,
self,
"imageAttr",
box="Image Filename Attribute",
tooltip="Attribute with image filenames",
callback=[self.clearScene, self.setupScene],
addSpace=True)
self.titleAttrCB = gui.comboBox(self.controlArea,
self,
"titleAttr",
box="Title Attribute",
tooltip="Attribute with image title",
callback=self.updateTitles,
addSpace=True)
gui.hSlider(self.controlArea,
self,
"zoom",
box="Zoom",
minValue=1,
maxValue=100,
step=1,
callback=self.updateZoom,
createLabel=False)
gui.separator(self.controlArea)
box = gui.widgetBox(self.controlArea, "Selection")
b = gui.button(box, self, "Commit", callback=self.commit)
cb = gui.checkBox(box,
self,
"autoCommit",
"Commit on any change",
tooltip="Send selections on any change",
callback=self.commitIf)
gui.setStopper(self,
b,
cb,
"selectionChangedFlag",
callback=self.commit)
gui.rubber(self.controlArea)
self.scene = GraphicsScene()
self.sceneView = QGraphicsView(self.scene, self)
self.sceneView.setAlignment(Qt.AlignTop | Qt.AlignLeft)
self.sceneView.setRenderHint(QPainter.Antialiasing, True)
self.sceneView.setRenderHint(QPainter.TextAntialiasing, True)
self.sceneView.setFocusPolicy(Qt.WheelFocus)
self.sceneView.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOn)
self.sceneView.installEventFilter(self)
self.mainArea.layout().addWidget(self.sceneView)
self.scene.selectionChanged.connect(self.onSelectionChanged)
self.scene.selectionRectPointChanged.connect(
self.onSelectionRectPointChanged, Qt.QueuedConnection)
self.graphButton.clicked.connect(self.saveScene)
self.resize(800, 600)
self.thumbnailWidget = None
self.sceneLayout = None
self.selectedIndices = []
#: List of _ImageItems
self.items = []
self._errcount = 0
self._successcount = 0
self.loader = ImageLoader(self)
def __init__(self):
super().__init__()
self.grouping = []
self.attributes = []
self.stats = []
self.dataset = None
self.posthoc_lines = []
self.label_txts = self.mean_labels = self.boxes = self.labels = \
self.label_txts_all = self.attr_labels = self.order = []
self.p = -1.0
self.scale_x = self.scene_min_x = self.scene_width = 0
self.label_width = 0
self.attr_list_box = gui.listBox(
self.controlArea, self, "attributes_select", "attributes",
box="Variable", callback=self.attr_changed,
sizeHint=QtCore.QSize(200, 150))
self.attr_list_box.setSizePolicy(QSizePolicy.Fixed,
QSizePolicy.MinimumExpanding)
box = gui.vBox(self.controlArea, "Grouping")
self.group_list_box = gui.listBox(
box, self, 'grouping_select', "grouping",
callback=self.attr_changed,
sizeHint=QtCore.QSize(200, 100))
self.group_list_box.setSizePolicy(QSizePolicy.Fixed,
QSizePolicy.MinimumExpanding)
# TODO: move Compare median/mean to grouping box
self.display_box = gui.vBox(self.controlArea, "Display")
gui.checkBox(self.display_box, self, "show_annotations", "Annotate",
callback=self.display_changed)
self.compare_rb = gui.radioButtonsInBox(
self.display_box, self, 'compare',
btnLabels=["No comparison", "Compare medians", "Compare means"],
callback=self.display_changed)
self.stretching_box = gui.checkBox(
self.controlArea, self, 'stretched', "Stretch bars", box='Display',
callback=self.display_changed).box
gui.vBox(self.mainArea, addSpace=True)
self.box_scene = QtGui.QGraphicsScene()
self.box_view = QtGui.QGraphicsView(self.box_scene)
self.box_view.setRenderHints(QtGui.QPainter.Antialiasing |
QtGui.QPainter.TextAntialiasing |
QtGui.QPainter.SmoothPixmapTransform)
self.box_view.viewport().installEventFilter(self)
self.mainArea.layout().addWidget(self.box_view)
e = gui.hBox(self.mainArea, addSpace=False)
self.infot1 = gui.widgetLabel(e, "<center>No test results.</center>")
self.mainArea.setMinimumWidth(650)
self.stats = self.dist = self.conts = []
self.is_continuous = False
self.update_display_box()
def __init__(self):
self.preprocessor = None
super().__init__()
box = gui.vBox(self.controlArea, "Preprocessor")
self.info_preproc = gui.widgetLabel(box, 'No preprocessor on input.')
def __init__(self):
super().__init__()
self.old_purge_classes = True
self.conditions = []
self.last_output_conditions = None
box = gui.widgetBox(self.controlArea, 'Conditions', stretch=100)
self.cond_list = QtGui.QTableWidget(box)
box.layout().addWidget(self.cond_list)
self.cond_list.setShowGrid(False)
self.cond_list.setSelectionMode(QtGui.QTableWidget.NoSelection)
self.cond_list.setColumnCount(3)
self.cond_list.setRowCount(0)
self.cond_list.verticalHeader().hide()
self.cond_list.horizontalHeader().hide()
self.cond_list.resizeColumnToContents(0)
self.cond_list.horizontalHeader().setResizeMode(
QtGui.QHeaderView.Stretch)
self.cond_list.viewport().setBackgroundRole(QtGui.QPalette.Window)
box2 = gui.widgetBox(box, orientation="horizontal")
self.add_button = gui.button(box2,
self,
"Add condition",
callback=self.add_row)
self.add_all_button = gui.button(box2,
self,
"Add all variables",
callback=self.add_all)
self.remove_all_button = gui.button(box2,
self,
"Remove all",
callback=self.remove_all)
gui.rubber(box2)
info = gui.widgetBox(self.controlArea, '', orientation="horizontal")
box_data_in = gui.widgetBox(info, 'Data In')
# self.data_in_rows = gui.widgetLabel(box_data_in, " ")
self.data_in_variables = gui.widgetLabel(box_data_in, " ")
gui.rubber(box_data_in)
box_data_out = gui.widgetBox(info, 'Data Out')
self.data_out_rows = gui.widgetLabel(box_data_out, " ")
# self.dataOutAttributesLabel = gui.widgetLabel(box_data_out, " ")
gui.rubber(box_data_out)
box = gui.widgetBox(self.controlArea, orientation="horizontal")
boxSettings = gui.widgetBox(box, 'Purging')
cb = gui.checkBox(boxSettings,
self,
"purge_attributes",
"Remove unused values/attributes",
callback=self.on_purge_change)
self.purgeClassesCB = gui.checkBox(gui.indentedBox(
boxSettings, sep=gui.checkButtonOffsetHint(cb)),
self,
"purge_classes",
"Remove unused classes",
callback=self.on_purge_change)
boxCommit = gui.widgetBox(box, 'Commit')
gui.checkBox(boxCommit, self, "update_on_change", "Commit on change")
gui.button(boxCommit, self, "Commit", self.output_data, default=True)
self.set_data(None)
self.resize(600, 400)
def __init__(self):
super().__init__()
self.results = None
self.classifier_names = []
self.perf_line = None
self.colors = []
self._curve_data = {}
self._plot_curves = {}
self._rocch = None
self._perf_line = None
self._tooltip_cache = None
box = gui.vBox(self.controlArea, "Plot")
self.target_cb = gui.comboBox(
box, self, "target_index",
label="Target", orientation=Qt.Horizontal,
callback=self._on_target_changed,
contentsLength=8, searchable=True)
gui.widgetLabel(box, "Classifiers")
line_height = 4 * QFontMetrics(self.font()).lineSpacing()
self.classifiers_list_box = gui.listBox(
box, self, "selected_classifiers", "classifier_names",
selectionMode=QListView.MultiSelection,
callback=self._on_classifiers_changed,
sizeHint=QSize(0, line_height))
abox = gui.vBox(self.controlArea, "Curves")
gui.comboBox(abox, self, "roc_averaging",
items=["Merge Predictions from Folds", "Mean TP Rate",
"Mean TP and FP at Threshold", "Show Individual Curves"],
callback=self._replot)
gui.checkBox(abox, self, "display_convex_curve",
"Show convex ROC curves", callback=self._replot)
gui.checkBox(abox, self, "display_convex_hull",
"Show ROC convex hull", callback=self._replot)
box = gui.vBox(self.controlArea, "Analysis")
gui.checkBox(box, self, "display_def_threshold",
"Default threshold (0.5) point",
callback=self._on_display_def_threshold_changed)
gui.checkBox(box, self, "display_perf_line", "Show performance line",
callback=self._on_display_perf_line_changed)
grid = QGridLayout()
gui.indentedBox(box, orientation=grid)
sp = gui.spin(box, self, "fp_cost", 1, 1000, 10,
alignment=Qt.AlignRight,
callback=self._on_display_perf_line_changed)
grid.addWidget(QLabel("FP Cost:"), 0, 0)
grid.addWidget(sp, 0, 1)
sp = gui.spin(box, self, "fn_cost", 1, 1000, 10,
alignment=Qt.AlignRight,
callback=self._on_display_perf_line_changed)
grid.addWidget(QLabel("FN Cost:"))
grid.addWidget(sp, 1, 1)
self.target_prior_sp = gui.spin(box, self, "target_prior", 1, 99,
alignment=Qt.AlignRight,
callback=self._on_target_prior_changed)
self.target_prior_sp.setSuffix(" %")
self.target_prior_sp.addAction(QAction("Auto", sp))
grid.addWidget(QLabel("Prior probability:"))
grid.addWidget(self.target_prior_sp, 2, 1)
self.plotview = pg.GraphicsView(background="w")
self.plotview.setFrameStyle(QFrame.StyledPanel)
self.plotview.scene().sigMouseMoved.connect(self._on_mouse_moved)
self.plot = pg.PlotItem(enableMenu=False)
self.plot.setMouseEnabled(False, False)
self.plot.hideButtons()
pen = QPen(self.palette().color(QPalette.Text))
tickfont = QFont(self.font())
tickfont.setPixelSize(max(int(tickfont.pixelSize() * 2 // 3), 11))
axis = self.plot.getAxis("bottom")
axis.setTickFont(tickfont)
axis.setPen(pen)
axis.setLabel("FP Rate (1-Specificity)")
axis.setGrid(16)
axis = self.plot.getAxis("left")
axis.setTickFont(tickfont)
axis.setPen(pen)
axis.setLabel("TP Rate (Sensitivity)")
axis.setGrid(16)
self.plot.showGrid(True, True, alpha=0.1)
self.plot.setRange(xRange=(0.0, 1.0), yRange=(0.0, 1.0), padding=0.05)
self.plotview.setCentralItem(self.plot)
self.mainArea.layout().addWidget(self.plotview)
def __init__(self):
super().__init__()
self.data = None
self.valid_data = self.valid_group_data = None
self.bar_items = []
self.curve_items = []
self.curve_descriptions = None
self.binnings = []
self.last_click_idx = None
self.drag_operation = self.DragNone
self.key_operation = None
self._user_var_bins = {}
varview = gui.listView(
self.controlArea, self, "var", box="Variable",
model=DomainModel(valid_types=DomainModel.PRIMITIVE,
separators=False),
callback=self._on_var_changed,
viewType=ListViewSearch
)
gui.checkBox(
varview.box, self, "sort_by_freq", "Sort categories by frequency",
callback=self._on_sort_by_freq, stateWhenDisabled=False)
box = self.continuous_box = gui.vBox(self.controlArea, "Distribution")
gui.comboBox(
box, self, "fitted_distribution", label="Fitted distribution",
orientation=Qt.Horizontal, items=(name[0] for name in self.Fitters),
callback=self._on_fitted_dist_changed)
slider = gui.hSlider(
box, self, "number_of_bins",
label="Bin width", orientation=Qt.Horizontal,
minValue=0, maxValue=max(1, len(self.binnings) - 1),
createLabel=False, callback=self._on_bins_changed)
self.bin_width_label = gui.widgetLabel(slider.box)
self.bin_width_label.setFixedWidth(35)
self.bin_width_label.setAlignment(Qt.AlignRight)
slider.sliderReleased.connect(self._on_bin_slider_released)
self.smoothing_box = gui.hSlider(
box, self, "kde_smoothing",
label="Smoothing", orientation=Qt.Horizontal,
minValue=2, maxValue=20, callback=self.replot, disabled=True)
gui.checkBox(
box, self, "hide_bars", "Hide bars", stateWhenDisabled=False,
callback=self._on_hide_bars_changed,
disabled=not self.fitted_distribution)
box = gui.vBox(self.controlArea, "Columns")
gui.comboBox(
box, self, "cvar", label="Split by", orientation=Qt.Horizontal,
searchable=True,
model=DomainModel(placeholder="(None)",
valid_types=(DiscreteVariable), ),
callback=self._on_cvar_changed, contentsLength=18)
gui.checkBox(
box, self, "stacked_columns", "Stack columns",
callback=self.replot)
gui.checkBox(
box, self, "show_probs", "Show probabilities",
callback=self._on_show_probabilities_changed)
gui.checkBox(
box, self, "cumulative_distr", "Show cumulative distribution",
callback=self._on_show_cumulative)
gui.auto_apply(self.buttonsArea, self, commit=self.apply)
self._set_smoothing_visibility()
self._setup_plots()
self._setup_legend()
def __init__(self, parent=None):
super().__init__(self, parent)
self.input_data = None
self.ref_data = None
self.ontology = None
self.annotations = None
self.loaded_annotation_code = None
self.treeStructRootKey = None
self.probFunctions = [
statistics.Binomial(),
statistics.Hypergeometric()
]
self.selectedTerms = []
self.selectionChanging = 0
self.__state = State.Ready
self.__scheduletimer = QTimer(self, singleShot=True)
self.__scheduletimer.timeout.connect(self.__update)
#############
# GUI
#############
self.tabs = gui.tabWidget(self.controlArea)
# Input tab
self.inputTab = gui.createTabPage(self.tabs, "Input")
box = gui.widgetBox(self.inputTab, "Info")
self.infoLabel = gui.widgetLabel(box, "No data on input\n")
gui.button(
box,
self,
"Ontology/Annotation Info",
callback=self.show_info,
tooltip="Show information on loaded ontology and annotations",
)
self.referenceRadioBox = gui.radioButtonsInBox(
self.inputTab,
self,
"use_reference_dataset",
["Entire genome", "Reference set (input)"],
tooltips=[
"Use entire genome for reference",
"Use genes from Referece Examples input signal as reference"
],
box="Reference",
callback=self.__invalidate,
)
self.referenceRadioBox.buttons[1].setDisabled(True)
gui.radioButtonsInBox(
self.inputTab,
self,
"aspect_index",
["Biological process", "Cellular component", "Molecular function"],
box="Aspect",
callback=self.__invalidate,
)
# Filter tab
self.filterTab = gui.createTabPage(self.tabs, "Filter")
box = gui.widgetBox(self.filterTab, "Filter GO Term Nodes")
gui.checkBox(
box,
self,
"filter_by_num_of_instances",
"Genes",
callback=self.filter_and_display_graph,
tooltip="Filter by number of input genes mapped to a term",
)
ibox = gui.indentedBox(box)
gui.spin(
ibox,
self,
'min_num_of_instances',
1,
100,
step=1,
label='#:',
labelWidth=15,
callback=self.filter_and_display_graph,
callbackOnReturn=True,
tooltip="Min. number of input genes mapped to a term",
)
gui.checkBox(
box,
self,
"filter_by_p_value_nofdr",
"p-value",
callback=self.filter_and_display_graph,
tooltip="Filter by term p-value",
)
gui.doubleSpin(
gui.indentedBox(box),
self,
'max_p_value_no_fdr',
1e-8,
1,
step=1e-8,
label='p:',
labelWidth=15,
callback=self.filter_and_display_graph,
callbackOnReturn=True,
tooltip="Max term p-value",
)
# use filter_by_p_value for FDR, as it was the default in prior versions
gui.checkBox(box,
self,
"filter_by_p_value",
"FDR",
callback=self.filter_and_display_graph,
tooltip="Filter by term FDR")
gui.doubleSpin(
gui.indentedBox(box),
self,
'max_p_value',
1e-8,
1,
step=1e-8,
label='p:',
labelWidth=15,
callback=self.filter_and_display_graph,
callbackOnReturn=True,
tooltip="Max term p-value",
)
box = gui.widgetBox(box, "Significance test")
gui.radioButtonsInBox(
box,
self,
"prob_func",
["Binomial", "Hypergeometric"],
tooltips=[
"Use binomial distribution test",
"Use hypergeometric distribution test"
],
callback=self.__invalidate,
) # TODO: only update the p values
box = gui.widgetBox(self.filterTab,
"Evidence codes in annotation",
addSpace=True)
self.evidenceCheckBoxDict = {}
for etype in go.evidence_types_ordered:
ecb = QCheckBox(etype,
toolTip=go.evidence_types[etype],
checked=self.use_evidence_type[etype])
ecb.toggled.connect(self.__on_evidence_changed)
box.layout().addWidget(ecb)
self.evidenceCheckBoxDict[etype] = ecb
# Select tab
self.selectTab = gui.createTabPage(self.tabs, "Select")
box = gui.radioButtonsInBox(
self.selectTab,
self,
"selection_direct_annotation",
["Directly or Indirectly", "Directly"],
box="Annotated genes",
callback=self.example_selection,
)
box = gui.widgetBox(self.selectTab, "Output", addSpace=True)
gui.radioButtonsInBox(
box,
self,
"selection_disjoint",
btnLabels=[
"All selected genes", "Term-specific genes",
"Common term genes"
],
tooltips=[
"Outputs genes annotated to all selected GO terms",
"Outputs genes that appear in only one of selected GO terms",
"Outputs genes common to all selected GO terms",
],
callback=self.example_selection,
)
# ListView for DAG, and table for significant GOIDs
self.DAGcolumns = [
'GO term', 'Cluster', 'Reference', 'p-value', 'FDR', 'Genes',
'Enrichment'
]
self.splitter = QSplitter(Qt.Vertical, self.mainArea)
self.mainArea.layout().addWidget(self.splitter)
# list view
self.listView = GOTreeWidget(self.splitter)
self.listView.setSelectionMode(QTreeView.ExtendedSelection)
self.listView.setAllColumnsShowFocus(1)
self.listView.setColumnCount(len(self.DAGcolumns))
self.listView.setHeaderLabels(self.DAGcolumns)
self.listView.header().setSectionsClickable(True)
self.listView.header().setSortIndicatorShown(True)
self.listView.header().setSortIndicator(
self.DAGcolumns.index('p-value'), Qt.AscendingOrder)
self.listView.setSortingEnabled(True)
self.listView.setItemDelegateForColumn(
6, EnrichmentColumnItemDelegate(self))
self.listView.setRootIsDecorated(True)
self.listView.itemSelectionChanged.connect(self.view_selection_changed)
# table of significant GO terms
self.sigTerms = QTreeWidget(self.splitter)
self.sigTerms.setColumnCount(len(self.DAGcolumns))
self.sigTerms.setHeaderLabels(self.DAGcolumns)
self.sigTerms.setSortingEnabled(True)
self.sigTerms.setSelectionMode(QTreeView.ExtendedSelection)
self.sigTerms.header().setSortIndicator(
self.DAGcolumns.index('p-value'), Qt.AscendingOrder)
self.sigTerms.setItemDelegateForColumn(
6, EnrichmentColumnItemDelegate(self))
self.sigTerms.itemSelectionChanged.connect(
self.table_selection_changed)
self.sigTableTermsSorted = []
self.graph = {}
self.originalGraph = None
self.inputTab.layout().addStretch(1)
self.filterTab.layout().addStretch(1)
self.selectTab.layout().addStretch(1)
class AnnotationSlot(SimpleNamespace):
taxid = ... # type: str
name = ... # type: str
filename = ... # type:str
@staticmethod
def parse_tax_id(f_name):
return f_name.split('.')[0]
try:
remote_files = serverfiles.ServerFiles().listfiles(DOMAIN)
except (ConnectTimeout, RequestException, ConnectionError):
# TODO: Warn user about failed connection to the remote server
remote_files = []
self.available_annotations = [
AnnotationSlot(
taxid=AnnotationSlot.parse_tax_id(annotation_file),
name=taxonomy.common_taxid_to_name(
AnnotationSlot.parse_tax_id(annotation_file)),
filename=FILENAME_ANNOTATION.format(
AnnotationSlot.parse_tax_id(annotation_file)),
) for _, annotation_file in set(remote_files +
serverfiles.listfiles(DOMAIN))
if annotation_file != FILENAME_ONTOLOGY
]
self._executor = ThreadExecutor()
def __init__(self):
super().__init__()
RecentPathsWComboMixin.__init__(self)
self.domain = None
self.data = None
self.loaded_file = ""
self.reader = None
layout = QGridLayout()
gui.widgetBox(self.controlArea, margin=0, orientation=layout)
vbox = gui.radioButtons(None,
self,
"source",
box=True,
addSpace=True,
callback=self.load_data,
addToLayout=False)
rb_button = gui.appendRadioButton(vbox, "文件:", addToLayout=False)
layout.addWidget(rb_button, 0, 0, Qt.AlignVCenter)
box = gui.hBox(None, addToLayout=False, margin=0)
box.setSizePolicy(Policy.MinimumExpanding, Policy.Fixed)
self.file_combo.setSizePolicy(Policy.MinimumExpanding, Policy.Fixed)
self.file_combo.activated[int].connect(self.select_file)
box.layout().addWidget(self.file_combo)
layout.addWidget(box, 0, 1)
file_button = gui.button(None,
self,
'...',
callback=self.browse_file,
autoDefault=False)
file_button.setIcon(self.style().standardIcon(QStyle.SP_DirOpenIcon))
file_button.setSizePolicy(Policy.Maximum, Policy.Fixed)
layout.addWidget(file_button, 0, 2)
reload_button = gui.button(None,
self,
"重新加载",
callback=self.load_data,
autoDefault=False)
reload_button.setIcon(self.style().standardIcon(
QStyle.SP_BrowserReload))
reload_button.setSizePolicy(Policy.Fixed, Policy.Fixed)
layout.addWidget(reload_button, 0, 3)
self.sheet_box = gui.hBox(None, addToLayout=False, margin=0)
self.sheet_combo = gui.comboBox(
None,
self,
"xls_sheet",
callback=self.select_sheet,
sendSelectedValue=True,
)
self.sheet_combo.setSizePolicy(Policy.MinimumExpanding, Policy.Fixed)
self.sheet_label = QLabel()
self.sheet_label.setText('Sheet')
self.sheet_label.setSizePolicy(Policy.MinimumExpanding, Policy.Fixed)
self.sheet_box.layout().addWidget(self.sheet_label, Qt.AlignLeft)
self.sheet_box.layout().addWidget(self.sheet_combo, Qt.AlignVCenter)
layout.addWidget(self.sheet_box, 2, 1)
self.sheet_box.hide()
rb_button = gui.appendRadioButton(vbox, "URL:", addToLayout=False)
layout.addWidget(rb_button, 3, 0, Qt.AlignVCenter)
self.url_combo = url_combo = QComboBox()
url_model = NamedURLModel(self.sheet_names)
url_model.wrap(self.recent_urls)
url_combo.setLineEdit(LineEditSelectOnFocus())
url_combo.setModel(url_model)
url_combo.setSizePolicy(Policy.Ignored, Policy.Fixed)
url_combo.setEditable(True)
url_combo.setInsertPolicy(url_combo.InsertAtTop)
url_edit = url_combo.lineEdit()
l, t, r, b = url_edit.getTextMargins()
url_edit.setTextMargins(l + 5, t, r, b)
layout.addWidget(url_combo, 3, 1, 3, 3)
url_combo.activated.connect(self._url_set)
# whit completer we set that combo box is case sensitive when
# matching the history
completer = QCompleter()
completer.setCaseSensitivity(Qt.CaseSensitive)
url_combo.setCompleter(completer)
box = gui.vBox(self.controlArea, "信息")
self.infolabel = gui.widgetLabel(box, '未加载数据。')
self.warnings = gui.widgetLabel(box, '')
box = gui.widgetBox(self.controlArea, "列(双击编辑)")
self.domain_editor = DomainEditor(self)
self.editor_model = self.domain_editor.model()
box.layout().addWidget(self.domain_editor)
box = gui.hBox(self.controlArea)
gui.button(box,
self,
"浏览文档数据集",
callback=lambda: self.browse_file(True),
autoDefault=False)
gui.rubber(box)
gui.button(box, self, "重置", callback=self.reset_domain_edit)
self.apply_button = gui.button(box,
self,
"应用",
callback=self.apply_domain_edit)
self.apply_button.setEnabled(False)
self.apply_button.setFixedWidth(170)
self.editor_model.dataChanged.connect(
lambda: self.apply_button.setEnabled(True))
self.set_file_list()
# Must not call open_file from within __init__. open_file
# explicitly re-enters the event loop (by a progress bar)
self.setAcceptDrops(True)
if self.source == self.LOCAL_FILE:
last_path = self.last_path()
if last_path and os.path.exists(last_path) and \
os.path.getsize(last_path) > self.SIZE_LIMIT:
self.Warning.file_too_big()
return
QTimer.singleShot(0, self.load_data)
def __init__(self):
super().__init__()
#: The input data
self.data = None # type: Optional[Orange.data.Table]
#: The input distance matrix (if present)
self.distances = None # type: Optional[Orange.misc.DistMatrix]
#: The effective distance matrix (is self.distances or computed from
#: self.data depending on input)
self._matrix = None # type: Optional[Orange.misc.DistMatrix]
#: An bool mask (size == len(data)) indicating missing group/cluster
#: assignments
self._mask = None # type: Optional[np.ndarray]
#: An array of cluster/group labels for instances with valid group
#: assignment
self._labels = None # type: Optional[np.ndarray]
#: An array of silhouette scores for instances with valid group
#: assignment
self._silhouette = None # type: Optional[np.ndarray]
self._silplot = None # type: Optional[SilhouettePlot]
controllayout = self.controlArea.layout()
assert isinstance(controllayout, QVBoxLayout)
self._distances_gui_box = distbox = gui.widgetBox(None, "Distance")
self._distances_gui_cb = gui.comboBox(
distbox,
self,
"distance_idx",
items=[name for name, _ in OWSilhouettePlot.Distances],
orientation=Qt.Horizontal,
callback=self._invalidate_distances)
controllayout.addWidget(distbox)
box = gui.vBox(self.controlArea, "Cluster Label")
self.cluster_var_cb = gui.comboBox(box,
self,
"cluster_var_idx",
contentsLength=14,
addSpace=4,
searchable=True,
callback=self._invalidate_scores)
gui.checkBox(box,
self,
"group_by_cluster",
"Group by cluster",
callback=self._replot)
self.cluster_var_model = itemmodels.VariableListModel(parent=self)
self.cluster_var_cb.setModel(self.cluster_var_model)
box = gui.vBox(self.controlArea, "Bars")
gui.widgetLabel(box, "Bar width:")
gui.hSlider(box,
self,
"bar_size",
minValue=1,
maxValue=10,
step=1,
callback=self._update_bar_size,
addSpace=6)
gui.widgetLabel(box, "Annotations:")
self.annotation_cb = gui.comboBox(box,
self,
"annotation_var_idx",
contentsLength=14,
callback=self._update_annotations)
self.annotation_var_model = itemmodels.VariableListModel(parent=self)
self.annotation_var_model[:] = ["None"]
self.annotation_cb.setModel(self.annotation_var_model)
ibox = gui.indentedBox(box, 5)
self.ann_hidden_warning = warning = gui.widgetLabel(
ibox, "(increase the width to show)")
ibox.setFixedWidth(ibox.sizeHint().width())
warning.setVisible(False)
gui.rubber(self.controlArea)
box = gui.vBox(self.buttonsArea, box=True)
gui.auto_send(box, self, "auto_commit", box=False)
# Ensure that the controlArea is not narrower than buttonsArea
self.controlArea.layout().addWidget(self.buttonsArea)
self.scene = QGraphicsScene(self)
self.view = StickyGraphicsView(self.scene)
self.view.setRenderHint(QPainter.Antialiasing, True)
self.view.setAlignment(Qt.AlignTop | Qt.AlignLeft)
self.mainArea.layout().addWidget(self.view)
self.settingsAboutToBePacked.connect(self.pack_settings)