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 __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 _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 _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 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 __init__(self, parent): points = QPolygonF() self._mediator = ArrowMediator() for poly in (QPointF(7,0), QPointF(-7,7), QPointF(-5,2), QPointF(-11,2), QPointF(-11,-2), QPointF(-5,-2), QPointF(-7,-7)): points.append(poly) QGraphicsPolygonItem.__init__(self, points, parent) self.setPen(Qt.darkCyan) self.setBrush(Qt.cyan)
def _draw_polygon(self, painter, xMap, yMap, range_tuple): # range_tuple might contain more then four values ! rtmin, rtmax, mzmin, mzmax = range_tuple[:4] points = QPolygonF() points.append(QPointF(xMap.transform(rtmin), yMap.transform(mzmin))) points.append(QPointF(xMap.transform(rtmin), yMap.transform(mzmax))) points.append(QPointF(xMap.transform(rtmax), yMap.transform(mzmax))) points.append(QPointF(xMap.transform(rtmax), yMap.transform(mzmin))) painter.drawPolygon(points) return points
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 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 __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 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, 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 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 __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 __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.setBrush( QBrush( self.bgcolor ) ) self.setPen(QPen(self.fgcolor, 1)) self.distributedObjects = distributedObjects QObject.connect(self.fromView, SIGNAL('geometryChanged()'), self.updatePosition) QObject.connect(self.toView, SIGNAL('geometryChanged()'), self.updatePosition) QObject.connect(self.fromView, SIGNAL('xChanged()'), self.updatePosition) QObject.connect(self.fromView, SIGNAL('yChanged()'), self.updatePosition) QObject.connect(self.toView, SIGNAL('xChanged()'), self.updatePosition) QObject.connect(self.toView, SIGNAL('yChanged()'), self.updatePosition) QObject.connect(self.fromView, SIGNAL('removing()'), self.delete) QObject.connect(self.toView, SIGNAL('removing()'), self.delete) self.arrowhead = QPolygonF() self.arrowSize = 20 self.setZValue(-1) # paint the arrows behind (lower z-value) everything else
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 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 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 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 __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.bounding = 1.414213562 * self.size self.length = float(params.get('length', 98.0)) self.width = float(params.get('width', 17.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))) s = (self.size - 1) / 2 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)) 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.pos = 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) self.updateSize()
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 __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 __updateShape(self): fBBox = QFontMetrics(self.Font).boundingRect(self.Name) if self.__polygon.boundingRect().width() < fBBox.width(): self.__polygon = QPolygonF(QRectF(fBBox).normalized().adjusted(-fBBox.width() / 4, -fBBox.height() / 4, fBBox.height(), fBBox.height() / 2))
def sample_interpolate(self, x, y): spline = QwtSpline() points = QPolygonF() for point in zip(x, y): points.append(QPointF(*point)) spline.setSplineType(QwtSpline.Natural) spline.setPoints(points) px = range(0, 2**12, DistanceIR.DIVIDER) py = [] for X in px: py.append(spline.value(X)) for i in range(x[0]/DistanceIR.DIVIDER): py[i] = y[0] for i in range(x[-1]/DistanceIR.DIVIDER, 2**12/DistanceIR.DIVIDER): py[i] = y[-1] for i in range(len(py)): if py[i] > y[0]: py[i] = y[0] if py[i] < y[-1]: py[i] = y[-1] try: old_text = self.sample_edit.text() for i in range(DistanceIR.NUM_VALUES): value = int(round(py[i]*100)) self.dist.set_sampling_point(i, value) set_value = self.dist.get_sampling_point(i) if set_value != value: self.sample_edit.setText("Error while writing sample point " + str(i)) self.sample_edit.setText("writing sample point, value: " + str((i, value))) QApplication.processEvents() self.sample_edit.setText(old_text) except ip_connection.Error: return
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 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 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 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 __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 item(self): if self.item_ is None: num_pts = len(self.pts_) if num_pts == 1: # draw a point item = QGraphicsEllipseItem(self.pts_[0][0]-self.radius_, self.pts_[0][1]-self.radius_, 2*self.radius_, 2*self.radius_) item.setBrush(self.qcolor) elif num_pts == 2: item = QGraphicsLineItem(self.pts_[0][0], self.pts_[0][1], self.pts_[1][0], self.pts_[1][1]) else: poly = QPolygonF() for p in self.pts_: poly.append(QPointF(p[0],p[1])) item = QGraphicsPolygonItem(poly) item.setFlags(QGraphicsItem.ItemIsSelectable | QGraphicsItem.ItemIsFocusable) item.setPen(self.qcolor) item.setEnabled(True) item.setActive(True) self.item_ = item return self.item_
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 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 __init__(self, ENodeHandle): ENode.__init__(self, ENodeHandle) self.__polygon = QPolygonF(QRectF(-50, -15, 100, 30)) self.__updateShape() self.__attributes = {} self.__hiddenAttributes = {} self.__group = QGraphicsItemGroup() self.__group.addToGroup(QGraphicsPolygonItem(self.__polygon)) self.__buildAttributes(self.Handle.lsInputAttributes()) self.__buildAttributes(self.Handle.lsOutputAttributes(), True) self.__muted = None
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
def arrow_path_concave(line, width): """ Return a :class:`QPainterPath` of a pretty looking arrow. """ path = QPainterPath() p1, p2 = line.p1(), line.p2() if p1 == p2: return path baseline = QLineF(line) # Require some minimum length. baseline.setLength(max(line.length() - width * 3, width * 3)) start, end = baseline.p1(), baseline.p2() mid = (start + end) / 2.0 normal = QLineF.fromPolar(1.0, baseline.angle() + 90).p2() path.moveTo(start) path.lineTo(start + (normal * width / 4.0)) path.quadTo(mid + (normal * width / 4.0), end + (normal * width / 1.5)) path.lineTo(end - (normal * width / 1.5)) path.quadTo(mid - (normal * width / 4.0), start - (normal * width / 4.0)) path.closeSubpath() arrow_head_len = width * 4 arrow_head_angle = 50 line_angle = line.angle() - 180 angle_1 = line_angle - arrow_head_angle / 2.0 angle_2 = line_angle + arrow_head_angle / 2.0 points = [ p2, p2 + QLineF.fromPolar(arrow_head_len, angle_1).p2(), baseline.p2(), p2 + QLineF.fromPolar(arrow_head_len, angle_2).p2(), p2 ] poly = QPolygonF(points) path_head = QPainterPath() path_head.addPolygon(poly) path = path.united(path_head) return path
def setSpinBoxDownIcon(self, opacity=0.6): self.buttonStyle = "spinDown" self.setToolTip("- 1") pixmap = QPixmap(250, 250) pixmap.fill(self.backgroundColor) painter = QPainter() painter.begin(pixmap) painter.setRenderHint(QPainter.Antialiasing) painter.setOpacity(opacity) brush = QBrush(self.foregroundColor) painter.setBrush(brush) pen = QPen(self.foregroundColor) painter.setPen(pen) points = QPolygonF() points.append(QPointF(125.0, 200.0)) points.append(QPointF(200.0, 70.0)) points.append(QPointF(50.0, 70.0)) painter.drawPolygon(points) painter.end() pixmap = pixmap.scaled(QSize(self.pixmapWidth, self.pixmapHeight),Qt.KeepAspectRatio, Qt.SmoothTransformation) self.setPixmap(pixmap)
def test_QPolygon_intersection(self): tri1 = QVectorF([(0,0),(0,1),(1,0)]) tri2 = QVectorF([(1,0),(0,0),(1,1)]) tri3 = QVectorF([(.5,.5),(1,0),(0,0),(.5,.5)]) tri3i = QVector([(1,1),(1,0),(0,0),(1,1)]) sq1 = QVectorF([(0,0),(0,1),(1,1),(1,0)]) # Intersect two triangles p1 = QPolygonF(tri1) p2 = QPolygonF(tri2) p3 = p1.intersected(p2) self.assertTrue( p1 == p1 ) self.assertTrue( p1 == QPolygonF(tri1) ) self.assertTrue( p3 == QPolygonF(tri3) ) # Intersect two integer triangles p1 = QtGui.QPolygon(map(lambda (x,y): QtCore.QPoint(x,y), [(0,0),(0,1),(1,0)])) p2 = QtGui.QPolygon(map(lambda (x,y): QtCore.QPoint(x,y), [(1,0),(0,0),(1,1)])) p3 = p1.intersected(p2) self.assertTrue( p3 == QtGui.QPolygon(tri3i) ) # Test containment/overlapping p1 = QtGui.QPolygonF(sq1) for v1 in sq1: self.assertTrue( p1.contains(v1) ) # vertices are contained self.assertTrue( p1.translated(2,0).intersected(p1).isEmpty() ) self.assertTrue( p1.translated(1,0).intersected(p1).isEmpty() ) # common edges do not overlap self.assertFalse( p1.translated(.5,0).intersected(p1).isEmpty() )
def render(self): """ Main-Method of the Pointer-Class <br> calculates/renders/draws the Lines of the Arrow """ points = QPolygonF() self.toView.x() pM1 = QPointF(self.fromView.x() + self.fromView.size().width()/2, self.fromView.y() + self.fromView.size().height()/2) pM2 = QPointF(self.toView.x() + self.toView.size().width()/2, self.toView.y() + self.toView.size().height()/2) deltaX = pM2.x()-pM1.x() deltaY = pM2.y()-pM1.y() if deltaX == 0: deltaX = 0.01 if deltaY == 0: deltaY = 0.01 if deltaX >= 0: if deltaY >= 0: # rechts unten if deltaX/deltaY >= self.fromView.size().width()/self.fromView.size().height(): # Start von rechter Seite pStart = QPointF(pM1.x() + self.fromView.size().width()/2, pM1.y() + (self.fromView.size().width()/2)*(deltaY/deltaX)) else: # Start von unterer Seite pStart = QPointF(pM1.x() + (self.fromView.size().height()/2)*(deltaX/deltaY), pM1.y() + self.fromView.size().height()/2) if deltaX/deltaY >= self.toView.size().width()/self.toView.size().height(): # Ende bei linker Seite pEnd = QPointF(pM2.x() - self.toView.size().width()/2, pM2.y() - (self.toView.size().width()/2)*(deltaY/deltaX)) else: # Ende bei oberer Seite pEnd = QPointF(pM2.x() - (self.toView.size().height()/2)*(deltaX/deltaY), pM2.y() - self.toView.size().height()/2) else: # rechts oben if deltaX/deltaY*-1 >= self.fromView.size().width()/self.fromView.size().height(): # Start von rechter Seite pStart = QPointF(pM1.x() + self.fromView.size().width()/2, pM1.y() + (self.fromView.size().width()/2)*(deltaY/deltaX)) else: # Start von oberer Seite pStart = QPointF(pM1.x() - (self.fromView.size().height()/2)*(deltaX/deltaY), pM1.y() - self.fromView.size().height()/2) if deltaX/deltaY*-1 >= self.toView.size().width()/self.toView.size().height(): # Ende bei linker Seite pEnd = QPointF(pM2.x() - self.toView.size().width()/2, pM2.y() - (self.toView.size().width()/2)*(deltaY/deltaX)) else: # Ende bei unterer Seite pEnd = QPointF(pM2.x() + (self.toView.size().height()/2)*(deltaX/deltaY), pM2.y() + self.toView.size().height()/2) else: if deltaY >= 0: # links unten if deltaX/deltaY*-1 >= self.fromView.size().width()/self.fromView.size().height(): # Start von linker Seite pStart = QPointF(pM1.x() - self.fromView.size().width()/2, pM1.y() - (self.fromView.size().width()/2)*(deltaY/deltaX)) else: # Start von unterer Seite pStart = QPointF(pM1.x() + (self.fromView.size().height()/2)*(deltaX/deltaY), pM1.y() + self.fromView.size().height()/2) if deltaX/deltaY*-1 >= self.toView.size().width()/self.toView.size().height(): # Ende bei rechten Seite pEnd = QPointF(pM2.x() + self.toView.size().width()/2, pM2.y() + (self.toView.size().width()/2)*(deltaY/deltaX)) else: # Ende bei oberer Seite pEnd = QPointF(pM2.x() - (self.toView.size().height()/2)*(deltaX/deltaY), pM2.y() - self.toView.size().height()/2) else: # links oben if deltaX/deltaY >= self.fromView.size().width()/self.fromView.size().height(): # Start von linker Seite pStart = QPointF(pM1.x() - self.fromView.size().width()/2, pM1.y() - (self.fromView.size().width()/2)*(deltaY/deltaX)) else: # Start von oberer Seite pStart = QPointF(pM1.x() - (self.fromView.size().height()/2)*(deltaX/deltaY), pM1.y() - self.fromView.size().height()/2) if deltaX/deltaY >= self.toView.size().width()/self.toView.size().height(): # Ende bei rechter Seite pEnd = QPointF(pM2.x() + self.toView.size().width()/2, pM2.y() + (self.toView.size().width()/2)*(deltaY/deltaX)) else: # Ende bei unterer Seite pEnd = QPointF(pM2.x() + (self.toView.size().height()/2)*(deltaX/deltaY), pM2.y() + self.toView.size().height()/2) #pStart = QPointF(self.fromView.x() + self.fromView.size().width(), # self.fromView.y() + self.fromView.size().height()/2) #pEnd = QPointF(self.toView.x(), self.toView.y() + self.toView.size().height()/2) p1 = pStart p2 = QPointF(pEnd.x()-(pEnd.x()-pStart.x())/7, pEnd.y()-(pEnd.y()-pStart.y())/7) p3 = QPointF(p2.x()-(p2.y()-p1.y())/20, p2.y()+(p2.x()-p1.x())/20) p4 = pEnd p5 = QPointF(p2.x()+(p2.y()-p1.y())/20, p2.y()-(p2.x()-p1.x())/20) p6 = p2 points.append(p1) points.append(p2) points.append(p3) points.append(p4) points.append(p5) points.append(p6) self.setPolygon(points)
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 calcArrow(srcdes_list,itemignoreZooming,iconScale): ''' if PoolItem then boundingrect should be background rather than graphicsobject ''' src = srcdes_list[0] des = srcdes_list[1] endtype = srcdes_list[2] order = srcdes_list[3] # print("Source => ", src) compartment = src.parentItem() srcobj = src.gobj desobj = des.gobj if isinstance(src,PoolItem): srcobj = src.bg if isinstance(des,PoolItem): desobj = des.bg # if itemignoreZooming: # srcRect = self.recalcSceneBoundingRect(srcobj) # desRect = self.recalcSceneBoundingRect(desobj) # else: srcRect = compartment.mapFromScene(srcobj.sceneBoundingRect()).boundingRect() desRect = compartment.mapFromScene(desobj.sceneBoundingRect()).boundingRect() arrow = QPolygonF() if srcRect.intersects(desRect): ''' This is created for getting a emptyline reference \ because 'lineCord' function keeps a reference between qgraphicsline and its src and des ''' arrow.append(QPointF(0,0)) arrow.append(QPointF(0,0)) return arrow if (order == 0): tmpLine = QLineF(srcRect.center().x(), srcRect.center().y(), desRect.center().x(), desRect.center().y()) elif(order > 0): dx = desRect.center().x()- srcRect.center().x() dy = desRect.center().y()- srcRect.center().y() dx0 = dy dy0 = -dx tetha1 = (math.atan2(dy0,dx0)) a0 = 4 *(math.cos(tetha1)) b0 = 4 *(math.sin(tetha1)) ''' Higher order ( > 4) connectivity will not be done''' if ((order == 3) or (order == 4)): a0 = a0*2 b0 = b0*2 if(order %2 == 0): srcCentera0 = srcRect.center().x()-a0 srcCenterb0 = srcRect.center().y()-b0 desCentera0 = desRect.center().x()-a0 desCenterb0 = desRect.center().y()-b0 else: srcCentera0 = srcRect.center().x()+a0 srcCenterb0 = srcRect.center().y()+b0 desCentera0 = desRect.center().x()+a0 desCenterb0 = desRect.center().y()+b0 pointa = QPointF(srcCentera0,srcCenterb0) pointb = QPointF(desCentera0,desCenterb0) tmpLine = QLineF(srcCentera0,srcCenterb0,desCentera0,desCenterb0) srcIntersects, lineSrcPoint = calcLineRectIntersection(srcRect, tmpLine) destIntersects, lineDestPoint = calcLineRectIntersection(desRect, tmpLine) if not srcIntersects: print 'Source does not intersect line. Arrow points:',lineSrcPoint,src.mobj.name, src.mobj.className if not destIntersects: print 'Dest does not intersect line. Arrow points:', lineDestPoint, des.mobj.name, des.mobj.className '''src and des are connected with line co-ordinates Arrow head is drawned if the distance between src and des line is >8 just for clean appeareance ''' if (abs(lineSrcPoint.x()-lineDestPoint.x()) > 8 or abs(lineSrcPoint.y()-lineDestPoint.y())>8): srcAngle = tmpLine.angle() if endtype == 'p' or endtype == 'stp': ''' Arrow head for Destination is calculated''' arrow.append(lineSrcPoint) arrow.append(lineDestPoint) degree = -60 srcXArr1,srcYArr1= arrowHead(srcAngle,degree,lineDestPoint,iconScale) arrow.append(QPointF(srcXArr1,srcYArr1)) arrow.append(QPointF(lineDestPoint.x(),lineDestPoint.y())) degree = -120 srcXArr2,srcYArr2 = arrowHead(srcAngle,degree,lineDestPoint,iconScale) arrow.append(QPointF(srcXArr2,srcYArr2)) arrow.append(QPointF(lineDestPoint.x(),lineDestPoint.y())) elif endtype == 'st': ''' Arrow head for Source is calculated''' arrow.append(lineDestPoint) arrow.append(lineSrcPoint) degree = 60 srcXArr2,srcYArr2 = arrowHead(srcAngle,degree,lineSrcPoint,iconScale) arrow.append(QPointF(srcXArr2,srcYArr2)) arrow.append(QPointF(lineSrcPoint.x(),lineSrcPoint.y())) degree = 120 srcXArr1,srcYArr1= arrowHead(srcAngle,degree,lineSrcPoint,iconScale) arrow.append(QPointF(srcXArr1,srcYArr1)) arrow.append(QPointF(lineSrcPoint.x(),lineSrcPoint.y())) elif endtype == 's' or endtype == 'sts': arrow.append(lineDestPoint) arrow.append(lineSrcPoint) degree = 60 srcXArr2,srcYArr2 = arrowHead(srcAngle,degree,lineSrcPoint,iconScale) arrow.append(QPointF(srcXArr2,srcYArr2)) arrow.append(QPointF(lineSrcPoint.x(),lineSrcPoint.y())) degree = 120 srcXArr1,srcYArr1= arrowHead(srcAngle,degree,lineSrcPoint,iconScale) arrow.append(QPointF(srcXArr1,srcYArr1)) arrow.append(QPointF(lineSrcPoint.x(),lineSrcPoint.y())) else: arrow.append(lineSrcPoint) arrow.append(lineDestPoint) return arrow
class PositionMarker(QgsMapCanvasItem): ''' classdocs ''' 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.bounding = 1.414213562 * self.size self.length = float(params.get('length', 98.0)) self.width = float(params.get('width', 17.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))) s = (self.size - 1) / 2 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)) 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.pos = 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) self.updateSize() def properties(self): return {'type': self.type, 'size': self.size, 'length': self.length, 'width': self.width, 'shape': self.shape, 'color': self.color.rgba(), 'fillColor': self.fillColor.rgba(), 'penWidth': self.penWidth, 'trackLength': self.trackLen, 'trackColor' : self.trackColor.rgba(), 'zValue': self.zValue()} def setMapPosition(self, pos): if self.pos != pos: self.updateTrack() self.pos = pos self.setPos(self.toCanvasCoordinates(self.pos)) self.update() def newHeading(self, heading): if self.heading != heading: self.heading = heading self.setRotation(self.canvas.rotation() + self.heading) self.update() def resetPosition(self): self.pos = None def updatePosition(self): if self.pos: self.prepareGeometryChange() self.updateSize() self.setPos(self.toCanvasCoordinates(self.pos)) self.setRotation(self.canvas.rotation() + self.heading) self.update() def updateSize(self): if self.type != 'SHAPE': return s = self.canvas.mapSettings() self.distArea.setSourceCrs(s.destinationCrs()) try: p1 = self.toMapCoordinates(QPoint(0, 0)) p2 = self.toMapCoordinates(QPoint(0, 100)) l = self.distArea.measureLine(p1, p2) f = 100 / l except: f = s.outputDpi() / 0.0254 / s.scale() paintLength = max(self.length * f, 50) paintWidth = paintLength * self.width / self.length self.paintShape.clear() for v in self.shape: self.paintShape << QPointF(v[0] * paintWidth, v[1] * paintLength) self.size = max(paintLength, paintWidth) self.bounding = sqrt(pow(paintLength, 2) + pow(paintLength, 2)) def updateTrack(self): if self.pos and self.trackLen: if len(self.track) >= self.trackLen: tpr = self.track.popleft() self.canvas.scene().removeItem(tpr) del(tpr) tp = QgsVertexMarker(self.canvas) tp.setCenter(self.pos) tp.setIconType(QgsVertexMarker.ICON_CROSS) tp.setColor(self.trackColor) tp.setZValue(self.zValue() - 0.1) tp.setIconSize(3) tp.setPenWidth(3) self.track.append(tp) def setVisible(self, visible): for tp in self.track: tp.setVisible(visible) QgsMapCanvasItem.setVisible(self, visible) def deleteTrack(self): for tp in self.track: self.canvas.scene().removeItem(tp) self.track.clear() def paint(self, painter, xxx, xxx2): if not self.pos: return s = (self.size - 1) / 2 pen = QPen(self.color) pen.setWidth(self.penWidth) painter.setPen(pen) if self.type == 'CROSS': painter.drawLine(QLineF(-s, 0, s, 0)) painter.drawLine(QLineF(0, -s, 0, s)) elif self.type == 'X': painter.drawLine(QLineF(-s, -s, s, s)) painter.drawLine(QLineF(-s, s, s, -s)) elif self.type == 'BOX': brush = QBrush(self.fillColor) painter.setBrush(brush) painter.drawConvexPolygon(self.paintShape) elif self.type == 'SHAPE': painter.setRenderHint(QPainter.Antialiasing, True) brush = QBrush(self.fillColor) painter.setBrush(brush) painter.drawConvexPolygon(self.paintShape) def boundingRect(self): s = self.bounding / 2 return QRectF(QPointF(-s, -s), QPointF(s, s)) def getColor(self, value): try: return QColor.fromRgba(int(value)) except ValueError: return QColor(value) def removeFromCanvas(self): self.deleteTrack() self.canvas.scene().removeItem(self)
def paintEvent(self, event): painter = QPainter(self) painter.setRenderHint(QPainter.Antialiasing) width = self.width() height = self.height() if self.dynamic_resize: knob_radius = self.dynamic_knob_radius else: knob_radius = self.knob_radius # ensure that the center point is in the middle of a pixel to ensure # that exact vertial and horizantal ticks are drawn exactly 1px wide x = math.floor(width / 2.0) + 0.5 y = math.floor(height / 2.0) + 0.5 if DEBUG: painter.fillRect(0, 0, width, height, Qt.yellow) painter.translate(x, y) if self.knob_style == KnobWidget.STYLE_NEEDLE: r = min(x, y) - 1 painter.setPen(Qt.white) painter.setBrush(Qt.white) painter.drawEllipse(QPoint(0, 0), r, r) angle = self.value_factor * self.total_angle - (self.total_angle / 2.0) # draw base knob or needle spike if self.knob_style == KnobWidget.STYLE_ROUND: painter.setPen(self.border_color) if self.pressed: gradient = QRadialGradient(0, 0, knob_radius) gradient.setColorAt(0, self.base_color_pressed) gradient.setColorAt(0.85, self.base_color) gradient.setColorAt(1, self.base_color) painter.setBrush(gradient) else: painter.setBrush(self.base_color) painter.drawEllipse(QPoint(0, 0), knob_radius, knob_radius) elif self.knob_style == KnobWidget.STYLE_NEEDLE: painter.save() painter.rotate(angle) painter.setPen(self.needle_color) painter.setBrush(self.needle_color) needle = QPolygonF() needle.append(QPointF(self.needle_base_radius * 0.6, 0)) needle.append(QPointF(0, -knob_radius)) needle.append(QPointF(-self.needle_base_radius * 0.6, 0)) painter.drawPolygon(needle) painter.restore() # draw knob mark or needle base if self.knob_style == KnobWidget.STYLE_ROUND: painter.save() painter.rotate(angle) painter.setPen(QPen(self.mark_color, 2)) painter.drawLine(0, -knob_radius * 0.4, 0, -knob_radius * 0.8) painter.restore() elif self.knob_style == KnobWidget.STYLE_NEEDLE: painter.setPen(self.border_color) painter.setBrush(self.base_color) painter.drawEllipse(QPoint(0, 0), self.needle_base_radius, self.needle_base_radius) if self.scale_visible: painter.setPen(Qt.black) # draw scale arc if self.scale_arc_visible: painter.drawArc(-knob_radius - self.knob_to_scale, -knob_radius - self.knob_to_scale, knob_radius * 2 + self.knob_to_scale * 2, knob_radius * 2 + self.knob_to_scale * 2, (90 + self.total_angle / 2) * 16, -self.total_angle * 16) # draw scale ticks def value_to_angle(value): return (float(value - self.minimum_value) / self.value_range) * self.total_angle - (self.total_angle / 2.0) value = self.minimum_value while value <= self.maximum_value: angle = value_to_angle(value) painter.save() painter.rotate(value_to_angle(value)) painter.drawLine(0, -knob_radius - self.knob_to_scale, 0, -knob_radius - self.knob_to_scale - self.tick_size_large) if self.scale_text_visible: p = painter.worldTransform().map(QPoint(0, -knob_radius - \ self.knob_to_scale - \ self.tick_size_large - \ self.tick_to_text - \ self.text_radius)) painter.restore() if self.scale_text_visible: if DEBUG: painter.save() painter.setPen(QColor(255, 0, 0, 50)) painter.setBrush(QColor(255, 0, 0, 50)) painter.drawEllipse(QPoint(p.x() - x, p.y() - y), self.text_radius, self.text_radius) painter.restore() painter.drawText(p.x() - x - 30, p.y() - y - 30, 60, 60, Qt.TextDontClip | Qt.AlignHCenter | Qt.AlignVCenter, str(value)) for i in range(1, self.scale_step_divisions): sub_value = value + (float(self.scale_step_size) * i) / self.scale_step_divisions if sub_value > self.maximum_value: break painter.save() painter.rotate(value_to_angle(sub_value)) painter.drawLine(0, -knob_radius - self.knob_to_scale, 0, -knob_radius - self.knob_to_scale - self.tick_size_small) painter.restore() value += self.scale_step_size if self.title_text != None: painter.drawText(-knob_radius, knob_radius - 30, knob_radius * 2, 60, Qt.TextDontClip | Qt.AlignHCenter | Qt.AlignVCenter, self.title_text)
class Pointer(QGraphicsLineItem): """ QGraphicsPolygonItem to model a Pointer as an Arrow from a Pointer-Variable to its Content. """ fgcolor = QColor(0, 0, 0) bgcolor = QColor(0, 0, 0) 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.setBrush( QBrush( self.bgcolor ) ) self.setPen(QPen(self.fgcolor, 1)) self.distributedObjects = distributedObjects QObject.connect(self.fromView, SIGNAL('geometryChanged()'), self.updatePosition) QObject.connect(self.toView, SIGNAL('geometryChanged()'), self.updatePosition) QObject.connect(self.fromView, SIGNAL('xChanged()'), self.updatePosition) QObject.connect(self.fromView, SIGNAL('yChanged()'), self.updatePosition) QObject.connect(self.toView, SIGNAL('xChanged()'), self.updatePosition) QObject.connect(self.toView, SIGNAL('yChanged()'), self.updatePosition) QObject.connect(self.fromView, SIGNAL('removing()'), self.delete) QObject.connect(self.toView, SIGNAL('removing()'), self.delete) self.arrowhead = QPolygonF() self.arrowSize = 20 self.setZValue(-1) # paint the arrows behind (lower z-value) everything else def boundingRect(self): extra = (self.pen().width() + 20) / 2 return QRectF(self.line().p1(), QSizeF(self.line().p2().x() - self.line().p1().x(), self.line().p2().y() - self.line().p1().y())).normalized().adjusted(-extra, -extra, extra, extra) def shape(self): path = QGraphicsLineItem.shape(self) path.addPolygon(self.arrowhead) return path def updatePosition(self): line = QLineF(self.mapFromItem(self.fromView, 0, 0), self.mapFromItem(self.toView, 0, 0)) self.setLine(line) def paint(self, painter, _1, _2): """ Main-Method of the Pointer-Class <br> calculates/renders/draws the Lines of the Arrow """ if self.fromView.collidesWithItem(self.toView): return # antialiasing makes things look nicer :) painter.setRenderHint(QPainter.Antialiasing) self.toView.x() pM1 = QPointF(self.fromView.x() + self.fromView.size().width() / 2, self.fromView.y() + self.fromView.size().height() / 2) pM2 = QPointF(self.toView.x() + self.toView.size().width() / 2, self.toView.y() + self.toView.size().height() / 2) deltaX = pM2.x() - pM1.x() deltaY = pM2.y() - pM1.y() if deltaX == 0: deltaX = 0.01 if deltaY == 0: deltaY = 0.01 if deltaX >= 0: if deltaY >= 0: # rechts unten if deltaX / deltaY >= self.fromView.size().width() / self.fromView.size().height(): # Start von rechter Seite pStart = QPointF(pM1.x() + self.fromView.size().width() / 2, pM1.y() + (self.fromView.size().width() / 2) * (deltaY / deltaX)) else: # Start von unterer Seite pStart = QPointF(pM1.x() + (self.fromView.size().height() / 2) * (deltaX / deltaY), pM1.y() + self.fromView.size().height() / 2) if deltaX / deltaY >= self.toView.size().width() / self.toView.size().height(): # Ende bei linker Seite pEnd = QPointF(pM2.x() - self.toView.size().width() / 2, pM2.y() - (self.toView.size().width() / 2) * (deltaY / deltaX)) else: # Ende bei oberer Seite pEnd = QPointF(pM2.x() - (self.toView.size().height() / 2) * (deltaX / deltaY), pM2.y() - self.toView.size().height() / 2) else: # rechts oben if deltaX / deltaY * -1 >= self.fromView.size().width() / self.fromView.size().height(): # Start von rechter Seite pStart = QPointF(pM1.x() + self.fromView.size().width() / 2, pM1.y() + (self.fromView.size().width() / 2) * (deltaY / deltaX)) else: # Start von oberer Seite pStart = QPointF(pM1.x() - (self.fromView.size().height() / 2) * (deltaX / deltaY), pM1.y() - self.fromView.size().height() / 2) if deltaX / deltaY * -1 >= self.toView.size().width() / self.toView.size().height(): # Ende bei linker Seite pEnd = QPointF(pM2.x() - self.toView.size().width() / 2, pM2.y() - (self.toView.size().width() / 2) * (deltaY / deltaX)) else: # Ende bei unterer Seite pEnd = QPointF(pM2.x() + (self.toView.size().height() / 2) * (deltaX / deltaY), pM2.y() + self.toView.size().height() / 2) else: if deltaY >= 0: # links unten if deltaX / deltaY * -1 >= self.fromView.size().width() / self.fromView.size().height(): # Start von linker Seite pStart = QPointF(pM1.x() - self.fromView.size().width() / 2, pM1.y() - (self.fromView.size().width() / 2) * (deltaY / deltaX)) else: # Start von unterer Seite pStart = QPointF(pM1.x() + (self.fromView.size().height() / 2) * (deltaX / deltaY), pM1.y() + self.fromView.size().height() / 2) if deltaX / deltaY * -1 >= self.toView.size().width() / self.toView.size().height(): # Ende bei rechten Seite pEnd = QPointF(pM2.x() + self.toView.size().width() / 2, pM2.y() + (self.toView.size().width() / 2) * (deltaY / deltaX)) else: # Ende bei oberer Seite pEnd = QPointF(pM2.x() - (self.toView.size().height() / 2) * (deltaX / deltaY), pM2.y() - self.toView.size().height() / 2) else: # links oben if deltaX / deltaY >= self.fromView.size().width() / self.fromView.size().height(): # Start von linker Seite pStart = QPointF(pM1.x() - self.fromView.size().width() / 2, pM1.y() - (self.fromView.size().width() / 2) * (deltaY / deltaX)) else: # Start von oberer Seite pStart = QPointF(pM1.x() - (self.fromView.size().height() / 2) * (deltaX / deltaY), pM1.y() - self.fromView.size().height() / 2) if deltaX / deltaY >= self.toView.size().width() / self.toView.size().height(): # Ende bei rechter Seite pEnd = QPointF(pM2.x() + self.toView.size().width() / 2, pM2.y() + (self.toView.size().width() / 2) * (deltaY / deltaX)) else: # Ende bei unterer Seite pEnd = QPointF(pM2.x() + (self.toView.size().height() / 2) * (deltaX / deltaY), pM2.y() + self.toView.size().height() / 2) self.setLine(QLineF(pEnd, pStart)) if self.line().length() != 0: angle = math.acos(self.line().dx() / self.line().length()) if self.line().dy() >= 0: angle = math.pi * 2 - angle arrowP1 = self.line().p1() + QPointF(math.sin(angle + math.pi / 2.5) * self.arrowSize, math.cos(angle + math.pi / 2.5) * self.arrowSize) arrowP2 = self.line().p1() + QPointF(math.sin(angle + math.pi - math.pi / 2.5) * self.arrowSize, math.cos(angle + math.pi - math.pi / 2.5) * self.arrowSize) self.arrowhead.clear() self.arrowhead.append(self.line().p1()) self.arrowhead.append(arrowP1) self.arrowhead.append(arrowP2) painter.setBrush(QBrush(self.bgcolor)) painter.drawLine(self.line()) painter.drawPolygon(self.arrowhead) def delete(self): """ removes the pointer from the DataGraph """ self.toView.incomingPointers.remove(self) self.fromView.outgoingPointers.remove(self) self.distributedObjects.datagraphController.removePointer(self) def setX(self, _): logging.error("Ignoring setting our Pointer's x position") def setY(self, _): logging.error("Ignoring setting our Pointer's y position")
def setGeometry(self): """ Read the parameters that define the geometry of the point """ params = parameters.instance self.setEditable(params.is_cell_editable) points = self.points polygon_id = self.polygon_id polygon = [points[pt].pos() if pt in points else None for pt in polygon_id] non_none_cnt = len([p for p in polygon if p is not None]) if non_none_cnt == 0: self.rect = QRectF() self.bounding_rect = QRectF() self.setVisible(False) return self.setVisible(True) # First, check if this is a "simple" cell walls = self.walls real_polygon = [pid for pid in polygon_id if pid in points] #sides = [ walls[real_polygon[i], real_polygon[(i+1)%len(real_polygon)]] for i in range(len(real_polygon)) ] sides = [None] * len(polygon) self.sides = sides real_scale_x = self.scale[0]/self.glob_scale real_scale_y = self.scale[1]/self.glob_scale for i in range(len(polygon)): if polygon[i] is not None: # Find the next j = (i+1) % len(polygon) while polygon[j] is None: j = (j+1) % len(polygon) w = [QPointF(p.x()*real_scale_x, p.y()*real_scale_y) for p in walls[polygon_id[i], polygon_id[j]]] sides[i] = [polygon[i]] + w + [polygon[j]] prev = real_polygon[-1] polygon_shape = [] for i in range(len(polygon)): if polygon[i]: polygon_shape.append(polygon[i]) polygon_shape.extend(sides[i]) # Now add the dummy points .. starts at the first non-None point if non_none_cnt > 2: start = None for i in range(len(polygon)): if polygon[i] is not None: start = i break prev = start cur = start+1 if start+1 < len(polygon) else 0 log_debug("Polygon before: [%s]" % ",".join("(%f,%f)" % (p.x(), p.y()) if p is not None else "None" for p in polygon)) while cur != start: if polygon[cur] is None: cnt = 1 next = cur+1 if cur+1 < len(polygon) else 0 while True: if polygon[next] is None: cnt += 1 else: break next += 1 if next == len(polygon): next = 0 #print "%d points missing" % cnt # First, find total length of wall length = 0.0 side = sides[prev] for i in range(len(side)-1): length += dist(side[i], side[i+1]) diff = length/(cnt+1) # Distance between two points i = cur p = side[0] for j in range(cnt): l = 0.0 found = False for k in range(len(side)-1): dl = dist(side[k], side[k+1]) l += dl if l > diff*(1+1e-5): # Account for accumulation of small errors c = (i + j) % len(polygon) delta = diff-l+dl p = side[k] + (side[k+1]-side[k])*delta/dl s1 = side[:k+1] + [p] s2 = [p] + side[k+1:] sides[c-1] = s1 sides[c] = s2 side = s2 polygon[c] = p found = True break assert found, "Could not find point in polygon for position %d" % (j+i,) #p = p + diff #c = (i+j)%len(polygon) #polygon[c] = QPointF(p) cur = next else: prev = cur cur += 1 if cur >= len(polygon): cur = 0 assert None not in polygon, "Error, some dummy points were not added" else: polygon = [p for p in polygon if p is not None] center = sum(polygon, QPointF(0, 0)) / float(len(polygon)) self.center = center if len(polygon) > 2: polygon = QPolygonF(polygon+[polygon[0]]) polygon.translate(-center) polygon_shape = QPolygonF(polygon_shape + [polygon_shape[0]]) self.polygon_shape = polygon_shape polygon_shape.translate(-center) # Translate the sides too sides = [[p-center for p in s] for s in sides] self.sides = sides assert len(sides) == len(polygon)-1 elif len(polygon) == 2: polygon = QLineF(polygon[0], polygon[1]) polygon.translate(-center) else: polygon = None self.polygon = polygon self.setPos(center) params = parameters.instance self.prepareGeometryChange() size = params.cell_size scale = self.scale height = size*cos(pi/6)*scale[1] width = size*scale[0] pos_x = size*cos(pi/3)*scale[0] self.sel_rect = QRectF(-width, -height, 2*width, 2*height) if isinstance(polygon, QPolygonF): self.rect = self.polygon_shape.boundingRect() | self.sel_rect elif isinstance(polygon, QLineF): self.rect = QRectF(polygon.p1(), polygon.p2()).normalized() | self.sel_rect else: self.rect = self.sel_rect self.bounding_rect = QRectF(self.rect) if self.p1 in points and self.p2 in points: self.division_line = QLineF(points[self.p1].pos()-center, points[self.p2].pos()-center) else: self.division_line = None self.hexagon = QPolygonF([QPointF(-width, 0), QPointF(-pos_x, height), QPointF(pos_x, height), QPointF(width, 0), QPointF(pos_x, -height), QPointF(-pos_x, -height)]) self.hexagon_path = QPainterPath() self.hexagon_path.addPolygon(self.hexagon) s1 = QPainterPath() if isinstance(self.polygon, QPolygonF): s1.addPolygon(polygon_shape) elif isinstance(self.polygon, QLineF): s1.moveTo(self.polygon.p1()) s1.lineTo(self.polygon.p2()) stroke = QPainterPathStroker() sel_thick = 3*params.cell_thickness if sel_thick == 0: sel_thick = 3 stroke.setWidth(sel_thick) self.stroke = stroke.createStroke(s1)
def paintEvent(self, event): page_bottom = self.edit.viewport().height() font_metrics = QFontMetrics(self.edit.document().defaultFont()) current_block = self.edit.document().findBlock( self.edit.textCursor().position()) pattern = self.pat if self.edit.lang == "python" else self.patNotPython painter = QPainter(self) background = resources.CUSTOM_SCHEME.get('sidebar-background', resources.COLOR_SCHEME['sidebar-background']) foreground = resources.CUSTOM_SCHEME.get('sidebar-foreground', resources.COLOR_SCHEME['sidebar-foreground']) painter.fillRect(self.rect(), QColor(background)) block = self.edit.firstVisibleBlock() viewport_offset = self.edit.contentOffset() line_count = block.blockNumber() painter.setFont(self.edit.document().defaultFont()) while block.isValid(): line_count += 1 # The top left position of the block in the document position = self.edit.blockBoundingGeometry(block).topLeft() + \ viewport_offset # Check if the position of the block is outside of the visible area if position.y() > page_bottom: break # Set the Painter Pen depending on special lines painter.setPen(QColor(foreground)) error = False checkers = sorted(self._neditable.registered_checkers, key=lambda x: x[2], reverse=True) for items in checkers: checker, color, _ = items if (line_count - 1) in checker.checks: painter.setPen(QColor(color)) font = painter.font() font.setItalic(True) font.setUnderline(True) painter.setFont(font) error = True break # We want the line number for the selected line to be bold. bold = False if block == current_block: bold = True font = painter.font() font.setBold(True) painter.setFont(font) # Draw the line number right justified at the y position of the # line. 3 is a magic padding number. drawText(x, y, text). if block.isVisible(): painter.drawText(self.width() - self.foldArea - font_metrics.width(str(line_count)) - 3, round(position.y()) + font_metrics.ascent() + font_metrics.descent() - 1, str(line_count)) # Remove the bold style if it was set previously. if bold: font = painter.font() font.setBold(False) painter.setFont(font) if error: font = painter.font() font.setItalic(False) font.setUnderline(False) painter.setFont(font) block = block.next() self.highest_line = line_count #Code Folding xofs = self.width() - self.foldArea painter.fillRect(xofs, 0, self.foldArea, self.height(), QColor(resources.CUSTOM_SCHEME.get('fold-area', resources.COLOR_SCHEME['fold-area']))) if self.foldArea != self.rightArrowIcon.width(): polygon = QPolygonF() self.rightArrowIcon = QPixmap(self.foldArea, self.foldArea) self.rightArrowIcon.fill(Qt.transparent) self.downArrowIcon = QPixmap(self.foldArea, self.foldArea) self.downArrowIcon.fill(Qt.transparent) polygon.append(QPointF(self.foldArea * 0.4, self.foldArea * 0.25)) polygon.append(QPointF(self.foldArea * 0.4, self.foldArea * 0.75)) polygon.append(QPointF(self.foldArea * 0.8, self.foldArea * 0.5)) iconPainter = QPainter(self.rightArrowIcon) iconPainter.setRenderHint(QPainter.Antialiasing) iconPainter.setPen(Qt.NoPen) iconPainter.setBrush(QColor( resources.CUSTOM_SCHEME.get('fold-arrow', resources.COLOR_SCHEME['fold-arrow']))) iconPainter.drawPolygon(polygon) polygon.clear() polygon.append(QPointF(self.foldArea * 0.25, self.foldArea * 0.4)) polygon.append(QPointF(self.foldArea * 0.75, self.foldArea * 0.4)) polygon.append(QPointF(self.foldArea * 0.5, self.foldArea * 0.8)) iconPainter = QPainter(self.downArrowIcon) iconPainter.setRenderHint(QPainter.Antialiasing) iconPainter.setPen(Qt.NoPen) iconPainter.setBrush(QColor( resources.CUSTOM_SCHEME.get('fold-arrow', resources.COLOR_SCHEME['fold-arrow']))) iconPainter.drawPolygon(polygon) self.calculate_docstring_block_fold() block = self.edit.firstVisibleBlock() while block.isValid(): position = self.edit.blockBoundingGeometry( block).topLeft() + viewport_offset #Check if the position of the block is outside of the visible area if position.y() > page_bottom: break if pattern.match(block.text()) and block.isVisible(): can_fold = True if self.patComment.match(block.text()) and \ (block.blockNumber() in self._endDocstringBlocks): can_fold = False if can_fold: if block.blockNumber() in self.foldedBlocks: painter.drawPixmap(xofs, round(position.y()), self.rightArrowIcon) else: painter.drawPixmap(xofs, round(position.y()), self.downArrowIcon) #Add Bookmarks and Breakpoint if block.blockNumber() in self.breakpoints: linear_gradient = QLinearGradient( xofs, round(position.y()), xofs + self.foldArea, round(position.y()) + self.foldArea) linear_gradient.setColorAt(0, QColor(255, 11, 11)) linear_gradient.setColorAt(1, QColor(147, 9, 9)) painter.setRenderHints(QPainter.Antialiasing, True) painter.setPen(Qt.NoPen) painter.setBrush(QBrush(linear_gradient)) painter.drawEllipse( xofs + 1, round(position.y()) + 6, self.foldArea - 1, self.foldArea - 1) elif block.blockNumber() in self.bookmarks: linear_gradient = QLinearGradient( xofs, round(position.y()), xofs + self.foldArea, round(position.y()) + self.foldArea) linear_gradient.setColorAt(0, QColor(13, 62, 243)) linear_gradient.setColorAt(1, QColor(5, 27, 106)) painter.setRenderHints(QPainter.Antialiasing, True) painter.setPen(Qt.NoPen) painter.setBrush(QBrush(linear_gradient)) painter.drawRoundedRect( xofs + 1, round(position.y()) + 6, self.foldArea - 2, self.foldArea - 1, 3, 3) block = block.next() painter.end() QWidget.paintEvent(self, event)
class EPoint(ENode): def __init__(self, ENodeHandle): ENode.__init__(self, ENodeHandle) self.__polygon = QPolygonF(QRectF(-50, -15, 100, 30)) self.__updateShape() self.__attributes = {} self.__hiddenAttributes = {} self.__group = QGraphicsItemGroup() self.__group.addToGroup(QGraphicsPolygonItem(self.__polygon)) self.__buildAttributes(self.Handle.lsInputAttributes()) self.__buildAttributes(self.Handle.lsOutputAttributes(), True) self.__muted = None def __updateShape(self): fBBox = QFontMetrics(self.Font).boundingRect(self.Name) if self.__polygon.boundingRect().width() < fBBox.width(): self.__polygon = QPolygonF(QRectF(fBBox).normalized().adjusted(-fBBox.width() / 4, -fBBox.height() / 4, fBBox.height(), fBBox.height() / 2)) def __buildAttributes(self, attributes, opposite=False): rotation = 90 for index, point in enumerate(self.getPoints(len(attributes), opposite)): switch = {0: point.y() - (8 + self.pen().width()), 1: point.y() + (5 + self.pen().width())} connSlot = EDraw.Circle(8, 3, rotation).translated(QPointF(point.x(), switch[opposite])) self.__group.addToGroup(QGraphicsPolygonItem(connSlot)) self.__attributes[connSlot] = dict({self.kGuiAttributeId: attributes[index].Id, self.kGuiAttributeType: attributes[index].Type, self.kGuiAttributeParent: self, self.kGuiAttributePlug: self.Polygon.boundingRect().center(), self.kGuiAttributeLongName: attributes[index].Name}) return @property def Polygon(self): return self.__polygon @property def BoundPolygon(self): return self.__polygon.boundingRect() def mute(self, uuid): self.__muted = uuid def togglePlug(self, plugId): hiddenId = self.mapFromId(plugId)[ENode.kGuiAttributeId] if self.__hiddenAttributes.has_key(hiddenId): self.__hiddenAttributes.pop(hiddenId, None) return self.__hiddenAttributes[self.mapFromId(plugId)[ENode.kGuiAttributeId]] = [] def mapFromPoint(self, QPoint): for attrRect, attrValues in self.__attributes.iteritems(): if attrRect.boundingRect().contains(self.mapFromScene(QPoint)): return attrValues[self.kGuiAttributeId], self.scenePos() return self.Handle.Id, None def mapFromId(self, attrId): for attrValue in self.__attributes.itervalues(): if attrValue[self.kGuiAttributeId] == attrId: return attrValue return None def boundingRect(self): extra = self.pen().width() return self.__group.boundingRect().normalized().adjusted(-extra, -extra, extra, extra) def shape(self): return QGraphicsItem.shape(self) def getLines(self, count, opposite=False): angleOffset = 25 inputLines = [] startAngle = QLineF(QPointF(0.0, 0.0), self.boundingRect().topRight()).angle() + angleOffset endAngle = QLineF(QPointF(0.0, 0.0), self.boundingRect().topLeft()).angle() - angleOffset if opposite: startAngle = QLineF(QPointF(0.0, 0.0), self.boundingRect().bottomLeft()).angle() + angleOffset endAngle = QLineF(QPointF(0.0, 0.0), self.boundingRect().bottomRight()).angle() - angleOffset step = (endAngle - startAngle) / (count - 1) for x in range(0, count): tLine = QLineF(QPointF(0.0, 0.0), QPointF(0, 100)) tLine.setAngle(startAngle) inputLines.append(tLine) startAngle += step return inputLines def getPoints(self, count, opposite=False): result = [] line = QLineF(self.__polygon.boundingRect().topLeft(), self.__polygon.boundingRect().topRight()) if opposite: line = QLineF(self.__polygon.boundingRect().bottomLeft(), self.__polygon.boundingRect().bottomRight()) step = 1.0 / (count + 1) currentStep = step for x in range(0, count): result.append(line.pointAt(currentStep)) currentStep += step return result def paint(self, painter, option, widget=None): painter.setPen(self.pen()) painter.setBrush(EDraw.EColor.DefaultTitleColor) painter.drawRoundedRect(self.__polygon.boundingRect(), 3, 3) painter.setPen(EDraw.EColor.DefaultTitleTextColor) painter.drawText(self.__polygon.boundingRect(), Qt.AlignCenter, self.Name) for connSlot, connData in self.__attributes.iteritems(): if connData[self.kGuiAttributeId] != self.__muted and connData[self.kGuiAttributeId] not in self.__hiddenAttributes.keys(): painter.drawPolygon(connSlot) painter.setBrush(Qt.NoBrush)
def paintEvent(self, event): page_bottom = self.edit.viewport().height() font_metrics = QFontMetrics(self.edit.document().defaultFont()) current_block = self.edit.document().findBlock(self.edit.textCursor().position()) if self._firstPaintEvent is True: self.jumpedUP = False self.strings = self.edit.toPlainText().split("\n") self._originalTotalLine = len(self.strings) self.edit.jump_to_line(len(self.strings) - 2) elif self.jumpedUP is False: self.edit.jump_to_line(1) self.edit.verticalScrollBar().setValue(0) self.jumpedUP = True return pattern = self.pat if self.edit.lang == "python" else self.patNotPython painter = QPainter(self) background = resources.CUSTOM_SCHEME.get("sidebar-background", resources.COLOR_SCHEME["sidebar-background"]) foreground = resources.CUSTOM_SCHEME.get("sidebar-foreground", resources.COLOR_SCHEME["sidebar-foreground"]) pep8color = resources.CUSTOM_SCHEME.get("pep8-underline", resources.COLOR_SCHEME["pep8-underline"]) errorcolor = resources.CUSTOM_SCHEME.get("error-underline", resources.COLOR_SCHEME["error-underline"]) migrationcolor = resources.CUSTOM_SCHEME.get( "migration-underline", resources.COLOR_SCHEME["migration-underline"] ) painter.fillRect(self.rect(), QColor(background)) """ if self._firstPaintEvent is True: block = self.edit.document().findBlock(0) else: block = self.edit.firstVisibleBlock() """ block = self.edit.firstVisibleBlock() viewport_offset = self.edit.contentOffset() line_count = block.blockNumber() painter.setFont(self.edit.document().defaultFont()) pat = re.compile("\s*#AppObject:") patAlexaAppImage = re.compile("\s*#AppImage:") patAlexaAppText = re.compile("\s*#AppText:") patAlexaLog = re.compile("\s*#Alexa Log") while block.isValid(): line_count += 1 # The top left position of the block in the document position = self.edit.blockBoundingGeometry(block).topLeft() + viewport_offset # Check if the position of the block is outside of the visible area if position.y() > page_bottom: break # Set the Painter Pen depending on special lines error = False if settings.CHECK_STYLE and ((line_count - 1) in self._pep8Lines): painter.setPen(QColor(pep8color)) font = painter.font() font.setItalic(True) font.setUnderline(True) painter.setFont(font) error = True elif settings.FIND_ERRORS and ((line_count - 1) in self._errorsLines): painter.setPen(QColor(errorcolor)) font = painter.font() font.setItalic(True) font.setUnderline(True) painter.setFont(font) error = True elif settings.SHOW_MIGRATION_TIPS and ((line_count - 1) in self._migrationLines): painter.setPen(QColor(migrationcolor)) font = painter.font() font.setItalic(True) font.setUnderline(True) painter.setFont(font) error = True else: painter.setPen(QColor(foreground)) # We want the line number for the selected line to be bold. bold = False if block == current_block: bold = True font = painter.font() font.setBold(True) painter.setFont(font) # Draw the line number right justified at the y position of the # line. 3 is a magic padding number. drawText(x, y, text). if block.isVisible(): painter.drawText( self.width() - self.foldArea - font_metrics.width(str(line_count)) - 3, round(position.y()) + font_metrics.ascent() + font_metrics.descent() - 1, str(line_count), ) # Remove the bold style if it was set previously. if bold: font = painter.font() font.setBold(False) painter.setFont(font) if error: font = painter.font() font.setItalic(False) font.setUnderline(False) painter.setFont(font) block = block.next() self.highest_line = line_count # Code Folding xofs = self.width() - self.foldArea painter.fillRect( xofs, 0, self.foldArea, self.height(), QColor(resources.CUSTOM_SCHEME.get("fold-area", resources.COLOR_SCHEME["fold-area"])), ) if self.foldArea != self.rightArrowIcon.width(): polygon = QPolygonF() self.rightArrowIcon = QPixmap(self.foldArea, self.foldArea) self.rightArrowIcon.fill(Qt.transparent) self.downArrowIcon = QPixmap(self.foldArea, self.foldArea) self.downArrowIcon.fill(Qt.transparent) polygon.append(QPointF(self.foldArea * 0.4, self.foldArea * 0.25)) polygon.append(QPointF(self.foldArea * 0.4, self.foldArea * 0.75)) polygon.append(QPointF(self.foldArea * 0.8, self.foldArea * 0.5)) iconPainter = QPainter(self.rightArrowIcon) iconPainter.setRenderHint(QPainter.Antialiasing) iconPainter.setPen(Qt.NoPen) iconPainter.setBrush( QColor(resources.CUSTOM_SCHEME.get("fold-arrow", resources.COLOR_SCHEME["fold-arrow"])) ) iconPainter.drawPolygon(polygon) polygon.clear() polygon.append(QPointF(self.foldArea * 0.25, self.foldArea * 0.4)) polygon.append(QPointF(self.foldArea * 0.75, self.foldArea * 0.4)) polygon.append(QPointF(self.foldArea * 0.5, self.foldArea * 0.8)) iconPainter = QPainter(self.downArrowIcon) iconPainter.setRenderHint(QPainter.Antialiasing) iconPainter.setPen(Qt.NoPen) iconPainter.setBrush( QColor(resources.CUSTOM_SCHEME.get("fold-arrow", resources.COLOR_SCHEME["fold-arrow"])) ) iconPainter.drawPolygon(polygon) if self._firstPaintEvent is True: block = self.edit.document().findBlock(0) else: block = self.edit.firstVisibleBlock() # block = self.edit.firstVisibleBlock() line_count = block.blockNumber() while block.isValid(): # while line_count < 5000: line_count += 1 position = self.edit.blockBoundingGeometry(block).topLeft() + viewport_offset # Check if the position of the block is outside of the visible area if position.y() > page_bottom: break # block.isVisible() and if block.isVisible() and pat.match(block.text()) and block not in self._foldedAlexaObject: self._fold(line_count) self._foldedAlexaObject.append(block) self._alexaObjectsPresent = True elif block.isVisible() and patAlexaAppImage.match(block.text()) and block not in self._foldedAlexaImage: self._fold(line_count) self._foldedAlexaImage.append(block) self._alexaObjectsPresent = True elif block.isVisible() and patAlexaAppText.match(block.text()) and block not in self._foldedAlexaText: self._fold(line_count) self._foldedAlexaText.append(block) self._alexaObjectsPresent = True elif block.isVisible() and patAlexaLog.match(block.text()) and block not in self._foldedAlexaLog: self._fold(line_count) self._foldedAlexaLog.append(block) self._alexaObjectsPresent = True elif pattern.match(block.text()) and block.isVisible(): if block.blockNumber() in self._foldedBlocks: painter.drawPixmap(xofs, round(position.y()), self.rightArrowIcon) else: # block.setVisible(True) painter.drawPixmap(xofs, round(position.y()), self.downArrowIcon) # Add Bookmarks and Breakpoint elif block.blockNumber() in self._breakpoints: linear_gradient = QLinearGradient( xofs, round(position.y()), xofs + self.foldArea, round(position.y()) + self.foldArea ) linear_gradient.setColorAt(0, QColor(255, 11, 11)) linear_gradient.setColorAt(1, QColor(147, 9, 9)) painter.setRenderHints(QPainter.Antialiasing, True) painter.setPen(Qt.NoPen) painter.setBrush(QBrush(linear_gradient)) painter.drawEllipse(xofs + 1, round(position.y()) + 6, self.foldArea - 1, self.foldArea - 1) elif block.blockNumber() in self._bookmarks: linear_gradient = QLinearGradient( xofs, round(position.y()), xofs + self.foldArea, round(position.y()) + self.foldArea ) linear_gradient.setColorAt(0, QColor(13, 62, 243)) linear_gradient.setColorAt(1, QColor(5, 27, 106)) painter.setRenderHints(QPainter.Antialiasing, True) painter.setPen(Qt.NoPen) painter.setBrush(QBrush(linear_gradient)) painter.drawRoundedRect(xofs + 1, round(position.y()) + 6, self.foldArea - 2, self.foldArea - 1, 3, 3) block = block.next() block = self.edit.document().findBlock(0) line_count = 0 line_hidden = 0 while block.isValid(): line_count += 1 if not block.isVisible(): line_hidden += 1 block = block.next() endScrollBar = line_count - line_hidden self.edit.verticalScrollBar().setRange(0, endScrollBar) if self._firstPaintEvent is True: self._firstPaintEvent = False # self.updateAlexaAppObjCoords() # self.updateAlexaLogCoords() painter.end() """ #self.edit.update() if self.edit.verticalScrollBar().value() != self._oldVerticalScrollbarPosition and self._alexaObjectsPresent is True: self._oldVerticalScrollbarPosition = self.edit.verticalScrollBar().value() self.updateAlexaCoords() self.edit.update() # in this way we can refresh alexa icon position if self.edit.horizontalScrollBar().value() != self._oldHorizontalScrollbarPosition and self._alexaObjectsPresent is True: self._oldHorizontalScrollbarPosition = self.edit.horizontalScrollBar().value() self.updateAlexaCoords() self.edit.update() # in this way we can refresh alexa icon position """ self.strings = self.edit.toPlainText().split("\n") self._currentTotalLine = len(self.strings) if self._currentTotalLine != self._originalTotalLine: self._originalTotalLine = self._currentTotalLine self.updateAlexaCoords() self.edit.update() """ if self._returnPressed is True: self._returnPressed = False self.updateAlexaAppObjCoords() self.updateAlexaLogCoords() self.edit.update() if self._backspacePressed is True: self._backspacePressed = False self.strings = self.edit.toPlainText().split('\n') self._currentTotalLine = len(self.strings) if self._currentTotalLine != self._originalTotalLine: self.updateAlexaAppObjCoords() self.updateAlexaLogCoords() self.edit.update() """ if self.edit._alexaAppObjIconsCoords != self._oldAlexaAppObjIconsCoords: self._oldAlexaAppObjIconsCoords = copy.deepcopy(self.edit._alexaAppObjIconsCoords) self.edit.update() if self.edit._alexaAppImgIconsCoords != self._oldAlexaAppImgIconsCoords: self._oldAlexaAppImgIconsCoords = copy.deepcopy(self.edit._alexaAppImgIconsCoords) self.edit.update() if self.edit._alexaAppTextIconsCoords != self._oldAlexaAppTextIconsCoords: self._oldAlexaAppTextIconsCoords = copy.deepcopy(self.edit._alexaAppTextIconsCoords) self.edit.update() if self.edit._alexaLogIconsCoords != self._oldAlexaLogIconsCoords: self._oldAlexaLogIconsCoords = copy.deepcopy(self.edit._alexaLogIconsCoords) self.edit.update() selectedLine = self.edit.textCursor().selectedText() textAtCursorPos = self.edit.textCursor().block().text() try: # tmp = selectedLine.index("# AppObject") if ( pat.match(selectedLine) or patAlexaLog.match(selectedLine) or pat.match(textAtCursorPos) or patAlexaLog.match(textAtCursorPos) or patAlexaAppImage.match(selectedLine) or patAlexaAppImage.match(textAtCursorPos) or patAlexaAppText.match(selectedLine) or patAlexaAppText.match(textAtCursorPos) ) and self._keypress is True: self._keypress = False self.updateAlexaCoords() except: pass QWidget.paintEvent(self, event) """
def paintEvent(self, event): page_bottom = self.edit.viewport().height() font_metrics = QFontMetrics(self.edit.document().defaultFont()) current_block = self.edit.document().findBlock( self.edit.textCursor().position()) painter = QPainter(self) painter.fillRect(self.rect(), Qt.lightGray) block = self.edit.firstVisibleBlock() viewport_offset = self.edit.contentOffset() line_count = block.blockNumber() painter.setFont(self.edit.document().defaultFont()) while block.isValid(): line_count += 1 # The top left position of the block in the document position = self.edit.blockBoundingGeometry(block).topLeft() + \ viewport_offset # Check if the position of the block is outside of the visible area if position.y() > page_bottom: break # Set the Painter Pen depending on special lines error = False if settings.CHECK_STYLE and \ ((line_count - 1) in self._pep8Lines): painter.setPen(Qt.darkYellow) font = painter.font() font.setItalic(True) font.setUnderline(True) painter.setFont(font) error = True elif settings.FIND_ERRORS and \ ((line_count - 1) in self._errorsLines): painter.setPen(Qt.red) font = painter.font() font.setItalic(True) font.setUnderline(True) painter.setFont(font) error = True else: painter.setPen(Qt.black) # We want the line number for the selected line to be bold. bold = False if block == current_block: bold = True font = painter.font() font.setBold(True) painter.setFont(font) # Draw the line number right justified at the y position of the # line. 3 is a magic padding number. drawText(x, y, text). if block.isVisible(): painter.drawText(self.width() - self.foldArea - \ font_metrics.width(str(line_count)) - 3, round(position.y()) + font_metrics.ascent() + \ font_metrics.descent() - 1, str(line_count)) # Remove the bold style if it was set previously. if bold: font = painter.font() font.setBold(False) painter.setFont(font) if error: font = painter.font() font.setItalic(False) font.setUnderline(False) painter.setFont(font) block = block.next() self.highest_line = line_count #Code Folding xofs = self.width() - self.foldArea painter.fillRect(xofs, 0, self.foldArea, self.height(), QColor(resources.CUSTOM_SCHEME.get('fold-area', resources.COLOR_SCHEME['fold-area']))) if self.foldArea != self.rightArrowIcon.width(): polygon = QPolygonF() self.rightArrowIcon = QPixmap(self.foldArea, self.foldArea) self.rightArrowIcon.fill(Qt.transparent) self.downArrowIcon = QPixmap(self.foldArea, self.foldArea) self.downArrowIcon.fill(Qt.transparent) polygon.append(QPointF(self.foldArea * 0.4, self.foldArea * 0.25)) polygon.append(QPointF(self.foldArea * 0.4, self.foldArea * 0.75)) polygon.append(QPointF(self.foldArea * 0.8, self.foldArea * 0.5)) iconPainter = QPainter(self.rightArrowIcon) iconPainter.setRenderHint(QPainter.Antialiasing) iconPainter.setPen(Qt.NoPen) iconPainter.setBrush(QColor( resources.CUSTOM_SCHEME.get('fold-arrow', resources.COLOR_SCHEME['fold-arrow']))) iconPainter.drawPolygon(polygon) polygon.clear() polygon.append(QPointF(self.foldArea * 0.25, self.foldArea * 0.4)) polygon.append(QPointF(self.foldArea * 0.75, self.foldArea * 0.4)) polygon.append(QPointF(self.foldArea * 0.5, self.foldArea * 0.8)) iconPainter = QPainter(self.downArrowIcon) iconPainter.setRenderHint(QPainter.Antialiasing) iconPainter.setPen(Qt.NoPen) iconPainter.setBrush(QColor( resources.CUSTOM_SCHEME.get('fold-arrow', resources.COLOR_SCHEME['fold-arrow']))) iconPainter.drawPolygon(polygon) block = self.edit.firstVisibleBlock() while block.isValid(): position = self.edit.blockBoundingGeometry( block).topLeft() + viewport_offset #Check if the position of the block is outside of the visible area if position.y() > page_bottom: break if self.pat.match(unicode(block.text())) and block.isVisible(): if block.blockNumber() in self._foldedBlocks: painter.drawPixmap(xofs, round(position.y()), self.rightArrowIcon) else: painter.drawPixmap(xofs, round(position.y()), self.downArrowIcon) #Add Bookmarks and Breakpoint elif block.blockNumber() in self._breakpoints: linear_gradient = QLinearGradient( xofs, round(position.y()), xofs + self.foldArea, round(position.y()) + self.foldArea) linear_gradient.setColorAt(0, QColor(255, 11, 11)) linear_gradient.setColorAt(1, QColor(147, 9, 9)) painter.setRenderHints(QPainter.Antialiasing, True) painter.setPen(Qt.NoPen) painter.setBrush(QBrush(linear_gradient)) painter.drawEllipse( xofs + 1, round(position.y()) + 6, self.foldArea - 1, self.foldArea - 1) elif block.blockNumber() in self._bookmarks: linear_gradient = QLinearGradient( xofs, round(position.y()), xofs + self.foldArea, round(position.y()) + self.foldArea) linear_gradient.setColorAt(0, QColor(13, 62, 243)) linear_gradient.setColorAt(1, QColor(5, 27, 106)) painter.setRenderHints(QPainter.Antialiasing, True) painter.setPen(Qt.NoPen) painter.setBrush(QBrush(linear_gradient)) painter.drawRoundedRect( xofs + 1, round(position.y()) + 6, self.foldArea - 2, self.foldArea - 1, 3, 3) block = block.next() painter.end() QWidget.paintEvent(self, event)
def _paintLine(self, painter, line): polyline = QPolygonF() for point in line: polyline.append(self.toCanvasCoordinates(point) - self.pos()) painter.drawPolyline(polyline)
def __init__(self, world): QGraphicsPolygonItem.__init__(self) ############################# ### Build graph ############################# graph = pydot.Dot() graph.set_node_defaults(color = 'red', fontcolor = 'red', label = '\<orphan\>') graph.set('overlap', 'prism') # build adjacency graph from world for area in world.areas: # create node for each room node = pydot.Node(area.id) node.set( 'label', area.name ) if area == world.player.currentArea: node.set( 'color', 'blue' ) node.set( 'fontcolor', 'blue' ) else: node.set( 'color', 'black' ) node.set( 'fontcolor', 'black' ) graph.add_node(node) # link to adjacent rooms for feature in area.features: for action in feature.actions: finalEvent = None for event in action.events: if type(event) == events.PlayerMoveEvent: finalEvent = pydot.Edge( src=area.id, dst=event.properties['destination'] ) if finalEvent is not None: graph.add_edge( finalEvent ) ################################ ### Generate SVG from graph ################################ ps = graph.create_svg(prog='neato') ######################################### ### Build graphics items from SVG ######################################### # build xml tree ns = {'svg': 'http://www.w3.org/2000/svg'} doc = ET.fromstring(ps) # grab the root node properties rootNode = doc.xpath('/svg:svg/svg:g[1]', namespaces=ns)[0] polygon = rootNode.xpath('./svg:polygon', namespaces=ns)[0] pointStr = polygon.xpath('./@points', namespaces=ns)[0] penColor = QString(polygon.xpath('./@stroke', namespaces=ns)[0]) fillColor = QString(polygon.xpath('./@fill', namespaces=ns)[0]) # parse root polygon path path = QPolygonF() for pair in pointStr.split(' '): dims = pair.split(',') point = QPointF( float(dims[0]), float(dims[1]) ) path.append(point) self.setPolygon(path) # fill in root node colors if QColor.isValidColor(penColor): self.setPen( QColor(penColor) ) if QColor.isValidColor(fillColor): self.setBrush( QColor(fillColor) ) # build each graph node for xmlNode in rootNode.xpath('./svg:g', namespaces=ns): group = QGraphicsRectItem(self) group.setPen( Qt.transparent ) group.setBrush( Qt.transparent ) if xmlNode.attrib['class'] == 'node': # find the area object name = xmlNode.xpath('./svg:title', namespaces=ns)[0].text group.setData( 0, QString(world.areas[world.areaLookup[name]].id) ) # get the ellipse info ellipseNode = xmlNode.xpath('./svg:ellipse', namespaces=ns)[0] elProps = { k: float(ellipseNode.attrib[k]) for k in ['cx', 'cy', 'rx', 'ry']} rect = QRectF( elProps['cx']-elProps['rx'], elProps['cy']-elProps['ry'], 2*elProps['rx'], 2*elProps['ry']) penColor = QString(ellipseNode.attrib['stroke']) ellipseItem = QGraphicsEllipseItem(rect, group) if QColor.isValidColor(penColor): ellipseItem.setPen( QColor(penColor) ) # get the text info textNode = xmlNode.xpath('./svg:text', namespaces=ns)[0] text = textNode.text textItem = QGraphicsTextItem(text, group) penColor = textNode.attrib.get('fill', 'black') nodePoint = QPointF(float(textNode.attrib['x']), float(textNode.attrib['y'])) textItem.setPos( nodePoint - textItem.boundingRect().center() + QPointF(0.0,-4.0)) if QColor.isValidColor(penColor): textItem.setDefaultTextColor( QColor(penColor) ) group.setRect( ellipseItem.boundingRect() ) group.setFlags( QGraphicsRectItem.ItemIsSelectable ) elif xmlNode.attrib['class'] == 'edge': # parse the line portion of the arrow line = xmlNode.xpath('./svg:path', namespaces=ns)[0] path = QPainterPath() # pull info from xml file linePath = line.attrib['d'] lineColor = line.attrib['stroke'] # parse path coords points = re.findall( '(-?\d+\.\d+),(-?\d+\.\d+)', linePath ) if len(points) != 4: continue startPoint = QPointF( float(points[0][0]), float(points[0][1]) ) path.moveTo(startPoint) curvePoints = [] for pointCoord in points[1:]: curvePoints.append( QPointF(float(pointCoord[0]), float(pointCoord[1])) ) path.cubicTo( curvePoints[0], curvePoints[1], curvePoints[2] ) # construct path item pathItem = QGraphicsPathItem(path, group) if QColor.isValidColor(lineColor): pathItem.setPen( QColor(lineColor) ) polyNode = xmlNode.xpath('./svg:polygon', namespaces=ns)[0] # pull info from xml file pointStr = polyNode.xpath('./@points', namespaces=ns)[0] penColor = QString(polyNode.xpath('./@stroke', namespaces=ns)[0]) fillColor = QString(polyNode.xpath('./@fill', namespaces=ns)[0]) # parse polygon path path = QPolygonF() for pair in pointStr.split(' '): dims = pair.split(',') point = QPointF( float(dims[0]), float(dims[1]) ) path.append(point) # construct polygon item polygonItem = QGraphicsPolygonItem(path, group) if QColor.isValidColor(penColor): polygonItem.setPen( QColor(penColor) ) if QColor.isValidColor(fillColor): polygonItem.setBrush( QColor(fillColor) ) group.setRect( pathItem.boundingRect() and polygonItem.boundingRect() )
from util import * from itertools import product baseWidth = styles.PATH_BASE_WIDTH ppL5 = QPainterPath() # Left 5' PainterPath ppR5 = QPainterPath() # Right 5' PainterPath ppL3 = QPainterPath() # Left 3' PainterPath ppR3 = QPainterPath() # Right 3' PainterPath # set up ppL5 (left 5' blue square) ppL5.addRect(0.25 * baseWidth, 0.125 * baseWidth,\ 0.75 * baseWidth, 0.75 * baseWidth) # set up ppR5 (right 5' blue square) ppR5.addRect(0, 0.125 * baseWidth,\ 0.75 * baseWidth, 0.75 * baseWidth) # set up ppL3 (left 3' blue triangle) l3poly = QPolygonF() l3poly.append(QPointF(baseWidth, 0)) l3poly.append(QPointF(0.25 * baseWidth, 0.5 * baseWidth)) l3poly.append(QPointF(baseWidth, baseWidth)) ppL3.addPolygon(l3poly) # set up ppR3 (right 3' blue triangle) r3poly = QPolygonF() r3poly.append(QPointF(0, 0)) r3poly.append(QPointF(0.75 * baseWidth, 0.5 * baseWidth)) r3poly.append(QPointF(0, baseWidth)) ppR3.addPolygon(r3poly) class PathHelix(QGraphicsItem): """ PathHelix is the primary "view" of the VirtualHelix data.