Source code for plotpy.tools.misc
# -*- coding: utf-8 -*-
import os.path as osp
import sys
import numpy as np
from guidata.configtools import get_icon
from guidata.dataset import BeginGroup, BoolItem, ChoiceItem, DataSet, EndGroup
from guidata.qthelpers import get_std_icon
from qtpy import QtCore as QC
from qtpy import QtWidgets as QW
from qtpy.QtPrintSupport import QPrintDialog, QPrinter
from plotpy import io
from plotpy.config import _
from plotpy.interfaces import IImageItemType
from plotpy.items import (
compute_image_items_original_size,
get_image_from_plot,
get_items_in_rectangle,
get_plot_qrect,
)
from plotpy.tools.base import CommandTool, DefaultToolbarID, RectangularActionTool
from plotpy.widgets import about
from plotpy.widgets.resizedialog import ResizeDialog
[docs]
class SaveAsTool(CommandTool):
""" """
def __init__(self, manager, toolbar_id=DefaultToolbarID):
super().__init__(
manager,
_("Save as..."),
get_std_icon("DialogSaveButton", 16),
toolbar_id=toolbar_id,
)
[docs]
def activate_command(self, plot, checked):
"""Activate tool"""
# FIXME: Qt's PDF printer is unable to print plots including images
# --> until this bug is fixed internally, disabling PDF output format
# when plot has image items.
formats = "%s (*.png)" % _("PNG image")
for item in plot.get_items():
if IImageItemType in item.types():
break
else:
formats += "\n%s (*.pdf)" % _("PDF document")
fname, _f = QW.QFileDialog.getSaveFileName(
plot, _("Save as"), _("untitled"), formats
)
if fname:
plot.save_widget(fname)
[docs]
class CopyToClipboardTool(CommandTool):
""" """
def __init__(self, manager, toolbar_id=DefaultToolbarID):
super().__init__(
manager,
_("Copy to clipboard"),
get_icon("copytoclipboard.png"),
toolbar_id=toolbar_id,
)
def save_snapshot(plot, p0, p1, new_size=None):
"""
Save rectangular plot area
p0, p1: resp. top left and bottom right points (`QPointF` objects)
new_size: destination image size (tuple: (width, height))
"""
items = get_items_in_rectangle(plot, p0, p1)
if not items:
QW.QMessageBox.critical(
plot,
_("Rectangle snapshot"),
_("There is no supported image item in current selection."),
)
return
src_x, src_y, src_w, src_h = get_plot_qrect(plot, p0, p1).getRect()
original_size = compute_image_items_original_size(items, plot, p0, p1)
if new_size is None:
new_size = (
int(abs(p1.x() - p0.x()) + 1),
int(abs(p1.y() - p0.y()) + 1),
) # Screen size
dlg = ResizeDialog(
plot, new_size=new_size, old_size=original_size, text=_("Destination size:")
)
if not dlg.exec():
return
class SnapshotParam(DataSet):
_levels = BeginGroup(_("Image levels adjustments"))
apply_contrast = BoolItem(_("Apply contrast settings"), default=False)
apply_interpolation = BoolItem(_("Apply interpolation algorithm"), default=True)
norm_range = BoolItem(_("Scale levels to maximum range"), default=False)
_end_levels = EndGroup(_("Image levels adjustments"))
_multiple = BeginGroup(_("Superimposed images"))
add_images = ChoiceItem(
_("If image B is behind image A, replace intersection by"),
[(False, "A"), (True, "A+B")],
default=None,
)
_end_multiple = EndGroup(_("Superimposed images"))
param = SnapshotParam(_("Rectangle snapshot"))
if not param.edit(parent=plot):
return
if dlg.keep_original_size:
destw, desth = original_size
else:
destw, desth = dlg.width, dlg.height
try:
data = get_image_from_plot(
plot,
p0,
p1,
destw=destw,
desth=desth,
add_images=param.add_images,
apply_lut=param.apply_contrast,
apply_interpolation=param.apply_interpolation,
original_resolution=dlg.keep_original_size,
)
dtype = None
for item in items:
if dtype is None or item.data.dtype.itemsize > dtype.itemsize:
dtype = item.data.dtype
if param.norm_range:
data = io.scale_data_to_dtype(data, dtype=dtype)
else:
data = np.array(data, dtype=dtype)
except MemoryError:
mbytes = int(destw * desth * 32.0 / (8 * 1024**2))
text = _(
"There is not enough memory left to process "
"this {destw:d} x {desth:d} image ({mbytes:d} "
"MB would be required)."
)
text = text.format(destw=destw, desth=desth, mbytes=mbytes)
QW.QMessageBox.critical(plot, _("Memory error"), text)
return
for model_item in items:
model_fname = model_item.get_filename()
if model_fname is not None and model_fname.lower().endswith(".dcm"):
break
else:
model_fname = None
fname, _f = QW.QFileDialog.getSaveFileName(
plot,
_("Save as"),
_("untitled"),
io.iohandler.get_filters("save", data.dtype, template=True),
)
_base, ext = osp.splitext(fname)
options = {}
if not fname:
return
elif ext.lower() == ".png":
options.update(dict(dtype=np.uint8, max_range=True))
elif ext.lower() == ".dcm":
# This import statement must stay here because if pydicom is not installed,
# the extension .dcm is not registered in the io module, so we will not
# get here.
try:
from pydicom import dcmread # pylint: disable=import-outside-toplevel
except ImportError:
raise ImportError("This should not happen (pydicom is not installed)")
model_dcm = dcmread(model_fname)
try:
ps_attr = "ImagerPixelSpacing"
ps_x, ps_y = getattr(model_dcm, ps_attr)
except AttributeError:
ps_attr = "PixelSpacing"
ps_x, ps_y = getattr(model_dcm, ps_attr)
model_dcm.Rows, model_dcm.Columns = data.shape
dest_height, dest_width = data.shape
(
_x,
_y,
_angle,
model_dx,
model_dy,
_hflip,
_vflip,
) = model_item.get_transform()
new_ps_x = ps_x * src_w / (model_dx * dest_width)
new_ps_y = ps_y * src_h / (model_dy * dest_height)
setattr(model_dcm, ps_attr, [new_ps_x, new_ps_y])
options.update(dict(template=model_dcm))
io.imwrite(fname, data, **options)
[docs]
class SnapshotTool(RectangularActionTool):
""" """
SWITCH_TO_DEFAULT_TOOL = True
TITLE = _("Rectangle snapshot")
ICON = "snapshot.png"
def __init__(self, manager, toolbar_id=DefaultToolbarID):
super().__init__(
manager, save_snapshot, toolbar_id=toolbar_id, fix_orientation=True
)
[docs]
def end_rect(self, filter, p0, p1):
"""End rect: emit ``SIG_TOOL_JOB_FINISHED`` *synchronously* so the
``switch_to_default_tool`` listener restores the canvas cursor while
we are still inside the mouse-release event handler chain — Qt then
gets the chance to refresh the cursor on neighbouring widgets
(axes, toolbar) before any nested event loop is started by the
snapshot dialogs. The action function itself is deferred via a
zero-delay timer so the modal ``ResizeDialog`` (and following
dialogs) is not opened from inside the rubber-band ``mouseRelease``
handler chain — otherwise Qt's implicit grab is left in an unclean
state on Windows and the cross cursor used by the canvas during
the drag remains "stuck" on neighbouring widgets until the mouse
moves over them.
"""
plot = filter.plot
if self.fix_orientation:
left, right = min(p0.x(), p1.x()), max(p0.x(), p1.x())
top, bottom = min(p0.y(), p1.y()), max(p0.y(), p1.y())
p0, p1 = QC.QPointF(left, top), QC.QPointF(right, bottom)
# Synchronous: cursor is restored on the canvas now, while we are
# still in the mouse-release handler chain.
self.SIG_TOOL_JOB_FINISHED.emit()
if self.switch_to_default_tool:
shape = self.get_last_final_shape()
plot.set_active_item(shape)
# Deferred: open the dialogs after Qt has cleanly released the grab.
QC.QTimer.singleShot(0, lambda: self.action_func(plot, p0, p1))
[docs]
class HelpTool(CommandTool):
""" """
def __init__(self, manager, toolbar_id=DefaultToolbarID):
super().__init__(
manager,
_("Help"),
get_std_icon("DialogHelpButton", 16),
toolbar_id=toolbar_id,
)
[docs]
def activate_command(self, plot, checked):
"""Activate tool"""
info = _(
"""<b>Keyboard/mouse shortcuts:</b><br><br>
- <u>single left-click</u>: item (curve, image, ...) selection<br>
- <u>single right-click</u>: context-menu relative to selected item<br>
- <u>shift</u>: on-active-curve (or image) cursor (+ <u>control</u> to maintain
cursor visible)<br>
- <u>shift + control</u>: on-active-curve cursor (+ <u>control</u> to maintain
cursor visible)<br>
- <u>alt</u>: free cursor<br>
- <u>left-click + mouse move</u>: move item (when available)<br>
- <u>middle-click + mouse move</u>: pan<br>
- <u>right-click + mouse move</u>: zoom"""
)
info += "<br><hr><br><b>" + _("Information on PlotPy:") + "</b><br><br>"
info += about.about(html=True)
QW.QMessageBox.information(plot, _("Help"), info)
class AboutTool(CommandTool):
""" """
def __init__(self, manager, toolbar_id=DefaultToolbarID):
super().__init__(
manager, _("About") + " plotpy", get_icon("plotpy.svg"), toolbar_id=None
)
def activate_command(self, plot, checked):
"""Activate tool"""
about.show_about_dialog()
[docs]
class PrintTool(CommandTool):
""" """
def __init__(self, manager, toolbar_id=DefaultToolbarID):
super().__init__(
manager, _("Print..."), get_icon("print.png"), toolbar_id=toolbar_id
)
[docs]
def activate_command(self, plot, checked):
"""Activate tool"""
printer = QPrinter()
dialog = QPrintDialog(printer, plot)
saved_in, saved_out, saved_err = sys.stdin, sys.stdout, sys.stderr
sys.stdout = None
ok = dialog.exec()
sys.stdin, sys.stdout, sys.stderr = saved_in, saved_out, saved_err
if ok:
plot.print_(printer)
[docs]
class OpenFileTool(CommandTool):
""" """
#: Signal emitted by OpenFileTool when a file was opened
#:
#: Args:
#: filename (str): The name of the file that was opened
SIG_OPEN_FILE = QC.Signal(str)
def __init__(
self, manager, title=_("Open..."), formats="*.*", toolbar_id=DefaultToolbarID
):
super().__init__(
manager, title, get_std_icon("DialogOpenButton", 16), toolbar_id=toolbar_id
)
self.formats = formats
self.directory = ""
[docs]
def get_filename(self, plot):
"""
:param plot:
:return:
"""
saved_in, saved_out, saved_err = sys.stdin, sys.stdout, sys.stderr
sys.stdout = None
filename, _f = QW.QFileDialog.getOpenFileName(
plot, _("Open"), self.directory, self.formats
)
sys.stdin, sys.stdout, sys.stderr = saved_in, saved_out, saved_err
filename = str(filename)
if filename:
self.directory = osp.dirname(filename)
return filename
[docs]
def activate_command(self, plot, checked):
"""Activate tool"""
filename = self.get_filename(plot)
if filename:
self.SIG_OPEN_FILE.emit(filename)
class FilterTool(CommandTool):
""" """
def __init__(self, manager, filter, toolbar_id=None):
super().__init__(manager, str(filter.name), toolbar_id=toolbar_id)
self.filter = filter
def update_status(self, plot):
"""
:param plot:
"""
self.set_status_active_item(plot)
def activate_command(self, plot, checked):
"""Activate tool"""
plot.apply_filter(self.filter)
