def load_finished(self, state):
pixmap = self.engine.grab()
self.image = QByteArray()
buf = QBuffer(self.image)
buf.open(QIODevice.WriteOnly)
pixmap.save(buf, "PNG")
buf.close()
self.quit()
def testWrite(self):
text = 'foobar'
doc = QTextDocument(text)
b = QBuffer()
b.open(QBuffer.ReadWrite)
writer = QTextDocumentWriter(b, "plaintext")
writer.write(doc)
b.close()
self.assertEqual(b.buffer(), text)
def from_scene(cls, scene):
buffer = QBuffer()
generator = QSvgGenerator()
generator.setOutputDevice(buffer)
scene_rect = scene.sceneRect()
generator.setViewBox(scene_rect)
painter = QPainter(generator)
scene.render(painter, scene_rect, scene_rect)
painter.end()
buffer.open(QBuffer.ReadOnly)
renderer = cls(buffer.readAll())
buffer.close()
renderer.scene = scene
return renderer
def qpixmap_to_np(im: QPixmap) -> np.ndarray:
# from PIL.ImageQt.fromqimage
buffer = QBuffer()
buffer.open(QIODevice.ReadWrite)
if im.hasAlphaChannel():
im.save(buffer, "png")
else:
im.save(buffer, "ppm")
npbuf = np.frombuffer(buffer.data(), "<B")
buffer.close()
out = cv2.imdecode(npbuf, cv2.IMREAD_UNCHANGED)
if out.shape[2] == 3:
# Add alpha channel
out = np.pad(out, ((0, 0), (0, 0), (0, 1)), constant_values=0xFF)
return out
def show_qr_code(self):
buffer_png = QBuffer()
buffer_png.open(QIODevice.ReadWrite)
self.text = self.le_qr_code.text()
self.fg_color = self.btn_fg.palette().button().color().name()
self.bg_color = self.btn_bg.palette().button().color().name()
self.scale = self.sb_scale.value()
qrcode = pyqrcode.create(self.text)
qrcode.png(file=buffer_png,
scale=self.scale,
module_color=self.fg_color,
background=self.bg_color)
pixmap_png = QPixmap()
pixmap_png.loadFromData(buffer_png.buffer())
self.lb_qr_img_info.setText(
f'QR Code com {pixmap_png.width()}x{pixmap_png.height()}')
self.lb_qr_img.setPixmap(pixmap_png)
buffer_png.close()
self.btn_save_qr.setEnabled(True)
def plot_dataset(dataset, color_map, scale_labels):
# Only generate the brush once for each unique value
lookup_table = {
x: pg.mkBrush(color_map.map(x))
for x in numpy.unique(dataset)
}
brushes = [lookup_table[x] for x in dataset.data]
scale_widget.setGradient(color_map.getGradient())
scale_widget.setLabels(scale_labels)
# Generate Plot
plot = plot_item.plot(data_x,
data_y,
pen=None,
symbolPen=None,
symbolBrush=brushes,
pxMode=False,
symbolSize=scale_factors,
symbol=pixel_paths)
plot_item.getViewWidget().parent().grab()
volcview_img = plot_item.getViewWidget().parent().grab()
self._view_extents = vbox.viewRange()
file_bytes = QByteArray()
file_buffer = QBuffer(file_bytes)
file_buffer.open(QIODevice.WriteOnly)
volcview_img.save(file_buffer, "PNG")
file_buffer.close()
file_stream = BytesIO(file_bytes)
pil_img = Image.open(file_stream)
# find coverage percent(ish)
width, height = pil_img.size
total_count = width * height # Should be 800,000, unless we changed the size of the images.
# dump into a numpy array to count grey pixels
as_array = numpy.array(pil_img)
# the grey value we use is 238, so if all elements of axis 2 are 238,
# then the pixel is grey.
is_grey = numpy.all(as_array == 238, axis=2)
# number that is False is non-grey, or covered, pixels
# Not quite true due to scale bar, borders, etc.
unique, counts = numpy.unique(is_grey, return_counts=True)
non_grey = dict(zip(unique, counts))[False]
covered_percent = non_grey / total_count
# Don't send the image to volcview unless it has at least 15% coverage.
# Allow 2% for the scale bar and other features.
threshold = .17
if sector['pixelSize'] == 5:
threshold = .06
if covered_percent > threshold:
self._add_coastlines(pil_img)
raw_data = QByteArray()
buffer = QBuffer(raw_data)
if not gen_cloud and not self._data_type in ('VIIRS'):
# "Save" the percentile bar to a bytes buffer, in PNG format
buffer.open(QIODevice.WriteOnly)
_percentContainer.grab().save(buffer, "PNG")
buffer.close()
# Use a bytes IO object to "read" the image into a PIL object
img_stream = BytesIO(raw_data)
with Image.open(img_stream) as img:
pil_img.paste(img, (5, 5), mask=img)
# Add the scale bar and timestamp.
scale_top = pil_img.height
buffer.open(QIODevice.WriteOnly)
scale_widget.grab() # why? WHYYYYYYYY????
scale_widget.grab().save(buffer, "PNG")
buffer.close()
img_stream = BytesIO(raw_data)
with Image.open(img_stream) as img:
scale_top = pil_img.height - img.height - 10
pil_img.paste(img, (25, scale_top), mask=img)
# Add the timestamp
buffer.open(QIODevice.WriteOnly)
date_label.grab().save(buffer, "PNG")
buffer.close()
img_stream = BytesIO(raw_data)
with Image.open(img_stream) as img:
pil_img.paste(img, (pil_img.width - img.width - 51,
scale_top - img.height - 5),
mask=img)
# Save an archive image
logging.debug("Saving archive image for %s", band)
filename = f"{self._file_date.strftime('%Y_%m_%d_%H%M%S')}-{band}-{self._data_type}.png"
save_file = os.path.join(config.FILE_BASE, 'VolcView',
sector['name'], filename)
os.makedirs(os.path.dirname(save_file), exist_ok=True)
pil_img.save(save_file, format='PNG')
file_stream = BytesIO()
# "Save" the image to memory in PNG format
pil_img.save(file_stream, format='PNG')
file_stream.seek(0) # Go back to the begining for reading out
logging.debug("Uploading image for %s", band)
if not DEBUG:
self._volcview_upload(file_stream, sector, band)
else:
logging.debug("******Pretending to send to volc view")
print("TEST UPLOAD", sector['name'], filename, "***200***")
logging.debug("Image upload complete")
if DEBUG:
# This is just Debugging code to save the generated
# image to disk for local analysis.
# Feel free to change file paths to something more
# appropriate if desired.
print(f"^^^^SAVING IMAGE FOR FILE TO DISK^^^")
dest_dir = f"/tmp/VolcViewImages/{sector['sector']}"
os.makedirs(dest_dir, exist_ok=True)
dest_file = f"{self._data_type}-{band}-{self._file_date.strftime('%Y_%m_%d_%H%M%S')}.png"
dest_path = os.path.join(dest_dir, dest_file)
file_stream.seek(0)
with open(dest_path, 'wb') as f:
f.write(file_stream.read())
###################
else:
logging.info("Not enough coverage to bother with")
plot_item.removeItem(plot)
def plot_dataset(dataset, color_map, scale_labels):
# Only generate the brush once for each unique value
lookup_table = {x: pg.mkBrush(color_map.map(x)) for x in numpy.unique(dataset)}
brushes = [lookup_table[x] for x in dataset.data]
scale_widget.setGradient(color_map.getGradient())
scale_widget.setLabels(scale_labels)
# Generate Plot
plot = plot_item.plot(data_x, data_y,
pen=None,
symbolPen=None,
symbolBrush=brushes,
pxMode=False,
symbolSize=scale_factors,
symbol=pixel_paths)
plot_item.getViewWidget().parent().grab()
volcview_img = plot_item.getViewWidget().parent().grab()
self._view_extents = vbox.viewRange()
file_bytes = QByteArray()
file_buffer = QBuffer(file_bytes)
file_buffer.open(QIODevice.WriteOnly)
volcview_img.save(file_buffer, "PNG")
file_buffer.close()
file_stream = BytesIO(file_bytes)
pil_img = Image.open(file_stream)
# find coverage percent(ish)
width, height = pil_img.size
total_count = width * height # Should be 800,000, unless we changed the size of the images.
# dump into a numpy array to count grey pixels
as_array = numpy.array(pil_img)
# the grey value we use is 238, so if all elements of axis 2 are 238,
# then the pixel is grey.
is_grey = numpy.all(as_array == 238, axis=2)
# number that is False is non-grey, or covered, pixels
# Not quite true due to scale bar, borders, etc.
unique, counts = numpy.unique(is_grey, return_counts=True)
non_grey = dict(zip(unique, counts))[False]
covered_percent = non_grey / total_count
# Don't send the image to volcview unless it has at least 15% coverage.
# Allow 2% for the scale bar and other features.
threshold = .17
if sector['pixelSize'] == 5:
threshold = .06
if covered_percent > threshold:
self._add_coastlines(pil_img)
raw_data = QByteArray()
buffer = QBuffer(raw_data)
if not gen_cloud and not self._data_type in ('VIIRS'):
# "Save" the percentile bar to a bytes buffer, in PNG format
buffer.open(QIODevice.WriteOnly)
_percentContainer.grab().save(buffer, "PNG")
buffer.close()
# Use a bytes IO object to "read" the image into a PIL object
img_stream = BytesIO(raw_data)
with Image.open(img_stream) as img:
pil_img.paste(img,
(5, 5),
mask = img)
# Add the scale bar and timestamp.
scale_top = pil_img.height
buffer.open(QIODevice.WriteOnly)
scale_widget.grab() # why? WHYYYYYYYY????
scale_widget.grab().save(buffer, "PNG")
buffer.close()
img_stream = BytesIO(raw_data)
with Image.open(img_stream) as img:
scale_top = pil_img.height - img.height - 10
pil_img.paste(img, (25, scale_top), mask = img)
# Add the timestamp
buffer.open(QIODevice.WriteOnly)
date_label.grab().save(buffer, "PNG")
buffer.close()
img_stream = BytesIO(raw_data)
with Image.open(img_stream) as img:
pil_img.paste(img,
(pil_img.width - img.width - 51,
scale_top - img.height - 5),
mask = img)
# Save an archive image
logging.debug("Saving archive image for %s", band)
os.makedirs(os.path.dirname(save_file), exist_ok = True)
pil_img.save(save_file, format = 'PNG')
else:
logging.info("Not enough coverage to bother with")
plot_item.removeItem(plot)
class MainWindow(QMainWindow):
def __init__(self):
super().__init__()
self.buffer = QBuffer()
self.buffer.open(QBuffer.ReadWrite)
self.setupUI()
self.model = QModel(self)
self.model.start()
""" USER INTERFACE SETUP """
def setupUI(self):
# WINDOW SETUP
self.setWindowTitle("Keras.QuickDraw")
self.setMinimumSize(QSize(800, 600))
self.setFixedSize(QSize(800, 600))
self.setWindowIcon(QIcon("favicon.ico"))
# INITIALIZE: WINDOW CENTRAL
self.widget_central = QWidget(self)
self.widget_central.setObjectName("Window Central")
self.widget_central.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.layout_central = QBoxLayout(QBoxLayout.TopToBottom, self.widget_central)
self.setCentralWidget(self.widget_central)
# INITIALIZE: CENTRAL HEADER
self.widget_header = QWidget(self.widget_central)
self.widget_header.setObjectName("Widget Header")
self.widget_header.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
self.widget_header_indicater = QLabel(parent = self.widget_header)
self.widget_header_caption = QLabel("(TARGET)", self.widget_header)
self.widget_header_counter = QLabel(parent = self.widget_header)
self.layout_header = QBoxLayout(QBoxLayout.LeftToRight, self.widget_header)
self.layout_header.addWidget(self.widget_header_indicater, 0, Qt.AlignLeft)
self.layout_header.addWidget(self.widget_header_caption , 1, Qt.AlignCenter)
self.layout_header.addWidget(self.widget_header_counter , 0, Qt.AlignRight)
# INITIALIZE: CENTRAL CANVAS
self.widget_canvas = QCanvas(self.widget_central, self)
self.widget_canvas.setObjectName("Widget Canvas")
self.widget_canvas.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
# INITIALIZE: CENTRAL BUTTONS
self.widget_footer = QWidget(self.widget_central)
self.widget_footer.setObjectName("Widget Footer")
self.widget_footer.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
self.widget_footer_clear = QPushButton("Clear", self.widget_footer)
self.widget_footer_clear.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.widget_footer_clear.clicked.connect(self.widget_canvas.resetCanvas)
self.widget_footer_undo = QPushButton("Undo", self.widget_footer)
self.widget_footer_undo.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.widget_footer_undo.clicked.connect(self.widget_canvas.undoCanvas)
self.layout_footer = QBoxLayout(QBoxLayout.LeftToRight, self.widget_footer)
self.layout_footer.addWidget(self.widget_footer_undo, 0)
self.layout_footer.addWidget(self.widget_footer_clear, 0)
self.layout_footer.setMargin(0)
# LAYOUT: HEADER + CANVAS + FOOTER -> CENTRAL WINDOW CENTRAL
self.layout_central.addWidget(self.widget_header, 0)
self.layout_central.addWidget(self.widget_canvas, 1, Qt.AlignCenter)
self.layout_central.addWidget(self.widget_footer, 0)
self.show()
""" EVENT: SAVING CANVAS (QThread ALTERNATIVE) """
def paintEvent(self, event: QPaintEvent) -> None:
# SCREENSHOT WIDGET OF QPaintDevice, SUCH AS QBITMAP
self.widget_canvas.render(self.widget_canvas.pixmap())
if self.isVisible:
self.buffer.reset()
self.widget_canvas.pixmap().save(self.buffer, "BMP")
return super().paintEvent(event)
""" EVENT: CLOSING MAINWINDOW """
def closeEvent(self, event: QCloseEvent) -> None:
self.model.terminate()
self.model.wait()
self.buffer.close()
return super().closeEvent(event)
