def setup_gui(self):
filename = os.path.join(os.path.dirname(__file__),
'uniformlist_plugin.ui')
data = QtCore.QByteArray(open(filename, 'rb').read())
buffer = QtCore.QBuffer(data)
self.window = QtUiTools.QUiLoader().load(buffer)
self.window.resize(350, 32 + self.size * 20)
self.sliders = [None] * self.size
self.labels = [None] * self.size
top_layout = self.window.findChild(QtCore.QObject, 'gridLayout')
for i in range(16):
layout = self.window.findChild(QtCore.QObject,
f"horizontalLayout_{i + 1}")
if self.size <= i:
for j in range(layout.count()):
widget = layout.itemAt(j).widget()
if widget:
widget.close()
top_layout.removeItem(layout)
continue
slider = self.window.findChild(QtCore.QObject, f"slider_{i + 1}")
label = self.window.findChild(QtCore.QObject, f"value_{i + 1}")
resolution = self.config['resolution'][i]
slider.setRange(self.config['min'][i] * resolution,
self.config['max'][i] * resolution)
self.sliders[i] = slider
self.labels[i] = label
# Quick trick to workaround python namespace by "double-lambda"
slider.valueChanged.connect((lambda i: (lambda *_: self.labels[
i].setText(f"{self.get_value(i): >4.2f}")))(i))
slider.setValue(self.config['default'][i] * resolution)
# Quick trick to prevent this window from appearing before the main window
QtCore.QTimer.singleShot(500, lambda *_: self.window.show())
def __init__(self, combo, fps=15, audio_phonems=None):
self.combo = combo
# audio
if combo is not None or audio_phonems is not None:
if audio_phonems is None:
audio_phonems = combo.get_audio_phonems()
rate, wave = concat_segments(audio_phonems)
self.audio_format = get_format(rate, wave)
self.data = QtCore.QByteArray(wave.tobytes(order="C"))
self.audio_input = QtCore.QBuffer(self.data)
else:
self.audio_format = None
self.data = None
self.audio_input = None
self.timer = None
self.audio_output = None
self.fps = fps
self.t = 0
self.period_ms = 1.0 / fps
if audio_phonems is None:
self.frames = get_loading_frames(fps)
else:
self.frames = self.get_video_extract(audio_phonems)
def add_marker_from_svg(file_path,
marker_name,
pixel_x=10,
pixel_y=None,
isLSBFirst=False,
isUpToDown=False):
"""adds a new marker bitmap from a vector graphic (svg)"""
# get an icon from the svg rendered with the given pixel
from PySide2 import QtCore, QtGui
pixel_y = pixel_y or pixel_x
icon = QtGui.QIcon(file_path)
icon = QtGui.QBitmap(icon.pixmap(pixel_x, pixel_y))
# create a XMP-icon
buffer = QtCore.QBuffer()
buffer.open(buffer.WriteOnly)
icon.save(buffer, "XPM")
buffer.close()
# get a string from the XMP-icon
ary = str(buffer.buffer(), "utf8")
ary = ary.split("\n", 1)[1]
ary = ary.replace('\n', "").replace('"', "").replace(";", "")
ary = ary.replace("}", "").replace("#", "x").replace(".", " ")
string = str.join("", ary.split(",")[3:])
# add the new marker style
setattr(coin.SoMarkerSet, marker_name,
coin.SoMarkerSet.getNumDefinedMarkers())
coin.SoMarkerSet.addMarker(getattr(coin.SoMarkerSet, marker_name),
coin.SbVec2s([pixel_x, pixel_y]), string,
isLSBFirst, isUpToDown)
def CadEmpresa(self):
INSERI = CrudEmpresa()
INSERI.idEmpresa = self.tx_idEmpresa.text()
INSERI.NomeFantasia = self.tx_NomeFantasia.text().upper()
INSERI.RazaoSocial = self.tx_RazaoSocial.text().upper()
INSERI.cnpj = self.tx_Cnpj.text()
INSERI.inscEstadual = self.tx_IE.text()
INSERI.telefone = re.sub('[^[0-9]', '',
(self.tx_TelefoneEmpresa.text()))
INSERI.email = self.tx_EmailEmpresa.text()
INSERI.site = self.tx_SiteEmpresa.text()
INSERI.obs = self.tx_ObsEmpresa.text().upper()
INSERI.cep = re.sub('[^[0-9]', '', (self.tx_CepEmpresa.text()))
INSERI.endereco = self.tx_Endereco.text().upper()
INSERI.numero = self.tx_NumEmpresa.text()
INSERI.bairro = self.tx_BairroEmpresa.text().upper()
INSERI.cidade = self.tx_CidadeEmpresa.text().upper()
INSERI.estado = self.tx_EstadoEmpresa.text().upper()
INSERI.titulo = self.tx_Titulo.text()
INSERI.subtitulo = self.tx_SubTitulo.text()
if self.lb_LogoEmpresa.pixmap():
image = QtGui.QPixmap(self.lb_LogoEmpresa.pixmap())
data = QtCore.QByteArray()
buf = QtCore.QBuffer(data)
image.save(buf, 'PNG')
INSERI.logo = str(data.toBase64(), encoding='utf8')
INSERI.CadEmpresa()
self.lb_NomeFantasia.setText(self.tx_Titulo.text())
self.lb_NomeFantasia2.setText(INSERI.subtitulo)
self.setWindowTitle(INSERI.titulo + " " + INSERI.subtitulo)
def toBase64(self):
self.__buffer = QtCore.QBuffer()
self.__buffer.open(QtCore.QBuffer.ReadWrite)
self.__render()
b64 = self.__buffer.data().toBase64().data()
return b64
def encode_pixmap(self, pixmap):
# byteArray + buffer 通过Base64将图片编码为二进制格式，MIMEDATA相关
pix_bytes = QtCore.QByteArray()
buffer = QtCore.QBuffer(pix_bytes)
# buffer使用需要打开和关闭
buffer.open(QtCore.QBuffer.WriteOnly)
pixmap.save(buffer, "PNG")
return pix_bytes.toBase64().data()
def pixmap_to_bytes(pixmap, save_type="PNG"):
bytarr = QtCore.QByteArray()
buf = QtCore.QBuffer(bytarr)
buf.open(QtCore.QIODevice.WriteOnly)
pixmap.save(buf, save_type)
return bytarr.data()
def save_copy(self):
fd = QtWidgets.QFileDialog()
fd.setDirectory(QtCore.QDir('~/'))
savefn = fd.getSaveFileName(self, 'Save File')[0]
pixmap = self.original_snap
barray = QtCore.QByteArray()
qbuffer = QtCore.QBuffer(barray)
qbuffer.open(QtCore.QIODevice.WriteOnly)
pixmap.save(qbuffer, "PNG")
bytesio = BytesIO(barray.data())
bytesio.seek(0)
with open(savefn, 'wb') as savefile:
savefile.write(bytesio.read())
def take_screenshot(self):
from PySide2 import QtCore as pyqt5c
from PySide2 import QtWidgets as pyqt5w
screen = pyqt5w.QApplication.primaryScreen()
pixmap = screen.grabWindow(self.groupBox.winId())
ba = pyqt5c.QByteArray()
buff = pyqt5c.QBuffer(ba)
pixmap = pixmap.scaled(500, 500, Qt.KeepAspectRatio,
Qt.SmoothTransformation)
pixmap.save('test1.tif', 'TIF')
return ba.data()
def _make_output(self, output_info, data, volume):
output = QtMultimedia.QAudioOutput(output_info,
output_info.preferredFormat())
output.setVolume(volume)
output.stateChanged.connect(lambda: self._delete_output(output))
buffer = QtCore.QBuffer()
buffer.open(QtCore.QIODevice.ReadWrite)
buffer.write(data)
buffer.seek(0)
output.start(buffer)
return output
def grabar(self):
regMarker = self.liEjemplos[0].bloqueDatos
name = regMarker.name.strip()
if name == "":
QTUtil2.message_error(self, _("Name missing"))
return
pm = self.liEjemplos[0].pixmapX()
bf = QtCore.QBuffer()
pm.save(bf, "PNG")
regMarker.png = bytes(bf.buffer())
self.regMarker = regMarker
self.accept()
def start_gui_updater(self):
if not self.loaded:
return
# Get Icon for FreeCAD.
icon = QtCore.QByteArray()
buf = QtCore.QBuffer(icon)
buf.open(QtCore.QIODevice.WriteOnly);
pixmap = QtGui.QPixmap(":/icons/freecad.svg")
pixmap.save(buf, "PNG")
self.updater.setApplicationName("FreeCAD")
self.updater.setIcon(icon)
self.updater.start(self.updater.getConstant("Action::UpdateWithGUI"))
def update_tooltip(self, gap=5):
nodes = [node() for node in self.children]
n_side = len(nodes)
if n_side > 3:
n_side = max(1, int(n_side**0.5))
x = 0
y = 0
h_max = 0
n = 0
x_max, y_max = 0, 0
positions = []
for node in nodes:
positions.append([x + gap, y + gap])
w, h = node._rect.width() + gap, node._rect.height() + gap
h_max = max(h_max, h)
x += w
n += 1
if n > n_side:
x = 0
y += h_max
h_max = 0
n = 0
x_max = max(x_max, x + w)
y_max = max(y_max, y + h)
if n_side == len(nodes):
x_max -= w
scale = SCALE_TOOLTIP / SCALE_DRAWINGS
buffer = QtCore.QBuffer()
buffer.open(QtCore.QIODevice.WriteOnly)
gen = QtSvg.QSvgGenerator()
gen.setOutputDevice(buffer)
painter = QtGui.QPainter(gen)
painter.scale(scale, scale)
painter.setPen(QtGui.QPen(QtCore.Qt.white, 0))
painter.setBrush(QtGui.QBrush(QtCore.Qt.white))
rect = QtCore.QRectF(0, 0, x_max, y_max)
painter.drawRect(rect)
painter.setPen(QtGui.QPen(QtCore.Qt.black, 0.5))
for i in range(len(nodes)):
x, y = positions[i]
painter.drawPicture(x, y, nodes[i].picture)
painter.drawText(rect, QtCore.Qt.AlignCenter | QtCore.Qt.AlignBottom,
self.label)
painter.end()
self.tool_tip = "<img src=\"data:image/png;base64,%s\">" % (bytes(
buffer.data().toBase64()).decode())
def fetch_icon(self):
""" Fetch the selected node's icon binary data
"""
node_type = self.asset.type()
node_def = node_type.definition()
qicon = hou.ui.createQtIcon(node_def.icon())
pix = qicon.pixmap(32, 32).toImage()
data = QtCore.QByteArray()
buffer = QtCore.QBuffer(data)
buffer.open(QtCore.QIODevice.WriteOnly)
pix.save(buffer, "PNG")
self.main_icon_section = "HELP_CARD_ICO_" + node_def.nodeTypeName(
) + ".png"
self.main_icon_data = str(buffer.data())
def setup_gui(self):
filename = os.path.join(os.path.dirname(__file__), 'uniform_plugin.ui')
data = QtCore.QByteArray(open(filename, 'rb').read())
buffer = QtCore.QBuffer(data)
self.window = QtUiTools.QUiLoader().load(buffer)
self.window.setWindowTitle(self.config['name'])
self.slider = self.window.findChild(QtCore.QObject, 'horizontalSlider')
self.label = self.window.findChild(QtCore.QObject, 'label')
self.slider.setRange(self.config['min'] * self.resolution,
self.config['max'] * self.resolution)
self.slider.valueChanged.connect(
lambda *_: self.label.setText(f"{self.get_value(): >4.2f}"))
# Quick trick to prevent this window from appearing before the main window
QtCore.QTimer.singleShot(500, lambda *_: self.window.show())
def dropEvent(self, event: QtGui.QDropEvent):
if (event.mimeData().hasUrls()):
cursor = None
working_path = None
for cur_path in event.mimeData().urls():
if (cur_path.isLocalFile()):
path = cur_path.path(options=QtCore.QUrl.FullyDecoded)
if (isinstance(pathlib.PurePath(), pathlib.PureWindowsPath)
and path.startswith("/")):
path = path[1:]
with open(path, "rb") as f:
try:
cursor = load_cursor(f)
working_path = path
except ValueError as e:
print(e)
else:
try:
req = urlopen(cur_path.url())
data = BytesIO(req.read())
data.seek(0)
cursor = load_cursor(data)
working_path = None
except (URLError, ValueError) as e:
print(e)
if (cursor is not None):
self.current_cursor = cursor
self._current_file = working_path
event.acceptProposedAction()
return
if (event.mimeData().hasImage()):
mem_img = BytesIO()
buffer = QtCore.QBuffer()
image = QtGui.QImage(event.mimeData().imageData())
image.save(buffer, "PNG")
mem_img.write(buffer)
mem_img.seek(0)
self.current_cursor = load_cursor(mem_img)
self._current_file = None
event.acceptProposedAction()
return
def qt_image_to_array(qimage: QtGui.QImage) -> np.ndarray:
"""
Convert qimage to numpy array
Code adapted from SO:
https://stackoverflow.com/a/1756587/7330813
"""
bio = io.BytesIO()
bfr = QtCore.QBuffer()
bfr.open(QtCore.QIODevice.ReadWrite)
qimage.save(bfr, 'PNG')
bytearr = bfr.data()
bio.write(bytearr.data())
bfr.close()
bio.seek(0)
img = Image.open(bio)
return np.array(img)
def captureParams(self):
params = self.getParams()
params["image-format"] = "PNG"
params["image-encoding"] = "hex"
screen = self.viewerWidget.grabFramebuffer()
barr = QtCore.QByteArray()
qbfr = QtCore.QBuffer(barr)
qbfr.open(QtCore.QIODevice.WriteOnly)
screen.save(qbfr, params["image-format"])
params["image"] = barr.data().hex()
fileName = QtWidgets.QFileDialog.getSaveFileName(
self.centralwidget, "Save Parameters", self.jsondir,
"Json Files (*.json)")
fpath = fileName[0]
if fpath:
with open(fpath, "w", encoding="utf-8", newline="\n") as fd:
json.dump(params, fd, ensure_ascii=False, indent=2)
def drawBaseImage(self, backgroundFile, titleText, titleFont, fontSize, alignment,\
xOffset, yOffset, textColor, visColor):
if backgroundFile == '':
im = Image.new("RGB", (1280, 720), "black")
else:
im = Image.open(backgroundFile)
if self._image == None or not self.lastBackgroundImage == backgroundFile:
self.lastBackgroundImage = backgroundFile
# resize if necessary
if not im.size == (1280, 720):
im = im.resize((1280, 720), Image.ANTIALIAS)
self._image = ImageQt(im)
self._image1 = QtGui.QImage(self._image)
painter = QPainter(self._image1)
font = titleFont
font.setPixelSize(fontSize)
painter.setFont(font)
painter.setPen(QColor(*textColor))
yPosition = yOffset
fm = QtGui.QFontMetrics(font)
if alignment == 0: #Left
xPosition = xOffset
if alignment == 1: #Middle
xPosition = xOffset - fm.width(titleText) / 2
if alignment == 2: #Right
xPosition = xOffset - fm.width(titleText)
painter.drawText(xPosition, yPosition, titleText)
painter.end()
buffer = QtCore.QBuffer()
buffer.open(QtCore.QIODevice.ReadWrite)
self._image1.save(buffer, "PNG")
strio = io.BytesIO()
strio.write(buffer.data())
buffer.close()
strio.seek(0)
return Image.open(strio)
def __init__(self, parent=None):
super(QGifWidget, self).__init__(parent)
self.setAlignment(QtCore.Qt.AlignCenter)
self.setSizePolicy(QtWidgets.QSizePolicy.Expanding,
QtWidgets.QSizePolicy.Expanding)
fileData = None
with open(GIF_PATH, "rb") as gifFile:
fileData = gifFile.read()
self.gifByteArray = QtCore.QByteArray(fileData)
self.gifBuffer = QtCore.QBuffer(self.gifByteArray)
self.movie = QtGui.QMovie()
self.movie.setFormat("GIF")
self.movie.setDevice(self.gifBuffer)
self.movie.setCacheMode(QtGui.QMovie.CacheAll)
self.movie.setSpeed(100)
self.setMovie(self.movie)
self.movie.jumpToFrame(0)
self.movie.start()
self.movie.setScaledSize(self.size())
def grabar(self):
regFlecha = self.liEjemplos[0].bloqueDatos
if self.siNombre:
name = regFlecha.name.strip()
if name == "":
QTUtil2.message_error(self, _("Name missing"))
return
bf = regFlecha
p = bf.physical_pos
p.x = 0
p.y = 16
p.ancho = 32
p.alto = 16
pm = BoardArrows.pixmapArrow(bf, 32, 32)
buf = QtCore.QBuffer()
pm.save(buf, "PNG")
regFlecha.png = bytes(buf.buffer())
self.regFlecha = regFlecha
self.accept()
def update_tooltip(self):
buffer = QtCore.QBuffer()
buffer.open(QtCore.QIODevice.WriteOnly)
scale = SCALE_TOOLTIP / SCALE_DRAWINGS
gen = QtSvg.QSvgGenerator()
gen.setOutputDevice(buffer)
painter = QtGui.QPainter(gen)
painter.scale(scale, scale)
rect = self._rect.marginsAdded(QtCore.QMargins(10, 10, 10, 10))
rect = QtCore.QRectF(rect.x(), rect.y(),
rect.width() * 0.8, rect.height())
painter.setPen(QtGui.QPen(QtCore.Qt.white, 0))
painter.setBrush(QtGui.QBrush(QtCore.Qt.white))
painter.drawRect(rect)
painter.setPen(QtGui.QPen(QtCore.Qt.black, 0.5))
painter.drawPicture(0, 0, self.picture)
painter.drawText(rect, QtCore.Qt.AlignCenter | QtCore.Qt.AlignBottom,
self.label)
painter.end()
self.tool_tip = "<img src=\"data:image/png;base64,%s\">" % (bytes(
buffer.data().toBase64()).decode())
def process(self, page_path: Path, warped, reliable, output):
blocks = reliable.regions.by_path
lines = reliable.lines.by_path
if not blocks:
return
page = reliable.page
predictors = warped.predictors
qt_im = ImageQt(page.warped)
pixmap = QtGui.QPixmap.fromImage(qt_im)
pixmap = render_warped_line_paths(pixmap, lines, predictors, opacity=1)
buffer = QtCore.QBuffer()
buffer.open(QtCore.QBuffer.ReadWrite)
pixmap.toImage().save(buffer, "PNG")
im = PIL.Image.open(io.BytesIO(buffer.data())).convert("RGB")
binarized = np.array(page.warped)
thresh = skimage.filters.threshold_sauvola(binarized, window_size=15)
binarized = PIL.Image.fromarray(
(binarized > thresh).astype(np.uint8) * 255)
alpha = np.array(binarized.convert("L")).astype(np.float32)
alpha += self._options["marker_opacity"]
alpha = (np.clip(alpha, 0, 1) * 255).astype(np.uint8)
im = PIL.Image.composite(binarized.convert("RGB"), im,
PIL.Image.fromarray(1 - alpha))
qt_im = ImageQt(im)
pixmap = QtGui.QPixmap.fromImage(qt_im)
if self._options["show_confidence"]:
pixmap = render_warped_line_confidence(pixmap, lines)
output.annotation(pixmap.toImage())
def cadProduto(self):
INSERI = CrudProdutos()
INSERI.idProduto = self.tx_idProduto.text()
INSERI.descricaoProduto = self.tx_DescricaoProduto.text().upper()
if self.lb_FotoProduto.pixmap():
imagem = QtGui.QPixmap(self.lb_FotoProduto.pixmap())
data = QtCore.QByteArray()
buf = QtCore.QBuffer(data)
imagem.save(buf, 'PNG')
INSERI.imagemProduto = str(data.toBase64(), encoding='utf8')
INSERI.idCategoria = self.cb_CategoriaProduto.currentData()
INSERI.idMarca = self.cb_MarcaProduto.currentData()
INSERI.estoqueMinimo = self.tx_EstoqueMinimoProduto.text()
INSERI.estoqueMaximo = self.tx_EstoqueMaximoProduto.text()
INSERI.obsProduto = self.tx_ObsProduto.text()
INSERI.valorCompra = self.tx_ValorCompraProduto.text()
INSERI.valorUnitario = self.tx_ValorUnitarioProduto.text()
INSERI.valorAtacado = self.tx_ValorAtacadoProduto.text()
INSERI.qtdeAtacado = self.tx_MinimoAtacado.text()
INSERI.cadProduto()
self.janelaProdutos()
def audio_state_handler(self, state):
if state == QtMultimedia.QAudio.IdleState and self.loop:
self.audio_input.close()
self.audio_input = QtCore.QBuffer(self.data)
self.audio_input.open(QtCore.QIODevice.ReadWrite)
self.audio_output.start(self.audio_input)
