def trace_edge(self, edge): if edge.l.y() == edge.r.y(): return if edge.l.y() > edge.r.y(): edge.l, edge.r = edge.r, edge.l step_x = (edge.r.x() - edge.l.x()) / (edge.r.y() - edge.l.y()) x = edge.l.x() y = edge.l.y() pix = QPixmap() painter = QPainter() painter.begin(self.image) painter.setPen(QColorConstants.Green) while y < edge.r.y(): if QColor(self.image.pixel(int(x) + 1, y)) != QColorConstants.Green: painter.drawPoint(int(x) + 1, y) else: painter.drawPoint(int(x), y) x += step_x y += 1 painter.end() pix.convertFromImage(self.image) self.scene.addPixmap(pix)
def paint(self, painter: QPainter, option: QStyleOptionGraphicsItem, widget: Optional[QWidget] = ...) -> None: # mark item_pixels = [] if self.item_type == 'line' and self.p_list: item_pixels = alg.draw_line(self.p_list, self.algorithm) elif self.item_type == 'polygon': if self.end == 1: item_pixels = alg.draw_polygon(self.p_list, self.algorithm) else: item_pixels = alg.draw_polyline(self.p_list, self.algorithm) elif self.item_type == 'ellipse': item_pixels = alg.draw_ellipse(self.p_list) elif self.item_type == 'curve': item_pixels = alg.draw_curve(self.p_list, self.algorithm) elif self.item_type == 'polyline': item_pixels = alg.draw_polyline(self.p_list, self.algorithm) elif self.item_type == 'pencil': item_pixels = alg.draw_polyline(self.p_list, 'Bresenham') elif self.item_type == 'clip': # 画一个矩形而已 x_min, y_min, x_max, y_max = self.p_list[0][0], self.p_list[0][ 1], self.p_list[1][0], self.p_list[1][1] item_pixels = alg.draw_polygon([[x_min, y_min], [x_min, y_max], [x_max, y_max], [x_max, y_min]], 'Bresenham') for p in item_pixels: # painter.setPen(self.item_color) pen = QPen(self.item_color, self.pen_width, Qt.SolidLine) painter.setPen(pen) painter.drawPoint(*p) if self.selected: painter.setPen(QColor(255, 0, 0)) if self.p_list: painter.drawRect(self.boundingRect())
def draw_data(self, qp: QtGui.QPainter, color: QtGui.QColor, data: List[Datapoint], delay: List[Datapoint]): pen = QtGui.QPen(color) pen.setWidth(self.dim.point) line_pen = QtGui.QPen(color) line_pen.setWidth(self.dim.line) qp.setPen(pen) for i, d in enumerate(data): x = self.getXPosition(d) y = self.getYPositionFromDelay(delay[i]) if self.isPlotable(x, y): qp.drawPoint(int(x), int(y)) if self.flag.draw_lines and i > 0: prevx = self.getXPosition(data[i - 1]) prevy = self.getYPositionFromDelay(delay[i - 1]) qp.setPen(line_pen) if self.isPlotable(x, y) and self.isPlotable(prevx, prevy): qp.drawLine(x, y, prevx, prevy) elif self.isPlotable(x, y) and not self.isPlotable(prevx, prevy): new_x, new_y = self.getPlotable(x, y, prevx, prevy) qp.drawLine(x, y, new_x, new_y) elif not self.isPlotable(x, y) and self.isPlotable( prevx, prevy): new_x, new_y = self.getPlotable(prevx, prevy, x, y) qp.drawLine(prevx, prevy, new_x, new_y) qp.setPen(pen)
def mousePressEvent(self, event): """Mouse press event to handle mouse clicks with various tools :param event: Source event :type event: QGraphicsSceneMouseEvent """ if event.buttons() == Qt.LeftButton and not self.pasting: self.scene.setColorSwitchEnabled(False) if self.start_pos is None: self.start_pos = QPointF( math.floor(event.pos().x()), math.floor(event.pos().y()) ) self.start_scene_pos = QPointF( math.floor(event.scenePos().x()), math.floor(event.scenePos().y()), ) self.last_pos = self.start_pos if self.tool is Tools.SELECT: self.selecting = False self.select_timer.stop() self.scene.update() if self.tool is Tools.PEN: pixmap = self.pixmap() painter = QPainter(pixmap) pen = QPen(QColor.fromRgba(self.color)) pen.setWidth(1) painter.setPen(pen) painter.drawPoint(self.start_pos) self.setPixmap(pixmap) painter.end()
def drawTo(self, endPoint): painter = QPainter(self.image) painter.setPen(QPen(self.myPenColor, self.myPenWidth, Qt.SolidLine, Qt.RoundCap, Qt.RoundJoin)) painter.drawPoint(endPoint) self.modified = True self.update()
def drawBackground(self, p: QPainter, r: QRect): p.drawRect(self.sceneRect()) if not self._paintGrid: return p.setPen(Qt.SolidLine) for point in self._backgroundPoints: p.drawPoint(point)
def mousePressEvent(self, e): if self.AC != "" and ( ((e.x() > self.label_AC.x()) and (e.x() < self.label_AC.x() + self.label_AC.width())) and ((e.y() > self.label_AC.y()) and (e.y() < self.label_AC.y() + self.label_AC.height()))): try: painter = QPainter(self.label_AC.pixmap()) mappedPoint = self.label_AC.mapFromParent(e.pos()) self.arr.append([mappedPoint.x(), mappedPoint.y()]) painter.setPen(QPen(Qt.blue, 1, Qt.DashLine)) painter.drawPoint(mappedPoint.x(), mappedPoint.y()) #painter.drawPoint(e.x(), e.y()) if len(self.arr) % 2 == 0 and len(self.arr) != 0: self.center = self.arr[-2] self.tip = self.arr[-1] self.radius = ((self.center[0] - self.tip[0])**2 + (self.center[1] - self.tip[1])**2)**.5 #painter.drawEllipse(self.label_AC.mapFromParent(e.pos()) , 2*self.radius, 2*self.radius) painter.drawEllipse(self.center[0] - self.radius, self.center[1] - self.radius, 2 * self.radius, 2 * self.radius) #print(self.arr[-1][0], " || " , self.arr[-1][1]) painter.end() self.update() except Exception as err: print(err)
def paintEvent(self, event): painter = QPainter(self) painter.setRenderHint(QPainter.Antialiasing) # 背景白色 painter.fillRect(event.rect(), QBrush(Qt.white)) # 绘制边缘虚线框 painter.setPen(Qt.DashLine) painter.setBrush(Qt.NoBrush) painter.drawRect(self.rect()) # 随机画条线 for _ in range(3): painter.setPen(QPen(QTCOLORLIST[qrand() % 5], 1, Qt.SolidLine)) painter.setBrush(Qt.NoBrush) painter.drawLine(QPoint(0, qrand() % self.height()), QPoint(self.width(), qrand() % self.height())) painter.drawLine(QPoint(qrand() % self.width(), 0), QPoint(qrand() % self.width(), self.height())) # 绘制噪点 painter.setPen(Qt.DotLine) painter.setBrush(Qt.NoBrush) for _ in range(self.width()): # 绘制噪点 painter.drawPoint(QPointF(qrand() % self.width(), qrand() % self.height())) # super(WidgetCode, self).paintEvent(event) # 绘制文字 # 绘制跳动文字 metrics = QFontMetrics(self.font()) x = (self.width() - metrics.width(self.text())) / 2 y = (self.height() + metrics.ascent() - metrics.descent()) / 2 for i, ch in enumerate(self.text()): index = (self.step + i) % 16 painter.setPen(TCOLORLIST[qrand() % 6]) painter.drawText(x, y - ((SINETABLE[index] * metrics.height()) / 400), ch) x += metrics.width(ch)
def paintEvent(self, event): if self.clear_mark: self.clear_mark = False main_painter = QPainter(self) self.pix = QPixmap(path) main_painter.drawPixmap(0, 0, self.pix) return painter = QPainter(self.pix) painter.begin(self.pix) pen = QPen(Qt.red, 3, Qt.SolidLine) painter.setPen(pen) pp = QPainter(self.pix) pen = QPen() pen.setWidth(4) pp.setPen(pen) pp.drawLine(self.lastPoint, self.endPoint) self.lastPoint = self.endPoint pp.end() temp_points = self.split_points() for item in range(len(temp_points)): painter.drawPoint(temp_points[item].x, temp_points[item].y) painter.end() painter = QPainter(self) painter.drawPixmap(0, 0, self.pix)
def paintEvent(self, event): if self.display_status: super().paintEvent(event) painter = QPainter(self) painter_path = QPainterPath() qt_pen_1 = QPen(Qt.red, 2, Qt.SolidLine) qt_pen_2 = QPen(Qt.green, 10, Qt.SolidLine) qt_pen_3 = QPen(Qt.red, 2, Qt.DotLine) painter.setPen(qt_pen_1) painter.drawPolygon(QPolygon(self.roi_rect), Qt.WindingFill) painter_path.addPolygon(QPolygonF(self.roi_rect)) painter_path.closeSubpath() # qt_brush = QBrush(Qt.green) qt_brush = QBrush(QColor(0, 255, 0, 64)) painter.setBrush(qt_brush) painter.drawPath(painter_path) # painter.drawPoint(self.tmp_center_pt) painter.setPen(qt_pen_3) painter.drawLine(self.roi_rect[0], self.roi_rect[2]) painter.drawLine(self.roi_rect[1], self.roi_rect[3]) painter.setPen(qt_pen_2) for elem in self.roi_rect: painter.drawPoint(elem) # for elem in self.img_rect: # painter.drawPoint(elem) if self.default_rect: self.update()
def paintEvent(self, paintEvent): #mandelbrot function must be within paintEvent to be used for drawing #determine whether point lies within mandelbrot set #doesn't seem to work! offsetWidth = 300 offsetHeight = 250 size = 200 def mandelbrot(cx, cy): zx = 0 zy = 0 for i in range(100): #calculates new value of z = z^2 + c xtemp = (zx**2) - (zy**2) ytemp = 2 * zx * zy zx = xtemp + cx zy = ytemp + cy #determine if its bound if ((zx - cx)**2) + ((zy - cy)**2) > 4: return i return 150 qp = QPainter(self) for i in range(2, 998): for j in range(2, 680): x = (i - offsetWidth) / size y = (j - offsetHeight) / size count = mandelbrot(x, y) if count == 150: qp.setPen(QColor(0, 0, 0)) else: frac = 255 * count / 100 qp.setPen(QColor(frac, frac, frac)) qp.drawPoint(i, j)
def drawLinesOnVideo(self, pt): ''' Draw Lines on Video ''' scr_x, scr_y = self.GetInverseMatrix(pt[1], pt[0]) radius = 3 center = QPoint(scr_x, scr_y) pen = QPen(Qt.yellow) pen.setWidth(radius) pen.setCapStyle(Qt.RoundCap) pen.setDashPattern([1, 4, 5, 4]) painter_p = QPainter(self) painter_p.setPen(pen) painter_p.setRenderHint(QPainter.HighQualityAntialiasing, True) painter_p.drawPoint(center) if len(self.drawLines) > 1: try: idx = self.drawLines.index(pt) scr_x, scr_y = self.GetInverseMatrix( self.drawLines[idx + 1][1], self.drawLines[idx + 1][0]) end = QPoint(scr_x, scr_y) painter_p.drawLine(center, end) except: None return
def fill_flag(win): pix = QPixmap() p = QPainter() p.begin(win.image) #p.setPen(QPen(col_one)) fill_extrem(win) FindPoints(win) #Sorter() #print(scan_dots) for i in range(len(scan_dots)): for j in range(0, 560): if (j > scan_dots[i][0]): #p.drawLine(scan_dots[i][0], scan_dots[i][1], scan_dots[i + 1][0], scan_dots[i + 1][1]) col = QColor(win.image.pixel(j, scan_dots[i][1])) if col == col_zero: p.setPen(QPen(col_one)) else: p.setPen(QPen(col_zero)) #p.drawLine(scan_dots[i][0], scan_dots[i][1], 581, scan_dots[i][1]) p.drawPoint(j, scan_dots[i][1]) if win.delay.isChecked(): delay() pix.convertFromImage(win.image) win.scene.addPixmap(pix) if not win.delay.isChecked(): pix.convertFromImage(win.image) win.scene.addPixmap(pix) #pix.convertFromImage(win.image) #win.scene.addPixmap(pix) p.end()
def paintEvent(self, paint_event): painter = QPainter(self) pen = QPen() pen.setWidth(5) painter.setPen(pen) for point in self._points_to_draw: painter.drawPoint(point)
def mousePressEvent(self, event): if event.button() == Qt.LeftButton: if self.sketch: self.lastPoint = self.cropEventPos(event) if not self.inEvent and not self.extractActivation: self.addHistory() if self.zoneActivationStatus or self.zoneLineActivationStatus: self.topCorner = self.lastPoint if self.penActivationStatus or self.zonePointActivationStatus: painter = QPainter(self.image) painter.setPen(self.pen) painter.drawPoint(self.cropEventPos(event)) self.isDrawn = True if self.zonePointActivationStatus: self.zonePointList.append(self.cropEventPos(event)) if len(self.zonePointList) == 2: painter.drawLine(self.zonePointList[0].x(), self.zonePointList[0].y(), self.zonePointList[1].x(), self.zonePointList[1].y()) self.zonePointList.pop(0) self.displayUpdate() if self.extractActivation: self.extractOriginPosition = self.cropEventPos(event) self.onExtract(self.extractOriginPosition)
def paintEvent(self, event): if not self.start: return if self.pos: q = QPainter(self) new_point = (self.pos.x(), self.pos.y()) self.points.append(new_point) x, y = self.points[0] if len(self.points) == 1: q.drawPoint(x, y) else: old_point = self.points[-2] x2, y2 = new_point x1, y1 = old_point steps = int(sqrt(((x2 - x1)**2) + ((y2 - y1)**2))) for (new_x, new_y) in self.points: q.drawLine(x, y, new_x, new_y) x, y = new_x, new_y if steps < step_size: self.points = self.points[:-1] else: actions, steps, direction = self.get_action( x1, y1, x2, y2, steps) print("Mouse Direction: " + direction) self.take_action(actions, steps, delay=0)
def paintEvent(self, QPaintEvent): pen3 = QPen(Qt.red, 1) pen4 = QPen(Qt.green, 1) painter = QPainter(self) # draw Hriazontal line painter.setPen(self.pen1) painter.drawPixmap(self.rect(), self._pixmap) painter.drawLine(self.drawCoord[0], 0, self.drawCoord[0], self.height()) # draw Vertical line painter.setPen(self.pen2) painter.drawLine(0, self.drawCoord[1], self.width(), self.drawCoord[1]) pen3.setWidth(3) painter.setPen(pen3) painter.drawPoint(self.drawCoord[0], self.drawCoord[1]) pen4.setWidth(5) painter.setPen(pen4) painter.drawPoint(self.drawCoord2[0], self.drawCoord2[1]) self.distancLine.setWidth(1) painter.setPen(self.distancLine) painter.drawLine(self.drawCoord[0], self.drawCoord[1], self.drawCoord2[0], self.drawCoord2[1]) pass
def render_from_z_mask(z_buf_mask, context): z_buf_mask = convert_deep_to_alpha(z_buf_mask) # рисовать qp = QPainter() picture = QPicture() qp.begin(picture) for x in range(len(z_buf_mask)): for y in range(len(z_buf_mask[0])): # a = color_mask[x][y] a = QColor(Qt.black) a.setAlpha(z_buf_mask[x][y]) qp.setPen(a) qp.drawPoint(x, y) qp.end() # painting done picture.save("drawing.pic") # save picture picture = QPicture() picture.load("drawing.pic") # load picture qp = QPainter() qp.begin(context) # paint in myImage qp.drawPicture(0, 0, picture) # draw the picture at (0,0) qp.end()
def capture_mousePressEvent(self, ev: QtGui.QMouseEvent): if (self.data is not None) and (self.drawPressPoint is True): # Set Pixmap in Source Label pixmap_cur = self.ReadImageAsQImageObjectinSource( self.ConvertToPath( self.data.read_frame_nparray(self.data_index))) painter_cur = QPainter() painter_cur.begin(pixmap_cur) pen_cur = QPen() pen_cur.setColor(QColor(255, 0, 0)) # RGB Channel, which means pure red pen_cur.setWidth(3) painter_cur.setPen(pen_cur) painter_cur.drawPoint(ev.x(), ev.y()) painter_cur.end() self.graphicslabel_Source.setPixmap(pixmap_cur) # Important !!!! Exchange X and Y index_x = ev.y() index_y = ev.x() self.im = misc.imread( self.ConvertToPath( self.data.read_frame_nparray(self.data_index))) label, self.line, self.centerpoint = alg.FindLineAndLabel( self.im, index_x, index_y) self.showVideoinFrameInProcessed(label) self.drawPressPoint = False
def paintEvent(self, QPaintEvent): font = QFont("宋体", 20, QFont.Black, True) painter = QPainter(self) if self.is_show_tri: painter.drawPixmap( self.rect(), QPixmap( self.qtri_img.scaled(self.size(), Qt.IgnoreAspectRatio, Qt.SmoothTransformation))) else: painter.drawPixmap(self.rect(), self.qPixmap) pen = QPen() pen.setCapStyle(Qt.RoundCap) pen.setWidth(10) pen.setBrush(QColor(255, 0, 0)) painter.setRenderHint(QPainter.Antialiasing, True) painter.setFont(font) for i, pos in enumerate(self.points): pen.setBrush(QColor(255, 0, 0)) painter.setPen(pen) painter.drawPoint(pos) pen.setBrush(QColor(218, 112, 214)) painter.setPen(pen) painter.drawText(pos, str(i))
def paintEvent(self, event): qpainter = QPainter(self) for xpix in range(ScreenSize[0]): for ypix in range(ScreenSize[1]): qpainter.setPen(Getcolor(xpix, ypix)) qpainter.drawPoint(xpix, ypix)
def paintEvent(self, event): qp = QPainter() qp.begin(self) pen = QPen(Qt.black, 5) qp.setPen(pen) qp.drawPoint(self.pos1[0], self.pos1[1]) qp.end()
def paintEvent(self, event): painter = QPainter(self) painter.setPen(QPen(Qt.black, 5, Qt.SolidLine)) #painter.setBrush(QBrush(Qt.red, Qt.SolidPattern)) painter.setBrush(QBrush(Qt.red, Qt.VerPattern)) self.getLstOfObject() if self.boolTraitement == 1 or self.lstOfObject: cpt = 0 self.erase(painter) for obj in self.lstOfObject: polarPoint = obj if self.lstOfColor[cpt] == 'G': painter.setPen(QPen(Qt.green, 5, Qt.SolidLine)) cpt += 1 elif self.lstOfColor[cpt] == 'Y': painter.setPen(QPen(Qt.yellow, 5, Qt.SolidLine)) cpt += 1 elif self.lstOfColor[cpt] == 'R': painter.setPen(QPen(Qt.red, 5, Qt.SolidLine)) cpt += 1 for element in polarPoint: #Choix de la couleur pour le crayon : rad = math.radians(element[0]) real_x = int((element[1] / 100) * math.degrees(math.cos(rad))) + self.mid real_y = int((element[1] / 100) * math.degrees(math.sin(rad))) + self.mid #print("x :", real_x, "y :", real_y); painter.drawPoint(real_x, real_y) self.update()
def fill_color(self, event): def get_cardinal_points(center_pos): cardinal_points = [] cx, cy = center_pos for x0, y0 in [(1, 0), (0, 1), (-1, 0), (0, -1)]: xx, yy = cx + x0, cy + y0 if (xx >= 0 and xx < w and yy >= 0 and yy < h and (xx, yy) not in have_seen): cardinal_points.append((xx, yy)) have_seen.add((xx, yy)) return cardinal_points x, y = event.x(), event.y() w, h = self.image.width(), self.image.height() target_color = self.image.pixel(x, y) painter = QPainter(self.image) painter.setPen(QPen(self.currColor)) have_seen = set() queue = [(x, y)] while queue: x, y = queue.pop() if self.image.pixel(x, y) == target_color: painter.drawPoint(QPoint(x, y)) points = get_cardinal_points((x, y)) queue.extend(points) self.update()
def draw_data(self, qp: QtGui.QPainter, color: QtGui.QColor, data: List[Datapoint], fstart: int = 0, fstop: int = 0): if not data: return fstop = fstop or data[-1].freq pen = QtGui.QPen(color) pen.setWidth(self.dim.point) line_pen = QtGui.QPen(color) line_pen.setWidth(self.dim.line) qp.setPen(pen) prev_x = self.getXPosition(data[0]) prev_y = int(self.height() / 2 + data[0].im * -1 * self.dim.height / 2) for i, d in enumerate(data): x = self.getXPosition(d) y = int(self.height() / 2 + d.im * -1 * self.dim.height / 2) if d.freq > fstart and d.freq < fstop: qp.drawPoint(x, y) if self.flag.draw_lines and i > 0: qp.setPen(line_pen) qp.drawLine(x, y, prev_x, prev_y) qp.setPen(pen) prev_x, prev_y = x, y
def paintEvent(self, event): """Update the frame with all the new laser information. Updated with the GUI loop""" self.laser_data = self.parent.controller.get_data(self.id) _width = self.width() _height = self.height() cx = _width / 2 cy = _height / 2 x1 = y1 = d = ang = 0 width = 2 pen = QPen(Qt.white, width) painter = QPainter(self) painter.setPen(pen) if self.laser_data: if len(self.laser_data.values) > 0: step = (self.laser_data.maxAngle - self.laser_data.minAngle) / len(self.laser_data.values) d = self.laser_data.maxRange / (_width / 2) ang = self.laser_data.minAngle for i in range(len(self.laser_data.values)): ang = self.laser_data.minAngle + i * step x1 = cx + (self.laser_data.values[i] / d) * math.cos(ang) y1 = cy - (self.laser_data.values[i] / d) * math.sin(ang) painter.drawPoint(QPointF(x1, y1))
def paintEvent(self, e): painter = QPainter(self) # painter.setBrush(QBrush(Qt.red, Qt.SolidPattern)) painter.setBrush(QBrush(Qt.green, Qt.DiagCrossPattern)) painter.drawRect(0, 0, 700, 700) painter.setPen(QPen(Qt.black, 8, Qt.SolidLine)) painter.setFont(QtGui.QFont('Decorative', 16)) painter.drawLine(2, 2, 2, 700) painter.drawText(10, 650, "x2") painter.drawLine(2, 2, 700, 2) painter.drawText(650, 25, "x1") # painter.rotate(RR) # painter.setPen(QPen(Qt.black, 5, Qt.SolidLine)) # painter.drawEllipse(F1 - A1, F2 - A2, 2 * A1, 2 * A2) # painter.rotate(-RR) painter.setPen(QPen(Qt.red, 5, Qt.SolidLine)) for x, y in data: painter.drawPoint(int(x), int(y)) # draw line of distributes: painter.setPen(QPen(Qt.blue, 6, Qt.SolidLine)) # distrubteX2 = w[1] / (w[1] + w[0]) distrubteX2 = 1 endpointX2 = rotate([F1, F2], [F1, (A2 + F2) * distrubteX2], RR) painter.drawLine(F1, F2, int(endpointX2[0]), int(endpointX2[1])) # distrubteX1 = w[0] / (w[1] + w[0]) distrubteX1 = 1 endpointX1 = rotate([F1, F2], [(F1 + A1) * distrubteX1, F2], RR) painter.drawLine(F1, F2, int(endpointX1[0]), int(endpointX1[1]))
def mousePressEvent(self, event): if event.button() == Qt.LeftButton: self.undo_states.append(self.pixmap.copy()) if len(self.undo_states ) > 3: # Сохраняем не больше 3х последних действий del self.undo_states[0] self.redo_actions_type.clear( ) # Как только внесли изменение в отмененное состояние, self.redo_states.clear() # Теряем возможность повторить действия self.drawing = True self.last_point = event.pos() painter = QPainter(self.pixmap) painter.setPen(QPen(self.color, 3, Qt.SolidLine)) if self.kp_mode: # Режим ключевых точек painter.drawEllipse(event.pos(), 6, 6) painter.setFont(QFont('Arial', 10)) painter.drawText(event.x() + 5, event.y() + 20, str(self.kp_text)) self.kp_text += 1 self.kp_list.append((event.x(), event.y())) self.undo_actions_type.append('kp') else: # Рисуем обычную точку painter.drawPoint(event.pos()) self.undo_actions_type.append('draw') self.update()
def paint(self, painter: QPainter, option: QStyleOptionGraphicsItem, widget: Optional[QWidget] = ...) -> None: painter.setPen(self.col) if self.item_type == 'line': item_pixels = alg.draw_line(self.p_list, self.algorithm) for p in item_pixels: painter.drawPoint(*p) if self.selected: painter.setPen(QColor(255, 0, 0)) painter.drawRect(self.boundingRect()) elif self.item_type == 'polygon': item_pixels = alg.draw_polygon(self.p_list, self.algorithm) for p in item_pixels: painter.drawPoint(*p) if self.fill == True: fill_pixels = alg.fill(self.p_list) for p in fill_pixels: painter.drawPoint(*p) if self.selected: painter.setPen(QColor(255, 0, 0)) painter.drawRect(self.boundingRect()) elif self.item_type == 'ellipse': item_pixels = alg.draw_ellipse(self.p_list) for p in item_pixels: painter.drawPoint(*p) if self.selected: painter.setPen(QColor(255, 0, 0)) painter.drawRect(self.boundingRect()) elif self.item_type == 'curve': item_pixels = alg.draw_curve(self.p_list, self.algorithm) for p in item_pixels: painter.drawPoint(*p) if self.selected: painter.setPen(QColor(255, 0, 0)) painter.drawRect(self.boundingRect())
def labelPoints(self, img: Optional[QPixmap], toSrc: bool): if not img or not self.points: return None painter = QPainter() painter.begin(img) painter.setRenderHint(QPainter.Antialiasing, True) pen = QPen() pen.setCapStyle(Qt.RoundCap) font = QFont('Consolas') if toSrc: pen.setWidthF(config.pointWidth * self.ratioToSrc) font.setPointSizeF(config.fontSize * self.ratioToSrc) else: pen.setWidthF(config.pointWidth) font.setPointSizeF(config.fontSize) painter.setFont(font) for index, (point, color) in self.points.items(): labelPoint: QPointF if toSrc: pen.setColor(color) labelPoint = self.getSrcPoint(point) else: pen.setColor( color if index != self.highlightMoveIndex and index not in self.highlightPoints else QColor.lighter(color) ) labelPoint = point painter.setPen(pen) painter.drawPoint(labelPoint) painter.drawText(static.getIndexShift(labelPoint), str(index)) painter.end()
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 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 paintEvent(self, event): qp = QPainter(self) qp.setPen(Qt.black) size = self.size() for i in range(1024): x = random.randint(1, size.width() - 1) y = random.randint(1, size.height() - 1) qp.drawPoint(x, y)
def paintEvent(self, event): qp = QPainter(self) qp.setRenderHint(QPainter.Antialiasing) # <- Set anti-aliasing See https://wiki.python.org/moin/PyQt/Painting%20and%20clipping%20demonstration qp.setPen(Qt.black) size = self.size() for i in range(1024): x = random.randint(1, size.width() - 1) y = random.randint(1, size.height() - 1) qp.drawPoint(x, y)
def drawPoints(self): qp = QPainter() qp.begin(self) qp.setPen(Qt.red) size = self.size() for i in range(1000): x = random.randint(1, size.width() - 1) y = random.randint(1, size.height() - 1) qp.drawPoint(x, y) qp.end() self.show()
def updateImage(self): if self.fid is not None: self.readCurrentFrame() else: self._normalizeImage() self.mainImage._canvas.setCursor(Qt.CrossCursor) if self.h5path in self.eggs: if self.frame_number in self.eggs[self.h5path]: current_list = self.eggs[self.h5path][self.frame_number] painter = QPainter() painter.begin(self.frame_qimg) pen = QPen() pen.setWidth(2) pen.setColor(Qt.red) painter.setPen(pen) painter.setBrush(Qt.red) for (x,y) in current_list: #painter.drawEllipse(x,y, 1,1) painter.drawPoint(x,y) painter.end() #set number of eggs eggs n_eggs_txt = "{} Eggs".format(len(self.eggs[self.h5path][self.frame_number])) self.ui.number_of_eggs.setText(n_eggs_txt) else: self.ui.number_of_eggs.setText("0 Eggs") prev_frame = self.frame_number-1 if self.ui.show_prev.isChecked() and prev_frame in self.eggs[self.h5path]: prev_list = self.eggs[self.h5path][prev_frame] painter = QPainter() painter.begin(self.frame_qimg) pen = QPen() pen.setWidth(1) pen.setColor(Qt.blue) painter.setPen(pen) for (x,y) in prev_list: painter.drawEllipse(x-3,y-3, 5,5) #painter.drawPoint(x,y) painter.end() self.mainImage.setPixmap(self.frame_qimg)
def __setImagePixel(self, pos, opaque): """ Private slot to set or erase a pixel. @param pos position of the pixel in the widget (QPoint) @param opaque flag indicating a set operation (boolean) """ i, j = self.__imageCoordinates(pos) if self.__image.rect().contains(i, j) and (i, j) != self.__lastPos: if opaque: painter = QPainter(self.__image) painter.setPen(self.penColor()) painter.setCompositionMode(self.__compositingMode) painter.drawPoint(i, j) else: self.__image.setPixel(i, j, qRgba(0, 0, 0, 0)) self.__lastPos = (i, j) self.update(self.__pixelRect(i, j))
def paintEvent(self, event): """Paint transparent background,animated pattern,background text.""" painter, font = QPainter(self), self.font() painter.fillRect(event.rect(), Qt.transparent) # fill transparent rect painter.setPen(QPen(QColor(randint(9, 255), randint(9, 255), 255))) painter.rotate(30) # Rotate painter ~30 Degree font.setBold(True) # Set painter Font for text font.setPixelSize(100) painter.setFont(font) painter.drawText(99, 99, "Python Qt") # draw the background text painter.rotate(-30) # Rotate -30 the QPen back painter.setPen(Qt.NoPen) # set the pen to no pen painter.setBrush(QColor("black")) # Background Color painter.setOpacity(0.9) # Background Opacity painter.drawRoundedRect(self.rect(), 25, 25) # Back Rounded Borders for i in range(2048): # animated random dots background pattern x = randint(10, self.size().width() - 10) y = randint(10, self.size().height() - 10) painter.setPen(QPen(QColor(randint(9, 255), randint(9, 255), 255))) painter.drawPoint(x, y) QMainWindow.paintEvent(self, event)
class Window(QWidget): def __init__(self): super().__init__() self.size_h = 600 self.size_w = 1000 self.setGeometry(200, 200, self.size_w, self.size_h) self.setFixedSize(self.size_w, self.size_h) self.setWindowTitle("Растровый редактор") self.points = [] self.preview = {} for _ in range(self.size_w): self.points.append([0 for _ in range(self.size_h)]) self.qp = QPainter() self.width = 0 self.left_x = 0 self.top_y = 0 self.height = 0 self.last_x = 0 self.last_y = 0 h_layout = QHBoxLayout() h_layout.addStretch(1) v_layout = QVBoxLayout() v_layout.addStretch(1) self.option = Instruments.pen self.thickness = 1 self.color = QColor(0, 0, 0) self.color_changer = QPushButton(self) self.color_changer.setFixedSize(30, 30) self.color_changer.setStyleSheet("background: black") self.color_changer.clicked[bool].connect(self.change_color) self.thick_changer = QSlider(Qt.Horizontal, self) self.thick_changer.setRange(1, 9) self.thick_changer.setFixedSize(50, 10) self.thick_changer.valueChanged[int].connect(self.change_thickness) self.thick_lab = QLabel("W: 1", self) pen = Button("Перо", Instruments.pen, self) pen.clicked[bool].connect(self.change_option) line = Button("Линия", Instruments.line, self) line.clicked[bool].connect(self.change_option) rect = Button("Прямоугольник", Instruments.rect, self) rect.clicked[bool].connect(self.change_option) fill = Button("Заливка", Instruments.fill, self) fill.clicked[bool].connect(self.change_option) clean = QPushButton("Очистить", self) clean.clicked[bool].connect(self.clean) save = QPushButton("Сохранить", self) save.clicked[bool].connect(self.save) load = QPushButton("Загрузить", self) load.clicked[bool].connect(self.load) h_layout.addWidget(save) h_layout.addWidget(load) h_layout.addWidget(self.thick_lab) h_layout.addWidget(self.thick_changer) h_layout.addWidget(pen) h_layout.addWidget(line) h_layout.addWidget(rect) h_layout.addWidget(fill) h_layout.addWidget(clean) h_layout.addWidget(self.color_changer) v_layout.addLayout(h_layout) self.setLayout(v_layout) self.figure_x1 = 0 self.figure_y1 = 0 def clean(self): for i in range(self.size_w): for j in range(self.size_h): self.points[i][j] = 0 self.left_x = 0 self.top_y = 0 self.width = self.size_w self.height = self.size_h self.repaint() def change_color(self): self.color = QColorDialog.getColor() self.color_changer.setStyleSheet("background: %s" % self.color.name()) self.top_y = 0 self.left_x = 0 self.width = self.size_w self.height = self.size_h self.repaint(self.left_x, self.top_y, self.width, self.height) def change_option(self): sender = self.sender() self.option = sender.option def change_thickness(self): self.thickness = self.thick_changer.value() self.thick_lab.setText("W: "+str(self.thickness)) def save(self): image = Image.new('RGB', (self.size_w, self.size_h), (0, 0, 0, 0)) drawer = ImageDraw.Draw(image) for i in range(self.size_w): for j in range(self.size_h): if self.points[i][j]: drawer.point((i, j), (self.points[i][j].red(),\ self.points[i][j].green(),\ self.points[i][j].blue())) else: drawer.point((i, j), tuple([255, 255, 255])) name = QFileDialog.getSaveFileName(self, filter="Images (*.png)")[0] if name: image.save(name, 'PNG') self.left_x = 0 self.top_y = 0 self.width = self.size_w self.height = self.size_h self.repaint() def load(self): picture_name = QFileDialog.getOpenFileName(self)[0] if picture_name.split('.')[-1] != 'png' or not picture_name: return image = Image.open(picture_name) data = image.load() size_y = min(image.size[1], self.size_h) size_x = min(image.size[0], self.size_w) for x in range(size_x): for y in range(size_y): x_y = data[x, y] self.points[x][y] = QColor(x_y[0], x_y[1], x_y[2]) self.left_x = 0 self.top_y = 0 self.width = self.size_w self.height = self.size_h self.repaint() def mousePressEvent(self, event): x = event.x() y = event.y() if self.option == Instruments.pen: logic.add_thickness_point(self.points, x, y, self.color, self.thickness) elif self.option == Instruments.line: self.figure_x1 = x self.figure_y1 = y elif self.option == Instruments.rect: self.figure_x1 = x self.figure_y1 = y else: logic.brush(x, y, self.points, self.color, self.size_w, self.size_h) self.left_x = 0 self.top_y = 0 self.width = self.size_w self.height = self.size_h self.repaint() return self.last_x = x self.last_y = y self.left_x = x-self.thickness self.width = 2*self.thickness self.top_y = y-self.thickness self.height = 2*self.thickness self.repaint(self.left_x, self.top_y, self.width, self.height) def mouseMoveEvent(self, event): x = event.x() y = event.y() if -1 < x < self.size_w-self.thickness and -1 < y < self.size_h-self.thickness: self.left_x = int(min(x, self.last_x)) - self.thickness self.top_y = int(min(y, self.last_y)) - self.thickness self.width = int(abs(self.left_x-max(x, self.last_x)))+self.thickness self.height = int(abs(self.top_y-max(y, self.last_y)))+self.thickness else: return if self.option == Instruments.pen: logic.draw_line(x, y, self.last_x, self.last_y, self.points, self.color, self.thickness) self.last_x = x self.last_y = y elif self.option == Instruments.line: self.preview.clear() logic.draw_line(x, y, self.figure_x1, self.figure_y1, self.preview, self.color, self.thickness) elif self.option == Instruments.rect: self.preview.clear() logic.draw_rect(x, y, self.figure_x1, self.figure_y1, self.preview, self.color, self.thickness) self.repaint(self.left_x, self.top_y, self.width, self.height) def mouseReleaseEvent(self, event): if self.option == Instruments.line or self.option == Instruments.rect: self.figure_x1 = 0 self.figure_y1 = 0 for point, color in self.preview.items(): self.points[point[0]][point[1]] = color self.preview.clear() self.top_y = 0 self.left_x = 0 self.width = self.size_w self.height = self.size_h self.repaint(0, 0, self.size_w, self.size_h) def paintEvent(self, QPaintEvent): self.qp.begin(self) for i in range(self.left_x, self.left_x+self.width): for j in range(self.top_y, self.top_y+self.height): if self.points[i][j]: self.qp.setPen(self.points[i][j]) self.qp.drawPoint(i, j) for point, color in self.preview.items(): self.qp.setPen(color) self.qp.drawPoint(point[0], point[1]) self.qp.end()
def refresh(self): #self.m.angleInfo.swingAngleV+=0.05 #self.m.angleInfo.armAngleV=math.pi/6; #self.m.angleInfo.armSpringAngleV=math.pi/6; #self.m.angleInfo.armFrontAngleV=math.pi/6; refreshDepthImage=None refreshImageImage=None if self.m.KSAvailable!=True: refreshDepthImage=self.m.imgBlank refreshImageImage=self.m.imgBlank else: try: #RGB Image imageFrame=KS.readImage() self.m.imageList[self.m.imgpos]=( QImage(imageFrame,640,480, QImage.Format_RGB888).rgbSwapped()) refreshImageImage=self.m.imageList[self.m.imgpos] #Depth image frame=KS.readDepth() f=np.fromstring(frame,dtype=np.uint8) self.m.depthList[self.m.imgpos]=QImage( f.repeat(4),640,480,QImage.Format_RGB32) refreshDepthImage=self.m.depthList[self.m.imgpos] #Draw points on depth image skeleton_list = [] KS.ctx.wait_and_update_all() user_list=[] for u_id in KS.userNode.users: readRet=KS.readSkeleton(self.joint_request, u_id) user_list.append(readRet) max_u=[[],[]] for u in user_list: if len(u[0])>=len(max_u[0]): max_u=u skeleton_list = max_u[0] self.joint_list=max_u[1] modifier = QPainter() color=QColor() modifier.begin(refreshDepthImage) for ske_joint in skeleton_list: if ske_joint[1] < 0: continue depth=self.hmapping(ske_joint[2]) color.setHsv(depth,255,255) modifier.setPen( QPen(color, 15, cap=Qt.RoundCap) ) modifier.drawPoint(ske_joint[0],ske_joint[1]) modifier.end() except openni.OpenNIError: self.m.KSAvailable=False print 'Kinect Sensor disconnected.' self.m.KSCheck('failurecheck'); return self.armTranspose() #Depth self.m.depthLabel.setPixmap( QPixmap.fromImage(refreshDepthImage.scaled( self.m.depthLabel.width(),self.m.depthLabel.height(), Qt.KeepAspectRatio)) ) #Image self.m.imageLabel.setPixmap( QPixmap.fromImage(refreshImageImage.scaled( self.m.imageLabel.width(),self.m.imageLabel.height(), Qt.KeepAspectRatio)) ) self.m.imgpos=1-self.m.imgpos;
def parse_terrain_to_image(terrainfile, waterheight=None): # In BWii the entry at position 1 is not KNHC, but something else that needs to be skipped if terrainfile.entries[1].name != b"KNHC": off = 1 else: off = 0 tiles = terrainfile.entries[1+off] # KNHC #tiles2 = terrainfile.entries[4+off] # TWCU tilemap = terrainfile.entries[3+off] # PAMC #tilemapdata = bytes(tilemap.data) pic = QImage(64*4*4, 64*4*4, QImage.Format_ARGB32) light_pic = QImage(64*4*4, 64*4*4, QImage.Format_ARGB32) #colortransition = QImage(os.path.join("lib", "colors_terrainview.png"), "PNG") #colors = [] #for i in range(colortransition.width()): # colors.append(colortransition.pixel(i, 0)) """new = QImage(len(colors), 200, QImage.Format_ARGB32) trans_painter = QPainter() trans_painter.begin(new) for i in range(len(colors)): r, g, b = colors[i] pen = trans_painter.pen() pen.setColor(QColor(r, g, b)) trans_painter.setPen(pen) for y in range(200): trans_painter.drawPoint(i, y) trans_painter.end() result = new.save("transition.png", "PNG") print("saved", result)""" #pic = QPixmap(64*4*4, 64*4*4) p = QPainter() p.begin(pic) light_p = QPainter() light_p.begin(light_pic) biggestheight = 0 lowest = 0xFFFF print(len(tiles.data)/(180*16)) heights = [] watercolor = (106, 152, 242) lowest_values = {} total_lowest_color = None for x in range(64): for y in range(64): a, b, offset = struct.unpack(">BBH", tilemap.data[(y*64+x)*4:(y*64+x+1)*4]) #print(a,b,offset) if b == 1: tiles_data = tiles.data[180*16*offset:180*16*(offset+1)] lowest = 0xFFFF lowest_color = None for ix in range(4): for iy in range(4): coord_offset = iy*4+ix single_tile = tiles_data[180*(coord_offset):180*(coord_offset+1)] if len(single_tile) == 0: print("Ooops:", offset) for iix in range(4): for iiy in range(4): point_offset = iiy*4 + iix #print("do stuff", (y*64+x)*4) height = struct.unpack(">H", single_tile[point_offset*2:(point_offset+1)*2])[0] light_r, light_g, light_b, unused = struct.unpack("BBBB", single_tile[32+point_offset*4:32+(point_offset+1)*4]) pen = p.pen() r = g = b = height//SCALE pen.setColor(QColor(r, g, b)) p.setPen(pen) p.drawPoint(x*16+ix*4+iix, y*16+iy*4+iiy) pen.setColor(QColor(light_r, light_g, light_b)) light_p.setPen(pen) light_p.drawPoint(x*16+ix*4+iix, y*16+iy*4+iiy) lowest_values[(x, y)] = lowest_color p.end() light_p.end() print(pic.size().height(), pic.size().width()) print(biggestheight, hex(biggestheight)) print(lowest, hex(lowest)) heights.sort() print(heights) finalimage = QImage(pic.width(), pic.height(), QImage.Format_ARGB32) p.begin(finalimage) p.drawImage(0, 0, pic) p.end() """p.begin(self.terrainview) p.drawImage(0, 0, pic) p.end()""" return finalimage.mirrored(False, True), light_pic.mirrored(False, True)#pic.mirrored(False, True)
def parse_terrain_to_image(terrainfile, waterheight=None): # In BWii the entry at position 1 is not KNHC, but something else that needs to be skipped if terrainfile.entries[1].name != b"KNHC": off = 1 else: off = 0 tiles = terrainfile.entries[1+off] # KNHC #tiles2 = terrainfile.entries[4+off] # TWCU tilemap = terrainfile.entries[3+off] # PAMC #tilemapdata = bytes(tilemap.data) pic = QImage(64*4*4, 64*4*4, QImage.Format_ARGB32) light_pic = QImage(64*4*4, 64*4*4, QImage.Format_ARGB32) #colortransition = QImage(os.path.join("lib", "colors_terrainview.png"), "PNG") #colors = [] #for i in range(colortransition.width()): # colors.append(colortransition.pixel(i, 0)) """new = QImage(len(colors), 200, QImage.Format_ARGB32) trans_painter = QPainter() trans_painter.begin(new) for i in range(len(colors)): r, g, b = colors[i] pen = trans_painter.pen() pen.setColor(QColor(r, g, b)) trans_painter.setPen(pen) for y in range(200): trans_painter.drawPoint(i, y) trans_painter.end() result = new.save("transition.png", "PNG") print("saved", result)""" #pic = QPixmap(64*4*4, 64*4*4) p = QPainter() p.begin(pic) light_p = QPainter() light_p.begin(light_pic) biggestheight = 0 lowest = 0xFFFF print(len(tiles.data)/(180*16)) heights = [] watercolor = (106, 152, 242) lowest_values = {} total_lowest_color = None outofbounds_count = 0 for x in range(64): for y in range(64): a, b, offset = struct.unpack(">BBH", tilemap.data[(y*64+x)*4:(y*64+x+1)*4]) #print(a,b,offset) if b == 1: tiles_data = tiles.data[180*16*offset:180*16*(offset+1)] lowest = 0xFFFF lowest_color = None for ix in range(4): for iy in range(4): coord_offset = iy*4+ix single_tile = tiles_data[180*(coord_offset):180*(coord_offset+1)] if len(single_tile) == 0: print("Ooops:", offset) for iix in range(4): for iiy in range(4): point_offset = iiy*4 + iix #print("do stuff", (y*64+x)*4) height = struct.unpack(">H", single_tile[point_offset*2:(point_offset+1)*2])[0] light_r, light_g, light_b, unused = struct.unpack("BBBB", single_tile[32+point_offset*4:32+(point_offset+1)*4]) #blend_r, blend_g, blend_b, wat = struct.unpack("BBBB", # single_tile[4+32+64+point_offset*4:4+32+64+(point_offset+1)*4]) pen = p.pen() """if height > biggestheight: biggestheight = height if height < lowest: lowest = height if height not in heights: heights.append(height) if height >= 0x4FF: height -= 0x4FF pen.setColor(QColor(((height>>2)+50)&0xFF, ((height>>2)+50)&0xFF, ((height>>2)+50)&0xFF)) elif height >= 0x3F0: height -= 0x3F0 pen.setColor(QColor(((height>>2)+90)&0xFF, ((height>>2)+30)&0xFF, ((height>>2)+30)&0xFF)) elif height >= 0x1FF: height -= 0x1FF pen.setColor(QColor(0, ((height>>2)+30)&0xFF, 0)) else: pen.setColor(QColor(0, 0, ((height>>2)+30)&0xFF))""" if height >= len(COLORS): #print("oops, color out of bounds:", height, len(COLORS)) outofbounds_count += 1 height = len(COLORS)-1 r, g, b = COLORS[height] if waterheight is not None and height <= waterheight*16: r = (r+watercolor[0]) // 2 g = (r+watercolor[1]) // 2 b = (b+watercolor[2]) // 2 #r, g, b = watercolor if height < lowest: #and height > 0: lowest = height lowest_color = (r, g, b) total_lowest_color = (r, g, b) pen.setColor(QColor(r, g, b)) #pen.setColor(QColor(light_r, light_g, light_b)) #pen.setColor(QColor(blend_r, blend_g, blend_b)) #pen.setColor(QColor(blend_r, blend_g, blend_b)) #pen.setColor(QColor(height>>8, height&0xFF, height&0xFF)) p.setPen(pen) p.drawPoint(x*16+ix*4+iix, y*16+iy*4+iiy) pen.setColor(QColor(light_r, light_g, light_b)) light_p.setPen(pen) light_p.drawPoint(x*16+ix*4+iix, y*16+iy*4+iiy) lowest_values[(x,y)] = lowest_color p.end() light_p.end() print(pic.size().height(), pic.size().width()) print(biggestheight, hex(biggestheight)) print(lowest, hex(lowest)) heights.sort() print(heights) if outofbounds_count > 0: print("{0} points out of bounds".format(outofbounds_count)) finalimage = QImage(pic.width(), pic.height(), QImage.Format_ARGB32) p.begin(finalimage) #common_lowest_values = if waterheight is not None: """neighbours = {} for x in range(64): for y in range(64): if (x,y) in lowest_values: for i in range(-1, 1+1): for j in range(-1, 1+1): if (x+i, y+j) not in lowest_values: if (x+i, y+j) not in neighbours: neighbours[(x+i, y+j)] = [lowest_values[(x,y)]] else: neighbours[((x+i, y+j))].append(lowest_values[(x,y)]) all_lowest_values = [] for pos, values in neighbours.items(): all_lowest_values.extend(values) r, g, b = values[0] if len(values) > 1: for r2, g2, b2 in values[1:]: r = (r+r2)//2 g = (g+g2)//2 b = (b+b2)//2 current = 0#sum(values) // len(values) x,y = pos #r, g, b = colors[current] #all_lowest = sum(all_lowest_values) // len(all_lowest_values) #watercolor = (106, 152, 242) #colors[0x4F] color = colors[lowest] print("LOWEST IS", lowest) print(neighbours) r = (color[0]+watercolor[0]) // 2 g = (color[1]+watercolor[1]) // 2 b = (color[2]+watercolor[2]) // 2""" p.fillRect(0, 0, 64*64*4, 64*64*4, QColor(total_lowest_color[0], total_lowest_color[1], total_lowest_color[2])) p.drawImage(0, 0, pic) p.end() """p.begin(self.terrainview) p.drawImage(0, 0, pic) p.end()""" return finalimage.mirrored(False, True), light_pic.mirrored(False, True)#pic.mirrored(False, True)
def paintEvent(self, event): painter = QPainter(self) width = self.width() height = self.height() if DEBUG: painter.fillRect(0, 0, width, height, Qt.blue) else: painter.fillRect(event.rect(), self.plot.canvas_color) y_min_scale = self.plot.y_scale.value_min y_max_scale = self.plot.y_scale.value_max factor_x = width / self.plot.x_diff factor_y = (height - CURVE_HEIGHT_COMPENSATION) / max(y_max_scale - y_min_scale, EPSILON) if self.plot.x_min != None and self.plot.x_max != None: x_min = self.plot.x_min x_max = self.plot.x_max if self.plot.curve_start == 'left': curve_x_offset = 0 else: curve_x_offset = round((self.plot.x_diff - (x_max - x_min)) * factor_x) transform = QTransform() transform.translate(curve_x_offset, height - CURVE_Y_OFFSET_COMPENSATION) transform.scale(factor_x, -factor_y) transform.translate(-x_min, -y_min_scale) self.plot.partial_update_width = math.ceil(transform.map(QLineF(0, 0, 1.5, 0)).length()) inverted_event_rect = transform.inverted()[0].mapRect(QRectF(event.rect())) painter.save() painter.setTransform(transform) pen = QPen() pen.setCosmetic(True) pen.setWidth(0) painter.setPen(pen) if False and self.plot.curves_visible[0]: # Currently unused support for bar graphs. # If we need this later on we should add an option to the # PlotWidget for it. # I tested this for the Sound Pressure Level Bricklet and it works, # but it didnt't look good. curve_x = self.plot.curves_x[0] curve_y = self.plot.curves_y[0] t = time.time() if self.max_points == None: self.max_points = [] for y in curve_y: self.max_points.append((t, y)) else: for i in range(len(curve_y)): if (curve_y[i] > self.max_points[i][1]) or ((t - self.max_points[i][0]) > 5): self.max_points[i] = (t, curve_y[i]) for i in range(len(self.plot.curves_x[0])): pen.setColor(self.plot.curve_configs[0].color) painter.setPen(pen) painter.drawLine(QPoint(curve_x[i], 0), QPoint(curve_x[i], curve_y[i])) pen.setColor(Qt.white) painter.setPen(pen) painter.drawLine(QPoint(curve_x[i], curve_y[i]), QPoint(curve_x[i], y_max_scale)) pen.setColor(Qt.darkGreen) painter.setPen(pen) painter.drawPoint(QPoint(curve_x[i], self.max_points[i][1])) else: for c in range(len(self.plot.curves_x)): if not self.plot.curves_visible[c]: continue curve_x = self.plot.curves_x[c] curve_y = self.plot.curves_y[c] curve_jump = self.plot.curves_jump[c] path = QPainterPath() lineTo = path.lineTo moveTo = path.moveTo start = max(min(bisect.bisect_left(curve_x, inverted_event_rect.left()), len(curve_x) - 1) - 1, 0) if start >= len(curve_x): continue moveTo(curve_x[start], curve_y[start]) for i in range(start + 1, len(curve_x)): if curve_jump[i]: curve_x_diff_half = (curve_x[i] - curve_x[i - 1]) / 2 lineTo(curve_x[i - 1] + curve_x_diff_half, curve_y[i - 1]) moveTo(curve_x[i] - curve_x_diff_half, curve_y[i]) lineTo(curve_x[i], curve_y[i]) pen.setColor(self.plot.curve_configs[c].color) painter.setPen(pen) painter.drawPath(path) painter.restore()