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 _add_controls_start_box(self):
box = gui.vBox(self.controlArea, True)
form = QFormLayout(
labelAlignment=Qt.AlignLeft,
formAlignment=Qt.AlignLeft,
fieldGrowthPolicy=QFormLayout.AllNonFixedFieldsGrow,
verticalSpacing=10
)
form.addRow(
"Max iterations:",
gui.spin(box, self, "max_iter", 1, 2000, step=50))
form.addRow(
"Perplexity:",
gui.spin(box, self, "perplexity", 1, 100, step=1))
box.layout().addLayout(form)
gui.separator(box, 10)
self.runbutton = gui.button(box, self, "Run", callback=self._toggle_run)
gui.separator(box, 10)
gui.hSlider(box, self, "pca_components", label="PCA components:",
minValue=2, maxValue=50, step=1)
def _create_layout(self):
self.mainArea.layout().addWidget(self.graphview)
info = gui.widgetBox(self.controlArea, 'Info')
gui.label(info, self, '%(n_object_types)d object types')
gui.label(info, self, '%(n_relations)d relations')
# Table view of relation details
info = gui.widgetBox(self.controlArea, 'Relations')
class TableView(gui.TableView):
def __init__(self, parent=None, **kwargs):
super().__init__(parent, **kwargs)
self._parent = parent
self.bold_font = self.BoldFontDelegate(self) # member because PyQt sometimes unrefs too early
self.setItemDelegateForColumn(2, self.bold_font)
self.setItemDelegateForColumn(4, self.bold_font)
self.horizontalHeader().setVisible(False)
def selectionChanged(self, selected, deselected):
super().selectionChanged(selected, deselected)
if not selected:
assert len(deselected) > 0
relation = None
else:
assert len(selected) == 1
data = self._parent.tablemodel[selected[0].top()][0]
relation = Relation(data)
self._parent.send(Output.RELATION, relation)
model = self.tablemodel = PyTableModel(parent=self)
table = self.table = TableView(self,
selectionMode=TableView.SingleSelection)
table.setModel(model)
info.layout().addWidget(self.table)
gui.lineEdit(self.controlArea,
self, 'pref_algo_name', 'Fuser name:',
orientation='horizontal',
callback=self.checkcommit, enterPlaceholder=True)
gui.radioButtons(self.controlArea,
self, 'pref_algorithm', [i[0] for i in DECOMPOSITION_ALGO],
box='Decomposition algorithm',
callback=self.checkcommit)
gui.radioButtons(self.controlArea,
self, 'pref_initialization', INITIALIZATION_ALGO,
box='Initialization algorithm',
callback=self.checkcommit)
slider = gui.hSlider(
self.controlArea, self, 'pref_n_iterations',
'Maximum number of iterations',
minValue=10, maxValue=500, createLabel=True,
callback=self.checkcommit)
slider.setTracking(False)
self.slider_rank = gui.hSlider(self.controlArea, self, 'pref_rank',
'Factorization rank',
minValue=1, maxValue=100, createLabel=True,
labelFormat=" %d%%",
callback=self.checkcommit)
self.slider_rank.setTracking(False)
gui.auto_commit(self.controlArea, self, "autorun", "Run",
checkbox_label="Run after any change ")
def _create_layout(self):
info = gui.widgetBox(self.controlArea, 'Info')
gui.label(info, self, '%(n_object_types)d object types')
gui.label(info, self, '%(n_relations)d relations')
# Table view of relation details
info = gui.widgetBox(self.controlArea, 'Relations')
def send_relation(item):
data = item.data(QtCore.Qt.UserRole)
self.send(Output.RELATION, Relation(data))
self.table = SimpleTableWidget(info, callback=send_relation)
self.controlArea.layout().addStretch(1)
gui.lineEdit(self.controlArea,
self, 'pref_algo_name', 'Fuser name',
callback=self.checkcommit, enterPlaceholder=True)
gui.radioButtons(self.controlArea,
self, 'pref_algorithm', [i[0] for i in DECOMPOSITION_ALGO],
box='Decomposition algorithm',
callback=self.checkcommit)
gui.radioButtons(self.controlArea,
self, 'pref_initialization', INITIALIZATION_ALGO,
box='Initialization algorithm',
callback=self.checkcommit)
gui.hSlider(self.controlArea, self, 'pref_n_iterations',
'Maximum number of iterations',
minValue=10, maxValue=500, createLabel=True,
callback=self.checkcommit)
self.slider_rank = gui.hSlider(self.controlArea, self, 'pref_rank',
'Factorization rank',
minValue=1, maxValue=100, createLabel=True,
labelFormat=" %d%%",
callback=self.checkcommit)
gui.auto_commit(self.controlArea, self, "autorun", "Run",
checkbox_label="Run after any change ")
def __init__(self):
super().__init__()
self.data = None
self.preprocessors = None
box = gui.widgetBox(self.controlArea, self.tr("Name"))
gui.lineEdit(box, self, "learner_name")
box = gui.widgetBox(self.controlArea, box=True)
gui.comboBox(box, self, "penalty_type", label="Regularization type: ",
items=self.penalty_types,
orientation="horizontal", addSpace=4)
gui.widgetLabel(box, "Strength:")
box2 = gui.widgetBox(gui.indentedBox(box), orientation="horizontal")
gui.widgetLabel(box2, "Weak").setStyleSheet("margin-top:6px")
gui.hSlider(box2, self, "C_index",
minValue=0, maxValue=len(self.C_s) - 1,
callback=self.set_c, createLabel=False)
gui.widgetLabel(box2, "Strong").setStyleSheet("margin-top:6px")
box2 = gui.widgetBox(box, orientation="horizontal")
box2.layout().setAlignment(Qt.AlignCenter)
self.c_label = gui.widgetLabel(box2)
box = gui.widgetBox(self.controlArea, orientation="horizontal",
margin=0)
box.layout().addWidget(self.report_button)
gui.button(box, self, "&Apply", callback=self.apply, default=True)
self.set_c()
self.apply()
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=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 __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 __init__(self):
super().__init__()
self.data = None
self.allAttrs = []
self.stringAttrs = []
self.selectedIndices = []
#: List of _ImageItems
self.items = []
self._errcount = 0
self._successcount = 0
self.info = gui.widgetLabel(
gui.vBox(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],
contentsLength=12,
addSpace=True,
)
self.titleAttrCB = gui.comboBox(
self.controlArea, self, "titleAttr",
box="Title Attribute",
tooltip="Attribute with image title",
callback=self.updateTitles,
contentsLength=12,
addSpace=True
)
self.titleAttrCB.setStyleSheet("combobox-popup: 0;")
gui.hSlider(
self.controlArea, self, "imageSize",
box="Image Size", minValue=32, maxValue=1024, step=16,
callback=self.updateSize,
createLabel=False
)
gui.rubber(self.controlArea)
gui.auto_commit(self.buttonsArea, self, "autoCommit", "Send", box=False)
self.thumbnailView = ThumbnailView(
alignment=Qt.AlignTop | Qt.AlignLeft, # scene alignment,
focusPolicy=Qt.StrongFocus,
verticalScrollBarPolicy=Qt.ScrollBarAlwaysOn
)
self.mainArea.layout().addWidget(self.thumbnailView)
self.scene = self.thumbnailView.scene()
self.scene.selectionChanged.connect(self.onSelectionChanged)
self.loader = ImageLoader(self)
def __init__(self):
super().__init__()
self.data = None # type: Optional[Table]
self.preprocessed_data = None # type: Optional[Table]
self.pca_projection = None # type: Optional[Table]
self.graph = None # type: Optional[nx.Graph]
self.partition = None # type: Optional[np.array]
# Use a executor with a single worker, to limit CPU overcommitment for
# cancelled tasks. The method does not have a fine cancellation
# granularity so we assure that there are not N - 1 jobs executing
# for no reason only to be thrown away. It would be better to use the
# global pool but implement a limit on jobs from this source.
self.__executor = futures.ThreadPoolExecutor(max_workers=1)
self.__task = None # type: Optional[TaskState]
self.__invalidated = False
# coalescing commit timer
self.__commit_timer = QTimer(self, singleShot=True)
self.__commit_timer.timeout.connect(self.commit)
pca_box = gui.vBox(self.controlArea, 'PCA Preprocessing')
self.apply_pca_cbx = gui.checkBox(
pca_box, self, 'apply_pca', label='Apply PCA preprocessing',
callback=self._invalidate_graph,
) # type: QCheckBox
self.pca_components_slider = gui.hSlider(
pca_box, self, 'pca_components', label='Components: ', minValue=2,
maxValue=_MAX_PCA_COMPONENTS,
callback=self._invalidate_pca_projection, tracking=False
) # type: QSlider
graph_box = gui.vBox(self.controlArea, 'Graph parameters')
self.metric_combo = gui.comboBox(
graph_box, self, 'metric_idx', label='Distance metric',
items=[m[0] for m in METRICS], callback=self._invalidate_graph,
orientation=Qt.Horizontal,
) # type: gui.OrangeComboBox
self.k_neighbors_spin = gui.spin(
graph_box, self, 'k_neighbors', minv=1, maxv=_MAX_K_NEIGBOURS,
label='k neighbors', controlWidth=80, alignment=Qt.AlignRight,
callback=self._invalidate_graph,
) # type: gui.SpinBoxWFocusOut
self.resolution_spin = gui.hSlider(
graph_box, self, 'resolution', minValue=0, maxValue=5., step=1e-1,
label='Resolution', intOnly=False, labelFormat='%.1f',
callback=self._invalidate_partition, tracking=False,
) # type: QSlider
self.resolution_spin.parent().setToolTip(
'The resolution parameter affects the number of clusters to find. '
'Smaller values tend to produce more clusters and larger values '
'retrieve less clusters.'
)
self.apply_button = gui.auto_commit(
self.controlArea, self, 'auto_commit', 'Apply', box=None,
commit=lambda: self.commit(),
callback=lambda: self._on_auto_commit_changed(),
) # type: QWidget
def add_bottom_buttons(self):
box = gui.vBox(self.controlArea, 'Forecast')
gui.spin(box, self, 'forecast_steps', 1, 100,
label='Forecast steps ahead:',
callback=self.apply)
gui.hSlider(box, self, 'forecast_confint',
None, 1, 99, label='Confidence intervals:',
callback=self.apply)
gui.auto_commit(self.controlArea, self, 'autocommit', "&Apply")
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):
self.tree = QTreeWidget(self.mainArea,
columnCount=2,
allColumnsShowFocus=True,
alternatingRowColors=True,
selectionMode=QTreeWidget.ExtendedSelection,
uniformRowHeights=True)
self.tree.setHeaderLabels(["Itemsets", "Support", "%"])
self.tree.header().setStretchLastSection(True)
self.tree.itemSelectionChanged.connect(self.selectionChanged)
self.mainArea.layout().addWidget(self.tree)
box = gui.widgetBox(self.controlArea, "Info")
self.nItemsets = self.nSelectedExamples = self.nSelectedItemsets = ''
gui.label(box, self, "Number of itemsets: %(nItemsets)s")
gui.label(box, self, "Selected itemsets: %(nSelectedItemsets)s")
gui.label(box, self, "Selected examples: %(nSelectedExamples)s")
hbox = gui.widgetBox(box, orientation='horizontal')
gui.button(hbox, self, "Expand all", callback=self.tree.expandAll)
gui.button(hbox, self, "Collapse all", callback=self.tree.collapseAll)
box = gui.widgetBox(self.controlArea, 'Find itemsets')
gui.hSlider(box, self, 'minSupport', minValue=1, maxValue=100,
label='Minimal support:', labelFormat="%d%%",
callback=lambda: self.find_itemsets())
gui.hSlider(box, self, 'maxItemsets', minValue=10000, maxValue=100000, step=10000,
label='Max. number of itemsets:', labelFormat="%d",
callback=lambda: self.find_itemsets())
gui.checkBox(box, self, 'filterSearch',
label='Apply below filters in search',
tooltip='If checked, the itemsets are filtered according '
'to below filter conditions already in the search '
'phase. \nIf unchecked, the only filters applied '
'during search are the ones above, '
'and the itemsets are \nfiltered afterwards only for '
'display, i.e. only the matching itemsets are shown.')
self.button = gui.auto_commit(
box, self, 'autoFind', 'Find itemsets', commit=self.find_itemsets)
box = gui.widgetBox(self.controlArea, 'Filter itemsets')
gui.lineEdit(box, self, 'filterKeywords', 'Contains:',
callback=self.filter_change, orientation='horizontal',
tooltip='A comma or space-separated list of regular '
'expressions.')
hbox = gui.widgetBox(box, orientation='horizontal')
gui.spin(hbox, self, 'filterMinItems', 1, 998, label='Min. items:',
callback=self.filter_change)
gui.spin(hbox, self, 'filterMaxItems', 2, 999, label='Max. items:',
callback=self.filter_change)
gui.rubber(hbox)
gui.rubber(self.controlArea)
gui.auto_commit(self.controlArea, self, 'autoSend', 'Send selection')
self.filter_change()
def __init__(self):
super().__init__()
self.selected_node = None
self.root_node = None
self.model = None
box = gui.vBox(
self.controlArea, 'Tree', addSpace=20,
sizePolicy=QSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed))
self.infolabel = gui.widgetLabel(box, 'No tree.')
layout = QFormLayout()
layout.setVerticalSpacing(20)
layout.setFieldGrowthPolicy(layout.ExpandingFieldsGrow)
box = self.display_box = \
gui.widgetBox(self.controlArea, "Display", addSpace=True,
orientation=layout)
layout.addRow(
"Zoom: ",
gui.hSlider(box, self, 'zoom',
minValue=1, maxValue=10, step=1, ticks=False,
callback=self.toggle_zoom_slider,
createLabel=False, addToLayout=False, addSpace=False))
layout.addRow(
"Width: ",
gui.hSlider(box, self, 'max_node_width',
minValue=50, maxValue=200, step=1, ticks=False,
callback=self.toggle_node_size,
createLabel=False, addToLayout=False, addSpace=False))
policy = QSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.Fixed)
layout.addRow(
"Depth: ",
gui.comboBox(box, self, 'max_tree_depth',
items=["Unlimited"] + [
"{} levels".format(x) for x in range(2, 10)],
addToLayout=False, sendSelectedValue=False,
callback=self.toggle_tree_depth, sizePolicy=policy))
layout.addRow(
"Edge width: ",
gui.comboBox(box, self, 'line_width_method',
items=['Fixed', 'Relative to root',
'Relative to parent'],
addToLayout=False,
callback=self.toggle_line_width, sizePolicy=policy))
gui.rubber(self.controlArea)
self.resize(800, 500)
self.scene = TreeGraphicsScene(self)
self.scene_view = TreeGraphicsView(self.scene)
self.scene_view.setViewportUpdateMode(QGraphicsView.FullViewportUpdate)
self.mainArea.layout().addWidget(self.scene_view)
self.toggle_zoom_slider()
self.scene.selectionChanged.connect(self.update_selection)
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._param_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._param_changed)
gui.widgetLabel(ibox, "Relative training set size:")
gui.hSlider(ibox, self, "sample_p", minValue=1, maxValue=100,
ticks=20, vertical=False,
callback=self._param_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)
gui.rubber(self.controlArea)
self.view = QTreeView(
rootIsDecorated=False,
uniformRowHeights=True,
wordWrap=True,
editTriggers=QTreeView.NoEditTriggers
)
self.result_model = QStandardItemModel()
self.result_model.setHorizontalHeaderLabels(
["Method"] + classification_stats.headers
)
self.view.setModel(self.result_model)
box = gui.widgetBox(self.mainArea, "Evaluation Results")
box.layout().addWidget(self.view)
def __init__(self, parent=None):
widget.OWWidget.__init__(self, parent)
self.data = None
self.target_group = None, []
self.targets = []
self.current_selection = []
self.validindices = numpy.empty((0,), dtype=int)
self.graph = VolcanoGraph(symbolSize=self.symbol_size, background="w")
self.graph.setSelectionMode(
VolcanoGraph.SymetricSelection if self.symetric_selections else
VolcanoGraph.RectSelection)
self.graph.selectionChanged.connect(self.on_selection_changed)
self.graph.scene().installEventFilter(self)
self.graph.getViewBox().setMouseEnabled(False, False)
self.graph.getViewBox().enableAutoRange(enable=True)
self.graph.plotItem.showGrid(True, True, 0.3)
self.mainArea.layout().addWidget(self.graph)
## GUI
box = gui.widgetBox(self.controlArea, "Info")
self.infoLabel = gui.label(box, self, "")
self.infoLabel.setText("No data on input")
self.infoLabel2 = gui.label(box, self, "")
self.infoLabel2.setText("0 selected genes")
box = gui.widgetBox(self.controlArea, "Target Labels")
self.target_widget = guiutils.LabelSelectionWidget(
self,
groupChanged=self.on_label_activated,
groupSelectionChanged=self.on_target_changed)
box.layout().addWidget(self.target_widget)
box = gui.widgetBox(self.controlArea, "Settings")
gui.hSlider(box, self, "symbol_size", label="Symbol size: ",
minValue=2, maxValue=20, step=1,
callback=lambda:
self.graph.setSymbolSize(self.symbol_size))
gui.checkBox(box, self, "symetric_selections", "Symmetric selection",
callback=self.__on_selectionModeChanged)
gui.auto_commit(self.controlArea, self, "auto_commit", "Commit")
gui.rubber(self.controlArea)
def _create_layout(self):
self.mainArea.layout().addWidget(self.graphview)
info = gui.widgetBox(self.controlArea, 'Info')
gui.label(info, self, '%(n_object_types)d object types')
gui.label(info, self, '%(n_relations)d relations')
# Table view of relation details
info = gui.widgetBox(self.controlArea, 'Relations')
def send_relation(selected, deselected):
if not selected:
assert len(deselected) > 0
relation = None
else:
assert len(selected) == 1
data = self.table.rowData(selected[0].top())
relation = Relation(data)
self.send(Output.RELATION, relation)
self.table = gui.TableWidget(info, select_rows=True)
self.table.selectionChanged = send_relation
self.table.setColumnFilter(bold_item, (1, 3))
gui.lineEdit(self.controlArea,
self, 'pref_algo_name', 'Fuser name:',
orientation='horizontal',
callback=self.checkcommit, enterPlaceholder=True)
gui.radioButtons(self.controlArea,
self, 'pref_algorithm', [i[0] for i in DECOMPOSITION_ALGO],
box='Decomposition algorithm',
callback=self.checkcommit)
gui.radioButtons(self.controlArea,
self, 'pref_initialization', INITIALIZATION_ALGO,
box='Initialization algorithm',
callback=self.checkcommit)
slider = gui.hSlider(
self.controlArea, self, 'pref_n_iterations',
'Maximum number of iterations',
minValue=10, maxValue=500, createLabel=True,
callback=self.checkcommit)
slider.setTracking(False)
self.slider_rank = gui.hSlider(self.controlArea, self, 'pref_rank',
'Factorization rank',
minValue=1, maxValue=100, createLabel=True,
labelFormat=" %d%%",
callback=self.checkcommit)
self.slider_rank.setTracking(False)
gui.auto_commit(self.controlArea, self, "autorun", "Run",
checkbox_label="Run after any change ")
def __init__(self):
super().__init__()
self.relation = None
form = QtGui.QGridLayout()
methodbox = gui.radioButtonsInBox(
self.controlArea, self, "method", [],
box=self.tr("Sampling method"), orientation=form)
rows = gui.appendRadioButton(methodbox, "Rows", addToLayout=False)
form.addWidget(rows, 0, 0, Qt.AlignLeft)
cols = gui.appendRadioButton(methodbox, "Columns", addToLayout=False)
form.addWidget(cols, 0, 1, Qt.AlignLeft)
rows_and_cols = gui.appendRadioButton(methodbox, "Rows and columns", addToLayout=False)
form.addWidget(rows_and_cols, 1, 0, Qt.AlignLeft)
entries = gui.appendRadioButton(methodbox, "Entries", addToLayout=False)
form.addWidget(entries, 1, 1, Qt.AlignLeft)
sample_size = gui.widgetBox(self.controlArea, "Proportion of data in the sample")
percent = gui.hSlider(
sample_size, self, 'percent', minValue=1, maxValue=100, step=5,
ticks=10, labelFormat=" %d%%")
gui.button(self.controlArea, self, "&Apply",
callback=self.send_output, default=True)
self.setSizePolicy(
QtGui.QSizePolicy(QtGui.QSizePolicy.Fixed,
QtGui.QSizePolicy.Fixed))
self.setMinimumWidth(250)
self.send_output()
def add_main_layout(self):
box = gui.widgetBox(self.controlArea, box=True)
gui.comboBox(box, self, "penalty_type", label="Regularization type: ",
items=self.penalty_types, orientation=Qt.Horizontal,
addSpace=4, callback=self.settings_changed)
gui.widgetLabel(box, "Strength:")
box2 = gui.hBox(gui.indentedBox(box))
gui.widgetLabel(box2, "Weak").setStyleSheet("margin-top:6px")
gui.hSlider(box2, self, "C_index",
minValue=0, maxValue=len(self.C_s) - 1,
callback=self.set_c, createLabel=False)
gui.widgetLabel(box2, "Strong").setStyleSheet("margin-top:6px")
box2 = gui.hBox(box)
box2.layout().setAlignment(Qt.AlignCenter)
self.c_label = gui.widgetLabel(box2)
self.set_c()
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):
super().__init__()
box = gui.widgetBox(self.controlArea, "Movie Selection (from %d)" % len(movielens.get_all_movie_names()))
methodbox = gui.radioButtons(box, self, "method", callback=self._on_method_changed)
gui.appendRadioButton(methodbox, "Fraction of movies")
percent = gui.hSlider(
gui.indentedBox(methodbox), self, "percent", minValue=1, maxValue=100, step=1, ticks=10, labelFormat="%d %%"
)
gui.appendRadioButton(methodbox, "Time period:")
ibox = gui.indentedBox(methodbox)
start = gui.spin(ibox, self, "start", 1907, 2015, 1, label="Starting year: ")
end = gui.spin(ibox, self, "end", 1907, 2015, 1, label="Ending year: ")
self.method_params = [percent, start, end]
gui.button(self.controlArea, self, "&Apply", callback=self.send_output, default=True)
self.setSizePolicy(QtGui.QSizePolicy(QtGui.QSizePolicy.Fixed, QtGui.QSizePolicy.Fixed))
self.setMinimumWidth(250)
self.setMaximumWidth(250)
self._on_method_changed()
self.send_output()
def __init__(self):
super().__init__()
# options box
self.options_box = gui.widgetBox(self.controlArea, "Data")
opts = dict(
widget=self.options_box, master=self, orientation=Qt.Horizontal,
callback=self.restart, sendSelectedValue=True,
maximumContentsLength=15)
self.cbx = gui.comboBox(value='attr_x', label='X: ', **opts)
self.cby = gui.comboBox(value='attr_y', label='Y: ', **opts)
self.centroids_box = gui.widgetBox(self.controlArea, "Centroids")
self.centroid_numbers_spinner = gui.spin(
self.centroids_box, self, 'number_of_clusters',
minv=1, maxv=10, step=1, label='Number of centroids:',
alignment=Qt.AlignRight, callback=self.number_of_clusters_change)
self.restart_button = gui.button(
self.centroids_box, self, "Randomize Positions",
callback=self.restart)
gui.separator(self.centroids_box)
self.lines_checkbox = gui.checkBox(
self.centroids_box, self, 'lines_to_centroids',
'Show membership lines', callback=self.complete_replot)
# control box
gui.separator(self.controlArea, 20, 20)
self.step_box = gui.widgetBox(self.controlArea, "Manually step through")
self.step_button = gui.button(
self.step_box, self, self.STEP_BUTTONS[1], callback=self.step)
self.step_back_button = gui.button(
self.step_box, self, "Step Back", callback=self.step_back)
self.run_box = gui.widgetBox(self.controlArea, "Run")
self.auto_play_speed_spinner = gui.hSlider(
self.run_box, self, 'auto_play_speed', label='Speed:',
minValue=0, maxValue=1.91, step=0.1, intOnly=False,
createLabel=False)
self.auto_play_button = gui.button(
self.run_box, self, self.AUTOPLAY_BUTTONS[0],
callback=self.auto_play)
gui.rubber(self.controlArea)
# disable until data loaded
self.set_disabled_all(True)
# graph in mainArea
self.scatter = Scatterplot(
click_callback=self.graph_clicked,
drop_callback=self.centroid_dropped,
xAxis_gridLineWidth=0, yAxis_gridLineWidth=0,
tooltip_enabled=False,
debug=False)
# Just render an empty chart so it shows a nice 'No data to display'
self.scatter.chart()
self.mainArea.layout().addWidget(self.scatter)
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(QtGui.QLayout.SetFixedSize)
def color_settings_box(self):
box = gui.vBox(self)
self.color_cb = gui.comboBox(box, self, "palette_index", label="Color:",
labelWidth=50, orientation=Qt.Horizontal)
self.color_cb.setIconSize(QSize(64, 16))
palettes = _color_palettes
self.palette_index = min(self.palette_index, len(palettes) - 1)
model = color_palette_model(palettes, self.color_cb.iconSize())
model.setParent(self)
self.color_cb.setModel(model)
self.color_cb.activated.connect(self.update_color_schema)
self.color_cb.setCurrentIndex(self.palette_index)
form = QFormLayout(
formAlignment=Qt.AlignLeft,
labelAlignment=Qt.AlignLeft,
fieldGrowthPolicy=QFormLayout.AllNonFixedFieldsGrow
)
def limit_changed():
self.update_levels()
self.reset_thresholds()
self._level_low_le = lineEditDecimalOrNone(self, self, "level_low", callback=limit_changed)
self._level_low_le.validator().setDefault(0)
form.addRow("Low limit:", self._level_low_le)
self._level_high_le = lineEditDecimalOrNone(self, self, "level_high", callback=limit_changed)
self._level_high_le.validator().setDefault(1)
form.addRow("High limit:", self._level_high_le)
lowslider = gui.hSlider(
box, self, "threshold_low", minValue=0.0, maxValue=1.0,
step=0.05, ticks=True, intOnly=False,
createLabel=False, callback=self.update_levels)
highslider = gui.hSlider(
box, self, "threshold_high", minValue=0.0, maxValue=1.0,
step=0.05, ticks=True, intOnly=False,
createLabel=False, callback=self.update_levels)
form.addRow("Low:", lowslider)
form.addRow("High:", highslider)
box.layout().addLayout(form)
return box
def __init__(self):
self.tree = QTreeWidget(self.mainArea,
columnCount=2,
allColumnsShowFocus=True,
alternatingRowColors=True,
selectionMode=QTreeWidget.ExtendedSelection,
uniformRowHeights=True)
self.tree.setHeaderLabels(["Itemsets", "Support", "%"])
self.tree.header().setStretchLastSection(True)
self.tree.itemSelectionChanged.connect(self.selectionChanged)
self.mainArea.layout().addWidget(self.tree)
box = gui.widgetBox(self.controlArea, "Info")
self.nItemsets = self.nSelectedExamples = self.nSelectedItemsets = ''
gui.label(box, self, "Number of itemsets: %(nItemsets)s")
gui.label(box, self, "Selected itemsets: %(nSelectedItemsets)s")
gui.label(box, self, "Selected examples: %(nSelectedExamples)s")
hbox = gui.widgetBox(box, orientation='horizontal')
gui.button(hbox, self, "Expand all", callback=self.tree.expandAll)
gui.button(hbox, self, "Collapse all", callback=self.tree.collapseAll)
box = gui.widgetBox(self.controlArea, 'Find itemsets')
gui.hSlider(box, self, 'minSupport', minValue=1, maxValue=100,
label='Minimal support [%]', callback=lambda: self.find_itemsets())
gui.hSlider(box, self, 'maxItemsets', minValue=10000, maxValue=100000, step=10000,
label='Max. number of itemsets', callback=lambda: self.find_itemsets())
gui.checkBox(box, self, 'filterSearch',
label='Apply below filters in search')
gui.auto_commit(box, self, 'autoFind', 'Find itemsets', commit=self.find_itemsets)
box = gui.widgetBox(self.controlArea, 'Filter itemsets')
gui.lineEdit(box, self, 'filterKeywords', 'Contains:',
callback=self.filter_change, orientation='horizontal')
hbox = gui.widgetBox(box, orientation='horizontal')
gui.spin(hbox, self, 'filterMinItems', 1, 998, label='Min. items:',
callback=self.filter_change)
gui.spin(hbox, self, 'filterMaxItems', 2, 999, label='Max. items:',
callback=self.filter_change)
gui.rubber(hbox)
gui.rubber(self.controlArea)
gui.auto_commit(self.controlArea, self, 'autoSend', 'Send selection')
self.filter_change()
def _add_controls_start_box(self):
box = gui.vBox(self.controlArea, True)
form = QFormLayout(
labelAlignment=Qt.AlignLeft,
formAlignment=Qt.AlignLeft,
fieldGrowthPolicy=QFormLayout.AllNonFixedFieldsGrow,
verticalSpacing=10,
)
self.perplexity_spin = gui.spin(
box, self, "perplexity", 1, 500, step=1, alignment=Qt.AlignRight,
callback=self._params_changed
)
form.addRow("Perplexity:", self.perplexity_spin)
self.perplexity_spin.setEnabled(not self.multiscale)
form.addRow(gui.checkBox(
box, self, "multiscale", label="Preserve global structure",
callback=self._multiscale_changed
))
sbe = gui.hBox(self.controlArea, False, addToLayout=False)
gui.hSlider(
sbe, self, "exaggeration", minValue=1, maxValue=4, step=1,
callback=self._params_changed
)
form.addRow("Exaggeration:", sbe)
sbp = gui.hBox(self.controlArea, False, addToLayout=False)
gui.hSlider(
sbp, self, "pca_components", minValue=2, maxValue=50, step=1,
callback=self._invalidate_pca_projection
)
form.addRow("PCA components:", sbp)
self.normalize_cbx = gui.checkBox(
box, self, "normalize", "Normalize data",
callback=self._invalidate_pca_projection,
)
form.addRow(self.normalize_cbx)
box.layout().addLayout(form)
gui.separator(box, 10)
self.runbutton = gui.button(box, self, "Run", callback=self._toggle_run)
def __init__(self):
super().__init__()
self.root = None
self.selected_node = None
self.root_node = None
self.tree = None
box = gui.widgetBox(
self.controlArea, 'Tree size', addSpace=20,
sizePolicy=QSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed))
self.info = gui.widgetLabel(box, 'No tree.')
layout = QGridLayout()
layout.setVerticalSpacing(20)
box = gui.widgetBox(self.controlArea, "Size", addSpace=True,
orientation=layout)
layout.addWidget(QLabel("Zoom: "), 0, 0, Qt.AlignRight)
layout.addWidget(gui.hSlider(
box, self, 'zoom', minValue=1, maxValue=10, step=1,
createLabel=False, ticks=False, addToLayout=False, addSpace=False,
callback=self.toggle_zoom_slider), 0, 1)
layout.addWidget(QLabel("Width: "), 1, 0, Qt.AlignRight)
layout.addWidget(gui.hSlider(
box, self, 'max_node_width', minValue=50, maxValue=200, step=1,
createLabel=False, ticks=False, addToLayout=False, addSpace=False,
callback=self.toggle_node_size), 1, 1)
layout.addWidget(QLabel("Depth: "), 2, 0, Qt.AlignRight)
layout.addWidget(gui.comboBox(
box, self, 'max_tree_depth',
items=["Unlimited"] + ["{} levels".format(x) for x in range(2, 10)],
addToLayout=False,
sendSelectedValue=False, callback=self.toggle_tree_depth,
sizePolicy=QSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.Fixed)), 2, 1)
layout.addWidget(QLabel("Edge width: "), 3, 0, Qt.AlignRight)
layout.addWidget(gui.comboBox(
box, self, 'line_width_method', addToLayout=False,
items=['Fixed', 'Relative to root', 'Relative to parent'],
callback=self.toggle_line_width), 3, 1)
self.resize(800, 500)
def __init__(self):
self.data = None
box = gui.vBox(self.controlArea, 'Granger Test')
gui.hSlider(box, self, 'confidence',
minValue=90, maxValue=99,
label='Confidence:',
labelFormat=" %d%%",
callback=self.on_changed)
gui.spin(box, self, 'max_lag', 1, 50,
label='Max lag:',
callback=self.on_changed)
gui.auto_commit(box, self, 'autocommit', '&Test')
gui.rubber(self.controlArea)
self.model = model = PyTableModel(parent=self)
model.setHorizontalHeaderLabels(['Min. lag', 'Series 1', '', 'Series 2'])
view = gui.TableView(self)
view.setModel(model)
bold = view.BoldFontDelegate(self)
view.setItemDelegateForColumn(1, bold)
view.setItemDelegateForColumn(3, bold)
view.horizontalHeader().setStretchLastSection(False)
self.mainArea.layout().addWidget(view)
def add_main_layout(self):
form = QFormLayout()
form.setFieldGrowthPolicy(form.AllNonFixedFieldsGrow)
form.setVerticalSpacing(25)
form.setLabelAlignment(Qt.AlignLeft)
gui.widgetBox(self.controlArea, True, orientation=form)
form.addRow(
"Neurons in hidden layers:",
gui.lineEdit(
None, self, "hidden_layers_input",
orientation=Qt.Horizontal, callback=self.settings_changed,
tooltip="A list of integers defining neurons. Length of list "
"defines the number of layers. E.g. 4, 2, 2, 3.",
placeholderText="e.g. 10,"))
form.addRow(
"Activation:",
gui.comboBox(
None, self, "activation_index", orientation=Qt.Horizontal,
label="Activation:", items=[i for i in self.act_lbl],
callback=self.settings_changed))
form.addRow(" ", gui.separator(None, 16))
form.addRow(
"Solver:",
gui.comboBox(
None, self, "solver_index", orientation=Qt.Horizontal,
label="Solver:", items=[i for i in self.solv_lbl],
callback=self.settings_changed))
self.reg_label = QLabel()
slider = gui.hSlider(
None, self, "alpha_index",
minValue=0, maxValue=len(self.alphas) - 1,
callback=lambda: (self.set_alpha(), self.settings_changed()),
createLabel=False)
form.addRow(self.reg_label, slider)
self.set_alpha()
form.addRow(
"Maximal number of iterations:",
gui.spin(
None, self, "max_iterations", 10, 10000, step=10,
label="Max iterations:", orientation=Qt.Horizontal,
alignment=Qt.AlignRight, callback=self.settings_changed))
form.addRow(gui.separator(None))
form.addRow(
gui.checkBox(
None, self, "replicable", label="Replicable training", callback=self.settings_changed),
)
def __init__(self):
super().__init__()
self.movies = None
self.infobox = gui.widgetBox(self.controlArea, "Select Actors")
percent = gui.hSlider(
gui.indentedBox(self.infobox), self, "percent",
minValue=1, maxValue=100, step=1, ticks=10, labelFormat="%d %%")
gui.button(self.controlArea, self, "&Apply",
callback=self.send_output, default=True)
self.setSizePolicy(QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed))
self.setMinimumWidth(250)
self.setMaximumWidth(250)
self.movies = None
def _create_layout(self):
self._add_graph()
box = gui.widgetBox(self.controlArea, "Relevance")
self.rel_slider = gui.hSlider(
box,
self,
"relevance",
minValue=0,
maxValue=1,
step=0.1,
intOnly=False,
labelFormat="%.1f",
callback_finished=self.on_params_change,
createLabel=True,
)
self.topic_box = gui.listBox(
self.controlArea,
self,
"selected_topic",
"topic_list",
box="Topics",
callback=self.on_params_change,
)
def __init__(self):
super().__init__()
if self.compatibility_mode:
self.Information.compatibility_mode()
self.data = None
self.indices = None
self.sampled_instances = self.remaining_instances = None
self.info.set_input_summary(self.info.NoInput)
self.info.set_output_summary(self.info.NoInput)
self.sampling_box = gui.vBox(self.controlArea, "Sampling Type")
sampling = gui.radioButtons(self.sampling_box,
self,
"sampling_type",
callback=self.sampling_type_changed)
def set_sampling_type(i):
def set_sampling_type_i():
self.sampling_type = i
self.sampling_type_changed()
return set_sampling_type_i
gui.appendRadioButton(sampling, "Fixed proportion of data:")
self.sampleSizePercentageSlider = gui.hSlider(
gui.indentedBox(sampling),
self,
"sampleSizePercentage",
minValue=0,
maxValue=100,
ticks=10,
labelFormat="%d %%",
callback=set_sampling_type(self.FixedProportion),
addSpace=12)
gui.appendRadioButton(sampling, "Fixed sample size")
ibox = gui.indentedBox(sampling)
self.sampleSizeSpin = gui.spin(ibox,
self,
"sampleSizeNumber",
label="Instances: ",
minv=1,
maxv=self._MAX_SAMPLE_SIZE,
callback=set_sampling_type(
self.FixedSize),
controlWidth=90)
gui.checkBox(ibox,
self,
"replacement",
"Sample with replacement",
callback=set_sampling_type(self.FixedSize),
addSpace=12)
gui.appendRadioButton(sampling, "Cross validation")
form = QFormLayout(formAlignment=Qt.AlignLeft | Qt.AlignTop,
labelAlignment=Qt.AlignLeft,
fieldGrowthPolicy=QFormLayout.AllNonFixedFieldsGrow)
ibox = gui.indentedBox(sampling, addSpace=True, orientation=form)
form.addRow(
"Number of subsets:",
gui.spin(ibox,
self,
"number_of_folds",
2,
100,
addToLayout=False,
callback=self.number_of_folds_changed))
self.selected_fold_spin = gui.spin(ibox,
self,
"selectedFold",
1,
self.number_of_folds,
addToLayout=False,
callback=self.fold_changed)
form.addRow(
"Unused subset:" if not self.compatibility_mode else
"Selected subset:", self.selected_fold_spin)
gui.appendRadioButton(sampling, "Bootstrap")
self.sql_box = gui.vBox(self.controlArea, "Sampling Type")
sampling = gui.radioButtons(self.sql_box,
self,
"sampling_type",
callback=self.sampling_type_changed)
gui.appendRadioButton(sampling, "Time:")
ibox = gui.indentedBox(sampling)
spin = gui.spin(ibox,
self,
"sampleSizeSqlTime",
minv=1,
maxv=3600,
callback=set_sampling_type(self.SqlTime))
spin.setSuffix(" sec")
gui.appendRadioButton(sampling, "Percentage")
ibox = gui.indentedBox(sampling)
spin = gui.spin(ibox,
self,
"sampleSizeSqlPercentage",
spinType=float,
minv=0.0001,
maxv=100,
step=0.1,
decimals=4,
callback=set_sampling_type(self.SqlProportion))
spin.setSuffix(" %")
self.sql_box.setVisible(False)
self.options_box = gui.vBox(self.controlArea, "Options")
self.cb_seed = gui.checkBox(self.options_box,
self,
"use_seed",
"Replicable (deterministic) sampling",
callback=self.settings_changed)
self.cb_stratify = gui.checkBox(self.options_box,
self,
"stratify",
"Stratify sample (when possible)",
callback=self.settings_changed)
self.cb_sql_dl = gui.checkBox(self.options_box,
self,
"sql_dl",
"Download data to local memory",
callback=self.settings_changed)
self.cb_sql_dl.setVisible(False)
gui.button(self.buttonsArea, self, "Sample Data", callback=self.commit)
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,
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)
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)
gui.auto_send(self.buttonsArea, self, "auto_commit")
self.scene = GraphicsScene(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)
def __init__(self):
super().__init__()
self.matrix = None
self.data = None
self.subset_data = None # type: Optional[Orange.data.Table]
self.matrix_data = None
self.signal_data = None
self._pen_data = None
self._brush_data = None
self._shape_data = None
self._size_data = None
self._label_data = None
self._similar_pairs = None
self._scatter_item = None
self._legend_item = None
self._selection_mask = None
self._subset_mask = None # type: Optional[numpy.ndarray]
self._invalidated = False
self._effective_matrix = None
self.__update_loop = None
self.__state = OWMDS.Waiting
self.__in_next_step = False
self.__draw_similar_pairs = False
box = gui.vBox(self.controlArea, "MDS Optimization")
form = QtGui.QFormLayout(
labelAlignment=Qt.AlignLeft,
formAlignment=Qt.AlignLeft,
fieldGrowthPolicy=QtGui.QFormLayout.AllNonFixedFieldsGrow,
verticalSpacing=10
)
form.addRow("Max iterations:",
gui.spin(box, self, "max_iter", 10, 10 ** 4, step=1))
form.addRow("Initialization:",
gui.comboBox(box, self, "initialization",
items=["PCA (Torgerson)", "Random"],
callback=self.__invalidate_embedding))
box.layout().addLayout(form)
form.addRow("Refresh:",
gui.comboBox(
box, self, "refresh_rate",
items=[t for t, _ in OWMDS.RefreshRate],
callback=self.__invalidate_refresh))
gui.separator(box, 10)
self.runbutton = gui.button(
box, self, "Run", callback=self._toggle_run)
box = gui.vBox(self.controlArea, "Graph")
self.colorvar_model = itemmodels.VariableListModel()
common_options = dict(
sendSelectedValue=True, valueType=str, orientation=Qt.Horizontal,
labelWidth=50, contentsLength=12)
self.cb_color_value = gui.comboBox(
box, self, "color_value", label="Color:",
callback=self._on_color_index_changed, **common_options)
self.cb_color_value.setModel(self.colorvar_model)
self.shapevar_model = itemmodels.VariableListModel()
self.cb_shape_value = gui.comboBox(
box, self, "shape_value", label="Shape:",
callback=self._on_shape_index_changed, **common_options)
self.cb_shape_value.setModel(self.shapevar_model)
self.sizevar_model = itemmodels.VariableListModel()
self.cb_size_value = gui.comboBox(
box, self, "size_value", label="Size:",
callback=self._on_size_index_changed, **common_options)
self.cb_size_value.setModel(self.sizevar_model)
self.labelvar_model = itemmodels.VariableListModel()
self.cb_label_value = gui.comboBox(
box, self, "label_value", label="Label:",
callback=self._on_label_index_changed, **common_options)
self.cb_label_value.setModel(self.labelvar_model)
gui.checkBox(
gui.indentedBox(box), self, 'label_only_selected',
'Label only selected points', callback=self._on_label_index_changed)
form = QtGui.QFormLayout(
labelAlignment=Qt.AlignLeft,
formAlignment=Qt.AlignLeft,
fieldGrowthPolicy=QtGui.QFormLayout.AllNonFixedFieldsGrow,
verticalSpacing=10
)
form.addRow("Symbol size:",
gui.hSlider(box, self, "symbol_size",
minValue=1, maxValue=20,
callback=self._on_size_index_changed,
createLabel=False))
form.addRow("Symbol opacity:",
gui.hSlider(box, self, "symbol_opacity",
minValue=100, maxValue=255, step=100,
callback=self._on_color_index_changed,
createLabel=False))
form.addRow("Show similar pairs:",
gui.hSlider(
gui.hBox(self.controlArea),
self, "connected_pairs", minValue=0, maxValue=20,
createLabel=False,
callback=self._on_connected_changed))
form.addRow("Jitter:",
gui.comboBox(
box, self, "jitter",
items=[text for text, _ in self.JitterAmount],
callback=self._update_plot))
box.layout().addLayout(form)
gui.rubber(self.controlArea)
box = QtGui.QGroupBox("Zoom/Select", )
box.setLayout(QtGui.QHBoxLayout())
box.layout().setContentsMargins(2, 2, 2, 2)
group = QtGui.QActionGroup(self, exclusive=True)
def icon(name):
path = "icons/Dlg_{}.png".format(name)
path = pkg_resources.resource_filename(widget.__name__, path)
return QtGui.QIcon(path)
action_select = QtGui.QAction(
"Select", self, checkable=True, checked=True, icon=icon("arrow"),
shortcut=QtGui.QKeySequence(Qt.ControlModifier + Qt.Key_1))
action_zoom = QtGui.QAction(
"Zoom", self, checkable=True, checked=False, icon=icon("zoom"),
shortcut=QtGui.QKeySequence(Qt.ControlModifier + Qt.Key_2))
action_pan = QtGui.QAction(
"Pan", self, checkable=True, checked=False, icon=icon("pan_hand"),
shortcut=QtGui.QKeySequence(Qt.ControlModifier + Qt.Key_3))
action_reset_zoom = QtGui.QAction(
"Zoom to fit", self, icon=icon("zoom_reset"),
shortcut=QtGui.QKeySequence(Qt.ControlModifier + Qt.Key_0))
action_reset_zoom.triggered.connect(
lambda: self.plot.autoRange(padding=0.1,
items=[self._scatter_item]))
group.addAction(action_select)
group.addAction(action_zoom)
group.addAction(action_pan)
self.addActions(group.actions() + [action_reset_zoom])
action_select.setChecked(True)
def button(action):
b = QtGui.QToolButton()
b.setToolButtonStyle(Qt.ToolButtonIconOnly)
b.setDefaultAction(action)
return b
box.layout().addWidget(button(action_select))
box.layout().addWidget(button(action_zoom))
box.layout().addWidget(button(action_pan))
box.layout().addSpacing(4)
box.layout().addWidget(button(action_reset_zoom))
box.layout().addStretch()
self.controlArea.layout().addWidget(box)
box = gui.vBox(self.controlArea, "Output")
self.output_combo = gui.comboBox(
box, self, "output_embedding_role",
items=["Original features only",
"Coordinates only",
"Coordinates as features",
"Coordinates as meta attributes"],
callback=self._invalidate_output, addSpace=4)
gui.auto_commit(box, self, "autocommit", "Send Selected",
checkbox_label="Send selected automatically",
box=None)
self.plot = pg.PlotWidget(background="w", enableMenu=False)
self.plot.setAspectLocked(True)
self.plot.getPlotItem().hideAxis("bottom")
self.plot.getPlotItem().hideAxis("left")
self.plot.getPlotItem().hideButtons()
self.plot.setRenderHint(QtGui.QPainter.Antialiasing)
self.mainArea.layout().addWidget(self.plot)
self.selection_tool = PlotSelectionTool(parent=self)
self.zoom_tool = PlotZoomTool(parent=self)
self.pan_tool = PlotPanTool(parent=self)
self.pinch_tool = PlotPinchZoomTool(parent=self)
self.pinch_tool.setViewBox(self.plot.getViewBox())
self.selection_tool.setViewBox(self.plot.getViewBox())
self.selection_tool.selectionFinished.connect(self.__selection_end)
self.current_tool = self.selection_tool
def activate_tool(action):
self.current_tool.setViewBox(None)
if action is action_select:
active, cur = self.selection_tool, Qt.ArrowCursor
elif action is action_zoom:
active, cur = self.zoom_tool, Qt.ArrowCursor
elif action is action_pan:
active, cur = self.pan_tool, Qt.OpenHandCursor
self.current_tool = active
self.current_tool.setViewBox(self.plot.getViewBox())
self.plot.getViewBox().setCursor(QtGui.QCursor(cur))
group.triggered[QtGui.QAction].connect(activate_tool)
self._initialize()
def __init__(self):
super().__init__()
self.map = map = LeafletMap(self)
self.mainArea.layout().addWidget(map)
self.selection = None
self.data = None
self.learner = None
def selectionChanged(indices):
self.selection = self.data[indices] if self.data is not None and indices else None
self._indices = indices
self.commit()
map.selectionChanged.connect(selectionChanged)
def _set_map_provider():
map.set_map_provider(self.TILE_PROVIDERS[self.tile_provider])
box = gui.vBox(self.controlArea, 'Map')
gui.comboBox(box, self, 'tile_provider',
orientation=Qt.Horizontal,
label='Map:',
items=tuple(self.TILE_PROVIDERS.keys()),
sendSelectedValue=True,
callback=_set_map_provider)
self._latlon_model = DomainModel(
parent=self, valid_types=ContinuousVariable)
self._class_model = DomainModel(
parent=self, placeholder='(None)', valid_types=DomainModel.PRIMITIVE)
self._color_model = DomainModel(
parent=self, placeholder='(Same color)', valid_types=DomainModel.PRIMITIVE)
self._shape_model = DomainModel(
parent=self, placeholder='(Same shape)', valid_types=DiscreteVariable)
self._size_model = DomainModel(
parent=self, placeholder='(Same size)', valid_types=ContinuousVariable)
self._label_model = DomainModel(
parent=self, placeholder='(No labels)')
def _set_lat_long():
self.map.set_data(self.data, self.lat_attr, self.lon_attr)
self.train_model()
self._combo_lat = combo = gui.comboBox(
box, self, 'lat_attr', orientation=Qt.Horizontal,
label='Latitude:', sendSelectedValue=True, callback=_set_lat_long)
combo.setModel(self._latlon_model)
self._combo_lon = combo = gui.comboBox(
box, self, 'lon_attr', orientation=Qt.Horizontal,
label='Longitude:', sendSelectedValue=True, callback=_set_lat_long)
combo.setModel(self._latlon_model)
def _toggle_legend():
self.map.toggle_legend(self.show_legend)
gui.checkBox(box, self, 'show_legend', label='Show legend',
callback=_toggle_legend)
box = gui.vBox(self.controlArea, 'Overlay')
self._combo_class = combo = gui.comboBox(
box, self, 'class_attr', orientation=Qt.Horizontal,
label='Target:', sendSelectedValue=True, callback=self.train_model
)
self.controls.class_attr.setModel(self._class_model)
self.set_learner(self.learner)
box = gui.vBox(self.controlArea, 'Points')
self._combo_color = combo = gui.comboBox(
box, self, 'color_attr',
orientation=Qt.Horizontal,
label='Color:',
sendSelectedValue=True,
callback=lambda: self.map.set_marker_color(self.color_attr))
combo.setModel(self._color_model)
self._combo_label = combo = gui.comboBox(
box, self, 'label_attr',
orientation=Qt.Horizontal,
label='Label:',
sendSelectedValue=True,
callback=lambda: self.map.set_marker_label(self.label_attr))
combo.setModel(self._label_model)
self._combo_shape = combo = gui.comboBox(
box, self, 'shape_attr',
orientation=Qt.Horizontal,
label='Shape:',
sendSelectedValue=True,
callback=lambda: self.map.set_marker_shape(self.shape_attr))
combo.setModel(self._shape_model)
self._combo_size = combo = gui.comboBox(
box, self, 'size_attr',
orientation=Qt.Horizontal,
label='Size:',
sendSelectedValue=True,
callback=lambda: self.map.set_marker_size(self.size_attr))
combo.setModel(self._size_model)
def _set_opacity():
map.set_marker_opacity(self.opacity)
def _set_zoom():
map.set_marker_size_coefficient(self.zoom)
def _set_jittering():
map.set_jittering(self.jittering)
def _set_clustering():
map.set_clustering(self.cluster_points)
self._opacity_slider = gui.hSlider(
box, self, 'opacity', None, 1, 100, 5,
label='Opacity:', labelFormat=' %d%%',
callback=_set_opacity)
self._zoom_slider = gui.valueSlider(
box, self, 'zoom', None, values=(20, 50, 100, 200, 300, 400, 500, 700, 1000),
label='Symbol size:', labelFormat=' %d%%',
callback=_set_zoom)
self._jittering = gui.valueSlider(
box, self, 'jittering', label='Jittering:', values=(0, .5, 1, 2, 5),
labelFormat=' %.1f%%', ticks=True,
callback=_set_jittering)
self._clustering_check = gui.checkBox(
box, self, 'cluster_points', label='Cluster points',
callback=_set_clustering)
gui.rubber(self.controlArea)
gui.auto_commit(self.controlArea, self, 'autocommit', 'Send Selection')
QTimer.singleShot(0, _set_map_provider)
QTimer.singleShot(0, _toggle_legend)
QTimer.singleShot(0, _set_opacity)
QTimer.singleShot(0, _set_zoom)
QTimer.singleShot(0, _set_jittering)
QTimer.singleShot(0, _set_clustering)
def __init__(self):
super().__init__()
self.data = None
self.distributions = None
self.contingencies = None
self.var = self.cvar = None
varbox = gui.vBox(self.controlArea, "Variable")
self.varmodel = itemmodels.VariableListModel()
self.groupvarmodel = []
self.varview = QListView(
selectionMode=QListView.SingleSelection, uniformItemSizes=True
)
self.varview.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Expanding)
self.varview.setModel(self.varmodel)
self.varview.setSelectionModel(
itemmodels.ListSingleSelectionModel(self.varmodel)
)
self.varview.selectionModel().selectionChanged.connect(
self._on_variable_idx_changed
)
varbox.layout().addWidget(self.varview)
box = gui.vBox(self.controlArea, "Precision")
gui.separator(self.controlArea, 4, 4)
box2 = gui.hBox(box)
self.l_smoothing_l = gui.widgetLabel(box2, "Smooth")
gui.hSlider(
box2,
self,
"smoothing_index",
minValue=0,
maxValue=len(self.smoothing_facs) - 1,
callback=self._on_set_smoothing,
createLabel=False,
)
self.l_smoothing_r = gui.widgetLabel(box2, "Precise")
self.cb_disc_cont = gui.checkBox(
gui.indentedBox(box, sep=4),
self,
"disc_cont",
"Bin numeric variables",
callback=self._on_groupvar_idx_changed,
tooltip="Show numeric variables as categorical.",
)
box = gui.vBox(self.controlArea, "Group by")
self.icons = gui.attributeIconDict
self.groupvarview = gui.comboBox(
box,
self,
"groupvar_idx",
callback=self._on_groupvar_idx_changed,
valueType=str,
contentsLength=12,
)
box2 = gui.indentedBox(box, sep=4)
self.cb_rel_freq = gui.checkBox(
box2,
self,
"relative_freq",
"Show relative frequencies",
callback=self._on_relative_freq_changed,
tooltip="Normalize probabilities so that probabilities "
"for each group-by value sum to 1.",
)
gui.separator(box2)
self.cb_prob = gui.comboBox(
box2,
self,
"show_prob",
label="Show probabilities:",
orientation=Qt.Horizontal,
callback=self._on_relative_freq_changed,
tooltip="Show probabilities for a chosen group-by value "
"(at each point probabilities for all group-by values sum to 1).",
)
self.plotview = pg.PlotWidget(background=None)
self.plotview.setRenderHint(QPainter.Antialiasing)
self.mainArea.layout().addWidget(self.plotview)
w = QLabel()
w.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
self.mainArea.layout().addWidget(w, Qt.AlignCenter)
self.ploti = pg.PlotItem()
self.plot = self.ploti.vb
self.ploti.hideButtons()
self.plotview.setCentralItem(self.ploti)
self.plot_prob = pg.ViewBox()
self.ploti.hideAxis("right")
self.ploti.scene().addItem(self.plot_prob)
self.ploti.getAxis("right").linkToView(self.plot_prob)
self.ploti.getAxis("right").setLabel("Probability")
self.plot_prob.setZValue(10)
self.plot_prob.setXLink(self.ploti)
self.update_views()
self.ploti.vb.sigResized.connect(self.update_views)
self.plot_prob.setRange(yRange=[0, 1])
def disable_mouse(plot):
plot.setMouseEnabled(False, False)
plot.setMenuEnabled(False)
disable_mouse(self.plot)
disable_mouse(self.plot_prob)
self.tooltip_items = []
self.plot.scene().installEventFilter(HelpEventDelegate(self.help_event, self))
pen = QPen(self.palette().color(QPalette.Text))
for axis in ("left", "bottom"):
self.ploti.getAxis(axis).setPen(pen)
self._legend = LegendItem()
self._legend.setParentItem(self.plot)
self._legend.hide()
self._legend.anchor((1, 0), (1, 0))
def __init__(self):
super().__init__()
self.matrix = None
self._tree = None
self._ordered_tree = None
self._sorted_matrix = None
self._sort_indices = None
self._selection = None
box = gui.widgetBox(self.controlArea, "Element sorting", margin=0)
self.sorting_cb = gui.comboBox(
box, self, "sorting",
items=["None", "Clustering", "Clustering with ordered leaves"],
callback=self._invalidate_ordering)
box = gui.widgetBox(self.controlArea, "Colors")
self.colormap_cb = gui.comboBox(
box, self, "colormap", callback=self._update_color
)
self.colormap_cb.setIconSize(QSize(64, 16))
self.palettes = list(_color_palettes)
init_color_combo(self.colormap_cb, self.palettes, QSize(64, 16))
self.colormap_cb.setCurrentIndex(self.colormap)
form = QFormLayout(
formAlignment=Qt.AlignLeft,
labelAlignment=Qt.AlignLeft,
fieldGrowthPolicy=QFormLayout.AllNonFixedFieldsGrow
)
# form.addRow(
# "Gamma",
# gui.hSlider(box, self, "color_gamma", minValue=0.0, maxValue=1.0,
# step=0.05, ticks=True, intOnly=False,
# createLabel=False, callback=self._update_color)
# )
form.addRow(
"Low",
gui.hSlider(box, self, "color_low", minValue=0.0, maxValue=1.0,
step=0.05, ticks=True, intOnly=False,
createLabel=False, callback=self._update_color)
)
form.addRow(
"High",
gui.hSlider(box, self, "color_high", minValue=0.0, maxValue=1.0,
step=0.05, ticks=True, intOnly=False,
createLabel=False, callback=self._update_color)
)
box.layout().addLayout(form)
box = gui.widgetBox(self.controlArea, "Annotations")
self.annot_combo = gui.comboBox(box, self, "annotation_idx",
callback=self._invalidate_annotations,
contentsLength=12)
self.annot_combo.setModel(itemmodels.VariableListModel())
self.annot_combo.model()[:] = ["None", "Enumeration"]
self.controlArea.layout().addStretch()
gui.auto_commit(self.controlArea, self, "autocommit",
"Send data", "Auto send is on")
self.inline_graph_report()
self.view = pg.GraphicsView(background="w")
self.mainArea.layout().addWidget(self.view)
self.grid_widget = pg.GraphicsWidget()
self.grid = QGraphicsGridLayout()
self.grid_widget.setLayout(self.grid)
self.viewbox = pg.ViewBox(enableMouse=False, enableMenu=False)
self.viewbox.setAcceptedMouseButtons(Qt.NoButton)
self.viewbox.setAcceptHoverEvents(False)
self.grid.addItem(self.viewbox, 1, 1)
self.left_dendrogram = DendrogramWidget(
self.grid_widget, orientation=DendrogramWidget.Left,
selectionMode=DendrogramWidget.NoSelection,
hoverHighlightEnabled=False
)
self.left_dendrogram.setAcceptedMouseButtons(Qt.NoButton)
self.left_dendrogram.setAcceptHoverEvents(False)
self.top_dendrogram = DendrogramWidget(
self.grid_widget, orientation=DendrogramWidget.Top,
selectionMode=DendrogramWidget.NoSelection,
hoverHighlightEnabled=False
)
self.top_dendrogram.setAcceptedMouseButtons(Qt.NoButton)
self.top_dendrogram.setAcceptHoverEvents(False)
self.grid.addItem(self.left_dendrogram, 1, 0)
self.grid.addItem(self.top_dendrogram, 0, 1)
self.right_labels = TextList(
alignment=Qt.AlignLeft)
self.bottom_labels = TextList(
orientation=Qt.Horizontal, alignment=Qt.AlignRight)
self.grid.addItem(self.right_labels, 1, 2)
self.grid.addItem(self.bottom_labels, 2, 1)
self.view.setCentralItem(self.grid_widget)
self.left_dendrogram.hide()
self.top_dendrogram.hide()
self.right_labels.hide()
self.bottom_labels.hide()
self.matrix_item = None
self.dendrogram = None
self.grid_widget.scene().installEventFilter(self)
self.graphButton.clicked.connect(self.save_graph)
def __init__(self, parent=None):
super().__init__(parent)
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)
gui.auto_commit(self.controlArea, self, "autoCommit", "Commit",
"Auto 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__()
# Instance variables
self.forest_type = self.CLASSIFICATION
self.model = None
self.forest_adapter = None
self.dataset = None
self.clf_dataset = None
# We need to store refernces to the trees and grid items
self.grid_items, self.ptrees = [], []
self.color_palette = None
# Different methods to calculate the size of squares
self.SIZE_CALCULATION = [
('Normal', lambda x: x),
('Square root', lambda x: sqrt(x)),
('Logarithmic', lambda x: log(x * self.size_log_scale)),
]
self.REGRESSION_COLOR_CALC = [
('None', lambda _, __: QtGui.QColor(255, 255, 255)),
('Class mean', self._color_class_mean),
('Standard deviation', self._color_stddev),
]
# CONTROL AREA
# Tree info area
box_info = gui.widgetBox(self.controlArea, 'Forest')
self.ui_info = gui.widgetLabel(box_info, label='')
# Display controls area
box_display = gui.widgetBox(self.controlArea, 'Display')
self.ui_depth_slider = gui.hSlider(
box_display, self, 'depth_limit', label='Depth', ticks=False,
callback=self.max_depth_changed)
self.ui_target_class_combo = gui.comboBox(
box_display, self, 'target_class_index', label='Target class',
orientation='horizontal', items=[], contentsLength=8,
callback=self.target_colors_changed)
self.ui_size_calc_combo = gui.comboBox(
box_display, self, 'size_calc_idx', label='Size',
orientation='horizontal',
items=list(zip(*self.SIZE_CALCULATION))[0], contentsLength=8,
callback=self.size_calc_changed)
self.ui_zoom_slider = gui.hSlider(
box_display, self, 'zoom', label='Zoom', ticks=False, minValue=20,
maxValue=150, callback=self.zoom_changed, createLabel=False)
# Stretch to fit the rest of the unsused area
gui.rubber(self.controlArea)
self.controlArea.setSizePolicy(
QtGui.QSizePolicy.Preferred, QtGui.QSizePolicy.Expanding)
# MAIN AREA
self.scene = QtGui.QGraphicsScene(self)
self.scene.selectionChanged.connect(self.commit)
self.grid = OWGrid()
self.grid.geometryChanged.connect(self._update_scene_rect)
self.scene.addItem(self.grid)
self.view = QtGui.QGraphicsView(self.scene)
self.view.setRenderHint(QtGui.QPainter.Antialiasing, True)
self.view.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOn)
self.mainArea.layout().addWidget(self.view)
self.resize(800, 500)
self.clear()
def _init_ui(self):
namesBox = gui.widgetBox(self.controlArea, "Names")
gui.lineEdit(namesBox,
self,
"attr1",
"Variable X ",
controlWidth=80,
orientation="horizontal",
enterPlaceholder=True,
callback=self._attr_name_changed)
gui.lineEdit(namesBox,
self,
"attr2",
"Variable Y ",
controlWidth=80,
orientation="horizontal",
enterPlaceholder=True,
callback=self._attr_name_changed)
gui.separator(namesBox)
gui.widgetLabel(namesBox, "Class labels")
self.classValuesView = listView = QListView(
selectionMode=QListView.SingleSelection,
sizePolicy=QSizePolicy(QSizePolicy.Ignored, QSizePolicy.Maximum))
listView.setModel(self.class_model)
itemmodels.select_row(listView, 0)
namesBox.layout().addWidget(listView)
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(
[addClassLabel, self.removeClassLabel], self)
actionsWidget.layout().addStretch(10)
actionsWidget.layout().setSpacing(1)
namesBox.layout().addWidget(actionsWidget)
tBox = gui.widgetBox(self.controlArea, "Tools", addSpace=True)
buttonBox = gui.widgetBox(tBox, orientation="horizontal")
toolsBox = gui.widgetBox(buttonBox, orientation=QtGui.QGridLayout())
self.toolActions = QtGui.QActionGroup(self)
self.toolActions.setExclusive(True)
for i, (name, tooltip, tool, icon) in enumerate(self.TOOLS):
action = QAction(
name,
self,
toolTip=tooltip,
checkable=True,
icon=QIcon(icon),
)
action.triggered.connect(partial(self.set_current_tool, tool))
button = QtGui.QToolButton(
iconSize=QSize(24, 24),
toolButtonStyle=Qt.ToolButtonTextUnderIcon,
sizePolicy=QSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.Fixed))
button.setDefaultAction(action)
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(QtGui.QKeySequence.Undo)
redo.setShortcut(QtGui.QKeySequence.Redo)
self.addActions([undo, redo])
gui.separator(tBox)
indBox = gui.indentedBox(tBox, sep=8)
form = QtGui.QFormLayout(
formAlignment=Qt.AlignLeft,
labelAlignment=Qt.AlignLeft,
fieldGrowthPolicy=QtGui.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)
gui.rubber(self.controlArea)
commitBox = gui.widgetBox(self.controlArea, "Commit")
gui.checkBox(commitBox,
self,
"autocommit",
"Commit on change",
tooltip="Send the data on any change.")
gui.button(commitBox, self, "Commit", callback=self.commit)
# main area GUI
viewbox = PaintViewBox()
self.plotview = pg.PlotWidget(background="w", viewBox=viewbox)
self.plot = self.plotview.getPlotItem()
axis_color = self.palette().color(QtGui.QPalette.Text)
axis_pen = QtGui.QPen(axis_color)
tickfont = QtGui.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)
self.plot.setRange(xRange=(0.0, 1.0),
yRange=(0.0, 1.0),
disableAutoRange=True)
self.mainArea.layout().addWidget(self.plotview)
# enable brush tool
self.toolActions.actions()[0].setChecked(True)
self.set_current_tool(self.TOOLS[0][2])
def _add_controls(self):
options = dict(labelWidth=75,
orientation=Qt.Horizontal,
sendSelectedValue=True,
contentsLength=14)
lat_lon_box = gui.vBox(self.controlArea, True)
self.lat_lon_model = DomainModel(DomainModel.MIXED,
valid_types=(ContinuousVariable, ))
# Added by Jean 2020/04/25 for support of selecting Tile provider
gui.comboBox(lat_lon_box,
self,
'graph.tile_provider_key',
label='Map:',
items=list(TILE_PROVIDERS.keys()),
callback=self.graph.update_tile_provider,
**options)
gui.comboBox(lat_lon_box,
self,
'attr_lat',
label='Latitude:',
callback=self.setup_plot,
model=self.lat_lon_model,
**options)
gui.comboBox(lat_lon_box,
self,
'attr_lon',
label='Longitude:',
callback=self.setup_plot,
model=self.lat_lon_model,
**options)
agg_box = gui.vBox(self.controlArea, True)
self.agg_attr_model = DomainModel(valid_types=(ContinuousVariable,
DiscreteVariable))
gui.comboBox(agg_box,
self,
'agg_attr',
label='Attribute:',
callback=self.update_agg,
model=self.agg_attr_model,
**options)
self.agg_func_combo = gui.comboBox(agg_box,
self,
'agg_func',
label='Agg.:',
items=[DEFAULT_AGG_FUNC],
callback=self.graph.update_colors,
**options)
# Modified by Jean 2020/05/13, set max to 3
a_slider = gui.hSlider(agg_box,
self,
'admin_level',
minValue=0,
maxValue=4,
step=1,
label='Detail:',
createLabel=False,
callback=self.setup_plot)
a_slider.setFixedWidth(176)
visualization_box = gui.vBox(self.controlArea, True)
b_slider = gui.hSlider(visualization_box,
self,
"binning_index",
label="Bin width:",
minValue=0,
maxValue=max(1,
len(self.binnings) - 1),
createLabel=False,
callback=self.graph.update_colors)
b_slider.setFixedWidth(176)
av_slider = gui.hSlider(visualization_box,
self,
"graph.alpha_value",
minValue=0,
maxValue=255,
step=10,
label="Opacity:",
createLabel=False,
callback=self.graph.update_colors)
av_slider.setFixedWidth(176)
gui.checkBox(visualization_box,
self,
"graph.show_legend",
"Show legend",
callback=self.graph.update_legend_visibility)
# Added by Jean 2020/06/16 for support of selecting color palette
av_slider.setFixedWidth(176)
gui.comboBox(
visualization_box,
self,
'palette_key',
label='Palette:',
items=list(ContinuousPalettes.keys()),
# items = [palette.friendly_name for palette in ContinuousPalettes.values()],
callback=self.update_palette,
**options)
self.controlArea.layout().addStretch(100)
plot_gui = OWPlotGUI(self)
plot_gui.box_zoom_select(self.controlArea)
gui.auto_send(self.controlArea, self, "auto_commit")
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 = {}
gui.listView(self.controlArea,
self,
"var",
box="变量",
model=DomainModel(valid_types=DomainModel.PRIMITIVE,
separators=False),
callback=self._on_var_changed)
box = self.continuous_box = gui.vBox(self.controlArea, "分布")
slider = gui.hSlider(box,
self,
"number_of_bins",
label="Bin 宽度",
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)
gui.comboBox(box,
self,
"fitted_distribution",
label="拟合分布",
orientation=Qt.Horizontal,
items=(name[0] for name in self.Fitters),
callback=self._on_fitted_dist_changed)
self.smoothing_box = gui.indentedBox(box, 40)
gui.hSlider(self.smoothing_box,
self,
"kde_smoothing",
label="平滑化",
orientation=Qt.Horizontal,
minValue=2,
maxValue=20,
callback=self.replot)
gui.checkBox(box,
self,
"hide_bars",
"隐藏柱子",
stateWhenDisabled=False,
callback=self._on_hide_bars_changed,
disabled=not self.fitted_distribution)
box = gui.vBox(self.controlArea, "列")
gui.comboBox(box,
self,
"cvar",
label="由...分割",
orientation=Qt.Horizontal,
model=DomainModel(
placeholder="(None)",
valid_types=(DiscreteVariable),
),
callback=self._on_cvar_changed,
contentsLength=18)
gui.checkBox(box, self, "stacked_columns", "堆叠列", callback=self.replot)
gui.checkBox(box,
self,
"show_probs",
"显示概率",
callback=self._on_show_probabilities_changed)
gui.checkBox(box,
self,
"cumulative_distr",
"Show cumulative distribution",
callback=self.replot)
gui.auto_apply(self.controlArea, self, commit=self.apply)
self._set_smoothing_visibility()
self._setup_plots()
self._setup_legend()
def __init__(self):
self.data = None
self._is_running = False
self._antecedentMatch = self._consequentMatch = lambda x: True
self.proxy_model = self.ProxyModel(self)
table = self.table = QTableView(
self,
showGrid=False,
sortingEnabled=True,
alternatingRowColors=True,
selectionBehavior=QTableView.SelectRows,
selectionMode=QTableView.ExtendedSelection,
horizontalScrollMode=QTableView.ScrollPerPixel,
verticalScrollMode=QTableView.ScrollPerPixel,
editTriggers=QTableView.NoEditTriggers)
table.verticalHeader().setVisible(False)
table.verticalHeader().setDefaultSectionSize(
table.verticalHeader().minimumSectionSize())
table.horizontalHeader().setStretchLastSection(True)
table.setModel(QStandardItemModel(table))
table.selectionChanged = self.selectionChanged
self.mainArea.layout().addWidget(table)
box = gui.widgetBox(self.controlArea, "Info")
self.nRules = self.nFilteredRules = self.nSelectedExamples = self.nSelectedRules = ''
gui.label(box, self, "Number of rules: %(nRules)s")
gui.label(box, self, "Filtered rules: %(nFilteredRules)s")
gui.label(box, self, "Selected rules: %(nSelectedRules)s")
gui.label(box, self, "Selected examples: %(nSelectedExamples)s")
box = gui.widgetBox(self.controlArea, 'Find association rules')
gui.valueSlider(box,
self,
'minSupport',
values=[.0001, .0005, .001, .005, .01, .05, .1, .5] +
list(range(1, 101)),
label='Minimal support:',
labelFormat="%g%%",
callback=lambda: self.find_rules())
gui.hSlider(box,
self,
'minConfidence',
minValue=1,
maxValue=100,
label='Minimal confidence:',
labelFormat="%g%%",
callback=lambda: self.find_rules())
gui.hSlider(box,
self,
'maxRules',
minValue=10000,
maxValue=100000,
step=10000,
label='Max. number of rules:',
callback=lambda: self.find_rules())
self.cb_classify = gui.checkBox(
box,
self,
'classify',
label='Induce classification (itemset → class) rules')
self.button = gui.auto_commit(box,
self,
'autoFind',
'Find rules',
commit=self.find_rules)
vbox = gui.widgetBox(self.controlArea, 'Filter rules')
## This is disabled because it's hard to make a scatter plot with
## selectable spots. Options:
## * PyQtGraph, which doesn't support selection OOTB (+is poorly
## contrived and under-documented);
## * Orange.widgets.visualize.ScatterPlotGraph, which comes without
## any documentation or comprehensible examples of use whatsoever;
## * QGraphicsView, which would work, but lacks graphing features,
## namely labels, axes, ticks.
##
## I don't feel like pursuing any of those right now, so I am letting
## it to be figured out at a later date.
#~ button = self.scatter_button = gui.button(vbox, self, 'Scatter plot',
#~ callback=self.show_scatter,
#~ autoDefault=False)
#~ button.setDisabled(True)
#~ self.scatter = self.ScatterPlotWindow(self)
box = gui.widgetBox(vbox, 'Antecedent')
gui.lineEdit(box,
self,
'filterKeywordsAntecedent',
'Contains:',
callback=self.filter_change,
orientation='horizontal',
tooltip='A comma or space-separated list of regular '
'expressions.')
hbox = gui.widgetBox(box, orientation='horizontal')
gui.spin(hbox,
self,
'filterAntecedentMin',
1,
998,
label='Min. items:',
callback=self.filter_change)
gui.spin(hbox,
self,
'filterAntecedentMax',
2,
999,
label='Max. items:',
callback=self.filter_change)
gui.rubber(hbox)
box = gui.widgetBox(vbox, 'Consequent')
gui.lineEdit(box,
self,
'filterKeywordsConsequent',
'Contains:',
callback=self.filter_change,
orientation='horizontal',
tooltip='A comma or space-separated list of regular '
'expressions.')
hbox = gui.widgetBox(box, orientation='horizontal')
gui.spin(hbox,
self,
'filterConsequentMin',
1,
998,
label='Min. items:',
callback=self.filter_change)
gui.spin(hbox,
self,
'filterConsequentMax',
2,
999,
label='Max. items:',
callback=self.filter_change)
gui.checkBox(box,
self,
'filterSearch',
label='Apply these filters in search',
tooltip='If checked, the rules are filtered according '
'to these filter conditions already in the search '
'phase. \nIf unchecked, the only filters applied '
'during search are the ones above, '
'and the generated rules \nare filtered afterwards '
'only for display, i.e. only the matching association '
'rules are shown.')
gui.rubber(hbox)
gui.rubber(self.controlArea)
gui.auto_commit(self.controlArea, self, 'autoSend', 'Send selection')
self.filter_change()
def initUI(self):
namesBox = gui.widgetBox(self.controlArea, "Names")
gui.lineEdit(namesBox,
self,
"attr1",
"Variable X ",
controlWidth=80,
orientation="horizontal",
enterPlaceholder=True,
callback=self.commitIf)
gui.lineEdit(namesBox,
self,
"attr2",
"Variable Y ",
controlWidth=80,
orientation="horizontal",
enterPlaceholder=True,
callback=self.commitIf)
gui.separator(namesBox)
gui.widgetLabel(namesBox, "Class labels")
self.classValuesView = listView = QtGui.QListView()
listView.setSelectionMode(QtGui.QListView.SingleSelection)
listView.setSizePolicy(QtGui.QSizePolicy.Ignored,
QtGui.QSizePolicy.Maximum)
listView.setModel(self.classValuesModel)
listView.selectionModel().select(
self.classValuesModel.index(0),
QtGui.QItemSelectionModel.ClearAndSelect)
listView.setFixedHeight(80)
listView.clicked.connect(self.updateCursor)
namesBox.layout().addWidget(listView)
addClassLabel = QtGui.QAction("+", self)
addClassLabel.pyqtConfigure(toolTip="Add class label")
addClassLabel.triggered.connect(self.addNewClassLabel)
self.removeClassLabel = QtGui.QAction("-", self)
self.removeClassLabel.pyqtConfigure(toolTip="Remove class label")
self.removeClassLabel.triggered.connect(self.removeSelectedClassLabel)
actionsWidget = itemmodels.ModelActionsWidget(
[addClassLabel, self.removeClassLabel], self)
actionsWidget.layout().addStretch(10)
actionsWidget.layout().setSpacing(1)
namesBox.layout().addWidget(actionsWidget)
tBox = gui.widgetBox(self.controlArea, "Tools", addSpace=True)
buttonBox = gui.widgetBox(tBox, orientation="horizontal")
toolsBox = gui.widgetBox(buttonBox, orientation=QtGui.QGridLayout())
self.toolActions = QtGui.QActionGroup(self)
self.toolActions.setExclusive(True)
for i, (name, tooltip, tool, icon) in enumerate(self.TOOLS):
action = QtGui.QAction(name, self)
action.setToolTip(tooltip)
action.setCheckable(True)
action.setIcon(QtGui.QIcon(icon))
# using the old connect here due to problems with overloading
self.connect(action,
QtCore.SIGNAL("triggered()"),
lambda tool=tool: self.setCurrentTool(tool))
button = QtGui.QToolButton()
button.setDefaultAction(action)
button.setIconSize(QtCore.QSize(24, 24))
button.setToolButtonStyle(QtCore.Qt.ToolButtonTextUnderIcon)
button.setSizePolicy(QtGui.QSizePolicy.MinimumExpanding,
QtGui.QSizePolicy.Fixed)
toolsBox.layout().addWidget(button, i / 3, i % 3)
self.toolActions.addAction(action)
if name in ("Jitter", "Magnet"):
picture = QtSvg.QSvgRenderer(icon)
pixmap = QtGui.QPixmap(24, 24)
pixmap.fill(QtCore.Qt.transparent)
painter = QtGui.QPainter()
painter.begin(pixmap)
painter.setRenderHints(painter.Antialiasing)
picture.render(painter)
painter.end()
tool.cursor = QtGui.QCursor(pixmap)
for column in range(3):
toolsBox.layout().setColumnMinimumWidth(column, 10)
toolsBox.layout().setColumnStretch(column, 1)
smallButtons = gui.widgetBox(buttonBox)
# undoRedoBox = gui.widgetBox(smallButtons, "", addSpace=True)
icon_undo = _i("Dlg_undo.png", "../icons")
undo = QtGui.QAction(QtGui.QIcon(icon_undo), "", self)
undo.pyqtConfigure(toolTip="Undo Action (Ctrl+Z)")
undo.setShortcut("Ctrl+Z")
undo.triggered.connect(self.undoStack.undo)
icon_redo = _i("Dlg_redo.png", "../icons")
redo = QtGui.QAction(QtGui.QIcon(icon_redo), "", self)
redo.pyqtConfigure(toolTip="Redo Action (Ctrl+Shift+Z)")
redo.setShortcut("Ctrl+Shift+Z")
redo.triggered.connect(self.undoStack.redo)
undoRedoActionsWidget = itemmodels.ModelActionsWidget(
[undo, redo], self, direction=QtGui.QBoxLayout.TopToBottom)
undoRedoActionsWidget.layout().addStretch(10)
undoRedoActionsWidget.layout().setSpacing(1)
smallButtons.layout().addWidget(undoRedoActionsWidget)
gui.separator(tBox)
indBox = gui.indentedBox(tBox, sep=8)
self.radiusSlider = gui.hSlider(indBox,
self,
"brushRadius",
None,
50,
100,
label="Radius",
createLabel=None)
self.densitySlider = gui.hSlider(indBox,
self,
"density",
None,
3,
10,
label="Density",
createLabel=None)
gui.rubber(self.controlArea)
commitBox = gui.widgetBox(self.controlArea, "Commit")
gui.checkBox(commitBox,
self,
"commit_on_change",
"Commit on change",
tooltip="Send the data on any change.")
gui.button(commitBox, self, "Commit", callback=self.sendData)
QtGui.QShortcut("Delete", self).activated.connect(self.deleteSelected)
# enable brush tool
self.toolActions.actions()[0].setChecked(True)
self.setCurrentTool(self.TOOLS[0][2])
# main area GUI
self.mainArea.layout().addWidget(self.plot)
def __init__(self):
super().__init__()
self.data = None
self.projection = None
self.subset_data = None
self._subset_mask = None
self._selection = None
self.__replot_requested = False
self.n_cont_var = 0
#: Remember the saved state to restore
self.__pending_selection_restore = self.selection_indices
self.selection_indices = None
self.variable_x = None
self.variable_y = None
box = gui.vBox(self.mainArea, True, margin=0)
self.graph = OWLinProjGraph(self,
box,
"Plot",
view_box=LinProjInteractiveViewBox)
box.layout().addWidget(self.graph.plot_widget)
plot = self.graph.plot_widget
SIZE_POLICY = (QSizePolicy.Minimum, QSizePolicy.Maximum)
self.variables_selection = VariablesSelection()
self.model_selected = VariableListModel(enable_dnd=True)
self.model_other = VariableListModel(enable_dnd=True)
self.variables_selection(self, self.model_selected, self.model_other)
self.vizrank, self.btn_vizrank = LinearProjectionVizRank.add_vizrank(
self.controlArea, self, "Suggest Features", self._vizrank)
self.variables_selection.add_remove.layout().addWidget(
self.btn_vizrank)
box = gui.widgetBox(self.controlArea,
"Placement",
sizePolicy=SIZE_POLICY)
self.radio_placement = gui.radioButtonsInBox(
box,
self,
"placement",
btnLabels=[
"Circular Placement", "Linear Discriminant Analysis",
"Principal Component Analysis", "Use input projection"
],
callback=self._change_placement)
self.viewbox = plot.getViewBox()
self.replot = None
g = self.graph.gui
box = g.point_properties_box(self.controlArea)
self.models = g.points_models
g.add_widget(g.JitterSizeSlider, box)
box.setSizePolicy(*SIZE_POLICY)
box = gui.widgetBox(self.controlArea,
"Hide axes",
sizePolicy=SIZE_POLICY)
self.rslider = gui.hSlider(box,
self,
"radius",
minValue=0,
maxValue=100,
step=5,
label="Radius",
createLabel=False,
ticks=True,
callback=self.update_radius)
self.rslider.setTickInterval(0)
self.rslider.setPageStep(10)
box = gui.vBox(self.controlArea, "Plot Properties")
box.setSizePolicy(*SIZE_POLICY)
g.add_widgets([
g.ShowLegend, g.ToolTipShowsAll, g.ClassDensity,
g.LabelOnlySelected
], box)
box = self.graph.box_zoom_select(self.controlArea)
box.setSizePolicy(*SIZE_POLICY)
self.icons = gui.attributeIconDict
p = self.graph.plot_widget.palette()
self.graph.set_palette(p)
gui.auto_commit(self.controlArea,
self,
"auto_commit",
"Send Selection",
auto_label="Send Automatically")
self.graph.zoom_actions(self)
self._new_plotdata()
self._change_placement()
self.graph.jitter_continuous = True
def __init__(self):
super().__init__()
# Instance variables
self.tree_type = self.GENERAL
self.model = None
self.instances = None
self.clf_dataset = None
# The tree adapter instance which is passed from the outside
self.tree_adapter = None
self.legend = None
self.color_palette = None
# Different methods to calculate the size of squares
self.SIZE_CALCULATION = [
('Normal', lambda x: x),
('Square root', lambda x: sqrt(x)),
# The +1 is there so that we don't get division by 0 exceptions
('Logarithmic', lambda x: log(x * self.size_log_scale + 1)),
]
# Color modes for regression trees
self.REGRESSION_COLOR_CALC = [
('None', lambda _, __: QtGui.QColor(255, 255, 255)),
('Class mean', self._color_class_mean),
('Standard deviation', self._color_stddev),
]
# CONTROL AREA
# Tree info area
box_info = gui.widgetBox(self.controlArea, 'Tree Info')
self.info = gui.widgetLabel(box_info)
# Display settings area
box_display = gui.widgetBox(self.controlArea, 'Display Settings')
self.depth_slider = gui.hSlider(
box_display, self, 'depth_limit', label='Depth', ticks=False,
callback=self.update_depth)
self.target_class_combo = gui.comboBox(
box_display, self, 'target_class_index', label='Target class',
orientation='horizontal', items=[], contentsLength=8,
callback=self.update_colors)
self.size_calc_combo = gui.comboBox(
box_display, self, 'size_calc_idx', label='Size',
orientation='horizontal',
items=list(zip(*self.SIZE_CALCULATION))[0], contentsLength=8,
callback=self.update_size_calc)
self.log_scale_box = gui.hSlider(
box_display, self, 'size_log_scale',
label='Log scale factor', minValue=1, maxValue=100, ticks=False,
callback=self.invalidate_tree)
# Plot properties area
box_plot = gui.widgetBox(self.controlArea, 'Plot Properties')
gui.checkBox(
box_plot, self, 'tooltips_enabled', label='Enable tooltips',
callback=self.update_tooltip_enabled)
gui.checkBox(
box_plot, self, 'show_legend', label='Show legend',
callback=self.update_show_legend)
# Stretch to fit the rest of the unsused area
gui.rubber(self.controlArea)
self.controlArea.setSizePolicy(
QtGui.QSizePolicy.Preferred, QtGui.QSizePolicy.Expanding)
# MAIN AREA
# The QGraphicsScene doesn't actually require a parent, but not linking
# the widget to the scene causes errors and a segfault on close due to
# the way Qt deallocates memory and deletes objects.
self.scene = TreeGraphicsScene(self)
self.scene.selectionChanged.connect(self.commit)
self.view = TreeGraphicsView(self.scene, padding=(150, 150))
self.view.setRenderHint(QtGui.QPainter.Antialiasing, True)
self.mainArea.layout().addWidget(self.view)
self.ptree = PythagorasTreeViewer()
self.scene.addItem(self.ptree)
self.view.set_central_widget(self.ptree)
self.resize(800, 500)
# Clear the widget to correctly set the intial values
self.clear()
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.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.buttonsArea, "Tools")
toolsBox = gui.widgetBox(tBox, 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(self.invalidate)
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,
addToLayout=False)
form.addRow("Radius:", slider)
slider = gui.hSlider(indBox,
self,
"density",
None,
minValue=1,
maxValue=100,
createLabel=False,
addToLayout=False)
form.addRow("Intensity:", slider)
slider = gui.hSlider(indBox,
self,
"symbol_size",
None,
minValue=1,
maxValue=100,
createLabel=False,
callback=self.set_symbol_size,
addToLayout=False)
form.addRow("Symbol:", slider)
self.btResetToInput = gui.button(tBox, self, "Reset to Input Data",
self.reset_to_input)
self.btResetToInput.setDisabled(True)
gui.auto_send(self.buttonsArea, self, "autocommit")
# 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__()
#: Input dissimilarity matrix
self.matrix = None # type: Optional[Orange.misc.DistMatrix]
#: Effective data used for plot styling/annotations. Can be from the
#: input signal (`self.signal_data`) or the input matrix
#: (`self.matrix.data`)
self.data = None # type: Optional[Orange.data.Table]
#: Input subset data table
self.subset_data = None # type: Optional[Orange.data.Table]
#: Data table from the `self.matrix.row_items` (if present)
self.matrix_data = None # type: Optional[Orange.data.Table]
#: Input data table
self.signal_data = None
self._similar_pairs = None
self._subset_mask = None # type: Optional[np.ndarray]
self._invalidated = False
self.effective_matrix = None
self._curve = None
self.variable_x = ContinuousVariable("mds-x")
self.variable_y = ContinuousVariable("mds-y")
self.__update_loop = None
# timer for scheduling updates
self.__timer = QTimer(self, singleShot=True, interval=0)
self.__timer.timeout.connect(self.__next_step)
self.__state = OWMDS.Waiting
self.__in_next_step = False
self.__draw_similar_pairs = False
box = gui.vBox(self.controlArea, "MDS Optimization")
form = QFormLayout(labelAlignment=Qt.AlignLeft,
formAlignment=Qt.AlignLeft,
fieldGrowthPolicy=QFormLayout.AllNonFixedFieldsGrow,
verticalSpacing=10)
form.addRow("Max iterations:",
gui.spin(box, self, "max_iter", 10, 10**4, step=1))
form.addRow(
"Initialization:",
gui.radioButtons(box,
self,
"initialization",
btnLabels=("PCA (Torgerson)", "Random"),
callback=self.__invalidate_embedding))
box.layout().addLayout(form)
form.addRow(
"Refresh:",
gui.comboBox(box,
self,
"refresh_rate",
items=[t for t, _ in OWMDS.RefreshRate],
callback=self.__invalidate_refresh))
gui.separator(box, 10)
self.runbutton = gui.button(box,
self,
"Run",
callback=self._toggle_run)
box = gui.vBox(self.mainArea, True, margin=0)
self.graph = OWMDSGraph(self,
box,
"MDSGraph",
view_box=MDSInteractiveViewBox)
box.layout().addWidget(self.graph.plot_widget)
self.plot = self.graph.plot_widget
g = self.graph.gui
box = g.point_properties_box(self.controlArea)
self.models = g.points_models
self.models[2].order = \
self.models[2].order[:1] + ("Stress", ) + self.models[2].order[1:]
gui.hSlider(box,
self,
"connected_pairs",
label="Show similar pairs:",
minValue=0,
maxValue=20,
createLabel=False,
callback=self._on_connected_changed)
g.add_widgets(ids=[g.JitterSizeSlider], widget=box)
box = gui.vBox(self.controlArea, "Plot Properties")
g.add_widgets([
g.ShowLegend, g.ToolTipShowsAll, g.ClassDensity,
g.LabelOnlySelected
], box)
self.controlArea.layout().addStretch(100)
self.icons = gui.attributeIconDict
palette = self.graph.plot_widget.palette()
self.graph.set_palette(palette)
gui.rubber(self.controlArea)
self.graph.box_zoom_select(self.controlArea)
gui.auto_commit(box,
self,
"auto_commit",
"Send Selected",
checkbox_label="Send selected automatically",
box=None)
self.plot.getPlotItem().hideButtons()
self.plot.setRenderHint(QPainter.Antialiasing)
self.graph.jitter_continuous = True
self._initialize()
def __init__(self):
super().__init__()
# var models
self.x_var_model = itemmodels.VariableListModel()
self.y_var_model = itemmodels.VariableListModel()
# info box
self.info_box = gui.widgetBox(self.controlArea, "Info")
self.learner_label = gui.label(widget=self.info_box,
master=self,
label="")
# options box
policy = QSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.Fixed)
self.options_box = gui.widgetBox(self.controlArea, "Data")
opts = dict(widget=self.options_box,
master=self,
orientation=Qt.Horizontal,
callback=self.change_attributes,
sendSelectedValue=True,
maximumContentsLength=15)
self.cbx = gui.comboBox(value='attr_x', label='X:', **opts)
self.cby = gui.comboBox(value='attr_y', label='Y:', **opts)
self.target_class_combobox = gui.comboBox(value='target_class',
label='Target class: ',
**opts)
self.cbx.setModel(self.x_var_model)
self.cby.setModel(self.y_var_model)
gui.separator(self.controlArea, 20, 20)
# properties box
self.properties_box = gui.widgetBox(self.controlArea, "Properties")
self.alpha_spin = gui.spin(widget=self.properties_box,
master=self,
callback=self.change_alpha,
value="alpha",
label="Learning rate: ",
minv=0.001,
maxv=100,
step=0.001,
spinType=float,
decimals=3,
alignment=Qt.AlignRight,
controlWidth=80)
self.stochastic_checkbox = gui.checkBox(
widget=self.properties_box,
master=self,
callback=self.change_stochastic,
value="stochastic",
label="Stochastic ")
self.step_size_spin = gui.spin(widget=self.properties_box,
master=self,
callback=self.change_step,
value="step_size",
label="Step size: ",
minv=1,
maxv=100,
step=1,
alignment=Qt.AlignRight,
controlWidth=80)
self.restart_button = gui.button(widget=self.properties_box,
master=self,
callback=self.restart,
label="Restart")
self.alpha_spin.setSizePolicy(policy)
self.step_size_spin.setSizePolicy(policy)
gui.separator(self.controlArea, 20, 20)
# step box
self.step_box = gui.widgetBox(self.controlArea,
"Manually step through")
self.step_button = gui.button(widget=self.step_box,
master=self,
callback=self.step,
label="Step",
default=True)
self.step_back_button = gui.button(widget=self.step_box,
master=self,
callback=self.step_back,
label="Step back")
gui.separator(self.controlArea, 20, 20)
# run box
self.run_box = gui.widgetBox(self.controlArea, "Run")
self.auto_play_button = gui.button(widget=self.run_box,
master=self,
label=self.auto_play_button_text[0],
callback=self.auto_play)
self.auto_play_speed_spinner = gui.hSlider(widget=self.run_box,
master=self,
value='auto_play_speed',
minValue=0,
maxValue=1.91,
step=0.1,
intOnly=False,
createLabel=False,
label='Speed:')
# graph in mainArea
self.scatter = Scatterplot(
click_callback=self.change_theta,
xAxis_gridLineWidth=0,
yAxis_gridLineWidth=0,
title_text='',
tooltip_shared=False,
legend=dict(enabled=False),
)
gui.rubber(self.controlArea)
# Just render an empty chart so it shows a nice 'No data to display'
self.scatter.chart()
self.mainArea.layout().addWidget(self.scatter)
self.step_size_lock()
self.step_back_button_lock()
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(QtGui.QLayout.SetFixedSize)
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, '森林')
self.ui_info = gui.widgetLabel(box_info)
# Display controls area
box_display = gui.widgetBox(self.controlArea, '显示')
self.ui_depth_slider = gui.hSlider(
box_display,
self,
'depth_limit',
label='深度',
ticks=False,
) # type: QSlider
self.ui_target_class_combo = gui.comboBox(
box_display,
self,
'target_class_index',
label='目标类别',
orientation=Qt.Horizontal,
items=[],
contentsLength=8,
) # type: gui.OrangeComboBox
self.ui_size_calc_combo = gui.comboBox(
box_display,
self,
'size_calc_idx',
label='大小',
orientation=Qt.Horizontal,
items=list(zip(*self.SIZE_CALCULATION))[0],
contentsLength=8,
) # type: gui.OrangeComboBox
self.ui_zoom_slider = gui.hSlider(
box_display,
self,
'zoom',
label='缩放',
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, select_fn=None):
QWidget.__init__(self)
OWComponent.__init__(self, parent)
self.parent = parent
self.select_fn = select_fn
self.selection_type = SELECTMANY
self.saving_enabled = hasattr(self.parent, "save_graph")
self.selection_enabled = True
self.viewtype = INDIVIDUAL # required bt InteractiveViewBox
self.highlighted = None
self.data_points = None
self.data_values = None
self.data_imagepixels = None
self.selection = None
self.plotview = pg.PlotWidget(background="w", viewBox=InteractiveViewBox(self))
self.plot = self.plotview.getPlotItem()
self.plot.scene().installEventFilter(
HelpEventDelegate(self.help_event, self))
layout = QVBoxLayout()
self.setLayout(layout)
self.layout().setContentsMargins(0, 0, 0, 0)
self.layout().addWidget(self.plotview)
self.img = ImageItemNan()
self.img.setOpts(axisOrder='row-major')
self.plot.addItem(self.img)
self.plot.vb.setAspectLocked()
self.plot.scene().sigMouseMoved.connect(self.plot.vb.mouseMovedEvent)
layout = QGridLayout()
self.plotview.setLayout(layout)
self.button = QPushButton("View", self.plotview)
self.button.setAutoDefault(False)
layout.setRowStretch(1, 1)
layout.setColumnStretch(1, 1)
layout.addWidget(self.button, 0, 0)
view_menu = MenuFocus(self)
self.button.setMenu(view_menu)
actions = []
zoom_in = QAction(
"Zoom in", self, triggered=self.plot.vb.set_mode_zooming
)
zoom_in.setShortcuts([Qt.Key_Z, QKeySequence(QKeySequence.ZoomIn)])
zoom_in.setShortcutContext(Qt.WidgetWithChildrenShortcut)
actions.append(zoom_in)
zoom_fit = QAction(
"Zoom to fit", self,
triggered=lambda x: (self.plot.vb.autoRange(), self.plot.vb.set_mode_panning())
)
zoom_fit.setShortcuts([Qt.Key_Backspace, QKeySequence(Qt.ControlModifier | Qt.Key_0)])
zoom_fit.setShortcutContext(Qt.WidgetWithChildrenShortcut)
actions.append(zoom_fit)
select_square = QAction(
"Select (square)", self, triggered=self.plot.vb.set_mode_select_square,
)
select_square.setShortcuts([Qt.Key_S])
select_square.setShortcutContext(Qt.WidgetWithChildrenShortcut)
actions.append(select_square)
select_polygon = QAction(
"Select (polygon)", self, triggered=self.plot.vb.set_mode_select_polygon,
)
select_polygon.setShortcuts([Qt.Key_P])
select_polygon.setShortcutContext(Qt.WidgetWithChildrenShortcut)
actions.append(select_polygon)
if self.saving_enabled:
save_graph = QAction(
"Save graph", self, triggered=self.save_graph,
)
save_graph.setShortcuts([QKeySequence(Qt.ControlModifier | Qt.Key_I)])
actions.append(save_graph)
view_menu.addActions(actions)
self.addActions(actions)
common_options = dict(
labelWidth=50, orientation=Qt.Horizontal, sendSelectedValue=True,
valueType=str)
choose_xy = QWidgetAction(self)
box = gui.vBox(self)
box.setFocusPolicy(Qt.TabFocus)
self.xy_model = DomainModel(DomainModel.METAS | DomainModel.CLASSES, valid_types=DomainModel.PRIMITIVE)
self.cb_attr_x = gui.comboBox(
box, self, "attr_x", label="Axis x:", callback=self.update_attr,
model=self.xy_model, **common_options)
self.cb_attr_y = gui.comboBox(
box, self, "attr_y", label="Axis y:", callback=self.update_attr,
model=self.xy_model, **common_options)
box.setFocusProxy(self.cb_attr_x)
self.color_cb = gui.comboBox(box, self, "palette_index", label="Color:",
labelWidth=50, orientation=Qt.Horizontal)
self.color_cb.setIconSize(QSize(64, 16))
palettes = _color_palettes
self.palette_index = min(self.palette_index, len(palettes) - 1)
model = color_palette_model(palettes, self.color_cb.iconSize())
model.setParent(self)
self.color_cb.setModel(model)
self.color_cb.activated.connect(self.update_color_schema)
self.color_cb.setCurrentIndex(self.palette_index)
form = QFormLayout(
formAlignment=Qt.AlignLeft,
labelAlignment=Qt.AlignLeft,
fieldGrowthPolicy=QFormLayout.AllNonFixedFieldsGrow
)
lowslider = gui.hSlider(
box, self, "threshold_low", minValue=0.0, maxValue=1.0,
step=0.05, ticks=True, intOnly=False,
createLabel=False, callback=self.update_color_schema)
highslider = gui.hSlider(
box, self, "threshold_high", minValue=0.0, maxValue=1.0,
step=0.05, ticks=True, intOnly=False,
createLabel=False, callback=self.update_color_schema)
form.addRow("Low:", lowslider)
form.addRow("High:", highslider)
box.layout().addLayout(form)
choose_xy.setDefaultWidget(box)
view_menu.addAction(choose_xy)
self.markings_integral = []
self.lsx = None # info about the X axis
self.lsy = None # info about the Y axis
self.data = None
self.data_ids = {}
def __init__(self):
super().__init__()
#: The input data
self.data = None # type: Optional[Orange.data.Table]
#: Distance matrix computed from 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[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]
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",
contentsLength=14,
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",
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)
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.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")
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)
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)
self.smoothing_box = gui.indentedBox(box, 40)
gui.hSlider(
self.smoothing_box, self, "kde_smoothing",
label="Smoothing", orientation=Qt.Horizontal,
minValue=2, maxValue=20, callback=self.replot)
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.controlArea, self, commit=self.apply)
self.info.set_input_summary(self.info.NoInput)
self.info.set_output_summary(self.info.NoOutput)
self._set_smoothing_visibility()
self._setup_plots()
self._setup_legend()
def __init__(self):
super().__init__()
# Instance variables
self.model = None
self.instances = None
self.clf_dataset = None
# The tree adapter instance which is passed from the outside
self.tree_adapter = None
self.legend = None
self.color_palette = None
# Different methods to calculate the size of squares
self.SIZE_CALCULATION = [
('Normal', lambda x: x),
('Square root', lambda x: sqrt(x)),
('Logarithmic', lambda x: log(x * self.size_log_scale + 1)),
]
# CONTROL AREA
# Tree info area
box_info = gui.widgetBox(self.controlArea, 'Tree Info')
self.info = gui.widgetLabel(box_info)
# Display settings area
box_display = gui.widgetBox(self.controlArea, 'Display Settings')
self.depth_slider = gui.hSlider(box_display,
self,
'depth_limit',
label='Depth',
ticks=False,
callback=self.update_depth)
self.target_class_combo = gui.comboBox(box_display,
self,
'target_class_index',
label='Target class',
orientation=Qt.Horizontal,
items=[],
contentsLength=8,
callback=self.update_colors)
self.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,
callback=self.update_size_calc)
self.log_scale_box = gui.hSlider(box_display,
self,
'size_log_scale',
label='Log scale factor',
minValue=1,
maxValue=100,
ticks=False,
callback=self.invalidate_tree)
# Plot properties area
box_plot = gui.widgetBox(self.controlArea, 'Plot Properties')
self.cb_show_tooltips = gui.checkBox(
box_plot,
self,
'tooltips_enabled',
label='Enable tooltips',
callback=self.update_tooltip_enabled)
self.cb_show_legend = gui.checkBox(box_plot,
self,
'show_legend',
label='Show legend',
callback=self.update_show_legend)
gui.button(self.controlArea,
self,
label="Redraw",
callback=self.redraw)
# Stretch to fit the rest of the unsused area
gui.rubber(self.controlArea)
self.controlArea.setSizePolicy(QSizePolicy.Preferred,
QSizePolicy.Expanding)
# MAIN AREA
self.scene = TreeGraphicsScene(self)
self.scene.selectionChanged.connect(self.commit)
self.view = TreeGraphicsView(self.scene, padding=(150, 150))
self.view.setRenderHint(QPainter.Antialiasing, True)
self.mainArea.layout().addWidget(self.view)
self.ptree = PythagorasTreeViewer(self)
self.scene.addItem(self.ptree)
self.view.set_central_widget(self.ptree)
self.resize(800, 500)
# Clear the widget to correctly set the intial values
self.clear()
def __init__(self):
super().__init__()
self.data = None
self.indices = None
box = gui.widgetBox(self.controlArea, "Information")
self.dataInfoLabel = gui.widgetLabel(box, 'No data on input.')
self.outputInfoLabel = gui.widgetLabel(box, ' ')
box = gui.widgetBox(self.controlArea, "Sampling Type")
sampling = gui.radioButtons(box,
self,
"sampling_type",
callback=self.sampling_type_changed)
def set_sampling_type(i):
def f():
self.sampling_type = i
self.sampling_type_changed()
return f
gui.appendRadioButton(sampling, "Fixed sample size:")
ibox = gui.indentedBox(sampling)
self.sampleSizeSpin = gui.spin(ibox,
self,
"sampleSizeNumber",
label="Instances: ",
minv=1,
maxv=2**31 - 1,
callback=set_sampling_type(
self.FixedSize))
gui.checkBox(ibox,
self,
"replacement",
"Sample with replacement",
callback=set_sampling_type(self.FixedSize))
gui.separator(sampling, 12)
gui.appendRadioButton(sampling, "Fixed proportion of data:")
self.sampleSizePercentageSlider = gui.hSlider(
gui.indentedBox(sampling),
self,
"sampleSizePercentage",
minValue=0,
maxValue=100,
ticks=10,
labelFormat="%d %%",
callback=set_sampling_type(self.FixedProportion))
gui.separator(sampling, 12)
gui.appendRadioButton(sampling, "Cross Validation:")
form = QtGui.QFormLayout(
formAlignment=Qt.AlignLeft | Qt.AlignTop,
labelAlignment=Qt.AlignLeft,
fieldGrowthPolicy=QtGui.QFormLayout.AllNonFixedFieldsGrow)
ibox = gui.indentedBox(sampling, addSpace=True, orientation=form)
form.addRow(
"Number of folds",
gui.spin(ibox,
self,
"number_of_folds",
2,
100,
addToLayout=False,
callback=self.number_of_folds_changed))
self.selected_fold_spin = gui.spin(ibox,
self,
"selectedFold",
1,
100,
addToLayout=False,
callback=self.fold_changed)
form.addRow("Selected fold", self.selected_fold_spin)
box = gui.widgetBox(self.controlArea, "Options")
gui.checkBox(box,
self,
"use_seed",
"Replicable (deterministic) sampling",
callback=self.settings_changed)
gui.checkBox(box,
self,
"stratify",
"Stratify sample (when possible)",
callback=self.settings_changed)
gui.button(self.controlArea, self, "Sample Data", callback=self.commit)
self.layout().setSizeConstraint(QtGui.QLayout.SetFixedSize)
def __init__(self):
super().__init__()
self.model = None
self.forest_adapter = None
self.instances = None
self.clf_dataset = None
# We need to store refernces to the trees and grid items
self.grid_items, self.ptrees = [], []
# In some rare cases, we need to prevent commiting, the only one
# that this currently helps is that when changing the size calculation
# the trees are all recomputed, but we don't want to output a new tree
# to keep things consistent with other ui controls.
self.__prevent_commit = False
self.color_palette = None
# Different methods to calculate the size of squares
self.SIZE_CALCULATION = [
('Normal', lambda x: x),
('Square root', lambda x: sqrt(x)),
('Logarithmic', lambda x: log(x + 1)),
]
# 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')
self.ui_depth_slider = gui.hSlider(box_display,
self,
'depth_limit',
label='Depth',
ticks=False,
callback=self.update_depth)
self.ui_target_class_combo = gui.comboBox(box_display,
self,
'target_class_index',
label='Target class',
orientation=Qt.Horizontal,
items=[],
contentsLength=8,
callback=self.update_colors)
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,
callback=self.update_size_calc)
self.ui_zoom_slider = gui.hSlider(box_display,
self,
'zoom',
label='Zoom',
ticks=False,
minValue=20,
maxValue=150,
callback=self.zoom_changed,
createLabel=False)
# Stretch to fit the rest of the unsused area
gui.rubber(self.controlArea)
self.controlArea.setSizePolicy(QSizePolicy.Preferred,
QSizePolicy.Expanding)
# MAIN AREA
self.scene = QGraphicsScene(self)
self.scene.selectionChanged.connect(self.commit)
self.grid = OWGrid()
self.grid.geometryChanged.connect(self._update_scene_rect)
self.scene.addItem(self.grid)
self.view = QGraphicsView(self.scene)
self.view.setRenderHint(QPainter.Antialiasing, True)
self.view.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOn)
self.mainArea.layout().addWidget(self.view)
self.resize(800, 500)
self.clear()
def __init__(self):
super().__init__()
# options box
self.options_box = gui.widgetBox(self.controlArea, "Data")
opts = dict(widget=self.options_box,
master=self,
orientation=Qt.Horizontal,
callback=self.restart,
sendSelectedValue=True,
maximumContentsLength=15)
self.cbx = gui.comboBox(value='attr_x', label='X: ', **opts)
self.cby = gui.comboBox(value='attr_y', label='Y: ', **opts)
self.centroids_box = gui.widgetBox(self.controlArea, "Centroids")
self.centroid_numbers_spinner = gui.spin(
self.centroids_box,
self,
'number_of_clusters',
minv=1,
maxv=10,
step=1,
label='Number of centroids:',
alignment=Qt.AlignRight,
callback=self.number_of_clusters_change)
self.restart_button = gui.button(self.centroids_box,
self,
"Randomize Positions",
callback=self.restart)
gui.separator(self.centroids_box)
self.lines_checkbox = gui.checkBox(self.centroids_box,
self,
'lines_to_centroids',
'Show membership lines',
callback=self.complete_replot)
# control box
gui.separator(self.controlArea, 20, 20)
self.step_box = gui.widgetBox(self.controlArea,
"Manually step through")
self.step_button = gui.button(self.step_box,
self,
self.STEP_BUTTONS[1],
callback=self.step)
self.step_back_button = gui.button(self.step_box,
self,
"Step Back",
callback=self.step_back)
self.run_box = gui.widgetBox(self.controlArea, "Run")
self.auto_play_speed_spinner = gui.hSlider(self.run_box,
self,
'auto_play_speed',
label='Speed:',
minValue=0,
maxValue=1.91,
step=0.1,
intOnly=False,
createLabel=False)
self.auto_play_button = gui.button(self.run_box,
self,
self.AUTOPLAY_BUTTONS[0],
callback=self.auto_play)
gui.rubber(self.controlArea)
# disable until data loaded
self.set_disabled_all(True)
# graph in mainArea
self.scatter = Scatterplot(click_callback=self.graph_clicked,
drop_callback=self.centroid_dropped,
xAxis_gridLineWidth=0,
yAxis_gridLineWidth=0,
tooltip_enabled=False,
debug=False)
# Just render an empty chart so it shows a nice 'No data to display'
self.scatter.chart()
self.mainArea.layout().addWidget(self.scatter)
def __init__(self):
super().__init__()
self.data = None # type: Optional[Table]
self.preprocessed_data = None # type: Optional[Table]
self.pca_projection = None # type: Optional[Table]
self.graph = None # type: Optional[nx.Graph]
self.partition = None # type: Optional[np.array]
# Use a executor with a single worker, to limit CPU overcommitment for
# cancelled tasks. The method does not have a fine cancellation
# granularity so we assure that there are not N - 1 jobs executing
# for no reason only to be thrown away. It would be better to use the
# global pool but implement a limit on jobs from this source.
self.__executor = futures.ThreadPoolExecutor(max_workers=1)
self.__task = None # type: Optional[TaskState]
self.__invalidated = False
# coalescing commit timer
self.__commit_timer = QTimer(self, singleShot=True)
self.__commit_timer.timeout.connect(self.commit)
pca_box = gui.vBox(self.controlArea, 'PCA Preprocessing')
self.apply_pca_cbx = gui.checkBox(
pca_box,
self,
'apply_pca',
label='Apply PCA preprocessing',
callback=self._invalidate_graph,
) # type: QCheckBox
self.pca_components_slider = gui.hSlider(
pca_box,
self,
'pca_components',
label='Components: ',
minValue=2,
maxValue=_MAX_PCA_COMPONENTS,
callback=self._invalidate_pca_projection,
tracking=False) # type: QSlider
graph_box = gui.vBox(self.controlArea, 'Graph parameters')
self.metric_combo = gui.comboBox(
graph_box,
self,
'metric_idx',
label='Distance metric',
items=[m[0] for m in METRICS],
callback=self._invalidate_graph,
orientation=Qt.Horizontal,
) # type: gui.OrangeComboBox
self.k_neighbors_spin = gui.spin(
graph_box,
self,
'k_neighbors',
minv=1,
maxv=_MAX_K_NEIGBOURS,
label='k neighbors',
controlWidth=80,
alignment=Qt.AlignRight,
callback=self._invalidate_graph,
) # type: gui.SpinBoxWFocusOut
self.resolution_spin = gui.hSlider(
graph_box,
self,
'resolution',
minValue=0,
maxValue=5.,
step=1e-1,
label='Resolution',
intOnly=False,
labelFormat='%.1f',
callback=self._invalidate_partition,
tracking=False,
) # type: QSlider
self.resolution_spin.parent().setToolTip(
'The resolution parameter affects the number of clusters to find. '
'Smaller values tend to produce more clusters and larger values '
'retrieve less clusters.')
self.apply_button = gui.auto_commit(
self.controlArea,
self,
'auto_commit',
'Apply',
box=None,
commit=lambda: self.commit(),
callback=lambda: self._on_auto_commit_changed(),
) # type: QWidget
def __init__(self):
super().__init__()
self.data = None
self.data_subset = None
self.plotdata = None
box = gui.widgetBox(self.controlArea, "Optimization", spacing=10)
form = QtGui.QFormLayout(
labelAlignment=Qt.AlignLeft,
formAlignment=Qt.AlignLeft,
fieldGrowthPolicy=QtGui.QFormLayout.AllNonFixedFieldsGrow,
verticalSpacing=10
)
form.addRow(
"Force law",
gui.comboBox(box, self, "force_law",
items=[text for text, _ in OWFreeViz.ForceLaw],
callback=self.__reset_update_interval)
)
form.addRow(
"Max iterations",
gui.spin(box, self, "maxiter", 10, 10 ** 4)
)
form.addRow(
"Initialization",
gui.comboBox(box, self, "initialization",
items=["Circular", "Random"],
callback=self.__reset_initialization)
)
form.addRow(
"Replot",
gui.comboBox(box, self, "replot_interval",
items=[text for text, _ in OWFreeViz.ReplotIntervals],
callback=self.__reset_update_interval)
)
box.layout().addLayout(form)
self.start_button = gui.button(
box, self, "Optimize", self._toogle_start)
self.color_varmodel = itemmodels.VariableListModel(parent=self)
self.shape_varmodel = itemmodels.VariableListModel(parent=self)
self.size_varmodel = itemmodels.VariableListModel(parent=self)
self.label_varmodel = itemmodels.VariableListModel(parent=self)
box = gui.widgetBox(self.controlArea, "Plot")
form = QtGui.QFormLayout(
formAlignment=Qt.AlignLeft,
labelAlignment=Qt.AlignLeft,
fieldGrowthPolicy=QtGui.QFormLayout.AllNonFixedFieldsGrow,
spacing=8,
)
box.layout().addLayout(form)
color_cb = gui.comboBox(
box, self, "color_var", sendSelectedValue=True,
emptyString="(Same color)", contentsLength=10,
callback=self._update_color)
color_cb.setModel(self.color_varmodel)
form.addRow("Color", color_cb)
opacity_slider = gui.hSlider(
box, self, "opacity", minValue=50, maxValue=255, ticks=True,
createLabel=False, callback=self._update_color)
opacity_slider.setTickInterval(0)
opacity_slider.setPageStep(10)
form.addRow("Opacity", opacity_slider)
shape_cb = gui.comboBox(
box, self, "shape_var", contentsLength=10, sendSelectedValue=True,
emptyString="(Same shape)", callback=self._update_shape)
shape_cb.setModel(self.shape_varmodel)
form.addRow("Shape", shape_cb)
size_cb = gui.comboBox(
box, self, "size_var", contentsLength=10, sendSelectedValue=True,
emptyString="(Same size)", callback=self._update_size)
size_cb.setModel(self.size_varmodel)
form.addRow("Size", size_cb)
size_slider = gui.hSlider(
box, self, "point_size", minValue=3, maxValue=20, ticks=True,
createLabel=False, callback=self._update_size)
form.addRow(None, size_slider)
label_cb = gui.comboBox(
box, self, "label_var", contentsLength=10, sendSelectedValue=True,
emptyString="(No labels)", callback=self._update_labels)
label_cb.setModel(self.label_varmodel)
form.addRow("Label", label_cb)
form.addRow(
"Jitter",
gui.comboBox(box, self, "jitter",
items=[text for text, _ in self.JitterAmount],
callback=self._update_xy)
)
self.class_density_cb = gui.checkBox(
box, self, "class_density", "", callback=self._update_density)
form.addRow("Class density", self.class_density_cb)
box = gui.widgetBox(self.controlArea, "Hide anchors")
rslider = gui.hSlider(
box, self, "min_anchor_radius", minValue=0, maxValue=100,
step=5, label="Hide radius", createLabel=False, ticks=True,
callback=self._update_anchor_visibility)
rslider.setTickInterval(0)
rslider.setPageStep(10)
box = gui.widgetBox(self.controlArea, "Zoom/Select")
hlayout = QtGui.QHBoxLayout()
box.layout().addLayout(hlayout)
toolbox = PlotToolBox(self)
hlayout.addWidget(toolbox.button(PlotToolBox.SelectTool))
hlayout.addWidget(toolbox.button(PlotToolBox.ZoomTool))
hlayout.addWidget(toolbox.button(PlotToolBox.PanTool))
hlayout.addSpacing(2)
hlayout.addWidget(toolbox.button(PlotToolBox.ZoomReset))
toolbox.standardAction(PlotToolBox.ZoomReset).triggered.connect(
lambda: self.plot.setRange(QtCore.QRectF(-1.05, -1.05, 2.1, 2.1))
)
toolbox.standardAction(PlotToolBox.ZoomIn).triggered.connect(
lambda: self.plot.getViewBox().scaleBy((1.25, 1.25))
)
toolbox.standardAction(PlotToolBox.ZoomIn).triggered.connect(
lambda: self.plot.getViewBox().scaleBy((1 / 1.25, 1 / 1.25))
)
selecttool = toolbox.plotTool(PlotToolBox.SelectTool)
selecttool.selectionFinished.connect(self.__select_area)
self.addActions(toolbox.actions())
self.controlArea.layout().addStretch(1)
box = gui.widgetBox(self.controlArea, "Output")
gui.comboBox(box, self, "embedding_domain_role",
items=["Original features only",
"Coordinates as features",
"Coordinates as meta attributes"])
gui.auto_commit(box, self, "autocommit", "Commit", box=False,
callback=self.commit)
self.plot = pg.PlotWidget(enableMouse=False, enableMenu=False)
self.plot.setFrameStyle(QtGui.QFrame.StyledPanel)
self.plot.plotItem.hideAxis("bottom")
self.plot.plotItem.hideAxis("left")
self.plot.plotItem.hideButtons()
self.plot.setAspectLocked(True)
self.plot.scene().installEventFilter(self)
self.legend = linproj.LegendItem()
self.legend.setParentItem(self.plot.getViewBox())
self.legend.anchor((1, 0), (1, 0))
self.plot.setRenderHint(QtGui.QPainter.Antialiasing, True)
self.mainArea.layout().addWidget(self.plot)
viewbox = self.plot.getViewBox()
viewbox.grabGesture(Qt.PinchGesture)
pinchtool = linproj.PlotPinchZoomTool(parent=self)
pinchtool.setViewBox(viewbox)
toolbox.setViewBox(viewbox)
self._loop = AsyncUpdateLoop(parent=self)
self._loop.yielded.connect(self.__set_projection)
self._loop.finished.connect(self.__freeviz_finished)
self._loop.raised.connect(self.__on_error)
