def __init__(self, startX, startY, midX, midY, endX, endY, rgb, parent=None): #OVERLOADED IMPL?# ArcObject::ArcObject(ArcObject* obj, QGraphicsItem* parent) : BaseObject(parent) """ Default class constructor. :param `startX`: TOWRITE :type `startX`: qreal :param `startY`: TOWRITE :type `startY`: qreal :param `midX`: TOWRITE :type `midX`: qreal :param `midY`: TOWRITE :type `midY`: qreal :param `endX`: TOWRITE :type `endX`: qreal :param `endY`: TOWRITE :type `endY`: qreal :param `rgb`: TOWRITE :type `rgb`: QRgb :param `parent`: TOWRITE :type `parent`: `QGraphicsItem`_ """ super(ArcObject, self).__init__(parent) qDebug("ArcObject Constructor()") self.arcStartPoint = QPointF() self.arcMidPoint = QPointF() self.arcEndPoint = QPointF() self.init(startX, startY, midX, midY, endX, endY, rgb, Qt.SolidLine) # TODO: getCurrentLineType
def mouseReleaseEvent(self, event): if event.button() == Qt.LeftButton: if self.panActive: self.panActive = False if not ENABLE_KINETIC_PANNING or self.lastMoveTime.msecsTo(QTime.currentTime()) > HOLD_TIME_THRESHOLD: return self.kineticPanSpeed = QPointF() entriesConsidered = 0 currentTime = QTime.currentTime() for entry in self.mouseHistory: if not entry.time: continue if entry.time.msecsTo(currentTime) < HOLD_TIME_THRESHOLD: self.kineticPanSpeed += entry.position entriesConsidered += 1 if entriesConsidered > 0: self.kineticPanSpeed /= entriesConsidered self.lastMoveTime = currentTime self.kineticTimer.start() self.panDecellerate = True event.accept()
def paint(self, painter, option, widget): """ TOWRITE :param `painter`: TOWRITE :type `painter`: `QPainter`_ :param `option`: TOWRITE :type `option`: `QStyleOptionGraphicsItem`_ :param `widget`: TOWRITE :type `widget`: `QWidget`_ """ objScene = self.scene() # QGraphicsScene* if not objScene: return paintPen = self.pen() # QPen painter.setPen(paintPen) self.updateRubber(painter) if option.state & QStyle.State_Selected: paintPen.setStyle(Qt.DashLine) if objScene.property(ENABLE_LWT): # .toBool() paintPen = self.lineWeightPen() painter.setPen(paintPen) if self.normalPath.elementCount(): painter.drawPath(self.normalPath) zero = self.normalPath.elementAt(0) # QPainterPath::Element last = self.normalPath.elementAt(self.normalPath.elementCount() - 1) # QPainterPath::Element painter.drawLine(QPointF(zero.x, zero.y), QPointF(last.x, last.y))
def paintEvent(self, pe): # make an arrow polygon right in the middle painter = QPainter(self) painter.setPen(Qt.NoPen) # draw the background transparent rect painter.save() painter.setOpacity(self.BACKGROUND_OPACITY) # get the rectangle coordinates it should extend over the whole width with only a portion at the center painter.setBrush(Qt.black) empty_space_percent = 1 - self.BACKROUND_HEIGHT_PERCENT rect_top = empty_space_percent / 2 * self.height() rect_height = self.BACKROUND_HEIGHT_PERCENT * self.height() painter.drawRect(0, rect_top, self.width(), rect_height) painter.restore() painter.setRenderHint(QPainter.Antialiasing) pen = QPen() pen.setWidth(self.ARROW_LINE_WIDTH) pen.setCapStyle(Qt.RoundCap) if self._mouse_inside: pen.setColor(self._hover_color) else: pen.setColor(self._normal_color) # get the arrow coords painter.setPen(pen) self_center = QPointF(self.width() / 2, self.height() / 2) # use this as the arrow tip for now if self._direction == self.LEFT: h_shift = self._arrow_width elif self._direction == self.RIGHT: h_shift = - self._arrow_width v_shift = self._arrow_height / 2 top_point = self_center + QPointF(h_shift, - v_shift) bottom_point = self_center + QPointF(h_shift, v_shift) painter.drawLine(top_point, self_center) painter.drawLine(self_center, bottom_point)
def calculateArcData(self, startX, startY, midX, midY, endX, endY): """ TOWRITE :param `startX`: TOWRITE :type `startX`: qreal :param `startY`: TOWRITE :type `startY`: qreal :param `midX`: TOWRITE :type `midX`: qreal :param `midY`: TOWRITE :type `midY`: qreal :param `endX`: TOWRITE :type `endX`: qreal :param `endY`: TOWRITE :type `endY`: qreal """ #TODO/PORT# double centerX; #TODO/PORT# double centerY; #TODO/PORT# getArcCenter(startX, startY, #TODO/PORT# midX, midY, #TODO/PORT# endX, endY, #TODO/PORT# ¢erX, ¢erY); self.arcStartPoint = QPointF(startX - centerX, startY - centerY) self.arcMidPoint = QPointF(midX - centerX, midY - centerY) self.arcEndPoint = QPointF(endX - centerX, endY - centerY) self.setPos(centerX, centerY) radius = QLineF(centerX, centerY, midX, midY).length() # qreal self.updateArcRect(radius) self.updatePath() self.setRotation(0) self.setScale(1)
def calculateArcData(self, startX, startY, midX, midY, endX, endY): """ TOWRITE :param `startX`: TOWRITE :type `startX`: qreal :param `startY`: TOWRITE :type `startY`: qreal :param `midX`: TOWRITE :type `midX`: qreal :param `midY`: TOWRITE :type `midY`: qreal :param `endX`: TOWRITE :type `endX`: qreal :param `endY`: TOWRITE :type `endY`: qreal """ #TODO/PORT# double centerX; #TODO/PORT# double centerY; #TODO/PORT# getArcCenter(startX, startY, #TODO/PORT# midX, midY, #TODO/PORT# endX, endY, #TODO/PORT# ¢erX, ¢erY); arcStartPoint = QPointF(startX - centerX, startY - centerY) arcMidPoint = QPointF(midX - centerX, midY - centerY) arcEndPoint = QPointF(endX - centerX, endY - centerY) self.setPos(centerX, centerY) radius = QLineF(centerX, centerY, midX, midY).length() # qreal self.updateArcRect(radius) self.updatePath() self.setRotation(0) self.setScale(1)
def test_subsegment(self): "Subsegment a single box with three seeds points" w = self.window # Open document for subsegmentation w.open_document(TESTDATA / 'test_subsegment.inselect') self.assertEqual(1, w.model.rowCount()) # Select a box and add sub-segmentation seed points # TODO LH Selecting the box and adding points like this is nasty - # possible to use QTest.mouseClick? box = w.view_graphics_item.scene.box_items().next() box.setSelected(True) seeds = [ QPointF(290.0, 145.0), QPointF(586.0, 276.0), QPointF(272.0, 453.0) ] for pos in seeds: box.append_subsegmentation_seed_point(pos) # Sub-segment self.run_async_operation(partial(w.run_plugin, 1)) # Should have three boxes self.assertEqual(3, w.model.rowCount()) self.assertTrue(w.model.modified) # Close the document with patch.object(QMessageBox, 'question', return_value=QMessageBox.No): self.assertTrue(self.window.close_document())
def simple_arrow(self, origin='head', path=None): ''' Compute the two points of an vertical arrow head ''' if origin == 'head': endp = self.end_point else: endp = self.start_point return (QPointF(endp.x() - 5, endp.y() - 5), QPointF(endp.x() + 5, endp.y() - 5))
def end_point(self): ''' Compute connection end point - redefined function ''' if self.child.on_the_right: return QPointF(self.child.x(), self.child.y() + self.child.boundingRect().height() / 2) else: return QPointF(self.child.x() + self.child.boundingRect().width(), self.child.y() + self.child.boundingRect().height() / 2)
def beforeTest(self): points = [QPointF(0, 0), QPointF(100, 100), QPointF(0, 100)] pol = self.scene.addPolygon(QPolygonF(points)) self.assert_(isinstance(pol, QGraphicsPolygonItem)) self.wrp = weakref.ref(pol, pol_del) #refcount need be 3 because one ref for QGraphicsScene, and one to rect obj self.assertEqual(sys.getrefcount(pol), 3)
def get_node_to_pos(self): if self.node_to is None: return QPointF() n2 = self.node_to() if n2 is None: return QPointF() return n2.pos()
def get_node_from_pos(self): if self.node_from is None: return QPointF() n1 = self.node_from() if n1 is None: return QPointF() return n1.pos()
def _draw_reticle(self): if self._reticle is None or (self._reticle.size() != self.size()): self._new_reticle() dbm_lines = [ QLineF(self._hz_to_x(self._low_frequency), self._dbm_to_y(dbm), self._hz_to_x(self._high_frequency), self._dbm_to_y(dbm)) for dbm in numpy.arange(self._low_dbm, self._high_dbm, 20.0) ] dbm_labels = [ (dbm, QPointF( self._hz_to_x(self._low_frequency) + 2, self._dbm_to_y(dbm) - 2)) for dbm in numpy.arange(self._low_dbm, self._high_dbm, 20.0) ] frequency_lines = [ QLineF(self._hz_to_x(frequency), self._dbm_to_y(self._high_dbm), self._hz_to_x(frequency), self._dbm_to_y(self._low_dbm)) for frequency in numpy.arange(self._low_frequency, self._high_frequency, self._frequency_step * 10.0) ] frequency_labels = [(frequency, QPointF( self._hz_to_x(frequency) + 2, self._dbm_to_y(self._high_dbm) + 10)) for frequency in numpy.arange( self._low_frequency, self._high_frequency, self._frequency_step * 10.0)] painter = QtGui.QPainter(self._reticle) try: painter.setRenderHint(QtGui.QPainter.Antialiasing) painter.setPen(Qt.blue) # TODO: Removed to support old (<1.0) PySide API in Ubuntu 10.10 #painter.drawLines(dbm_lines) for dbm_line in dbm_lines: painter.drawLine(dbm_line) # TODO: Removed to support old (<1.0) PySide API in Ubuntu 10.10 #painter.drawLines(frequency_lines) for frequency_line in frequency_lines: painter.drawLine(frequency_line) painter.setPen(Qt.white) for dbm, point in dbm_labels: painter.drawText(point, '%+.0f' % dbm) for frequency, point in frequency_labels: painter.drawText(point, '%.0f' % (frequency / 1e6)) finally: painter.end()
def __init__(self, parent): super(QNEConnection, self).__init__(parent) self.setPen(QPen(Qt.black, 2)) self.setBrush(QBrush(Qt.NoBrush)) self.setZValue(-1) self.m_port1 = None self.m_port2 = None self.pos1 = QPointF() self.pos2 = QPointF()
def gripEdit(self, before, after): """ TOWRITE :param `before`: TOWRITE :type `before`: `QPointF`_ :param `after`: TOWRITE :type `after`: `QPointF`_ """ if before == self.scenePos(): delta = QPointF(after-before) self.moveBy(delta.x(), delta.y())
def updatePath(self): path = QPainterPath() path.moveTo(self.pos1) dx = self.pos2.x() - self.pos1.x() dy = self.pos2.y() - self.pos1.y() ctr1 = QPointF(self.pos1.x() + dx * 0.25, self.pos1.y() + dy * 0.1) ctr2 = QPointF(self.pos1.x() + dx * 0.75, self.pos1.y() + dy * 0.9) path.cubicTo(ctr1, ctr2, self.pos2) self.setPath(path)
def gripEdit(self, before, after): """ TOWRITE :param `before`: TOWRITE :type `before`: `QPointF`_ :param `after`: TOWRITE :type `after`: `QPointF`_ """ if before == self.scenePos(): delta = QPointF(after - before) self.moveBy(delta.x(), delta.y())
def middle_points(self): ''' Compute connection intermediate points - redefined function ''' # Make sure the connection does not overlap the comment item if (self.child.on_the_right or (not self.child.on_the_right and self.child.x() + self.child.boundingRect().width() < self.parentItem().boundingRect().width())): go_to_point = self.start_point.x() + 5 else: go_to_point = self.end_point.x() + 5 yield QPointF(go_to_point, self.start_point.y()) yield QPointF(go_to_point, self.end_point.y())
def shape(self): bound = QPainterPath() rotMatrix = QTransform().rotate(self.angle) poly = QPolygonF([ QPointF(0, 0), QPointF(self.w, 0), QPointF(self.w, self.h), QPointF(0, self.h), ]) poly = rotMatrix.map(poly) bound.addPolygon(poly) return bound
def end_point(self): ''' Compute connection end point - redefined function ''' # Arrow always bumps at the screen edge try: view = self.scene().views()[0] view_pos = view.mapToScene( view.viewport().geometry()).boundingRect().topLeft() scene_pos_x = self.mapFromScene(view_pos).x() return QPointF(scene_pos_x, self.start_point.y()) except (IndexError, AttributeError): # In case there is no view (e.g. Export PNG from cmd line) return QPointF(self.start_point.x() - 250, self.start_point.y())
def __readDiagramInfo(self, diagramNode): dinfo = treenode.DiagramInfo() # read diagram info: if diagramNode is None: return dinfo, -1 if diagramNode.hasAttribute('uid'): uid = int(diagramNode.getAttribute('uid')) else: uid = -1 if diagramNode.hasAttribute('expanded'): val = diagramNode.getAttribute('expanded').lower() if val in ('yes', '1', 'true'): dinfo.expanded = True else: dinfo.expanded = False if diagramNode.hasAttribute('hAuto'): val = diagramNode.getAttribute('hAuto').lower() if val in ('yes', '1', 'true'): dinfo.autopositioning[DisplayRegime.Horizontal].autopos = True else: dinfo.autopositioning[DisplayRegime.Horizontal].autopos = False if diagramNode.hasAttribute('vAuto'): val = diagramNode.getAttribute('vAuto').lower() if val in ('yes', '1', 'true'): dinfo.autopositioning[DisplayRegime.Vertical].autopos = True else: dinfo.autopositioning[DisplayRegime.Vertical].autopos = False hShift = QPointF() if diagramNode.hasAttribute('hx'): hShift.setX(float(diagramNode.getAttribute('hx'))) if diagramNode.hasAttribute('hy'): hShift.setY(float(diagramNode.getAttribute('hy'))) dinfo.autopositioning[DisplayRegime.Horizontal].shift = hShift vShift = QPointF() if diagramNode.hasAttribute('vx'): vShift.setX(float(diagramNode.getAttribute('vx'))) if diagramNode.hasAttribute('vy'): vShift.setY(float(diagramNode.getAttribute('vy'))) dinfo.autopositioning[DisplayRegime.Vertical].shift = vShift if diagramNode.hasAttribute('sceneX'): dinfo.scenePos.setX(float(diagramNode.getAttribute('sceneX'))) if diagramNode.hasAttribute('sceneY'): dinfo.scenePos.setY(float(diagramNode.getAttribute('sceneY'))) return dinfo, uid
def paintEvent(self, event): painter = QPainter(self) painter.setBrush(self.brush) painter.setPen(self.pen) painter.setRenderHint(QPainter.Antialiasing) rect = self.geometry() from_point = QPointF(0, rect.height() / 2) to_point = QPointF(rect.width(), rect.height() / 2) # from_point = QPointF(0, 0) # to_point = QPointF(rect.width(), rect.height()) # noinspection PyProtectedMember ClassyEdge._draw_arrow(painter, from_point, to_point, 10)
def gripEdit(self, before, after): """ TOWRITE :param `before`: TOWRITE :type `before`: `QPointF`_ :param `after`: TOWRITE :type `after`: `QPointF`_ """ if before == self.objectCenter(): delta = QPointF(after - before) self.moveBy(delta.x(), delta.y()) else: self.setObjectRadius(QLineF(self.objectCenter(), after).length())
def gripEdit(self, before, after): """ TOWRITE :param `before`: TOWRITE :type `before`: `QPointF`_ :param `after`: TOWRITE :type `after`: `QPointF`_ """ if before == self.objectCenter(): delta = QPointF(after-before) self.moveBy(delta.x(), delta.y()) else: self.setObjectRadius(QLineF(self.objectCenter(), after).length())
def testsquareToQuad(self): q1 = QPolygonF() q1.append(QPointF(10.0, 10.0)) q1.append(QPointF(20.0, 10.0)) q1.append(QPointF(10.0, -10.0)) q1.append(QPointF(20.0, -10.0)) t1 = QTransform() r1 = QTransform.squareToQuad(q1, t1) r2 = QTransform.squareToQuad(q1) self.assertTrue(r1) self.assert_(r2) self.assertEqual(t1, r2)
def __init__(self, parent): super(QNEConnection, self).__init__(parent) self.normalPen = QPen(QApplication.palette().text().color(), 2) self.selectedPen = QPen(QApplication.palette().text().color(), 2, Qt.DashLine) self.setPen(self.normalPen) self.setBrush(QBrush(Qt.NoBrush)) self.setZValue(-1) self.setFlag(QGraphicsItem.ItemIsSelectable) self.m_port1 = None self.m_port2 = None self.pos1 = QPointF() self.pos2 = QPointF()
def gripEdit(self, before, after): """ TOWRITE :param `before`: TOWRITE :type `before`: `QPointF`_ :param `after`: TOWRITE :type `after`: `QPointF`_ """ if before == self.objectEndPoint1(): self.setObjectEndPoint1(after) elif before == self.objectEndPoint2(): self.setObjectEndPoint2(after) elif before == self.objectMidPoint(): delta = QPointF(after - before) self.moveBy(delta.x(), delta.y())
def __init__(self, x, y, w, h, key_size=50, parent=None): super(KeyboardEditorScene, self).__init__(x, y, w, h, parent=parent) self.dragStartPos = None self.selectedItem = None self.dragItemStartPos = None self.zIncrementer = 0 self.dragging = False self.dragBoxRect = DragBox(QPointF(0.0, 0.0), QPointF(0.0, 0.0)) self.dragBoxRect.hide() self.dragBoxRect.setZValue(5000000) self.addItem(self.dragBoxRect) self.gridActive = True self.keySize = key_size self.snapSize = 0.125
def gripEdit(self, before, after): """ TOWRITE :param `before`: TOWRITE :type `before`: `QPointF`_ :param `after`: TOWRITE :type `after`: `QPointF`_ """ if before == self.objectEndPoint1(): self.setObjectEndPoint1(after) elif before == self.objectEndPoint2(): self.setObjectEndPoint2(after) elif before == self.objectMidPoint(): delta = QPointF(after-before) self.moveBy(delta.x(), delta.y())
def __init__(self, manager): QGraphicsGeoMap.__init__(self, manager) self.coordQueryState = False self.panActive = False self.kineticTimer = QTimer() self.lastCircle = None self.lastMoveTime = None self.kineticPanSpeed = None self.panDecellerate = True self.remainingPan = QPointF() self.mouseHistory = deque([MouseHistoryEntry() for i in range(5)]) self.kineticTimer.timeout.connect(self.kineticTimerEvent) self.kineticTimer.setInterval(KINETIC_PANNING_RESOLUTION)
def removePoints(self, listp): print("Remove Points") print("--------------------------------------------------------") print("Entran", len(listp), "polilineas") ####################################################################### poligon_list = [] for poliline in listp: qp = QPolygonF() for p in poliline: qp.append(QPointF(p.x, p.z)) poligon_list.append(qp) print("Hay ", len(poligon_list), "poligonos") resulting_list = recursiP(poligon_list) polylines = [] for element in resulting_list: polyline = [] for pnt in element: punto = SNGPoint2D() punto.x = pnt.x() punto.z = pnt.y() polyline.append(punto) polylines.append(polyline) print("Salen", len(polylines), "polilineas") print("--------------------------------------------------------") return polylines
def __init__(self, mw, parent=None): """ Default class constructor. :param `mw`: Pointer to a application main window instance. :type `mw`: `MainWindow`_ :param `parent`: Pointer to a parent widget instance. :type `parent`: `QWidget`_ """ super(MdiArea, self).__init__(parent) self.mainWin = mw self.gSpiralsImgPath = mw.gImgDir + os.sep + 'texture-spirals.png' self.gLogoSpiralsImgPath = mw.gImgDir + os.sep + 'logo-spirals.png' try: #if QT_VERSION >= 0x040800 self.setTabsClosable(True) except AttributeError: pass self.useLogo = False self.useTexture = False self.useColor = False self.bgLogo = QPixmap() self.bgTexture = QPixmap(self.gSpiralsImgPath) self.bgColor = QColor() self.bgLogo = QPixmap(self.gLogoSpiralsImgPath) # Brushes self.colorBrush = QBrush(QColor(EMBROIDERBLUE1)) self.backgroundBrush = QBrush(QPixmap(self.gSpiralsImgPath)) linearGrad = QLinearGradient(QPointF(0, 0), QPointF(400, 400)) linearGrad.setColorAt(0, QColor(EMBROIDERBLUE1)) linearGrad.setColorAt(1, QColor(EMBROIDERBLUE2)) self.gradientBrush = QBrush(linearGrad) self.setHorizontalScrollBarPolicy(Qt.ScrollBarAsNeeded) self.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded) self.setActivationOrder(QMdiArea.ActivationHistoryOrder) self.setFocusPolicy(Qt.WheelFocus) self.setFocus() self.setAcceptDrops(True) self.doSetDocumentMode(True)
def paint(self, painter, option, widget=None): """@reimp @public virtual void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = 0) """ #Q_UNUSED(option) #Q_UNUSED(widget) d = self.__d key = d.hash pm = QPixmap() if not QPixmapCache.find(key, pm): # Set up a convenient path path = QPainterPath() path.setFillRule(Qt.OddEvenFill) path.addEllipse(QPointF(d.actualOuterRadius, d.actualOuterRadius), d.actualOuterRadius, d.actualOuterRadius) path.addEllipse(QPointF(d.actualOuterRadius, d.actualOuterRadius), d.actualInnerRadius, d.actualInnerRadius) nActualDiameter = 2.0 * d.actualOuterRadius pm = QPixmap(nActualDiameter, nActualDiameter) pm.fill(Qt.transparent) p = QPainter(pm) # Draw the ring background p.setPen(Qt.NoPen) p.setBrush(d.backgroundColor) p.setRenderHint(QPainter.Antialiasing) p.drawPath(path) # Draw the ring foreground # TODO: Expose this gradient as Qml Property gradient = QConicalGradient(d.actualOuterRadius, d.actualOuterRadius, 0.0) gradient.setColorAt(0.0, Qt.transparent) gradient.setColorAt(0.05, d.foregroundColor) gradient.setColorAt(0.8, Qt.transparent) p.setBrush(gradient) p.drawPath(path) p.end() QPixmapCache.insert(key, pm) # Draw pixmap at center of item w, h = self.width(), self.height() sz = min(w, h) painter.drawPixmap(0.5 * (w - sz), 0.5 * (h - sz), pm)
def _translate(self, p): """ Take floating point, screen coordinates as {'x':x, 'y':y} Return integer, scene coordinates as QPointF(x,y) """ # We want to return floating point coords but mapFromGlobal only works with integers # So, simply truncate, mapFromGlobal, and add the decimal part back xf, xint = math.modf(p['x']) yf, yint = math.modf(p['y']) # Multi-monitor support: # The coords from the tracker are relative to the screen. Add the global offset of this screen. globalCoords = QPoint(xint, yint) + self._desktopWidget.screenGeometry(self.tracker.get('screenindex')).topLeft() # Get widget coordinates, and add back the decimal parts wCoords = QPointF(self.mapFromGlobal(globalCoords)) return self.mapToScene(wCoords.toPoint()) + QPointF(xf, yf)
def objectQuadrant270(self): """ TOWRITE :return: TOWRITE :rtype: `QPointF`_ """ return self.objectCenter() + QPointF(0, self.objectRadius())
def end_point(self): ''' Compute connection end point - redefined function ''' # Arrow always bumps at the screen edge view = self.scene().views()[0] view_pos = view.mapToScene( view.viewport().geometry()).boundingRect().topLeft() scene_pos_x = self.mapFromScene(view_pos).x() return QPointF(scene_pos_x, self.start_point.y())
def itemAt(self, position): items = self.scene.items(QRectF( position - QPointF(2,2) , QSizeF(4,4) )) for item in items: if item.type() > QGraphicsItem.UserType: return item return None
def setPosition(self, position): """ Position is in values between 0 and 1. """ margins = self.boundedItem._margins rect = self.boundedItem.boundingRect() width = rect.width() - (margins.left() + margins.right() + 1) height = rect.height() - (margins.top() + margins.bottom() + 1) actualX = margins.left() + position[0] * width actualY = margins.top() + (1.0 - position[1]) * height actualPosition = QPointF() actualPosition.setX(actualX) actualPosition.setY(actualY) self.setPos(actualPosition)
def __init__(self): global has_midi self.mrotation = 0 self.mtranslate = QPointF(0.0,0.0) self.mscale = QPointF(1.0,1.0) self.dof = -2.0 self.epx = 0.5 self.ppx = 0.6 self.ppy = 0.0 self.loadFile() super(Example, self).__init__() if has_midi: self.midi = pypm.Input(0) self.timer = QtCore.QTimer(self); self.timer.timeout.connect(self.timerEvent) self.timer.start(100) self.initUI()
def setPos(self, position): """ @overrides(NodeItem) """ margins = self.boundedItem._margins rect = self.boundedItem.rect() width = rect.width() - (margins.left() + margins.right() + 1) height = rect.height() - (margins.top() + margins.bottom() + 1) boundedX = max(position.x(), margins.left()) boundedX = min(boundedX, margins.left() + width) boundedY = max(position.y(), margins.top()) boundedY = min(boundedY, margins.top() + height) boundedPosition = QPointF() boundedPosition.setX(boundedX) boundedPosition.setY(boundedY) super(TransferFunctionNodeItem, self).setPos(boundedPosition)
def mousePressEvent(self, event): self.setFocus() if event.button() == Qt.LeftButton: if event.modifiers() & Qt.ControlModifier: pass else: if self.coordQueryState: self.coordQueryResult.emit(self.screenPositionToCoordinate(event.lastPos())) return self.panActive = True self.kineticTimer.stop() self.kineticPanSpeed = QPointF() self.lastMoveTime = QTime.currentTime() event.accept()
class Example(QtGui.QWidget): def __init__(self): global has_midi self.mrotation = 0 self.mtranslate = QPointF(0.0,0.0) self.mscale = QPointF(1.0,1.0) self.dof = -2.0 self.epx = 0.5 self.ppx = 0.6 self.ppy = 0.0 self.loadFile() super(Example, self).__init__() if has_midi: self.midi = pypm.Input(0) self.timer = QtCore.QTimer(self); self.timer.timeout.connect(self.timerEvent) self.timer.start(100) self.initUI() def loadFile(self): try: json_data=open('json_data.txt') variables = json.load(json_data) json_data.close() self.mrotation = variables['mrotation'] self.mtranslate.setX(variables['mtranslatex']) self.mtranslate.setY(variables['mtranslatey']) self.mscale.setX(variables['mscalex']) self.mscale.setY(variables['mscaley']) self.dof = variables['dof'] self.epx = variables['epx'] self.ppx = variables['ppx'] self.ppy = variables['ppy'] except: print "Could not load file" def saveFile(self): data = {} data['mrotation'] = self.mrotation data['mtranslatex'] = self.mtranslate.x() data['mtranslatey'] = self.mtranslate.y() data['mscalex'] = self.mscale.x() data['mscaley'] = self.mscale.y() data['dof'] = self.dof data['epx'] = self.epx data['ppx'] = self.ppx data['ppy'] = self.ppy try: json_data=open('json_data.txt', 'w') json_data.write(json.dumps(data)) json_data.close() except: print "Could not save file" def initUI(self): self.setGeometry(300, 300, 500, 500) self.setWindowTitle('Transform test') self.show() def timerEvent(self): gotpkg = False while True: pkg = self.midi.Read(1) if pkg: gotpkg = True data, counter = pkg[0] bank, instrument, value, val2 = data if instrument==2: self.mrotation = int(value*2.83) if instrument==3: self.mscale.setX(value/75.0) if(self.mscale.x()==0.0): self.mscale.setX(0.001) if instrument==4: self.mscale.setY((value/127.0)**1.25) if(self.mscale.y()==0.0): self.mscale.setY(0.001) if instrument==15: self.mtranslate.setX((value/32.0)-2.0) if instrument==16: self.mtranslate.setY((value/32.0)-2.0) if instrument==5: self.epx = (value/20.0)-1.75 if instrument==17: self.dof = value/-32.0 if(self.dof==0.0): self.dof = 0.001 if instrument==6: self.ppx = (value/20.0)-1.75 if instrument==18: self.ppy = value/-32.0 if(self.ppy==0.0): self.ppy = 0.001 print bank,instrument,value, int(value*7.88) else: break if gotpkg: self.repaint() def paintEvent(self, event): #mtx = self.mtx mtx = QTransform() mtx.rotate(self.mrotation) mtx.scale(self.mscale.x(), self.mscale.y()) mtx.translate(self.mtranslate.x(), self.mtranslate.y()) eyepos = QPointF(self.epx, self.dof) ppoi = QPointF(self.ppx, self.ppy) point = QRectF(0.0,0.0,0.05,0.05); tpoi = mtx.map(ppoi) teyepos = mtx.map(eyepos) evec = QVector2D(tpoi - teyepos).normalized() pts = find_points(float2(tpoi.x(),tpoi.y()), float2(evec.x(), evec.y())) print pts qp = QtGui.QPainter() qp.begin(self) qp.scale(self.width()/5.0,self.height()/5.0) qp.translate(2.5,2.5) #draw voxel bounds qp.drawRect(QRectF(0.0,0.0,1.0,1.0)) #qp.transform(mtx) #draw eyepos point.moveTo(mtx.map(eyepos)) qp.fillRect(point, QColor("black")) point.moveTo(mtx.map(ppoi)) qp.fillRect(point, QColor("grey")) qp.setPen(QColor("cyan")) qp.drawLine(mtx.map(QLineF(-0.5,0.0,1.5,0.0))) qp.setPen(QColor("blue")) qp.drawLine(mtx.map(QLineF(-0.0,0.0,1.0,0.0))) qp.setPen(QColor("lime")) qp.drawLine(QLineF(eyepos,ppoi)) qp.setPen(QColor("green")) qp.drawLine(QLineF(teyepos,tpoi)) qp.setPen(QColor("orange")) qp.drawLine(QLineF(pts['x'],pts['y'],pts['z'], pts['w'])) point.moveTo(QPointF(pts['x'],pts['y'])) qp.fillRect(point, QColor("red")) point.moveTo(QPointF(pts['z'],pts['w'])) qp.fillRect(point, QColor("pink")) qp.end() def drawText(self, event, qp): qp.setPen(QtGui.QColor(168, 34, 3)) qp.setFont(QtGui.QFont('Decorative', 10)) qp.drawText(event.rect(), QtCore.Qt.AlignCenter, self.text)
class MapWidget(QGraphicsGeoMap): coordQueryResult = Signal(QGeoCoordinate) def __init__(self, manager): QGraphicsGeoMap.__init__(self, manager) self.coordQueryState = False self.panActive = False self.kineticTimer = QTimer() self.lastCircle = None self.lastMoveTime = None self.kineticPanSpeed = None self.panDecellerate = True self.remainingPan = QPointF() self.mouseHistory = deque([MouseHistoryEntry() for i in range(5)]) self.kineticTimer.timeout.connect(self.kineticTimerEvent) self.kineticTimer.setInterval(KINETIC_PANNING_RESOLUTION) def setMouseClickCoordQuery(self, state): self.coordQueryState = state def mousePressEvent(self, event): self.setFocus() if event.button() == Qt.LeftButton: if event.modifiers() & Qt.ControlModifier: pass else: if self.coordQueryState: self.coordQueryResult.emit(self.screenPositionToCoordinate(event.lastPos())) return self.panActive = True self.kineticTimer.stop() self.kineticPanSpeed = QPointF() self.lastMoveTime = QTime.currentTime() event.accept() def mouseReleaseEvent(self, event): if event.button() == Qt.LeftButton: if self.panActive: self.panActive = False if not ENABLE_KINETIC_PANNING or self.lastMoveTime.msecsTo(QTime.currentTime()) > HOLD_TIME_THRESHOLD: return self.kineticPanSpeed = QPointF() entriesConsidered = 0 currentTime = QTime.currentTime() for entry in self.mouseHistory: if not entry.time: continue if entry.time.msecsTo(currentTime) < HOLD_TIME_THRESHOLD: self.kineticPanSpeed += entry.position entriesConsidered += 1 if entriesConsidered > 0: self.kineticPanSpeed /= entriesConsidered self.lastMoveTime = currentTime self.kineticTimer.start() self.panDecellerate = True event.accept() def mouseMoveEvent(self, event): if event.modifiers() & Qt.ControlModifier: if self.lastCircle: self.lastCircle.setCenter(self.screenPositionToCoordinate(event.pos())) elif self.panActive: currentTime = QTime.currentTime() deltaTime = self.lastMoveTime.msecsTo(currentTime) delta = event.lastPos() - event.pos() if deltaTime > 0: self.kineticPanSpeed = delta / deltaTime self.mouseHistory.popleft() self.mouseHistory.append(MouseHistoryEntry(self.kineticPanSpeed, currentTime)) self.panFloatWrapper(delta) event.accept() def kineticTimerEvent(self): currentTime = QTime.currentTime() deltaTime = self.lastMoveTime.msecsTo(currentTime) self.lastMoveTime = currentTime if self.panDecellerate: self.kineticPanSpeed *= pow(0.5, float(deltaTime / KINETIC_PANNING_HALFLIFE)) scaledSpeed = self.kineticPanSpeed * deltaTime if self.kineticPanSpeed.manhattanLength() < KINETIC_PAN_SPEED_THRESHOLD: self.kineticTimer.stop() return self.panFloatWrapper(scaledSpeed) def panFloatWrapper(self, delta): self.remainingPan += delta move = self.remainingPan.toPoint() self.pan(move.x(), move.y()) self.remainingPan -= move def mouseDoubleClickEvent(self, event): self.setFocus() self.pan(event.lastPos().x() - self.size().width() / 2.0, event.lastPos().y() - self.size().height() / 2.0) if self.zoomLevel() < self.maximumZoomLevel(): self.setZoomLevel(self.zoomLevel() + 1) event.accept() def keyPressEvent(self, event): if event.key() == Qt.Key_Minus: if self.zoomLevel() > self.minimumZoomLevel(): self.setZoomLevel(self.zoomLevel() - 1) elif event.key() == Qt.Key_Plus: if self.zoomLevel() < self.maximumZoomLevel(): self.setZoomLevel(self.zoomLevel() + 1) elif event.key() == Qt.Key_T: if self.mapType() == QGraphicsGeoMap.StreetMap: self.setMapType(QGraphicsGeoMap.SatelliteMapDay) elif self.mapType() == QGraphicsGeoMap.SatelliteMapDay: self.setMapType(QGraphicsGeoMap.StreetMap) event.accept() def wheelEvent(self, event): if event.delta() > 0: if self.zoomLevel() < self.maximumZoomLevel(): self.setZoomLevel(self.zoomLevel() + 1) else: if self.zoomLevel() > self.minimumZoomLevel(): self.setZoomLevel(self.zoomLevel() - 1) event.accept()
def __init__(self, scene): ''' Initialize the game ''' self.scene = scene scene.scene_left.connect(self.quit_scene) self.rocket = Rocket() self.width = self.scene.sceneRect().width() self.height = self.scene.sceneRect().height() self.screen_bottom = self.height - self.rocket.boundingRect().height() scene.addItem(self.rocket) # Compute random land points random.seed() p1 = QPointF(0.0, random.uniform(0.0, self.height)) p2 = QPointF(random.uniform(0.0, self.width / 4.0), random.uniform(0.0, self.height)) p3 = QPointF(random.uniform(p2.x(), 2 * self.width / 3.0), self.height) p4 = QPointF(p3.x() + 40.0, self.height) p5 = QPointF(self.width, random.uniform(0.0, self.height)) path = QPainterPath(p1) slope = (p2.y() - p1.y()) / (p2.x() - p1.x()) sign = 3 for point in range(int((p2.x() - p1.x()) / 5)): sign = -sign x = p1.x() + point * 5 path.lineTo(x, slope * x + sign) path.lineTo(p2) path.lineTo(p3) path.lineTo(p4) path.lineTo(p5) scene.addPath(path) # Initialize the music try: self.music = phonon.Phonon.createPlayer( phonon.Phonon.MusicCategory, phonon.Phonon.MediaSource(':/lander.mp3')) except NameError: LOG.warning('Could not initialise phonon') # Initialize the animation for the translation of the rocket self.animation = QtCore.QPropertyAnimation(self.rocket, "position") self.rocket_position = None # Initialize the animation for the rotation of the rocket self.rotation = QtCore.QPropertyAnimation(self.rocket, "angle") # Catch the key events to add user interaction: self.scene.keyPressEvent = lambda x: self.key(x) # updateCurrentTime is called by Qt when time changes self.animation.updateCurrentTime = lambda x: self.time_progress(x) # Connect signal sent at end of animation self.animation.finished.connect(self.animation_finished)
class QNEConnection(QGraphicsPathItem): (Type) = (QGraphicsItem.UserType +2) def __init__(self, parent): super(QNEConnection, self).__init__(parent) self.normalPen = QPen(QApplication.palette().text().color(), 2) self.selectedPen = QPen(QApplication.palette().text().color(), 2, Qt.DashLine) self.setPen(self.normalPen) self.setBrush(QBrush(Qt.NoBrush)) self.setZValue(-1) self.setFlag(QGraphicsItem.ItemIsSelectable) self.m_port1 = None self.m_port2 = None self.pos1 = QPointF() self.pos2 = QPointF() def __del__(self): #print("Del QNEConnection") pass def delete(self): if self.m_port1: self.m_port1.removeConnection(self) if self.m_port2: self.m_port2.removeConnection(self) if self.scene(): self.scene().removeItem(self) self.m_port1 = None self.m_port2 = None def paint(self, painter, option, widget): if self.isSelected(): painter.setPen(self.selectedPen) else: painter.setPen(self.normalPen) painter.drawPath(self.path()) def setPos1(self, pos): self.pos1 = pos def setPos2(self, pos): self.pos2 = pos def setPort1(self, port): self.m_port1 = port self.m_port1.addConnection(self) def setPort2(self, port): self.m_port2 = port self.m_port2.addConnection(self) def updatePosFromPorts(self): self.pos1 = self.m_port1.scenePos()+QPointF(self.m_port1.radius(),0) self.pos2 = self.m_port2.scenePos()+QPointF(self.m_port2.radius(),0) def updatePath(self): path = QPainterPath() path.moveTo(self.pos1) dx = self.pos2.x() - self.pos1.x() dy = self.pos2.y() - self.pos1.y() ctr1 = QPointF(self.pos1.x() + dx * 0.25, self.pos1.y() + dy * 0.1) ctr2 = QPointF(self.pos1.x() + dx * 0.75, self.pos1.y() + dy * 0.9) path.cubicTo(ctr1, ctr2, self.pos2) self.setPath(path) def type(self): return self.Type def port1(self): return self.m_port1 def port2(self): return self.m_port2
class QNEConnection(QGraphicsPathItem): (Type) = (QGraphicsItem.UserType +2) def __init__(self, parent): super(QNEConnection, self).__init__(parent) self.setPen(QPen(Qt.black, 2)) self.setBrush(QBrush(Qt.NoBrush)) self.setZValue(-1) self.m_port1 = None self.m_port2 = None self.pos1 = QPointF() self.pos2 = QPointF() def __del__(self): #print("Del QNEConnection") pass def delete(self): if self.m_port1: self.m_port1.removeConnection(self) if self.m_port2: self.m_port2.removeConnection(self) self.m_port1 = None self.m_port2 = None self.scene().removeItem(self) def setPos1(self, pos): self.pos1 = pos def setPos2(self, pos): self.pos2 = pos def setPort1(self, port): self.m_port1 = port self.m_port1.addConnection(self) def setPort2(self, port): self.m_port2 = port self.m_port2.addConnection(self) def updatePosFromPorts(self): self.pos1 = self.m_port1.scenePos() self.pos2 = self.m_port2.scenePos() def updatePath(self): path = QPainterPath() path.moveTo(self.pos1) dx = self.pos2.x() - self.pos1.x() dy = self.pos2.y() - self.pos1.y() ctr1 = QPointF(self.pos1.x() + dx * 0.25, self.pos1.y() + dy * 0.1) ctr2 = QPointF(self.pos1.x() + dx * 0.75, self.pos1.y() + dy * 0.9) path.cubicTo(ctr1, ctr2, self.pos2) self.setPath(path) def type(self): return self.Type def port1(self): return self.m_port1 def port2(self): return self.m_port2
def testQPointFToTuple(self): p = QPointF(1, 2) self.assertEqual((1, 2), p.toTuple())
def updateRubber(self, painter): """ TOWRITE :param `painter`: TOWRITE :type `painter`: `QPainter`_ """ rubberMode = self.objectRubberMode() # int if rubberMode == OBJ_RUBBER_ELLIPSE_LINE: sceneLinePoint1 = self.objectRubberPoint("ELLIPSE_LINE_POINT1") # QPointF sceneLinePoint2 = self.objectRubberPoint("ELLIPSE_LINE_POINT2") # QPointF itemLinePoint1 = self.mapFromScene(sceneLinePoint1) # QPointF itemLinePoint2 = self.mapFromScene(sceneLinePoint2) # QPointF itemLine = QLineF(itemLinePoint1, itemLinePoint2) if painter: self.drawRubberLine(itemLine, painter, VIEW_COLOR_CROSSHAIR) self.updatePath() elif rubberMode == OBJ_RUBBER_ELLIPSE_MAJORDIAMETER_MINORRADIUS: sceneAxis1Point1 = self.objectRubberPoint("ELLIPSE_AXIS1_POINT1") # QPointF sceneAxis1Point2 = self.objectRubberPoint("ELLIPSE_AXIS1_POINT2") # QPointF sceneCenterPoint = self.objectRubberPoint("ELLIPSE_CENTER") # QPointF sceneAxis2Point2 = self.objectRubberPoint("ELLIPSE_AXIS2_POINT2") # QPointF ellipseWidth = self.objectRubberPoint("ELLIPSE_WIDTH").x() # qreal ellipseRot = self.objectRubberPoint("ELLIPSE_ROT").x() # qreal # TODO: incorporate perpendicularDistance() into libcgeometry px = sceneAxis2Point2.x() # qreal py = sceneAxis2Point2.y() # qreal x1 = sceneAxis1Point1.x() # qreal y1 = sceneAxis1Point1.y() # qreal line = QLineF(sceneAxis1Point1, sceneAxis1Point2) norm = line.normalVector() # QLineF dx = px - x1 # qreal dy = py - y1 # qreal norm.translate(dx, dy) iPoint = QPointF() norm.intersect(line, iPoint) ellipseHeight = QLineF(px, py, iPoint.x(), iPoint.y()).length() * 2.0 # qreal self.setObjectCenter(sceneCenterPoint) self.setObjectSize(ellipseWidth, ellipseHeight) self.setRotation(-ellipseRot) itemCenterPoint = self.mapFromScene(sceneCenterPoint) # QPointF itemAxis2Point2 = self.mapFromScene(sceneAxis2Point2) # QPointF itemLine = QLineF(itemCenterPoint, itemAxis2Point2) if painter: self.drawRubberLine(itemLine, painter, VIEW_COLOR_CROSSHAIR) self.updatePath() elif rubberMode == OBJ_RUBBER_ELLIPSE_MAJORRADIUS_MINORRADIUS: sceneAxis1Point2 = self.objectRubberPoint("ELLIPSE_AXIS1_POINT2") # QPointF sceneCenterPoint = self.objectRubberPoint("ELLIPSE_CENTER") # QPointF sceneAxis2Point2 = self.objectRubberPoint("ELLIPSE_AXIS2_POINT2") # QPointF ellipseWidth = self.objectRubberPoint("ELLIPSE_WIDTH").x() # qreal ellipseRot = self.objectRubberPoint("ELLIPSE_ROT").x() # qreal # TODO: incorporate perpendicularDistance() into libcgeometry px = sceneAxis2Point2.x() # qreal py = sceneAxis2Point2.y() # qreal x1 = sceneCenterPoint.x() # qreal y1 = sceneCenterPoint.y() # qreal line = QLineF(sceneCenterPoint, sceneAxis1Point2) norm = line.normalVector() # QLineF dx = px - x1 # qreal dy = py - y1 # qreal norm.translate(dx, dy) iPoint = QPointF() norm.intersect(line, iPoint) ellipseHeight = QLineF(px, py, iPoint.x(), iPoint.y()).length() * 2.0 # qreal self.setObjectCenter(sceneCenterPoint) self.setObjectSize(ellipseWidth, ellipseHeight) self.setRotation(-ellipseRot) itemCenterPoint = self.mapFromScene(sceneCenterPoint) # QPointF itemAxis2Point2 = self.mapFromScene(sceneAxis2Point2) # QPointF itemLine = QLineF(itemCenterPoint, itemAxis2Point2) if painter: self.drawRubberLine(itemLine, painter, VIEW_COLOR_CROSSHAIR) self.updatePath() elif rubberMode == OBJ_RUBBER_GRIP: pass # TODO: updateRubber() gripping for EllipseObject
def gripEdit(self, before, after): """ TOWRITE :param `before`: TOWRITE :type `before`: `QPointF`_ :param `after`: TOWRITE :type `after`: `QPointF`_ """ delta = QPointF(after-before) if before == self.objectTopLeft(): self.setObjectRect(after.x(), after.y(), self.objectWidth() - delta.x(), self.objectHeight() - delta.y()) elif before == self.objectTopRight(): self.setObjectRect(self.objectTopLeft().x(), self.objectTopLeft().y() + delta.y(), self.objectWidth() + delta.x(), self.objectHeight() - delta.y()) elif before == self.objectBottomLeft(): self.setObjectRect(self.objectTopLeft().x() + delta.x(), self.objectTopLeft().y(), self.objectWidth() - delta.x(), self.objectHeight() + delta.y()) elif before == self.objectBottomRight(): self.setObjectRect(self.objectTopLeft().x(), self.objectTopLeft().y(), self.objectWidth() + delta.x(), self.objectHeight() + delta.y())
class ArcObject(BaseObject): """ Subclass of `BaseObject`_ TOWRITE """ Type = OBJ_TYPE_ARC def __init__(self, startX, startY, midX, midY, endX, endY, rgb, parent=None): #OVERLOADED IMPL?# ArcObject::ArcObject(ArcObject* obj, QGraphicsItem* parent) : BaseObject(parent) """ Default class constructor. :param `startX`: TOWRITE :type `startX`: qreal :param `startY`: TOWRITE :type `startY`: qreal :param `midX`: TOWRITE :type `midX`: qreal :param `midY`: TOWRITE :type `midY`: qreal :param `endX`: TOWRITE :type `endX`: qreal :param `endY`: TOWRITE :type `endY`: qreal :param `rgb`: TOWRITE :type `rgb`: QRgb :param `parent`: TOWRITE :type `parent`: `QGraphicsItem`_ """ super(ArcObject, self).__init__(parent) qDebug("ArcObject Constructor()") self.arcStartPoint = QPointF() self.arcMidPoint = QPointF() self.arcEndPoint = QPointF() self.init(startX, startY, midX, midY, endX, endY, rgb, Qt.SolidLine) # TODO: getCurrentLineType #OVERLOADED IMPL?# if obj: #OVERLOADED IMPL?# self.init(obj.objectStartX(), obj.objectStartY(), obj.objectMidX(), obj.objectMidY(), obj.objectEndX(), obj.objectEndY(), obj.objectColorRGB(), Qt.SolidLine) # TODO: getCurrentLineType #OVERLOADED IMPL?# self.setRotation(obj.rotation()) def __del__(self): """Class destructor.""" qDebug("ArcObject Destructor()") def init(self, startX, startY, midX, midY, endX, endY, rgb, lineType): """ TOWRITE :param `startX`: TOWRITE :type `startX`: qreal :param `startY`: TOWRITE :type `startY`: qreal :param `midX`: TOWRITE :type `midX`: qreal :param `midY`: TOWRITE :type `midY`: qreal :param `endX`: TOWRITE :type `endX`: qreal :param `endY`: TOWRITE :type `endY`: qreal :param `rgb`: TOWRITE :type `rgb`: QRgb :param `lineType`: TOWRITE :type `lineType`: Qt.PenStyle """ self.setData(OBJ_TYPE, self.type()) self.setData(OBJ_NAME, OBJ_NAME_ARC) # WARNING: DO NOT enable QGraphicsItem::ItemIsMovable. If it is enabled, # WARNING: and the item is double clicked, the scene will erratically move the item while zooming. # WARNING: All movement has to be handled explicitly by us, not by the scene. self.setFlag(QGraphicsItem.ItemIsSelectable, True) self.calculateArcData(startX, startY, midX, midY, endX, endY) self.setObjectColorRGB(rgb) self.setObjectLineType(lineType) self.setObjectLineWeight(0.35) # TODO: pass in proper lineweight self.setPen(self.objectPen()) def calculateArcData(self, startX, startY, midX, midY, endX, endY): """ TOWRITE :param `startX`: TOWRITE :type `startX`: qreal :param `startY`: TOWRITE :type `startY`: qreal :param `midX`: TOWRITE :type `midX`: qreal :param `midY`: TOWRITE :type `midY`: qreal :param `endX`: TOWRITE :type `endX`: qreal :param `endY`: TOWRITE :type `endY`: qreal """ #TODO/PORT# double centerX; #TODO/PORT# double centerY; #TODO/PORT# getArcCenter(startX, startY, #TODO/PORT# midX, midY, #TODO/PORT# endX, endY, #TODO/PORT# ¢erX, ¢erY); self.arcStartPoint = QPointF(startX - centerX, startY - centerY) self.arcMidPoint = QPointF(midX - centerX, midY - centerY) self.arcEndPoint = QPointF(endX - centerX, endY - centerY) self.setPos(centerX, centerY) radius = QLineF(centerX, centerY, midX, midY).length() # qreal self.updateArcRect(radius) self.updatePath() self.setRotation(0) self.setScale(1) def updateArcRect(self, radius): """ TOWRITE :param `radius`: TOWRITE :type `radius`: qreal """ arcRect = QRectF() arcRect.setWidth(radius * 2.0) arcRect.setHeight(radius * 2.0) arcRect.moveCenter(QPointF(0, 0)) self.setRect(arcRect) # pythonic setObjectCenter overload @signature(QPointF) def setObjectCenterFromPoint(self, point): """ TOWRITE :param `point`: TOWRITE :type `point`: `QPointF`_ """ self.setObjectCenter(point.x(), point.y()) # pythonic setObjectCenter overload @signature(float, float) def setObjectCenterFromXY(self, pointX, pointY): """ TOWRITE :param `pointX`: TOWRITE :type `pointX`: qreal :param `pointY`: TOWRITE :type `pointY`: qreal """ self.setPos(pointX, pointY) @overloaded(setObjectCenterFromPoint, setObjectCenterFromXY) def setObjectCenter(self, *args): """ TOWRITE """ pass def setObjectCenterX(self, pointX): """ TOWRITE :param `pointX`: TOWRITE :type `pointX`: qreal """ self.setX(pointX) def setObjectCenterY(self, pointY): """ TOWRITE :param `pointY`: TOWRITE :type `pointY`: qreal """ self.setY(pointY) def setObjectRadius(self, radius): """ TOWRITE :param `radius`: TOWRITE :type `radius`: qreal """ # qreal rad; if radius <= 0: rad = 0.0000001 else: rad = radius center = self.scenePos() # QPointF startLine = QLineF(center, self.objectStartPoint()) # QLineF midLine = QLineF(center, self.objectMidPoint()) # QLineF endLine = QLineF(center, self.objectEndPoint()) # QLineF startLine.setLength(rad) midLine.setLength(rad) endLine.setLength(rad) self.arcStartPoint = arcStartPoint = startLine.p2() self.arcMidPoint = arcMidPoint = midLine.p2() self.arcEndPoint = arcEndPoint = endLine.p2() self.calculateArcData(arcStartPoint.x(), arcStartPoint.y(), arcMidPoint.x(), arcMidPoint.y(), arcEndPoint.x(), arcEndPoint.y()) def setObjectStartAngle(self, angle): """ TOWRITE :param `angle`: TOWRITE :type `angle`: qreal """ pass # TODO: ArcObject setObjectStartAngle def setObjectEndAngle(self, angle): """ TOWRITE :param `angle`: TOWRITE :type `angle`: qreal """ pass # TODO: ArcObject setObjectEndAngle # pythonic setObjectStartPoint overload @signature(QPointF) def setObjectStartPointFromPoint(self, point): """ TOWRITE :param `point`: TOWRITE :type `point`: `QPointF`_ """ self.setObjectStartPoint(point.x(), point.y()) # pythonic setObjectStartPoint overload @signature(float, float) def setObjectStartPointFromXY(self, pointX, pointY): """ TOWRITE :param `pointX`: TOWRITE :type `pointX`: qreal :param `pointY`: TOWRITE :type `pointY`: qreal """ arcMidPoint = self.arcMidPoint arcEndPoint = self.arcEndPoint self.calculateArcData(pointX, pointY, arcMidPoint.x(), arcMidPoint.y(), arcEndPoint.x(), arcEndPoint.y()) @overloaded(setObjectStartPointFromPoint, setObjectStartPointFromXY) def setObjectStartPoint(self, *args): """ TOWRITE """ pass # pythonic setObjectMidPoint overload @signature(QPointF) def setObjectMidPointFromPoint(self, point): """ TOWRITE :param `point`: TOWRITE :type `point`: `QPointF`_ """ self.setObjectMidPoint(point.x(), point.y()) # pythonic setObjectMidPoint overload @signature(float, float) def setObjectMidPointFromXY(self, pointX, pointY): """ TOWRITE :param `pointX`: TOWRITE :type `pointX`: qreal :param `pointY`: TOWRITE :type `pointY`: qreal """ arcStartPoint = self.arcStartPoint arcEndPoint = self.arcEndPoint self.calculateArcData(arcStartPoint.x(), arcStartPoint.y(), pointX, pointY, arcEndPoint.x(), arcEndPoint.y()) @overloaded(setObjectMidPointFromPoint, setObjectMidPointFromXY) def setObjectMidPoint(self, *args): """ TOWRITE """ pass # pythonic setObjectEndPoint overload @signature(QPointF) def setObjectEndPointFromPoint(self, point): """ TOWRITE :param `point`: TOWRITE :type `point`: `QPointF`_ """ self.setObjectEndPoint(point.x(), point.y()) # pythonic setObjectEndPoint overload @signature(float, float) def setObjectEndPointFromXY(self, pointX, pointY): """ TOWRITE :param `pointX`: TOWRITE :type `pointX`: qreal :param `pointY`: TOWRITE :type `pointY`: qreal """ arcStartPoint = self.arcStartPoint arcMidPoint = self.arcMidPoint self.calculateArcData(arcStartPoint.x(), arcStartPoint.y(), arcMidPoint.x(), arcMidPoint.y(), pointX, pointY) @overloaded(setObjectEndPointFromPoint, setObjectEndPointFromXY) def setObjectEndPoint(self, *args): """ TOWRITE """ pass def objectStartAngle(self): """ TOWRITE :rtype: qreal """ angle = QLineF(self.scenePos(), self.objectStartPoint()).angle() # qreal while angle >= 360.0: angle -= 360.0 while angle < 0.0: angle += 360.0 return angle def objectEndAngle(self): """ TOWRITE :rtype: qreal """ angle = QLineF(self.scenePos(), self.objectEndPoint()).angle() # qreal while angle >= 360.0: angle -= 360.0 while angle < 0.0: angle += 360.0 return angle def objectStartPoint(self): """ TOWRITE :rtype: `QPointF`_ """ rot = radians(self.rotation()) # qreal cosRot = qCos(rot) # qreal sinRot = qSin(rot) # qreal x = self.arcStartPoint.x() * self.scale() # qreal y = self.arcStartPoint.y() * self.scale() # qreal rotX = x * cosRot - y*sinRot # qreal rotY = x * sinRot + y*cosRot # qreal return (self.scenePos() + QPointF(rotX, rotY)) def objectStartX(self): """ TOWRITE :rtype: qreal """ return self.objectStartPoint().x() def objectStartY(self): """ TOWRITE :rtype: qreal """ return self.objectStartPoint().y() def objectMidPoint(self): """ TOWRITE :rtype: `QPointF`_ """ rot = radians(self.rotation()) # qreal cosRot = qCos(rot) # qreal sinRot = qSin(rot) # qreal x = self.arcMidPoint.x() * self.scale() # qreal y = self.arcMidPoint.y() * self.scale() # qreal rotX = x * cosRot - y * sinRot # qreal rotY = x * sinRot + y * cosRot # qreal return (self.scenePos() + QPointF(rotX, rotY)) def objectMidX(self): """ TOWRITE :rtype: qreal """ return self.objectMidPoint().x() def objectMidY(self): """ TOWRITE :rtype: qreal """ return self.objectMidPoint().y() def objectEndPoint(self): """ TOWRITE :rtype: `QPointF`_ """ rot = radians(self.rotation()) # qreal cosRot = qCos(rot) # qreal sinRot = qSin(rot) # qreal x = self.arcEndPoint.x() * self.scale() # qreal y = self.arcEndPoint.y() * self.scale() # qreal rotX = x * cosRot - y * sinRot # qreal rotY = x * sinRot + y * cosRot # qreal return (self.scenePos() + QPointF(rotX, rotY)) def objectEndX(self): """ TOWRITE :rtype: qreal """ return self.objectEndPoint().x() def objectEndY(self): """ TOWRITE :rtype: qreal """ return self.objectEndPoint().y() def objectArea(self): """ TOWRITE :rtype: qreal """ # Area of a circular segment. r = self.objectRadius() # qreal theta = radians(self.objectIncludedAngle()) # qreal return ((r * r) / 2) * (theta - qSin(theta)) def objectArcLength(self): """ TOWRITE :rtype: qreal """ return radians(self.objectIncludedAngle()) * self.objectRadius() def objectChord(self): """ TOWRITE :rtype: qreal """ return QLineF(self.objectStartX(), self.objectStartY(), self.objectEndX(), self.objectEndY()).length() def objectIncludedAngle(self): """ TOWRITE :rtype: qreal """ chord = self.objectChord() # qreal rad = self.objectRadius() # qreal if chord <= 0 or rad <= 0: return 0 # Prevents division by zero and non-existant circles. # NOTE: Due to floating point rounding errors, we need to clamp the quotient so it is in the range [-1, 1] # If the quotient is out of that range, then the result of asin() will be NaN. quotient = chord / (2.0 * rad) # qreal if quotient > 1.0: quotient = 1.0 if quotient < 0.0: quotient = 0.0 # NOTE: 0 rather than -1 since we are enforcing a positive chord and radius return degrees(2.0 * asin(quotient)) # Properties of a Circle - Get the Included Angle - Reference: ASD9 def objectClockwise(self): """ TOWRITE :rtype: bool """ # NOTE: Y values are inverted here on purpose if self.isArcClockwise(self.objectStartX(), -self.objectStartY(), self.objectMidX(), -self.objectMidY(), self.objectEndX(), -self.objectEndY()): return True return False def updatePath(self): """ TOWRITE """ startAngle = (self.objectStartAngle() + self.rotation()) # qreal spanAngle = self.objectIncludedAngle() # qreal if self.objectClockwise(): spanAngle = -spanAngle path = QPainterPath() path.arcMoveTo(self.rect(), startAngle) path.arcTo(self.rect(), startAngle, spanAngle) # NOTE: Reverse the path so that the inside area isn't considered part of the arc path.arcTo(self.rect(), startAngle + spanAngle, -spanAngle) self.setObjectPath(path) def paint(self, painter, option, widget): """ TOWRITE :param `painter`: TOWRITE :type `painter`: `QPainter`_ :param `option`: TOWRITE :type `option`: `QStyleOptionGraphicsItem`_ :param `widget`: TOWRITE :type `widget`: `QWidget`_ """ objScene = self.scene() # QGraphicsScene* if not objScene: return paintPen = self.pen() # QPen painter.setPen(paintPen) self.updateRubber(painter) if option.state & QStyle.State_Selected: paintPen.setStyle(Qt.DashLine) if objScene.property(ENABLE_LWT): # .toBool() paintPen = self.lineWeightPen() painter.setPen(paintPen) startAngle = (self.objectStartAngle() + self.rotation()) * 16 # qreal spanAngle = self.objectIncludedAngle() * 16 # qreal if self.objectClockwise(): spanAngle = -spanAngle rad = self.objectRadius() # qreal paintRect = QRectF(-rad, -rad, rad * 2.0, rad * 2.0) painter.drawArc(paintRect, startAngle, spanAngle) def updateRubber(self, painter=None): """ TOWRITE :param `painter`: TOWRITE :type `painter`: `QPainter`_ """ # TODO: Arc Rubber Modes # TODO: updateRubber() gripping for ArcObject pass def vulcanize(self): """ TOWRITE """ qDebug("ArcObject vulcanize()") self.updateRubber() self.setObjectRubberMode(OBJ_RUBBER_OFF) def mouseSnapPoint(self, mousePoint): """ Returns the closest snap point to the mouse point. :param `mousePoint`: TOWRITE :type `mousePoint`: `QPointF`_ :rtype: `QPointF`_ """ center = self.objectCenter() # QPointF start = self.objectStartPoint() # QPointF mid = self.objectMidPoint() # QPointF end = self.objectEndPoint() # QPointF cntrDist = QLineF(mousePoint, center).length() # qreal startDist = QLineF(mousePoint, start).length() # qreal midDist = QLineF(mousePoint, mid).length() # qreal endDist = QLineF(mousePoint, end).length() # qreal minDist = qMin(qMin(cntrDist, startDist), qMin(midDist, endDist)) # qreal if minDist == cntrDist: return center elif minDist == startDist: return start elif minDist == midDist: return mid elif minDist == endDist: return end return self.scenePos() def allGripPoints(self): """ TOWRITE :rtype: QList<QPointF> """ # QList<QPointF> gripPoints; # gripPoints << objectCenter() << objectStartPoint() << objectMidPoint() << objectEndPoint(); gripPoints = list(self.objectCenter() + self.objectStartPoint() + self.objectMidPoint() + self.objectEndPoint()) return gripPoints def gripEdit(self, before, after): """ TOWRITE :param `before`: TOWRITE :type `before`: `QPointF`_ :param `after`: TOWRITE :type `after`: `QPointF`_ .. TODO:: gripEdit() for ArcObject """ pass # TODO: gripEdit() for ArcObject def objectCenter(self): """ TOWRITE :return: TOWRITE :rtype: `QPointF`_ """ return self.scenePos() def objectCenterX(self): """ TOWRITE :return: TOWRITE :rtype: float """ return self.scenePos().x() def objectCenterY(self): """ TOWRITE :return: TOWRITE :rtype: float """ return self.scenePos().y() def objectRadius(self): """ TOWRITE :return: TOWRITE :rtype: float """ return self.rect().width() / 2.0 * self.scale()