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 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 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 __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 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 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 _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 step_12(flag: int, i: int, line: QLine, r1: QPoint, r2: QPoint,
cutter: Rect):
# внутри окна нет концов отрезков
i += 1
if i > 2:
return step_31(flag, r1, r2)
q = line.p1() if i == 1 else line.p2()
return step_15(flag, i, q, line, r1, r2, cutter)
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 __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 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 simple_cut(cutter: Rect, line: QLine):
t1, t2 = count_T(line.p1(), cutter), count_T(line.p2(), cutter)
flag = 1
r1, r2 = copy.deepcopy(line.p1()), copy.deepcopy(line.p2())
# отрезок полностью видимый
if t1 | t2 == 0:
return step_31(flag, r1, r2)
pl = t1 & t2
# отрезок лежит по одну из сторон окна (невидимый)- тривиальная невидимость
if pl != 0:
flag = -1
return step_31(flag)
# отрезок частично видимый
if t1 == 0:
r1 = copy.deepcopy(line.p1())
q = copy.deepcopy(line.p2())
i = 2
return step_15(flag, i, q, line, r1, r2, cutter)
if t2 == 0:
r1 = copy.deepcopy(line.p2())
q = copy.deepcopy(line.p1())
i = 2
return step_15(flag, i, q, line, r1, r2, cutter)
# внутри окна нет концов отрезка
i = 0
return step_12(flag, i, line, r1, r2, cutter)
class LineDrawCanvas(QWidget):
def __init__(self, parent=None):
super(LineDrawCanvas, self).__init__(parent)
self.setMinimumSize(200, 200)
self.linePen = QPen(Qt.SolidLine)
self.linePen.setColor(Qt.magenta)
self.linePen.setWidth(6)
self.drawingPen = QPen(Qt.DashLine)
self.drawingPen.setColor(Qt.cyan)
self.drawingPen.setWidth(3)
self.currentLine = None
self.lines = []
def reset(self):
self.lines = []
self.update()
def paintEvent(self, event):
qp = QPainter(self)
qp.setPen(QPen(Qt.black))
qp.setBrush(QBrush(Qt.white))
bounds = self.rect()
qp.drawRect(0, 0,
bounds.width() - 1,
bounds.height() - 1) # draw an outline around the graph
qp.setPen(self.linePen)
for line in self.lines:
qp.drawLine(line)
if self.currentLine != None:
qp.setPen(self.drawingPen)
qp.drawLine(self.currentLine)
def mousePressEvent(self, event):
self.currentLine = QLine(event.pos(), event.pos()) # start a new line
def mouseMoveEvent(self, event):
if self.currentLine != None:
self.currentLine.setP2(
event.pos()) # update the second point of the line
self.update() # redraw the widget to show the updated line
def mouseReleaseEvent(self, event):
if self.currentLine != None:
# Turn the currentLine into a permanent line
self.lines.append(self.currentLine)
self.currentLine = None
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)
class MainWindow(QMainWindow):
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 draw(self):
button = self.sender()
self.line = QLine(QPoint(), button.pos())
self.update()
def paintEvent(self, event):
QMainWindow.paintEvent(self, event)
if not self.line.isNull():
painter = QPainter(self)
pen = QPen(Qt.yellow, 3)
painter.setPen(pen)
painter.setBrush(QBrush(Qt.yellow, Qt.SolidPattern))
x, y = randint(0, 400), randint(0, 400)
painter.drawEllipse(x, x, y, y)
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 __init__(self, parent=None):
super(Dialog, self).__init__(parent)
self.isFinished = False
self.isDragging = False
self.line = QLine()
self.roiRect = QRect()
self.initialize()
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 _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 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 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 paint(self, painter: QPainter, option, widget=None):
rect = getRect(widget)
delta = QPoint(5, 0)
self.line = QLine(rect.bottomRight() + delta * 2,
rect.topRight() + delta * 2)
point = self.getPoint()
painter.setPen(QPen(Qt.black, 0))
painter.setBrush(Qt.black)
offset_h = QPointF(10, 0)
offset_v = QPointF(0, 10)
points = QPolygonF((
QPointF(point),
QPointF(point + offset_h - offset_v),
QPointF(point + offset_h + offset_v),
QPointF(point)
))
painter.drawPolygon(points, 4)
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()
class NGL_Line(NGL_Base):
"""
NGL_Line(NGL_Base)
Provides a embedded NGL library line widget.
"""
# Signal used to indicate changes to the status of the widget.
valueChanged = pyqtSignal(QLine)
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 paintEvent(self, event):
""" Paint ngl widget event """
p = QPainter()
p.begin(self)
p.drawLine(self._line)
p.end()
def sizeHint(self):
""" Return Qt sizeHint """
return self._size()
def _size(self):
width = abs(self._line.x2() - self._line.x1()) + 1
height = abs(self._line.y2() - self._line.y1()) + 1
return QSize(width, height)
def update(self):
self._size_update()
super(NGL_Line, self).update()
def _size_update(self):
""" Size update for widget """
w = self._size().width()
h = self._size().height()
self.setMinimumSize(w, h)
self.setMaximumSize(w, h)
# # Provide getter and setter methods for the property.
@pyqtProperty(QPoint)
def P1(self):
return self._line.p1()
@P1.setter
def P1(self, point):
self._line.setP1(point)
self.update()
# Provide getter and setter methods for the property.
@pyqtProperty(QPoint)
def P2(self):
return self._line.p2()
@P2.setter
def P2(self, point):
self._line.setP2(point)
self.update()
def doNGLCode(self, **kwargs):
template = 'NGL_GP_DrawLine({x0}, {y0}, {x1}, {y1}, {color});'
# convert coordinates
g = self._ngl_geometry()
y1 = self._ngl_y(self.P1.y(), g.height() - 1)
y2 = self._ngl_y(self.P2.y(), g.height() - 1)
return template.format(
x0 = g.x(),
y0 = g.y() + y1,
x1 = g.x() + g.width() - 1,
y1 = g.y() + y2,
color = self._ngl_color('color: rgb'))
