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 __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 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 __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()
