def paintEvent(self, event):
rect = QRect(10, 20, 80, 60)
path = QPainterPath()
path.moveTo(20, 80)
path.lineTo(20, 30)
path.cubicTo(80, 0, 50, 50, 80, 80)
startAngle = 30 * 16
arcLength = 120 * 16
painter = QPainter(self)
painter.setPen(self.pen)
painter.setBrush(self.brush)
if self.antialiased:
painter.setRenderHint(QPainter.Antialiasing)
for x in range(0, self.width(), 100):
for y in range(0, self.height(), 100):
painter.save()
painter.translate(x, y)
if self.transformed:
painter.translate(50, 50)
painter.rotate(60.0)
painter.scale(0.6, 0.9)
painter.translate(-50, -50)
if self.shape == RenderArea.Line:
painter.drawLine(rect.bottomLeft(), rect.topRight())
elif self.shape == RenderArea.Points:
painter.drawPoints(RenderArea.points)
elif self.shape == RenderArea.Polyline:
painter.drawPolyline(RenderArea.points)
elif self.shape == RenderArea.Polygon:
painter.drawPolygon(RenderArea.points)
elif self.shape == RenderArea.Rect:
painter.drawRect(rect)
elif self.shape == RenderArea.RoundedRect:
painter.drawRoundedRect(rect, 25, 25, Qt.RelativeSize)
elif self.shape == RenderArea.Ellipse:
painter.drawEllipse(rect)
elif self.shape == RenderArea.Arc:
painter.drawArc(rect, startAngle, arcLength)
elif self.shape == RenderArea.Chord:
painter.drawChord(rect, startAngle, arcLength)
elif self.shape == RenderArea.Pie:
painter.drawPie(rect, startAngle, arcLength)
elif self.shape == RenderArea.Path:
painter.drawPath(path)
elif self.shape == RenderArea.Text:
painter.drawText(rect, Qt.AlignCenter,
"PyQt by\nRiverbank Computing")
elif self.shape == RenderArea.Pixmap:
painter.drawPixmap(10, 10, self.pixmap)
painter.restore()
painter.setPen(self.palette().dark().color())
painter.setBrush(Qt.NoBrush)
painter.drawRect(QRect(0, 0, self.width() - 1, self.height() - 1))
def paintEvent(self, event):
rect = QRect(10, 20, 80, 60)
path = QPainterPath()
path.moveTo(20, 80)
path.lineTo(20, 30)
path.cubicTo(80, 0, 50, 50, 80, 80)
startAngle = 30 * 16
arcLength = 120 * 16
painter = QPainter(self)
painter.setPen(self.pen)
painter.setBrush(self.brush)
if self.antialiased:
painter.setRenderHint(QPainter.Antialiasing)
for x in range(0, self.width(), 100):
for y in range(0, self.height(), 100):
painter.save()
painter.translate(x, y)
if self.transformed:
painter.translate(50, 50)
painter.rotate(60.0)
painter.scale(0.6, 0.9)
painter.translate(-50, -50)
if self.shape == RenderArea.Line:
painter.drawLine(rect.bottomLeft(), rect.topRight())
elif self.shape == RenderArea.Points:
painter.drawPoints(RenderArea.points)
elif self.shape == RenderArea.Polyline:
painter.drawPolyline(RenderArea.points)
elif self.shape == RenderArea.Polygon:
painter.drawPolygon(RenderArea.points)
elif self.shape == RenderArea.Rect:
painter.drawRect(rect)
elif self.shape == RenderArea.RoundedRect:
painter.drawRoundedRect(rect, 25, 25, Qt.RelativeSize)
elif self.shape == RenderArea.Ellipse:
painter.drawEllipse(rect)
elif self.shape == RenderArea.Arc:
painter.drawArc(rect, startAngle, arcLength)
elif self.shape == RenderArea.Chord:
painter.drawChord(rect, startAngle, arcLength)
elif self.shape == RenderArea.Pie:
painter.drawPie(rect, startAngle, arcLength)
elif self.shape == RenderArea.Path:
painter.drawPath(path)
elif self.shape == RenderArea.Text:
painter.drawText(rect, Qt.AlignCenter,
"PyQt by\nRiverbank Computing")
elif self.shape == RenderArea.Pixmap:
painter.drawPixmap(10, 10, self.pixmap)
painter.restore()
painter.setPen(self.palette().dark().color())
painter.setBrush(Qt.NoBrush)
painter.drawRect(QRect(0, 0, self.width() - 1, self.height() - 1))
def paintEvent(self, event):
painter = QPainter(self)
# complete graph ratio
scale, translation = self._get_scale_translation()
if self.need_draw_grid:
self.draw_grid(scale, translation)
painter.drawPixmap(QPoint(), self.pixmap)
############ EXTERIOR #################################
painter.setPen(self.external_contour_pen)
exterior_coords_on_screen = [
QPoint(*tuple(p * scale + translation))
for p in self.current_polygon_exterior
]
painter.drawPolyline(QPolygon(exterior_coords_on_screen))
############ INTERIOR #################################
painter.setPen(self.internal_contour_pen)
interior_coords_list = []
for current_polygon_interior in self.current_polygon_interiors:
interior_coords_on_screen = [
QPoint(*tuple(p * scale + translation))
for p in current_polygon_interior
]
painter.drawPolyline(QPolygon(interior_coords_on_screen))
interior_coords_list.append(interior_coords_on_screen)
####################### Points of each point ##########
# Draw selected Point in different color
if self.current_selected_tuple is not None and self.current_selected_tuple[
0] == 'exterior':
exterior_coords_on_screen = self.draw_exterior_selected_point(
exterior_coords_on_screen, painter)
if self.current_selected_tuple is not None and self.current_selected_tuple[
0] == 'interior':
interior_coords_list = self.draw_interior_selected_point(
interior_coords_list, painter)
painter.setPen(self.external_point_pen)
painter.drawPoints(QPolygon(exterior_coords_on_screen))
painter.setPen(self.internal_point_pen)
for interior_coord in interior_coords_list:
painter.drawPoints(QPolygon(interior_coord))
###################### Each tile in the solution ###############
if self.current_best_solution is not None:
self.draw_solution(painter)
def paintEvent(self, e):
QLabel.paintEvent(self, e)
qp = QPainter(self)
qp.setRenderHint(QPainter.Antialiasing)
for color in [Qt.red, Qt.blue, Qt.green]:
pen = QPen(color, 5)
brush = QBrush(color)
qp.setPen(pen)
qp.setBrush(brush)
for point in self.points:
qp.drawPoints(
QPolygon([
x['point'] for x in self.points if x['color'] == color
]))
def paintEvent(self, QPaintEvent):
p = QPainter(self)
p.setPen(self.pen)
p.setBrush(self.brush)
rect = QRect(50, 100, 300, 200)
points = [
QPoint(150, 100),
QPoint(300, 150),
QPoint(350, 250),
QPoint(100, 300)
]
startAngle = 30 * 16
spanAngle = 120 * 16
path = QPainterPath()
path.addRect(150, 150, 100, 100)
path.moveTo(100, 100)
path.cubicTo(300, 100, 200, 200, 300, 300)
path.cubicTo(100, 300, 200, 200, 100, 100)
if self.shape == "Line":
p.drawLine(rect.topLeft(), rect.bottomRight())
elif self.shape == "Rectangle":
p.drawRect(rect)
elif self.shape == 'Rounded Rectangle':
p.drawRoundedRect(rect, 25, 25, Qt.RelativeSize)
elif self.shape == "Ellipse":
p.drawEllipse(rect)
elif self.shape == "Polygon":
p.drawPolygon(QPolygon(points), Qt.WindingFill)
elif self.shape == "Polyline":
p.drawPolyline(QPolygon(points))
elif self.shape == "Points":
p.drawPoints(QPolygon(points))
elif self.shape == "Pie":
p.drawPie(rect, startAngle, spanAngle)
elif self.shape == "Arc":
p.drawArc(rect, startAngle, spanAngle)
elif self.shape == "Chord":
p.drawChord(rect, startAngle, spanAngle)
elif self.shape == "Path":
p.drawPath(path)
elif self.shape == "Text":
p.drawText(rect, Qt.AlignCenter, "Hello Qt!")
elif self.shape == "Pixmap":
p.drawPixmap(150, 150, QPixmap("images/qt-logo.png"))
def paintEvent(self, event):
pp = QPainter(self.pix)
# pp.setPen(Qt.red)
pp.setPen(QPen(Qt.red, 20))
pp.drawArc(0, 0, 100, 100, 0, 45 * 16)
# 根据鼠标指针前后两个位置绘制直线
pp.drawPoints(self.lastPoint, self.endPoint)
# pp.drawArc(0, 0, self.lastPoint, self.endPoint, 0, 360 * 16)
# pp.drawLine(self.lastPoint, self.endPoint)
# 让前一个坐标值等于后一个坐标值，
# 这样就能实现画出连续的线
self.lastPoint = self.endPoint
painter = QPainter(self)
painter.drawPixmap(0, 0, self.pix)
self.label_29.setPixmap(self.pix)
def set_pixels(self):
painter = QPainter(self.pixmap())
self.clear_background(painter)
painter.setPen(Qt.white)
size_screen_ram = 8192 # self.screen_width * self.screen_height / 16
x = y = 0
points = []
self.request_screen_memory.emit()
for i in range(size_screen_ram):
word = self.bits[i * 16:(i + 1) * 16]
for bit in word:
x += 1
if x == self.screen_width:
x = 0
y += 1
if bit:
points.append(QPoint(x, y))
# painter.drawPoint(x, y)
painter.drawPoints(QPolygon(points))
painter.end()
self.update()
def drawWaveforms(self):
painter = QPainter(self.pixmap)
length = Rhd2000DataBlock.getSamplesPerDataBlock(
) * self.numUsbBlocksToPlot
polyline = [0] * (length + 1)
# Assume all frames are the same size.
yAxisLength = (self.frameList[self.numFramesIndex[self.selectedPort]]
[0].height() - 2) / 2.0
tAxisLength = self.frameList[self.numFramesIndex[
self.selectedPort]][0].width() - 1
for j in range(
len(self.frameList[self.numFramesIndex[self.selectedPort]])):
stream = self.selectedChannelIndex(
j + self.topLeftFrame[self.selectedPort]).boardStream
channel = self.selectedChannelIndex(
j + self.topLeftFrame[self.selectedPort]).chipChannel
stype = self.selectedChannelIndex(
j + self.topLeftFrame[self.selectedPort]).signalType
if self.selectedChannelIndex(
j + self.topLeftFrame[self.selectedPort]).enabled:
xOffset = self.frameList[self.numFramesIndex[
self.selectedPort]][j].left() + 1
xOffset += self.tPosition * tAxisLength / self.tScale
# Set clipping region
adjustedFrame = copy(
self.frameList[self.numFramesIndex[self.selectedPort]][j])
adjustedFrame.adjust(0, 1, 0, 0)
painter.setClipRect(adjustedFrame)
# Erase segment of old wavefrom
eraseBlock = copy(adjustedFrame)
eraseBlock.setLeft(xOffset)
eraseBlock.setRight(
(tAxisLength * (1000.0 / self.sampleRate) / self.tScale) *
(length - 1) + xOffset)
painter.eraseRect(eraseBlock)
# Redraw y = 0 axis
self.drawAxisLines(painter, j)
if stype == constants.AmplifierSignal:
# Plot RHD2000 amplifier waveform
tStepMsec = 1000.0 / self.sampleRate
xScaleFactor = tAxisLength * tStepMsec / self.tScale
yScaleFactor = -yAxisLength / self.yScale
yOffset = self.frameList[self.numFramesIndex[
self.selectedPort]][j].center().y()
# build waveform
for i in range(length):
polyline[i + 1] = QPointF(
xScaleFactor * i + xOffset,
yScaleFactor * self.signalProcessor.
amplifierPostFilter[stream][channel][i] + yOffset)
# join to old waveform
if self.tPosition == 0.0:
polyline[0] = polyline[1]
else:
polyline[0] = QPointF(
xScaleFactor * -1 + xOffset,
yScaleFactor * self.plotDataOld[
j + self.topLeftFrame[self.selectedPort]] +
yOffset)
# save last point in waveform to join to next segment
self.plotDataOld[j + self.topLeftFrame[
self.
selectedPort]] = self.signalProcessor.amplifierPostFilter[
stream][channel][length - 1]
# draw waveform
painter.setPen(Qt.blue)
if self.pointPlotMode:
painter.drawPoints(QPolygonF(polyline))
else:
painter.drawPolyline(QPolygonF(polyline))
elif stype == constants.AuxInputSignal:
# Plot RHD2000 auxiliary input signal
tStepMsec = 1000.0 / (self.sampleRate / 4)
xScaleFactor = tAxisLength * tStepMsec / self.tScale
yScaleFactor = -(2.0 * yAxisLength) / 2.5
yOffset = self.frameList[self.numFramesIndex[
self.selectedPort]][j].bottom()
# build waveform
for i in range(length / 4):
polyline[i + 1] = QPointF(
xScaleFactor * i + xOffset, yScaleFactor *
self.signalProcessor.auxChannel[stream][channel][i]
+ yOffset)
# join to old waveform
if self.tPosition == 0.0:
polyline[0] = polyline[1]
else:
polyline[0] = QPointF(
xScaleFactor * -1 + xOffset,
yScaleFactor * self.plotDataOld[
j + self.topLeftFrame[self.selectedPort]] +
yOffset)
# save last point in waveform to join to next segment
self.plotDataOld[j + self.topLeftFrame[
self.selectedPort]] = self.signalProcessor.auxChannel[
stream][channel][(length / 4) - 1]
# draw waveform
pen = QPen()
pen.setColor(QColor(200, 50, 50))
painter.setPen(pen)
polyline = polyline[:(length // 4) + 1]
if self.pointPlotMode:
painter.drawPoints(QPolygonF(polyline))
else:
painter.drawPolyline(QPolygonF(polyline))
elif stype == constants.SupplyVoltageSignal:
# Plot RHD2000 supply voltage signal
tStepMsec = 1000.0 / (self.sampleRate / 60.0)
xScaleFactor = tAxisLength * tStepMsec / self.tScale
yScaleFactor = -(2.0 * yAxisLength) / 1.5
yOffset = self.frameList[self.numFramesIndex[
self.selectedPort]][j].bottom()
voltageLow = False
voltageOutOfRange = False
# build waveform
for i in range(length / 60):
voltage = self.signalProcessor.supplyVoltage[stream][i]
polyline[i + 1] = QPointF(
xScaleFactor * i + xOffset,
yScaleFactor * (voltage - 2.5) + yOffset)
if voltage < 2.9 or voltage > 3.6:
voltageOutOfRange = True
elif voltage < 3.2:
voltageLow = True
# join to old waveform
if self.tPosition == 0.0:
polyline[0] = polyline[1]
else:
polyline[0] = QPointF(
xScaleFactor * -1 + xOffset,
yScaleFactor *
(self.plotDataOld[j + self.topLeftFrame[
self.selectedPort]] - 2.5) + yOffset)
# save last point in waveform to join to next segment
self.plotDataOld[j + self.topLeftFrame[
self.
selectedPort]] = self.signalProcessor.supplyVoltage[
stream][(length / 60) - 1]
# draw waveform
painter.setPen(Qt.green)
if voltageLow:
painter.setPen(Qt.yellow)
if voltageOutOfRange:
painter.setPen(Qt.red)
polyline = polyline[:(length // 60) + 1]
if self.pointPlotMode:
painter.drawPoints(QPolygonF(polyline))
else:
painter.drawPolyline(QPolygonF(polyline))
elif stype == constants.BoardAdcSignal:
# Plot USB interface board ADC input signal
tStepMsec = 1000.0 / self.sampleRate
xScaleFactor = tAxisLength * tStepMsec / self.tScale
yScaleFactor = -(2.0 * yAxisLength) / 3.3
yOffset = self.frameList[self.numFramesIndex[
self.selectedPort]][j].bottom()
# build waveform
for i in range(length):
polyline[i + 1] = QPointF(
xScaleFactor * i + xOffset, yScaleFactor *
self.signalProcessor.boardAdc[channel][i] +
yOffset)
# join to old waveform
if self.tPosition == 0.0:
polyline[0] = polyline[1]
else:
polyline[0] = QPointF(
xScaleFactor * -1 + xOffset,
yScaleFactor * self.plotDataOld[
j + self.topLeftFrame[self.selectedPort]] +
yOffset)
# save last point in waveform to join to next segment
self.plotDataOld[j + self.topLeftFrame[
self.selectedPort]] = self.signalProcessor.boardAdc[
channel][length - 1]
# draw waveform
painter.setPen(Qt.darkGreen)
if self.pointPlotMode:
painter.drawPoints(QPolygonF(polyline))
else:
painter.drawPolyline(QPolygonF(polyline))
elif stype == constants.BoardDigInSignal:
# Plot USB interface board digital input signal
tStepMsec = 1000.0 / self.sampleRate
xScaleFactor = tAxisLength * tStepMsec / self.tScale
yScaleFactor = -(2.0 * yAxisLength) / 2.0
yOffset = (self.frameList[self.numFramesIndex[
self.selectedPort]][j].bottom() +
self.frameList[self.numFramesIndex[
self.selectedPort]][j].center().y()) / 2.0
# build waveform
for i in range(length):
polyline[i + 1] = QPointF(
xScaleFactor * i + xOffset, yScaleFactor *
self.signalProcessor.boardDigIn[channel][i] +
yOffset)
# join to old waveform
if self.tPosition == 0.0:
polyline[0] = polyline[1]
else:
polyline[0] = QPointF(
xScaleFactor * -1 + xOffset,
yScaleFactor * self.plotDataOld[
j + self.topLeftFrame[self.selectedPort]] +
yOffset)
# save last point in waveform to join to next segment
self.plotDataOld[j + self.topLeftFrame[
self.selectedPort]] = self.signalProcessor.boardDigIn[
channel][length - 1]
# draw waveform
pen = QPen()
pen.setColor(QColor(200, 50, 200))
painter.setPen(pen)
if self.pointPlotMode:
painter.drawPoints(QPolygonF(polyline))
else:
painter.drawPolyline(QPolygonF(polyline))
painter.setClipping(False)
tStepMsec = 1000.0 / self.sampleRate
self.tPosition += length * tStepMsec
if self.tPosition >= self.tScale:
self.tPosition = 0.0
class QtRenderer(Renderer):
"""An implementation of :class:`~renderer.Renderer` for PyQt5.
This renderer will draw on any `QPaintDevice`
"""
def __init__(self, paint_device):
"""Creates a new renderer based on a QPaintDevice pd"""
self._grid_pen = QPen(QColor(0x808080))
self._grid_pen.setStyle(Qt.DashLine)
self._painter = None
Renderer.__init__(self, paint_device)
def set_canvas(self, canvas):
"""Tell the renderer to draw on canvas
The type of canvas is implementation-dependent"""
if self._painter is not None:
self._painter.restore()
self._painter.restore()
self._painter.end()
self._paintdevice = canvas
self._painter = QPainter(canvas)
self._painter.setRenderHint(QPainter.Antialiasing)
# invert the y axis
self._painter.scale(1,-1)
self._painter.translate(0,-canvas.height())
Renderer.set_canvas(self,canvas)
def _get_canvas_size(self,pd):
"""Get the canvas size tuple (width,height)"""
return (pd.width(), pd.height())
def push_state(self):
"""Store the current state on the stack.
Current state includes default pose, pen and brush"""
### FIXME store things
self._painter.save()
def pop_state(self):
"""Restore the last saved state from the stack
The state includes default pose, pen and brush"""
### FIXME store things
self._painter.restore()
def _calculate_bounds(self):
transform = self._painter.worldTransform().inverted()[0]
xs,ys = zip(
transform.map(0.0,0.0),
transform.map(0.0,float(self.size[1])),
transform.map(float(self.size[0]),float(self.size[1])),
transform.map(float(self.size[0]),0.0)
)
self._bounds = (min(xs), min(ys), max(xs), max(ys))
def _draw_grid(self):
self.reset_pose()
self._painter.setPen(self._grid_pen)
xmin, ymin, xmax, ymax = self._bounds
# Determine min/max x & y line indices:
x_ticks = (int(xmin//self._grid_spacing), int(xmax//self._grid_spacing + 1))
y_ticks = (int(ymin//self._grid_spacing), int(ymax//self._grid_spacing + 1))
self._painter.drawLines(
[QLineF(xmin, i * self._grid_spacing,
xmax, i * self._grid_spacing)
for i in range(*y_ticks)])
self._painter.drawLines(
[QLineF(i * self._grid_spacing, ymin,
i * self._grid_spacing, ymax)
for i in range(*x_ticks)])
def scale(self, factor):
"""Scale drawing operations by factor
To be implemented in subclasses."""
self._painter.scale(factor,factor)
def rotate(self, angle):
"""Rotate canvas by angle (in radians)
To be implemented in subclasses."""
self._painter.rotate(degrees(angle))
def translate(self, dx, dy):
"""Translate canvas by dx, dy
To be implemented in subclasses."""
self._painter.translate(dx,dy)
def clear_screen(self):
"""Erases the current screen with a white brush"""
self._painter.save()
self._painter.resetTransform()
self.set_pen(0xFFFFFF)
self.set_brush(0xFFFFFF)
self.draw_rectangle(0,0,self.size[0],self.size[1])
self._painter.restore()
Renderer.clear_screen(self)
@staticmethod
def __qcolor(color):
"""Returns qcolor for a given ARGB color"""
c = QColor(color)
if color > 0xFFFFFF:
c.setAlpha((color >> 24) & 0xFF)
return c
def set_pen(self,color=0, thickness=0):
"""Sets the line color and thickness.
Color is interpreted as 0xAARRGGBB."""
if color is None:
self._painter.setPen(Qt.NoPen)
else:
self._painter.setPen(QPen(self.__qcolor(color),thickness))
def set_brush(self,color):
"""Sets the fill color.
Color is interpreted as 0xAARRGGBB."""
if color is None:
self._painter.setBrush(Qt.NoBrush)
else:
self._painter.setBrush(self.__qcolor(color))
def draw_polygon(self,points):
"""Draws a polygon.
Expects a list of points as a list of tuples or as a numpy array."""
self._painter.drawPolygon(QPolygonF([QPointF(*point[:2]) for point in points]))
def draw_ellipse(self, cx, cy, ra, rb = None):
"""Draws an ellipse."""
if rb is None:
rb = ra
self._painter.drawEllipse(QRectF(cx-ra,cy-ra,2*ra,2*rb))
def draw_rectangle(self, x, y, w, h):
"""Draws a rectangle."""
self._painter.drawRect(QRectF(x,y,w,h))
def draw_text(self, text, x, y, bgcolor = 0):
"""Draws a text string at the defined position."""
pass
def draw_line(self, x1, y1, x2, y2):
"""Draws a line using the current pen from (x1,y1) to (x2,y2)"""
self._painter.drawLine(QLineF(x1,y1,x2,y2))
def draw_point(self,x,y):
"""Draw a single point using the current pen at (x,y)"""
self._painter.drawPoint(QPointF(x,y))
def draw_points(self,points):
"""Draw a set of points, given as [(x,y)], using the current pen"""
self._painter.drawPoints(QPolygonF([QPointF(x,y) for x,y in points]))
class AniState:
"""Wrapper class around QPainter to ease its usage."""
def __init__(self, widget, frame, time, dt, center=False):
self._painter = QPainter(widget)
self._painter.setRenderHint(QPainter.Antialiasing, True)
if center:
self._painter.translate(widget.width() / 2, widget.height() / 2)
self.width = widget.width()
self.height = widget.height()
self.frame = frame
self.time = time
self.dt = dt
def color(self, value):
"""
Sets the border color. The input value might be ``None`` to use
no border, a tuple consisting of (r, g, b, [a]), a string or an
integer representing the color, or a QColor/QPen itself.
"""
width = self._painter.pen().widthF()
if value is None:
self._painter.setPen(Qt.NoPen)
elif isinstance(value, tuple):
self._painter.setPen(QPen(QColor(*value), width))
elif isinstance(value, (str, int)):
self._painter.setPen(QPen(QColor(value), width))
elif isinstance(value, QColor):
self._painter.setPen(QPen(value, width))
elif isinstance(value, QPen):
self._painter.setPen(value)
return self
def fill(self, value):
"""
Sets the fill color. The input value might be ``None`` to use
no fill, a tuple consisting of (r, g, b, [a]), a string or an
integer representing the color, or a QColor/QBrush itself.
"""
if value is None:
self._painter.setBrush(Qt.NoBrush)
elif isinstance(value, tuple):
self._painter.setBrush(QBrush(QColor(*value)))
elif isinstance(value, (str, int)):
self._painter.setBrush(QBrush(QColor(value)))
elif isinstance(value, QColor):
self._painter.setBrush(QBrush(value))
elif isinstance(value, QBrush):
self._painter.setBrush(value)
return self
def size(self, size):
"""
Sets the size for lines and points.
"""
pen = self._painter.pen()
pen.setWidthF(size)
self._painter.setPen(pen)
return self
def line(self, x1, y1, x2=None, y2=None):
"""
Draws a line between the input positions.
If list/tuples are given as the first two arguments, they should
consist of two elements representing elements in a position vector.
"""
if isinstance(x1, (tuple, list)):
x2 = y1
x1, y1 = x1
if isinstance(x2, (tuple, list)):
x2, y2 = x2
self._painter.drawLine(x1, y1, x2, y2)
return self
def point(self, x, y=None):
"""
Draws a single point.
If a list/tuple is supplied as the first argument, it should
consist of two elements representing elements in a position vector.
"""
if isinstance(x, (tuple, list)):
x, y = x
self._painter.drawPoint(x, y)
return self
def points(self, values):
"""
Draws a series of points. If the first element of the list of
values is a list/tuple, then the following must be the same type.
"""
assert len(values) % 2 == 0
if isinstance(values[0], (tuple, list)):
self._painter.drawPoints(*[QPointF(x, y) for x, y, in values])
else:
self._painter.drawPoints(*[QPointF(values[i], values[i + 1])
for i in range(0, len(values), 2)])
def lines(self, values, closed=False):
"""
Draws a series of connected lines. If the first element of the list
of values is a list/tuple, then the following must be the same type.
If ``closed``, the first point will be connected to the last.
"""
assert len(values) > 4 and len(values) % 2 == 0
if isinstance(values[0], (tuple, list)):
self._painter.drawLines(*[
QLineF(
values[i - 1][0], values[i - 1][1],
values[i][0], values[i][0]
)
for i in range(0 if closed else 1, len(values))
])
else:
self._painter.drawLines(*[
QLineF(
values[i - 2], values[i - 1],
values[i], values[i + 1]
)
for i in range(0 if closed else 2, len(values), 2)
])
return self
def box(self, x, y, width, height):
"""Draws a box at the given position with the given size."""
self._painter.drawRect(x, y, width, height)
def rect(self, x1, y1, x2, y2):
"""Wrapper around anistate.box(x1, y1, x2 - x1, y2 - y1)."""
if x2 < x1:
x1, x2 = x2, x1
if y2 < y1:
y1, y2 = y2, y1
self._painter.drawRect(x1, y1, x2 - x1, y2 - y1)
def circle(self, x, y, radius):
"""Draws a centered circle at the given position and radius."""
self._painter.drawEllipse(QPointF(x, y), radius, radius)
def poly(self, values):
"""Draws a filled polygon with the shape of the input values."""
assert len(values) % 2 == 0
if isinstance(values[0], (tuple, list)):
self._painter.drawPolygon(*[QPointF(x, y) for x, y, in values])
else:
self._painter.drawPolygon(*[QPointF(values[i], values[i + 1])
for i in range(0, len(values), 2)])
return self
