def _write_selection_to_output_file(self, index: int, selection: Selection,
progress_step_size: float):
"""
Creates a new image file and writes the content of the given selection to disk.
:param index: The index of this selection. This is used to build increasing file numbers for the output file.
:param selection: The Selection in progress
:param progress_step_size: Float giving the current progress step size per file in percent. Used for progress
notifications and logging purposes.
:return:
"""
extract = self.image_data.copy(selection.as_qrect)
self.write_output_progress.emit(
int((2 * index - 1) * progress_step_size))
logger.debug(
f"Extracted selection. Progress: {(2*index-1)*progress_step_size:2.2f}%"
)
writer = QImageWriter(self._get_output_file_name(index))
if writer.canWrite():
writer.write(extract)
logger.debug(
f"Written extracted selection to disk. Progress: {(2*index)*progress_step_size:2.2f}%"
)
else:
logger.warning(
f"Image data can not be written! Offending File: {writer.fileName()}"
)
self.write_output_progress.emit(int((2 * index) * progress_step_size))
def tmpimage(tmpdir, qtbot):
"""Create an image to work with."""
path = str(tmpdir.join("any_image.png"))
width = 10
height = 10
pm = QPixmap(width, height)
qtbot.addWidget(pm)
writer = QImageWriter(path)
assert writer.write(pm.toImage())
return path
def __initFileFilters(self):
"""
Private method to define the supported image file filters.
"""
filters = {
'bmp': self.tr("Windows Bitmap File (*.bmp)"),
'gif': self.tr("Graphic Interchange Format File (*.gif)"),
'ico': self.tr("Windows Icon File (*.ico)"),
'jpg': self.tr("JPEG File (*.jpg)"),
'mng': self.tr("Multiple-Image Network Graphics File (*.mng)"),
'pbm': self.tr("Portable Bitmap File (*.pbm)"),
'pcx': self.tr("Paintbrush Bitmap File (*.pcx)"),
'pgm': self.tr("Portable Graymap File (*.pgm)"),
'png': self.tr("Portable Network Graphics File (*.png)"),
'ppm': self.tr("Portable Pixmap File (*.ppm)"),
'sgi': self.tr("Silicon Graphics Image File (*.sgi)"),
'svg': self.tr("Scalable Vector Graphics File (*.svg)"),
'tga': self.tr("Targa Graphic File (*.tga)"),
'tif': self.tr("TIFF File (*.tif)"),
'xbm': self.tr("X11 Bitmap File (*.xbm)"),
'xpm': self.tr("X11 Pixmap File (*.xpm)"),
}
outputFormats = []
writeFormats = QImageWriter.supportedImageFormats()
for writeFormat in writeFormats:
try:
outputFormats.append(filters[bytes(writeFormat).decode()])
except KeyError:
pass
outputFormats.sort()
self.__outputFilter = ';;'.join(outputFormats)
self.__defaultFilter = filters['png']
def createActions(self):
self.openAct = QAction("&Open...", self, shortcut="Ctrl+O",
triggered=self.open)
for format in QImageWriter.supportedImageFormats():
format = str(format)
text = format.upper() + "..."
action = QAction(text, self, triggered=self.save)
action.setData(format)
self.saveAsActs.append(action)
self.printAct = QAction("&Print...", self,
triggered=self.scribbleArea.print_)
self.exitAct = QAction("E&xit", self, shortcut="Ctrl+Q",
triggered=self.close)
self.penColorAct = QAction("&Pen Color...", self,
triggered=self.penColor)
self.penWidthAct = QAction("Pen &Width...", self,
triggered=self.penWidth)
self.clearScreenAct = QAction("&Clear Screen", self, shortcut="Ctrl+L",
triggered=self.scribbleArea.clearImage)
self.aboutAct = QAction("&About", self, triggered=self.about)
self.aboutQtAct = QAction("About &Qt", self,
triggered=QApplication.instance().aboutQt)
def __saveImage(self):
"""
Private slot to handle the Save Image menu action.
"""
if self.mainWidget is None:
E5MessageBox.critical(self, self.tr("Save Image"),
self.tr("""There is no UI file loaded."""))
return
defaultExt = "PNG"
filters = ""
formats = QImageWriter.supportedImageFormats()
for imageFormat in formats:
filters = "{0}*.{1} ".format(filters,
bytes(imageFormat).decode().lower())
fileFilter = self.tr("Images ({0})").format(filters[:-1])
fname = E5FileDialog.getSaveFileName(self, self.tr("Save Image"), "",
fileFilter)
if not fname:
return
ext = QFileInfo(fname).suffix().upper()
if not ext:
ext = defaultExt
fname.append(".{0}".format(defaultExt.lower()))
pix = self.mainWidget.grab()
self.__updateChildren(self.lastStyle)
if not pix.save(fname, str(ext)):
E5MessageBox.critical(
self, self.tr("Save Image"),
self.tr("""<p>The file <b>{0}</b> could not be saved.</p>""").
format(fname))
def saveImage(self, dirpath):
img = FlowBoardPainter.renderImage(self._board, self._solver)
filename = hex(abs(self._solver.stateHash()))[2:] + '.png'
writer = QImageWriter(path.join(dirpath, filename))
writer.setFormat('png')
if not writer.write(img):
raise Exception(writer.errorString())
def fileSaveAs(self):
if self.image.isNull():
return
fname = self.filename if self.filename else '.'
formats = ['{0}'.format(str(format).lower()) for format in QImageWriter.supportedImageFormats()]
formats = ['*.{0}'.format(format[2:5]) for format in formats]
fname,_ = QFileDialog.getSaveFileName(self, 'Image Editor - Save Image', fname, 'Image files ({0})'.format(' '.join(formats)))
if fname:
if '.' not in fname:
fname += '.png'
self.addRecentFiles(fname)
self.filename = fname
self.fileSave()
def render_png(self, svg_data: str, *, compression=40) -> bytes:
""" Rasterize an SVG image to PNG format and return the raw bytes. """
im = self._render(svg_data)
buf = QBuffer()
writer = QImageWriter(buf, b'PNG')
writer.setCompression(compression)
writer.write(im)
return buf.data().data()
def _supported_file_formats() -> typing.List[str]:
"""
Returns all supported file types. This is the intersection of readable and writable file formats.
"""
supported_input_formats = set(
f.data().decode("utf-8")
for f in QImageReader.supportedImageFormats())
supported_output_formats = set(
f.data().decode("utf-8")
for f in QImageWriter.supportedImageFormats())
supported_formats = sorted(
list(supported_input_formats.intersection(
supported_output_formats)))
return supported_formats
def objectSaveAs(self, obj):
formats = [
'{0}'.format(str(format).lower())
for format in QImageWriter.supportedImageFormats()
]
formats = ['*.{0}'.format(format[2:5]) for format in formats]
fname, _ = QFileDialog.getSaveFileName(
self, 'De-occlusion - Save object', '.',
'Image files ({0})'.format(' '.join(formats)))
if fname:
if '.' not in fname:
fname += '.png'
obj = np.concatenate([obj[:, :, :3][:, :, ::-1], obj[:, :, 3:4]],
axis=2)
cv2.imwrite(fname, obj)
def fileSaveAs(self):
if self.image.isNull():
return True
fname = self.filename if self.filename is not None else "."
formats = (["*.{0}".format(format.data().decode("ascii").lower())
for format in QImageWriter.supportedImageFormats()])
fname, tpye = QFileDialog.getSaveFileName(self,
"Image Changer - Save Image", fname,
"Image files ({0})".format(" ".join(formats)))
if fname:
if "." not in fname:
fname += ".png"
self.addRecentFile(fname)
self.filename = fname
return self.fileSave()
return False
def fileSaveAs(self):
if self.mainApp.canvas_show.isNull():
return
fname = self.filename if self.filename else '.'
formats = [
'{0}'.format(str(format).lower())
for format in QImageWriter.supportedImageFormats()
]
formats = ['*.{0}'.format(format[2:5]) for format in formats]
fname, _ = QFileDialog.getSaveFileName(
self, 'De-occlusion - Save Image', fname,
'Image files ({0})'.format(' '.join(formats)))
if fname:
if '.' not in fname:
fname += '.png'
self.filename = fname
self.fileSave()
def export(self):
allowed_formats = QImageWriter.supportedImageFormats()
allowed_formats = [
str(f.data(), encoding='utf-8') for f in allowed_formats
]
filter_string = 'Images ('
for f in allowed_formats:
filter_string += '*.%s ' % f
filter_string = filter_string[:-1] + ')'
fileName, _ = QFileDialog.getSaveFileName(self, "Export File",
QDir.currentPath(),
filter_string)
if not fileName:
return
self.imageView.image.pixmap().save(fileName)
self.statusbar.showMessage('Image exported to %s' % fileName)
def _initFileOptionsWidget(self):
# List all image formats supported by QImageWriter
exts = [bytes(ext).decode() for ext in QImageWriter.supportedImageFormats()]
# insert them into file format combo box
for ext in exts:
self.fileFormatCombo.addItem(ext + " sequence")
# connect handles
self.fileFormatCombo.currentIndexChanged.connect(self._handleFormatChange)
self.filePatternEdit.textEdited.connect(self._handlePatternChange)
self.directoryEdit.textChanged.connect(self._validateFilePath)
self.selectDirectoryButton.clicked.connect(self._browseForPath)
# set default file format to png
self.fileFormatCombo.setCurrentIndex(exts.index("png"))
self._updateFilePattern()
self._validateFilePath()
def init_image_file_dialog(self, dialog, accept_mode):
if self.firstDialog:
self.firstDialog = False
pictures_locations = QStandardPaths.standardLocations(
QStandardPaths.PicturesLocation)
dialog.setDirectory(QDir.currentPath(
) if len(pictures_locations) == 0 else pictures_locations[-1])
mime_type_filters = []
supported_mime_types = QImageReader.supportedMimeTypes() if (accept_mode == QFileDialog.AcceptOpen) \
else QImageWriter.supportedMimeTypes()
for mimeTypeName in supported_mime_types:
mime_type_filters.append(mimeTypeName.data().decode())
mime_type_filters.sort()
dialog.setMimeTypeFilters(mime_type_filters)
dialog.selectMimeTypeFilter("image/jpeg")
if accept_mode == QFileDialog.AcceptSave:
dialog.setDefaultSuffix("jpg")
dialog.setOption(QFileDialog.DontUseNativeDialog, True)
def saveImage(self):
image = QPixmap(self.size())
self.render(image)
formats = QImageWriter.supportedImageFormats()
formats = map(
lambda format: "*.{}".format(bytes(format).decode("utf-8")),
formats)
path = QFileDialog.getSaveFileName(
self, self.tr("Save Image"),
"{}_{}.png".format(self.multiplier, self.modulus),
self.tr("Image files ({})").format(" ".join(formats)))
filename = path[0]
if filename is not None and filename != '':
if not image.save(filename):
QMessageBox.warning(
self, self.tr("Save Image"),
self.tr("Failed to save file at the specified location."))
class ImageFileOpenDialog(FileDialogBase):
"""Modal dialog for inserting an image"""
title = "Insert image"
img_formats = QImageWriter.supportedImageFormats()
img_format_strings = ("*." + fmt.data().decode('utf-8')
for fmt in img_formats)
img_format_string = " ".join(img_format_strings)
name_filter = "Images ({})".format(img_format_string) + ";;" \
"Scalable Vector Graphics (*.svg *.svgz)"
def show_dialog(self):
"""Present dialog and update values"""
path = self.main_window.settings.last_file_input_path
self.file_path, self.selected_filter = \
QFileDialog.getOpenFileName(self.main_window,
self.title,
str(path),
self.name_filter)
def render(self, mapFileName, imageFileName):
map = None
renderer = None
reader = MapReader()
map = reader.readMap(mapFileName)
if (not map):
qWarning("Error while reading " + mapFileName + ":\n" +
reader.errorString())
return 1
x = map.orientation()
if x == Map.Orientation.Isometric:
renderer = IsometricRenderer(map)
elif x == Map.Orientation.Staggered:
renderer = StaggeredRenderer(map)
elif x == Map.Orientation.Hexagonal:
renderer = HexagonalRenderer(map)
else:
renderer = OrthogonalRenderer(map)
if (self.mTileSize > 0):
xScale = self.mTileSize / map.tileWidth()
yScale = self.mTileSize / map.tileHeight()
else:
xScale = yScale = self.mScale
mapSize = renderer.mapSize()
margins = map.computeLayerOffsetMargins()
mapSize.setWidth(mapSize.width() + margins.left() + margins.right())
mapSize.setHeight(mapSize.height() + margins.top() + margins.bottom())
mapSize.setWidth(mapSize.width() * xScale)
mapSize.setHeight(mapSize.height() * yScale)
image = QImage(mapSize, QImage.Format_ARGB32)
image.fill(Qt.transparent)
painter = QPainter(image)
if (xScale != 1.0 or yScale != 1.0):
if (self.mUseAntiAliasing):
painter.setRenderHints(QPainter.SmoothPixmapTransform
| QPainter.Antialiasing)
painter.setTransform(QTransform.fromScale(xScale, yScale))
painter.translate(margins.left(), margins.top())
# Perform a similar rendering than found in exportasimagedialog.py
for layer in map.layers():
if (not self.shouldDrawLayer(layer)):
continue
painter.setOpacity(layer.opacity())
painter.translate(layer.offset())
tileLayer = layer
imageLayer = layer
tp = type(layer)
if tp == TileLayer:
renderer.drawTileLayer(painter, tileLayer)
elif tp == ImageLayer:
renderer.drawImageLayer(painter, imageLayer)
painter.translate(-layer.offset())
painter.end()
# Save image
imageWriter = QImageWriter(imageFileName)
if (not imageWriter.write(image)):
qWarning("Error while writing " + imageFileName + ": " +
imageWriter.errorString())
return 1
return 0
def image_to_data(img, compression_quality=95, fmt='JPEG', png_compression_level=9, jpeg_optimized=True, jpeg_progressive=False):
'''
Serialize image to bytestring in the specified format.
:param compression_quality: is for JPEG and goes from 0 to 100. 100 being lowest compression, highest image quality
:param png_compression_level: is for PNG and goes from 0-9. 9 being highest compression.
:param jpeg_optimized: Turns on the 'optimize' option for libjpeg which losslessly reduce file size
:param jpeg_progressive: Turns on the 'progressive scan' option for libjpeg which allows JPEG images to be downloaded in streaming fashion
'''
fmt = fmt.upper()
ba = QByteArray()
buf = QBuffer(ba)
buf.open(QBuffer.WriteOnly)
if fmt == 'GIF':
w = QImageWriter(buf, b'PNG')
w.setQuality(90)
if not w.write(img):
raise ValueError('Failed to export image as ' + fmt + ' with error: ' + w.errorString())
from PIL import Image
im = Image.open(BytesIO(ba.data()))
buf = BytesIO()
im.save(buf, 'gif')
return buf.getvalue()
is_jpeg = fmt in ('JPG', 'JPEG')
w = QImageWriter(buf, fmt.encode('ascii'))
if is_jpeg:
if img.hasAlphaChannel():
img = blend_image(img)
# QImageWriter only gained the following options in Qt 5.5
if jpeg_optimized:
w.setOptimizedWrite(True)
if jpeg_progressive:
w.setProgressiveScanWrite(True)
w.setQuality(compression_quality)
elif fmt == 'PNG':
cl = min(9, max(0, png_compression_level))
w.setQuality(10 * (9-cl))
if not w.write(img):
raise ValueError('Failed to export image as ' + fmt + ' with error: ' + w.errorString())
return ba.data()
def exportGeorefRaster(self, layer, rasterPath, isPutRotationInWorldFile,
isExportOnlyWorldFile):
baseRasterFilePath, _ = os.path.splitext(rasterPath)
# suppose supported format already checked
rasterFormat = utils.imageFormat(rasterPath)
try:
originalWidth = layer.image.width()
originalHeight = layer.image.height()
radRotation = layer.rotation * math.pi / 180
if isPutRotationInWorldFile or isExportOnlyWorldFile:
# keep the image as is and put all transformation params
# in world file
img = layer.image
a = layer.xScale * math.cos(radRotation)
# sin instead of -sin because angle in CW
b = -layer.yScale * math.sin(radRotation)
d = layer.xScale * -math.sin(radRotation)
e = -layer.yScale * math.cos(radRotation)
c = layer.center.x() - (a * (originalWidth - 1) / 2 + b *
(originalHeight - 1) / 2)
f = layer.center.y() - (d * (originalWidth - 1) / 2 + e *
(originalHeight - 1) / 2)
else:
# transform the image with rotation and scaling between the
# axes
# maintain at least the original resolution of the raster
ratio = layer.xScale / layer.yScale
if ratio > 1:
# increase x
scaleX = ratio
scaleY = 1
else:
# increase y
scaleX = 1
scaleY = 1.0 / ratio
width = abs(
scaleX * originalWidth * math.cos(radRotation)) + abs(
scaleY * originalHeight * math.sin(radRotation))
height = abs(
scaleX * originalWidth * math.sin(radRotation)) + abs(
scaleY * originalHeight * math.cos(radRotation))
qDebug("wh %f,%f" % (width, height))
img = QImage(QSize(math.ceil(width), math.ceil(height)),
QImage.Format_ARGB32)
# transparent background
img.fill(QColor(0, 0, 0, 0))
painter = QPainter(img)
painter.setRenderHint(QPainter.Antialiasing, True)
# painter.setRenderHint(QPainter.SmoothPixmapTransform, True)
rect = QRectF(
QPointF(-layer.image.width() / 2.0,
-layer.image.height() / 2.0),
QPointF(layer.image.width() / 2.0,
layer.image.height() / 2.0),
)
painter.translate(QPointF(width / 2.0, height / 2.0))
painter.rotate(layer.rotation)
painter.scale(scaleX, scaleY)
painter.drawImage(rect, layer.image)
painter.end()
extent = layer.extent()
a = extent.width() / width
e = -extent.height() / height
# 2nd term because (0,0) of world file is on center of upper
# left pixel instead of upper left corner of that pixel
c = extent.xMinimum() + a / 2
f = extent.yMaximum() + e / 2
b = d = 0.0
if not isExportOnlyWorldFile:
# export image
if rasterFormat == "tif":
writer = QImageWriter()
# use LZW compression for tiff
# useful for scanned documents (mostly white)
writer.setCompression(1)
writer.setFormat(b"TIFF")
writer.setFileName(rasterPath)
writer.write(img)
else:
img.save(rasterPath, rasterFormat)
worldFilePath = baseRasterFilePath + "."
if rasterFormat == "jpg":
worldFilePath += "jgw"
elif rasterFormat == "png":
worldFilePath += "pgw"
elif rasterFormat == "bmp":
worldFilePath += "bpw"
elif rasterFormat == "tif":
worldFilePath += "tfw"
with open(worldFilePath, "w") as writer:
# order is as described at
# http://webhelp.esri.com/arcims/9.3/General/topics/author_world_files.htm
writer.write("%.13f\n%.13f\n%.13f\n%.13f\n%.13f\n%.13f" %
(a, d, b, e, c, f))
crsFilePath = rasterPath + ".aux.xml"
with open(crsFilePath, "w") as writer:
writer.write(
self.auxContent(
self.iface.mapCanvas().mapSettings().destinationCrs()))
widget = QgsMessageBar.createMessage(
"Raster Geoferencer", "Raster exported successfully.")
self.iface.messageBar().pushWidget(widget, Qgis.Info, 2)
except Exception as ex:
QgsMessageLog.logMessage(repr(ex))
widget = QgsMessageBar.createMessage(
"Raster Geoferencer",
"There was an error performing this command. "
"See QGIS Message log for details.",
)
self.iface.messageBar().pushWidget(widget, Qgis.Critical, 5)
def createActions(self):
self.openAct = QAction("&Open...",
self,
shortcut="Ctrl+O",
triggered=self.open)
self.openRecentAct = QAction("&Open Recent...",
self,
shortcut="Ctrl+Shift+O",
triggered=self.openLast)
for format in QImageWriter.supportedImageFormats():
format = str(format)
text = format.upper() + "..."
action = QAction(text, self, triggered=self.save)
action.setData(format)
self.saveAsActs.append(action)
self.printAct = QAction("&Print...",
self,
triggered=self.scribbleArea.print_)
self.exitAct = QAction("E&xit",
self,
shortcut="Ctrl+Q",
triggered=self.close)
self.penColorAct = QAction("&Pen Color...",
self,
triggered=self.penColor)
self.penWidthAct = QAction("Pen &Width...",
self,
triggered=self.penWidth)
self.startSweepAct = QAction("&Start Sweeping..",
self,
triggered=self.scribbleArea.startSweep)
self.drawRectAct = QAction("&Grab Cut",
self,
triggered=self.scribbleArea.startGrabCut)
self.axisRotateAct = QCheckBox(checked=True, text="Axis Rotate")
self.axisRotateAct.stateChanged.connect(
self.scribbleArea.setAxisRotate)
label = QLabel("Line:")
self.input_axisResolution = QLineEdit()
self.input_axisResolution.setText("20")
self.input_axisResolution.setMaximumWidth(80)
self.input_axisResolution.textChanged.connect(
self.scribbleArea.setModelResolution)
self.input_primitiveDensity = QLineEdit()
self.input_primitiveDensity.setText("200")
self.input_primitiveDensity.setMaximumWidth(80)
self.input_primitiveDensity.textChanged.connect(
self.scribbleArea.setModelDensity)
self.clearScreenAct = QAction("&Clear Screen",
self,
shortcut="Ctrl+L",
triggered=self.scribbleArea.clearImage)
self.aboutAct = QAction("&About", self, triggered=self.about)
self.aboutQtAct = QAction("About &Qt",
self,
triggered=QApplication.instance().aboutQt)
def writableImageFormatsFilter():
return toImageFileFilter(QImageWriter.supportedImageFormats())
