def __init__(self, values, errors=None, colors=None, header='', fsize=9, height=0, hlines=None, kind='bar', hlines_col=None, extras=None, col_width=11, ylim=None, xlabel='', ylabel=''): self.col_w = float(col_width) self.height = height # self.values = [float(v) for v in values] self.values = [int(v) for v in values] self.width = self.col_w * len(self.values) self.errors = errors if errors else [] self.colors = colors if colors else ['gray'] * len(self.values) self.header = header self.fsize = fsize if ylim: self.ylim = tuple((float(y) for y in ylim)) else: self.ylim = (int(min(self.values) - 0.5), int(max(self.values) + 0.5)) self.xlabel = xlabel self.ylabel = ylabel if self.errors: if type(self.errors[0]) is list or type(self.errors[0]) is tuple: self._up_err = [float(e[1]) for e in self.errors] self._dw_err = [float(-e[0]) for e in self.errors] else: self._up_err = [float(e) for e in self.errors] self._dw_err = [float(-e) for e in self.errors] if kind == 'bar': self.draw_fun = self.draw_bar elif kind == 'stick': self.draw_fun = self.draw_stick elif kind == 'curve': self.draw_fun = self.draw_curve else: raise 'kind %s not yet implemented... ;)' self.hlines = [float(h) for h in hlines] if hlines else [1.0] self.hlines_col = hlines_col if hlines_col else ['black'] * len( self.hlines) self.extras = extras if extras else [''] if len(self.extras) != len(self.values): self.extras = [''] super(RulerFace, self).__init__( QGraphicsRectItem(-40, 0, self.width + 40, self.height + 50)) self.item.setPen(QPen(QColor('white')))
def update_items(self): self.item = QGraphicsRectItem(-30, 0, self.width + 40, self.height + 70) #self.item.setPen(QPen(QColor('gray'))) self.item.setPen(QPen(QColor('white'))) try: put_colored_boxes = self.put_colored_boxes except AttributeError: put_colored_boxes = (False, 0) if put_colored_boxes[0]: (_, tree_h) = put_colored_boxes self.draw_colored_boxes(tree_h) # draw lines for line, col in zip(self.hlines, self.hlines_col): self.draw_hlines(line, col) # draw plot width = self.col_w for i, val in enumerate(self.values): self.draw_fun(width * i + self.col_w / 2, val, i) # draw error bars if self.errors: for i in range(len(self.errors)): self.draw_errors(width * i + self.col_w / 2, i) # draw x axis self.draw_x_axis() # draw y axis self.draw_y_axis() # put header self.write_header()
def showMoveHelper(self, visible=True): """show help text In empty HandBoards""" if visible: if not self.__moveHelper: splitter = QGraphicsRectItem(self) hbCenter = self.rect().center() splitter.setRect(hbCenter.x() * 0.5, hbCenter.y(), hbCenter.x() * 1, 1) helpItems = [splitter] for name, yFactor in [(m18n('Move Exposed Tiles Here'), 0.5), (m18n('Move Concealed Tiles Here'), 1.5)]: helper = QGraphicsSimpleTextItem(name, self) helper.setScale(3) nameRect = QRectF() nameRect.setSize(helper.mapToParent(helper.boundingRect()).boundingRect().size()) center = QPointF(hbCenter) center.setY(center.y() * yFactor) helper.setPos(center - nameRect.center()) if self.sceneRotation() == 180: rotateCenter(helper, 180) helpItems.append(helper) self.__moveHelper = self.scene().createItemGroup(helpItems) self.__moveHelper.setVisible(True) else: if self.__moveHelper: self.__moveHelper.setVisible(False)
def mousePressEvent(self, event): pos = event.scenePos() any_item = self.scene.item_at(pos) if not any_item and event.button() & Qt.LeftButton: self.modifiers = event.modifiers() self.selection_rect = QRectF(pos, QSizeF(0, 0)) self.rect_item = QGraphicsRectItem( self.selection_rect.normalized()) self.rect_item.setPen( QPen(QBrush(QColor(51, 153, 255, 192)), 0.4, Qt.SolidLine, Qt.RoundCap)) self.rect_item.setBrush(QBrush(QColor(168, 202, 236, 192))) self.rect_item.setZValue(-100) # Clear the focus if necessary. if not self.scene.stickyFocus(): self.scene.clearFocus() if not self.modifiers & Qt.ControlModifier: self.scene.clearSelection() event.accept() return True else: self.cancel(self.ErrorReason) return False
def scientific_name_face(node, *args, **kwargs): scientific_name_text = QGraphicsTextItem() #underscore = node.name.replace("_", " ") words = node.name.split("_") text = [] if len(words) < 2: # some sort of acronym or bin name, leave it alone text = words elif len(words) > 2: if len(words) >= 5: text.extend( ['<b>' + words[0] + ' <i> ' + words[1], words[2] + ' </i> ']) text.extend(words[3:] + ['</b>']) elif len(words) == 3: text.extend([ ' <span style="color:grey"><i> ' + words[0], words[1] + words[2] + ' </i></span>' ]) else: # assume that everything after the # second word is strain name # which should not get italicized text.extend([ ' <span style="color:grey"><i> ' + words[0], words[1] + ' </i></span>' ]) text.extend(words[2:]) else: text.extend([ ' <span style="color:grey"><i> ' + words[0], words[1] + ' </i></span> ' ]) scientific_name_text.setHtml(' '.join(text)) # below is a bit of a hack - I've found that the height of the bounding # box gives a bit too much padding around the name, so I just minus 10 # from the height and recenter it. Don't know whether this is a generally # applicable number to use #myFont = QFont() masterItem = QGraphicsRectItem( 0, 0, scientific_name_text.boundingRect().width(), scientific_name_text.boundingRect().height() - 10) scientific_name_text.setParentItem(masterItem) center = masterItem.boundingRect().center() scientific_name_text.setPos( masterItem.boundingRect().x(), center.y() - scientific_name_text.boundingRect().height() / 2) # I don't want a border around the masterItem masterItem.setPen(QPen(QtCore.Qt.NoPen)) return masterItem
def __init__(self, text, parent): QGraphicsObject.__init__(self, parent) self.text_item = QGraphicsTextItem(text + ':', self) f = self.text_item.font() f.setBold(True) self.text_item.setFont(f) self.rect_item = QGraphicsRectItem(self.text_item.boundingRect(), self) self.rect_item.setPen(QPen(Qt.NoPen)) self.rect_item.stackBefore(self.text_item)
def __init__(self, pen=QPen(Qt.black), brush=QBrush(Qt.white), xData=None, yData=None, tooltip=None): OWCurve.__init__(self, xData, yData, tooltip=tooltip) self.set_pen(pen) self.set_brush(brush) self._item = QGraphicsRectItem(self)
def __init__(self): QGraphicsScene.__init__(self) self.__disableFocusRect = False self._focusBoard = None self.focusRect = QGraphicsRectItem() pen = QPen(QColor(Qt.blue)) pen.setWidth(6) self.focusRect.setPen(pen) self.addItem(self.focusRect) self.focusRect.setZValue(ZValues.marker) self.focusRect.hide()
def _setSceneRect(self): w, h = self.dataShape rect = self.data2scene.mapRect(QRect(0, 0, w, h)) sw, sh = rect.width(), rect.height() self.setSceneRect(0, 0, sw, sh) #this property represent a parent to QGraphicsItems which should #be clipped to the data, such as temporary capped lines for brushing. #This works around ilastik issue #516. self.dataRect = QGraphicsRectItem(0, 0, sw, sh) self.dataRect.setPen(QPen(QColor(0, 0, 0, 0))) self.dataRect.setFlag(QGraphicsItem.ItemClipsChildrenToShape) self.addItem(self.dataRect)
def hoverEnterEvent(self, e): """ when mouse is over""" if not self.label: self.label = QGraphicsRectItem(parent=self) #self.label.setY(-18) self.label.setX(11) self.label.setBrush(QBrush(QColor("white"))) self.label.text = QGraphicsSimpleTextItem(parent=self.label) self.setZValue(1) self.label.text.setText(self.codon) self.label.setRect(self.label.text.boundingRect()) self.label.setVisible(True)
def setTiles(self): #background brush = QBrush() pix = QPixmap(os.getcwd() + "/robotImages/tile.png") brush.setTexture(pix) brush.setStyle(24) self.setBackgroundBrush(brush) #wall #left left = QGraphicsRectItem() pix = QPixmap(os.getcwd() + "/robotImages/tileVert.png") left.setRect(QtCore.QRectF(0, 0, pix.width(), self.height)) brush.setTexture(pix) brush.setStyle(24) left.setBrush(brush) left.name = 'left' self.addItem(left) #right right = QGraphicsRectItem() right.setRect(self.width - pix.width(), 0, pix.width(), self.height) right.setBrush(brush) right.name = 'right' self.addItem(right) #top top = QGraphicsRectItem() pix = QPixmap(os.getcwd() + "/robotImages/tileHori.png") top.setRect(QtCore.QRectF(0, 0, self.width, pix.height())) brush.setTexture(pix) brush.setStyle(24) top.setBrush(brush) top.name = 'top' self.addItem(top) #bottom bottom = QGraphicsRectItem() bottom.setRect(0, self.height - pix.height(), self.width, pix.height()) bottom.setBrush(brush) bottom.name = 'bottom' self.addItem(bottom)
def scientific_name_face(node, *args, **kwargs): scientific_name_text = QGraphicsTextItem() words = node.visual_label.split() text = [] if hasattr(node, 'bg_col'): container_div = '<div style="background-color:{};">'.format(node.bgcolor) text.append(container_div) if len(words) < 2: # some sort of acronym or bin name, leave it alone text.extend(words) elif len(words) > 2: if words[0] == 'Candidatus': # for candidatus names, only the Candidatus part is italicised # name shortening it for brevity text.append('<i>Ca.</i>') text.extend(words[1:]) elif re.match('^[A-Z]+$', words[0]): # If the first word is in all caps then it is an abreviation # so we don't want to italicize that at all text.extend(words) else: # assume that everything after the second word is strain name # which should not get italicised text.extend(['<i>'+words[0],words[1]+'</i>']) text.extend(words[2:]) else: text.extend(['<i>'+words[0],words[1]+'</i>']) if hasattr(node, 'bg_col'): text.append('</div>') scientific_name_text.setHtml(' '.join(text)) #print(scientific_name_text.boundingRect().width(), scientific_name_text.boundingRect().height()) # below is a bit of a hack - I've found that the height of the bounding # box gives a bit too much padding around the name, so I just minus 10 # from the height and recenter it. Don't know whether this is a generally # applicable number to use masterItem = QGraphicsRectItem(0, 0, scientific_name_text.boundingRect().width(), scientific_name_text.boundingRect().height() - 10) scientific_name_text.setParentItem(masterItem) center = masterItem.boundingRect().center() scientific_name_text.setPos(masterItem.boundingRect().x(), center.y() - scientific_name_text.boundingRect().height()/2) # I dont want a border around the masterItem masterItem.setPen(QPen(QtCore.Qt.NoPen)) return masterItem
def hoverEnterEvent(self, event): """ Stuff related to hover enter events. For now we just show a rectangular outline. """ if not self._outline: self._outline = QGraphicsRectItem(self.boundingRect(), self) highlightColor = QColor(Qt.blue) highlightColor.setAlpha(30) self._outline.setBrush(highlightColor) highlightPen = QPen(Qt.blue) highlightPen.setWidth(2) self._outline.setPen(highlightPen) else: self._outline.show()
def hoverEnterEvent(self, e): # There are many ways of adding interactive elements. With the # following code, I show/hide a text item over my custom # DynamicItemFace if not self.label: self.label = QGraphicsRectItem() self.label.setParentItem(self) # This is to ensure that the label is rendered over the # rest of item children (default ZValue for items is 0) self.label.setZValue(1) self.label.setBrush(QBrush(QColor("white"))) self.label.text = QGraphicsSimpleTextItem() self.label.text.setParentItem(self.label) self.label.text.setText(self.node.name) self.label.setRect(self.label.text.boundingRect()) self.label.setVisible(True)
def update_items(self): rect_h = self.height if self.x_axis: rect_h += 30 self.item = QGraphicsRectItem(0, 0, self.width + 40, rect_h) self.item.setPen(QPen(QColor('white'))) #X axis if self.x_axis: self.draw_x_axis() # Legend self.draw_legend() # Y axes and colo rect yi = -1 for model in ["PCOC", "PC", "OC", "Topological", "Identical"]: if self.dict_values_pcoc.has_key(model): yi += 1 y = yi * self.col_w # Y axes ## Stick yaxis = (yi + 0.5) * self.col_w lineItem = QGraphicsLineItem(self.width, yaxis, self.width + 5, yaxis, parent=self.item) lineItem.setPen(QPen(QColor('black'))) ## Text text = QGraphicsSimpleTextItem(model) text.setFont(QFont("Arial", self.fsize - 2)) text.setParentItem(self.item) tw = text.boundingRect().width() th = text.boundingRect().height() ## Center text according to masterItem size text.setPos(self.width + 5, yaxis - th / 2) # Color rect for each model values = self.dict_values_pcoc[model] for i, val in enumerate(values): self.draw_fun(i * self.col_w, y, val, col_width=self.col_w)
def ugly_name_face(node, *args, **kargs): """ This is my item generator. It must receive a node object, and returns a Qt4 graphics item that can be used as a node face. """ width = node.dist * 2.5 height = 12 masterItem = InteractiveItem(0, 0, width, height) masterItem.node = node masterItem.setPen(QPen(QtCore.Qt.NoPen)) color_rect = QGraphicsRectItem(masterItem.rect()) color_rect.setParentItem(masterItem) color_rect.setBrush(QBrush(QColor(100, 100, 200, 100))) color_rect.setPen(QPen(QtCore.Qt.NoPen)) masterItem.color_rect = color_rect return masterItem
def __init__(self, palette, values, parent): QGraphicsObject.__init__(self, parent) self.parent = parent self.palette = palette self.values = values self.legend = parent self.label_items = [QGraphicsTextItem(text, self) for text in values] for i in self.label_items: i.setTextWidth(50) self.rect = QRectF() self.gradient_item = QGraphicsRectItem(self) self.gradient = QLinearGradient() self.gradient.setStops([(v * 0.1, self.palette[v * 0.1]) for v in range(11)]) self.orientation = Qt.Horizontal self.set_orientation(Qt.Vertical)
def updateSelectionRect(self, event): pos = event.scenePos() buttonDownPos = event.buttonDownScenePos(Qt.LeftButton) rect = QRectF(pos, buttonDownPos).normalized() rect = rect.intersected(self.sceneRect()) if not self.selectionRect: self.selectionRect = QGraphicsRectItem() self.selectionRect.setBrush(QColor(10, 10, 10, 20)) self.selectionRect.setPen(QPen(QColor(200, 200, 200, 200))) self.addItem(self.selectionRect) self.selectionRect.setRect(rect) if event.modifiers() & Qt.ControlModifier or \ event.modifiers() & Qt.ShiftModifier: path = self.selectionArea() else: path = QPainterPath() path.addRect(rect) self.setSelectionArea(path) self.selectionRectPointChanged.emit(pos)
def render_drop_shadow_frame(pixmap, shadow_rect, shadow_color, offset, radius, rect_fill_color): pixmap.fill(QColor(0, 0, 0, 0)) scene = QGraphicsScene() rect = QGraphicsRectItem(shadow_rect) rect.setBrush(QColor(rect_fill_color)) rect.setPen(QPen(Qt.NoPen)) scene.addItem(rect) effect = QGraphicsDropShadowEffect(color=shadow_color, blurRadius=radius, offset=offset) rect.setGraphicsEffect(effect) scene.setSceneRect(QRectF(QPointF(0, 0), QSizeF(pixmap.size()))) painter = QPainter(pixmap) scene.render(painter) painter.end() scene.clear() scene.deleteLater() return pixmap
def __init__(self, seq, seqtype="aa", fsize=10, fg_colors=None, bg_colors=None, codon=None, col_w=11, alt_col_w=3, special_col=None, interactive=False): self.seq = seq self.codon = codon self.fsize = fsize self.style = seqtype self.col_w = float(col_w) self.alt_col_w = float(alt_col_w) self.special_col = special_col if special_col else [] self.width = 0 # will store the width of the whole sequence self.interact = interactive if self.style == "aa": if not fg_colors: fg_colors = _aafgcolors if not bg_colors: bg_colors = _aabgcolors else: if not fg_colors: fg_colors = _ntfgcolors if not bg_colors: bg_colors = _ntbgcolors self.fg_col = self.__init_col(fg_colors) self.bg_col = self.__init_col(bg_colors) # for future? self.row_h = 13.0 super(MySequenceFace, self).__init__(QGraphicsRectItem(0, 0, self.width, self.row_h))
def test_controlpointrect(self): control = ControlPointRect() rect = QGraphicsRectItem(QRectF(10, 10, 100, 200)) self.scene.addItem(rect) self.scene.addItem(control) control.setRect(rect.rect()) control.setFocus() control.rectChanged.connect(rect.setRect) control.setRect(QRectF(20, 20, 100, 200)) self.assertEqual(control.rect(), rect.rect()) self.assertEqual(control.rect(), QRectF(20, 20, 100, 200)) control.setControlMargins(5) self.assertEqual(control.controlMargins(), QMargins(5, 5, 5, 5)) control.rectEdited.connect(rect.setRect) self.view.show() self.app.exec_() self.assertEqual(rect.rect(), control.rect())
def __init__(self, name, point, parent): QGraphicsObject.__init__(self, parent) self.text_item = QGraphicsTextItem(name, self) if point: s = point.size() height = max(2 * s, self.text_item.boundingRect().height()) else: height = self.text_item.boundingRect().height() p = 0.5 * height self.text_item.setPos(height, 0) self.point_item = point if point: self.point_item.setParentItem(self) self.point_item.setPos(p, p) self._rect = QRectF(0, 0, height + self.text_item.boundingRect().width(), height) self.rect_item = QGraphicsRectItem(self._rect, self) self.rect_item.setPen(QPen(Qt.NoPen)) self.rect_item.stackBefore(self.text_item) if self.point_item: self.rect_item.stackBefore(self.point_item)
def trinomial_face(binom, spp, ftype="Verdana", fsize=10, fgcolor="black", fstyle="normal", bold=False): """ Stolen from: https://connorskennerton.wordpress.com/2016/11/16/python-ete3-formatting-organism-names-the-way-i-want/ """ font = QFont(ftype, fsize) font.setBold(bold) if fstyle == "italic": font.setStyle(QFont.StyleItalic) elif fstyle == "oblique": font.setStyle(QFont.StyleOblique) text = QGraphicsTextItem() text.setFont(font) if spp is None: text.setHtml("<i>{}</i>".format(binom)) else: text.setHtml("<i>{}</i> {}".format(binom, spp)) rect = QGraphicsRectItem(0, 0, text.boundingRect().width(), text.boundingRect().height() - 10) text.setParentItem(rect) center = rect.boundingRect().center() text.setPos(rect.boundingRect().x(), center.y() - text.boundingRect().height() / 2) # no border rect.setPen(QPen(QtCore.Qt.NoPen)) return ete3.faces.StaticItemFace(rect)
def draw_legend(self): legend_h = self.height * ((self.nb_models - 1) / float(self.nb_models)) if legend_h < 35: legend_h = 35 legend_rect = QGraphicsRectItem(-20, 0, 10, legend_h, parent=self.item) x0 = -20 n_cat = 6. for y, str_y in [(1, 1), (1 / n_cat * 5, 0.99), (1 / n_cat * 4, 0.9), (1 / n_cat * 3, 0.8), (1 / n_cat * 2, 0.7), (1 / n_cat * 1, 0.5), (1 / n_cat * 0, 0)]: y_stick = legend_h - y * legend_h lineItem = QGraphicsLineItem(x0 - 5, y_stick, x0, y_stick, parent=self.item) lineItem.setPen(QPen(QColor('black'))) text = QGraphicsSimpleTextItem(str(str_y)) text.setFont(QFont("Arial", self.fsize - 4)) text.setParentItem(self.item) tw = text.boundingRect().width() th = text.boundingRect().height() # Center text according to masterItem size text.setPos(x0 - tw - 7, y_stick - th / 2) for (y1, y2, c) in [(1, 1 / n_cat * 5, 0.99), (1 / n_cat * 5, 1 / n_cat * 4, 0.9), (1 / n_cat * 4, 1 / n_cat * 3, 0.8), (1 / n_cat * 3, 1 / n_cat * 2, 0.7), (1 / n_cat * 2, 1 / n_cat * 1, 0.5), (1 / n_cat * 1, 1 / n_cat * 0, 0)]: y1_stick = legend_h - y1 * legend_h y2_stick = legend_h - y2 * legend_h self.draw_fun(x0, y1_stick, c, col_width=10, col_height=y2_stick - y1_stick)
def __init__(o, parent, puzzle_client, mainwindow, *args): QGraphicsScene.__init__(o, parent, *args) o._input_tracker = InputTracker(o, accepts=sum(KEYS.values(), [])) o.setBackgroundBrush(QBrush(QColor("darkGray"))) o.client = puzzle_client o.mainwindow = mainwindow o.cluster_map = {} # connect my events o.client.puzzle.connect(o._display_puzzle) o.client.piece_pixmaps.connect(o._set_piece_pixmaps) o.client.clusters.connect(o.OnClustersChanged) o.client.grabbed.connect(o.onClustersGrabbed) o.client.moved.connect(o.onClustersMoved) o.client.dropped.connect(o.onClustersDropped) o.client.joined.connect(o.onClustersJoined) # request puzzle data from server o.client.get_puzzle() # init piece movement o.rotations = 1 # number of rotations that the puzzle allows # List of cluster (widgets) that have been grabbed locally. dict clusterid -> ClusterWidget o.grabbed_widgets = {} # number of rotations (relative to initial rotation) having been applied to the grabbed widgets. o._move_rotation = 0 # time of last position update (for rate limit) o._last_move_send_time = 0 # init selection o._drag_start = None o._rubberband = QGraphicsRectItem(QRectF(0., 0., 100., 100.)) p = QPen(QColor(255, 255, 255)) o._rubberband.setPen(p) o._rubberband.hide() o.addItem(o._rubberband)
def polygon_name_face(node, *args, **kwargs): """create a wedge shaped face in the style of ARB Args: width (int): size in pixels for the width of the wedge height (int): size in pixels for the height of the wedge width_percent (float): change the angle of the point of the wedge. This must be a number between 0 and 1 Returns: QGraphicsRectItem: The Qt graphics item of the polygon """ n_leaves = len(node.get_leaves()) closest_leaf_dist = node.get_closest_leaf()[1] farthest_leaf_dist = node.get_farthest_leaf()[1] base_height = 30 width = 60 height = math.log(n_leaves, 2) + base_height width_percent = closest_leaf_dist / farthest_leaf_dist #print(width, height, width_percent) points = [ (0.0, 0.0), # top left point (width, 0.0), # top right point (width * width_percent, height), # bottom right point (0.0, height), # bottom left point (0.0, 0.0) # back to the beginning ] shape = QPolygonF() for i in points: shape << QtCore.QPointF(*i) ## Creates a main master Item that will contain all other elements ## Items can be standard QGraphicsItem masterItem = QGraphicsRectItem(0, 0, width, height) # Keep a link within the item to access node info masterItem.node = node # I dont want a border around the masterItem masterItem.setPen(QPen(QtCore.Qt.NoPen)) polygon = QGraphicsPolygonItem(shape, masterItem) # Make the wedge grey in color polygon.setBrush(QBrush(QColor( '#D3D3D3'))) # Print the name of the node # Center text according to masterItem size center = masterItem.boundingRect().center() text = QGraphicsSimpleTextItem(node.name) text.setParentItem(polygon) tw = text.boundingRect().width() th = text.boundingRect().height() text.setPos(center.x() + tw/2, center.y() - th/2) # this is a hack to prevent the name being printed twice # we set the node name to blank after we write it with the QGraphicsSimpleTextItem # it must be set to a blank string for it not to be printed later node.name = '' # print the number of collapsed leaves in the polygon leaves_count_text = QGraphicsSimpleTextItem('('+str(n_leaves)+')') leaves_count_text.setParentItem(polygon) leaves_count_text.setFont(QFont('Veranda', 6)) leaves_count_text.setPos(masterItem.boundingRect().x() + 5, center.y() - leaves_count_text.boundingRect().height()/2) polygon.setPos(0, masterItem.boundingRect().y()/1.5) return masterItem
def draw_colored_boxes(self, h): stick_colors = self.colors num_col_red = stick_colors.count("red") num_col_orange = stick_colors.count("orange") num_col_yellow = stick_colors.count("#EFDB00") num_col_gray = stick_colors.count("gray") colored_box_h = self.height + h - 5 if num_col_red: rect_red = QGraphicsRectItem(self.col_w * 0 - 1, self.coordY(self.ylim[1]) - 5, self.col_w * num_col_red, colored_box_h) qpen = QPen(QColor('red')) qpen.setWidth(1) qpen.setStyle( 5) # dash line : http://doc.qt.io/qt-4.8/qt.html#PenStyle-enum rect_red.setPen(qpen) rect_red.setBrush(QColor("#FFD1D1")) rect_red.setZValue(-1) rect_red.setParentItem(self.item) #rect_red.setOpacity(0.5) if num_col_orange: rect_orange = QGraphicsRectItem(self.col_w * num_col_red + 1, self.coordY(self.ylim[1]) - 5, self.col_w * num_col_orange - 2, colored_box_h) qpen = QPen(QColor('orange')) qpen.setWidth(1) qpen.setStyle( 5) # dash line : http://doc.qt.io/qt-4.8/qt.html#PenStyle-enum rect_orange.setPen(qpen) rect_orange.setBrush(QColor("#FFE3B0")) rect_orange.setZValue(-1) rect_orange.setParentItem(self.item) #rect_orange.setOpacity(0.5) if num_col_yellow: rect_yellow = QGraphicsRectItem( self.col_w * (num_col_orange + num_col_red) + 1, self.coordY(self.ylim[1]) - 5, self.col_w * num_col_yellow - 2, colored_box_h) qpen = QPen(QColor('#EFDB00')) qpen.setWidth(1) qpen.setStyle( 5) # dash line : http://doc.qt.io/qt-4.8/qt.html#PenStyle-enum rect_yellow.setPen(qpen) rect_yellow.setBrush(QColor("#FBFFA5")) rect_yellow.setZValue(-1) rect_yellow.setParentItem(self.item) #rect_yellow.setOpacity(0.5) if num_col_gray: rect_gray = QGraphicsRectItem( self.col_w * (num_col_orange + num_col_red + num_col_yellow) + 1, self.coordY(self.ylim[1]) - 5, self.col_w * num_col_gray, colored_box_h) qpen = QPen(QColor('gray')) qpen.setWidth(1) qpen.setStyle( 5) # dash line : http://doc.qt.io/qt-4.8/qt.html#PenStyle-enum rect_gray.setPen(qpen) rect_gray.setBrush(QColor("#E2E2E2")) rect_gray.setZValue(-1) rect_gray.setParentItem(self.item)
def setAxisIntersect(self, intersect): self._axisIntersect = intersect #print "SkeletonsLayer(axis=%d) is updating intersect=%d" % (self._axis, self._axisIntersect) nodes, eIntersected, ePlane = self._3d._skeletons.intersect( self._axis, self._axisIntersect) #update existing items toRemove = [] for node, item in self._node2view.iteritems(): if node.pos[self._axis] != self._axisIntersect: self._scene.removeItem(item) toRemove.append(node) elif node.pointF(self._axis) != item.pos(): item.setPos(self._scene.data2scene.map(node.pointF( self._axis))) if node.isSelected() != item.isSelected(): item.setSelected(node.isSelected()) assert item.isSelected() == node.isSelected() i = 0 newSize = [0, 0] for j in range(3): if j == self._axis: continue newSize[i] = node.shape[j] i += 1 newRectF = QRectF(0, 0, *newSize) newRectF = self._scene.data2scene.mapRect(newRectF) item.setRect( QRectF(-newRectF.width() / 2.0, -newRectF.height() / 2.0, newRectF.width(), newRectF.height())) for r in toRemove: del self._node2view[r] #add new views for nodes for n in nodes: if n in self._node2view: continue pos2D = list(n.pos) del pos2D[self._axis] shape2D = n.shape2D(self._axis) itm = QGraphicsSkeletonNode(shape2D, skeletons=self._3d._skeletons, node=n) itm.setPos(self._scene.data2scene.map(QPointF(*pos2D))) itm.setSelected(n.isSelected()) self._scene.addItem(itm) self._node2view[n] = itm for itm in self._edge2view.values(): self._scene.removeItem(itm) self._edge2view = dict() for e in ePlane: l = QLineF(e[0].pointF(), e[1].pointF()) c1 = e[0].color() c2 = e[1].color() mixColor = QColor((c1.red() + c2.red()) / 2, (c1.green() + c2.green()) / 2, (c1.blue() + c2.blue()) / 2) line = QGraphicsLineItem(self._scene.data2scene.map(l)) line.setPen(QPen(mixColor)) self._scene.addItem(line) self._edge2view[e] = line for theEdge, e in eIntersected: c1 = theEdge[0].color() c2 = theEdge[1].color() mixColor = QColor((c1.red() + c2.red()) / 2, (c1.green() + c2.green()) / 2, (c1.blue() + c2.blue()) / 2) nodeSize = 6 p = QGraphicsRectItem(-nodeSize / 2, -nodeSize / 2, nodeSize, nodeSize) pos2D = list(e) del pos2D[self._axis] p.setPos(self._scene.data2scene.map(QPointF(*pos2D))) p.setPen(QPen(mixColor)) self._scene.addItem(p) self._edge2view[e] = p
def draw_fun(self, x, y, val, col_width=10, col_height=10, color="gray"): color = get_corr_color(val) rect = QGraphicsRectItem(x, y, col_width, col_height, parent=self.item) rect.setPen(QPen(QColor('black'))) rect.setBrush(QColor(color))