def __init__(self, i, mu1, mu2, sigma1, sigma2, phi, color): OWPlotItem.__init__(self) self.outer_box = QGraphicsPolygonItem(self) self.inner_box = QGraphicsPolygonItem(self) self.i = i self.mu1 = mu1 self.mu2 = mu2 self.sigma1 = sigma1 self.sigma2 = sigma2 self.phi = phi self.twosigmapolygon = QPolygonF([ QPointF(i, mu1 - sigma1), QPointF(i, mu1 + sigma1), QPointF(i + 1, mu2 + sigma2), QPointF(i + 1, mu2 - sigma2), QPointF(i, mu1 - sigma1) ]) self.sigmapolygon = QPolygonF([ QPointF(i, mu1 - .5 * sigma1), QPointF(i, mu1 + .5 * sigma1), QPointF(i + 1, mu2 + .5 * sigma2), QPointF(i + 1, mu2 - .5 * sigma2), QPointF(i, mu1 - .5 * sigma1) ]) if isinstance(color, tuple): color = QColor(*color) color.setAlphaF(.3) self.outer_box.setBrush(color) self.outer_box.setPen(QColor(0, 0, 0, 0)) self.inner_box.setBrush(color) self.inner_box.setPen(color)
def set_poly_from_pos(self, positions, isactive=True, m=2, n=1): if isactive: # positions = ExternalDivision(positions).get_3rd_points_by(1).round().astype(int) positions = ExternalDivision(positions).get_3rd_points_by_ratio( m=m, n=n).round().astype(int) polygon = QPolygonF(map(QPointF, *positions.T)) else: polygon = QPolygonF() self.setPolygon(polygon)
def drawPatchQt(self, pos, turn, invert, patch_type, image, size, foreColor, backColor, penwidth): # pylint: disable=unused-argument """ :param size: patch size """ path = self.PATH_SET[patch_type] if not path: # blank patch invert = not invert path = [(0., 0.), (1., 0.), (1., 1.), (0., 1.), (0., 0.)] polygon = QPolygonF([QPointF(x * size, y * size) for x, y in path]) rot = turn % 4 rect = [ QPointF(0., 0.), QPointF(size, 0.), QPointF(size, size), QPointF(0., size) ] rotation = [0, 90, 180, 270] nopen = QtGui.QPen(foreColor, Qt.NoPen) foreBrush = QtGui.QBrush(foreColor, Qt.SolidPattern) if penwidth > 0: pen_color = QtGui.QColor(255, 255, 255) pen = QtGui.QPen(pen_color, Qt.SolidPattern) pen.setWidth(penwidth) painter = QPainter() painter.begin(image) painter.setPen(nopen) painter.translate(pos[0] * size + penwidth / 2, pos[1] * size + penwidth / 2) painter.translate(rect[rot]) painter.rotate(rotation[rot]) if invert: # subtract the actual polygon from a rectangle to invert it poly_rect = QPolygonF(rect) polygon = poly_rect.subtracted(polygon) painter.setBrush(foreBrush) if penwidth > 0: # draw the borders painter.setPen(pen) painter.drawPolygon(polygon, Qt.WindingFill) # draw the fill painter.setPen(nopen) painter.drawPolygon(polygon, Qt.WindingFill) painter.end() return image
def __init__(self, parent, fromView, toView, distributedObjects): """ Constructor @param parent parent for the QGraphicsPolygonItem-Constructor @param fromView datagraph.htmlvariableview.HtmlVariableView, starting point of the Pointer @param toView datagraph.htmlvariableview.HtmlVariableView, end point of the Pointer @param distributedObjects distributedobjects.DistributedObjects, the DistributedObjects-Instance fromView and toView are QGraphicsWebViews """ QGraphicsLineItem.__init__(self, parent) self.fromView = fromView fromView.addOutgoingPointer(self) self.toView = toView toView.addIncomingPointer(self) self.setPen(QPen(self.fgcolor, 1)) self.distributedObjects = distributedObjects self.fromView.geometryChanged.connect(self.updatePosition) self.toView.geometryChanged.connect(self.updatePosition) self.fromView.xChanged.connect(self.updatePosition) self.fromView.yChanged.connect(self.updatePosition) self.toView.xChanged.connect(self.updatePosition) self.toView.yChanged.connect(self.updatePosition) self.fromView.removing.connect(self.delete) self.toView.removing.connect(self.delete) self.arrowhead = QPolygonF() self.arrowSize = 20 self.setZValue( -1) # paint the arrows behind (lower z-value) everything else
def read_patternRepeats_API_3(stream, numRepeats): """ Read all patternRepeats from our output stream """ patternRepeats = [] for count in range(numRepeats): polygon = QPolygonF() stream >> polygon position = QPointF() stream >> position legendID = stream.readUInt16() width = stream.readInt16() color = QColor() stream >> color newItem = { "polygon": polygon, "position": position, "width": width, "color": color, "legendID": legendID } patternRepeats.append(newItem) return patternRepeats
def create_polygon_pie(self, outer_radius, inner_raduis, start, lenght): polygon_pie = QPolygonF() n = 360 # angle steps size for full circle # changing n value will causes drawing issues w = 360 / n # angle per step # create outer circle line from "start"-angle to "start + lenght"-angle x = 0 y = 0 for i in range(lenght+1): # add the points of polygon t = w * i + start - self.angle_offset x = outer_radius * math.cos(math.radians(t)) y = outer_radius * math.sin(math.radians(t)) polygon_pie.append(QPointF(x, y)) # create inner circle line from "start + lenght"-angle to "start"-angle for i in range(lenght+1): # add the points of polygon # print("2 " + str(i)) t = w * (lenght - i) + start - self.angle_offset x = inner_raduis * math.cos(math.radians(t)) y = inner_raduis * math.sin(math.radians(t)) polygon_pie.append(QPointF(x, y)) # close outer line polygon_pie.append(QPointF(x, y)) return polygon_pie
def __init__(self, *args): self.seleccionado = False self.velocity = random.randint(1, 10) QGraphicsPixmapItem.__init__(self, *args) self.setPixmap( QPixmap("sprites/" + str(random.randint(1, 45)) + ".png")) self.setTransformOriginPoint(self.boundingRect().width() / 2.0, self.boundingRect().height() / 2.0) self.setZValue(10) ##menu contextual self.menu = QMenu() self.Actions = [] #arreglo de acciones self.Actions.append(self.menu.addAction("Seguir")) self.Actions.append(self.menu.addAction("Editar")) self.Actions.append(self.menu.addAction("girar clockwise")) self.Actions.append(self.menu.addAction("girar anti-clockwise")) self.Actions.append(self.menu.addAction("Colisiones")) self.Actions.append(self.menu.addAction("Duplicar")) self.Actions.append(self.menu.addAction("Eliminar")) self.menu.triggered[QAction].connect(self.test) ##offset para el arrastre self.offset = QPointF(0, 0) ##poligono de vision poligono = QPolygonF() poligono.append(QPointF(-1, 10)) poligono.append(QPointF(-1, 20)) poligono.append(QPointF(-30, 40)) poligono.append(QPointF(-40, 15)) poligono.append(QPointF(-30, -10)) self.vision = QGraphicsPolygonItem(poligono, self, self.scene()) self.vision.setBrush(QColor(255, 255, 0, 100)) self.vision.setPen(QColor(255, 255, 0))
def points(self, phase ): pnts = QPolygonF() numSamples = 15; for i in range(numSamples): v = 6.28 * i / ( numSamples - 1 ) pnts += QPointF( math.sin( v - phase ), v ) return pnts
def _add_selection(self, item): """Add selection rooted at item """ outline = self._selection_poly(item) selection_item = QGraphicsPolygonItem(self) # selection_item = QGraphicsPathItem(self) selection_item.setPos(self.contentsRect().topLeft()) # selection_item.setPen(QPen(Qt.NoPen)) selection_item.setPen(make_pen(width=1, cosmetic=True)) transform = self._itemgroup.transform() path = transform.map(outline) margin = 4 if item.node.is_leaf: path = QPolygonF(path.boundingRect().adjusted( -margin, -margin, margin, margin)) else: pass # ppath = QPainterPath() # ppath.addPolygon(path) # path = path_outline(ppath, width=margin).toFillPolygon() selection_item.setPolygon(path) # selection_item.setPath(path_outline(path, width=4)) selection_item.unscaled_path = outline self._selection[item] = selection_item item.setSelected(True)
def __init__(self, width, height, label, color='#0000FF'): self.pol = QPolygonF() self.pol = QPolygonF() self.pol.append(QPointF(width / 2.0, 0)) self.pol.append(QPointF(width, height / 2.0)) self.pol.append(QPointF(width / 2.0, height)) self.pol.append(QPointF(0, height / 2.0)) self.pol.append(QPointF(width / 2.0, 0)) self.label = label QGraphicsPolygonItem.__init__(self, self.pol) self.setBrush(QBrush(QColor(color))) self.setPen(QPen(QColor(color)))
def points( self, phase ): points = QPolygonF() numSamples = 9 for i in range(numSamples): v = i * 2.0 * 3.14159 / ( numSamples - 1 ) points += QPointF( math.sin( v - phase ), math.cos( 3.0 * ( v + phase ) ) ) return points;
def points(self, phase ): points = QPolygonF() numSamples = 50 for i in range(numSamples): v = 10.0 * i / ( numSamples - 1 ) points += QPointF( v, math.cos( 3.0 * ( v + phase ) ) ) return points
def setSamples(self, numPoints): samples = QPolygonF() for i in range(numPoints): x = randomValue() * 24.0 + 1.0 y = math.log(10.0 * (x - 1.0) + 1.0) * (randomValue() * 0.5 + 0.9) samples += QPointF(x, y) self.d_plot.setSamples(samples)
def polygon_from_data(xData, yData): """ Creates a polygon from a list of x and y coordinates. :returns: A polygon with point corresponding to ``xData`` and ``yData``. :rtype: QPolygonF """ if xData and yData: n = min(len(xData), len(yData)) p = QPolygonF(n + 1) for i in range(n): p[i] = QPointF(xData[i], yData[i]) p[n] = QPointF(xData[0], yData[0]) return p else: return QPolygonF()
def _paintPolygon(self, painter, polygon): path = QPainterPath() for line in polygon: ring = QPolygonF() for point in line: cur = self.toCanvasCoordinates(point) - self.pos() ring.append(cur) ring.append(ring[0]) path.addPolygon(ring) painter.drawPath(path)
def paintEvent(self, event=None): font = QFont(self.font()) font.setPointSize(font.pointSize() - 1) fm = QFontMetricsF(font) fracWidth = fm.width(FractionSlider.WSTRING) indent = fm.boundingRect("9").width() / 2.0 if not X11: fracWidth *= 1.5 span = self.width() - (FractionSlider.XMARGIN * 2) value = self.__numerator / float(self.__denominator) painter = QPainter(self) painter.setRenderHint(QPainter.Antialiasing) painter.setRenderHint(QPainter.TextAntialiasing) painter.setPen(self.palette().color(QPalette.Mid)) painter.setBrush(self.palette().brush( QPalette.AlternateBase)) painter.drawRect(self.rect()) segColor = QColor(Qt.green).dark(120) segLineColor = segColor.dark() painter.setPen(segLineColor) painter.setBrush(segColor) painter.drawRect(FractionSlider.XMARGIN, FractionSlider.YMARGIN, span, fm.height()) textColor = self.palette().color(QPalette.Text) segWidth = span / self.__denominator segHeight = fm.height() * 2 nRect = fm.boundingRect(FractionSlider.WSTRING) x = FractionSlider.XMARGIN yOffset = segHeight + fm.height() for i in range(self.__denominator + 1): painter.setPen(segLineColor) painter.drawLine(x, FractionSlider.YMARGIN, x, segHeight) painter.setPen(textColor) y = segHeight rect = QRectF(nRect) rect.moveCenter(QPointF(x, y + fm.height() / 2.0)) painter.drawText(rect, Qt.AlignCenter, QString.number(i)) y = yOffset rect.moveCenter(QPointF(x, y + fm.height() / 2.0)) painter.drawText(rect, Qt.AlignCenter, QString.number(self.__denominator)) painter.drawLine(QPointF(rect.left() + indent, y), QPointF(rect.right() - indent, y)) x += segWidth span = int(span) y = FractionSlider.YMARGIN - 0.5 triangle = [QPointF(value * span, y), QPointF((value * span) + (2 * FractionSlider.XMARGIN), y), QPointF((value * span) + FractionSlider.XMARGIN, fm.height())] painter.setPen(Qt.yellow) painter.setBrush(Qt.darkYellow) painter.drawPolygon(QPolygonF(triangle))
def drawSkel(self, worm_img, worm_qimg, row_data, roi_corner=(0, 0)): if not self.skel_file or not isinstance(self.trajectories_data, pd.DataFrame): return c_ratio_y = worm_qimg.width() / worm_img.shape[1] c_ratio_x = worm_qimg.height() / worm_img.shape[0] skel_id = int(row_data['skeleton_id']) qPlg = {} with tables.File(self.skel_file, 'r') as ske_file_id: for tt in ['skeleton', 'contour_side1', 'contour_side2']: dat = ske_file_id.get_node('/' + tt)[skel_id] dat[:, 0] = (dat[:, 0] - roi_corner[0]) * c_ratio_x dat[:, 1] = (dat[:, 1] - roi_corner[1]) * c_ratio_y qPlg[tt] = QPolygonF() for p in dat: qPlg[tt].append(QPointF(*p)) if 'is_good_skel' in row_data and row_data['is_good_skel'] == 0: self.skel_colors = { 'skeleton': (102, 0, 0), 'contour_side1': (102, 0, 0), 'contour_side2': (102, 0, 0) } else: self.skel_colors = { 'skeleton': (27, 158, 119), 'contour_side1': (217, 95, 2), 'contour_side2': (231, 41, 138) } pen = QPen() pen.setWidth(2) painter = QPainter() painter.begin(worm_qimg) for tt, color in self.skel_colors.items(): pen.setColor(QColor(*color)) painter.setPen(pen) painter.drawPolyline(qPlg[tt]) pen.setColor(Qt.black) painter.setBrush(Qt.white) painter.setPen(pen) radius = 3 painter.drawEllipse(qPlg['skeleton'][0], radius, radius) painter.end()
def __init__(self): Curve.__init__(self) self.d_points = QPolygonF() self.setStyle( Qwt.QwtPlotCurve.Lines ) self.setPen( Qt.red, 2 ) self.initSamples() # somewhere in the center transform = QTransform() transform.translate( 7.0, 3.0 ) transform.scale( 1.5, 1.5 ) self.setTransformation( transform )
def _selection_poly(self, item): """Return an selection item covering the selection rooted at item. """ def branches(item): return [self._items[ch] for ch in item.node.branches] def left(item): return [self._items[ch] for ch in item.node.branches[:1]] def right(item): return [self._items[ch] for ch in item.node.branches[-1:]] allitems = list(preorder(item, left)) + list(preorder(item, right))[1:] if len(allitems) == 1: assert (allitems[0].node.is_leaf) else: allitems = [item for item in allitems if not item.node.is_leaf] brects = [QPolygonF(item.boundingRect()) for item in allitems] return reduce(QPolygonF.united, brects, QPolygonF())
def calculate_polygon_points(self): # QPolygonF nesnesi oluşturup tüm köşe noktalarının # x ve y değerlerini hesaplıyoruz. Sonrasında x,y # değerleriyle QPointF nesnesi oluşturup QPolygon'a # bu noktaları ekliyoruz. p = QPolygonF() angle = self.calculate_angle() for i in range(self.edge_count): x = cos(angle * i) * self.radius y = sin(angle * i) * self.radius p.append(QPointF(x, y)) return p
def drawToolButtonMenuIndicator(self, option, painter, widget=None): arrow_rect = self.proxy().subControlRect(QStyle.CC_ToolButton, option, QStyle.SC_ToolButtonMenu, widget) text_color = option.palette.color(QPalette.WindowText if option.state & QStyle.State_AutoRaise else QPalette.ButtonText) button_color = option.palette.color(QPalette.Button) background_color = self.background_color(button_color, 0.5) painter.save() # draw separating vertical line if option.state & (QStyle.State_On|QStyle.State_Sunken): top_offset, bottom_offset = 4, 3 else: top_offset, bottom_offset = 2, 2 if option.direction == Qt.LeftToRight: separator_line = QLineF(arrow_rect.x()-3, arrow_rect.top()+top_offset, arrow_rect.x()-3, arrow_rect.bottom()-bottom_offset) else: separator_line = QLineF(arrow_rect.right()+3, arrow_rect.top()+top_offset, arrow_rect.right()+3, arrow_rect.bottom()-bottom_offset) light_gradient = QLinearGradient(separator_line.p1(), separator_line.p2()) light_gradient.setColorAt(0.0, ColorScheme.shade(self.background_top_color(button_color), ColorScheme.LightShade, 0.0)) light_gradient.setColorAt(1.0, ColorScheme.shade(self.background_bottom_color(button_color), ColorScheme.MidlightShade, 0.5)) separator_color = ColorScheme.shade(self.background_bottom_color(button_color), ColorScheme.MidShade, 0.0) painter.setRenderHint(QPainter.Antialiasing, False) painter.setPen(QPen(light_gradient, 1)) painter.drawLine(separator_line.translated(-1, 0)) painter.drawLine(separator_line.translated(+1, 0)) painter.setPen(QPen(separator_color, 1)) painter.drawLine(separator_line) # draw arrow arrow = QPolygonF([QPointF(-3, -1.5), QPointF(0.5, 2.5), QPointF(4, -1.5)]) if option.direction == Qt.LeftToRight: arrow.translate(-2, 1) else: arrow.translate(+2, 1) pen_thickness = 1.6 painter.setRenderHint(QPainter.Antialiasing, True) painter.translate(arrow_rect.center()) painter.translate(0, +1) painter.setPen(QPen(self.calc_light_color(background_color), pen_thickness, Qt.SolidLine, Qt.RoundCap, Qt.RoundJoin)) painter.drawPolyline(arrow) painter.translate(0, -1) painter.setPen(QPen(self.deco_color(background_color, text_color), pen_thickness, Qt.SolidLine, Qt.RoundCap, Qt.RoundJoin)) painter.drawPolyline(arrow) painter.restore()
def paint(self, painter, option, widget=None): painter.setPen(self.pen()) painter.setBrush( EDraw.EColor.LinearGradient(self.boundingRect(), Qt.darkGray)) painter.drawPolygon(QPolygonF(self.boundingRect())) painter.setPen(Qt.lightGray) r = QRectF(0.0, -(self.__sExtra / 2), self.__name.boundingRect().width(), self.boundingRect().height()) painter.drawText(r, Qt.AlignRight | Qt.AlignCenter, "%s: " % self.__name.toPlainText())
def __init__(self, startItem, startIndex, endItem, endIndex, parent=None, scene=None): super(ModelerArrowItem, self).__init__(parent, scene) self.arrowHead = QPolygonF() self.endIndex = endIndex self.startIndex = startIndex self.startItem = startItem self.endItem = endItem self.endPoints = [] self.setFlag(QGraphicsItem.ItemIsSelectable, False) self.myColor = Qt.gray self.setPen(QPen(self.myColor, 1, Qt.SolidLine, Qt.RoundCap, Qt.RoundJoin)) self.setZValue(0)
def create_polygon_pie(self, outer_radius, inner_raduis, start, lenght): """ Args: outer_radius: inner_raduis: start: lenght: """ polygon_pie = QPolygonF() # start = self.scale_angle_start_value # start = 0 # lenght = self.scale_angle_size # lenght = 180 # inner_raduis = self.width()/4 # print(start) n = 360 # angle steps size for full circle # changing n value will causes drawing issues w = 360 / n # angle per step # create outer circle line from "start"-angle to "start + lenght"-angle x = 0 y = 0 # todo enable/disable bar graf here if not self.enable_barGraph: # float_value = ((lenght / (self.value_max - self.value_min)) * (self.value - self.value_min)) lenght = int( round((lenght / (self.value_max - self.value_min)) * (self.value - self.value_min))) # print("f: %s, l: %s" %(float_value, lenght)) pass # mymax = 0 for i in range(lenght + 1): # add the points of polygon t = w * i + start - self.angle_offset x = outer_radius * math.cos(math.radians(t)) y = outer_radius * math.sin(math.radians(t)) polygon_pie.append(QPointF(x, y)) # create inner circle line from "start + lenght"-angle to "start"-angle for i in range(lenght + 1): # add the points of polygon # print("2 " + str(i)) t = w * (lenght - i) + start - self.angle_offset x = inner_raduis * math.cos(math.radians(t)) y = inner_raduis * math.sin(math.radians(t)) polygon_pie.append(QPointF(x, y)) # close outer line polygon_pie.append(QPointF(x, y)) return polygon_pie
def __init__(self, poly = None, dim = None): if not poly: if not dim: raise ValueError("need to set bounding rect!") else: poly = [] for i in range(10): poly.append(planar.Point( random.randint(dim.left(),dim.right()), random.randint(dim.top(),dim.bottom()))) poly = planar.Polygon.convex_hull(poly) poly = QPolygonF([QPointF(p.x,p.y) for p in poly]) QGraphicsPolygonItem.__init__(self, poly) self.setConnectors([(0,random.random()),(len(poly)//2,random.random())])
def __init__(self, canvas, params={}): ''' Constructor :param iface: An interface instance that will be passed to this class which provides the hook by which you can manipulate the QGIS application at run time. :type iface: QgsInterface :param params: A dictionary defining all the properties of the position marker :type params: dictionary ''' self.canvas = canvas self.type = params.get('type', 'BOX').upper() self.size = int(params.get('size', 16)) self.showLabel = bool(params.get('showLabel', True)) s = (self.size - 1) / 2 self.length = float(params.get('length', 98.0)) self.width = float(params.get('width', 17.0)) self.offsetX = float(params.get('offsetX', 0.0)) self.offsetY = float(params.get('offsetY', 0.0)) self.shape = params.get('shape', ((0.0, -0.5), (0.5, -0.3), (0.5, 0.5), (-0.5, 0.50), (-0.5, -0.3))) self.paintShape = QPolygonF( [QPointF(-s, -s), QPointF(s, -s), QPointF(s, s), QPointF(-s, s)]) self.color = self.getColor(params.get('color', 'black')) self.fillColor = self.getColor(params.get('fillColor', 'lime')) self.penWidth = int(params.get('penWidth', 1)) spw = s + self.penWidth + 1 self.bounding = QRectF(-spw, -spw, spw * 2, spw * 2) if self.type in ('CROSS', 'X'): self.penWidth = 5 self.trackLen = int(params.get('trackLength', 100)) self.trackColor = self.getColor( params.get('trackColor', self.fillColor)) self.track = deque() self.position = None self.heading = 0 super(PositionMarker, self).__init__(canvas) self.setZValue(int(params.get('zValue', 100))) self.distArea = QgsDistanceArea() self.distArea.setEllipsoid(u'WGS84') self.distArea.setEllipsoidalMode(True) if self.showLabel: self.label = MarkerLabel(self.canvas, params) self.label.setZValue(self.zValue() + 0.1) self.updateSize()
def drawArrow(self, painter, p, v, head_size): base = p - v tip = p + v painter.drawLine(base, tip) vl = length(v) nv = v / vl head_size = head_size * vl orth = QPointF(nv.y(), -nv.x()) * head_size base_center = tip - nv * head_size * 2.0 base1 = base_center + orth base2 = base_center - orth base_center = tip - nv * head_size * 1.0 painter.drawPolygon(QPolygonF([base_center, base1, tip, base2]))
def updateShape(self, point=None, pos=None): # Main arrow direction params = parameters.instance scale = self.scale ms = min(scale) head_size = params.arrow_head_size * ms width = params.arrow_line_size * ms self.prepareGeometryChange() if point == self.source: p1 = pos else: p1 = self.source.pos() self.setPos(p1) if point == self.target: p2 = pos else: p2 = self.target.pos() tip = p2 - p1 if abs(tip.x()) > 0.001 or abs(tip.y()) > 0.001: # Normalised #ntip = tip/stip ntip = tip # Arrow head base orth = QPointF(ntip.y(), -ntip.x()) * (head_size * 0.5) base_center = tip * (1 - 2 * head_size) base1 = base_center + orth base2 = base_center - orth base_center = tip * (1 - head_size * 1.50) else: ntip = tip base_center = tip base1 = tip base2 = tip self.tip = tip self.base_center = base_center self.base1 = base1 self.base2 = base2 path = QPainterPath() path.lineTo(base_center) path.addPolygon(QPolygonF([base_center, base1, tip, base2])) path.closeSubpath() self.rect = path.controlPointRect().adjusted(-width, -width, 2 * width, 2 * width) self.path = path self.update()
def on_actionGotoCell_triggered(self): cells = [str(cid) for cid in self._data.cells] selected, ok = QInputDialog.getItem(self, "Goto cell", "Select the cell to go to", cells, 0) if ok: cid = int(selected) self.ui.actionAdd_cell.setChecked(True) data = self._data if cid not in data.cells: return ls = data.cells_lifespan[cid] prev_pos = self._previousScene.current_data._current_index cur_pos = self._currentScene.current_data._current_index full_poly = data.cells[cid] poly = [pid for pid in full_poly if pid in data[prev_pos]] #log_debug("Cell %d on time %d: %s" % (cid, prev_pos, poly)) if prev_pos < ls.start or prev_pos >= ls.end or not poly: for i in range(*ls.slice().indices(len(data))): poly = [pid for pid in full_poly if pid in data[i]] if poly: log_debug("Found cell %d on image %d with polygon %s" % (cid, i, poly)) new_prev_pos = i break else: log_debug("Cell %d found nowhere in range %s!!!" % (cid, ls.slice())) else: new_prev_pos = prev_pos new_cur_pos = min(max(cur_pos + new_prev_pos - prev_pos, 0), len(data)) self.ui.previousState.setCurrentIndex(new_prev_pos) self.ui.currentState.setCurrentIndex(new_cur_pos) self._previousScene.current_cell = cid self._currentScene.current_cell = cid prev_data = self._previousScene.current_data poly = data.cells[cid] prev_poly = QPolygonF( [prev_data[ptid] for ptid in poly if ptid in prev_data]) prev_bbox = prev_poly.boundingRect() log_debug("Previous bounding box = %dx%d+%d+%d" % (prev_bbox.width(), prev_bbox.height(), prev_bbox.left(), prev_bbox.top())) self.ui.previousData.ensureVisible(prev_bbox)
def polygon(self): font = QFont('Verdana', 8) fm = QFontMetricsF(font) hUp = fm.height() * 1.2 * (len(self.element.parameters) + 2) hDown = fm.height() * 1.2 * (len(self.element.outputs) + 2) pol = QPolygonF([ QPointF(-(ModelerGraphicItem.BOX_WIDTH + 2) / 2, -(ModelerGraphicItem.BOX_HEIGHT + 2) / 2 - hUp), QPointF(-(ModelerGraphicItem.BOX_WIDTH + 2) / 2, (ModelerGraphicItem.BOX_HEIGHT + 2) / 2 + hDown), QPointF((ModelerGraphicItem.BOX_WIDTH + 2) / 2, (ModelerGraphicItem.BOX_HEIGHT + 2) / 2 + hDown), QPointF((ModelerGraphicItem.BOX_WIDTH + 2) / 2, -(ModelerGraphicItem.BOX_HEIGHT + 2) / 2 - hUp), QPointF(-(ModelerGraphicItem.BOX_WIDTH + 2) / 2, -(ModelerGraphicItem.BOX_HEIGHT + 2) / 2 - hUp) ]) return pol