def _add_cookie_callback(self): if self.stage.live: cookie_idx = self.cookie_select.currentIndex() pos_idx = self.pos_select.currentIndex() self.logger.info( 'Adding cookie {0} to the recipe at {1}'.format(self.icings[cookie_idx], self.positions[pos_idx])) self.recipe.add_cookie( {'icing': self.icings[cookie_idx]}, self.positions[pos_idx]) image = self.q_image_displays[pos_idx] scene = QGraphicsScene() scene.addPixmap( QPixmap(os.path.join(DATA_DIR, self.pattern_images[cookie_idx].value))) image.setScene(scene) image.fitInView(scene.itemsBoundingRect()) image.show() else: self.logger.info( 'Stage is dead, cannot do anything. Please exit.')
class SelectByColorDlg(QDialog): def __init__(self, color, pieceItems): super().__init__() self._color = color self.resize(800, 800) self.scene = QGraphicsScene() layout = QVBoxLayout(self) self.view = _MyView(self) layout.addWidget(self.view) self.view.setScene(self.scene) self._view_widget = QGLWidget() self.view.setViewport(self._view_widget) self.view.setMouseTracking(True) gry = sum(color) / 3.0 if (gry < 168): bg = [224,]*3 else: bg = [128,]*3 self.scene.setBackgroundBrush(QBrush(QColor(*bg))) self.setup_scene(self.scene, pieceItems) d = self.piece_diag self.view.scale(60./d, 60./d) self._hover_radius = 1.0 self.selected_item_ids = [] def setup_scene(self, scene, pieceItems): root = self._rootitem = _RootItem(self._color) scene.addItem(root) # order piece items by color distance of the most similar color pairs = [(self._distance(item), item) for item in pieceItems] pairs.sort(key = lambda pair: pair[0]) phi_increment = 0.61803398874 * 2 * pi phi = 0.0 gamma = 1.0 # scale distance relative to average piece size if pairs: rect = pairs[0][1].boundingRect() diag = (rect.width()**2 + rect.height()**2) ** 0.5 # take the median piece idx = len(pairs) // 2 meddist = pairs[idx][0] meddist = max(meddist, .1) scale = 6*diag/(meddist) ** gamma self.piece_diag = diag else: scale = 1.0 self.piece_diag = 1.0 self.dist_and_id = [] for distance, orig_item in pairs: item = orig_item.copy_to(root, rotate=False) rr = item.boundingRect() item.setTransformOriginPoint(rr.center()) item.setRotation(item.angle_deg) item.setPos( scale * distance**gamma * cos(phi)-rr.width()*0.5, scale * distance**gamma * sin(phi)-rr.height()*0.5 ) self.dist_and_id.append((scale*distance**gamma, item.id)) phi += phi_increment self.updateSceneRect() def set_hover_radius(self, r): self._hover_radius = r self.selected_item_ids = [pair[1] for pair in self.dist_and_id if pair[0] < r] self._rootitem.sel_size = r self._rootitem.update() def confirm_result(self): self.accept() def _distance(self, pieceItem): color = self._color def dst(c1, c2): c1 = rgb2Lab(c1) c2 = rgb2Lab(c2) return sum((c1i-c2i)**2 for c1i, c2i in zip(c1, c2)) ** 0.5 if not pieceItem.dominant_colors: return 255.0 return min(dst(color, piececolor) for piececolor in pieceItem.dominant_colors[:4]) def updateSceneRect(self): r = self.scene.itemsBoundingRect() w, h = r.width(), r.height() a = .05 r = r.adjusted(-w*a, -h*a, w*a, h*a) self.scene.setSceneRect(r)
class OWQualityControl(widget.OWWidget): name = "Quality Control" description = "Experiment quality control" icon = "../widgets/icons/QualityControl.svg" priority = 5000 inputs = [("Experiment Data", Orange.data.Table, "set_data")] outputs = [] DISTANCE_FUNCTIONS = [("Distance from Pearson correlation", dist_pcorr), ("Euclidean distance", dist_eucl), ("Distance from Spearman correlation", dist_spearman)] settingsHandler = SetContextHandler() split_by_labels = settings.ContextSetting({}) sort_by_labels = settings.ContextSetting({}) selected_distance_index = settings.Setting(0) def __init__(self, parent=None): super().__init__(parent) ## Attributes self.data = None self.distances = None self.groups = None self.unique_pos = None self.base_group_index = 0 ## GUI box = gui.widgetBox(self.controlArea, "Info") self.info_box = gui.widgetLabel(box, "\n") ## Separate By box box = gui.widgetBox(self.controlArea, "Separate By") self.split_by_model = itemmodels.PyListModel(parent=self) self.split_by_view = QListView() self.split_by_view.setSelectionMode(QListView.ExtendedSelection) self.split_by_view.setModel(self.split_by_model) box.layout().addWidget(self.split_by_view) self.split_by_view.selectionModel().selectionChanged.connect( self.on_split_key_changed) ## Sort By box box = gui.widgetBox(self.controlArea, "Sort By") self.sort_by_model = itemmodels.PyListModel(parent=self) self.sort_by_view = QListView() self.sort_by_view.setSelectionMode(QListView.ExtendedSelection) self.sort_by_view.setModel(self.sort_by_model) box.layout().addWidget(self.sort_by_view) self.sort_by_view.selectionModel().selectionChanged.connect( self.on_sort_key_changed) ## Distance box box = gui.widgetBox(self.controlArea, "Distance Measure") gui.comboBox(box, self, "selected_distance_index", items=[name for name, _ in self.DISTANCE_FUNCTIONS], callback=self.on_distance_measure_changed) self.scene = QGraphicsScene() self.scene_view = QGraphicsView(self.scene) self.scene_view.setRenderHints(QPainter.Antialiasing) self.scene_view.setAlignment(Qt.AlignLeft | Qt.AlignVCenter) self.mainArea.layout().addWidget(self.scene_view) self.scene_view.installEventFilter(self) self._disable_updates = False self._cached_distances = {} self._base_index_hints = {} self.main_widget = None self.resize(800, 600) def clear(self): """Clear the widget state.""" self.data = None self.distances = None self.groups = None self.unique_pos = None with disable_updates(self): self.split_by_model[:] = [] self.sort_by_model[:] = [] self.main_widget = None self.scene.clear() self.info_box.setText("\n") self._cached_distances = {} def set_data(self, data=None): """Set input experiment data.""" self.closeContext() self.clear() self.error(0) self.warning(0) if data is not None: keys = self.get_suitable_keys(data) if not keys: self.error(0, "Data has no suitable feature labels.") data = None self.data = data if data is not None: self.on_new_data() def update_label_candidates(self): """Update the label candidates selection GUI (Group/Sort By views). """ keys = self.get_suitable_keys(self.data) with disable_updates(self): self.split_by_model[:] = keys self.sort_by_model[:] = keys def get_suitable_keys(self, data): """ Return suitable attr label keys from the data where the key has at least two unique values in the data. """ attrs = [attr.attributes.items() for attr in data.domain.attributes] attrs = reduce(operator.iadd, attrs, []) # in case someone put non string values in attributes dict attrs = [(str(key), str(value)) for key, value in attrs] attrs = set(attrs) values = defaultdict(set) for key, value in attrs: values[key].add(value) keys = [key for key in values if len(values[key]) > 1] return keys def selected_split_by_labels(self): """Return the current selected split labels. """ sel_m = self.split_by_view.selectionModel() indices = [r.row() for r in sel_m.selectedRows()] return [self.sort_by_model[i] for i in indices] def selected_sort_by_labels(self): """Return the current selected sort labels """ sel_m = self.sort_by_view.selectionModel() indices = [r.row() for r in sel_m.selectedRows()] return [self.sort_by_model[i] for i in indices] def selected_distance(self): """Return the selected distance function. """ return self.DISTANCE_FUNCTIONS[self.selected_distance_index][1] def selected_base_group_index(self): """Return the selected base group index """ return self.base_group_index def selected_base_indices(self, base_group_index=None): indices = [] for g, ind in self.groups: if base_group_index is None: label = group_label(self.selected_split_by_labels(), g) ind = [i for i in ind if i is not None] i = self._base_index_hints.get(label, ind[0] if ind else None) else: i = ind[base_group_index] indices.append(i) return indices def on_new_data(self): """We have new data and need to recompute all. """ self.closeContext() self.update_label_candidates() self.info_box.setText( "%s genes \n%s experiments" % (len(self.data), len(self.data.domain.attributes)) ) self.base_group_index = 0 keys = self.get_suitable_keys(self.data) self.openContext(keys) ## Restore saved context settings (split/sort selection) split_by_labels = self.split_by_labels sort_by_labels = self.sort_by_labels def select(model, selection_model, selected_items): """Select items in a Qt item model view """ all_items = list(model) try: indices = [all_items.index(item) for item in selected_items] except: indices = [] for ind in indices: selection_model.select(model.index(ind), QItemSelectionModel.Select) with disable_updates(self): select(self.split_by_view.model(), self.split_by_view.selectionModel(), split_by_labels) select(self.sort_by_view.model(), self.sort_by_view.selectionModel(), sort_by_labels) with widget_disable(self): self.split_and_update() def on_split_key_changed(self, *args): """Split key has changed """ with widget_disable(self): if not self._disable_updates: self.base_group_index = 0 self.split_by_labels = self.selected_split_by_labels() self.split_and_update() def on_sort_key_changed(self, *args): """Sort key has changed """ with widget_disable(self): if not self._disable_updates: self.base_group_index = 0 self.sort_by_labels = self.selected_sort_by_labels() self.split_and_update() def on_distance_measure_changed(self): """Distance measure has changed """ if self.data is not None: with widget_disable(self): self.update_distances() self.replot_experiments() def on_view_resize(self, size): """The view with the quality plot has changed """ if self.main_widget: current = self.main_widget.size() self.main_widget.resize(size.width() - 6, current.height()) self.scene.setSceneRect(self.scene.itemsBoundingRect()) def on_rug_item_clicked(self, item): """An ``item`` in the quality plot has been clicked. """ update = False sort_by_labels = self.selected_sort_by_labels() if sort_by_labels and item.in_group: ## The item is part of the group if item.group_index != self.base_group_index: self.base_group_index = item.group_index update = True else: if sort_by_labels: # If the user clicked on an background item it # invalidates the sorted labels selection with disable_updates(self): self.sort_by_view.selectionModel().clear() update = True index = item.index group = item.group label = group_label(self.selected_split_by_labels(), group) if self._base_index_hints.get(label, 0) != index: self._base_index_hints[label] = index update = True if update: with widget_disable(self): self.split_and_update() def eventFilter(self, obj, event): if obj is self.scene_view and event.type() == QEvent.Resize: self.on_view_resize(event.size()) return super().eventFilter(obj, event) def split_and_update(self): """ Split the data based on the selected sort/split labels and update the quality plot. """ split_labels = self.selected_split_by_labels() sort_labels = self.selected_sort_by_labels() self.warning(0) if not split_labels: self.warning(0, "No separate by label selected.") self.groups, self.unique_pos = \ exp.separate_by(self.data, split_labels, consider=sort_labels, add_empty=True) self.groups = sorted(self.groups.items(), key=lambda t: list(map(float_if_posible, t[0]))) self.unique_pos = sorted(self.unique_pos.items(), key=lambda t: list(map(float_if_posible, t[0]))) if self.groups: if sort_labels: group_base = self.selected_base_group_index() base_indices = self.selected_base_indices(group_base) else: base_indices = self.selected_base_indices() self.update_distances(base_indices) self.replot_experiments() def get_cached_distances(self, measure): if measure not in self._cached_distances: attrs = self.data.domain.attributes mat = numpy.zeros((len(attrs), len(attrs))) self._cached_distances[measure] = \ (mat, set(zip(range(len(attrs)), range(len(attrs))))) return self._cached_distances[measure] def get_cached_distance(self, measure, i, j): matrix, computed = self.get_cached_distances(measure) key = (i, j) if i < j else (j, i) if key in computed: return matrix[i, j] else: return None def get_distance(self, measure, i, j): d = self.get_cached_distance(measure, i, j) if d is None: vec_i = take_columns(self.data, [i]) vec_j = take_columns(self.data, [j]) d = measure(vec_i, vec_j) mat, computed = self.get_cached_distances(measure) mat[i, j] = d key = key = (i, j) if i < j else (j, i) computed.add(key) return d def store_distance(self, measure, i, j, dist): matrix, computed = self.get_cached_distances(measure) key = (i, j) if i < j else (j, i) matrix[j, i] = matrix[i, j] = dist computed.add(key) def update_distances(self, base_indices=()): """Recompute the experiment distances. """ distance = self.selected_distance() if base_indices == (): base_group_index = self.selected_base_group_index() base_indices = [ind[base_group_index] \ for _, ind in self.groups] assert(len(base_indices) == len(self.groups)) base_distances = [] attributes = self.data.domain.attributes pb = gui.ProgressBar(self, len(self.groups) * len(attributes)) for (group, indices), base_index in zip(self.groups, base_indices): # Base column of the group if base_index is not None: base_vec = take_columns(self.data, [base_index]) distances = [] # Compute the distances between base column # and all the rest data columns. for i in range(len(attributes)): if i == base_index: distances.append(0.0) elif self.get_cached_distance(distance, i, base_index) is not None: distances.append(self.get_cached_distance(distance, i, base_index)) else: vec_i = take_columns(self.data, [i]) dist = distance(base_vec, vec_i) self.store_distance(distance, i, base_index, dist) distances.append(dist) pb.advance() base_distances.append(distances) else: base_distances.append(None) pb.finish() self.distances = base_distances def replot_experiments(self): """Replot the whole quality plot. """ self.scene.clear() labels = [] max_dist = numpy.nanmax(list(filter(None, self.distances))) rug_widgets = [] group_pen = QPen(Qt.black) group_pen.setWidth(2) group_pen.setCapStyle(Qt.RoundCap) background_pen = QPen(QColor(0, 0, 250, 150)) background_pen.setWidth(1) background_pen.setCapStyle(Qt.RoundCap) main_widget = QGraphicsWidget() layout = QGraphicsGridLayout() attributes = self.data.domain.attributes if self.data is not None: for (group, indices), dist_vec in zip(self.groups, self.distances): indices_set = set(indices) rug_items = [] if dist_vec is not None: for i, attr in enumerate(attributes): # Is this a within group distance or background in_group = i in indices_set if in_group: rug_item = ClickableRugItem(dist_vec[i] / max_dist, 1.0, self.on_rug_item_clicked) rug_item.setPen(group_pen) tooltip = experiment_description(attr) rug_item.setToolTip(tooltip) rug_item.group_index = indices.index(i) rug_item.setZValue(rug_item.zValue() + 1) else: rug_item = ClickableRugItem(dist_vec[i] / max_dist, 0.85, self.on_rug_item_clicked) rug_item.setPen(background_pen) tooltip = experiment_description(attr) rug_item.setToolTip(tooltip) rug_item.group = group rug_item.index = i rug_item.in_group = in_group rug_items.append(rug_item) rug_widget = RugGraphicsWidget(parent=main_widget) rug_widget.set_rug(rug_items) rug_widgets.append(rug_widget) label = group_label(self.selected_split_by_labels(), group) label_item = QGraphicsSimpleTextItem(label, main_widget) label_item = GraphicsSimpleTextLayoutItem(label_item, parent=layout) label_item.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed) labels.append(label_item) for i, (label, rug_w) in enumerate(zip(labels, rug_widgets)): layout.addItem(label, i, 0, Qt.AlignVCenter) layout.addItem(rug_w, i, 1) layout.setRowMaximumHeight(i, 30) main_widget.setLayout(layout) self.scene.addItem(main_widget) self.main_widget = main_widget self.rug_widgets = rug_widgets self.labels = labels self.on_view_resize(self.scene_view.size())
class ConductorGraph(Plugin): _deferred_fit_in_view=Signal() _client_list_update_signal=Signal() def __init__(self, context): self._context=context super(ConductorGraph, self).__init__(context) self.initialised=False self.setObjectName('Conductor Graph') self._current_dotcode=None self._node_items=None self._edge_items=None self._node_item_events={} self._edge_item_events={} self._client_info_list={} self._widget=QWidget() self.cur_selected_client_name = "" self.pre_selected_client_name = "" # factory builds generic dotcode items self.dotcode_factory=PydotFactory() # self.dotcode_factory=PygraphvizFactory() self.dotcode_generator=RosGraphDotcodeGenerator() self.dot_to_qt=DotToQtGenerator() self._graph=ConductorGraphInfo() self._graph._reg_event_callback(self._update_client_list) self._graph._reg_period_callback(self._set_network_statisics) rospack=rospkg.RosPack() ui_file=os.path.join(rospack.get_path('concert_conductor_graph'), 'ui', 'conductor_graph.ui') loadUi(ui_file, self._widget, {'InteractiveGraphicsView': InteractiveGraphicsView}) self._widget.setObjectName('ConductorGraphUi') if context.serial_number() > 1: self._widget.setWindowTitle(self._widget.windowTitle() + (' (%d)' % context.serial_number())) self._scene=QGraphicsScene() self._scene.setBackgroundBrush(Qt.white) self._widget.graphics_view.setScene(self._scene) #self._widget.refresh_graph_push_button.setIcon(QIcon.fromTheme('view-refresh')) self._widget.refresh_graph_push_button.setIcon(QIcon.fromTheme('window-new')) self._widget.refresh_graph_push_button.pressed.connect(self._update_conductor_graph) self._widget.highlight_connections_check_box.toggled.connect(self._redraw_graph_view) self._widget.auto_fit_graph_check_box.toggled.connect(self._redraw_graph_view) self._widget.fit_in_view_push_button.setIcon(QIcon.fromTheme('zoom-original')) self._widget.fit_in_view_push_button.pressed.connect(self._fit_in_view) self._deferred_fit_in_view.connect(self._fit_in_view, Qt.QueuedConnection) self._deferred_fit_in_view.emit() self._widget.tabWidget.currentChanged.connect(self._change_client_tab) self._client_list_update_signal.connect(self._update_conductor_graph) #rospy.Subscriber(concert_msgs.Strings.CONCERT_CLIENT_CHANGES, ConcertClients, self._update_client_list) context.add_widget(self._widget) def restore_settings(self, plugin_settings, instance_settings): self.initialised=True self._refresh_rosgraph() def shutdown_plugin(self): pass def _update_conductor_graph(self): # re-enable controls customizing fetched ROS graph self._refresh_rosgraph() self._update_client_tab() def _refresh_rosgraph(self): if not self.initialised: return self._update_graph_view(self._generate_dotcode()) def _generate_dotcode(self): return self.dotcode_generator.generate_dotcode(rosgraphinst=self._graph, dotcode_factory=self.dotcode_factory, orientation='LR' ) def _update_graph_view(self, dotcode): #if dotcode==self._current_dotcode: # return self._current_dotcode=dotcode self._redraw_graph_view() def _update_client_list(self): print "[conductor graph]: _update_client_list" self._client_list_update_signal.emit() pass def _start_service(self,node_name,service_name): service=self._graph._client_info_list[node_name]['gateway_name']+"/"+service_name info_text='' if service_name=='status': service_handle=rospy.ServiceProxy(service, Status) call_result=service_handle() info_text="<html>" info_text +="<p>-------------------------------------------</p>" info_text +="<p><b>application_namespace: </b>" +call_result.application_namespace+"</p>" info_text +="<p><b>remote_controller: </b>" +call_result.remote_controller+"</p>" info_text +="<p><b>application_status: </b>" +call_result.application_status+"</p>" info_text +="</html>" self._client_list_update_signal.emit() elif service_name=='platform_info': service_handle=rospy.ServiceProxy(service, GetPlatformInfo) call_result=service_handle() info_text = "<html>" info_text += "<p>-------------------------------------------</p>" info_text += "<p><b>rocon_uri: </b>" + call_result.platform_info.uri + "</p>" info_text += "<p><b>concert_version: </b>" + call_result.platform_info.version + "</p>" info_text += "</html>" self._client_list_update_signal.emit() elif service_name=='invite': #sesrvice service_handle=rospy.ServiceProxy(service, Invite) #dialog dlg=QDialog(self._widget) dlg.setMinimumSize(400,0) dlg.setMaximumSize(400,0) dlg.setSizePolicy(QSizePolicy.Fixed,QSizePolicy.Expanding) #dialog layout ver_layout=QVBoxLayout(dlg) ver_layout.setContentsMargins (0,0,0,0) dynamic_arg=[] dynamic_arg.append(DynamicArgumentLayer(ver_layout,'Remote Target Name',False,[('remote_target_name','string')])) dynamic_arg.append(DynamicArgumentLayer(ver_layout,'Application Namespace',False,[('application_namespace','string')])) dynamic_arg.append(DynamicArgumentLayer(ver_layout,'Cancel',False,[('cancel','bool')])) #button button_hor_sub_widget=QWidget() button_hor_layout=QHBoxLayout(button_hor_sub_widget) btn_call=QPushButton("Call") btn_cancel=QPushButton("cancel") btn_call.clicked.connect(lambda: dlg.done(0)) btn_call.clicked.connect(lambda : self._call_invite_service(service,service_handle,dynamic_arg)) btn_cancel.clicked.connect(lambda: dlg.done(0)) #add button button_hor_layout.addWidget(btn_call) button_hor_layout.addWidget(btn_cancel) #add button layout ver_layout.addWidget(button_hor_sub_widget) dlg.setVisible(True) elif service_name=='start_app': #sesrvice service_handle=rospy.ServiceProxy(service, StartApp) #dialog dlg=QDialog(self._widget) dlg.setMinimumSize(400,0) dlg.setMaximumSize(400,0) dlg.setSizePolicy(QSizePolicy.Fixed,QSizePolicy.Expanding) #dialog layout ver_layout=QVBoxLayout(dlg) ver_layout.setContentsMargins (0,0,0,0) dynamic_arg=[] dynamic_arg.append(DynamicArgumentLayer(ver_layout,'Name',False,[('name','string')])) dynamic_arg.append(DynamicArgumentLayer(ver_layout,'Remappings',True,[('remap to','string'),('remap from','string')])) #button button_hor_sub_widget=QWidget() button_hor_layout=QHBoxLayout(button_hor_sub_widget) btn_call=QPushButton("Call") btn_cancel=QPushButton("cancel") btn_call.clicked.connect(lambda: dlg.done(0)) btn_call.clicked.connect(lambda : self._call_start_app_service(service,service_handle,dynamic_arg)) btn_cancel.clicked.connect(lambda: dlg.done(0)) #add button button_hor_layout.addWidget(btn_call) button_hor_layout.addWidget(btn_cancel) #add button layout ver_layout.addWidget(button_hor_sub_widget) dlg.setVisible(True) elif service_name=='stop_app': service_handle=rospy.ServiceProxy(service, StopApp) call_result=service_handle() info_text="<html>" info_text +="<p>-------------------------------------------</p>" info_text +="<p><b>stopped: </b>" +str(call_result.stopped)+"</p>" info_text +="<p><b>error_code: </b>" +str(call_result.error_code)+"</p>" info_text +="<p><b>message: </b>" +call_result.message+"</p>" info_text +="</html>" self._update_client_tab() else: print 'has no service' return # display the result of calling service # get tab widget handle service_text_widget=None cur_tab_widget=self._widget.tabWidget.currentWidget() if cur_tab_widget==None: return object_name='services_text_widget' for k in cur_tab_widget.children(): if k.objectName().count(object_name) >=1 : service_text_widget=k break if service_text_widget==None: return service_text_widget.clear() service_text_widget.appendHtml(info_text) def _call_invite_service(self,service,service_handle,dynamic_arg): remote_target_name="" application_namespace="" cancel=False for k in dynamic_arg: if k.name=='Remote Target Name': item_widget=k._get_param_list()[0][0][1] remote_target_name=item_widget.toPlainText() elif k.name=='Application Namespace': item_widgetwidget=k._get_param_list()[0][0][1] application_namespace=item_widget.toPlainText() elif k.name=='Cancel': item_widget=k._get_param_list()[0][0][1] cancel=item_widget.itemData(item_widget.currentIndex()) #calling service call_result=service_handle(remote_target_name,application_namespace,cancel) #status update self._client_list_update_signal.emit() # display the result of calling service info_text="<html>" info_text +="<p>-------------------------------------------</p>" info_text +="<p><b>result: </b>" +str(call_result.result)+"</p>" info_text +="<p><b>error_code: </b>" +str(call_result.error_code)+"</p>" info_text +="<p><b>message: </b>" +call_result.message+"</p>" info_text +="</html>" # get tab widget handle service_text_widget=None cur_tab_widget=self._widget.tabWidget.currentWidget() if cur_tab_widget==None: return object_name='services_text_widget' for k in cur_tab_widget.children(): if k.objectName().count(object_name) >=1 : service_text_widget=k break if service_text_widget==None: return service_text_widget.clear() service_text_widget.appendHtml(info_text) pass def _call_start_app_service(self,service,service_handle,dynamic_arg): name="" remappings=[] for k in dynamic_arg: if k.name=='Name': name=k._get_param_list()[0][0][1].toPlainText() elif k.name=='Remappings': for l in k._get_param_list(): remap_to=l[0][1].toPlainText() remap_from=l[1][1].toPlainText() remappings.append(Remapping(remap_to,remap_from)) #calling service call_result=service_handle(name,remappings) #status update self._client_list_update_signal.emit() # display the result of calling service info_text = '' info_text="<html>" info_text +="<p>-------------------------------------------</p>" info_text +="<p><b>started: </b>" +str(call_result.started)+"</p>" info_text +="<p><b>error_code: </b>" +str(call_result.error_code)+"</p>" info_text +="<p><b>message: </b>" +call_result.message+"</p>" info_text +="<p><b>app_namespace: </b>" +call_result.app_namespace+"</p>" info_text +="</html>" # get tab widget handle service_text_widget=None cur_tab_widget=self._widget.tabWidget.currentWidget() if cur_tab_widget==None: return object_name='services_text_widget' for k in cur_tab_widget.children(): if k.objectName().count(object_name) >=1 : service_text_widget=k break if service_text_widget==None: return service_text_widget.clear() service_text_widget.appendHtml(info_text) pass def _update_client_tab(self): print '[_update_client_tab]' self.pre_selected_client_name = self.cur_selected_client_name self._widget.tabWidget.clear() for k in self._graph._client_info_list.values(): main_widget=QWidget() ver_layout=QVBoxLayout(main_widget) ver_layout.setContentsMargins (9,9,9,9) ver_layout.setSizeConstraint (ver_layout.SetDefaultConstraint) #button layout sub_widget=QWidget() sub_widget.setAccessibleName('sub_widget') btn_grid_layout=QGridLayout(sub_widget) btn_grid_layout.setContentsMargins (9,9,9,9) btn_grid_layout.setColumnStretch (1, 0) btn_grid_layout.setRowStretch (2, 0) invite_btn=QPushButton("Invite") platform_info_btn=QPushButton("Get Platform Info") status_btn=QPushButton("Get Status") start_app_btn=QPushButton("Start App") stop_app_btn=QPushButton("Stop App") invite_btn.clicked.connect(lambda: self._start_service(self._widget.tabWidget.tabText(self._widget.tabWidget.currentIndex()),"invite")) platform_info_btn.clicked.connect(lambda: self._start_service(self._widget.tabWidget.tabText(self._widget.tabWidget.currentIndex()),"platform_info")) status_btn.clicked.connect(lambda: self._start_service(self._widget.tabWidget.tabText(self._widget.tabWidget.currentIndex()),"status")) start_app_btn.clicked.connect(lambda: self._start_service(self._widget.tabWidget.tabText(self._widget.tabWidget.currentIndex()),"start_app")) stop_app_btn.clicked.connect(lambda: self._start_service(self._widget.tabWidget.tabText(self._widget.tabWidget.currentIndex()),"stop_app")) btn_grid_layout.addWidget(invite_btn) btn_grid_layout.addWidget(platform_info_btn) btn_grid_layout.addWidget(status_btn) btn_grid_layout.addWidget(start_app_btn) btn_grid_layout.addWidget(stop_app_btn) ver_layout.addWidget(sub_widget) #client information layout context_label = QLabel() context_label.setText("Client information") ver_layout.addWidget(context_label) app_context_widget=QPlainTextEdit() app_context_widget.setObjectName(k["name"]+'_'+'app_context_widget') app_context_widget.setAccessibleName('app_context_widget') app_context_widget.appendHtml(k["app_context"]) app_context_widget.setReadOnly(True) cursor = app_context_widget.textCursor() cursor.movePosition(QTextCursor.Start,QTextCursor.MoveAnchor,0) app_context_widget.setTextCursor(cursor) ver_layout.addWidget(app_context_widget) #service layout context_label = QLabel() context_label.setText("Service result") ver_layout.addWidget(context_label) services_text_widget=QPlainTextEdit() services_text_widget.setObjectName(k["name"]+'_'+'services_text_widget') services_text_widget.setReadOnly(True) cursor = services_text_widget.textCursor() cursor.movePosition(QTextCursor.Start,QTextCursor.MoveAnchor,0) services_text_widget.setTextCursor(cursor) ver_layout.addWidget(services_text_widget) # new icon path="" if k["is_new"]==True: path=os.path.join(os.path.dirname(os.path.abspath(__file__)),"../../resources/images/new.gif") #add tab self._widget.tabWidget.addTab(main_widget,QIcon(path), k["name"]); #set previous selected tab for k in range(self._widget.tabWidget.count()): tab_text=self._widget.tabWidget.tabText(k) if tab_text == self.pre_selected_client_name: self._widget.tabWidget.setCurrentIndex(k) def _change_client_tab(self,index): self.cur_selected_client_name = self._widget.tabWidget.tabText(self._widget.tabWidget.currentIndex()) if self._widget.tabWidget.widget(index) !=None: for k in self._widget.tabWidget.widget(index).children(): if k.objectName().count("services_text_widget"): k.clear() pass def _set_network_statisics(self): if self._edge_items == None: return else: for edge_items in self._edge_items.itervalues(): for edge_item in edge_items: edge_dst_name=edge_item.to_node._label.text() edge_item.setToolTip(str(self._graph._client_info_list[edge_dst_name]['conn_stats'])) def _redraw_graph_view(self): self._scene.clear() self._node_item_events={} self._edge_item_events={} self._node_items=None self._edge_items=None if self._widget.highlight_connections_check_box.isChecked(): highlight_level=3 else: highlight_level=1 highlight_level=3 if self._widget.highlight_connections_check_box.isChecked() else 1 # layout graph and create qt items (nodes, edges)=self.dot_to_qt.dotcode_to_qt_items(self._current_dotcode, highlight_level=highlight_level, same_label_siblings=True) self._node_items=nodes self._edge_items=edges # if we wish to make special nodes, do that here (maybe subclass GraphItem, just like NodeItem does) #node for node_item in nodes.itervalues(): # set the color of conductor to orange if node_item._label.text()==self._graph._concert_conductor_name: royal_blue=QColor(65, 105, 255) node_item._default_color=royal_blue node_item.set_color(royal_blue) # redefine mouse event self._node_item_events[node_item._label.text()]=GraphEventHandler(self._widget.tabWidget,node_item,node_item.mouseDoubleClickEvent); node_item.mouseDoubleClickEvent=self._node_item_events[node_item._label.text()].NodeEvent; self._scene.addItem(node_item) #edge for edge_items in edges.itervalues(): for edge_item in edge_items: #redefine the edge hover event self._edge_item_events[edge_item._label.text()]=GraphEventHandler(self._widget.tabWidget,edge_item,edge_item._label.hoverEnterEvent); edge_item._label.hoverEnterEvent =self._edge_item_events[edge_item._label.text()].EdgeEvent; #self._edge_item_events[edge_item._label.text()]=GraphEventHandler(self._widget.tabWidget,edge_item,edge_item.mouseDoubleClickEvent); #edge_item.mouseDoubleClickEvent=self._edge_item_events[edge_item._label.text()].EdgeEvent; edge_item.add_to_scene(self._scene) #set the color of node as connection strength one of red, yellow, green edge_dst_name=edge_item.to_node._label.text() if edge_dst_name in self._graph._client_info_list.keys(): connection_strength=self._graph._client_info_list[edge_dst_name]['connection_strength'] if connection_strength=='very_strong': green=QColor(0, 255, 0) edge_item._default_color=green edge_item.set_color(green) elif connection_strength=='strong': green_yellow=QColor(125, 255,0) edge_item._default_color=green_yellow edge_item.set_color(green_yellow) elif connection_strength=='normal': yellow=QColor(238, 238,0) edge_item._default_color=yellow edge_item.set_color(yellow) elif connection_strength=='weak': yellow_red=QColor(255, 125,0) edge_item._default_color=yellow_red edge_item.set_color(yellow_red) elif connection_strength=='very_weak': red=QColor(255, 0,0) edge_item._default_color=red edge_item.set_color(red) #set the tooltip about network information edge_item.setToolTip(str(self._graph._client_info_list[edge_dst_name]['conn_stats'])) self._scene.setSceneRect(self._scene.itemsBoundingRect()) if self._widget.auto_fit_graph_check_box.isChecked(): self._fit_in_view() def _fit_in_view(self): self._widget.graphics_view.fitInView(self._scene.itemsBoundingRect(), Qt.KeepAspectRatio)
class Canvas(QGraphicsView): def __init__(self, window, resultDict, imagePath): QGraphicsView.__init__(self) self.window = window self.pen = QPen(QColor("red")) self.pen.setWidth(0.5) self.canvasScene = QGraphicsScene() self.setScene(self.canvasScene) self.resultDict = resultDict self.imagePath = imagePath self.setBackgroundBrush(QBrush(Qt.black, Qt.SolidPattern)) def drawImage(self, imageFile): """Draw an image on the canvas""" image = QPixmap(imageFile) self.canvasScene.addPixmap(image) return image def drawFeaturePoint(self, pointList): """Draw a feature point on the canvas""" radius = 0.5 width, height = 2, 2 x1, y1, x2, y2 = pointList #Draw ellipse and bounding rect. Is a hacked version! self.canvasScene.addEllipse(x1 - radius + 5, y1 - radius + 3, 2 * radius, 2 * radius, self.pen) self.canvasScene.addEllipse(x2 - radius + self.imageWidth + 10, y2 - radius + 3, 2 * radius, 2 * radius, self.pen) self.canvasScene.addRect(x1 - width / 2. + 5, y1 - height / 2. + 3, width, height, self.pen) self.canvasScene.addRect(x2 - width / 2. + self.imageWidth + 10, y2 - height / 2. + 3, width, height, self.pen) def drawFeatureImages(self, imageFile): """Draw two consecutive images on the screen""" #Load image files path, file_ = os.path.split(imageFile) image1 = QPixmap(os.path.join(path, 'first_' + file_)) image2 = QPixmap(os.path.join(path, 'second_' + file_)) self.imageWidth = image1.width() #Add pixmaps image1Map = self.canvasScene.addPixmap(image1) image2Map = self.canvasScene.addPixmap(image2) #Shift pixmaps to the right position image1Map.setOffset(QPointF(5, 3)) image2Map.setOffset(QPointF(10 + image1.width(), 3)) def drawPolygon(self, Polygon): """Draw a polygon on the canvas""" polygon = QPolygonF() for point in Polygon: polygon.append(QPointF(point[0], point[1])) self.canvasScene.addPolygon(polygon, self.pen) def getWorkerId(self): return self.resultDict.values()[self.index][0][0] def getAssignmentId(self): return self.resultDict.keys()[self.index] def nextImage(self): """Load next image""" self.index += 1 self.canvasScene.clear() if self.index > len(self.resultDict) - 1 or len(self.resultDict) <= 0: self.canvasScene.addText("No annotations to review") self.window.reviewFlag = False self.window.updateTable() else: #Draw Image and Polygon assignmentId = self.resultDict.keys()[self.index] result = self.resultDict[assignmentId] image = result[0][1] pointList = result[0][2] if self.window.segmentation_mode: pointList = [round(float(point), 3) for point in pointList] pointList = zip(*[iter(pointList)] * 2) self.drawImage(os.path.join(self.imagePath, image)) self.drawPolygon(pointList) else: pointList = [round(float(point), 3) for point in pointList] pointList = zip(*[iter(pointList)] * 4) self.drawFeatureImages(os.path.join(self.imagePath, image)) for point in pointList: self.drawFeaturePoint(point) #update scene self.window.setWindowTitle("MTurk Review Tool ({0}/{1}) Rejected: {2} Approved: {3}".format(self.index + 1, len(self.resultDict), len(self.window.rejected), len(self.window.approved))) self.canvasScene.setSceneRect(self.canvasScene.itemsBoundingRect()) self.fitInView(0, 0, self.canvasScene.width(), self.canvasScene.height(), 1) self.canvasScene.update(0, 0, self.canvasScene.width(), self.canvasScene.height())
class TreeDialog(QDialog): def __init__(self): import treedialog QDialog.__init__(self) self.ui = treedialog.Ui_Dialog() self.ui.setupUi(self) self.ui.draw_buton.clicked.connect(self.new_anim) self.scene = QGraphicsScene() self.ui.image.setScene(self.scene) self.ui.image.setRenderHints(QPainter.HighQualityAntialiasing) def get_params(self): params = dict() params["branch_split"] = self.ui.branch_split.value() params["branch_after_range"] = (self.ui.branch_after_min.value(), self.ui.branch_after_max.value()) params["branch_split_var"] = self.ui.branch_split_var.value() params["gravity"] = self.ui.gravity.value() params["down_die_probability"] = self.ui.down_die_probability.value() params["down_damping_x"] = self.ui.down_damping_x.value() params["down_damping_y"] = self.ui.down_damping_x.value() params["start_branches"] = self.ui.start_branches.value() params["keep_central"] = self.ui.keep_central.value() params["color"] = QColor(self.ui.r.value() * 255, self.ui.g.value() * 255, self.ui.b.value() * 255) params["color_speed"] = self.ui.color_speed.value() params["painter_thickness"] = self.ui.painter_thickness.value() params["painter_generations"] = self.ui.painter_generations.value() start_rand = [random.uniform(-1, 1) * self.ui.v_start_var.value() for i in range(2)] params["v_start"] = complex(self.ui.v_start_x.value()+start_rand[0], self.ui.v_start_y.value()+start_rand[1]) return params def new_anim(self): image = None painter_id = random.randint(0, 2**32) self.active_painer = painter_id index = 0 every = self.ui.repaint.value() self.scene.clear() tree_count = self.ui.tree_count.value() need_spacing = 65 used_locations = [] for tree_index in range(tree_count): z_range = 80 base_z = random.uniform(-z_range, z_range) def make_base(): return complex(10 + random.uniform(-350 + 150*tree_count, 350 + 150*tree_count), base_z) def closest_distance_to_used(base): return min([np.abs(np.real(base - item)) for item in used_locations]) base_location = make_base() while not len(used_locations) == 0 and closest_distance_to_used(base_location) < need_spacing: base_location = make_base() used_locations.append(base_location) scale = 1.0 + 0.75 * ((z_range - base_z) / (2*z_range)) ** 2 self.tree = Tree(self.get_params(), base_location=base_location, scale=scale) for iteration in self.tree.grow_iterations(self.ui.generations.value(), yield_every=every): self.tree.draw(self.scene, incremental=True) self.ui.progress.setText("Working ... displayed frame: {0}".format(index)) gradient = QLinearGradient(self.scene.itemsBoundingRect().topLeft(), self.scene.itemsBoundingRect().bottomLeft()) gradient.setColorAt(0.4, QColor(0, 0, 0)) gradient.setColorAt(0, QColor(25, 25, 25)) self.scene.setBackgroundBrush(QBrush(gradient)) self.ui.image.repaint() QApplication.processEvents() index += every if self.active_painer != painter_id: return self.ui.image.fitInView(self.scene.itemsBoundingRect(), 1) d = GrassDrawer(self.ui.image) d.draw_some_grass(150 + 75*tree_count) #self.ui.image.fitInView(self.scene.itemsBoundingRect(), 1) self.ui.progress.setText("Done. Displayed frame: {0}".format(index))
class Nexus(QMainWindow): """ Die Hauptklasse des Programms. In dieser Klasse wird die GUI gesteuert und die Würfelwürfe aufgerufen. """ dicePoolChanged = pyqtSignal(int) xAgainChanged = pyqtSignal(int) cursed = pyqtSignal(bool) def __init__(self, parent=None): """ Konstruktor """ self.translator_app = QTranslator() self.translator_qt = QTranslator() QApplication.installTranslator( self.translator_app ) QApplication.installTranslator( self.translator_qt ) QWidget.__init__(self, parent) QCoreApplication.setOrganizationName("Caern") QCoreApplication.setOrganizationDomain("www.caern.de") QCoreApplication.setApplicationName("DiceRoller WoD") QCoreApplication.setApplicationVersion(QString.number(PROGRAM_VERSION_MAJOR) + "." + QString.number(PROGRAM_VERSION_MINOR) + "." + QString.number(PROGRAM_VERSION_CHANGE) ) QApplication.setWindowIcon(QIcon(":/icons/logo/WoD.png")) self.ui = Ui_MainWindow() self.ui.setupUi(self) self.createInfo() #self.createLanguageMenu() self.instantRoll = InstantRoll() self.extendedRoll = ExtendedRoll() # Dieser Zähler bestimmt, wie der rollende Würfel angezeigt wird. self.timerDice = QTimer() # Verzögert die tatsächliche Ausführung des Würfelwurfs. self.timerRoll = QTimer() self.populateUi() self.createConnections() self.initializing() self.setWindowTitle(QCoreApplication.applicationName()) #self.retranslateUi() ## Die von der letzten Benutzung gespeicherte Größe und Position auf dem Bildschirm laden. #self.readSettings() #def closeEvent(self, event): #""" #Diese Funktion wird aufgerufen, wann immer das Programm geschlossen wird. #Die Idee dahinter ist, vor dem Beenden, Größe und Position des Fensters zu speichern. #""" #self.writeSettings() #event.accept() def createInfo(self): """ Erzeugt Tooltips und Hilfe für die einzelnen Teile des Programms. """ self.ui.action_houserules.setStatusTip(self.ui.action_houserules.toolTip()) #def createLanguageMenu(self): #""" #Erzeugt das Menü zum Umschalten zwischen den möglichen Sprachen. #""" #self.menu_language = QMenu( self.tr("&Language") ) #self.actionGroup_language = QActionGroup(self) #self.langPath = getPath() + "/" + PROGRAM_LANGUAGE_PATH #self.dir_qm = QDir( self.langPath ); #self.fileNames = self.dir_qm.entryList( QStringList( "DiceRoller-WoD_*.qm" )); ## Englisch hat keine qm-Datei, also muß es von Hand hinzugefügt werden. #self.action = QAction( "&1 English", self.actionGroup_language ) #self.action.setCheckable( True ) #self.action.setData( "en" ) #self.action.setChecked( True ) #self.menu_language.addAction( self.action ) #self.actionGroup_language.addAction( self.action ) #iter = 0 #for i in self.fileNames: #self.trFilename = unicode(i) #self.locale = unicode(i) #self.locale = self.locale[(self.locale.find( "_" )+1):(self.locale.find( "." ))] #self.translator = QTranslator() #self.translator.load( self.trFilename, self.dir_qm.absolutePath() ) #self.language = self.translator.translate( "MainWindow", "English" ) #self.action = QAction( "&" + QString.number(iter + 2) + " " + self.language, self.actionGroup_language ) #self.action.setCheckable( True ) #self.action.setData( self.locale ) #self.menu_language.addAction ( self.action ) #self.actionGroup_language.addAction ( self.action ) #iter += 1 #self.actionGroup_language.triggered.connect(self.switchLanguage) #self.ui.menuBar.insertMenu(self.ui.menuHelp.menuAction(), self.menu_language) #def switchLanguage( self, action ): #""" #Schaltet zwischen den einzelnen Sprachen um. #""" #self.locale = action.data().toString(); #self.qmPath = getPath() + "/" + PROGRAM_LANGUAGE_PATH ##if self.translator_app.load( "DiceRoller-WoD_" + self.locale, self.qmPath ): ##qDebug("Hat DiceRoller-WoD_" + self.locale + " geladen.") ##if self.translator_qt.load( "qt_" + self.locale, QLibraryInfo.location ( QLibraryInfo.TranslationsPath ) ): ##qDebug("Hat qt_" + self.locale + " geladen.") ## Alle Texte neu setzen #self.retranslateUi() ## Seltsamerweise ist retranslate in Ui_MainWindow leer. Ich weiß nicht, wieso das der Fall ist. #self.ui.retranslateUi(self.ui) #def retranslateUi(self): #""" #Diese Funktion übersetzt alle Texte, welche nicht in der .ui-Datei festgelegt sind, sondern im Quellcode (hier) geschrieben wurden. #""" #self.menu_language.setTitle( self.tr( "&Language" ) ) #self.reset() def populateUi(self): self.svgRenderer = QSvgRenderer(":/icons/W10.svg") self.scene = QGraphicsScene() self.view = QGraphicsView() self.view.setFrameShape(QFrame.NoFrame) self.view.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff) self.view.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff) self.view.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum) self.view.setStyleSheet("background-color: transparent;"); self.view.setScene(self.scene) self.ui.horizontalLayout_dice.insertWidget(1, self.view) def createConnections(self): """ Erstelle die Verbindungen zwischen den verschiedenen Klassen und Elementen des Programms. """ self.ui.action_about.triggered.connect(self.aboutApp) self.ui.action_aboutQt.triggered.connect(QApplication.aboutQt) self.ui.action_houserules.toggled.connect(self.setHouserules) self.ui.pushButton_roll.clicked.connect(self.roll) self.ui.spinBox_pool.valueChanged.connect(self.calcDicePool) self.ui.spinBox_pool.valueChanged.connect(self.reset) self.ui.spinBox_modifier.valueChanged.connect(self.calcDicePoolMod) self.ui.spinBox_modifier.valueChanged.connect(self.reset) self.ui.checkBox_rote.toggled.connect(self.instantRoll.setRote) self.ui.checkBox_rote.toggled.connect(self.extendedRoll.setRote) self.ui.checkBox_rote.toggled.connect(self.reset) self.ui.comboBox_xAgain.activated.connect(self.setXAgainThreshold) self.ui.comboBox_xAgain.activated.connect(self.reset) self.ui.groupBox_extended.toggled.connect(self.changeText) self.ui.radioButton_target.toggled.connect(self.changeText) self.ui.radioButton_maxRolls.toggled.connect(self.changeText) self.ui.groupBox_extended.toggled.connect(self.reset) self.ui.radioButton_target.toggled.connect(self.setExtendedMode) self.ui.spinBox_target.valueChanged.connect(self.extendedRoll.setTarget) self.ui.spinBox_target.valueChanged.connect(self.reset) self.ui.spinBox_maxRolls.valueChanged.connect(self.extendedRoll.setMaxRolls) self.ui.spinBox_maxRolls.valueChanged.connect(self.reset) self.ui.checkBox_rollsLimited.toggled.connect(self.extendedRoll.setLimited) self.ui.checkBox_rollsLimited.toggled.connect(self.reset) self.xAgainChanged.connect(self.instantRoll.setThreshold) self.xAgainChanged.connect(self.extendedRoll.setThreshold) self.cursed.connect(self.instantRoll.setCurse) self.cursed.connect(self.extendedRoll.setCurse) self.instantRoll.rolled.connect(self.setResultSuccesses) self.extendedRoll.rolled.connect(self.setResultSuccesses) self.extendedRoll.rollsNeeded.connect(self.setResultRolls) self.instantRoll.rollFinished.connect(self.setResult) self.extendedRoll.rollFinished.connect(self.setResult) self.dicePoolChanged.connect(self.changeDiceDisplay) self.timerDice.timeout.connect(self.displayDice) self.timerRoll.timeout.connect(self._executeRoll) def initializing(self): """ Initialisiert das Programm mit den Startwerten. """ self.ui.action_quit.setIcon(QIcon(":/icons/actions/exit.png")) self.ui.action_about.setIcon(QIcon(":/icons/logo/WoD.png")) self.ui.pushButton_quit.setIcon(self.ui.action_quit.icon()) self.ui.pushButton_roll.setIcon(QIcon(":icons/W10_0.svg")) self.ui.action_quit.setMenuRole(QAction.QuitRole) self.ui.action_about.setText(self.tr("About %1...").arg(QApplication.applicationName())) self.ui.action_about.setMenuRole(QAction.AboutRole) self.ui.spinBox_pool.setValue(2) self.ui.checkBox_rote.setChecked(False) self.ui.comboBox_xAgain.setCurrentIndex(0) self.ui.spinBox_target.setValue(1) self.changeText() self.ui.radioButton_target.setChecked(True) self.ui.groupBox_extended.setChecked(False) self.ui.checkBox_rollsLimited.setChecked(True) self.dice = [] for i in xrange(10): self.W10_x = QGraphicsSvgItem() self.W10_x.setSharedRenderer(self.svgRenderer) self.W10_x.setElementId("layer" + str(i)) #self.W10_x.setVisible(False) # Ich lege diese Liste an, da ich auf die Liste in self.scene irgendwie nicht zugreifen kann. self.dice.append(self.W10_x) #self.scene.addItem(self.W10_x) def displayDice(self, value=None): """ @todo Der Würfel kann mehrmals in Folge das selbe Ergebnis anzeigen, was dazu führt, daß der Bildablauf zu stocken scheint. """ if (value == None): dieValue = Random.random(10)-1 else: dieValue = value for item in self.scene.items(): self.scene.removeItem(item) self.scene.addItem(self.dice[dieValue]) self.view.setSceneRect(self.scene.itemsBoundingRect()) self.view.fitInView(self.dice[dieValue]) def changeDiceDisplay(self, number): """ Diese Funktion bestimmt, wieviele Würfel angezeigt werden. """ pass #if (self.ui.horizontalLayout_dice.count > 2): #pass #randomValue = Random.random(10)-1 #for die in xrange(number): #self.__W10_scene = QGraphicsScene() #self.__W10_scene.addItem(self.dice[randomValue]) #self.__W10_view = QGraphicsView() #self.__W10_view.setScene(self.__W10_scene) #self.__W10_view.setSceneRect(self.scene.itemsBoundingRect()) #self.__W10_view.fitInView(self.dice[randomValue]) #self.ui.horizontalLayout_dice.insertWidget(1, self.__W10_view) def aboutApp(self): """ Zeigt die Info-Nachricht an. """ self.appText = self.tr(""" <h1>%1</h1> <h2>Version: %2</h2> <p>Copyright (C) 2011 by Victor von Rhein<br> EMail: [email protected]</p> """).arg(QCoreApplication.applicationName()).arg(QCoreApplication.applicationVersion()) self.gnuText = self.tr(""" <h2>GNU General Public License</h2> <p>This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.</p> <p>This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.</p> <p>You should have received a copy of the GNU General Public License along with this program. If not, see <a>http://www.gnu.org/licenses/</a>.</p> """) self.wodText = self.tr(""" <h2>%1</h2> <p>%1, %2, the %3 and all referring terms and symbols are copyrighted by %4</p> """).arg("World of Darkness").arg("White Wolf").arg("White Wolf-Logo").arg("White Wolf Inc.") self.aboutText = self.appText + self.gnuText + self.wodText QMessageBox.about(self, "About " + QCoreApplication.applicationName(), self.aboutText ) def roll(self): """ Der Wurf wird durchgeführt. Der tatsächliche Wurf wird aber von den Timern angestoßen. """ # Es wird ein rollender Würfel angezeigt. self.timerDice.start(DICEROLL_TIMER_INTERVAL) self.timerRoll.start(DICEROLL_TIMER_DELAY) def _executeRoll(self): """ Entscheidet vor dem eigentlichen Würfelwurf, ob ein normaler oder ein erweiterter Wurf notwendig ist und führt diesen aus. """ if self.ui.groupBox_extended.isChecked(): #qDebug("Checked") self.extendedRoll.roll() else: #qDebug("Not Checked") self.instantRoll.roll() # Die Anzeige des rollenden Würfels wird angehalten self.timerDice.stop() self.timerRoll.stop() def calcDicePool(self, value): """ Berechnet die Größe des zur Verfügung stehenden Würfelpools, welcher von den Würfeln und den Modifikatoren abhängt. """ self.instantRoll.poolSize = value + self.ui.spinBox_modifier.value() self.extendedRoll.poolSize = self.instantRoll.poolSize self.extendedRoll.limit = value self.dicePoolChanged.emit(self.instantRoll.poolSize) def calcDicePoolMod(self, value): """ Berechnet wie schon calcDicePool() die Größe des Würfelvorrats, allerdings werden dieser Funktion andere Argumente übergeben. """ self.instantRoll.poolSize = value + self.ui.spinBox_pool.value() self.extendedRoll.poolSize = value + self.ui.spinBox_pool.value() def setHouserules(self, value): #qDebug("Test" + str(value)) self.extendedRoll.isHouserules = value def setXAgainThreshold(self, value): """ Legt fest, bei welchem Ergebnis weitergewürfelt werden kann und wann dies überhaupt nicht der Fall sein sollte oder gar Erfolge abgezogen werden können. """ self.__threshold = 0 if (value < 3): self.__threshold = 10 - value # Index 0 entspricht 10 again, 1 entspricht 9 again etc. else: self.__threshold = 11 # Index 3 entspricht "no reroll" self.xAgainChanged.emit(self.__threshold) if (value > 3): self.cursed.emit(True) # Kein reroll und 1er werden Abgezogen. else: self.cursed.emit(False) # 1er werden nicht abgezogen. def setExtendedMode(self, sw): """ Legt den Modus fest, mit welchem der erweiterte Wurf durchgeführt wird. Entweder wird auf ein Ergebnishingewürfelt, oder nach einer bestimmten Anzahl würde die Anzahl der Erfolge gezählt. """ if (sw): self.extendedRoll.isResultInRolls = False else: self.extendedRoll.isResultInRolls = True def setResult(self, value): """ Schreibt das Ergebnis des Wurfs in die GUI. Dabei wird auch je nach Erfolgsqualität bei dem dargestellten Würfel eine andere Augenzahl gezeigt. """ self.ui.statusBar.showMessage(self.tr("Result of diceroll is displayed.")) if (value == DieResult.dramaticFailure): self.ui.label_resultText.setText(self.tr("Dramatic Failure")); self.ui.label_result.setPixmap(QPixmap(":/icons/actions/cnrdelete-all1.png")); self.displayDice(1) elif (value == DieResult.failure): self.ui.label_resultText.setText(self.tr("Failure")); self.ui.label_result.setPixmap(QPixmap(":/icons/actions/fileclose.png")); self.displayDice(Random.random(2, 7)) elif (value == DieResult.success): self.ui.label_resultText.setText(self.tr("Success")); self.ui.label_result.setPixmap(QPixmap(":/icons/actions/ok.png")); self.displayDice(Random.random(8, 9)) else: self.ui.label_resultText.setText(self.tr("Exceptional Success")); self.ui.label_result.setPixmap(QPixmap(":/icons/actions/bookmark.png")); self.displayDice(0) def setResultRolls(self, value): """ Zeigt in der GUI an, wieviele Würfe nötig waren. """ if (self.ui.groupBox_extended.isChecked() and self.ui.radioButton_target.isChecked()): self.ui.lcdNumber_successes.display(value) def setResultSuccesses(self, value): """ Zeigt in der GUI an, wieviele Erfolge erzielt wurden. """ if (not self.ui.groupBox_extended.isChecked() or not self.ui.radioButton_target.isChecked()): self.ui.lcdNumber_successes.display(value) def changeText(self): """ Verändert den Text in der Statuszeile. """ if (self.ui.groupBox_extended.isChecked() and self.ui.radioButton_target.isChecked()): self.ui.label_successes.setText(self.tr("Number of rolls needed:")) else: self.ui.label_successes.setText(self.tr("Number of successes:")) def reset(self): """ Setzt das Programm auf einen definierten Startwert zurück. """ self.ui.label_result.setPixmap(QPixmap(":/icons/actions/fileclose.png")) self.ui.label_resultText.setText(self.tr("No result yet!")) self.ui.lcdNumber_successes.display(0) self.ui.statusBar.showMessage(self.tr("Press the Button to roll the dice!"))
class Window(QWidget): ''' The MainWindow widget ''' def __init__(self, game): super().__init__() self.game = game self.game.ui = self self.setWindowTitle('WordJuggler') self.resize(800, 600) self.setStyleSheet('QGroupBox { border:0; font:bold;' + 'padding:20px 10px; min-width:220px; }') self.board = BoardItem(game.width, game.height) self.rack = RackItem(game.rack_size, game.width, game.height) self.scene = QGraphicsScene() self.scene.setBackgroundBrush(QBrush(QColor('#f9ece0'))) self.scene.addItem(self.board) self.scene.addItem(self.rack) self.scene.setSceneRect(self.scene.itemsBoundingRect()) self.view = BoardView(self.scene, self) self.view.letterChanged.connect(self.letterChanged) self.ranking = QGroupBox('Rankings') self.rankings = QLabel() rankings = QVBoxLayout() rankings.addWidget(self.rankings) self.ranking.setLayout(rankings) self.statistic = QGroupBox('Statistics') self.statistics = QLabel() statistics = QVBoxLayout() statistics.addWidget(self.statistics) self.statistic.setLayout(statistics) self.move = QGroupBox('Last 10 Moves') self.moves = QLabel() moves = QVBoxLayout() moves.addWidget(self.moves) self.move.setLayout(moves) self.buttons = QVBoxLayout() self.buttons.setSpacing(3) self.continue_button = QPushButton('Place &Word') self.continue_button.setEnabled(False) self.continue_button.setFixedSize(130, 25) self.continue_button.clicked.connect(self.continueClicked) self.pass_button = QPushButton('&Pass') self.pass_button.setEnabled(False) self.pass_button.setFixedSize(130, 25) self.pass_button.clicked.connect(self.passClicked) self.exchange_button = QPushButton('&Exchange') self.exchange_button.setEnabled(False) self.exchange_button.setFixedSize(130, 25) self.exchange_button.clicked.connect(self.exchangeClicked) self.buttons.addWidget(self.exchange_button, alignment=Qt.AlignCenter) self.buttons.addWidget(self.pass_button, alignment=Qt.AlignCenter) self.buttons.addWidget(self.continue_button, alignment=Qt.AlignCenter) information = QVBoxLayout() information.setMargin(20) information.setSpacing(20) information.addWidget(self.ranking) information.addWidget(self.statistic) information.addWidget(self.move) information.addStretch() information.addLayout(self.buttons) layout = QHBoxLayout() layout.setSpacing(0) layout.setMargin(0) layout.addWidget(self.view) layout.addLayout(information) self.setLayout(layout) self.show() for player in self.game.players: player.played_cb = self.playerDone self.playerNext() def update(self, *args, **kwargs): self.rankings.setText( '<br>'.join('%i. <font color=%s>%s</font> (%i points)' % (i + 1, player.color, player.name, player.score) for i,player in enumerate(sorted(self.game.players, reverse=True, key=attrgetter('score'))))) self.statistics.setText(('Total Players: %i\n' + 'Placed Words: %i\n' + 'Remaining Letters: %i') % (len(self.game.players), len(list(self.game.board.get_words())), self.game.letters.remaining_letters)) moves = [] for i,(player,move) in list(enumerate(self.game.moves))[-10:]: if move[0] == Player.PASS: desc = 'Pass' elif move[0] == Player.EXCHANGE_LETTERS: desc = 'Exchange (%s,%s)' % move[1:] else: desc = 'Word (%i,%i,%s,%s,%i)' % move[1:] moves.append('%i. <font color=%s>%s</font>' % (i + 1, player.color, desc)) self.moves.setText('<br>'.join(moves)) super().update(*args, **kwargs) def letterChanged(self): ''' As soon as a letter changes we need to en/disable all controls ''' self.exchange_button.setEnabled(False) self.exchange_button.setText('Exchange') if self.game.letters.remaining_letters >= self.game.rack_size: selected = ''.join(l.char for l in self.scene.items() if type(l) is LetterItem and l.selected) if selected: self.exchange_button.setText('Exchange: %s' % selected) self.exchange_button.setEnabled(True) self.pass_button.setEnabled(True) self.continue_button.setEnabled(True if self.board.validNewWord() else False) def playerNext(self): player = self.game.next_player() self.letterChanged() self.update() player.update_letters() self.rack.name = self.game.current_player.name self.rack.color = self.game.current_player.color for i,letter in enumerate(player.letters): item = LetterItem(letter, self.game.letters.get_score(letter), player.color) item.own(self.rack, i, move=False) self.scene.addItem(item) self.update() player.played_cb = self.playerDone player.play() def continueClicked(self): if type(self.game.current_player) is Human: self.game.current_player.continue_cb() def passClicked(self): if type(self.game.current_player) is Human: self.game.current_player.pass_cb() def exchangeClicked(self): if type(self.game.current_player) is Human: self.game.current_player.exchange_cb() def playerDone(self, player, move, *args): self.exchange_button.setEnabled(False) self.exchange_button.setText('Exchange') self.pass_button.setEnabled(False) self.continue_button.setEnabled(False) for item in self.scene.items(): if type(item) is LetterItem and not item.is_safe and \ not item.deleted: item.own(None) item.fade() for x,y,letter in self.game.board: if not self.board.getLetter(x, y): item = LetterItem(letter.char, self.game.letters.get_score(letter), letter.player.color, safe=True) item.own(self.board, x, y, move=False) self.scene.addItem(item) self.update() if self.game.state() == self.game.RUNNING: self.game.current_player.update_letters() self.playerNext() else: self.game.finish_score() self.update() self.gameOver() def getLetters(self, count, msg=''): print('random letters: %s' % self.game.get_letters_old(count)) while True: text,ok = QInputDialog.getText(self, 'New Letters', 'Player: <font color=%s>%s</font><br>' % ( self.game.current_player.color, self.game.current_player.name) + msg + 'Tell me %i new letters in order to continue..' % count) text = ''.join(filter(lambda x: x in self.game.letters.letters, text.lower())) if len(text) == count and all(self.game.letters.available(c) for c in text): return text def gameOver(self): winner = sorted(self.game.players, reverse=True, key=attrgetter('score'))[0] self.dialog = QMessageBox(QMessageBox.Information, 'Game Over', ('<b>Game Over!</b><br><br>The player ' + '<b><font color=%s>%s</font></b> has won!') % (winner.color, winner.name), QMessageBox.Ok, self) self.dialog.show()
class OWQualityControl(widget.OWWidget): name = "Quality Control" description = "Experiment quality control" icon = "../widgets/icons/QualityControl.svg" priority = 5000 inputs = [("Experiment Data", Orange.data.Table, "set_data")] outputs = [] DISTANCE_FUNCTIONS = [("Distance from Pearson correlation", dist_pcorr), ("Euclidean distance", dist_eucl), ("Distance from Spearman correlation", dist_spearman) ] settingsHandler = SetContextHandler() split_by_labels = settings.ContextSetting({}) sort_by_labels = settings.ContextSetting({}) selected_distance_index = settings.Setting(0) def __init__(self, parent=None): super().__init__(parent) ## Attributes self.data = None self.distances = None self.groups = None self.unique_pos = None self.base_group_index = 0 ## GUI box = gui.widgetBox(self.controlArea, "Info") self.info_box = gui.widgetLabel(box, "\n") ## Separate By box box = gui.widgetBox(self.controlArea, "Separate By") self.split_by_model = itemmodels.PyListModel(parent=self) self.split_by_view = QListView() self.split_by_view.setSelectionMode(QListView.ExtendedSelection) self.split_by_view.setModel(self.split_by_model) box.layout().addWidget(self.split_by_view) self.split_by_view.selectionModel().selectionChanged.connect( self.on_split_key_changed) ## Sort By box box = gui.widgetBox(self.controlArea, "Sort By") self.sort_by_model = itemmodels.PyListModel(parent=self) self.sort_by_view = QListView() self.sort_by_view.setSelectionMode(QListView.ExtendedSelection) self.sort_by_view.setModel(self.sort_by_model) box.layout().addWidget(self.sort_by_view) self.sort_by_view.selectionModel().selectionChanged.connect( self.on_sort_key_changed) ## Distance box box = gui.widgetBox(self.controlArea, "Distance Measure") gui.comboBox(box, self, "selected_distance_index", items=[name for name, _ in self.DISTANCE_FUNCTIONS], callback=self.on_distance_measure_changed) self.scene = QGraphicsScene() self.scene_view = QGraphicsView(self.scene) self.scene_view.setRenderHints(QPainter.Antialiasing) self.scene_view.setAlignment(Qt.AlignLeft | Qt.AlignVCenter) self.mainArea.layout().addWidget(self.scene_view) self.scene_view.installEventFilter(self) self._disable_updates = False self._cached_distances = {} self._base_index_hints = {} self.main_widget = None self.resize(800, 600) def clear(self): """Clear the widget state.""" self.data = None self.distances = None self.groups = None self.unique_pos = None with disable_updates(self): self.split_by_model[:] = [] self.sort_by_model[:] = [] self.main_widget = None self.scene.clear() self.info_box.setText("\n") self._cached_distances = {} def set_data(self, data=None): """Set input experiment data.""" self.closeContext() self.clear() self.error(0) self.warning(0) if data is not None: keys = self.get_suitable_keys(data) if not keys: self.error(0, "Data has no suitable feature labels.") data = None self.data = data if data is not None: self.on_new_data() def update_label_candidates(self): """Update the label candidates selection GUI (Group/Sort By views). """ keys = self.get_suitable_keys(self.data) with disable_updates(self): self.split_by_model[:] = keys self.sort_by_model[:] = keys def get_suitable_keys(self, data): """ Return suitable attr label keys from the data where the key has at least two unique values in the data. """ attrs = [attr.attributes.items() for attr in data.domain.attributes] attrs = reduce(operator.iadd, attrs, []) # in case someone put non string values in attributes dict attrs = [(str(key), str(value)) for key, value in attrs] attrs = set(attrs) values = defaultdict(set) for key, value in attrs: values[key].add(value) keys = [key for key in values if len(values[key]) > 1] return keys def selected_split_by_labels(self): """Return the current selected split labels. """ sel_m = self.split_by_view.selectionModel() indices = [r.row() for r in sel_m.selectedRows()] return [self.sort_by_model[i] for i in indices] def selected_sort_by_labels(self): """Return the current selected sort labels """ sel_m = self.sort_by_view.selectionModel() indices = [r.row() for r in sel_m.selectedRows()] return [self.sort_by_model[i] for i in indices] def selected_distance(self): """Return the selected distance function. """ return self.DISTANCE_FUNCTIONS[self.selected_distance_index][1] def selected_base_group_index(self): """Return the selected base group index """ return self.base_group_index def selected_base_indices(self, base_group_index=None): indices = [] for g, ind in self.groups: if base_group_index is None: label = group_label(self.selected_split_by_labels(), g) ind = [i for i in ind if i is not None] i = self._base_index_hints.get(label, ind[0] if ind else None) else: i = ind[base_group_index] indices.append(i) return indices def on_new_data(self): """We have new data and need to recompute all. """ self.closeContext() self.update_label_candidates() self.info_box.setText( "%s genes \n%s experiments" % (len(self.data), len(self.data.domain.attributes))) self.base_group_index = 0 keys = self.get_suitable_keys(self.data) self.openContext(keys) ## Restore saved context settings (split/sort selection) split_by_labels = self.split_by_labels sort_by_labels = self.sort_by_labels def select(model, selection_model, selected_items): """Select items in a Qt item model view """ all_items = list(model) try: indices = [all_items.index(item) for item in selected_items] except: indices = [] for ind in indices: selection_model.select(model.index(ind), QItemSelectionModel.Select) with disable_updates(self): select(self.split_by_view.model(), self.split_by_view.selectionModel(), split_by_labels) select(self.sort_by_view.model(), self.sort_by_view.selectionModel(), sort_by_labels) with widget_disable(self): self.split_and_update() def on_split_key_changed(self, *args): """Split key has changed """ with widget_disable(self): if not self._disable_updates: self.base_group_index = 0 self.split_by_labels = self.selected_split_by_labels() self.split_and_update() def on_sort_key_changed(self, *args): """Sort key has changed """ with widget_disable(self): if not self._disable_updates: self.base_group_index = 0 self.sort_by_labels = self.selected_sort_by_labels() self.split_and_update() def on_distance_measure_changed(self): """Distance measure has changed """ if self.data is not None: with widget_disable(self): self.update_distances() self.replot_experiments() def on_view_resize(self, size): """The view with the quality plot has changed """ if self.main_widget: current = self.main_widget.size() self.main_widget.resize(size.width() - 6, current.height()) self.scene.setSceneRect(self.scene.itemsBoundingRect()) def on_rug_item_clicked(self, item): """An ``item`` in the quality plot has been clicked. """ update = False sort_by_labels = self.selected_sort_by_labels() if sort_by_labels and item.in_group: ## The item is part of the group if item.group_index != self.base_group_index: self.base_group_index = item.group_index update = True else: if sort_by_labels: # If the user clicked on an background item it # invalidates the sorted labels selection with disable_updates(self): self.sort_by_view.selectionModel().clear() update = True index = item.index group = item.group label = group_label(self.selected_split_by_labels(), group) if self._base_index_hints.get(label, 0) != index: self._base_index_hints[label] = index update = True if update: with widget_disable(self): self.split_and_update() def eventFilter(self, obj, event): if obj is self.scene_view and event.type() == QEvent.Resize: self.on_view_resize(event.size()) return super().eventFilter(obj, event) def split_and_update(self): """ Split the data based on the selected sort/split labels and update the quality plot. """ split_labels = self.selected_split_by_labels() sort_labels = self.selected_sort_by_labels() self.warning(0) if not split_labels: self.warning(0, "No separate by label selected.") self.groups, self.unique_pos = \ exp.separate_by(self.data, split_labels, consider=sort_labels, add_empty=True) self.groups = sorted(self.groups.items(), key=lambda t: list(map(float_if_posible, t[0]))) self.unique_pos = sorted( self.unique_pos.items(), key=lambda t: list(map(float_if_posible, t[0]))) if self.groups: if sort_labels: group_base = self.selected_base_group_index() base_indices = self.selected_base_indices(group_base) else: base_indices = self.selected_base_indices() self.update_distances(base_indices) self.replot_experiments() def get_cached_distances(self, measure): if measure not in self._cached_distances: attrs = self.data.domain.attributes mat = numpy.zeros((len(attrs), len(attrs))) self._cached_distances[measure] = \ (mat, set(zip(range(len(attrs)), range(len(attrs))))) return self._cached_distances[measure] def get_cached_distance(self, measure, i, j): matrix, computed = self.get_cached_distances(measure) key = (i, j) if i < j else (j, i) if key in computed: return matrix[i, j] else: return None def get_distance(self, measure, i, j): d = self.get_cached_distance(measure, i, j) if d is None: vec_i = take_columns(self.data, [i]) vec_j = take_columns(self.data, [j]) d = measure(vec_i, vec_j) mat, computed = self.get_cached_distances(measure) mat[i, j] = d key = key = (i, j) if i < j else (j, i) computed.add(key) return d def store_distance(self, measure, i, j, dist): matrix, computed = self.get_cached_distances(measure) key = (i, j) if i < j else (j, i) matrix[j, i] = matrix[i, j] = dist computed.add(key) def update_distances(self, base_indices=()): """Recompute the experiment distances. """ distance = self.selected_distance() if base_indices == (): base_group_index = self.selected_base_group_index() base_indices = [ind[base_group_index] \ for _, ind in self.groups] assert (len(base_indices) == len(self.groups)) base_distances = [] attributes = self.data.domain.attributes pb = gui.ProgressBar(self, len(self.groups) * len(attributes)) for (group, indices), base_index in zip(self.groups, base_indices): # Base column of the group if base_index is not None: base_vec = take_columns(self.data, [base_index]) distances = [] # Compute the distances between base column # and all the rest data columns. for i in range(len(attributes)): if i == base_index: distances.append(0.0) elif self.get_cached_distance(distance, i, base_index) is not None: distances.append( self.get_cached_distance(distance, i, base_index)) else: vec_i = take_columns(self.data, [i]) dist = distance(base_vec, vec_i) self.store_distance(distance, i, base_index, dist) distances.append(dist) pb.advance() base_distances.append(distances) else: base_distances.append(None) pb.finish() self.distances = base_distances def replot_experiments(self): """Replot the whole quality plot. """ self.scene.clear() labels = [] max_dist = numpy.nanmax(list(filter(None, self.distances))) rug_widgets = [] group_pen = QPen(Qt.black) group_pen.setWidth(2) group_pen.setCapStyle(Qt.RoundCap) background_pen = QPen(QColor(0, 0, 250, 150)) background_pen.setWidth(1) background_pen.setCapStyle(Qt.RoundCap) main_widget = QGraphicsWidget() layout = QGraphicsGridLayout() attributes = self.data.domain.attributes if self.data is not None: for (group, indices), dist_vec in zip(self.groups, self.distances): indices_set = set(indices) rug_items = [] if dist_vec is not None: for i, attr in enumerate(attributes): # Is this a within group distance or background in_group = i in indices_set if in_group: rug_item = ClickableRugItem( dist_vec[i] / max_dist, 1.0, self.on_rug_item_clicked) rug_item.setPen(group_pen) tooltip = experiment_description(attr) rug_item.setToolTip(tooltip) rug_item.group_index = indices.index(i) rug_item.setZValue(rug_item.zValue() + 1) else: rug_item = ClickableRugItem( dist_vec[i] / max_dist, 0.85, self.on_rug_item_clicked) rug_item.setPen(background_pen) tooltip = experiment_description(attr) rug_item.setToolTip(tooltip) rug_item.group = group rug_item.index = i rug_item.in_group = in_group rug_items.append(rug_item) rug_widget = RugGraphicsWidget(parent=main_widget) rug_widget.set_rug(rug_items) rug_widgets.append(rug_widget) label = group_label(self.selected_split_by_labels(), group) label_item = QGraphicsSimpleTextItem(label, main_widget) label_item = GraphicsSimpleTextLayoutItem(label_item, parent=layout) label_item.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed) labels.append(label_item) for i, (label, rug_w) in enumerate(zip(labels, rug_widgets)): layout.addItem(label, i, 0, Qt.AlignVCenter) layout.addItem(rug_w, i, 1) layout.setRowMaximumHeight(i, 30) main_widget.setLayout(layout) self.scene.addItem(main_widget) self.main_widget = main_widget self.rug_widgets = rug_widgets self.labels = labels self.on_view_resize(self.scene_view.size())