def __create_parts(self):
"""Create circles and rectangle."""
dir_vec = QtGui.QVector2D(self.__end.x() - self.__begin.x(),
self.__end.y() - self.__begin.y())
dir_vec.normalize()
norm_vec = QtGui.QVector2D(-dir_vec.y(), dir_vec.x())
vecs = [
QtGui.QVector2D(self.__begin) + self.__radius * norm_vec,
QtGui.QVector2D(self.__end) + self.__radius * norm_vec,
QtGui.QVector2D(self.__end) - self.__radius * norm_vec,
QtGui.QVector2D(self.__begin) - self.__radius * norm_vec,
]
self.__polygon = QtWidgets.QGraphicsPolygonItem(
QtGui.QPolygonF([QtCore.QPointF(vec.x(), vec.y())
for vec in vecs]))
self.__ellipse_1 = QtWidgets.QGraphicsEllipseItem(
self.__begin.x() - self.__radius,
self.__begin.y() - self.__radius, 2 * self.__radius,
2 * self.__radius)
self.__ellipse_2 = QtWidgets.QGraphicsEllipseItem(
self.__end.x() - self.__radius,
self.__end.y() - self.__radius, 2 * self.__radius,
2 * self.__radius)
for item in (self.__ellipse_1, self.__ellipse_2, self.__polygon):
item.setPen(self.__pen)
item.setBrush(self.__brush)
def __init__(self, size, value):
super().__init__()
#Count the amount of hitsplat timer cycles before splat is removed
self.counter = 0
self.background = QtWidgets.QGraphicsEllipseItem(0, 0, size, size)
if value == 0:
brush = QtGui.QBrush(QtGui.QColor(0, 0, 255))
else:
brush = QtGui.QBrush(QtGui.QColor(255, 0, 0))
self.background.setBrush(brush)
self.addToGroup(self.background)
#Hitsplat displays damage value
self.text_item = QtWidgets.QGraphicsTextItem("-" + str(value))
#Hitsplat clolor based on damage
if value < 10:
self.text_item.setPos(6, 0)
else:
self.text_item.setPos(2, 0)
self.text_item.setDefaultTextColor(QtGui.QColor(255, 255, 255))
font = QtGui.QFont()
font.setPixelSize(16)
font.setBold(True)
self.text_item.setFont(font)
self.addToGroup(self.text_item)
def shoot(self, rightKey):
if self.projectile == None:
self.projectile = QtWidgets.QGraphicsEllipseItem(
self.x(), self.y(), 20, 20)
self.projectile.setBrush(self.projectile_brush)
self.temp_x = self.x()
self.projectile_rKey = rightKey
def mousePressEvent(self, event):
self.begin = self.end = event.scenePos()
self.item = self.itemAt(self.begin, QtGui.QTransform())
if self.item:
if self.tool == 'erase':
self.removeItem(self.item)
elif self.tool == "move":
self.offset = self.begin - self.item.pos()
elif self.tool == 'rectangle':
self.rect = QtWidgets.QGraphicsRectItem(self.begin.x(),
self.begin.y(), 0, 0)
elif self.tool == 'ellipse':
self.ellipse = QtWidgets.QGraphicsEllipseItem(
self.begin.x(), self.begin.y(), 0, 0)
elif self.tool == 'line':
self.line = QtWidgets.QGraphicsLineItem(self.begin.x(),
self.begin.y(),
self.end.x(), self.end.y())
elif self.tool == 'polygon':
c = event.scenePos()
self.polyRects.append(
QtWidgets.QGraphicsRectItem(c.x() - 10,
c.y() - 10, 20, 20))
self.addItem(self.polyRects[-1])
self.polygon.append(c)
def __init__(self, port, graph, hOffset, color, connectionPointType):
super(PortCircle, self).__init__(port)
self.__port = port
self._graph = graph
self._connectionPointType = connectionPointType
self.__connections = set()
self._supportsOnlySingleConnections = connectionPointType == 'In'
self.setSizePolicy(
QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Fixed,
QtWidgets.QSizePolicy.Fixed))
size = QtCore.QSizeF(self.__diameter, self.__diameter)
self.setPreferredSize(size)
self.setWindowFrameMargins(0, 0, 0, 0)
self.transform().translate(self.__radius * hOffset, 0)
self.__defaultPen = QtGui.QPen(QtGui.QColor("#000000"), 1.0)
self.__hoverPen = QtGui.QPen(QtGui.QColor("#000000"), 1.5)
self._ellipseItem = QtWidgets.QGraphicsEllipseItem(self)
self._ellipseItem.setPen(self.__defaultPen)
self._ellipseItem.setPos(size.width() / 2, size.height() / 2)
self._ellipseItem.setRect(
-self.__radius,
-self.__radius,
self.__diameter,
self.__diameter,
)
self.setColor(color)
self.setAcceptHoverEvents(True)
def setupScene(self):
self.scene = QtWidgets.QGraphicsScene()
self.viewwidget.setScene(self.scene)
self.cursor = QtWidgets.QGraphicsItemGroup()
self.cursor.setZValue(100)
circle = QtWidgets.QGraphicsEllipseItem(self.cursor)
circle.setRect(-5, -5, 10, 10)
circle.setBrush(QtGui.QBrush(QtCore.Qt.red))
circle.setFlag(QtWidgets.QGraphicsItem.ItemIgnoresTransformations,
True)
self.scene.addItem(self.cursor)
def onMouseMoveEvent(event):
position = QtCore.QPointF(event.scenePos())
self.xwidget.setText(str(position.x()))
self.ywidget.setText(str(position.y()))
origin = relative_position_default_origin
self.latwidget.setText(
str(round(origin[0] + position.y() / (6371000 * deg), 6)))
self.lonwidget.setText(
str(
round(
origin[1] + position.x() /
math.cos(deg * origin[0] + position.y() / 6371000) /
(6371000 * deg), 6)))
QtWidgets.QGraphicsScene.mouseMoveEvent(
self.scene, event) # propagate to objects in scene
self.scene.mouseMoveEvent = onMouseMoveEvent
def process_circle(self):
x = np.array([
self._mouse_pos[0, 0], self._mouse_pos[1, 0],
self._mouse_pos[2, 0], self._mouse_pos[3, 0]
])
y = np.array([
self._mouse_pos[0, 1], self._mouse_pos[1, 1],
self._mouse_pos[2, 1], self._mouse_pos[3, 1]
])
circle = find_circle_from_points(x, y)
self._circle = [int(circle[0]), int(circle[1]), int(circle[2])]
Ellipse = QtWidgets.QGraphicsEllipseItem(0, 0, self._circle[2] * 2,
self._circle[2] * 2)
#ellipse will be green
pen = QtGui.QPen(QtCore.Qt.green)
Ellipse.setPen(pen)
#if I want to fill the ellipse i should do this:
#brush = QtGui.QBrush(QtCore.Qt.green)
#Ellipse.setPen(brush)
#this is the position of the top-left corner of the ellipse.......
Ellipse.setPos(circle[0] - self._circle[2],
circle[1] - self._circle[2])
Ellipse.setTransform(QtGui.QTransform())
self._scene.addItem(Ellipse)
def drawEllipse(self, x, y, w, h):
ellipse = QtWidgets.QGraphicsEllipseItem(x, y, w - 1, h - 1)
transform = QtGui.QTransform()
transform.translate(-(w - 1) / 2, -(h - 1) / 2)
ellipse.setTransform(transform)
ellipse.setBrush(QtCore.Qt.black)
self.addItem(ellipse)
def piechart(self, pben, plben, ppat, plpat, punc, poth):
# cria elemento de cena para o gráfico de pizza
cena = QtWidgets.QGraphicsScene()
# define vetor com os valores das porcentagens
# 'Benígno', 'Provavelmente benígno', 'Patogênico', 'Provavelmente patogênico', 'Incerto'
valores = [pben, plben, ppat, plpat, punc, poth]
total = sum(valores)
# define as cores (verde, verde leve, vermelho, vermelho leve, cinza)
cores = list(
map(QColor, [
'#33cc33', '#70db70', '#ff3300', '#ff704d', '#669999',
'#8c8c8c'
]))
# parâmetros para definir a elipse
angulo_i = 0
contador = 0
# desenha cada fatia da elipse
for v in valores:
# Max span is 5760, so we have to calculate corresponding span angle
angulo = round(float(v * 5760) / total)
elipse = QtWidgets.QGraphicsEllipseItem(0, 0, 200, 200)
elipse.setPos(0, 0)
elipse.setStartAngle(angulo_i)
elipse.setSpanAngle(angulo)
elipse.setBrush(cores[contador])
angulo_i += angulo
contador += 1
cena.addItem(elipse)
return cena
def initLayout(self):
self.boxCornerItems = []
for i in range(8):
corner = QtWidgets.QGraphicsEllipseItem()
corner.setRect(-4, -4, 8, 8)
corner.setZValue(2.0)
pen = corner.pen()
pen.setWidth(1)
if i < 4:
pen.setColor(QtGui.QColor(0, 0, 255))
corner.setPen(pen)
corner.setBrush(QtGui.QBrush(QtGui.QColor(0, 0, 255)))
else:
pen.setColor(QtGui.QColor(0, 255, 0))
corner.setPen(pen)
corner.setBrush(QtGui.QBrush(QtGui.QColor(0, 255, 0)))
self.graphicsScene.addItem(corner)
self.boxCornerItems.append(corner)
self.boxLineItems = []
for i in range(12):
line = QtWidgets.QGraphicsLineItem()
pen = line.pen()
pen.setWidth(3)
if i < 4:
pen.setColor(QtGui.QColor(0, 0, 255))
elif i < 8:
pen.setColor(QtGui.QColor(0, 255, 0))
else:
pen.setColor(QtGui.QColor(255, 0, 0))
line.setPen(pen)
line.setZValue(2.0 - float(i) / 12.0)
self.graphicsScene.addItem(line)
self.boxLineItems.append(line)
self.updateLayout()
def mouseMoveEvent(self, event):
# print("Scene.mouseMoveEvent()")
self.end = event.scenePos()
width = self.end.x() - self.begin.x()
height = self.end.y() - self.begin.y()
if self.item and self.tool == "move":
self.item.setPos(event.scenePos() - self.offset)
if self.tool == 'rectangle':
self.removeItem(self.rect)
self.rect = QtWidgets.QGraphicsRectItem(self.begin.x(),
self.begin.y(), width,
height)
self.rect.setPen(self.pen)
self.rect.setBrush(self.brush)
self.addItem(self.rect)
elif self.tool == 'ellipse':
self.removeItem(self.ellipse)
self.ellipse = QtWidgets.QGraphicsEllipseItem(
self.begin.x(), self.begin.y(), width, height)
self.ellipse.setPen(self.pen)
self.ellipse.setBrush(self.brush)
self.addItem(self.ellipse)
elif self.tool == 'line':
self.removeItem(self.line)
self.line = QtWidgets.QGraphicsLineItem(self.begin.x(),
self.begin.y(),
self.end.x(), self.end.y())
self.line.setPen(self.pen)
self.addItem(self.line)
def plot(self):
""" create grafiks group item with all grafik pyqt elements of the player """
self.item_group = QtWidgets.QGraphicsItemGroup()
#for i in range(1,len(self._line_list)):
# # -> mulitplay pos with line with -> move to upper field corner
# p1 = self._line_list[i-1]
# p2 = self._line_list[i]
# l = QtWidgets.QGraphicsLineItem()
# l.setLine(p1.x()*self.magnification,p1.y()*self.magnification,p2.x()*self.magnification,p2.y()*self.magnification)
# l.setPen(self.pen)
# self.item_group.addToGroup(l)
for l in self._line_list:
ql = l.get_q_line_item()
ql.setPen(self.pen)
self.item_group.addToGroup(ql)
for i in range(0,len(self._point_list)):
# -> mulitplay pos with line with -> move to upper field corner
p = self._point_list[i]
l = QtWidgets.QGraphicsEllipseItem()
l.setRect((p.x()-0.5)*self.magnification,(p.y()-0.5)*self.magnification,self.magnification,self.magnification)
#l.setLine(p1.x()*self.magnification,p1.y()*self.magnification,p2.x()*self.magnification,p2.y()*self.magnification)
#l.setPen(self.pen)
l.setBrush(QtGui.QColor(255,0,0))
self.item_group.addToGroup(l)
return self.item_group
def build_sector_of_scanning(self):
self.scanning_shape = QtWidgets.QGraphicsEllipseItem(
-self.lidar_maximum_distance, -self.lidar_maximum_distance,
2 * self.lidar_maximum_distance, 2 * self.lidar_maximum_distance,
self.carrier_item)
self.scanning_shape.setStartAngle(-self.lidars_half_angle * 16)
self.scanning_shape.setSpanAngle(2 * self.lidars_half_angle * 16)
def _InitUI(self):
self.setFiltersChildEvents(False)
oFrom = QtWidgets.QGraphicsEllipseItem()
oTo = QtWidgets.QGraphicsRectItem()
oLine = QtWidgets.QGraphicsLineItem()
self.setFlags(QGraphicsItem.ItemIsSelectable | QGraphicsItem.ItemIsMovable)
pen = oFrom.pen()
pen.setWidth(2)
pen.setColor(QColor(0, 160, 230))
oFrom.setPen(pen)
oTo.setPen(pen)
oLine.setPen(pen)
oFrom.setBrush(QColor(247, 160, 57))
oTo.setBrush(QColor(247, 160, 57))
self.addToGroup(oFrom)
self.addToGroup(oTo)
self.addToGroup(oLine)
length = 50
oFrom.setRect(QRectF(-length/2, -length/2, length, length))
oTo.setRect(QRectF(-length/2, -length/2, length, length))
oFrom.setPos(80, 80)
oTo.setPos(200, 150)
oLine.setLine(QLineF(oFrom.pos(), oTo.pos()))
def __init__(self, id: str = None, other: CanvasVertex = None):
if other:
self._copy_constructor(other)
else:
self.id = id
QtWidgets.QGraphicsItem.__init__(self)
self.placed = False
self.vertex_width = 10.
self.vertex_height = 10.
self.vertex_text_gap = 3.
self.vertex_ellipse_rect = QtCore.QRectF(-self.vertex_width / 2.,
-self.vertex_height / 2,
self.vertex_width,
self.vertex_height)
self.ellipse_default_brush = QtGui.QBrush(QtCore.Qt.black)
self.ellipse_selected_brush = QtGui.QBrush(QtCore.Qt.red)
self.ellipse = QtWidgets.QGraphicsEllipseItem(self.vertex_ellipse_rect,
self)
self.ellipse.setBrush(self.ellipse_default_brush)
self.text = QtWidgets.QGraphicsTextItem(self.getId(), self)
# self.text.setTextInteractionFlags(QtCore.Qt.TextEditable)
# self.text.document().contentsChanged.connect(self.changeIdFromText)
self.positionText()
def draw_origin(self):
pen = qg.QPen(qg.QColor('#e533e5'), 2)
pen.setCosmetic(True) # changes width depending on zoom
pen.setJoinStyle(qc.Qt.RoundJoin)
length = self.scene.itemsBoundingRect().width() / 16
diameter = length / 10
origin_item = qw.QGraphicsItemGroup()
circle = qw.QGraphicsEllipseItem(
qc.QRectF(-diameter / 2, -diameter / 2, diameter, diameter))
circle.setPen(pen)
circle.setEnabled(False)
origin_item.addToGroup(circle)
x_line = qw.QGraphicsLineItem(
0,
0,
length,
0,
)
x_line.setPen(pen)
origin_item.addToGroup(x_line)
y_line = qw.QGraphicsLineItem(0, 0, 0, length)
y_line.setPen(pen)
origin_item.addToGroup(y_line)
origin_item.setEnabled(False)
origin_item.setZValue(-1)
self.scene_origin = origin_item
self.scene.addItem(self.scene_origin)
def add_center(self, stain):
center = QtWidgets.QGraphicsEllipseItem(stain.position[0],
stain.position[1], 1, 1)
pen = QtGui.QPen(QtCore.Qt.white)
pen.setWidth(3)
center.setPen(pen)
return center
def draw(self, p):
it = QtWidgets.QGraphicsEllipseItem(0, 0, 10, 10)
it.setPen(QtGui.QPen(QtCore.Qt.blue, 3, QtCore.Qt.SolidLine))
it.setBrush(QBrush(Qt.blue, Qt.SolidPattern))
self.scene.addItem(it)
it.setPos(p)
self.items.append(it)
self.item_dict[it] = [p.__pos__().x(), p.__pos__().y()]
def draw_point_coord(self, x, y, width, color):
coor_point = QtCore.QRectF(x - width / 2, y - width / 2, width, width)
ellipse = QtWidgets.QGraphicsEllipseItem(coor_point)
ellipse.setBrush(QtGui.QBrush(color))
setHighlight(ellipse, self)
self.scene.addItem(ellipse)
ellipse.setZValue(1)
return ellipse
def __init__(self, radius, model, color=QtGui.QColor("black")):
super().__init__()
self.radius = radius
self.item = QtWidgets.QGraphicsEllipseItem(
QtCore.QRectF(-1 * radius, -1 * radius, 2 * radius, 2 * radius))
self.item.setBrush(color)
self.model = model
self._set_pos(QtCore.QPointF(model.x, model.y))
def drawACircle(self, centerX, centerY, Radius, brush=None, pen=None):
ellipse = qtw.QGraphicsEllipseItem(centerX - Radius, centerY - Radius,
2 * Radius, 2 * Radius)
if pen is not None:
ellipse.setPen(pen)
if brush is not None:
ellipse.setBrush(brush)
self.scene.addItem(ellipse)
def draw_dots(self, dot_list):
"""Draws the dots at the given positions"""
for dot in dot_list:
self.scene.addItem(
QtWidgets.QGraphicsEllipseItem(
dot.pos_x-self.dot_size/2,
-dot.pos_y-self.dot_size/2,
self.dot_size,
self.dot_size))
def loadStatistic(self, flag):
self.text = []
self.nbr = []
self.scene = []
repeated = get().repeatedVisitors(
self.dateEditFrom.date().toString('yyyy-MM-dd'),
self.dateEditTo.date().toString('yyyy-MM-dd'))
dwell = get().dwellTime(
self.dateEditFrom.date().toString('yyyy-MM-dd'),
self.dateEditTo.date().toString('yyyy-MM-dd'))
if flag:
self.correlation = get().correlation()
self.forecasting = get().forecasting()
data = [[self.AnalyticsGraphics, repeated],
[self.PresenceGraphics, dwell],
[self.CorrelationGraphics, self.correlation],
[self.ForecastingGraphics, self.forecasting]]
colours = []
palette = [
0x24A14D, 0xEB9E3E, 0xCE3B3E, 0x3576BE, 0x389FD3, 0x9548A9,
0x008080
]
for i in palette:
colours.append(QtGui.QColor(i))
for item in data:
start_angle = 0
count = 0
total = sum([item[1][x] for x in item[1]])
y = 10
self.scene.append(QtWidgets.QGraphicsScene())
self.scene[-1].setSceneRect(0, 0, 470, 300)
for elem in item[1]:
angle = round(float(item[1][elem] * 5760) / total)
ellipse = QtWidgets.QGraphicsEllipseItem(0, 0, 300, 300)
ellipse.setPos(0, 0)
ellipse.setStartAngle(start_angle)
ellipse.setSpanAngle(angle)
ellipse.setPen(QtGui.QColor(0xffffff))
ellipse.setBrush(colours[count])
start_angle += angle
self.scene[-1].addRect(
350, y, 40, 15, QtGui.QPen(QtGui.QColor(0xFFFFFF)),
QtGui.QBrush(QtGui.QColor(palette[count])))
self.text.append(QtWidgets.QGraphicsTextItem())
self.nbr.append(QtWidgets.QGraphicsTextItem())
self.text[-1].setPos(347, y + 15)
self.text[-1].setPlainText(elem)
self.nbr[-1].setPos(390, y - 3)
self.nbr[-1].setPlainText(str(item[1][elem]))
count += 1
y += 40
self.scene[-1].addItem(self.text[-1])
self.scene[-1].addItem(self.nbr[-1])
self.scene[-1].addItem(ellipse)
item[0].setScene(self.scene[-1])
def draw_pendulum(self, double_pendulum):
self.length1 = double_pendulum.pendulum1.length * 100
self.length2 = double_pendulum.pendulum2.length * 100
self.rect_width = 5
self.diameter = 20
self.outline = QtGui.QPen(QtCore.Qt.transparent)
self.brush1 = QtGui.QBrush(QtCore.Qt.green)
self.brush2 = QtGui.QBrush(QtCore.Qt.blue)
self.rect1 = QtWidgets.QGraphicsRectItem(-self.rect_width / 2, 0,
self.rect_width, self.length1)
self.rect1.setPen(self.outline)
self.rect1.setBrush(self.brush1)
self.rect1.setTransformOriginPoint(0, 0)
self.circle1 = QtWidgets.QGraphicsEllipseItem(
-self.diameter / 2, self.length1 - self.diameter / 2,
self.diameter, self.diameter, self.rect1)
self.circle1.setPen(self.outline)
self.circle1.setBrush(self.brush1)
self.rect2 = QtWidgets.QGraphicsRectItem(-self.rect_width / 2,
self.length1, self.rect_width,
self.length2, self.rect1)
self.rect2.setPen(self.outline)
self.rect2.setBrush(self.brush2)
self.rect2.setTransformOriginPoint(0, self.length1)
self.rect2.setFlag(QtWidgets.QGraphicsItem.ItemStacksBehindParent,
True)
self.circle2 = QtWidgets.QGraphicsEllipseItem(
-self.diameter / 2,
self.length1 + self.length2 - self.diameter / 2, self.diameter,
self.diameter, self.rect2)
self.circle2.setPen(self.outline)
self.circle2.setBrush(self.brush2)
self.rect1.setRotation(math.degrees(double_pendulum.pendulum1.theta))
self.rect2.setRotation(
math.degrees(double_pendulum.pendulum2.theta -
double_pendulum.pendulum1.theta))
self.scene.addItem(self.rect1)
def scene_with_undo_redo():
scene = Scene(0, 0, 512, 512)
undo_redo = UndoRedo(scene)
item_1 = QtWidgets.QGraphicsEllipseItem(0, 0, 100, 100)
item_2 = QtWidgets.QGraphicsLineItem(15, 20, 45, 120)
undo_redo.insert_in_undo_redo_add(item_1)
undo_redo.insert_in_undo_redo_add(item_2)
return ((item_1, item_2), scene, undo_redo)
def on_item_added(self, guid):
view1 = self.main_window.view1
model = self.main_window.model
print("item guid={0} added".format(guid))
item = model.items[guid]
x, y = item["pos"]
graphics_item = QtWidgets.QGraphicsEllipseItem(x, y, 60, 40)
item["graphics_item"] = graphics_item
view1.scene.addItem(graphics_item)
def __init__(self, parent, real_pos):
super().__init__(parent)
self.setEnabled(True)
self.setActive(True)
circle = QtWidgets.QGraphicsEllipseItem(self)
circle.setRect(-5, -5, 10, 10)
circle.setBrush(QtGui.QBrush(QtCore.Qt.yellow))
circle.setFlag(QtWidgets.QGraphicsItem.ItemIgnoresTransformations,
True)
self.real_pos = real_pos
def __init__(self, points):
super(Barlicity, self).__init__()
# set up the scene
scene = QtWidgets.QGraphicsScene(self)
view = QtWidgets.QGraphicsView(scene)
self.setCentralWidget(view)
self.resize(
Qt.QSize(
QtWidgets.QDesktopWidget().availableGeometry(
self).size().height() * 0.8,
QtWidgets.QDesktopWidget().availableGeometry(
self).size().height() * 0.8))
view.setSceneRect(QtCore.QRectF(0, 0, 1000, 1000))
# create and position the scanner circle
self.circle = QtWidgets.QGraphicsEllipseItem(
QtCore.QRectF(-50, -50, 100, 100))
self.circle.setOpacity(0.6)
self.circle.setBrush(Qt.QColor(0, 100, 255))
# these two variables are set from the scamp threads, and then they are read during the "do_frame" method (which
# operates in Qt land) and used to actually position the circle. GUI actions can only be on the main QT thread.
self.circle_center = (500, 500)
self.circle_width = scale_factor * (
WIDTH_AVERAGE + WIDTH_VARIATION * math.sin(WIDTH_START_PHASE))
# Having defined them, since we're on the Qt thread right now, we position the circle
self.circle.setPos(*self.circle_center)
self.circle.setRect(-self.circle_width / 2, -self.circle_width / 2,
self.circle_width, self.circle_width)
scene.addItem(self.circle)
# the scanner moves around between the different points; this keeps track of where it is
self.scanner_index = 0
# create all of the points
self.points_graphics = []
for i, point in enumerate(points):
self.points_graphics.append(
scene.addEllipse(Qt.QRectF(point[0] - 5, point[1] - 5, 10, 10),
brush=Qt.QColor(0, 0, 0)))
text = scene.addText(str(i))
text.setPos(point[0] - 25, point[1])
self.contained_points = []
# this checks which points are currently in the scanner and puts their indices in self.contained_points
self.check_contained_points()
# set up the Qt repaint to happen every 10 milliseconds by calling self.do_frame
self.repaint_timer = QtCore.QTimer(self)
self.repaint_timer.timeout.connect(self.do_frame)
self.repaint_timer.start(10)
self.repaint()
# These scamp objects are defined when the window is shown
self.session = self.piano = self.harpsichord = None
def __init__(self, x1, x2, y1, y2, lineThickness, grFaktor, parent=None):
QtWidgets.QGraphicsItemGroup.__init__(self)
self.parent = parent
correction = 0.85
rx = (x1 - x2)
ry = (y1 - y2)
nx = rx / max(sqrt(rx**2 + ry**2), 0.1)
ny = ry / max(sqrt(rx**2 + ry**2), 0.1)
mx1 = (
x1 + x2
) * 0.5 - ny * grFaktor * correction - 0.5 * nx * grFaktor * correction
my1 = (
y1 + y2
) * 0.5 + nx * grFaktor * correction - 0.5 * ny * grFaktor * correction
mx2 = (
x1 + x2
) * 0.5 + ny * grFaktor * correction - 0.5 * nx * grFaktor * correction
my2 = (
y1 + y2
) * 0.5 - nx * grFaktor * correction - 0.5 * ny * grFaktor * correction
mx3 = (
x1 + x2
) * 0.5 + ny * grFaktor * correction + 0.5 * nx * grFaktor * correction
my3 = (
y1 + y2
) * 0.5 - nx * grFaktor * correction + 0.5 * ny * grFaktor * correction
mx4 = (
x1 + x2
) * 0.5 - ny * grFaktor * correction + 0.5 * nx * grFaktor * correction
my4 = (
y1 + y2
) * 0.5 + nx * grFaktor * correction + 0.5 * ny * grFaktor * correction
circle = QtWidgets.QGraphicsEllipseItem((x1 + x2) * 0.5 - grFaktor,
(y1 + y2) * 0.5 - grFaktor,
2.0 * grFaktor,
2.0 * grFaktor,
parent=parent)
circle.setPen(
QtGui.QPen(QtGui.QColor(255, 0, 0, 255), lineThickness,
QtCore.Qt.SolidLine))
circle.setBrush(
QtGui.QBrush(QtGui.QColor(255, 255, 255, 255),
QtCore.Qt.SolidPattern))
line1 = QtWidgets.QGraphicsLineItem(mx1, my1, mx3, my3)
line1.setPen(
QtGui.QPen(QtGui.QColor(255, 0, 0, 255), lineThickness,
QtCore.Qt.SolidLine))
line2 = QtWidgets.QGraphicsLineItem(mx2, my2, mx4, my4)
line2.setPen(
QtGui.QPen(QtGui.QColor(255, 0, 0, 255), lineThickness,
QtCore.Qt.SolidLine))
self.addToGroup(circle)
self.addToGroup(line1)
self.addToGroup(line2)
def faireRond(self, x, y, r, coul, op):
rond = QtWidgets.QGraphicsEllipseItem(x, y, r, r)
rond.setFlag(QtWidgets.QGraphicsItem.ItemIsMovable)
rond.setOpacity(op)
rond.setBrush(QtGui.QBrush(coul))
rond.setPen(QtGui.QPen(QtCore.Qt.SolidLine))
rond.setZValue(self.id + 1)
rond.setScale(2)
self.scene.addItem(rond)
self.id += 1
#print(rond.zValue())
return rond
