def paint(self, painter, option, widget=None):
pen = QPen(QColor(0, 0, 0))
pen.setWidth(0)
red_pen = QPen(QColor(255, 0, 0))
red_pen.setWidth(0)
scale = 1
# lines
painter.setPen(pen)
if len(self.points) > 1:
painter.drawPolyline(QPolygonF(self.points))
# point mark
painter.setPen(pen)
if PolygonBase.mark_points:
scale = painter.transform().m11()
if len(self.points) > 0:
scale = painter.transform().m11()
painter.drawEllipse(self.points[0], L_SIZE / scale, L_SIZE / scale)
for point in self.points:
painter.drawEllipse(point, S_SIZE / scale, S_SIZE / scale)
# pre add
painter.setPen(red_pen)
if self.mouse_point is not None:
if len(self.points) > 0:
painter.drawLine(self.points[-1], self.mouse_point)
if PolygonBase.mark_points:
painter.drawEllipse(self.mouse_point, S_SIZE / scale, S_SIZE / scale)
def debug(self, painter):
#Paint path
painter.setBrush(QBrush(QColor(0, 0, 0, 25)))
pen = QPen(QColor(255, 0, 0, 100))
pen.setWidth(1)
painter.setPen(pen)
#Curve area
path = QPainterPath()
path.addPath(self.shape())
painter.drawPath(path)
#Curve controll points
painter.drawEllipse(self.curvePoint1, 2, 2)
painter.drawEllipse(self.curvePoint2, 2, 2)
#Draw area
painter.setPen(QPen(QColor(0, 255, 0, 100)))
painter.setBrush(QBrush(QColor(0, 0, 0, 15)))
path2 = QPainterPath()
rect = self.boundingRect()
path2.addRect(rect)
painter.drawPath(path2)
#Middel point
painter.setPen(QPen(QColor(0, 0, 255, 100)))
painter.drawEllipse(self.midPoint, 2, 2)
def add_color_scale(self):
x_init = self.position[0] + self.margin + self.width
y_init = self.position[1] + self.margin
square_size = 20
text_title = QGraphicsSimpleTextItem("clearance")
text_title.setPos(x_init, y_init - square_size)
self.addToGroup(text_title)
for i in range(10):
x = x_init
y = y_init + 9 * square_size - i * square_size
rect = QGraphicsRectItem(x, y, square_size, square_size)
pen = QPen()
pen.setWidth(0.01)
value = (float(i)/9 * (self.vertical_clearance_max - self.vertical_clearance_min)) + self.vertical_clearance_min
color = self.color_interpolation.get_interpolation_from_value(value)
brush = QBrush(color)
rect.setPen(pen)
rect.setBrush(brush)
self.addToGroup(rect)
if i == 0:
text_start = QGraphicsSimpleTextItem("%.2f m" % float(self.vertical_clearance_min))
text_start.setPos(x + square_size + 5, y)
self.addToGroup(text_start)
if i == 9:
text_end = QGraphicsSimpleTextItem("%.2f m" % float(self.vertical_clearance_max))
text_end.setPos(x + square_size + 5, y)
self.addToGroup(text_end)
else:
value = self.vertical_clearance_min + (self.vertical_clearance_max-self.vertical_clearance_min) * i/9
text = QGraphicsSimpleTextItem("%.2f m" % value)
text.setPos(x + square_size + 5, y)
self.addToGroup(text)
def drawPixmapFor3d(self):
self.pixmap3d = QPixmap(self.itemWidth, self.itemHeight)
self.pixmap3d.fill(Qt.transparent)
painter = QPainter()
painter.begin(self.pixmap3d)
painter.setRenderHint(QPainter.Antialiasing)
pen = QPen()
pen.setWidth(2)
painter.setPen(pen)
painter.setBrush(QBrush(QColor(220, 220, 220)))
top = [QPoint(5, 10),
QPoint(self.itemWidth - 10, 10),
QPoint(self.itemWidth - 5, 5),
QPoint(10, 5),
QPoint(5, 10)]
painter.drawConvexPolygon(*top)
left = [QPoint(self.itemWidth - 10, 10),
QPoint(self.itemWidth - 10, self.itemHeight - 5),
QPoint(self.itemWidth - 5, self.itemHeight - 10),
QPoint(self.itemWidth - 5, 5),
QPoint(self.itemWidth - 10, 10)]
painter.drawConvexPolygon(*left)
painter.setBrush(QBrush())
painter.drawRect(QRect(5, 10, self.itemWidth - 15, self.itemHeight - 15))
painter.drawText(QRect(5, 10, self.itemWidth - 15, self.itemHeight - 15), Qt.AlignCenter, '3D')
painter.end()
def updateCircle(self, s):
size = s * self.zoom
pixmap = QPixmap(self.width(), self.height())
pixmap.fill(Qt.transparent)
#painter ellipse 1
painter = QPainter()
painter.begin(pixmap)
painter.setRenderHint(QPainter.Antialiasing)
pen = QPen(Qt.red)
pen.setWidth(3)
painter.setPen(pen)
brush = QBrush(Qt.green)
painter.setBrush(brush)
painter.drawEllipse(QRect(old_div(self.width(),2) - old_div(size,2), old_div(self.height(),2) - old_div(size,2), size, size))
painter.end()
#painter ellipse 2
painter2 = QPainter()
painter2.begin(pixmap)
painter2.setRenderHint(QPainter.Antialiasing)
pen2 = QPen(Qt.green)
pen2.setStyle(Qt.DotLine)
pen2.setWidth(3)
painter2.setPen(pen2)
painter2.drawEllipse(QRect(old_div(self.width(),2) - old_div(size,2), old_div(self.height(),2) - old_div(size,2), size, size))
painter2.end()
self.ellipseLabel.setPixmap(QPixmap(pixmap))
self.lastSize = s
def _drawState(self, qp, xpos, width, data, hovering=False):
# Set pen and brush style
if hovering:
color = SignalLogWidget.SIGNAL_COLOR_HOVER
else:
color = SignalLogWidget.SIGNAL_COLOR
pen = QPen(color)
pen.setWidth(2)
brush = QBrush(color)
qp.setPen(pen)
qp.setBrush(brush)
size = self.size()
h = size.height()
# Draw datastripe when data contains tokens
if data == []:
qp.drawLine(xpos, h / 2, xpos + width, h / 2)
else:
qp.setPen(Qt.NoPen)
qp.drawRect(xpos, 2, width, h - 4)
pen.setColor(SignalLogWidget.TEXT_COLOR)
qp.setPen(pen)
rect = QRect(xpos + 3, 3, width - 3, h - 6)
qp.drawText(rect, Qt.AlignCenter, str(data)[1:-1])
def updateFilledCircle(self, s):
size = s * self.zoom
pixmap = QPixmap(self.width(), self.height())
pixmap.fill(Qt.transparent)
#painter filled ellipse
p = QPalette()
painter = QPainter()
painter.begin(pixmap)
painter.setRenderHint(QPainter.Antialiasing)
brush = QBrush(p.link().color())
painter.setBrush(brush)
painter.setOpacity(0.4)
painter.drawEllipse(QRect(old_div(self.width(),2) - old_div(size,2), old_div(self.height(),2) - old_div(size,2), size, size))
painter.end()
#painter ellipse 2
painter2 = QPainter()
painter2.begin(pixmap)
painter2.setRenderHint(QPainter.Antialiasing)
pen2 = QPen(Qt.green)
pen2.setWidth(1)
painter2.setPen(pen2)
painter2.drawEllipse(QRect(old_div(self.width(),2) - old_div(size,2), old_div(self.height(),2) - old_div(size,2), size, size))
painter2.end()
self.ellipseLabel.setPixmap(QPixmap(pixmap))
self.lastSize = s
def paint(self, painter, option, widget=None):
# init graphics
pen = QPen(QColor(0, 0, 0))
pen.setWidth(0)
pen.setStyle(Qt.DashDotLine)
redPen = QPen(QColor(255, 0, 0))
redPen.setWidth(0)
# current points
points = self.__apply_offset(self.points, self.offset)
if len(points) > 0:
# draw
painter.setPen(pen)
painter.drawPolyline(QPolygonF(points))
if PolygonBase.highlight_selection:
brush = QBrush(QColor(0, 0, 0, 64))
painter.fillRect(self.dots_rect, brush)
if PolygonBase.close_polygon:
painter.drawLine(points[-1], points[0])
scale = painter.transform().m11()
if PolygonBase.mark_points:
if len(points) > 0:
painter.drawEllipse(points[0], L_SIZE / scale, L_SIZE / scale)
for point in points:
painter.drawEllipse(point, S_SIZE / scale, S_SIZE / scale)
if self.point_id >= 0:
painter.setPen(redPen)
if len(points) > 0:
painter.drawEllipse(points[self.point_id], M_SIZE / scale, M_SIZE / scale)
def paintEvent(self, event):
# Check whether this orb is enhanced
if type(self.parent) == Board:
enh = self.parent.enhanced[self.position]
else:
enh = False
painter = QPainter(self)
painter.drawPixmap(event.rect().adjusted(2,2,-2,-2), self.pixmap())
w = event.rect().width()
if enh:
path = QPainterPath()
pen = QPen()
pen.setWidth(1);
pen.setBrush(Qt.white)
brush = QBrush(Qt.yellow)
font = QFont()
font.setPointSize(20)
font.setWeight(QFont.Black)
path.addText(event.rect().x()+w-15,event.rect().y()+w-5,font,'+')
painter.setPen(pen)
painter.setBrush(brush)
painter.setFont(font)
painter.drawPath(path)
def draw_indicator(indicator: int):
pixmap = QPixmap(24, 24)
painter = QPainter(pixmap)
w, h = pixmap.width(), pixmap.height()
painter.fillRect(0, 0, w, h, QBrush((QColor(0, 0, 200, 255))))
pen = QPen(QColor("white"))
pen.setWidth(2)
painter.setPen(pen)
font = util.get_monospace_font()
font.setBold(True)
font.setPixelSize(16)
painter.setFont(font)
f = QFontMetrics(painter.font())
indicator_str = str(indicator) if indicator < 10 else "+"
fw = f.width(indicator_str)
fh = f.height()
painter.drawText(math.ceil(w / 2 - fw / 2), math.ceil(h / 2 + fh / 4), indicator_str)
painter.end()
return QIcon(pixmap)
def __init__(self, map, *args):
super().__init__(*args)
self.map = map
self.position = map.center
self.providers = deque([
'osm', 'stamen-terrain', 'stamen-toner-lite', 'stamen-toner',
'stamen-watercolor', 'ms-aerial', 'ms-hybrid', 'ms-road',
'bluemarble',
])
self.refresh_map = asyncio.Event()
scene = QGraphicsScene()
self.scene = scene
self.setScene(scene)
self.map_layer = QGraphicsPixmapItem()
scene.addItem(self.map_layer)
self.circle = QGraphicsEllipseItem(0, 0, 20, 20)
pen = QPen(QColor(255, 0, 0, 128))
pen.setWidth(2)
self.circle.setPen(pen)
scene.addItem(self.circle)
self.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
self.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
def paintEvent(self, ev):
color = self.palette().color(QPalette.Highlight)
painter = QPainter(self)
# Filled rectangle.
painter.setClipRect(self.rect())
color.setAlpha(50)
painter.fillRect(self.rect().adjusted(2,2,-2,-2), color)
# Thin rectangle outside.
color.setAlpha(150)
painter.setPen(color)
painter.drawRect(self.rect().adjusted(0,0,-1,-1))
# Pseudo-handles at the corners and sides
color.setAlpha(100)
pen = QPen(color)
pen.setWidth(8)
painter.setPen(pen)
painter.setBackgroundMode(Qt.OpaqueMode)
# Clip at 4 corners
region = QRegion(QRect(0,0,20,20))
region += QRect(self.rect().width()-20, 0, 20, 20)
region += QRect(self.rect().width()-20, self.rect().height()-20, 20, 20)
region += QRect(0, self.rect().height()-20, 20, 20)
# Clip middles
region += QRect(0, self.rect().height() // 2 - 10, self.rect().width(), 20)
region += QRect(self.rect().width() // 2 - 10, 0, 20, self.rect().height())
# Draw thicker rectangles, clipped at corners and sides.
painter.setClipRegion(region)
painter.drawRect(self.rect())
def draw(self, painter: QPainter):
pen = QPen(Layer.color(LayerType.annotate))
pen.setCapStyle(Qt.RoundCap)
pen.setJoinStyle(Qt.RoundJoin)
pen.setWidth(0)
painter.setPen(pen)
painter.drawLine(self.pt1, self.pt2)
def addWP(self, wp):
if wp.command in [mavutil.mavlink.MAV_CMD_NAV_WAYPOINT,
mavutil.mavlink.MAV_CMD_NAV_WAYPOINT,
mavutil.mavlink.MAV_CMD_NAV_LOITER_TO_ALT,
mavutil.mavlink.MAV_CMD_NAV_LOITER_TURNS,
mavutil.mavlink.MAV_CMD_NAV_LOITER_TIME,
mavutil.mavlink.MAV_CMD_NAV_LOITER_UNLIM,
mavutil.mavlink.MAV_CMD_NAV_LAND]:
#point
rad = self.__wp_diameter * 0.5
ellipse = QGraphicsEllipseItem(wp.y - rad, -wp.x - rad,
self.__wp_diameter, self.__wp_diameter, self.__mission_layer)
ellipse.setBrush(QBrush(QColor(255, 255, 255)))
e_pen = QPen(QColor(255, 255, 255))
e_pen.setWidth(0)
ellipse.setPen(e_pen)
self.__mission_layer.addToGroup(ellipse)
#label
label = QGraphicsTextItem(str(wp.seq), self.__mission_layer)
label.setZValue(2)
label.setDefaultTextColor(Qt.white)
label.setPos(wp.y + rad, -wp.x - rad)
label.setScale(0.00002) #bit hacky -- really should scale based on
#current zoom, but I'm in a hurry.
self.__mission_layer.addToGroup(label)
label.show()
class PlotLine(QGraphicsLineItem):
def __init__(self, view, p1, p2):
super().__init__()
self.p1 = p1
self.p2 = p2
self.cls = p1.cls
self.view = view
self.highlighted = False
self.lineWidth = 1
self.lineWidthHighl = 4
self._pen = None
self._penHighl = None
self.updateColor()
self.updateLine()
view.plotPaletteChanged.connect(self.updateColor)
view.axisChanged.connect(self.updateLine)
def updateColor(self):
color = self.view.getClassColor(self.cls)
self._pen = QPen(color)
self._pen.setWidth(self.lineWidth)
colorHighl = QColor(color)
colorHighl.setAlpha(255)
self._penHighl = QPen(colorHighl)
self._penHighl.setWidth(self.lineWidthHighl)
def updateLine(self):
p1 = self.p1.mapToScene(self.p1.boundingRect().center())
p2 = self.p2.mapToScene(self.p2.boundingRect().center())
self.setLine(QLineF(p1, p2))
def paint(self, qp: QPainter, option: QStyleOptionGraphicsItem, widget: QWidget = None):
self.setPen(self._pen if not self.highlighted else self._penHighl)
super().paint(qp, option, widget)
def draw(self, painter):
pen = QPen(Layer.color(LayerType.annotate))
pen.setCapStyle(Qt.RoundCap)
pen.setJoinStyle(Qt.RoundJoin)
pen.setWidth(0)
painter.setPen(pen)
if self._firstPt is not None:
painter.drawLine(self._firstPt, self._pos)
def paint(self, painter, option, widget=None):
with painter_context(painter):
pen = QPen(painter.pen())
pen.setWidth(10.0)
pen.setColor(QColor(255, 0, 0))
painter.setPen(pen)
shrunken_rectf = self.rectf.adjusted(10, 10, -10, -10)
painter.drawRoundedRect(shrunken_rectf, 50, 50, Qt.RelativeSize)
def paint (self, painter, option, widget): # print 'paint' # print self.po # draw background every time boundRect = self.boundingRect() rightEnd = boundRect.right() leftEnd = boundRect.left() # print 'rightEnd',rightEnd # print 'leftEnd',leftEnd gridNum = int(math.floor(rightEnd / self.gridGap)) # print 'gridNum',gridNum # get grid line 100 frame gap width/frame * 100 for i in range (0,gridNum+1): x = i*self.gridGap painter.drawLine(x, 0, x, 30) # draw x axis every time # if labeling, increase rectangle if (self.isLabeling) : # get current label's shapes #currentShape = self.labelShapes[self.currentLabelShapeIndex] #increase end value = current middle line labels = self.labelData fly_idx= labels['names'].index(self.currFly) labels['t1'][fly_idx][-1]=self.currentFrame self.labelData=labels #print self.labelData # draw all the existing shapes # for loop draw all shapes fly_to_draw= self.currFly labels=self.labelData if fly_to_draw in labels['names']: fly_idx= labels['names'].index(fly_to_draw) bouts= len(labels['labels'][fly_idx]) for i in xrange(bouts): color = self.colorMatch[labels['labels'][fly_idx][i]] self.currColor = color yPos = self.yMatch[labels['labels'][fly_idx][i]] painter.setBrush(QBrush(color)) pen=QPen(color) pen.setWidth(1) painter.setPen(pen) widthRect= (labels['t1'][fly_idx][i]-labels['t0'][fly_idx][i]+1) * self.widthPerFrame startPos= labels['t0'][fly_idx][i] * self.widthPerFrame #painter.drawRect(int x, int y, int width, int height) painter.drawRect(startPos,yPos,widthRect,10)
def draw(self, painter):
pen = QPen(Layer.color(LayerType.selection))
pen.setCapStyle(Qt.RoundCap)
pen.setJoinStyle(Qt.RoundJoin)
pen.setWidth(0)
painter.setPen(pen)
for h in self._handles:
h.draw(painter)
painter.drawLine(self._obj.pt1, self._obj.pt2)
def paintEvent(self, event):
QWidget.paintEvent(self, event)
width, height = self.width(), self.height()
polygon = QPolygon()
for i, rate in enumerate(self.loads):
x = width - i * self.pointDistance
y = height - rate * height
if x < self.boxWidth:
break
polygon.append(QPoint(x, y))
painter = QPainter(self)
pen = QPen()
pen.setColor(Qt.darkGreen)
painter.setPen(pen)
painter.setRenderHint(QPainter.Antialiasing, True)
#画网格
painter.setOpacity(0.5)
gridSize = self.pointDistance * 4
deltaX = (width - self.boxWidth) % gridSize + self.boxWidth
deltaY = height % gridSize
for i in range(int(width / gridSize)):
x = deltaX + gridSize * i
painter.drawLine(x, 0, x, height)
for j in range(int(height / gridSize)):
y = j * gridSize + deltaY
painter.drawLine(self.boxWidth, y, width, y)
#画折线
pen.setColor(Qt.darkCyan)
pen.setWidth(2)
painter.setPen(pen)
painter.setOpacity(1)
painter.drawPolyline(polygon)
#画展示框
if len(self.loads) > 0:
rate = self.loads[0]
else:
rate = 1.0
rect1 = QRect(4, height * 0.05, self.boxWidth - 9, height * 0.7)
rect2 = QRect(4, height * 0.8, self.boxWidth - 9, height * 0.2)
centerX = int(rect1.width() / 2) + 1
pen.setWidth(1)
for i in range(rect1.height()):
if i % 4 == 0:
continue
if (rect1.height() - i) / rect1.height() > rate:
pen.setColor(Qt.darkGreen)
else:
pen.setColor(Qt.green)
painter.setPen(pen)
for j in range(rect1.width()):
if centerX - 1 <= j <= centerX + 1:
continue
painter.drawPoint(rect1.x() + j, rect1.y() + i)
pen.setColor(Qt.black)
painter.setPen(pen)
painter.drawText(rect2, Qt.AlignHCenter | Qt.AlignVCenter, str(int(rate * 100)) + "%")
def drawWidget(self, qp): color = self.palette().color(QPalette.Background) qp.setBrush(QColor(100,0,0)) pen=QPen() pen.setWidth(self.width()/10) pen.setColor(QColor(0,0,255)) pen.setCapStyle(Qt.RoundCap) w=self.width()/2 x_shift=w+w*0.05 y_shift=w+w*0.05 r=0.35*w r1=w*0.8 qp.setPen(pen) my_max=100 p=[] c=[] for phi in range(0,360,30): p.append(phi) c.append(0) f=0 for i in range(0,len(p)): if p[i]>self.delta: f=i break i=f m=1.0 while(i>=0): c[i]=m m=m*0.7 i=i-1 i=len(c)-1 while(i>f): c[i]=m m=m*0.7 i=i-1 for i in range(0,len(p)): self.pos=p[i] x = r * cos( (2*pi)*self.pos/360 ) y = r * sin( (2*pi)*self.pos/360 ) x1 = r1 * cos( (2*pi)*self.pos/360 ) y1 = r1 * sin( (2*pi)*self.pos/360 ) cb=self.blue_target*c[i]+color.blue()*(1.0-c[i]) cg=self.green_target*c[i]+color.green()*(1.0-c[i]) cr=self.red_target*c[i]+color.red()*(1.0-c[i]) pen.setColor(QColor(cr,cg,cb)) qp.setPen(pen) qp.drawLine(x+x_shift,y+y_shift,x1+x_shift,y1+y_shift)
def paintRects(self, painter, rects):
"""Override this method to implement different drawing behaviour."""
pen = QPen(self.color())
pen.setWidth(self.lineWidth)
painter.setPen(pen)
painter.setRenderHint(QPainter.Antialiasing, True)
rad = self.radius
for r in rects:
r.adjust(-rad, -rad, rad, rad)
painter.drawRoundedRect(r, rad, rad)
def paintEvent(self, paint_event):
if self.points:
painter = QPainter(self)
pen = QPen()
pen.setWidth(20)
painter.setPen(pen)
painter.setRenderHint(QPainter.Antialiasing, True)
for pos in self.points:
painter.drawPoint(pos[0], pos[1])
painter.end()
def paint(self, painter, option, widget=None):
if len(self.points) > 1:
# init graphics
pen = QPen(COLOR[self.layer])
pen.setWidth(0)
painter.setPen(pen)
# draw
painter.drawPolyline(QPolygonF(self.points))
if PolygonBase.close_polygon:
painter.drawLine(self.points[-1], self.points[0])
def _drawPlanetPic(self, painter: QPainter):
if self._img_loaded:
painter.drawImage(self._img.rect(), self._img, self._img.rect(), Qt.AutoColor)
if self._planet.is_current:
pen = QPen(QColor(0, 200, 0))
pen.setWidth(4)
painter.setPen(pen)
rc = self.rect()
rc.adjust(0, 0, -1, -1)
painter.drawRect(rc)
def drawPixmapForUnckecked(self):
self.pixmapUnckecked = QPixmap(self.itemWidth, self.itemHeight)
self.pixmapUnckecked.fill(Qt.transparent)
painter = QPainter()
painter.begin(self.pixmapUnckecked)
painter.setRenderHint(QPainter.Antialiasing)
pen = QPen()
pen.setWidth(2)
painter.setPen(pen)
painter.drawRect(QRect(5, 5, self.itemWidth - 10, self.itemHeight - 10))
painter.end()
def paint(self, painter, option, widget=None):
p = QPen(Qt.black)
if self.isSelected():
p.setWidth(5)
painter.setPen(p)
else:
p.setWidth(1)
painter.setPen(p)
painter.setBrush(self.bg_color)
r = self.rect.height() / 8.0
painter.drawRoundedRect(self.rect, r, r)
def paintEvent(self, ev):
pen = QPen()
pen.setStyle(Qt.DotLine)
pen.setWidth(2)
pen.setColor(QColor(Qt.white))
brush = QBrush()
brush.setStyle(Qt.SolidPattern)
brush.setColor(QColor(0, 0, 0))
painter = QPainter(self)
painter.setPen(pen)
painter.setBrush(brush)
painter.drawRect(ev.rect())
def paintEvent(self, ev):
color = self._color
if not color or color.alpha() == 0:
return
painter = QPainter(self)
adj = self.lineWidth // 2
rect = self.rect().adjusted(adj, adj, -adj, -adj)
pen = QPen(color)
pen.setWidth(self.lineWidth)
painter.setPen(pen)
painter.setRenderHint(QPainter.Antialiasing, True)
painter.drawRoundedRect(rect, self.radius, self.radius)
def paint(self, painter, option, widget):
if self.points is not None and self.isDrawLine:
painter.save()
pen = QPen(self.color)
pen.setWidth(self.getLineWidth())
painter.setPen(pen)
qPoints = [QPointF(*p.tolist()) for p in self.points]
polygon = QPolygonF(qPoints)
painter.drawPolyline(polygon)
painter.restore()
def __init__(self):
QMainWindow.__init__(self)
# define values file upload.
value.set_value()
self.measureData = []
self.tempMessage = []
self.xlist, self.ylist, self.rlist, self.xclist, self.yclist, self.laserlist = [], [], [], [], [], []
self.tempData = [
self.measureData, self.xlist, self.ylist, self.rlist, self.xclist,
self.yclist, self.laserlist
]
self.resultData = data_set_two.MeasureData(None)
# start ui drawing.
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
# set window view size maximum.
self.showMaximized()
self.message_list = [
self.ui.msg_1, self.ui.msg_2, self.ui.msg_3, self.ui.msg_4,
self.ui.msg_5
]
# laser connect state ui values list.
self.uiList = [self.ui.img_Rsock, self.ui.img_Lsock, self.ui.img_Bsock]
self.uiBList = [self.ui.img_B1, self.ui.img_B2, self.ui.laser_state_B]
# laser state ui values list.
self.uiLaserList = [
self.ui.img_R1, self.ui.img_R2, self.ui.img_R3, self.ui.img_R4,
self.ui.img_L1, self.ui.img_L2, self.ui.img_L3, self.ui.img_L4
]
self.layerlist = [
self.ui.layer_R1, self.ui.layer_R2, self.ui.layer_R3,
self.ui.layer_R4, self.ui.layer_L1, self.ui.layer_L2,
self.ui.layer_L3, self.ui.layer_L4
]
# set range.
self.gScene = QGraphicsScene(0, 0,
value.get_frame() / 4,
value.get_frame() / 4,
self.ui.graphicsView)
self.ui.graphicsView.setScene(self.gScene)
# socket connection start
self.th = Socket(self, self.uiList)
self.th.start()
self.dialog = Connection(self.th)
self.calculation = Calculation()
# setting window set.
Setting.setting = Setting(self.th, self.uiBList)
Setting.setting.ui = Ui_SettingWindow()
Setting.setting.ui.setupUi(Setting.setting)
Setting.setting.btnList = [
Setting.setting.ui.btn_laser, Setting.setting.ui.btn_chuck_default,
Setting.setting.ui.btn_frame_set, Setting.setting.ui.btn_coor_set,
Setting.setting.ui.btn_chuck_set, Setting.setting.ui.btn_laser_set
]
Setting.setting.ui.setting_info.setText(
'척 기본값 : %s\n프레임 길이 : %d\n좌표계 보정값 : %s\n척 보정값 : %s\n레이저 사이 간격 : %s'
% (value.get_chuck(), value.get_frame(), value.get_coor(),
value.get_chuck_scale(), value.get_laser()))
# drawing basic view ---------------------------------------------------------------------------
# -------------------------------------------------------------------------------------------------
# pen, brush setting
inside_color = QBrush(Qt.white)
pen = QPen(Qt.red)
pen.setWidth(4)
# make 8 laser lines
self.laser = []
line = self.calculation.get_laser_location()
for i in range(len(line)):
line[i] = line[i] * 0.25
self.laser.append(
QGraphicsLineItem(0, (self.gScene.height() / 2 - line[i]),
self.gScene.width(),
(self.gScene.height() / 2 - line[i])))
self.laser[i].setPen(pen)
self.gScene.addItem(self.laser[i])
# make circle
pen.setColor(Qt.blue)
self.circle = self.gScene.addEllipse(self.gScene.width() / 2 - 50,
self.gScene.height() / 2 - 50,
100, 100, pen, inside_color)
self.circle_pot = self.gScene.addEllipse(
self.gScene.width() / 2 - 2.25,
self.gScene.height() / 2 - 2.25, 5, 5, pen, Qt.blue)
# make chuck pot
pen.setColor(Qt.red)
self.chuck_pot = self.gScene.addEllipse(
self.gScene.width() / 2 - 2.25,
self.gScene.height() / 2 - 2.25, 5, 5, pen, Qt.red)
# make x, y lines
self.x_line = QGraphicsLineItem(0,
self.gScene.height() / 2,
self.gScene.width(),
self.gScene.height() / 2)
self.gScene.addItem(self.x_line)
self.y_line = QGraphicsLineItem(self.gScene.width() / 2, 0,
self.gScene.width() / 2,
self.gScene.height())
self.gScene.addItem(self.y_line)
def paintEvent(self, event):
painter = QPainter(self)
if self.main_ui.combo_interpolation.currentIndex() == 0:
scale_mode = Qt.SmoothTransformation
else:
scale_mode = Qt.FastTransformation
painter.drawImage(
event.rect(),
self.image.scaledToWidth(self.width * self.image_pixel_size,
scale_mode))
if self.agc_roi_from != None and self.agc_roi_to != None and not self.image_is_16bit:
from_x, from_y, to_x, to_y = self.agc_roi_from.x(
), self.agc_roi_from.y(), self.agc_roi_to.x(), self.agc_roi_to.y()
draw_rect(
painter,
from_x * self.image_pixel_size + self.image_pixel_size // 2,
from_y * self.image_pixel_size + self.image_pixel_size // 2,
(to_x - from_x) * self.image_pixel_size + 1,
(to_y - from_y) * self.image_pixel_size + 1, 1, Qt.green)
self.main_ui.update_agc_roi_label()
if self.spotmeter_roi_from != None and self.spotmeter_roi_to != None:
pen = QPen()
pen.setColor(Qt.white)
pen.setWidth(1)
painter.setPen(pen)
from_x, from_y, to_x, to_y = self.spotmeter_roi_from.x(
), self.spotmeter_roi_from.y(), self.spotmeter_roi_to.x(
), self.spotmeter_roi_to.y()
from_x = from_x * self.image_pixel_size + self.image_pixel_size // 2 + 1
from_y = from_y * self.image_pixel_size + self.image_pixel_size // 2 + 1
to_x = to_x * self.image_pixel_size + self.image_pixel_size // 2 - 1
to_y = to_y * self.image_pixel_size + self.image_pixel_size // 2 - 1
cross_x = from_x + (to_x - from_x) / 2.0
cross_y = from_y + (to_y - from_y) / 2.0
if to_x - from_x > self.image_pixel_size or to_y - from_y > self.image_pixel_size:
lines = [
QLineF(from_x, from_y, from_x + self.crosshair_width,
from_y),
QLineF(from_x, from_y, from_x,
from_y + self.crosshair_width),
QLineF(to_x, to_y, to_x, to_y - self.crosshair_width),
QLineF(to_x, to_y, to_x - self.crosshair_width, to_y),
QLineF(from_x, to_y, from_x, to_y - self.crosshair_width),
QLineF(from_x, to_y, from_x + self.crosshair_width, to_y),
QLineF(to_x, from_y, to_x, from_y + self.crosshair_width),
QLineF(to_x, from_y, to_x - self.crosshair_width, from_y)
]
painter.drawLines(lines)
lines = [
QLineF(cross_x - self.crosshair_width, cross_y,
cross_x + self.crosshair_width, cross_y),
QLineF(cross_x, cross_y - self.crosshair_width, cross_x,
cross_y + self.crosshair_width)
]
painter.drawLines(lines)
self.main_ui.update_spotmeter_roi_label()
def __init__(self):
QWidget.__init__(self)
screenWidth = 800
screenHeight = 480
GPIO.output(15, GPIO.HIGH)
# QTimer uses QFrameSlots wherein every video frame from the live preview is encoded.
self.timer = QTimer()
self.timer.timeout.connect(self.nextFrameSlot)
# self.timer.timeout.connect(self.requestPower)
# self.timer.timeout.connect(self.requestDistance)
self.scene = QGraphicsScene()
self.view = QGraphicsView(self.scene, self)
self.view.setContentsMargins(QMargins())
self.view.setStyleSheet("border-width: 0px; border-style: solid")
layout = QVBoxLayout(self)
layout.setContentsMargins(QMargins())
layout.setSpacing(0)
self.openCamera()
self.label = QLabel()
self.label.setFixedSize(screenWidth, screenHeight)
# QPen is used to change the properties of the middle line drawn in the GUI.
pen = QPen()
pen.setWidth(5)
pen.setColor(Qt.green)
pen.setStyle(Qt.DotLine)
rectPen = QPen()
rectPen.setStyle(Qt.NoPen)
# QFont is used to change the properties of the text rendered in the GUI.
font = QFont('Noto')
font.setPixelSize(26)
font2 = QFont('Noto')
font2.setPixelSize(70)
# Pixmaps
happyMeasurePixmap = QPixmap.fromImage(QImage('img/happy_measure.png'))
create4CarePixmap = QPixmap.fromImage(QImage('img/create4care.png'))
self.batteryEmptyPixmap = QPixmap.fromImage(
QImage('img/battery_empty.png'))
self.warningPixmap = QPixmap.fromImage(QImage('img/warning.png'))
self.warningPlaceholderPixmap = QPixmap.fromImage(
QImage('img/warning_placeholder.png'))
self.battery100Pixmap = QPixmap.fromImage(
QImage('img/battery_100.png'))
self.battery80Pixmap = QPixmap.fromImage(QImage('img/battery_80.png'))
self.battery60Pixmap = QPixmap.fromImage(QImage('img/battery_60.png'))
self.battery40Pixmap = QPixmap.fromImage(QImage('img/battery_40.png'))
self.battery20Pixmap = QPixmap.fromImage(QImage('img/battery_20.png'))
self.battery0Pixmap = QPixmap.fromImage(QImage('img/battery_0.png'))
self.batteryUnknownPixmap = QPixmap.fromImage(
QImage('img/battery_unknown.png'))
# Labels
self.batteryLabel = QLabel()
self.batteryLabel.setFixedSize(120, 41)
self.batteryLabel.setGeometry(39, 30, 0, 0)
self.batteryLabel.setPixmap(batteryUnknownPixmap)
self.warningLabel = QLabel()
self.warningLabel.setFixedSize(129, 66)
self.warningLabel.setGeometry(39, 200, 0, 0)
self.warningLabel.setPixmap(self.warningPlaceholderPixmap)
self.emptyLabel = QLabel()
self.emptyLabel.setFixedSize(209, 219)
self.emptyLabel.setGeometry(500, 110, 0, 0)
self.emptyLabel.setStyleSheet("background:transparent")
# Shapes & Lines
backgroundRectangle = QGraphicsRectItem(0, 0, 200, screenHeight)
backgroundRectangle.setBrush(QBrush(QColor(47, 47, 125)))
backgroundRectangle.setPen(rectPen)
# TextItems
self.batteryTextItem = QGraphicsTextItem("100%")
self.batteryTextItem.setFont(font)
self.batteryTextItem.setDefaultTextColor(Qt.white)
self.batteryTextItem.setPos(39 + 45, 75)
self.batteryTextItem.setPlainText("?")
self.counterSignal.connect(self.batteryTextItem.setPlainText)
# self.distanceSignal.connect(self.lengthTextItem.setPlaintext)
threading.Thread(target=self.batteryManagerThread).start()
threading.Thread(target=self.inputHandlerThread).start()
# threading.Thread(target=self.standbyThread).start()
# Add all widgets - THE ORDER OF THE ADDWIDGETS DECIDES WHICH WIDGETS APPEAR ON THE FOREGROUND
layout.addWidget(self.view)
self.scene.addWidget(self.label)
self.scene.addItem(backgroundRectangle)
# self.scene.addItem(lengthTextItem)
self.scene.addItem(self.batteryTextItem)
self.scene.addWidget(self.batteryLabel)
self.scene.addWidget(self.warningLabel)
self.scene.addWidget(self.emptyLabel)
# self.batteryPixmapItem = self.scene.addPixmap(battery100Pixmap).setPos(39,30)
self.happyMeasurePixmapItem = self.scene.addPixmap(
happyMeasurePixmap).setPos(38, 307)
self.create4CarePixmapItem = self.scene.addPixmap(
create4CarePixmap).setPos(38, 386)
# If lineThickness < 10: startX = 10 - lineThickness & endY = 480 - startX
self.lineItem = self.scene.addLine(400 - 2, 5, 400 - 2,
screenHeight - 5, pen)
self.setLayout(layout)
self.setWindowTitle("EEP71")
class Widget(QWidget):
# Constructor of "Main_Window"
def __init__(self):
super().__init__()
self.initui()
def initui(self):
#############################################################################################################
# Modifications: #
#############################################################################################################
# Window-Title of Main_Window
self.str_windowname = 'TestingWidget'
self.setWindowTitle("%s" % self.str_windowname)
# Change the window icon
#self.setWindowIcon()
# Changing the MainWindow geometry:
# Origin and Size of MainWindow:
self.int_origin_x = 100
self.int_origin_y = 100
self.int_length = 1000
self.int_width = 800
self.setGeometry(self.int_origin_x, self.int_origin_y, self.int_length,
self.int_width)
# (x-coordinate of left upper edge, y-coordinate of left upper edge,int_width of window, heigth of window)
#
gridlayout = QGridLayout()
################################
self.instance_qgraphicsview = QGraphicsView()
self.instance_ggraphicsscene = QGraphicsScene()
self.instance_qgraphicsview.setScene(self.instance_ggraphicsscene)
self.blackpen = QPen(Qt.red)
self.blackpen.setWidth(6)
self.instance_ggraphicsscene.addEllipse(10, 10, 1000, 10000,
self.blackpen)
self.instance_ggraphicsscene.addText("Hello World!")
self.button = QPushButton("Test")
self.instance_ggraphicsscene.addWidget(self.button)
self.instance_qgraphicsview.setMaximumSize(100, 100)
################################
self.instance_qgraphicsview2 = QGraphicsView()
self.instance_ggraphicsscene2 = QGraphicsScene()
self.instance_qgraphicsview2.setScene(self.instance_ggraphicsscene)
width = 5
height = 5
dpi = 100
self.figure = Figure(figsize=(width, height), dpi=dpi)
self.instance_qgraphicsview.setMaximumSize(100, 100)
self.instance_ggraphicsscene.addWidget(self.figure)
canvas = FigureCanvasQTAgg()
canvas.add_figure(self.figure)
gridlayout.addWidget(self.instance_qgraphicsview, 0, 0, 1, 1)
gridlayout.addWidget(self.instance_ggraphicsscene, 0, 1, 1, 1)
self.setLayout(gridlayout)
print("Geschafft!")
# Show object of "MainWindow":
self.show()
def drawEvent(self, event, col_width, x_loc):
t0_f = timeStrToFloat(event.t0)
t1_f = timeStrToFloat(event.t1)
length = (t1_f - t0_f) * (self.h / 24)
space = QtCore.QSizeF(col_width - PEN_WIDTH, length - PEN_WIDTH)
r = QtCore.QRectF(QtCore.QPointF(x_loc + 1,
t0_f * (self.h / 24) + 1), space)
pen = QPen(QtCore.Qt.black)
pen.setWidth(PEN_WIDTH)
brush = QBrush(event.color)
### Checks maximum font size if level
font_size = MAX_EVENT_FONT_PT
l_title = QLabel(event.title[self.lang] + " ")
l_time = QLabel('(' + event.t0 + ' - ' + event.t1 + ')')
l_time.setFont(
QtGui.QFont(DEFAULT_EVENT_FONT, font_size, QtGui.QFont.Normal))
l_title.setFont(
QtGui.QFont(DEFAULT_EVENT_FONT, font_size, QtGui.QFont.Bold))
title_width = l_title.fontMetrics().boundingRect(l_title.text()).width() + \
l_time.fontMetrics().boundingRect(l_time.text()).width() + W_BUFFER
title_height = l_title.fontMetrics().boundingRect(
l_title.text()).height() + H_BUFFER
while (title_height > length
or title_width > col_width) and font_size > MIN_EVENT_FONT_PT:
font_size -= FONT_STEP
l_title.setFont(
QtGui.QFont(DEFAULT_EVENT_FONT, font_size, QtGui.QFont.Bold))
l_time.setFont(
QtGui.QFont(DEFAULT_EVENT_FONT, font_size, QtGui.QFont.Normal))
title_width = l_title.fontMetrics().boundingRect(l_title.text()).width() + \
l_time.fontMetrics().boundingRect(l_time.text()).width() + W_BUFFER
title_height = l_title.fontMetrics().boundingRect(
l_title.text()).height() + H_BUFFER
font_size_level = font_size
over_height_level = title_height - length
over_width_level = title_width - col_width
### Checks maximum font size if stacked
font_size = MAX_EVENT_FONT_PT
l_title = QLabel(event.title[self.lang])
l_time = QLabel('(' + event.t0 + ' - ' + event.t1 + ')')
l_time.setFont(
QtGui.QFont(DEFAULT_EVENT_FONT, font_size, QtGui.QFont.Normal))
l_title.setFont(
QtGui.QFont(DEFAULT_EVENT_FONT, font_size, QtGui.QFont.Bold))
title_width = max(
l_title.fontMetrics().boundingRect(l_title.text()).width(),
l_time.fontMetrics().boundingRect(
l_time.text()).width()) + W_BUFFER
title_height = l_title.fontMetrics().boundingRect(l_title.text()).height() + \
l_time.fontMetrics().boundingRect(l_time.text()).height() + H_BUFFER
while (title_height > length
or title_width > col_width) and font_size > MIN_EVENT_FONT_PT:
font_size -= FONT_STEP
l_title.setFont(
QtGui.QFont(DEFAULT_EVENT_FONT, font_size, QtGui.QFont.Bold))
l_time.setFont(
QtGui.QFont(DEFAULT_EVENT_FONT, font_size, QtGui.QFont.Normal))
title_width = max(
l_title.fontMetrics().boundingRect(l_title.text()).width(),
l_time.fontMetrics().boundingRect(
l_time.text()).width()) + W_BUFFER
title_height = l_title.fontMetrics().boundingRect(l_title.text()).height() + \
l_time.fontMetrics().boundingRect(l_time.text()).height() + H_BUFFER
font_size_stacked = font_size
over_height_stacked = title_height - length
over_width_stacked = title_width - col_width
### Checks if it can draw the event without the time label if it is too big
if ((over_width_level > 0 or over_height_level > 0) and \
(over_width_stacked > 0 or over_height_stacked > 0)):
font_size = MAX_EVENT_FONT_PT
l_title = QLabel(event.title[self.lang])
l_title.setFont(
QtGui.QFont(DEFAULT_EVENT_FONT, font_size, QtGui.QFont.Bold))
title_width = l_title.fontMetrics().boundingRect(
l_title.text()).width() + W_BUFFER
title_height = l_title.fontMetrics().boundingRect(
l_title.text()).height() + H_BUFFER
while (title_height > length or
title_width > col_width) and font_size > MIN_EVENT_FONT_PT:
font_size -= FONT_STEP
l_title.setFont(
QtGui.QFont(DEFAULT_EVENT_FONT, font_size,
QtGui.QFont.Bold))
title_width = l_title.fontMetrics().boundingRect(
l_title.text()).width() + W_BUFFER
title_height = l_title.fontMetrics().boundingRect(
l_title.text()).height() + H_BUFFER
font_size_level = font_size
over_height_level = title_height - length
over_width_level = title_width - col_width
if (over_height_level > 0 or over_width_level > 0):
l_title = QLabel('')
l_time = QLabel('')
else:
l_title = QLabel(event.title[self.lang] + " ")
l_title.setFont(
QtGui.QFont(DEFAULT_EVENT_FONT, font_size_level,
QtGui.QFont.Bold))
l_title.move(x_loc + X_BUFFER, t0_f * (self.h / 24) + Y_BUFFER)
l_time = QLabel('')
r = RectEvent(r)
r.setInfo(self, event)
r.setPen(pen)
r.setBrush(brush)
self.scheduleScene.addItem(r)
l_title.setStyleSheet(EVENT_LABEL_CSS)
l_time.setStyleSheet(EVENT_LABEL_CSS)
self.scheduleScene.addWidget(l_title)
self.scheduleScene.addWidget(l_time)
return
### Sets font and arrangement to the better layout
if font_size_level > font_size_stacked:
level = True
elif font_size_level < font_size_stacked:
level = False
else:
if over_width_level <= 0 and over_height_level <= 0:
level = True
elif over_width_level > col_width:
level = False
elif over_height_stacked > 0:
level = True
else:
level = False
if level:
l_title = QLabel(event.title[self.lang] + " ")
l_time = QLabel('(' + event.t0 + ' - ' + event.t1 + ')')
l_time.setFont(
QtGui.QFont(DEFAULT_EVENT_FONT, font_size_level,
QtGui.QFont.Normal))
l_title.setFont(
QtGui.QFont(DEFAULT_EVENT_FONT, font_size_level,
QtGui.QFont.Bold))
l_title.move(x_loc + X_BUFFER, t0_f * (self.h / 24) + Y_BUFFER)
l_time.move(x_loc + X_BUFFER + \
l_title.fontMetrics().boundingRect(l_title.text()).width(),
t0_f * (self.h/24) + Y_BUFFER)
else:
l_title = QLabel(event.title[self.lang])
l_time = QLabel('(' + event.t0 + ' - ' + event.t1 + ')')
l_time.setFont(
QtGui.QFont(DEFAULT_EVENT_FONT, font_size_stacked,
QtGui.QFont.Normal))
l_title.setFont(
QtGui.QFont(DEFAULT_EVENT_FONT, font_size_stacked,
QtGui.QFont.Bold))
l_title.move(x_loc + X_BUFFER, t0_f * (self.h / 24) + Y_BUFFER)
l_time.move(x_loc + X_BUFFER, t0_f * (self.h/24) + Y_BUFFER + STACKED_BUFFER + \
l_title.fontMetrics().boundingRect(l_title.text()).height())
r = RectEvent(r)
r.setInfo(self, event)
r.setPen(pen)
r.setBrush(brush)
self.scheduleScene.addItem(r)
l_title.setStyleSheet(EVENT_LABEL_CSS)
l_time.setStyleSheet(EVENT_LABEL_CSS)
self.scheduleScene.addWidget(l_title)
self.scheduleScene.addWidget(l_time)
def makeSquiggles(self, image):
"""
actual calculations
:param image: bitmap to squigglify
:return:
"""
noOfLines = self.parent.noOfLines.value()
height = image.height()
width = image.width()
amplitude = self.parent.strength.value()
strokeWidth = self.parent.lineWidth.value()
detail = self.parent.detail.value()
invertColors = self.parent.invertColors.checkState() == Qt.Checked
verticalSquiggles = self.parent.verticalSquiggles.checkState(
) == Qt.Checked
maxBrightness = self.parent.maxBrightness.value()
minBrightness = self.parent.minBrightness.value()
self.removeOldGraphicsItems()
group = QGraphicsItemGroup()
finalRow = False
minStepSize = self.parent.minStepSize.value()
maxStepSize = self.parent.maxStepSize.value()
# TODO: too much code duplication!
path = QPainterPath()
if not verticalSquiggles:
scaledystep = max(1, height / noOfLines)
for y in frange(0, height, scaledystep):
if fabs(y - height) < 1e-3 or y >= height:
finalRow = True
x = 0
disturbance_direction = -1
prevX = 0
prevY = y
while x < width:
disturbance_direction = -disturbance_direction
grayvalue = qGray(image.pixel(x, y))
if invertColors:
grayvalue = 255 - grayvalue
stepSize = Mapping.linexp(grayvalue, 0, 255, minStepSize,
maxStepSize)
stepSize = Mapping.linlin(stepSize, 1, 10, 1, 10 / detail)
amplitudeSize = Mapping.linlin(grayvalue, 0, 255,
amplitude, 0)
if x == 0:
path = QPainterPath()
path.moveTo(x, y)
x = prevX + stepSize
newY = prevY + amplitudeSize * disturbance_direction
if minBrightness <= grayvalue <= maxBrightness:
path.quadTo((prevX + x) / 2, newY, x, prevY)
else:
path.moveTo(x, prevY)
if x >= width:
item = QGraphicsPathItem(path)
pen = QPen()
pen.setWidth(strokeWidth)
item.setPen(pen)
group.addToGroup(item)
prevX = x
prevY = y
if finalRow:
break
else:
scaledxstep = max(1, width / noOfLines)
for x in frange(0, width, scaledxstep):
if fabs(x - width) < 1e-3 or x >= width:
finalRow = True
y = 0
disturbance_direction = -1
prevX = x
prevY = 0
while y < height:
disturbance_direction = -disturbance_direction
grayvalue = qGray(image.pixel(x, y))
if invertColors:
grayvalue = 255 - grayvalue
stepSize = Mapping.linexp(grayvalue, 0, 255, minStepSize,
maxStepSize)
stepSize = Mapping.linlin(stepSize, 1, 10, 1, 10 / detail)
amplitudeSize = Mapping.linlin(grayvalue, 0, 255,
amplitude, 0)
if y == 0:
path = QPainterPath()
path.moveTo(x, y)
y = prevY + stepSize
newX = prevX + amplitudeSize * disturbance_direction
if minBrightness <= grayvalue <= maxBrightness:
path.quadTo(newX, (prevY + y) / 2, prevX, y)
else:
path.moveTo(x, prevY)
if y >= height:
item = QGraphicsPathItem(path)
pen = QPen()
pen.setWidth(strokeWidth)
item.setPen(pen)
group.addToGroup(item)
prevX = x
prevY = y
if finalRow:
break
self.addNewGraphicsItems(group)
def paintEvent(self, e):
try:
plan = self.plan
segment = self.plan.beams[self.bi][self.si]
except:
print("Tried to paint a plan, but no plan was loaded.")
return
attr = "second"
if self.be == 0:
attr = "first"
w = self.width() #/800
h = self.height() #/800
# print(w,h)
qp = QPainter()
qp.begin(self)
pen = QPen(Qt.black, 1, Qt.SolidLine)
h400 = h / 2 # TEST
w400 = w / 2 # TEST
vert_zoom = w400 / 400. * 20
hor_zoom = h400 / 400. * 20
leafedges = np.linspace(0, h, plan.accelerator.leafs_per_bank + 1)
if segment.collimator.mlc.orientation.value == -1:
pen.setStyle(Qt.DashLine)
else:
pen.setStyle(Qt.SolidLine)
for l in range(plan.accelerator.leafs_per_bank):
bound1 = leafedges[l]
bound2 = leafedges[l + 1]
#left
coord = vert_zoom * getattr(segment.collimator.mlc.leftLeaves[l],
attr)
pen.setColor(Qt.green)
qp.setPen(pen)
qp.drawLine(w400 + coord, bound1, w400 + coord, bound2)
qp.drawLine(
w400 + coord - 50,
bound1,
w400 + coord,
bound1,
)
qp.drawLine(w400 + coord - 50, bound2, w400 + coord, bound2)
#right
coord = vert_zoom * getattr(segment.collimator.mlc.rightLeaves[l],
attr)
pen.setColor(Qt.blue)
qp.setPen(pen)
qp.drawLine(w400 + coord, bound1, w400 + coord, bound2)
qp.drawLine(w400 + coord + 50, bound1, w400 + coord, bound1)
qp.drawLine(w400 + coord + 50, bound2, w400 + coord, bound2)
#jaws
if segment.collimator.parallelJaw.orientation.value == -1:
pen.setStyle(Qt.DashLine)
else:
pen.setStyle(Qt.SolidLine)
# if segment.collimator.parallelJaw.orientation.value is not -1:
l, r = vert_zoom * getattr(segment.collimator.parallelJaw.j1,
attr), vert_zoom * getattr(
segment.collimator.parallelJaw.j2, attr)
pen.setColor(Qt.green)
pen.setWidth(2)
qp.setPen(pen)
qp.drawLine(w400 + l, 0, w400 + l, h)
pen.setColor(Qt.blue)
qp.setPen(pen)
qp.drawLine(w400 + r, 0, w400 + r, h)
if segment.collimator.perpendicularJaw.orientation.value == -1:
pen.setStyle(Qt.DashLine)
else:
pen.setStyle(Qt.SolidLine)
# if segment.collimator.perpendicularJaw.orientation.value is not -1:
t, b = hor_zoom * getattr(
segment.collimator.perpendicularJaw.j1, attr), hor_zoom * getattr(
segment.collimator.perpendicularJaw.j2, attr)
pen.setColor(Qt.cyan)
qp.setPen(pen)
qp.drawLine(0, h400 + t, w, h400 + t)
pen.setColor(Qt.magenta)
qp.setPen(pen)
qp.drawLine(0, h400 + b, w, h400 + b)
# fieldsize
x1, x2 = vert_zoom * segment.beamInfo.fieldMin.first, vert_zoom * segment.beamInfo.fieldMax.first
y1, y2 = hor_zoom * segment.beamInfo.fieldMin.second, hor_zoom * segment.beamInfo.fieldMax.second
pen.setColor(Qt.red)
qp.setPen(pen)
qp.drawLine(w400 + x1, h400 + y1, w400 + x1, h400 + y2)
qp.drawLine(w400 + x1, h400 + y1, w400 + x2, h400 + y1)
qp.drawLine(w400 + x1, h400 + y2, w400 + x2, h400 + y2)
qp.drawLine(w400 + x2, h400 + y1, w400 + x2, h400 + y2)
pen.setColor(Qt.black)
qp.setPen(pen)
qp.drawText(10, 10, "viewport: 40cm x 40cm")
qp.drawText(
10, 25,
f"isoCenter: {str(self.plan.beams[self.bi][0].beamInfo.isoCenter.x)[:5]},{str(self.plan.beams[self.bi][0].beamInfo.isoCenter.y)[:5]},{str(self.plan.beams[self.bi][0].beamInfo.isoCenter.z)[:5]}"
)
qp.drawText(10, 40, f"weight: {str(segment.beamInfo.relativeWeight)}")
qp.drawText(
10, 55,
f"gantryAngle: {str(getattr(segment.beamInfo.gantryAngle,attr))}")
qp.drawText(
10, 70,
f"collimatorAngle: {str(getattr(self.plan.beams[self.bi][0].beamInfo.collimatorAngle,attr))}"
)
qp.drawText(
10, 85,
f"couchAngle: {str(getattr(self.plan.beams[self.bi][0].beamInfo.couchAngle,attr))}"
)
qp.end()
class AnimBox(QGraphicsObject):
"""A Box that draws an outline when hover over.
Attributes
----------
hoverEnter: pyqtSignal
Emitted when the mouse hover into the box
hoverExit: pyqtSignal
Emitted when the mouse hover out of the box
"""
hoverEnter = pyqtSignal()
hoverExit = pyqtSignal()
def __init__(self, x, y, width, height, parent=None):
"""Prepares the box and animation
Parameters
----------
x: float
x position of the top-left corner of the box
y: float
y position of the top-left corner of the box
width: float
Width of the box
height: float
Height of the box
parent: object
Passed into QGraphicsObject init method
"""
super().__init__(parent=parent)
self.x = x
self.y = y
self.width = width
self.height = height
self.circumference = 2 * (width + height)
self.default_pen = QPen()
self.default_pen.setColor(Qt.white)
self.outline_pen = QPen()
self.outline_pen.setColor(Qt.white)
self.outline_pen.setWidth(5)
self.detected = False # Whether the mouse hover over the box
self.btn_rect = QRectF(self.x, self.y, self.width, self.height)
self.left = QLineF()
self.down = QLineF()
self.right = QLineF()
self.up = QLineF()
self.line_order = [self.up, self.right, self.down, self.left]
self.set_freeze(False)
self.length = 0
self.anim = QPropertyAnimation(self, b'length')
self.anim.setStartValue(0)
for t in range(1, 10):
self.anim.setKeyValueAt(t / 10, self.logistic_func(t / 10))
self.anim.setEndValue(self.circumference)
def set_freeze(self, freeze):
"""Set whether the box should accept the mouse events
Parameters
----------
freeze: bool
True to stop the box from accepting mouse inputs, False otherwise
"""
if freeze:
self.setAcceptedMouseButtons(Qt.NoButton)
self.setAcceptHoverEvents(False)
else:
self.setAcceptedMouseButtons(Qt.LeftButton)
self.setAcceptHoverEvents(True)
def toggle_anim(self, toggling):
"""Toggle the highlight animation to be play forward or backward
Parameters
----------
toggling: bool
True for forward, False for backwards
"""
if toggling:
self.anim.setDirection(QAbstractAnimation.Forward)
else:
self.anim.setDirection(QAbstractAnimation.Backward)
self.anim.start()
def logistic_func(self, x):
"""The logistic function that determines the animation motion
Parameters
----------
x: list or numpy array
Values to be feed into the function
Returns
-------
list or numpy array
Values of the logistic function corresponding to the input range
"""
return self.circumference / (1 + math.exp(-(x - 0.5) * 18))
def boundingRect(self):
"""Reimplemented from QGraphicsObject.
"""
return QRectF(self.x - 5, self.y - 5, self.width + 10,
self.height + 10)
def paint(self, painter, style, widget=None):
"""Reimplemented from QGraphicsObject. Draws the Box and the highlights.
"""
painter.setPen(self.outline_pen)
for line in self.line_order:
if line.length() > 1:
painter.drawLine(line)
painter.setPen(self.default_pen)
painter.drawRect(self.btn_rect)
@pyqtProperty(float)
def length(self):
"""float: The length of the highlight to be drawn.
When set, the length of the outlines are determined
"""
return self._length
@length.setter
def length(self, value):
self._length = value
remaining_length = value
if remaining_length >= 2 * self.width + self.height:
length_to_draw = remaining_length - (2 * self.width + self.height)
remaining_length -= length_to_draw
else:
length_to_draw = 0
self.line_order[3].setLine(self.x, self.y + self.height, self.x,
self.y + self.height - length_to_draw)
if remaining_length >= self.width + self.height:
length_to_draw = remaining_length - (self.width + self.height)
remaining_length -= length_to_draw
else:
length_to_draw = 0
self.line_order[2].setLine(self.x + self.width, self.y + self.height,
self.x + self.width - length_to_draw,
self.y + self.height)
if remaining_length >= self.width:
length_to_draw = remaining_length - self.width
remaining_length -= length_to_draw
else:
length_to_draw = 0
self.line_order[1].setLine(self.x + self.width, self.y,
self.x + self.width,
self.y + length_to_draw)
self.line_order[0].setLine(self.x, self.y, self.x + remaining_length,
self.y)
self.update()
def hoverEnterEvent(self, event):
"""Reimplemented hoverEnterEvent. Detect the mouse and toggle the animation
"""
if ~self.detected:
self.hoverEnter.emit()
self.detected = True
self.toggle_anim(True)
super().hoverEnterEvent(event)
def hoverLeaveEvent(self, event):
"""Reimplemented hoverLeaveEvent. Detect the mouse leaving and reverse the animation
"""
if self.detected:
self.hoverExit.emit()
self.detected = False
self.toggle_anim(False)
super().hoverLeaveEvent(event)
class NodeItem(GraphItem):
def __init__(self,
highlight_level,
bounding_box,
label,
shape,
color=None,
parent=None,
label_pos=None,
tooltip=None):
super(NodeItem, self).__init__(highlight_level, parent)
self._default_color = self._COLOR_BLACK if color is None else color
self._brush = QBrush(self._default_color)
self._label_pen = QPen()
self._label_pen.setColor(self._default_color)
self._label_pen.setJoinStyle(Qt.RoundJoin)
self._ellipse_pen = QPen(self._label_pen)
self._ellipse_pen.setWidth(1)
self._incoming_edges = set()
self._outgoing_edges = set()
self.parse_shape(shape, bounding_box)
self.addToGroup(self._graphics_item)
self._label = QGraphicsSimpleTextItem(label)
self._label.setFont(GraphItem._LABEL_FONT)
label_rect = self._label.boundingRect()
if label_pos is None:
label_rect.moveCenter(bounding_box.center())
else:
label_rect.moveCenter(label_pos)
self._label.setPos(label_rect.x(), label_rect.y())
self.addToGroup(self._label)
if tooltip is not None:
self.setToolTip(tooltip)
self.set_node_color()
self.setAcceptHoverEvents(True)
self.hovershape = None
def parse_shape(self, shape, bounding_box):
if shape in ('box', 'rect', 'rectangle'):
self._graphics_item = QGraphicsRectItem(bounding_box)
elif shape in ('ellipse', 'oval', 'circle'):
self._graphics_item = QGraphicsEllipseItem(bounding_box)
elif shape in ('box3d', ):
self._graphics_item = QGraphicsBox3dItem(bounding_box)
else:
print("Invalid shape '%s', defaulting to ellipse" % shape,
file=sys.stderr)
self._graphics_item = QGraphicsEllipseItem(bounding_box)
def set_hovershape(self, newhovershape):
self.hovershape = newhovershape
def shape(self):
if self.hovershape is not None:
path = QPainterPath()
path.addRect(self.hovershape)
return path
else:
return super(self.__class__, self).shape()
def add_incoming_edge(self, edge):
self._incoming_edges.add(edge)
def add_outgoing_edge(self, edge):
self._outgoing_edges.add(edge)
def set_node_color(self, color=None):
if color is None:
color = self._default_color
self._brush.setColor(color)
self._ellipse_pen.setColor(color)
self._label_pen.setColor(color)
self._graphics_item.setPen(self._ellipse_pen)
self._label.setBrush(self._brush)
self._label.setPen(self._label_pen)
def hoverEnterEvent(self, event):
# hovered node item in red
self.set_node_color(self._COLOR_RED)
if self._highlight_level > 1:
cyclic_edges = self._incoming_edges.intersection(
self._outgoing_edges)
# incoming edges in blue
incoming_nodes = set()
for incoming_edge in self._incoming_edges.difference(cyclic_edges):
incoming_edge.set_node_color(self._COLOR_BLUE)
incoming_edge.set_label_color(self._COLOR_BLUE)
if incoming_edge.from_node != self:
incoming_nodes.add(incoming_edge.from_node)
# outgoing edges in green
outgoing_nodes = set()
for outgoing_edge in self._outgoing_edges.difference(cyclic_edges):
outgoing_edge.set_node_color(self._COLOR_GREEN)
outgoing_edge.set_label_color(self._COLOR_GREEN)
if outgoing_edge.to_node != self:
outgoing_nodes.add(outgoing_edge.to_node)
# incoming/outgoing edges in teal
for edge in cyclic_edges:
edge.set_node_color(self._COLOR_TEAL)
if self._highlight_level > 2:
cyclic_nodes = incoming_nodes.intersection(outgoing_nodes)
# incoming nodes in blue
for incoming_node in incoming_nodes.difference(cyclic_nodes):
incoming_node.set_node_color(self._COLOR_BLUE)
# outgoing nodes in green
for outgoing_node in outgoing_nodes.difference(cyclic_nodes):
outgoing_node.set_node_color(self._COLOR_GREEN)
# incoming/outgoing nodes in teal
for node in cyclic_nodes:
node.set_node_color(self._COLOR_TEAL)
def hoverLeaveEvent(self, event):
self.set_node_color()
if self._highlight_level > 1:
for incoming_edge in self._incoming_edges:
incoming_edge.set_node_color()
incoming_edge.set_label_color()
if self._highlight_level > 2 and incoming_edge.from_node != self:
incoming_edge.from_node.set_node_color()
for outgoing_edge in self._outgoing_edges:
outgoing_edge.set_node_color()
outgoing_edge.set_label_color()
if self._highlight_level > 2 and outgoing_edge.to_node != self:
outgoing_edge.to_node.set_node_color()
def __init__(self):
super().__init__()
title = "Paint Application"
top = 400
left = 400
width = 800
height = 600
self.px_p_meter = 100
icon = "icons/pain.png"
self.setWindowTitle(title)
self.setGeometry(top, left, width, height)
self.setWindowIcon(QIcon(icon))
self.image = QImage(self.size(), QImage.Format_RGB32)
self.image.fill(Qt.white)
self.waypoints = []
self.drawing = False
self.brushSize = 5
self.brushColor = Qt.black
self.lastPoint = QPoint()
mainMenu = self.menuBar()
fileMenu = mainMenu.addMenu("File")
brushSize = mainMenu.addMenu("Brush Size")
brushColor = mainMenu.addMenu("Brush Color")
'''
saveAction = QAction(QIcon("icons/save.png"), "Save",self)
saveAction.setShortcut("Ctrl+S")
fileMenu.addAction(saveAction)
saveAction.triggered.connect(self.save)
'''
exportAction = QAction(QIcon("icons/export.png"), "Export Track", self)
exportAction.setShortcut("Ctrl+E")
fileMenu.addAction(exportAction)
exportAction.triggered.connect(self.exportTrack)
clearAction = QAction(QIcon("icons/clear.png"), "Clear", self)
clearAction.setShortcut("Ctrl+C")
fileMenu.addAction(clearAction)
clearAction.triggered.connect(self.clear)
threepxAction = QAction(QIcon("icons/threepx.png"), "3px", self)
brushSize.addAction(threepxAction)
threepxAction.triggered.connect(self.threePixel)
fivepxAction = QAction(QIcon("icons/fivepx.png"), "5px", self)
brushSize.addAction(fivepxAction)
fivepxAction.triggered.connect(self.fivePixel)
sevenpxAction = QAction(QIcon("icons/sevenpx.png"), "7px", self)
brushSize.addAction(sevenpxAction)
sevenpxAction.triggered.connect(self.sevenPixel)
ninepxAction = QAction(QIcon("icons/ninepx.png"), "9px", self)
brushSize.addAction(ninepxAction)
ninepxAction.triggered.connect(self.ninePixel)
blackAction = QAction(QIcon("icons/black.png"), "Black", self)
blackAction.setShortcut("Ctrl+B")
brushColor.addAction(blackAction)
blackAction.triggered.connect(self.blackColor)
whitekAction = QAction(QIcon("icons/white.png"), "White", self)
whitekAction.setShortcut("Ctrl+W")
brushColor.addAction(whitekAction)
whitekAction.triggered.connect(self.whiteColor)
redAction = QAction(QIcon("icons/red.png"), "Red", self)
redAction.setShortcut("Ctrl+R")
brushColor.addAction(redAction)
redAction.triggered.connect(self.redColor)
greenAction = QAction(QIcon("icons/green.png"), "Green", self)
greenAction.setShortcut("Ctrl+G")
brushColor.addAction(greenAction)
greenAction.triggered.connect(self.greenColor)
yellowAction = QAction(QIcon("icons/yellow.png"), "Yellow", self)
yellowAction.setShortcut("Ctrl+Y")
brushColor.addAction(yellowAction)
yellowAction.triggered.connect(self.yellowColor)
painter = QPainter(self.image)
painter.setBrush(Qt.black)
painter.setPen(QPen(Qt.black, 2, Qt.SolidLine))
painter.drawLine(10, 50, 10 + self.px_p_meter, 50)
pen = QPen(Qt.black)
pen.setWidth(2)
painter.setPen(pen)
font = QFont()
font.setFamily('Times')
font.setBold(True)
font.setPointSize(12)
painter.setFont(font)
painter.drawText(20 + self.px_p_meter, 55, "1 m")
def paintEvent(self, objQPaintEvent):
p = QPainter()
p.begin(self)
pen = QPen(Qt.black, 2, Qt.SolidLine)
p.setPen(pen)
p.drawLine(20, 15, 150, 15)
pen.setStyle(Qt.DashLine)
p.setPen(pen)
p.drawLine(20, 35, 150, 35)
pen.setStyle(Qt.DotLine)
p.setPen(pen)
p.drawLine(20, 55, 150, 55)
pen.setStyle(Qt.DashDotLine)
p.setPen(pen)
p.drawLine(20, 75, 150, 75)
pen.setStyle(Qt.DashDotDotLine)
p.setPen(pen)
p.drawLine(20, 95, 150, 95)
pen.setStyle(Qt.CustomDashLine)
pen.setDashPattern([1, 4, 5, 4])
p.setPen(pen)
p.drawLine(20, 115, 150, 115)
pen.setWidth(1)
pen.setStyle(Qt.SolidLine)
p.setPen(pen)
brush = QBrush(Qt.SolidPattern)
p.setBrush(brush)
p.drawRect(180, 10, 40, 30)
brush = QBrush(Qt.Dense5Pattern)
p.setBrush(brush)
p.drawRect(240, 10, 40, 30)
brush = QBrush(Qt.Dense7Pattern)
p.setBrush(brush)
p.drawRect(300, 10, 40, 30)
brush = QBrush(Qt.green, Qt.HorPattern)
p.setBrush(brush)
p.drawRect(180, 50, 40, 30)
brush = QBrush(Qt.green, Qt.VerPattern)
p.setBrush(brush)
p.drawRect(240, 50, 40, 30)
brush = QBrush(Qt.green, Qt.Dense6Pattern)
brush = QBrush(Qt.green, Qt.CrossPattern)
p.setBrush(brush)
p.drawRect(300, 50, 40, 30)
brush = QBrush(Qt.blue, Qt.BDiagPattern)
p.setBrush(brush)
p.drawRect(180, 90, 40, 30)
brush = QBrush(Qt.blue, Qt.FDiagPattern)
p.setBrush(brush)
p.drawRect(240, 90, 40, 30)
brush = QBrush(Qt.blue, Qt.DiagCrossPattern)
p.setBrush(brush)
p.drawRect(300, 90, 40, 30)
g = QLinearGradient(180, 130, 220, 160)
g.setColorAt(0, Qt.red)
g.setColorAt(1, Qt.blue)
brush = QBrush(g)
p.setBrush(brush)
p.drawRect(180, 130, 40, 30)
g = QRadialGradient(260, 145, 20)
g.setColorAt(0, Qt.red)
g.setColorAt(0.5, Qt.yellow)
g.setColorAt(1, Qt.blue)
p.setBrush(g)
p.drawRect(240, 130, 40, 30)
g = QConicalGradient(320, 145, 0)
g.setColorAt(0, Qt.red)
g.setColorAt(0.4, Qt.yellow)
g.setColorAt(0.8, Qt.blue)
g.setColorAt(1, Qt.red)
p.setBrush(g)
p.drawRect(300, 130, 40, 30)
brush = QBrush()
brush.setTexture(QPixmap(":appres.img/texture.jpg"))
p.setBrush(brush)
pen.setColor(Qt.transparent)
p.setPen(pen)
p.drawRect(15, 130, 135, 35)
p.end()
class CalibrationWidget(QWidget):
cursorPos = pyqtSignal(float, float, 'qint64')
def __init__(self, parent=None):
super().__init__(parent)
self._margin_x = 0.0
self._margin_y = 0.0
self._offset_x = 1.0
self._offset_y = 1.0
self._ampl_x = 1.0
self._ampl_y = 1.0
self._coeff_x = 5.0
self._coeff_y = 4.0
self._coeff_delta = 0.0
self._t = 0.0
self._circle_size = 20
self._pen = QPen()
self._pen.setWidth(2)
self._pen.setColor(Qt.black)
self._brush = QBrush(Qt.yellow)
self._elapsed_timer = QElapsedTimer()
self._timer = QTimer()
self._timer.setInterval(1000 / 60)
self._timer.timeout.connect(self.update)
self.resize(800, 600)
self.setWindowTitle('Eyetracker calibration')
self._elapsed_timer.start()
self._timer.start()
def resizeEvent(self, event):
w, h = self.width(), self.height()
self._margin_x = 0.05 * w
self._margin_y = 0.08 * h
self._offset_x = 0.5 * w
self._offset_y = 0.5 * h
self._ampl_x = 0.5 * (w - 2.0 * self._margin_x)
self._ampl_y = 0.5 * (h - 2.0 * self._margin_y)
self._circle_size = 0.05 * h
self._pen.setWidth(0.005 * h)
def paintEvent(self, event):
qp = QPainter()
qp.begin(self)
qp.setRenderHint(QPainter.Antialiasing)
elapsed = self._elapsed_timer.restart()
if elapsed > 100:
elapsed = 100
self._t += 0.0002 * elapsed
x = self._offset_x + \
self._ampl_x * math.sin(self._coeff_x * self._t + self._coeff_delta)
y = self._offset_y + \
self._ampl_y * math.sin(self._coeff_y * self._t)
qp.setPen(self._pen)
qp.setBrush(self._brush)
qp.drawEllipse(QPointF(x, y), self._circle_size, self._circle_size)
qp.end()
self.cursorPos.emit(x, y, QDateTime.currentMSecsSinceEpoch())
def drawGlyphFillAndStroke(
painter,
glyph,
scale,
drawFill=True,
drawStroke=True,
drawSelection=True,
drawComponentFill=True,
drawComponentStroke=False,
contourFillColor=None,
contourStrokeColor=None,
componentFillColor=None,
componentStrokeColor=None,
selectionColor=None,
partialAliasing=True,
):
if glyph.template:
if glyph.unicode is None:
return
text = chr(glyph.unicode)
font = glyph.font
height = 750
if font is not None and font.info.ascender:
height = font.info.ascender
painter.save()
font = platformSpecific.otherUIFont()
font.setPointSize(height)
painter.setFont(font)
color = QColor(Qt.lightGray)
color.setAlphaF(0.4)
painter.setPen(color)
metrics = painter.fontMetrics()
xOffset = -(metrics.width(text) - glyph.width) / 2
painter.translate(xOffset, 0)
painter.scale(1, -1)
painter.drawText(0, 0, text)
painter.restore()
return
# get the layer color
layer = glyph.layer
layerColor = None
if layer is not None and layer.color is not None:
layerColor = colorToQColor(layer.color)
if selectionColor is None:
selectionColor = defaultColor("glyphSelection")
# get the paths
contourPath = glyph.getRepresentation("defconQt.NoComponentsQPainterPath")
componentPath, selectedComponentPath, originPts = glyph.getRepresentation(
"TruFont.SelectedComponentsQPainterPath"
)
painter.save()
# fill
# contours
if drawFill:
if contourFillColor is None:
if layerColor is not None:
contourFillColor = layerColor
else:
contourFillColor = defaultColor("glyphContourFill")
painter.fillPath(contourPath, QBrush(contourFillColor))
# components
if drawComponentFill:
if componentFillColor is None:
if layerColor is not None:
componentFillColor = layerColor
else:
componentFillColor = defaultColor("glyphComponentFill")
selectedComponentFillColor = QColor(componentFillColor)
selectedComponentFillColor.setRed(0)
selectedComponentFillColor.setGreen(0)
selectedComponentFillColor.setBlue(0)
painter.fillPath(componentPath, QBrush(componentFillColor))
if drawSelection:
painter.fillPath(selectedComponentPath, QBrush(selectedComponentFillColor))
else:
painter.fillPath(selectedComponentPath, QBrush(componentFillColor))
# components origin
# TODO: make this a parameter, disable on sizes < MinDetails
if drawSelection:
painter.save()
pen = QPen(componentFillColor)
pen.setWidth(0)
painter.setPen(pen)
for x, y in originPts:
painter.drawLine(x, y + 5 * scale, x, y)
painter.drawLine(x, y, x + 4.5 * scale, y)
painter.restore()
# selection
if drawSelection:
selectionPath = glyph.getRepresentation("TruFont.SelectedContoursQPainterPath")
pen = QPen(selectionColor)
pen.setWidthF(3.5 * scale)
painter.setPen(pen)
painter.drawPath(selectionPath)
# stroke
if drawStroke:
# work out the color
if contourStrokeColor is None:
if layerColor is not None:
contourStrokeColor = layerColor
else:
contourStrokeColor = defaultColor("glyphContourStroke")
# contours
pen = QPen(contourStrokeColor)
pen.setWidth(0)
painter.setPen(pen)
if partialAliasing:
drawGlyphWithAliasedLines(painter, glyph)
else:
painter.drawPath(contourPath)
# components
if drawComponentStroke:
if componentStrokeColor is None:
if layerColor is not None:
componentStrokeColor = layerColor
else:
componentStrokeColor = defaultColor("glyphContourStroke")
pen = QPen(componentStrokeColor)
pen.setWidth(0)
painter.setPen(pen)
painter.drawPath(selectedComponentPath)
painter.drawPath(componentPath)
painter.restore()
class MyWindow(QWidget):
def __init__(self):
super(MyWindow, self).__init__()
self.ui = MainDialog()
self.ui.setupUi(self)
self.setup_custom_classes()
self.pen = QPen(QColor(250, 0, 0))
self.pen.setWidth(2)
self.brush = QBrush(QColor(250, 20, 20))
# ---- radio buttons selection ----
self.ui.radioButton.clicked.connect(self.update_TT)
self.ui.radioButton_2.clicked.connect(self.update_TT)
self.ui.radioButton_3.clicked.connect(self.update_TT)
# ---- clean button ----
self.ui.clean.clicked.connect(self.cleanup)
# ---- triangle parameters updated ----
self.ui.line_a.valueChanged.connect(self.update_triangle)
self.ui.line_b.valueChanged.connect(self.update_triangle)
self.ui.line_c.valueChanged.connect(self.update_triangle)
self.ui.angle.valueChanged.connect(self.update_triangle)
def setup_custom_classes(self):
self.ui.widget = MyWidget(self)
self.ui.widget.setGeometry(QRect(20, 20, 481, 521))
def keyPressEvent(self, e):
if e.key() == Qt.Key_Escape:
self.close()
return
if e.key() == Qt.Key_Return:
self.action()
def update_TT(self):
print('updating TT:', end=" ")
if self.ui.radioButton.isChecked():
print('TriangleType.RIGHT')
self.ui.widget.updateSelection(TriangleType.RIGHT)
self.ui.line_c.setEnabled(False)
self.ui.angle.setEnabled(False)
if self.ui.radioButton_2.isChecked():
print('TriangleType.ISOSCELES')
self.ui.widget.updateSelection(TriangleType.ISOSCELES)
self.ui.line_b.setEnabled(False)
self.ui.line_c.setEnabled(False)
self.ui.angle.setEnabled(True)
if self.ui.radioButton_3.isChecked():
print('TriangleType.EQUILATERAL')
self.ui.widget.updateSelection(TriangleType.EQUILATERAL)
self.ui.line_b.setEnabled(False)
self.ui.line_c.setEnabled(False)
self.ui.angle.setValue(60)
self.ui.angle.setEnabled(False)
def update_triangle(self):
# self.widget = MyWidget()
new = (int(self.ui.line_a.text()), int(self.ui.line_b.text()),
int(self.ui.line_c.text()))
angle = int(self.ui.angle.text())
self.ui.widget.update_current_triangle(new, angle)
def cleanup(self):
print('cleaning')
self.ui.widget.cleanup()
def paintEvent(self, paintEvent: QPaintEvent):
pass
def action(self):
pass
class StripChart(QWidget):
"""Permits display of a numerical quantitiy as well
as a plot of its history."""
def __init__(self,
ylim=[-1, 1],
buffer_length=ccfg.plot_buffer_length,
color=ccfg.plot_line_color,
line_width=ccfg.plot_line_width,
ytick_interval=None,
print_function=lambda val: '%0.1e' % val,
hlines=[0.0]):
super(StripChart, self).__init__()
self.layout = QVBoxLayout()
self.lbl = QLabel()
self.plot = QLabel()
self.pixmap = QPixmap()
self.buf = np.zeros(buffer_length)
self.buffer_length = buffer_length
self.buffer_current_index = 0
self.layout.addWidget(self.lbl)
self.layout.addWidget(self.plot)
self.setLayout(self.layout)
self.x = np.arange(buffer_length)
self.hlines = hlines
self.data_y_max = ylim[1]
self.data_y_min = ylim[0]
if ytick_interval is not None:
t0 = np.fix(float(self.data_y_min) /
float(ytick_interval)) * ytick_interval
t1 = np.fix(float(self.data_y_max) /
float(ytick_interval)) * ytick_interval
self.yticks = np.arange(t0, t1, ytick_interval)
else:
self.yticks = []
self.plot_width_px = ccfg.plot_width_px
self.plot_height_px = ccfg.plot_height_px
self.xtick0 = 0
self.xtick1 = ccfg.plot_xtick_length
self.plot.setMinimumWidth(ccfg.plot_width_px)
self.lbl.setMinimumWidth(ccfg.plot_width_px)
self.xscale = float(ccfg.plot_width_px) / float(self.buffer_length - 1)
# there's a slight penalty for drawing a 32 bit pixmap instead of an 8
# bit pixmap, but it dowsn't look like it really affects performance
# so it's probably safe to make this false
permit_only_gray_plots = False
if permit_only_gray_plots:
self.bmp = np.ones((ccfg.plot_height_px, ccfg.plot_width_px),
dtype=np.uint8) * 255
bpl = int(self.bmp.nbytes / ccfg.plot_height_px)
self.plot_background = QImage(self.bmp, ccfg.plot_width_px,
ccfg.plot_height_px, bpl,
QImage.Format_Indexed8)
else:
A = np.ones((ccfg.plot_height_px, ccfg.plot_width_px),
dtype=np.uint32) * ccfg.plot_background_color[3]
R = np.ones((ccfg.plot_height_px, ccfg.plot_width_px),
dtype=np.uint32) * ccfg.plot_background_color[0]
G = np.ones((ccfg.plot_height_px, ccfg.plot_width_px),
dtype=np.uint32) * ccfg.plot_background_color[1]
B = np.ones((ccfg.plot_height_px, ccfg.plot_width_px),
dtype=np.uint32) * ccfg.plot_background_color[2]
val = (A << 24 | R << 16 | G << 8 | B).flatten()
bpl = int(val.nbytes / ccfg.plot_height_px)
self.plot_background = QImage(val, ccfg.plot_width_px,
ccfg.plot_height_px, bpl,
QImage.Format_ARGB32)
self.pixmap.convertFromImage(self.plot_background)
self.lbl.setFixedHeight(ccfg.caption_height_px * 2)
self.setMinimumWidth(ccfg.plot_width_px)
self.setMinimumHeight(ccfg.plot_height_px + ccfg.caption_height_px * 2)
self.print_function = print_function
self.plot.setFrameShape(QFrame.Box)
self.plot.setLineWidth(1)
self.pen = QPen()
self.pen.setColor(QColor(*color))
self.pen.setWidth(line_width)
self.ytick_pen = QPen()
self.ytick_pen.setColor(QColor(0, 0, 0, 255))
self.ytick_pen.setWidth(0.5)
self.ytick_pen.setStyle(Qt.DotLine)
self.xtick_pen = QPen()
self.xtick_pen.setColor(QColor(0, 0, 0, 255))
self.xtick_pen.setWidth(2.0)
self.xtick_pen.setStyle(Qt.SolidLine)
self.hline_pen = QPen()
self.hline_pen.setColor(QColor(0, 0, 0, 255))
self.hline_pen.setWidth(1.0)
self.hline_pen.setStyle(Qt.SolidLine)
self.painter = QPainter()
def setText(self, new_text):
self.lbl.setText(new_text)
def setValue(self, new_value):
self.buf[self.buffer_current_index] = new_value
self.buffer_current_index = (self.buffer_current_index +
1) % self.buffer_length
self.setText('%s\nsmoothed:%s' %
(self.print_function(new_value),
self.print_function(self.buf.mean())))
def scale_y(self, vec):
h = self.plot.height()
out = (h - (vec - self.data_y_min) /
(self.data_y_max - self.data_y_min) * h)
return out
def setAlignment(self, new_alignment):
self.lbl.setAlignment(new_alignment)
def paintEvent(self, ev):
pixmap = QPixmap()
pixmap.convertFromImage(self.plot_background)
self.painter.begin(pixmap)
self.painter.setPen(self.ytick_pen)
temp = self.scale_y(
np.array(
list(self.buf[self.buffer_current_index:]) +
list(self.buf[:self.buffer_current_index])))
for yt in self.yticks:
self.painter.drawLine(
QLine(0, self.scale_y(yt), self.buffer_length * self.xscale,
self.scale_y(yt)))
self.painter.setPen(self.hline_pen)
for hline in self.hlines:
self.painter.drawLine(
QLine(0, self.scale_y(hline), self.buffer_length * self.xscale,
self.scale_y(hline)))
self.painter.setPen(self.pen)
for idx in range(self.buffer_length - 1):
x1 = (idx) * self.xscale
x2 = (idx + 1) * self.xscale
y1 = temp[idx]
y2 = temp[idx + 1]
self.painter.drawLine(QLine(x1, y1, x2, y2))
interval = self.buffer_length // 10
interval = ccfg.plot_xtick_interval
if idx % interval == 0:
self.painter.setPen(self.xtick_pen)
self.painter.drawLine(
QLine((x1 - self.buffer_current_index * self.xscale) %
(self.buffer_length * self.xscale), self.xtick0,
(x1 - self.buffer_current_index * self.xscale) %
(self.buffer_length * self.xscale), self.xtick1))
self.painter.setPen(self.pen)
#if True:#20<self.buffer_current_index<80:
# painter.drawEllipse(x1,y1,x2,y2)
self.painter.end()
self.plot.setPixmap(pixmap)
class QtRoundProgressBar(QWidget):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self._initialized = False
def setup(self,
bounds = [0, 100], angleBounds = [-45, 225], fillDirection = -1, colors = [QColor('red'), QColor('black'), QColor('white')],
thickness = [10, 0], capType = [0, 0], edgesRemoval = [0, 0]
):
self._current_value = bounds[0]
# Angle Bounds
self._angle_bounds = angleBounds
self._max_angle = self._angle_bounds[1] - self._angle_bounds[0]
# Bounds
self._bounds = bounds
self._bounds_range = self._bounds[1] - self._bounds[0]
mul = (self._current_value - self._bounds[0]) / self._bounds_range
self._current_value = self._bounds_range * mul + self._bounds[0]
self._target_angle = self._current_angle = (self._max_angle / self._bounds_range * (self._current_value - self._bounds[0]))
# Fill Direction
self._fill_direction = fillDirection
if self._fill_direction == 0:
self._mid = (self._angle_bounds[1] - self._angle_bounds[0]) / 2 + self._angle_bounds[0]
# Colors [0 = foreground color, 1 = background color, 2 = border color]
self._colors = colors
# Thickness [0 = thickness, 1 = border thickness]
self._thickness = thickness
self._arc_ofst = math.ceil((self._thickness[0] + self._thickness[1]) / 2.0)
self._rect_arc = QRect(
self._arc_ofst, self._arc_ofst,
self.width() - self._arc_ofst * 2.0, self.height() - self._arc_ofst * 2.0
)
# Cap
self._cap = capType
# Edge Removal
self._edgesRemoval = edgesRemoval
# Internal variables
self._pen = QPen(self._colors[0], self._thickness[0], Qt.SolidLine)
self._pen.setWidth(self._thickness[0])
# Offset caused by SquareCap and RoundCap when border is enabled
self._ofst1 = [0, 0] # This offset is required only if the border is enabled
self._ofst2 = [0, 0] # This offset is additional for Qt.RoundCap (Needed regardless of border)
for i in range(2):
if self._thickness[1] > 0:
if self._cap[i] ==1:
self._ofst1[i] = 180 / math.pi * (((self._thickness[0] * 0.05) / 2) / (self._rect_arc.width() / 2))
# Additional Offset specific to RoundCap
if self._cap[i] == 1:
self._ofst2[i] = 180 / math.pi * ((self._thickness[0] / 2) / (self._rect_arc.width() / 2))
# Ready Flag
self._initialized = True
def setValue(self, val):
self._current_value = max(self._bounds[0], min(val, self._bounds[1]))
self._target_angle = (self._max_angle / self._bounds_range * (self._current_value - self._bounds[0]))
def redraw(self):
self._redraw = True
def setGeometry(self, x, y, w, h):
""" Override setGeometry method """
super().setGeometry(x, y, w, h)
# Recompute container
self._rect = QRect(0, 0, self.width(), self.height())
if self._initialized:
self._arc_ofst = math.ceil((self._thickness[0] + self._thickness[1]) / 2.0)
self._rect_arc = QRect(
self._arc_ofst, self._arc_ofst,
self.width() - self._arc_ofst * 2.0, self.height() - self._arc_ofst * 2.0
)
# Reset PixMaps
self._background_buffer = QPixmap(self.width(), self.height())
self._background_buffer.fill(Qt.transparent)
self._foreground_t_buffer = QPixmap(self.width(), self.height())
self._foreground_t_buffer.fill(Qt.transparent)
self._foreground_buffer = QPixmap(self.width(), self.height())
self._foreground_buffer.fill(Qt.transparent)
def paintEvent(self, e):
""" Override Paint Function """
if not self._initialized: return
paint = QPainter()
# Draw the bar components
if self._redraw:
self._background_buffer.fill(Qt.transparent)
self._foreground_t_buffer.fill(Qt.transparent)
# Draw Border
paint.begin(self._background_buffer)
paint.setRenderHint(QPainter.Antialiasing)
if self._thickness[1] > 0:
self._pen.setColor(self._colors[2])
# Process each cap
startAngle = self._angle_bounds[0]
angleStep = self._max_angle / 2 + self._max_angle / 4
# Draw Bar Border
for i in range(2):
self._pen.setWidth(self._thickness[0] + self._thickness[1])
self._pen.setCapStyle(Qt.RoundCap if self._cap[i] == 1 else Qt.FlatCap)
paint.setPen(self._pen)
# Draw Border as a full bar
paint.drawArc(self._rect_arc, (startAngle + self._ofst1[i] + self._ofst2[i]) * 16.0, (angleStep - self._ofst1[i] * (i + 1) - self._ofst2[i] * (i + 1)) * 16.0)
# Erase insides of the bar to create the border (Necessary to enable the use of transparent background)
paint.setCompositionMode(QPainter.CompositionMode_Clear)
self._pen.setWidth(self._thickness[0])
paint.setPen(self._pen)
paint.drawArc(self._rect_arc, (startAngle + self._ofst2[i]) * 16.0, (angleStep - self._ofst2[i] * (i + 1)) * 16.0)
paint.setCompositionMode(QPainter.CompositionMode_SourceOver)
startAngle += angleStep - self._max_angle / 2
if self._cap[0] == 0 or self._cap[1] == 0:
self._pen.setWidth(self._thickness[1])
self._pen.setCapStyle(Qt.FlatCap)
paint.setPen(self._pen)
outerRadius = self.width() / 2
maxThickness = self._thickness[0] + self._thickness[1]
for i in range(2):
if self._cap[i] == 0:
rads = math.radians(self._angle_bounds[i])
p1 = [
(self.width() / 2) + (self.width() / 2 - maxThickness) * math.cos(rads),
(self.height() / 2) - (self.height() / 2 - maxThickness) * math.sin(rads)
]
p2 = [
(self.width() / 2) + (self.width() / 2) * math.cos(rads),
(self.height() / 2) - (self.height() / 2) * math.sin(rads)
]
paint.drawLine(p1[0], p1[1], p2[0], p2[1])
self._pen.setWidth(self._thickness[0])
# Draw Square Border End Caps
# Outer edge removal
if self._edgesRemoval[0] > 0 or self._edgesRemoval[1] > 0:
paint.setCompositionMode(QPainter.CompositionMode_Clear)
rt = 2 if (self._thickness[0] + self._thickness[1]) % 2 != 0 else 1
self._pen.setWidth(self._thickness[1] + rt)
paint.setPen(self._pen)
if self._edgesRemoval[0] > 0:
# Outer edge removal
paint.drawArc(self._rect, 0 * 16.0, 360 * 16.0)
if self._edgesRemoval[1] > 0:
# Inner edge removal
t_rect = QRect(self._arc_ofst * 2, self._arc_ofst * 2, self.width() - self._arc_ofst * 4, self.height() - self._arc_ofst * 4)
paint.drawArc(t_rect, 0 * 16.0, 360 * 16.0)
self._pen.setWidth(self._thickness[0])
paint.setCompositionMode(QPainter.CompositionMode_SourceOver)
else:
self._pen.setWidth(self._thickness[0])
# Draw Background
startAngle = self._angle_bounds[0]
angleStep = self._max_angle / 2 + self._max_angle / 4
self._pen.setColor(self._colors[1])
for i in range(2):
self._pen.setCapStyle(Qt.RoundCap if self._cap[i] == 1 else Qt.FlatCap)
paint.setPen(self._pen)
paint.drawArc(self._rect_arc, (startAngle + self._ofst2[i]) * 16.0, (angleStep - self._ofst2[i] * (i + 1)) * 16.0)
startAngle += angleStep - self._max_angle / 2
paint.end()
# Draw Foreground
paint.begin(self._foreground_t_buffer)
paint.setRenderHint(QPainter.Antialiasing)
if self._thickness[1] > 0:
self._pen.setWidth(self._thickness[0] - 2)
else:
self._pen.setWidth(self._thickness[0])
self._pen.setColor(self._colors[0])
startAngle = self._angle_bounds[0]
angleStep = self._max_angle / 2 + self._max_angle / 4
for i in range(2):
self._pen.setCapStyle(Qt.RoundCap if self._cap[i] == 1 else Qt.FlatCap)
paint.setPen(self._pen)
paint.drawArc(self._rect_arc, (startAngle + self._ofst2[i]) * 16.0, (angleStep - self._ofst2[i] * (i + 1)) * 16.0)
startAngle += angleStep - self._max_angle / 2
paint.end()
# Set pen to foreground styling
self._pen.setCapStyle(Qt.FlatCap)
self._pen.setWidth(self._thickness[0] + 2)
# Update Flags
self._redraw = False
# Cut foreground to appropriate length
if self._current_angle != self._target_angle or self._redraw:
paint.begin(self._foreground_buffer)
paint.setCompositionMode(QPainter.CompositionMode_SourceOver)
paint.drawPixmap(self._rect, self._foreground_t_buffer)
paint.setRenderHint(QPainter.Antialiasing)
paint.setCompositionMode(QPainter.CompositionMode_Clear)
paint.setPen(self._pen)
if self._fill_direction > 0:
paint.drawArc(self._rect_arc, (self._angle_bounds[0] + self._target_angle) * 16.0, (self._max_angle - self._target_angle + 1.0) * 16.0)
elif self._fill_direction < 0:
paint.drawArc(
self._rect_arc,
(self._angle_bounds[0] - 1.0) * 16.0, (self._max_angle - self._target_angle) * 16.0
)
else:
ofst = self._target_angle / 2
paint.drawArc(self._rect_arc, self._angle_bounds[0] * 16.0, ((self._angle_bounds[1] - (self._mid + ofst))) * 16.0)
paint.drawArc(self._rect_arc, (self._mid + ofst) * 16.0, ((self._max_angle - self._target_angle / 2)) * 16.0)
paint.setCompositionMode(QPainter.CompositionMode_SourceOver)
paint.end()
# Update Flags
self._current_angle = self._target_angle
paint.begin(self)
paint.setRenderHint(QPainter.SmoothPixmapTransform)
paint.drawPixmap(self._rect, self._background_buffer)
if self._current_angle > 0:
paint.drawPixmap(self._rect, self._foreground_buffer)
paint.end()
class App(QWidget):
def __init__(self):
super().__init__()
self.title = "Pygargue"
self.table_left = 0
self.table_top = 0
self.table_width = 1200
self.table_height = 800
self.x_press = None
self.y_press = None
self.obstacles = [] # type:list[Obstacle]
self.highlighted_point = {} # type: dict[int, Point]
self.highlighted_angles = {} # type: dict[int, float]
self.feed_forward_arrow = None # ((xs, ys), (xe, ye))
self.feed_forward_arrow_enabled = False
self.robot_speed_command = [0, 0, 0]
self.repaint_mutex = Lock()
self.ivy = Ivy(self)
self.repaint_mutex.acquire()
self.initUI()
self.repaint_mutex.release()
def initUI(self):
self.setWindowTitle(self.title)
self.setGeometry(self.table_left, self.table_top, self.table_width, self.table_height)
palette = QPalette()
palette.setColor(QPalette.Background, QColor(*BACKGROUND_COLOR))
self.setAutoFillBackground(True)
self.setPalette(palette)
self.pen = QPen(QColor(255,0,0))
self.pen.setWidth(1)
self.brush = QBrush(QColor(0,0,0))
self.robot = QRobot(self)
# painter = QPainter(self)
# painter.setPen(self.pen)
# painter.setBrush(self.brush)
# painter.drawPolygon(self.polygon)
self.show()
def paintEvent(self, event):
self.table_width = min(self.geometry().width(), self.geometry().height() * 3/2)
# The table will keep the 3/2 ratio whatever the window ratio
self.table_height = min(self.geometry().height(), self.geometry().width() * 2/3)
painter = QPainter(self)
self.paint_background(painter, 0, 0, self.table_width - 1, self.table_height - 1)
painter.setPen(QPen(QColor(255,0,0)))
painter.drawLine(0, 0, 0, self.table_height-1)
painter.drawLine(0, self.table_height-1, self.table_width-1, self.table_height-1)
painter.drawLine(self.table_width-1, self.table_height-1, self.table_width-1, 0)
painter.drawLine(self.table_width-1, 0, 0, 0)
for obs in self.obstacles:
painter.setPen(QPen(QColor(*OBSTACLE_COLOR)))
painter.setBrush(QBrush(QColor(*OBSTACLE_COLOR)))
draw_function_name, draw_object = obs.to_qobject(0, 0, self.table_width - 1, self.table_height - 1)
paint_function = getattr(painter, draw_function_name) # get the method of painter
paint_function(draw_object)
painter.setPen(QPen(QColor(*OBSTACLE_COLOR, 150)))
painter.setBrush(QBrush(QColor(*OBSTACLE_COLOR, 150)))
draw_function_name, draw_object = obs.to_qobject(0, 0, self.table_width - 1, self.table_height - 1,
inflate_radius=self.robot.radius)
paint_function = getattr(painter, draw_function_name) # get the method of painter
paint_function(draw_object)
for pt in self.highlighted_point.values():
pt.paint(painter, 0, 0, self.table_width - 1, self.table_height - 1)
self.robot.paint(painter, 0, 0, self.table_width - 1, self.table_height - 1)
self.robot.paint_angles(self.highlighted_angles, painter, 0, 0, self.table_width - 1, self.table_height - 1)
self.paint_feedforward(painter)
@pyqtSlot()
def on_quit(self):
self.ivy.stop()
def paint_background(self, painter, x_offset, y_offset, width, height):
old_brush = painter.brush()
old_pen = painter.pen()
width_factor = width / 3000
height_factor = height / 2000
start_green_zone = QPolygonF()
start_green_zone.append(QPointF(width - (0 * width_factor + x_offset), 2000 * height_factor + y_offset))
start_green_zone.append(QPointF(width - (0 * width_factor + x_offset), 1350 * height_factor + y_offset))
start_green_zone.append(QPointF(width - (400 * width_factor + x_offset), 1350 * height_factor + y_offset))
start_green_zone.append(QPointF(width - (400 * width_factor + x_offset), 2000 * height_factor + y_offset))
painter.setPen(QPen(QColor(97, 153, 59)))
painter.setBrush(QBrush(QColor(97, 153, 59)))
painter.drawPolygon(start_green_zone)
start_orange_zone = QPolygonF()
start_orange_zone.append(QPointF(width - (2600 * width_factor + x_offset), 2000 * height_factor + y_offset))
start_orange_zone.append(QPointF(width - (3000 * width_factor + x_offset), 2000 * height_factor + y_offset))
start_orange_zone.append(QPointF(width - (3000 * width_factor + x_offset), 1350 * height_factor + y_offset))
start_orange_zone.append(QPointF(width - (2600 * width_factor + x_offset), 1350 * height_factor + y_offset))
painter.setPen(QPen(QColor(208, 93, 40)))
painter.setBrush(QBrush(QColor(208, 93, 40)))
painter.drawPolygon(start_orange_zone)
construction_zone_green = QPolygonF()
construction_zone_green.append(QPointF(width - (400 * width_factor + x_offset), 1820 * height_factor + y_offset))
construction_zone_green.append(QPointF(width - (400 * width_factor + x_offset), 2000 * height_factor + y_offset))
construction_zone_green.append(QPointF(width - (960 * width_factor + x_offset), 2000 * height_factor + y_offset))
construction_zone_green.append(QPointF(width - (960 * width_factor + x_offset), 1820 * height_factor + y_offset))
painter.setPen(QPen(QColor(97, 153, 59)))
painter.setBrush(QBrush(QColor(0, 0, 0, 0)))
painter.drawPolygon(construction_zone_green)
construction_zone_orange = QPolygonF()
construction_zone_orange.append(QPointF(width - (2040 * width_factor + x_offset), 1820 * height_factor + y_offset))
construction_zone_orange.append(QPointF(width - (2040 * width_factor + x_offset), 2000 * height_factor + y_offset))
construction_zone_orange.append(QPointF(width - (2600 * width_factor + x_offset), 2000 * height_factor + y_offset))
construction_zone_orange.append(QPointF(width - (2600 * width_factor + x_offset), 1820 * height_factor + y_offset))
painter.setPen(QPen(QColor(208, 93, 40)))
painter.setBrush(QBrush(QColor(0, 0, 0, 0)))
painter.drawPolygon(construction_zone_orange)
white_line = QPolygonF()
white_line.append(QPointF(width - (1120 * width_factor + x_offset),
2000 * height_factor + y_offset))
white_line.append(QPointF(width - (1140 * width_factor + x_offset),
2000 * height_factor + y_offset))
white_line.append(QPointF(width - (1140 * width_factor + x_offset),
1660 * height_factor + y_offset))
white_line.append(QPointF(width - (1490 * width_factor + x_offset),
1660 * height_factor + y_offset))
white_line.append(QPointF(width - (1490 * width_factor + x_offset),
1700 * height_factor + y_offset))
white_line.append(QPointF(width - (1510 * width_factor + x_offset),
1700 * height_factor + y_offset))
white_line.append(QPointF(width - (1510 * width_factor + x_offset),
1660 * height_factor + y_offset))
white_line.append(QPointF(width - (1860 * width_factor + x_offset),
1660 * height_factor + y_offset))
white_line.append(QPointF(width - (1860 * width_factor + x_offset),
2000 * height_factor + y_offset))
white_line.append(QPointF(width - (1880 * width_factor + x_offset),
2000 * height_factor + y_offset))
white_line.append(QPointF(width - (1880 * width_factor + x_offset),
1660 * height_factor + y_offset))
white_line.append(QPointF(width - (3000 * width_factor + x_offset),
1660 * height_factor + y_offset))
white_line.append(QPointF(width - (3000 * width_factor + x_offset),
1640 * height_factor + y_offset))
white_line.append(QPointF(width - (2400 * width_factor + x_offset),
1640 * height_factor + y_offset))
white_line.append(QPointF(width - (2400 * width_factor + x_offset),
1170 * height_factor + y_offset))
white_line.append(QPointF(width - (2700 * width_factor + x_offset),
1170 * height_factor + y_offset))
white_line.append(QPointF(width - (2700 * width_factor + x_offset),
1150 * height_factor + y_offset))
white_line.append(QPointF(width - (2400 * width_factor + x_offset),
1150 * height_factor + y_offset))
white_line.append(QPointF(width - (2400 * width_factor + x_offset),
320 * height_factor + y_offset))
white_line.append(QPointF(width - (2380 * width_factor + x_offset),
320 * height_factor + y_offset))
white_line.append(QPointF(width - (2380 * width_factor + x_offset),
1150 * height_factor + y_offset))
white_line.append(QPointF(width - (2150 * width_factor + x_offset),
1150 * height_factor + y_offset))
white_line.append(QPointF(width - (2150 * width_factor + x_offset),
1170 * height_factor + y_offset))
white_line.append(QPointF(width - (2380 * width_factor + x_offset),
1170 * height_factor + y_offset))
white_line.append(QPointF(width - (2380 * width_factor + x_offset),
1640 * height_factor + y_offset))
white_line.append(QPointF(width - (1510 * width_factor + x_offset),
1640 * height_factor + y_offset))
white_line.append(QPointF(width - (1510 * width_factor + x_offset),
1600 * height_factor + y_offset))
white_line.append(QPointF(width - (1490 * width_factor + x_offset),
1600 * height_factor + y_offset))
white_line.append(QPointF(width - (1490 * width_factor + x_offset),
1640 * height_factor + y_offset))
white_line.append(QPointF(width - (620 * width_factor + x_offset),
1640 * height_factor + y_offset))
white_line.append(QPointF(width - (620 * width_factor + x_offset),
1170 * height_factor + y_offset))
white_line.append(QPointF(width - (850 * width_factor + x_offset),
1170 * height_factor + y_offset))
white_line.append(QPointF(width - (850 * width_factor + x_offset),
1150 * height_factor + y_offset))
white_line.append(QPointF(width - (620 * width_factor + x_offset),
1150 * height_factor + y_offset))
white_line.append(QPointF(width - (620 * width_factor + x_offset),
320 * height_factor + y_offset))
white_line.append(QPointF(width - (600 * width_factor + x_offset),
320 * height_factor + y_offset))
white_line.append(QPointF(width - (600 * width_factor + x_offset),
1150 * height_factor + y_offset))
white_line.append(QPointF(width - (300 * width_factor + x_offset),
1150 * height_factor + y_offset))
white_line.append(QPointF(width - (300 * width_factor + x_offset),
1170 * height_factor + y_offset))
white_line.append(QPointF(width - (600 * width_factor + x_offset),
1170 * height_factor + y_offset))
white_line.append(QPointF(width - (600 * width_factor + x_offset),
1640 * height_factor + y_offset))
white_line.append(QPointF(width - (0 * width_factor + x_offset),
1640 * height_factor + y_offset))
white_line.append(QPointF(width - (0 * width_factor + x_offset),
1660 * height_factor + y_offset))
white_line.append(QPointF(width - (1120 * width_factor + x_offset),
1660 * height_factor + y_offset))
painter.setPen(QPen(QColor(255, 255, 255)))
painter.setBrush(QBrush(QColor(255, 255, 255, 255)))
painter.drawPolygon(white_line)
painter.setPen(old_pen)
painter.setBrush(old_brush)
def paint_feedforward(self, painter):
if self.feed_forward_arrow is not None and self.feed_forward_arrow_enabled:
painter.setPen(QPen(QColor(*FEEDFORWARD_ARROW_COLOR)))
painter.setBrush(QBrush(QColor(*FEEDFORWARD_ARROW_COLOR)))
painter.drawLine(QPointF(*self.feed_forward_arrow[0]), QPointF(*self.feed_forward_arrow[1]))
angle = math.atan2(self.feed_forward_arrow[1][1] - self.feed_forward_arrow[0][1],
self.feed_forward_arrow[1][0] - self.feed_forward_arrow[0][0])
painter.drawLine(QPointF(*self.feed_forward_arrow[1]), QPointF(
self.feed_forward_arrow[1][0] + 10 * math.cos(angle + math.radians(150)),
self.feed_forward_arrow[1][1] + 10 * math.sin(angle + math.radians(150))))
painter.drawLine(QPointF(*self.feed_forward_arrow[1]), QPointF(
self.feed_forward_arrow[1][0] + 10 * math.cos(angle - math.radians(150)),
self.feed_forward_arrow[1][1] + 10 * math.sin(angle - math.radians(150))))
def move_robot(self, x, y, theta):
self.robot.position = (x, y)
self.robot.orientation = theta
self.repaint_mutex.acquire()
self.repaint()
self.repaint_mutex.release()
def new_trajectory(self, trajectory):
self.robot.trajectory = trajectory
self.repaint_mutex.acquire()
self.repaint()
self.repaint_mutex.release()
def keyPressEvent(self, event:QKeyEvent):
if event.isAutoRepeat():
return
key = event.key()
if key == Qt.Key_G:
img = ObstacleMap(self.obstacles, GRAPH_TABLE_RATIO, self.robot.radius)
print("dumping")
img.dump_obstacle_grid_to_file("graph.txt")
elif key == Qt.Key_Ampersand:
self.ivy.send_action(1)
elif key == Qt.Key_Eacute:
self.ivy.send_action(2)
elif key == Qt.Key_QuoteDbl:
self.ivy.send_action(3)
elif key == Qt.Key_Apostrophe:
self.ivy.send_action(4)
elif key == Qt.Key_ParenLeft:
self.ivy.send_action(5)
elif key == Qt.Key_Minus:
self.ivy.send_action(6)
elif key == Qt.Key_Egrave:
self.ivy.send_action(7)
elif key == Qt.Key_Underscore:
self.ivy.send_action(8)
elif key == Qt.Key_Ccedilla:
self.ivy.send_action(9)
elif key == Qt.Key_Agrave:
self.ivy.send_action(10)
elif key == Qt.Key_ParenRight:
self.ivy.send_action(11)
elif key == Qt.Key_Equal:
self.ivy.send_action(12)
elif key == Qt.Key_Z:
self.robot_speed_command[1] = -1
self.ivy.send_speed_direction(self.robot_speed_command)
elif key == Qt.Key_Q:
self.robot_speed_command[0] = 1
self.ivy.send_speed_direction(self.robot_speed_command)
elif key == Qt.Key_S:
self.robot_speed_command[1] = 1
self.ivy.send_speed_direction(self.robot_speed_command)
elif key == Qt.Key_D:
self.robot_speed_command[0] = -1
self.ivy.send_speed_direction(self.robot_speed_command)
elif key == Qt.Key_A:
self.robot_speed_command[2] = 1
self.ivy.send_speed_direction(self.robot_speed_command)
elif key == Qt.Key_E:
self.robot_speed_command[2] = -1
self.ivy.send_speed_direction(self.robot_speed_command)
def keyReleaseEvent(self, event:QKeyEvent):
if event.isAutoRepeat():
return
key = event.key()
if key == Qt.Key_Z:
self.robot_speed_command[1] = 0
self.ivy.send_speed_direction(self.robot_speed_command)
elif key == Qt.Key_Q:
self.robot_speed_command[0] = 0
self.ivy.send_speed_direction(self.robot_speed_command)
elif key == Qt.Key_S:
self.robot_speed_command[1] = 0
self.ivy.send_speed_direction(self.robot_speed_command)
elif key == Qt.Key_D:
self.robot_speed_command[0] = 0
self.ivy.send_speed_direction(self.robot_speed_command)
elif key == Qt.Key_A:
self.robot_speed_command[2] = 0
self.ivy.send_speed_direction(self.robot_speed_command)
elif key == Qt.Key_E:
self.robot_speed_command[2] = 0
self.ivy.send_speed_direction(self.robot_speed_command)
def mousePressEvent(self, event:QMouseEvent):
width_factor = self.table_width / 3000
height_factor = self.table_height / 2000
self.x_press = event.x() / width_factor
self.y_press = event.y() / height_factor
self.feed_forward_arrow = ((event.x(), event.y()), (0, 0))
def mouseMoveEvent(self, event:QMouseEvent):
if self.feed_forward_arrow is not None and math.hypot(event.x() - self.feed_forward_arrow[0][0],
event.y() - self.feed_forward_arrow[0][1]) >= THRESHOLD_DISTANCE_ANGLE_SELECTION:
self.feed_forward_arrow = (self.feed_forward_arrow[0], (event.x(), event.y()))
self.feed_forward_arrow_enabled = True
self.repaint_mutex.acquire()
self.repaint()
self.repaint_mutex.release()
def mouseReleaseEvent(self, event:QMouseEvent):
if math.hypot(event.x() - self.feed_forward_arrow[0][0], event.y() - self.feed_forward_arrow[0][1]) < THRESHOLD_DISTANCE_ANGLE_SELECTION:
self.ivy.send_go_to(3000 - int(self.x_press), int(self.y_press))
else:
width_factor = self.table_width / 3000
height_factor = self.table_height / 2000
x_release = event.x() / width_factor
y_release = event.y() / height_factor
dx = x_release - self.x_press
dy = y_release - self.y_press
theta = atan2(dy, -dx)
self.ivy.send_go_to_orient(3000 - int(self.x_press), int(self.y_press), theta)
self.x_press = None
self.y_press = None
self.feed_forward_arrow = None
self.feed_forward_arrow_enabled = False
self.repaint_mutex.acquire()
self.repaint()
self.repaint_mutex.release()
def draw_background(self, painter):
self.initCoordinateSystem(painter)
pen = QPen(QColor(0, 0, 0))
pen.setWidth(4)
painter.setPen(pen)
back1 = QRadialGradient(QPointF(0.0, 0.0), 180.0,
QPointF(-35.0, 145.0))
back1.setColorAt(0.0, QColor(250, 250, 250))
back1.setColorAt(1.0, QColor(20, 20, 20))
back2 = QRadialGradient(QPointF(0.0, 0.0), 225.0, QPointF(76.5, 135.0))
back2.setColorAt(0.0, QColor(10, 10, 10))
back2.setColorAt(1.0, QColor(250, 250, 250))
painter.setBrush(QBrush(back1))
painter.drawEllipse(-162, -162, 324, 324)
painter.setPen(Qt.NoPen)
painter.setBrush(QBrush(back2))
painter.drawEllipse(-152, -152, 304, 304)
shield = QRadialGradient(QPointF(0, 0), 182, QPointF(-12.0, -15.0))
shield.setColorAt(0.0, Qt.white)
shield.setColorAt(0.5, QColor(240, 240, 240))
shield.setColorAt(1.0, QColor(215, 215, 215))
painter.setBrush(QBrush(shield))
painter.setPen(pen)
painter.drawEllipse(-142, -142, 284, 284)
painter.setPen(Qt.NoPen)
painter.setBrush(QColor(0, 200, 0))
angle = int(
(3840 * (self.mPointer.nominal() - self.mPointer.minimal())) /
(self.mPointer.maximal() - self.mPointer.minimal()))
painter.drawPie(QRect(-141, -141, 282, 282), -480, 3840 - angle % 5760)
painter.setBrush(QBrush(Qt.red))
angle = int(
(3840 * (self.mPointer.critical() - self.mPointer.minimal())) /
(self.mPointer.maximal() - self.mPointer.minimal()))
painter.drawPie(QRect(-141, -141, 282, 282), -480, 3840 - angle % 5760)
painter.setBrush(QBrush(shield))
painter.drawEllipse(-129, -129, 258, 258)
painter.rotate(60)
painter.save()
painter.setBrush(QBrush(Qt.black))
line_length = 10
scaleTriangle = [QPoint(-6, 141), QPoint(6, 141), QPoint(0, 129)]
for i in range(33):
painter.setPen(pen)
if i % 4:
painter.drawLine(0, 140, 0, 140 - line_length)
else:
painter.setPen(Qt.NoPen)
painter.drawConvexPolygon(QPolygon(scaleTriangle))
painter.rotate(7.5)
pen.setWidth(3)
if i % 2:
line_length = 10
else:
line_length = 5
painter.restore()
painter.setPen(Qt.black)
painter.rotate(-60.0)
painter.setFont(self.mDigitFont)
for i in range(9):
v = self.mPointer.minimal() + i * (self.mPointer.maximal() -
self.mPointer.minimal()) / 8.0
if abs(v) < 0.000001:
v = 0.0
val = "{}".format(v)
Size = painter.fontMetrics().size(Qt.TextSingleLine, val)
painter.save()
painter.translate(
self.mDigitOffset * math.cos((5 + i) * math.pi / 6.0),
self.mDigitOffset * math.sin((5 + i) * math.pi / 6.0))
painter.drawText(QPointF(Size.width() / -2.0,
Size.height() / 4.0), val)
painter.restore()
class HistogramView(QWidget):
"""
Our main histogram display
"""
_TOP_MARGIN_IN_PX = 5
@log
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self._painter = QPainter()
self._color_pens = [QPen(Qt.red), QPen(Qt.green), QPen(Qt.blue)]
for pen in self._color_pens:
pen.setWidth(2)
self._white_pen = QPen(Qt.white)
self._white_pen.setWidth(2)
# pylint: disable=C0103, R0914
@log
def paintEvent(self, _):
"""
Do the painting, Leonardo !
:param _: ignored Qt event
"""
if self.isVisible():
self._painter.begin(self)
self._painter.translate(QPoint(0, 0))
if DYNAMIC_DATA.histogram_container is not None:
histograms = DYNAMIC_DATA.histogram_container.get_histograms()
bin_count = DYNAMIC_DATA.histogram_container.bin_count
global_maximum = DYNAMIC_DATA.histogram_container.global_maximum
if global_maximum > 0:
if len(histograms) > 1:
pens = self._color_pens
self._painter.setCompositionMode(
QPainter.CompositionMode_Plus)
else:
pens = [self._white_pen]
histograms = [histograms[0]]
self._painter.setCompositionMode(
QPainter.CompositionMode_SourceOver)
for pen, histogram in zip(pens, histograms):
self._painter.save()
self._painter.setPen(pen)
for i, value in enumerate(histogram):
x = round(i / bin_count * self.width())
bar_height = round(value / global_maximum *
self.height())
self._painter.drawLine(
x, self.height(), x,
self.height() -
(bar_height - HistogramView._TOP_MARGIN_IN_PX))
self._painter.restore()
else:
self._display_text("Invalid data")
else:
self._display_text("No data")
self._painter.end()
@log
def _display_text(self, text: str):
font_inspector = self._painter.fontMetrics()
text_height = font_inspector.height()
text_width = font_inspector.width(text)
self._painter.drawText(
(self.width() - text_width) / 2,
((self.height() - text_height) / 2) + text_height, text)
def createBar(self):
print("in create bar")
min_num, max_num = 0, 100
max_count = 0
linked_bag_list = []
try:
df = self.linked['Beam Diff'].dropna()
linked_bag_list = df.values.tolist()
min_num = int(min(linked_bag_list))
if min_num > 0: # check if greater than 0, set to 0
min_num = 0
max_num = int(max(linked_bag_list))
except AttributeError:
self.statusbar.showMessage('Data not ready')
count = linked_bag_list
count = [0] * (max_num + 1) # choose the largest num as length of count
for num in linked_bag_list:
count[int(num)] += 1 # update every number's count
max_count = max(count)
setBar = QBarSet('Beam Difference Occurrence')
setBar.append(count)
brush = QBrush(QColor(0x57B1FD))
pen = QPen(QColor(0x57B1FD))
pen.setWidth(2)
setBar.setPen(pen)
setBar.setBrush(brush)
series = QBarSeries()
series.append(setBar)
chart = QChart()
font = QFont()
font.setPixelSize(18)
chart.setTitleFont(font)
chart.setTitle('Linked Bins Histogram')
chart.addSeries(series)
chart.setAnimationOptions(QChart.SeriesAnimations)
axisX = QValueAxis()
axisX.setTitleText("Attenuation Window")
axisX.setRange(min_num, max_num+20)
chart.setAxisX(axisX, series)
axisY = QValueAxis()
axisY.setTitleText("Frequency")
axisY.setRange(0, max_count+20)
chart.setAxisY(axisY, series)
chart.legend().setVisible(True)
chart.legend().setAlignment(Qt.AlignBottom)
chartView = QChartView(chart)
chartView.setRenderHint(QPainter.Antialiasing)
# MainWindow.setCentralWidget(chartView)
return chartView
def drawGlyphPoints(
painter,
glyph,
scale,
drawStartPoints=True,
drawOnCurves=True,
drawOffCurves=True,
drawCoordinates=False,
drawSelection=True,
drawBluesMarkers=True,
onCurveColor=None,
onCurveSmoothColor=None,
offCurveColor=None,
otherColor=None,
backgroundColor=None,
):
if onCurveColor is None:
onCurveColor = defaultColor("glyphOnCurvePoints")
if onCurveSmoothColor is None:
onCurveSmoothColor = defaultColor("glyphOnCurveSmoothPoints")
if offCurveColor is None:
offCurveColor = defaultColor("glyphOffCurvePoints")
if otherColor is None:
otherColor = defaultColor("glyphOtherPoints")
if backgroundColor is None:
backgroundColor = defaultColor("background")
bluesMarkerColor = defaultColor("glyphBluesMarker")
notchColor = defaultColor("glyphContourStroke").lighter(200)
# get the outline data
outlineData = glyph.getRepresentation("defconQt.OutlineInformation")
points = []
# blue zones markers
if drawBluesMarkers and drawOnCurves:
font = glyph.font
blues = []
if font.info.postscriptBlueValues:
blues += font.info.postscriptBlueValues
if font.info.postscriptOtherBlues:
blues += font.info.postscriptOtherBlues
if blues:
blues_ = set(blues)
size = 13 * scale
selectedSize = 15 * scale
snapSize = 17 * scale
selectedSnapSize = 20 * scale
painter.save()
pen = painter.pen()
pen.setColor(QColor(255, 255, 255, 125))
pen.setWidth(0)
painter.setPen(pen)
for point in outlineData["onCurvePoints"]:
x, y = point["point"]
# TODO: we could add a non-overlapping interval tree special
# cased for borders
selected = drawSelection and point.get("selected", False)
if selected:
size_ = selectedSize
snapSize_ = selectedSnapSize
else:
size_ = size
snapSize_ = snapSize
for yMin, yMax in zip(blues[::2], blues[1::2]):
if not (y >= yMin and y <= yMax):
continue
# if yMin > 0 and y == yMin or yMin <= 0 and y == yMax:
if y in blues_:
path = lozengePath(x, y, snapSize_)
else:
path = ellipsePath(x, y, size_)
painter.fillPath(path, bluesMarkerColor)
painter.drawPath(path)
painter.restore()
# handles
if drawOffCurves and outlineData["offCurvePoints"]:
painter.save()
painter.setPen(otherColor)
for x1, y1, x2, y2 in outlineData["bezierHandles"]:
drawLine(painter, x1, y1, x2, y2)
painter.restore()
# on curve
if drawOnCurves and outlineData["onCurvePoints"]:
size = 6.5 * scale
selectedSize = 8.5 * scale
smoothSize = 8 * scale
selectedSmoothSize = 10 * scale
startSize = 7 * scale
selectedStartSize = 9 * scale
loneStartSize = 12 * scale
selectedLoneStartSize = 14 * scale
painter.save()
notchPath = QPainterPath()
paths = (QPainterPath(), QPainterPath())
smoothPaths = (QPainterPath(), QPainterPath())
for point in outlineData["onCurvePoints"]:
x, y = point["point"]
points.append((x, y))
# notch
if "smoothAngle" in point:
angle = point["smoothAngle"]
t = Identity.rotate(angle)
x1, y1 = t.transformPoint((-1.35 * scale, 0))
x2, y2 = -x1, -y1
x1 += x
y1 += y
x2 += x
y2 += y
notchPath.moveTo(x1, y1)
notchPath.lineTo(x2, y2)
# points
selected = drawSelection and point.get("selected", False)
if selected:
size_ = selectedSize
smoothSize_ = selectedSmoothSize
startSize_ = selectedStartSize
loneStartSize_ = selectedLoneStartSize
else:
size_ = size
smoothSize_ = smoothSize
startSize_ = startSize
loneStartSize_ = loneStartSize
if drawStartPoints and "startPointAngle" in point:
angle = point["startPointAngle"]
if angle is not None:
pointPath = trianglePath(x, y, startSize_, angle)
else:
pointPath = ellipsePath(x, y, loneStartSize_)
elif point["smooth"]:
pointPath = ellipsePath(x, y, smoothSize_)
else:
pointPath = rectanglePath(x, y, size_)
# store the path
if point["smooth"]:
smoothPaths[selected].addPath(pointPath)
else:
paths[selected].addPath(pointPath)
path, selectedPath = paths
smoothPath, selectedSmoothPath = smoothPaths
# fill
selectedPath.setFillRule(Qt.WindingFill)
selectedSmoothPath.setFillRule(Qt.WindingFill)
painter.fillPath(selectedPath, onCurveColor)
painter.fillPath(selectedSmoothPath, onCurveSmoothColor)
# stroke
pen = QPen(onCurveColor)
pen.setWidthF(1.2 * scale)
painter.setPen(pen)
painter.drawPath(path)
pen.setColor(onCurveSmoothColor)
painter.setPen(pen)
painter.drawPath(smoothPath)
# notch
pen.setColor(notchColor)
pen.setWidth(0)
painter.setPen(pen)
painter.drawPath(notchPath)
painter.restore()
# off curve
if drawOffCurves and outlineData["offCurvePoints"]:
# points
offSize = 4.25 * scale
selectedOffSize = 6.75 * scale
path = QPainterPath()
selectedPath = QPainterPath()
selectedPath.setFillRule(Qt.WindingFill)
for point in outlineData["offCurvePoints"]:
x, y = point["point"]
selected = drawSelection and point.get("selected", False)
if selected:
offSize_ = selectedOffSize
else:
offSize_ = offSize
pointPath = ellipsePath(x, y, offSize_)
if selected:
selectedPath.addPath(pointPath)
else:
path.addPath(pointPath)
pen = QPen(offCurveColor)
pen.setWidthF(2.5 * scale)
painter.save()
painter.setPen(pen)
painter.drawPath(path)
painter.fillPath(path, QBrush(backgroundColor))
painter.fillPath(selectedPath, QBrush(offCurveColor.lighter(135)))
painter.restore()
# coordinates
if drawCoordinates:
painter.save()
painter.setPen(otherColor)
font = painter.font()
font.setPointSize(7)
painter.setFont(font)
for x, y in points:
posX = x
# TODO: We use + here because we align on top. Consider abstracting
# yOffset.
posY = y + 6 * scale
x = round(x, 1)
if int(x) == x:
x = int(x)
y = round(y, 1)
if int(y) == y:
y = int(y)
text = "%d %d" % (x, y)
drawTextAtPoint(
painter, text, posX, posY, scale, xAlign="center", yAlign="top"
)
painter.restore()
def paintEvent(self, pe):
p = QPainter(self)
p.setRenderHint(QPainter.Antialiasing)
pen = QPen()
pen.setWidth(1)
pen.setColor(QColor(0x8c, 0xa3, 0xb0))
p.setPen(pen)
p.setBrush(QColor(0xe4, 0xec, 0xf4))
rx = 6
space = self.space
w = self.usable_width
kw = self.key_w
def drawRow(row, sx, sy, last_end=False):
x = sx
y = sy
keys = row
rw = w - sx
i = 0
for k in keys:
rect = QRectF(x, y, kw, kw)
if i == len(keys) - 1 and last_end:
rect.setWidth(rw)
p.drawRoundedRect(rect, rx, rx)
p.setPen(Qt.black)
rect.adjust(5, 1, 0, 0)
p.setFont(self.lowerFont)
p.drawText(
rect, Qt.AlignLeft | Qt.AlignBottom, self.regular_text(k))
p.setFont(self.upperFont)
p.drawText(
rect, Qt.AlignLeft | Qt.AlignTop, self.shift_text(k))
rw = rw - space - kw
x = x + space + kw
i = i + 1
p.setPen(pen)
return (x, rw)
x = .5
y = .5
keys = self.kb["keys"]
ext_return = self.kb["extended_return"]
first_key_w = 0
rows = 4
remaining_x = [0, 0, 0, 0]
remaining_widths = [0, 0, 0, 0]
for i in range(0, rows):
if first_key_w > 0:
first_key_w = first_key_w * 1.375
if self.kb == self.kb_105 and i == 3:
first_key_w = kw * 1.275
rect = QRectF(x, y, first_key_w, kw)
p.drawRoundedRect(rect, rx, rx)
x = x + first_key_w + space
else:
first_key_w = kw
x, rw = drawRow(keys[i], x, y, i == 1 and not ext_return)
remaining_x[i] = x
remaining_widths[i] = rw
if i != 1 and i != 2:
rect = QRectF(x, y, rw, kw)
p.drawRoundedRect(rect, rx, rx)
x = .5
y = y + space + kw
if ext_return:
rx = rx * 2
x1 = remaining_x[1]
y1 = .5 + kw * 1 + space * 1
w1 = remaining_widths[1]
x2 = remaining_x[2]
y2 = .5 + kw * 2 + space * 2
# this is some serious crap... but it has to be so
# maybe one day keyboards won't look like this...
# one can only hope
pp = QPainterPath()
pp.moveTo(x1, y1 + rx)
pp.arcTo(x1, y1, rx, rx, 180, -90)
pp.lineTo(x1 + w1 - rx, y1)
pp.arcTo(x1 + w1 - rx, y1, rx, rx, 90, -90)
pp.lineTo(x1 + w1, y2 + kw - rx)
pp.arcTo(x1 + w1 - rx, y2 + kw - rx, rx, rx, 0, -90)
pp.lineTo(x2 + rx, y2 + kw)
pp.arcTo(x2, y2 + kw - rx, rx, rx, -90, -90)
pp.lineTo(x2, y1 + kw)
pp.lineTo(x1 + rx, y1 + kw)
pp.arcTo(x1, y1 + kw - rx, rx, rx, -90, -90)
pp.closeSubpath()
p.drawPath(pp)
else:
x = remaining_x[2]
y = .5 + kw * 2 + space * 2
rect = QRectF(x, y, remaining_widths[2], kw)
p.drawRoundedRect(rect, rx, rx)
QWidget.paintEvent(self, pe)
class SchedulerGUI(QMainWindow, Ui_MainWindow):
def __init__(self, parent=None):
QMainWindow.__init__(self, parent=parent)
self.setStyleSheet(MAIN_WINDOW_CSS)
self.setupUi(self)
self.scheduleFolder = sampleSchedule()
self.schedule = self.scheduleFolder.schedulers[
self.calendarWidget.selectedDate()]
self.schedule.events[62].customGUI = MeasureWidget
self.activatedColumns = {}
for key in self.scheduleFolder.columns:
self.activatedColumns[key] = True
self.lang = 'en'
self.restore_buttons = {}
self.restoreAllButton.clicked.connect(self.restoreAllColumns)
self.translateDict = {}
for widget in self.centralwidget.findChildren((QPushButton)):
langDict = {}
for l in languages:
langDict[l] = trans(widget.text(), l)
key = widget
self.translateDict[key] = langDict
self.translateWidgets()
self.language0Button.clicked.connect(partial(self.changeLang, 'en'))
self.language1Button.clicked.connect(partial(self.changeLang, 'ru'))
self.language2Button.clicked.connect(partial(self.changeLang, 'de'))
self.language3Button.clicked.connect(partial(self.changeLang, 'ja'))
self.language4Button.clicked.connect(partial(self.changeLang, 'fr'))
self.language5Button.clicked.connect(partial(self.changeLang, 'it'))
self.language0Button.setIcon(QtGui.QIcon('flags/United-States.png'))
self.language1Button.setIcon(QtGui.QIcon('flags/Russia.png'))
self.language2Button.setIcon(QtGui.QIcon('flags/Germany.png'))
self.language3Button.setIcon(QtGui.QIcon('flags/Japan.png'))
self.language4Button.setIcon(QtGui.QIcon('flags/France.png'))
self.language5Button.setIcon(QtGui.QIcon('flags/Italy.png'))
self.drawAlarm = QTimer()
self.drawAlarm.timeout.connect(self.drawAlarmFunc)
self.drawAlarm.start(0.3)
self.calendarWidget.setNavigationBarVisible(False)
self.calendarWidget.setStyleSheet(CALENDAR_CSS)
self.calendarWidget.clicked.connect(self.updateDisplayedDate)
self.calendarWidget.currentPageChanged.connect(self.updateNavBarDate)
self.calendarWidget.selectionChanged.connect(self.updateDisplayedDate)
self.updateDisplayedDate()
self.updateNavBarDate()
self.nextMonthButton.clicked.connect(self.calendarWidget.showNextMonth)
self.prevMonthButton.clicked.connect(
self.calendarWidget.showPreviousMonth)
self.nextDayButton.clicked.connect(self.selectNextDate)
self.prevDayButton.clicked.connect(self.selectPrevDate)
self.todayButton.clicked.connect(self.selectToday)
navBarWidgets = [
self.prevMonthButton, self.displayedCalendarLabel,
self.nextMonthButton
]
for widget in self.centralwidget.findChildren(QPushButton):
#if widget not in navBarWidgets:
widget.setStyleSheet(MAIN_BUTTONS_CSS)
weekendFormat = QTextCharFormat()
weekendFormat.setForeground(QBrush(Qt.black, Qt.SolidPattern))
self.calendarWidget.setWeekdayTextFormat(Qt.Saturday, weekendFormat)
self.calendarWidget.setWeekdayTextFormat(Qt.Sunday, weekendFormat)
self.customGUIs = {}
def keyPressEvent(self, event):
if event.key() == QtCore.Qt.Key_A:
self.selectPrevDate()
elif event.key() == QtCore.Qt.Key_D:
self.selectNextDate()
def closeEvent(self, event):
quit()
def resizeEvent(self, event):
self.draw()
def eventClicked(self, event):
'''
try:
self.dockWidget.deleteLater()
except AttributeError:
pass
'''
if event.customGUI != None:
self.dockWidget = event.customGUI(self)
else:
self.dockWidget = DefaultEvent(self)
self.dockWidget.setAllowedAreas(Qt.RightDockWidgetArea
| Qt.NoDockWidgetArea)
self.dockWidget.setMinimumWidth(450)
self.addDockWidget(Qt.RightDockWidgetArea, self.dockWidget)
self.dockWidgetEvent = event
self.updateEventPopupText()
def updateEventPopupText(self):
try:
timeText = self.dockWidgetEvent.t0 + ' - ' + self.dockWidgetEvent.t1 + ' (GMT)'
self.dockWidget.timeLabel.setText(timeText)
self.dockWidget.titleLabel.setText(
self.dockWidgetEvent.title[self.lang])
self.dockWidget.summaryLabel.setText(
self.dockWidgetEvent.summary[self.lang])
self.dockWidget.descriptionLabel.setText(
self.dockWidgetEvent.description[self.lang])
self.dockWidget.setWindowTitle(
self.dockWidgetEvent.title[self.lang])
except AttributeError:
pass
def selectNextDate(self):
date = self.calendarWidget.selectedDate()
self.calendarWidget.setSelectedDate(date.addDays(1))
def selectPrevDate(self):
date = self.calendarWidget.selectedDate()
self.calendarWidget.setSelectedDate(date.addDays(-1))
def selectToday(self):
self.calendarWidget.setSelectedDate(QDate.currentDate())
self.calendarWidget.showToday()
def updateNavBarDate(self):
month = MONTH[self.calendarWidget.monthShown()][self.lang]
year = self.calendarWidget.yearShown()
self.displayedCalendarLabel.setText(month + " " + str(year))
def updateDisplayedDate(self):
self.dateLabel.setText(
self.dateToStr(self.calendarWidget.selectedDate()))
try:
self.schedule = self.scheduleFolder.schedulers[
self.calendarWidget.selectedDate()]
except KeyError:
self.schedule = Scheduler([])
self.draw()
def dateToStr(self, date):
month = MONTH[date.month()][self.lang]
year = date.year()
day = date.day()
return month + " " + str(day) + " " + str(year)
def drawAlarmFunc(self):
self.drawAlarm.stop()
self.draw()
def draw(self, w=-1):
self.scheduleScene = QGraphicsScene()
self.activatedScene = QGraphicsScene()
if w == -1:
self.w = self.scheduleView.width()
else:
self.w = w
self.h = Y_SIDE * 24
self.h_a = self.activatedView.height()
self.gridPen = QPen(GRID_COLOR)
for i in range(0, 24):
self.scheduleScene.addLine(0, i * Y_SIDE, self.w, i * Y_SIDE)
self.drawTimeTapes()
cols = self.getActivatedColumns()
x_offset = WIDTH_TL * len(self.scheduleFolder.timeTapes)
if (len(cols) > 0):
col_width = (self.w - x_offset) / len(cols)
col_positions = self.drawColumns(cols, x_offset, col_width)
for i in range(0, len(self.schedule.events)):
try:
pos = col_positions[self.schedule.events[i].column_abr]
self.drawEvent(self.schedule.events[i], col_width, pos)
except KeyError:
pass
t_now = QTime.currentTime().hour() + QTime.currentTime().minute() / 60
self.gridPen = QPen(Qt.green)
self.gridPen.setWidth(2)
self.scheduleScene.addLine(0, t_now * (self.h / 24), self.w,
t_now * (self.h / 24), self.gridPen)
t_fast_return = t_now + 40 / 60
self.gridPen = QPen(Qt.red)
self.gridPen.setWidth(2)
self.scheduleScene.addLine(0, t_fast_return * (self.h / 24), self.w,
t_fast_return * (self.h / 24), self.gridPen)
self.scheduleView.setScene(self.scheduleScene)
self.activatedView.setScene(self.activatedScene)
def drawTimeTapes(self):
for i in range(0, len(self.scheduleFolder.timeTapes)):
self.scheduleScene.addLine(WIDTH_TL * i, 0, WIDTH_TL * i, self.h)
self.activatedScene.addLine(WIDTH_TL * i, 0, WIDTH_TL * i,
self.h_a)
l = QLabel(self.scheduleFolder.timeTapes[i].name)
l.move(WIDTH_TL * i + TT_X_BUFFER, TT_Y_BUFFER)
l.setStyleSheet(TIME_TAPE_CSS)
self.activatedScene.addWidget(l)
for j in range(0, 24):
l = QLabel(self.scheduleFolder.timeTapes[i].labels[j])
l.move(WIDTH_TL * i + TT_X_BUFFER, Y_SIDE * j + TT_Y_BUFFER)
l.setStyleSheet(TIME_TAPE_CSS)
self.scheduleScene.addWidget(l)
def drawColumns(self, cols, x_offset, col_width):
col_positions = {}
self.deactivateButtons = []
for i in range(0, len(cols)):
self.scheduleScene.addLine(x_offset + col_width * i, 0,
x_offset + col_width * i, self.h)
'''
self.activatedScene.addLine(x_offset + col_width * i, 0,
x_offset + col_width * i, self.h_a)
'''
b = QPushButton(cols[i].name['en'])
b.move(x_offset + col_width * i + COLUMN_BUTTON_X_BUFFER + 1, 0)
b.clicked.connect(partial(self.deactivateColumn, cols[i].abr))
b.setSizePolicy(QSizePolicy.Ignored, QSizePolicy.Ignored)
b.setStyleSheet(MAIN_BUTTONS_CSS)
b.resize(col_width - COLUMN_BUTTON_X_BUFFER * 2, self.h_a - 2)
b = self.activatedScene.addWidget(b)
col_positions[cols[i].abr] = x_offset + col_width * i
return col_positions
def drawEvent(self, event, col_width, x_loc):
t0_f = timeStrToFloat(event.t0)
t1_f = timeStrToFloat(event.t1)
length = (t1_f - t0_f) * (self.h / 24)
space = QtCore.QSizeF(col_width - PEN_WIDTH, length - PEN_WIDTH)
r = QtCore.QRectF(QtCore.QPointF(x_loc + 1,
t0_f * (self.h / 24) + 1), space)
pen = QPen(QtCore.Qt.black)
pen.setWidth(PEN_WIDTH)
brush = QBrush(event.color)
### Checks maximum font size if level
font_size = MAX_EVENT_FONT_PT
l_title = QLabel(event.title[self.lang] + " ")
l_time = QLabel('(' + event.t0 + ' - ' + event.t1 + ')')
l_time.setFont(
QtGui.QFont(DEFAULT_EVENT_FONT, font_size, QtGui.QFont.Normal))
l_title.setFont(
QtGui.QFont(DEFAULT_EVENT_FONT, font_size, QtGui.QFont.Bold))
title_width = l_title.fontMetrics().boundingRect(l_title.text()).width() + \
l_time.fontMetrics().boundingRect(l_time.text()).width() + W_BUFFER
title_height = l_title.fontMetrics().boundingRect(
l_title.text()).height() + H_BUFFER
while (title_height > length
or title_width > col_width) and font_size > MIN_EVENT_FONT_PT:
font_size -= FONT_STEP
l_title.setFont(
QtGui.QFont(DEFAULT_EVENT_FONT, font_size, QtGui.QFont.Bold))
l_time.setFont(
QtGui.QFont(DEFAULT_EVENT_FONT, font_size, QtGui.QFont.Normal))
title_width = l_title.fontMetrics().boundingRect(l_title.text()).width() + \
l_time.fontMetrics().boundingRect(l_time.text()).width() + W_BUFFER
title_height = l_title.fontMetrics().boundingRect(
l_title.text()).height() + H_BUFFER
font_size_level = font_size
over_height_level = title_height - length
over_width_level = title_width - col_width
### Checks maximum font size if stacked
font_size = MAX_EVENT_FONT_PT
l_title = QLabel(event.title[self.lang])
l_time = QLabel('(' + event.t0 + ' - ' + event.t1 + ')')
l_time.setFont(
QtGui.QFont(DEFAULT_EVENT_FONT, font_size, QtGui.QFont.Normal))
l_title.setFont(
QtGui.QFont(DEFAULT_EVENT_FONT, font_size, QtGui.QFont.Bold))
title_width = max(
l_title.fontMetrics().boundingRect(l_title.text()).width(),
l_time.fontMetrics().boundingRect(
l_time.text()).width()) + W_BUFFER
title_height = l_title.fontMetrics().boundingRect(l_title.text()).height() + \
l_time.fontMetrics().boundingRect(l_time.text()).height() + H_BUFFER
while (title_height > length
or title_width > col_width) and font_size > MIN_EVENT_FONT_PT:
font_size -= FONT_STEP
l_title.setFont(
QtGui.QFont(DEFAULT_EVENT_FONT, font_size, QtGui.QFont.Bold))
l_time.setFont(
QtGui.QFont(DEFAULT_EVENT_FONT, font_size, QtGui.QFont.Normal))
title_width = max(
l_title.fontMetrics().boundingRect(l_title.text()).width(),
l_time.fontMetrics().boundingRect(
l_time.text()).width()) + W_BUFFER
title_height = l_title.fontMetrics().boundingRect(l_title.text()).height() + \
l_time.fontMetrics().boundingRect(l_time.text()).height() + H_BUFFER
font_size_stacked = font_size
over_height_stacked = title_height - length
over_width_stacked = title_width - col_width
### Checks if it can draw the event without the time label if it is too big
if ((over_width_level > 0 or over_height_level > 0) and \
(over_width_stacked > 0 or over_height_stacked > 0)):
font_size = MAX_EVENT_FONT_PT
l_title = QLabel(event.title[self.lang])
l_title.setFont(
QtGui.QFont(DEFAULT_EVENT_FONT, font_size, QtGui.QFont.Bold))
title_width = l_title.fontMetrics().boundingRect(
l_title.text()).width() + W_BUFFER
title_height = l_title.fontMetrics().boundingRect(
l_title.text()).height() + H_BUFFER
while (title_height > length or
title_width > col_width) and font_size > MIN_EVENT_FONT_PT:
font_size -= FONT_STEP
l_title.setFont(
QtGui.QFont(DEFAULT_EVENT_FONT, font_size,
QtGui.QFont.Bold))
title_width = l_title.fontMetrics().boundingRect(
l_title.text()).width() + W_BUFFER
title_height = l_title.fontMetrics().boundingRect(
l_title.text()).height() + H_BUFFER
font_size_level = font_size
over_height_level = title_height - length
over_width_level = title_width - col_width
if (over_height_level > 0 or over_width_level > 0):
l_title = QLabel('')
l_time = QLabel('')
else:
l_title = QLabel(event.title[self.lang] + " ")
l_title.setFont(
QtGui.QFont(DEFAULT_EVENT_FONT, font_size_level,
QtGui.QFont.Bold))
l_title.move(x_loc + X_BUFFER, t0_f * (self.h / 24) + Y_BUFFER)
l_time = QLabel('')
r = RectEvent(r)
r.setInfo(self, event)
r.setPen(pen)
r.setBrush(brush)
self.scheduleScene.addItem(r)
l_title.setStyleSheet(EVENT_LABEL_CSS)
l_time.setStyleSheet(EVENT_LABEL_CSS)
self.scheduleScene.addWidget(l_title)
self.scheduleScene.addWidget(l_time)
return
### Sets font and arrangement to the better layout
if font_size_level > font_size_stacked:
level = True
elif font_size_level < font_size_stacked:
level = False
else:
if over_width_level <= 0 and over_height_level <= 0:
level = True
elif over_width_level > col_width:
level = False
elif over_height_stacked > 0:
level = True
else:
level = False
if level:
l_title = QLabel(event.title[self.lang] + " ")
l_time = QLabel('(' + event.t0 + ' - ' + event.t1 + ')')
l_time.setFont(
QtGui.QFont(DEFAULT_EVENT_FONT, font_size_level,
QtGui.QFont.Normal))
l_title.setFont(
QtGui.QFont(DEFAULT_EVENT_FONT, font_size_level,
QtGui.QFont.Bold))
l_title.move(x_loc + X_BUFFER, t0_f * (self.h / 24) + Y_BUFFER)
l_time.move(x_loc + X_BUFFER + \
l_title.fontMetrics().boundingRect(l_title.text()).width(),
t0_f * (self.h/24) + Y_BUFFER)
else:
l_title = QLabel(event.title[self.lang])
l_time = QLabel('(' + event.t0 + ' - ' + event.t1 + ')')
l_time.setFont(
QtGui.QFont(DEFAULT_EVENT_FONT, font_size_stacked,
QtGui.QFont.Normal))
l_title.setFont(
QtGui.QFont(DEFAULT_EVENT_FONT, font_size_stacked,
QtGui.QFont.Bold))
l_title.move(x_loc + X_BUFFER, t0_f * (self.h / 24) + Y_BUFFER)
l_time.move(x_loc + X_BUFFER, t0_f * (self.h/24) + Y_BUFFER + STACKED_BUFFER + \
l_title.fontMetrics().boundingRect(l_title.text()).height())
r = RectEvent(r)
r.setInfo(self, event)
r.setPen(pen)
r.setBrush(brush)
self.scheduleScene.addItem(r)
l_title.setStyleSheet(EVENT_LABEL_CSS)
l_time.setStyleSheet(EVENT_LABEL_CSS)
self.scheduleScene.addWidget(l_title)
self.scheduleScene.addWidget(l_time)
def getActivatedColumns(self):
cols = []
for key in self.scheduleFolder.columns:
if self.activatedColumns[key]:
cols.append(self.scheduleFolder.columns[key])
cols = sorted(cols, key=lambda x: x.abr)
return cols
def getDeactivatedColumns(self):
cols = []
for key in self.scheduleFolder.columns:
if not self.activatedColumns[key]:
cols.append(self.scheduleFolder.columns[key])
cols = sorted(cols, key=lambda x: x.abr)
return cols
def deactivateColumn(self, key):
b = QPushButton(RESTORE[self.lang] + ' ' +
self.scheduleFolder.columns[key].name[self.lang])
b.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)
#b.setMinimumSize(20,1)
b.setStyleSheet(MAIN_BUTTONS_CSS)
self.restoreButtonLayout.insertWidget(-1, b)
b.clicked.connect(partial(self.activateColumn, key, b))
self.restore_buttons[b] = key
self.activatedColumns[key] = False
self.draw()
def activateColumn(self, key, b):
self.activatedColumns[key] = True
self.draw()
b.deleteLater()
del self.restore_buttons[b]
def restoreAllColumns(self):
for key in self.activatedColumns:
self.activatedColumns[key] = True
for b in self.restore_buttons:
b.deleteLater()
self.restore_buttons = {}
self.draw()
def translateWidgets(self):
restoreButs = list(self.restoreButtonLayout.itemAt(i).widget() \
for i in range(1,self.restoreButtonLayout.count()))
for widget in self.centralwidget.findChildren(QPushButton):
if widget not in restoreButs:
try:
widget.setText(self.translateDict[widget][self.lang])
except KeyError:
langDict = {}
for l in languages:
langDict[l] = trans(widget.text(), l)
key = widget
self.translateDict[key] = langDict
widget.setText(self.translateDict[widget][self.lang])
else:
key = self.restore_buttons[widget]
widget.setText(RESTORE[self.lang] + ' ' +
self.scheduleFolder.columns[key].name['en'])
def changeLang(self, lang):
self.lang = lang
self.translateWidgets()
self.drawAlarm.start(1)
self.updateDisplayedDate()
self.updateNavBarDate()
self.updateEventPopupText()
class GameWindow(QtWidgets.QMainWindow, Ui_game_screen):
def __init__(self):
QtWidgets.QMainWindow.__init__(self)
# Ui_game_screen.__init__(self)
self.setupUi(self)
self.setWindowTitle("Snake eat dots")
self.timer = QtCore.QTimer()
self.timer.timeout.connect(self.gameRun)
self.timer.start(SPEED)
self.game = GameCore()
self.pen_snake = QPen()
self.pen_snake.setWidth(PEN_SIZE)
self.pen_dot = QPen()
self.pen_dot.setWidth(PEN_SIZE)
self.pen_dot.setColor(QColor(255, 0, 0, 127))
self.pen_board = QPen()
self.pen_board.setWidth(PEN_SIZE)
self.pen_board.setColor(QColor(127, 0, 0, 127))
def gameRun(self):
if not self.game.moveSnake():
self.timer.stop()
self.update()
def paintEvent(self, e):
qp = QPainter()
qp.begin(self)
qp.setPen(self.pen_snake)
# size = self.size()
#Paint Border
qp.setPen(self.pen_board)
qp.drawRect(0, 0, SCREEN_WIDTH, SCREEN_HIGHT)
#Paint snake
for i in range(len(self.game.snake_shape)):
qp.drawPoint(self.game.snake_shape[i].x() * PEN_SIZE,
self.game.snake_shape[i].y() * PEN_SIZE)
#Paint Dot
qp.setPen(self.pen_dot)
qp.drawPoint(self.game.dotPosition.x() * PEN_SIZE,
self.game.dotPosition.y() * PEN_SIZE)
qp.end()
def on_playButton_released(self):
print("maya")
# self.update()
self.playButton.hide()
def keyPressEvent(self, event):
key_press = event.key()
# print(key_press)
# don't need autorepeat, while haven't released, just run once
if not event.isAutoRepeat():
if (key_press == Qt.Key_W or key_press == Qt.Key_Up
) and self.game.snake_direction != DIRECTION_DOWN: # W
# print('up')
self.game.changeDirection(DIRECTION_UP)
elif (key_press == Qt.Key_S or key_press == Qt.Key_Down
) and self.game.snake_direction != DIRECTION_UP: # S
# print('down')
self.game.changeDirection(DIRECTION_DOWN)
elif (key_press == Qt.Key_A or key_press == Qt.Key_Left
) and self.game.snake_direction != DIRECTION_RIGHT: # A
# print('left')
self.game.changeDirection(DIRECTION_LEFT)
elif (key_press == Qt.Key_D or key_press == Qt.Key_Right
) and self.game.snake_direction != DIRECTION_LEFT: # D
# print('right')
self.game.changeDirection(DIRECTION_RIGHT)
elif key_press == Qt.Key_Space: # SPACE
if self.timer.isActive():
self.timer.stop()
else:
self.timer.start()
self.update()
def on_actItem_Line_triggered(self):
item=QGraphicsLineItem(-100,0,100,0)
pen=QPen(Qt.red)
pen.setWidth(4)
item.setPen(pen) #设置线条属性
self.__setItemProperties(item,"直线")
class Test:
def __init__(self):
window = self.window = QLabel()
window.setGeometry(0, 0, *SIZE)
window.setWindowTitle("Tablet Scribling")
window.paintEvent = self.paintEvent
window.tabletEvent = self.tabletEvent
window.keyPressEvent = self.keyPressEvent
window.show()
self.text = "fnord"
window.setMouseTracking(True)
self.points = []
self.last_point = None
self.pen = QPen(Qt.black, 1, Qt.SolidLine)
self.image = QImage(*SIZE, QImage.Format_ARGB32)
self.image.fill(QColor(255, 255, 255))
window.setPixmap(QPixmap.fromImage(self.image))
def paintEvent(self, event):
# print(event, dir(event))
qp = QPainter()
qp.begin(self.image)
qp.setRenderHints(QPainter.Antialiasing, True)
qp.setPen(self.pen)
# self.drawText(event, qp)
qp.setPen(Qt.black)
self.draw_blurbs(qp)
# self.window.setPixmap(QPixmap.fromImage(self.image))
# self.window.pixmap().fill(Qt.red)
qp.end()
qp = QPainter()
qp.begin(self.window)
qp.drawImage(QPoint(0, 0), self.image)
qp.end()
def keyPressEvent(self, event):
key = event.key()
if key == Qt.Key_Delete:
self.image.fill(QColor(255, 255, 255))
self.window.update()
elif key == Qt.Key_Return:
self.image.save("image.png")
#def mouseMoveEvent(self, event):
#print(event, event.pos())
#event.accept()
#self.points.append((event.x(), event.y()))
#self.window.update()
def tabletEvent(self, event):
print(event, event.pos(), event.pressure())
event.accept()
self.points.append((event.x(), event.y(), event.pressure()))
self.window.update()
def draw_blurbs(self, qp):
if not self.last_point:
if self.points:
if self.points[0][2]:
self.last_point = self.points[0]
else:
self.points[:] = []
return
lp = self.last_point
for p in self.points:
if p[2] != lp[2]:
# pen = QtGui.QPen(QtCore.Qt.black, 2, QtCore.Qt.SolidLine)
self.pen.setWidth(p[2] * 60)
qp.setPen(self.pen)
qp.drawLine(lp[0], lp[1], p[0], p[1])
if p[2]:
self.last_point = p
else:
self.last_point = None
self.points[:] = []
def drawContents(self, painter):
if self._to_stop:
return
painter.save()
painter.setPen(QColor(0, 0, 0, 255))
painter.setRenderHint(QPainter.Antialiasing)
painter.setRenderHint(QPainter.Antialiasing, True)
version = Application.getInstance().getVersion().split("-")
buildtype = Application.getInstance().getBuildType()
if buildtype:
version[0] += " (%s)" % buildtype
application = Application.getInstance()
version = [
"Version %s" % (application.getComponentVersion("cura_version"))
]
font = QFont() # Using system-default font here
font.setPointSize(8)
painter.setFont(font)
painter.drawText(380 * self._scale, 220 * self._scale,
330 * self._scale, 230 * self._scale,
Qt.AlignHCenter | Qt.AlignBottom,
self._current_message)
painter.drawText(380 * self._scale, 200 * self._scale,
330 * self._scale, 230 * self._scale,
Qt.AlignHCenter | Qt.AlignBottom, version[0])
if len(version) > 1:
font.setPixelSize(16)
painter.setFont(font)
painter.drawText(380 * self._scale, 220 * self._scale,
330 * self._scale, 265 * self._scale,
Qt.AlignHCenter | Qt.AlignBottom,
self._current_message)
painter.drawText(380 * self._scale, 200 * self._scale,
330 * self._scale, 265 * self._scale,
Qt.AlignHCenter | Qt.AlignBottom, version[1])
# draw the loading image
pen = QPen()
pen.setWidth(6 * self._scale)
pen.setColor(QColor(120, 136, 20, 255))
painter.setPen(pen)
#painter.drawArc(60, 150, 32 * self._scale, 32 * self._scale, self._loading_image_rotation_angle * 16, 300 * 16)
painter.drawArc(420 * self._scale, 410 * self._scale, 32 * self._scale,
32 * self._scale,
self._loading_image_rotation_angle * 16, 300 * 16)
# draw message text
#if self._current_message:
# font = QFont() # Using system-default font here
# font.setPixelSize(13)
# pen = QPen()
# pen.setColor(QColor(255, 255, 255, 255))
# painter.setPen(pen)
# painter.setFont(font)
# painter.drawText(100, 128, 170, 64,
# Qt.AlignLeft | Qt.AlignVCenter | Qt.TextWordWrap,
# self._current_message)
painter.restore()
super().drawContents(painter)
def createUnlinkedBar(self):
max_count = 0
unlinked_bag_list = []
try:
df = self.unlinked['Beam Diff'].dropna()
unlinked_bag_list = df.values.tolist()
except AttributeError:
self.statusbar.showMessage('Data not ready')
count = [0] * 4
for num in unlinked_bag_list:
if -1000 <= num and num <= -51:
count[0] += 1
elif -50 <= num and num <= -1:
count[1] += 1
elif 151 <= num and num <= 200:
count[2] += 1
elif 201 <= num:
count[3] += 1
# print(count)
max_count = max(count)
setBar = QBarSet('Beam Difference Occurrence')
setBar.append(count)
series = QBarSeries()
series.append(setBar)
brush = QBrush(QColor(0xfdb157))
pen = QPen(QColor(0xfdb157))
pen.setWidth(2)
setBar.setPen(pen)
setBar.setBrush(brush)
chart = QChart()
font = QFont()
font.setPixelSize(18)
chart.setTitleFont(font)
chart.setTitle('Unlinked Bins Summary')
chart.addSeries(series)
chart.setAnimationOptions(QChart.SeriesAnimations)
labels = ['Not useful(-50 to -1000)', 'Pushed by operator(-1 to -50)', 'Slipping on belt(151 to 200)', 'Not useful 201+']
axisX = QBarCategoryAxis()
axisX.append(labels)
# chart.setAxisX(axisX, series)
chart.addAxis(axisX, Qt.AlignBottom)
# chart.ChartAreas[0].AxisX.LabelAutoFitStyle = LabelAutoFitStyle.WrodWrap
series.attachAxis(axisX)
axisY = QValueAxis()
axisY.setRange(0, max_count+1)
# chart.setAxisY(axisY, series)
chart.addAxis(axisY, Qt.AlignLeft)
series.attachAxis(axisY)
chart.legend().setVisible(True)
chart.legend().setAlignment(Qt.AlignBottom)
chartView = QChartView(chart)
chartView.setRenderHint(QPainter.Antialiasing)
# MainWindow.setCentralWidget(chartView)
return chartView
class QrReaderVideoOverlay(QWidget):
"""
Overlays the QR scanner results over the video
"""
BG_RECT_PADDING = 10
BG_RECT_CORNER_RADIUS = 10.0
BG_RECT_OPACITY = 0.75
QR_FINDER_OPACITY = 0.25
QR_FINDER_SIZE = 0.5
def __init__(self, parent: QWidget = None):
super().__init__(parent)
self.results = []
self.flip_x = False
self.validator_results = None
self.crop = None
self.resolution = None
self.qr_outline_pen = QPen()
self.qr_outline_pen.setColor(Qt.red)
self.qr_outline_pen.setWidth(3)
self.qr_outline_pen.setStyle(Qt.DotLine)
self.text_pen = QPen()
self.text_pen.setColor(Qt.black)
self.bg_rect_pen = QPen()
self.bg_rect_pen.setColor(Qt.black)
self.bg_rect_pen.setStyle(Qt.DotLine)
self.bg_rect_fill = QColor(255, 255, 255, 255 * self.BG_RECT_OPACITY)
self.qr_finder = QSvgRenderer(":icons/qr_finder.svg")
def set_results(self, results: List[QrCodeResult], flip_x: bool,
validator_results: QrReaderValidatorResult):
self.results = results
self.flip_x = flip_x
self.validator_results = validator_results
self.update()
def set_crop(self, crop: QRect):
self.crop = crop
def set_resolution(self, resolution: QSize):
self.resolution = resolution
def paintEvent(self, _event: QPaintEvent):
if not self.crop or not self.resolution:
return
painter = QPainter(self)
# Keep a backup of the transform and create a new one
transform = painter.worldTransform()
# Set scaling transform
transform = transform.scale(self.width() / self.resolution.width(),
self.height() / self.resolution.height())
# Compute the transform to flip the coordinate system on the x axis
transform_flip = QTransform()
if self.flip_x:
transform_flip = transform_flip.translate(self.resolution.width(),
0.0)
transform_flip = transform_flip.scale(-1.0, 1.0)
# Small helper for tuple to QPoint
def toqp(point):
return QPoint(point[0], point[1])
# Starting from here we care about AA
painter.setRenderHint(QPainter.Antialiasing)
# Draw the QR code finder overlay
painter.setWorldTransform(transform_flip * transform, False)
painter.setOpacity(self.QR_FINDER_OPACITY)
qr_finder_size = self.crop.size() * self.QR_FINDER_SIZE
tmp = (self.crop.size() - qr_finder_size) / 2
qr_finder_pos = QPoint(tmp.width(), tmp.height()) + self.crop.topLeft()
qr_finder_rect = QRect(qr_finder_pos, qr_finder_size)
self.qr_finder.render(painter, QRectF(qr_finder_rect))
painter.setOpacity(1.0)
# Draw all the QR code results
for res in self.results:
painter.setWorldTransform(transform_flip * transform, False)
# Draw lines between all of the QR code points
pen = QPen(self.qr_outline_pen)
if res in self.validator_results.result_colors:
pen.setColor(self.validator_results.result_colors[res])
painter.setPen(pen)
num_points = len(res.points)
for i in range(0, num_points):
i_n = i + 1
line_from = toqp(res.points[i])
line_from += self.crop.topLeft()
line_to = toqp(
res.points[i_n] if i_n < num_points else res.points[0])
line_to += self.crop.topLeft()
painter.drawLine(line_from, line_to)
# Draw the QR code data
# Note that we reset the world transform to only the scaled transform
# because otherwise the text could be flipped. We only use transform_flip
# to map the center point of the result.
painter.setWorldTransform(transform, False)
font_metrics = painter.fontMetrics()
data_metrics = QSize(font_metrics.horizontalAdvance(res.data),
font_metrics.capHeight())
center_pos = toqp(res.center)
center_pos += self.crop.topLeft()
center_pos = transform_flip.map(center_pos)
text_offset = QPoint(data_metrics.width(), data_metrics.height())
text_offset = text_offset / 2
text_offset.setX(-text_offset.x())
center_pos += text_offset
padding = self.BG_RECT_PADDING
bg_rect_pos = center_pos - QPoint(padding,
data_metrics.height() + padding)
bg_rect_size = data_metrics + (QSize(padding, padding) * 2)
bg_rect = QRect(bg_rect_pos, bg_rect_size)
bg_rect_path = QPainterPath()
radius = self.BG_RECT_CORNER_RADIUS
bg_rect_path.addRoundedRect(QRectF(bg_rect), radius, radius,
Qt.AbsoluteSize)
painter.setPen(self.bg_rect_pen)
painter.fillPath(bg_rect_path, self.bg_rect_fill)
painter.drawPath(bg_rect_path)
painter.setPen(self.text_pen)
painter.drawText(center_pos, res.data)
def do_redrawFill(self):
self.chart.removeAllSeries() #删除所有序列
pen = QPen(self.__colorLine) #线条颜色
pen.setWidth(2)
seriesFullWave = QLineSeries() #全波形
seriesFullWave.setUseOpenGL(True)
seriesFullWave.setPen(pen)
seriesPositive = QLineSeries() #正半部分曲线
seriesPositive.setUseOpenGL(True)
seriesPositive.setVisible(False) #不显示
seriesNegative = QLineSeries() #负半部分曲线
seriesNegative.setUseOpenGL(True)
seriesNegative.setVisible(False) #不显示即可
seriesZero = QLineSeries() #零均值线
seriesZero.setUseOpenGL(True)
seriesZero.setVisible(False) #不显示即可
## 填充数据
vx = 0
intv = 0.001 #1000Hz采样，数据点间隔时间
pointCount = len(self.__vectData)
for i in range(pointCount):
value = self.__vectData[i]
seriesFullWave.append(vx, value) #完整波形
seriesZero.append(vx, 0) #零值线
if value > 0:
seriesPositive.append(vx, value) #正半部分波形
seriesNegative.append(vx, 0)
else:
seriesPositive.append(vx, 0)
seriesNegative.append(vx, value) #负半部分波形
vx = vx + intv
self.__axisX.setRange(0, vx)
## 创建QAreaSeries序列，设置上、下界的QLineSeries对象
pen.setStyle(Qt.NoPen) #无线条,隐藏填充区域的边线
if self.ui.radioFill_Pos.isChecked(): #positive fill
series = QAreaSeries(seriesPositive, seriesZero) #QAreaSeries
series.setColor(self.__colorFill) #填充色
series.setPen(pen) #不显示线条
self.chart.addSeries(series)
series.attachAxis(self.__axisX)
series.attachAxis(self.__axisY)
elif self.ui.radioFill_Neg.isChecked(): #negative fill
series = QAreaSeries(seriesZero, seriesNegative)
series.setColor(self.__colorFill)
series.setPen(pen) #不显示线条
self.chart.addSeries(series)
series.attachAxis(self.__axisX)
series.attachAxis(self.__axisY)
elif self.ui.radioFill_Both.isChecked(): #both fill
series = QAreaSeries(seriesZero, seriesFullWave)
series.setColor(self.__colorFill)
series.setPen(pen) #不显示线条
self.chart.addSeries(series)
series.attachAxis(self.__axisX)
series.attachAxis(self.__axisY)
series.clicked.connect(self.do_area_clicked) #关联槽函数
## 构建QAreaSeries的两个QLineSeries序列必须添加到chart里，否则程序崩溃
self.chart.addSeries(seriesZero) #隐藏
self.chart.addSeries(seriesPositive) #隐藏
self.chart.addSeries(seriesNegative) #隐藏
self.chart.addSeries(seriesFullWave) #全波形曲线，显示
seriesPositive.attachAxis(self.__axisX)
seriesPositive.attachAxis(self.__axisY)
seriesNegative.attachAxis(self.__axisX)
seriesNegative.attachAxis(self.__axisY)
seriesZero.attachAxis(self.__axisX)
seriesZero.attachAxis(self.__axisY)
seriesFullWave.attachAxis(self.__axisX)
seriesFullWave.attachAxis(self.__axisY)
