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