def drawHangmanBody(self, painter):
"""
Create and draw body parts for hangman.
"""
if "head" in self.empty_list:
head = QRect((self.width / 2) + 42, 40, 40, 40)
painter.setPen(QPen(QColor("#000000"), 3))
painter.setBrush(QBrush(QColor("#FFFFFF")))
painter.drawEllipse(head)
if "body" in self.empty_list:
body = QRect((self.width / 2) + 60, 80, 2, 55)
painter.setBrush(QBrush(QColor("#000000")))
painter.drawRect(body)
if "right_arm" in self.empty_list:
right_arm = QLine((self.width / 2) + 60, 85, (self.width / 2) + 50,
(self.height / 2) + 30)
pen = QPen(Qt.black, 3, Qt.SolidLine)
painter.setPen(pen)
painter.drawLine(right_arm)
if "left_arm" in self.empty_list:
left_arm = QLine((self.width / 2) + 62, 85, (self.width / 2) + 72,
(self.height / 2) + 30)
painter.drawLine(left_arm)
if "right_leg" in self.empty_list:
right_leg = QLine((self.width / 2) + 60, 135,
(self.width / 2) + 50, (self.height / 2) + 75)
painter.drawLine(right_leg)
if "left_leg" in self.empty_list:
left_leg = QLine((self.width / 2) + 62, 135, (self.width / 2) + 72,
(self.height / 2) + 75)
painter.drawLine(left_leg)
# Reset variable
self.incorrect_letter = False
def drawBackground(self, painter, rect):
super().drawBackground(painter, rect)
# here we create our grid
left = int(math.floor(rect.left()))
right = int(math.ceil(rect.right()))
top = int(math.floor(rect.top()))
bottom = int(math.ceil(rect.bottom()))
first_left = left - (left % self.gridSize)
first_top = top - (top % self.gridSize)
# compute all lines to be drawn
lines_light, lines_dark = [], []
for x in range(first_left, right, self.gridSize):
if (x % (self.gridSize * self.gridSquares) != 0):
lines_light.append(QLine(x, top, x, bottom))
else:
lines_dark.append(QLine(x, top, x, bottom))
for y in range(first_top, bottom, self.gridSize):
if (y % (self.gridSize * self.gridSquares) != 0):
lines_light.append(QLine(left, y, right, y))
else:
lines_dark.append(QLine(left, y, right, y))
# draw the lines
painter.setPen(self._pen_light)
painter.drawLines(*lines_light)
painter.setPen(self._pen_dark)
painter.drawLines(*lines_dark)
def paint(self, painter, option, widget):
painter.setPen( QPen(Qt.green, 1, Qt.SolidLine, Qt.RoundCap, Qt.RoundJoin) )
painter.drawLine( QLine( QPoint(0,0), QPoint(0,100) ) )
#painter.drawLine( QLineF( QPointF(100,0), QPointF(100,100) ) )
painter.setPen( QPen(Qt.red, 1, Qt.SolidLine, Qt.RoundCap, Qt.RoundJoin) )
painter.drawLine( QLine( QPoint(0,0), QPoint(100,0) ) )
def _paintEvent(self, painter):
if not self._lEnabled:
return
pen = QPen(self.lineColor)
pen.setWidth(self.borderWidth)
painter.setPen(pen)
cx, setp = self.width() / 2, self.width() / self._lSp
if self.hasFocus():
if self._lInDraw:
painter.drawLines(
QLine(cx, self.height(), cx + setp * self._lSetp,
self.height()),
QLine(cx, self.height(), cx - setp * self._lSetp,
self.height()),
)
else:
painter.drawLine(0, self.height(), self.width(), self.height())
else:
if self._lOutDraw:
painter.drawLines(
QLine(cx + setp * (self._lSp - self._lSetp), self.height(),
cx, self.height()),
QLine(cx - setp * (self._lSp - self._lSetp), self.height(),
cx, self.height()),
)
def updateConnector(self, pos):
if self.text == "P":
self.line = QLine(pos.x() + 20, pos.y() - 10, pos.x() + 20, pos.y())
self.setRect(pos.x() + 10, pos.y() - 30, 20, 20)
else:
self.line = QLine(pos.x() + 20, pos.y() + 40, pos.x() + 20, pos.y() + 50)
self.setRect(pos.x() + 10, pos.y() + 50, 20, 20)
def drawBackground(self, painter, rect):
super().drawBackground(painter, rect)
left = int(math.floor(rect.left()))
right = int(math.ceil(rect.right()))
top = int(math.floor(rect.top()))
bottom = int(math.ceil(rect.bottom()))
first_left = left - (left % self.grid_size)
first_top = top - (top % self.grid_size)
lines_light, lines_dark = [], []
for x in range(first_left, right, self.grid_size):
if x % (self.grid_size * self.grid_squares) != 0:
lines_light.append(QLine(x, top, x, bottom))
else:
lines_dark.append(QLine(x, top, x, bottom))
for y in range(first_top, bottom, self.grid_size):
if y % (self.grid_size * self.grid_squares) != 0:
lines_light.append(QLine(left, y, right, y))
else:
lines_dark.append(QLine(left, y, right, y))
# draw the lines
painter.setPen(self._pen_light)
if lines_light:
painter.drawLines(*lines_light)
painter.setPen(self._pen_dark)
if lines_dark:
painter.drawLines(*lines_dark)
def drawBackground(self, painter, rect):
super().drawBackground(painter, rect)
# draw grid
# > compute all lines to be drawn
lines_light, lines_dark = [], []
left = int(math.floor(rect.left()))
right = int(math.ceil(rect.right()))
top = int(math.floor(rect.top()))
bottom = int(math.ceil(rect.bottom()))
first_left = left - left % self._grid_size
first_top = top - top % self._grid_size
for x in range(first_left, right, self._grid_size):
if x % self._grid_squares == 0:
lines_dark.append(QLine(x, top, x, bottom))
else:
lines_light.append(QLine(x, top, x, bottom))
for y in range(first_top, bottom, self._grid_size):
if y % self._grid_squares == 0:
lines_dark.append(QLine(left, y, right, y))
else:
lines_light.append(QLine(left, y, right, y))
# > use pen to draw lines
painter.setPen(self._grid_pen)
painter.drawLines(*lines_light)
painter.setPen(self._grid_pen_dark)
painter.drawLines(*lines_dark)
def paintEvent(self, ev):
pixmap = QPixmap()
pixmap.convertFromImage(self.plot_background)
self.painter.begin(pixmap)
self.painter.setPen(self.ytick_pen)
temp = self.scale_y(
np.array(
list(self.buf[self.buffer_current_index:]) +
list(self.buf[:self.buffer_current_index])))
for yt in self.yticks:
self.painter.drawLine(
QLine(0, self.scale_y(yt), self.buffer_length * self.xscale,
self.scale_y(yt)))
self.painter.setPen(self.hline_pen)
for hline in self.hlines:
self.painter.drawLine(
QLine(0, self.scale_y(hline), self.buffer_length * self.xscale,
self.scale_y(hline)))
self.painter.setPen(self.pen)
for idx in range(self.buffer_length - 1):
x1 = (idx) * self.xscale
x2 = (idx + 1) * self.xscale
y1 = temp[idx]
y2 = temp[idx + 1]
self.painter.drawLine(QLine(x1, y1, x2, y2))
interval = self.buffer_length // 10
interval = ccfg.plot_xtick_interval
if idx % interval == 0:
self.painter.setPen(self.xtick_pen)
self.painter.drawLine(
QLine((x1 - self.buffer_current_index * self.xscale) %
(self.buffer_length * self.xscale), self.xtick0,
(x1 - self.buffer_current_index * self.xscale) %
(self.buffer_length * self.xscale), self.xtick1))
self.painter.setPen(self.pen)
#if True:#20<self.buffer_current_index<80:
# painter.drawEllipse(x1,y1,x2,y2)
self.painter.end()
self.plot.setPixmap(pixmap)
def __init__(self):
super(bullsEye, self).__init__()
global imageWidth
global imageHeight
global BEx
global BEy
global BEd
global lineColorR
global lineColorG
global lineColorB
global lineWidth
self.line1 = QLine(BEx, BEy - BEd / 2, BEx, BEy + BEd / 2)
self.line2 = QLine(BEx - BEd / 2, BEy, BEx + BEd / 2, BEy)
def paint(self, painter, option, widget):
pen = QPen(Qt.SolidLine)
pen.setColor(QColor(lineColorR, lineColorG, lineColorB))
pen.setWidth(lineWidth)
painter.setPen(pen)
for i in range(1, 1 + lineCount):
painter.drawLine(
QLine(int(i * imageWidth / (lineCount + 1)), 0,
int(i * imageWidth / (lineCount + 1)), imageHeight))
painter.drawLine(
QLine(0, int(i * imageHeight / (lineCount + 1)), imageWidth,
int(i * imageHeight / (lineCount + 1))))
self.update()
def draw_line(self):
self.line = QLine(self.width() / 1.7,
self.height() / 1.25,
self.width() / 6.26,
self.height() / 4.5)
self.line2 = QLine(self.width() / 1.7,
self.height() / 4.5,
self.width() / 6.26,
self.height() / 1.25)
# self.line = QLine(QPoint(self.width() / 1.7, self.height() / 1.25),
# QPoint(self.width() / 6.26, self.height() / 4.5))
# self.line2 = QLine(QPoint(self.width() / 1.7, self.height() / 4.5),
# QPoint(self.width() / 6.26, self.height() / 1.25))
self.update()
def __init__(self, inherit, pos):
self.text = ""
self.line = None
self.connectedEnds = []
self.selected = True
QRect.__init__(self)
if inherit == "parent":
self.text = "P"
self.line = QLine(pos.x() + 20, pos.y() - 10, pos.x() + 20, pos.y())
self.setRect(pos.x() + 10, pos.y() - 30, 20, 20)
else:
self.text = "C"
self.line = QLine(pos.x() + 20, pos.y() + 40, pos.x() + 20, pos.y() + 50)
self.setRect(pos.x() + 10, pos.y() + 50, 20, 20)
def mouseMoveEvent(self, event):
# MAKESHIFT code that "fixes" the coder issue.
if (event.buttons() & Qt.LeftButton) & self.drawing:
self.line = QLine(self.lastPoint, event.pos())
painterTemp = QPainter(self.imageAbove)
painterTemp.setPen(QPen(self.brushColor, self.brushSize, Qt.SolidLine, Qt.RoundCap, Qt.RoundJoin))
if (self.strokeCount == 0):
painterTemp.setCompositionMode(QPainter.CompositionMode_SourceOver)
painterTemp.drawLine(self.line)
self.strokeCount = 1
else:
self.painterSim.setPen(QPen(self.brushColor, self.brushSize, Qt.SolidLine, Qt.RoundCap, Qt.RoundJoin))
self.painterSim.setCompositionMode(QPainter.CompositionMode_SourceOver)
self.painterSim.drawLine(self.line)
self.painterSim.setPen(QPen(Qt.transparent, self.brushSize, Qt.SolidLine, Qt.RoundCap, Qt.RoundJoin))
self.painterSim.setCompositionMode(QPainter.CompositionMode_Source)
self.painterSim.drawPoint(event.pos())
self.brushColor = Qt.transparent
self.painter.setCompositionMode(QPainter.CompositionMode_SourceOver)
painterTemp.end()
empty = QPoint(0,0)
self.painter.drawImage(empty, self.imageTemp)
self.imageTemp.fill(Qt.transparent)
self.lastPoint = event.pos()
self.update()
def __init__(self, parent=None):
""" Constructor for ngl widget """
super(NGL_Line, self).__init__(parent)
self._line = QLine(0, 0, 150, 150)
self._static = True
self.update()
def __init__(self, mwindow):
self.mwindow = mwindow
self.ctrl_flag = True
self.state = 0
self.label = ""
self.lbl_pos = None
self.current_conn = None
self.lines = {}
self.move_line = QLine()
QFrame.__init__(self)
self.setObjectName("treeF")
self.setMouseTracking(True)
self.menu = QMenu(self)
clearA = QAction('Clear Connectors', self)
clearA.triggered.connect(self.removeAll)
self.menu.addAction(clearA)
clearallA = QAction('Clear Frame', self)
clearallA.triggered.connect(self.clearAll)
self.menu.addAction(clearallA)
self.show()
def draw(self,pixmap,downsample=1,active=None):
if active is None:
active=self.active
d = float(downsample)
if not self.visible:
return
if self.mode=='lines':
painter = QPainter()
painter.begin(pixmap)
painter.setPen(self.pen)
for index,(x1,x2,y1,y2) in enumerate(self.coords):
if active[index]:
painter.drawLine(QLine(x1/d,y1/d,x2/d,y2/d))
painter.end()
elif self.mode=='rects':
painter = QPainter()
painter.begin(pixmap)
painter.setPen(self.pen)
for index,(x1,x2,y1,y2) in enumerate(self.coords):
if not active[index]:
painter.setPen(self.err_pen)
else:
painter.setPen(self.pen)
width = x2-x1
height = y2-y1
painter.drawRect(x1/d,y1/d,width/d,height/d)
painter.end()
def __init__(self, parent=None):
super(Dialog, self).__init__(parent)
self.isFinished = False
self.isDragging = False
self.line = QLine()
self.roiRect = QRect()
self.initialize()
def _arrange_data(self):
self.rect = QRect()
for i in range(len(self.pattern.coordinates)):
coordinates = self.pattern.coordinates[i]
color_item = self.colorModel.item(i)
lines = []
xb, yb = [], []
mx, my = 0, 0
for op, x, y in coordinates:
xb.append(x)
yb.append(y)
if op == "move":
mx, my = x, y
elif op == "stitch":
line = QLine(mx, -my, x, -y)
lines.append(line)
mx, my = x, y
xb = [min(xb), max(xb)]
yb = [min(yb), max(yb)]
rect = QRect(min(xb), -max(yb),
max(xb) - min(xb),
max(yb) - min(yb))
self.rect = self.rect.united(rect)
zone = Zone(rect, color_item)
zone.lines = lines
self._partition_data(zone)
self.zones.append(zone)
def mousePressEvent(self, event):
global index
global flag
global flag_del
global l_pontos
if len(Dados["imagens"][clean_f_list[index]]["pontos"]) < 1:
flag = True
self.x0 = event.x()
self.y0 = event.y()
l_pontos.append((self.x0, self.y0))
if len(l_pontos) == 3:
l_pontos.sort()
l_pontos[1], l_pontos[2] = l_pontos[2], l_pontos[1]
Dados["imagens"][clean_f_list[index]]["pontos"].append(
l_pontos.copy())
l_pontos.clear()
line1 = QLine(self.x0 - 5, self.y0 - 5, self.x0 + 5, self.y0 + 5)
line2 = QLine(self.x0 + 5, self.y0 - 5, self.x0 - 5, self.y0 + 5)
lines.append((line1, line2))
self.update()
if flag_del:
flag = True
l_pontos = Dados["imagens"][
clean_f_list[index]]["pontos"][0].copy()
self.x0 = event.x()
self.y0 = event.y()
l_pontos.append((self.x0, self.y0))
for i in l_pontos:
x, y = i
line1 = QLine(x - 5, y - 5, x + 5, y + 5)
line2 = QLine(x + 5, y - 5, x - 5, y + 5)
lines.append((line1, line2))
if len(l_pontos) == 3:
l_pontos.sort()
l_pontos[1], l_pontos[2] = l_pontos[2], l_pontos[1]
Dados["imagens"][
clean_f_list[index]]["pontos"][0] = l_pontos.copy()
l_pontos.clear()
self.update()
flag_del = False
def draw_vertical(self):
height = self.height()
p1 = QPoint(self.margin, self.margin)
p2 = QPoint(self.margin, height - self.margin)
axis_line = QLine(p1, p2)
self.painter.save()
self.painter.setPen(self.axis_pen)
self.painter.drawLine(axis_line)
self.painter.restore()
def paintEvent(self,event):
painter = QPainter()
painter.begin(self)
painter.setRenderHint(QPainter.Antialiasing)
for case in switch(self.selected_option):
if case('Direction'):
painter.setPen(QPen(QBrush(Qt.red), 1, Qt.DashLine))
painter.drawLine(QLine(self.pos_start,self.pos_end))
break
if case('Forbidden'):
painter.setPen(QPen(QBrush(Qt.green), 1, Qt.DashLine))
painter.drawRect(self.roiRect)
break
if case('RedLine'):
painter.setPen(QPen(QBrush(Qt.yellow), 1, Qt.DashLine))
painter.drawLine(QLine(self.pos_start,self.pos_end))
break
painter.end()
def draw_needle(self, qp, event, w):
w *= 0.6
center = event.rect().center()
angle = ((self.value * 270.0) / self._max_value) - 225
rad = w / 2
x = int(rad * math.cos(math.radians(angle)) + center.x())
y = int(rad * math.sin(math.radians(angle)) + center.y())
line = QLine(center.x(), center.y(), x, y)
qp.setPen(QPen(Qt.red, 4))
qp.drawLine(line)
def draw_horizon(self):
width = self.width()
height = self.height()
p1 = QPoint(self.margin, height - self.margin)
p2 = QPoint(width - self.margin, height - self.margin)
axis_line = QLine(p1, p2)
self.painter.save()
self.painter.setPen(self.axis_pen)
self.painter.drawLine(axis_line)
self.painter.restore()
def __init__(self):
QMainWindow.__init__(self)
self.setMinimumSize(QSize(300, 300))
self.setMouseTracking(True)
pybutton = QPushButton('button', self)
pybutton.clicked.connect(self.draw_line)
pybutton.resize(100, 100)
pybutton.move(100, 100)
self.line = QLine()
def horizontal_toothpick(self, x, y):
end1 = (x - self.TOOTHPICK_HALFLENGTH, y)
end2 = (x + self.TOOTHPICK_HALFLENGTH, y)
self.lines.append(QLine(*end1, *end2))
for end in [end1, end2]:
if end not in self.points:
self.free_ends[end] = False
self.points.add(end)
elif end in self.free_ends:
del self.free_ends[end]
def vertical_toothpick(self, x, y):
end1 = (x, y - self.TOOTHPICK_HALFLENGTH)
end2 = (x, y + self.TOOTHPICK_HALFLENGTH)
self.lines.append(QLine(*end1, *end2))
for end in [end1, end2]:
if end not in self.points:
self.free_ends[end] = True
self.points.add(end)
elif end in self.free_ends:
del self.free_ends[end]
def create_arrow(
self,
end_pos: Tuple[int, int]
or List[int, int] = None) -> Tuple[QLine, QLine]:
"""
creates arrow's lines and returns them in QLine format
:param end_pos: position of line's top
:return: two QLine in tuple
"""
if self.start_pos:
start = self.start_pos
end = self.end_pos or end_pos
else:
start, end = self.get_start_and_end(end_pos or self.end_pos)
ul = arctan2(-(start[0] - end[0]), -(start[1] - end[1]))
s1 = int(end[0] + 20 * math.sin(ul - 40)), int(end[1] +
20 * math.cos(ul - 40))
s2 = int(end[0] + 20 * math.sin(ul + 40)), int(end[1] +
20 * math.cos(ul + 40))
return QLine(*s1, *end), QLine(*s2, *end)
def draw(self, qp: QPainter, end_pos: tuple or list = None) -> bool:
"""
draws line in core object
:param qp: QPainter of main UI object (core)
:param end_pos: position of mouse if arrow on mouse
if arrow has end position, end_pos param will be ignored
"""
if self.end_pos:
qp.drawLine(QLine(*self.start_pos, *self.end_pos))
if self.need_arrow:
ar1, ar2 = self.create_arrow(end_pos=self.end_pos)
qp.drawLines(ar1, ar2)
return False
elif end_pos:
start, end = self.get_start_and_end(end_pos)
qp.drawLine(QLine(*start, *end))
if self.need_arrow:
ar1, ar2 = self.create_arrow(end_pos=end_pos)
qp.drawLines(ar1, ar2)
return True
def __init__(self):
QMainWindow.__init__(self)
self.setMinimumSize(QSize(1000, 500))
self.setWindowTitle("Yellow Circle")
button = QPushButton('Draw', self)
button.clicked.connect(self.draw)
button.resize(100, 50)
button.move(450, 400)
self.line = QLine()
def paint(cursor):
y3 = self._neditor.cursorRect(cursor).top()
y4 = self._neditor.cursorRect(cursor).bottom()
user_data = cursor.block().userData()
if user_data is not None:
for x in range(self._indentation_width,
user_data.indentation,
self._indentation_width):
width = self._neditor.fontMetrics().width('i' * x) + offset
if width > 0:
painter.drawLine(QLine(width, y3, width, y4))
