def create_colormap_img(cmap_name, width=50, height=20):
colormap = cm.get_cmap(cmap_name)
gradient_array = np.tile(np.linspace(0, 1, width), height)
img_array = (colormap(gradient_array) * 255).astype(np.uint8)
return QImage(img_array, width, height,
QImage.Format_RGBA8888_Premultiplied)
def graph2icon(g: Graph,
width: int,
node_mode: bool,
show_label: bool,
monochrome: bool,
*,
except_node: Optional[int] = None,
engine: str = "",
pos: Optional[_Pos] = None) -> QIcon:
"""Draw a generalized chain graph."""
if engine:
pos = engine_picker(g, engine, node_mode)
if pos is None:
raise ValueError("no engine selected")
if not pos:
pixmap = QPixmap(width, width)
pixmap.fill(Qt.transparent)
return QIcon(pixmap)
width_bound = -float('inf')
for x, y in pos.values():
if abs(x) > width_bound:
width_bound = x
if abs(y) > width_bound:
width_bound = y
width_bound *= 2.5
image = QImage(QSize(int(width_bound), int(width_bound)),
QImage.Format_ARGB32_Premultiplied)
image.fill(Qt.transparent)
painter = QPainter(image)
painter.translate(image.width() / 2, image.height() / 2)
pen = QPen()
r = int(width_bound / 50)
pen.setWidth(r)
painter.setPen(pen)
_font.setPixelSize(r * 6)
painter.setFont(_font)
# Draw edges
if node_mode:
for l1, l2 in g.edges:
if except_node in {l1, l2}:
pen.setColor(Qt.gray)
else:
pen.setColor(Qt.black)
painter.setPen(pen)
painter.drawLine(QPointF(pos[l1][0], -pos[l1][1]),
QPointF(pos[l2][0], -pos[l2][1]))
else:
if monochrome:
color = QColor(Qt.darkGray)
else:
color = LINK_COLOR
color.setAlpha(150)
painter.setBrush(QBrush(color))
for link in g.vertices:
if link == except_node:
pen.setColor(Qt.gray)
else:
pen.setColor(Qt.black)
painter.setPen(pen)
painter.drawPolygon(*convex_hull([(pos[n][0], -pos[n][1])
for n, edge in edges_view(g)
if link in edge],
as_qpoint=True))
# Draw vertices
for k, (x, y) in pos.items():
if node_mode:
color = color_num(len(list(g.neighbors(k))) - 1)
if k == except_node:
color.setAlpha(150)
else:
if monochrome:
color = Qt.black
elif except_node in dict(edges_view(g))[k]:
color = color_qt('Green')
else:
color = color_qt('Blue')
pen.setColor(color)
painter.setPen(pen)
painter.setBrush(QBrush(color))
point = QPointF(x, -y)
painter.drawEllipse(point, r, r)
if show_label:
pen.setColor(Qt.darkMagenta)
painter.setPen(pen)
painter.drawText(point, str(k))
painter.end()
return QIcon(QPixmap.fromImage(image).scaledToWidth(width))
def get_qimage(self) -> QImage:
"""To QImage."""
height, width, color = self._img.shape
return QImage(self._img.data, width, height, color * height,
QImage.Format_RGB888)
def _mgui_set_value(self, val: np.ndarray) -> None:
image = QImage(val, val.shape[1], val.shape[0], QImage.Format_RGBA8888)
self._pixmap = QPixmap.fromImage(image)
self._rescale()
def renderDocument(self,
plot,
filename,
sizeMM=(300, 200),
resolution=85,
format_=None):
"""
Render a plot to a file
The format of the document will be auto-detected from the
suffix of the file name.
:param qwt.plot.QwtPlot plot: Plot widget
:param str fileName: Path of the file, where the document will be stored
:param QSizeF sizeMM: Size for the document in millimeters
:param int resolution: Resolution in dots per Inch (dpi)
"""
if isinstance(sizeMM, tuple):
sizeMM = QSizeF(*sizeMM)
if format_ is None:
ext = osp.splitext(filename)[1]
if not ext:
raise TypeError(
"Unable to determine target format from filename")
format_ = ext[1:]
if plot is None or sizeMM.isEmpty() or resolution <= 0:
return
title = plot.title().text()
if not title:
title = "Plot Document"
mmToInch = 1.0 / 25.4
size = sizeMM * mmToInch * resolution
documentRect = QRectF(0.0, 0.0, size.width(), size.height())
fmt = format_.lower()
if fmt in ("pdf", "ps"):
printer = QPrinter()
if fmt == "pdf":
printer.setOutputFormat(QPrinter.PdfFormat)
else:
printer.setOutputFormat(QPrinter.PostScriptFormat)
printer.setColorMode(QPrinter.Color)
printer.setFullPage(True)
printer.setPaperSize(sizeMM, QPrinter.Millimeter)
printer.setDocName(title)
printer.setOutputFileName(filename)
printer.setResolution(resolution)
painter = QPainter(printer)
self.render(plot, painter, documentRect)
painter.end()
elif fmt == "svg":
generator = QSvgGenerator()
generator.setTitle(title)
generator.setFileName(filename)
generator.setResolution(resolution)
generator.setViewBox(documentRect)
painter = QPainter(generator)
self.render(plot, painter, documentRect)
painter.end()
elif fmt in QImageWriter.supportedImageFormats():
imageRect = documentRect.toRect()
dotsPerMeter = int(round(resolution * mmToInch * 1000.0))
image = QImage(imageRect.size(), QImage.Format_ARGB32)
image.setDotsPerMeterX(dotsPerMeter)
image.setDotsPerMeterY(dotsPerMeter)
image.fill(QColor(Qt.white).rgb())
painter = QPainter(image)
self.render(plot, painter, imageRect)
painter.end()
image.save(filename, fmt)
else:
raise TypeError("Unsupported file format '%s'" % fmt)
def _update_bitmap(self) -> None:
"""Update the bitmap with latest image data."""
height, width = BITMAP_SHAPE[:2]
image = QImage(self._image, width, height, QImage.Format_RGBA8888)
self.setPixmap(QPixmap.fromImage(image))
def mouse_on_map(self, val):
if val != self.current_color:
self.current_color = val
img = color_bar_fun(np.arange(0, 256), val)
self.image = QImage(img.data, 256, 1, img.dtype.itemsize * 256 * 3, QImage.Format_RGB888)
self.preview.repaint()
def load_by_qt(self, path):
self.qimg = QImage(str(path))
