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)