351 lines
13 KiB
Python
351 lines
13 KiB
Python
# -*- coding: utf-8 -*-
|
|
"""
|
|
GraphicsWidget displaying an image histogram along with gradient editor. Can be used to adjust the appearance of images.
|
|
"""
|
|
|
|
|
|
from ..Qt import QtGui, QtCore
|
|
from .. import functions as fn
|
|
from .GraphicsWidget import GraphicsWidget
|
|
from .ViewBox import *
|
|
from .GradientEditorItem import *
|
|
from .LinearRegionItem import *
|
|
from .PlotDataItem import *
|
|
from .AxisItem import *
|
|
from .GridItem import *
|
|
from ..Point import Point
|
|
from .. import functions as fn
|
|
import numpy as np
|
|
from .. import debug as debug
|
|
|
|
import weakref
|
|
|
|
__all__ = ['HistogramLUTItem']
|
|
|
|
|
|
class HistogramLUTItem(GraphicsWidget):
|
|
"""
|
|
This is a graphicsWidget which provides controls for adjusting the display of an image.
|
|
|
|
Includes:
|
|
|
|
- Image histogram
|
|
- Movable region over histogram to select black/white levels
|
|
- Gradient editor to define color lookup table for single-channel images
|
|
|
|
================ ===========================================================
|
|
image (:class:`~pyqtgraph.ImageItem` or ``None``) If *image* is
|
|
provided, then the control will be automatically linked to
|
|
the image and changes to the control will be immediately
|
|
reflected in the image's appearance.
|
|
fillHistogram (bool) By default, the histogram is rendered with a fill.
|
|
For performance, set ``fillHistogram=False``
|
|
rgbHistogram (bool) Sets whether the histogram is computed once over all
|
|
channels of the image, or once per channel.
|
|
levelMode 'mono' or 'rgba'. If 'mono', then only a single set of
|
|
black/white level lines is drawn, and the levels apply to
|
|
all channels in the image. If 'rgba', then one set of
|
|
levels is drawn for each channel.
|
|
================ ===========================================================
|
|
"""
|
|
|
|
sigLookupTableChanged = QtCore.Signal(object)
|
|
sigLevelsChanged = QtCore.Signal(object)
|
|
sigLevelChangeFinished = QtCore.Signal(object)
|
|
|
|
def __init__(self, image=None, fillHistogram=True, rgbHistogram=False, levelMode='mono'):
|
|
GraphicsWidget.__init__(self)
|
|
self.lut = None
|
|
self.imageItem = lambda: None # fake a dead weakref
|
|
self.levelMode = levelMode
|
|
self.rgbHistogram = rgbHistogram
|
|
|
|
self.layout = QtGui.QGraphicsGridLayout()
|
|
self.setLayout(self.layout)
|
|
self.layout.setContentsMargins(1,1,1,1)
|
|
self.layout.setSpacing(0)
|
|
self.vb = ViewBox(parent=self)
|
|
self.vb.setMaximumWidth(152)
|
|
self.vb.setMinimumWidth(45)
|
|
self.vb.setMouseEnabled(x=False, y=True)
|
|
self.gradient = GradientEditorItem()
|
|
self.gradient.setOrientation('right')
|
|
self.gradient.loadPreset('grey')
|
|
self.regions = [
|
|
LinearRegionItem([0, 1], 'horizontal', swapMode='block'),
|
|
LinearRegionItem([0, 1], 'horizontal', swapMode='block', pen='r',
|
|
brush=fn.mkBrush((255, 50, 50, 50)), span=(0., 1/3.)),
|
|
LinearRegionItem([0, 1], 'horizontal', swapMode='block', pen='g',
|
|
brush=fn.mkBrush((50, 255, 50, 50)), span=(1/3., 2/3.)),
|
|
LinearRegionItem([0, 1], 'horizontal', swapMode='block', pen='b',
|
|
brush=fn.mkBrush((50, 50, 255, 80)), span=(2/3., 1.)),
|
|
LinearRegionItem([0, 1], 'horizontal', swapMode='block', pen='w',
|
|
brush=fn.mkBrush((255, 255, 255, 50)), span=(2/3., 1.))]
|
|
for region in self.regions:
|
|
region.setZValue(1000)
|
|
self.vb.addItem(region)
|
|
region.lines[0].addMarker('<|', 0.5)
|
|
region.lines[1].addMarker('|>', 0.5)
|
|
region.sigRegionChanged.connect(self.regionChanging)
|
|
region.sigRegionChangeFinished.connect(self.regionChanged)
|
|
|
|
self.region = self.regions[0] # for backward compatibility.
|
|
|
|
self.axis = AxisItem('left', linkView=self.vb, maxTickLength=-10, parent=self)
|
|
self.layout.addItem(self.axis, 0, 0)
|
|
self.layout.addItem(self.vb, 0, 1)
|
|
self.layout.addItem(self.gradient, 0, 2)
|
|
self.range = None
|
|
self.gradient.setFlag(self.gradient.ItemStacksBehindParent)
|
|
self.vb.setFlag(self.gradient.ItemStacksBehindParent)
|
|
|
|
self.gradient.sigGradientChanged.connect(self.gradientChanged)
|
|
self.vb.sigRangeChanged.connect(self.viewRangeChanged)
|
|
add = QtGui.QPainter.CompositionMode_Plus
|
|
self.plots = [
|
|
PlotCurveItem(pen=(200, 200, 200, 100)), # mono
|
|
PlotCurveItem(pen=(255, 0, 0, 100), compositionMode=add), # r
|
|
PlotCurveItem(pen=(0, 255, 0, 100), compositionMode=add), # g
|
|
PlotCurveItem(pen=(0, 0, 255, 100), compositionMode=add), # b
|
|
PlotCurveItem(pen=(200, 200, 200, 100), compositionMode=add), # a
|
|
]
|
|
|
|
self.plot = self.plots[0] # for backward compatibility.
|
|
for plot in self.plots:
|
|
plot.setRotation(90)
|
|
self.vb.addItem(plot)
|
|
|
|
self.fillHistogram(fillHistogram)
|
|
self._showRegions()
|
|
|
|
self.vb.addItem(self.plot)
|
|
self.autoHistogramRange()
|
|
|
|
if image is not None:
|
|
self.setImageItem(image)
|
|
|
|
def fillHistogram(self, fill=True, level=0.0, color=(100, 100, 200)):
|
|
colors = [color, (255, 0, 0, 50), (0, 255, 0, 50), (0, 0, 255, 50), (255, 255, 255, 50)]
|
|
for i,plot in enumerate(self.plots):
|
|
if fill:
|
|
plot.setFillLevel(level)
|
|
plot.setBrush(colors[i])
|
|
else:
|
|
plot.setFillLevel(None)
|
|
|
|
def paint(self, p, *args):
|
|
if self.levelMode != 'mono':
|
|
return
|
|
|
|
pen = self.region.lines[0].pen
|
|
rgn = self.getLevels()
|
|
p1 = self.vb.mapFromViewToItem(self, Point(self.vb.viewRect().center().x(), rgn[0]))
|
|
p2 = self.vb.mapFromViewToItem(self, Point(self.vb.viewRect().center().x(), rgn[1]))
|
|
gradRect = self.gradient.mapRectToParent(self.gradient.gradRect.rect())
|
|
p.setRenderHint(QtGui.QPainter.Antialiasing)
|
|
for pen in [fn.mkPen((0, 0, 0, 100), width=3), pen]:
|
|
p.setPen(pen)
|
|
p.drawLine(p1 + Point(0, 5), gradRect.bottomLeft())
|
|
p.drawLine(p2 - Point(0, 5), gradRect.topLeft())
|
|
p.drawLine(gradRect.topLeft(), gradRect.topRight())
|
|
p.drawLine(gradRect.bottomLeft(), gradRect.bottomRight())
|
|
|
|
def setHistogramRange(self, mn, mx, padding=0.1):
|
|
"""Set the Y range on the histogram plot. This disables auto-scaling."""
|
|
self.vb.enableAutoRange(self.vb.YAxis, False)
|
|
self.vb.setYRange(mn, mx, padding)
|
|
|
|
def autoHistogramRange(self):
|
|
"""Enable auto-scaling on the histogram plot."""
|
|
self.vb.enableAutoRange(self.vb.XYAxes)
|
|
|
|
def setImageItem(self, img):
|
|
"""Set an ImageItem to have its levels and LUT automatically controlled
|
|
by this HistogramLUTItem.
|
|
"""
|
|
self.imageItem = weakref.ref(img)
|
|
img.sigImageChanged.connect(self.imageChanged)
|
|
self._setImageLookupTable()
|
|
self.regionChanged()
|
|
self.imageChanged(autoLevel=True)
|
|
|
|
def viewRangeChanged(self):
|
|
self.update()
|
|
|
|
def gradientChanged(self):
|
|
if self.imageItem() is not None:
|
|
self._setImageLookupTable()
|
|
|
|
self.lut = None
|
|
self.sigLookupTableChanged.emit(self)
|
|
|
|
def _setImageLookupTable(self):
|
|
if self.gradient.isLookupTrivial():
|
|
self.imageItem().setLookupTable(None) #lambda x: x.astype(np.uint8))
|
|
else:
|
|
self.imageItem().setLookupTable(self.getLookupTable) ## send function pointer, not the result
|
|
|
|
def getLookupTable(self, img=None, n=None, alpha=None):
|
|
"""Return a lookup table from the color gradient defined by this
|
|
HistogramLUTItem.
|
|
"""
|
|
if self.levelMode != 'mono':
|
|
return None
|
|
if n is None:
|
|
if img.dtype == np.uint8:
|
|
n = 256
|
|
else:
|
|
n = 512
|
|
if self.lut is None:
|
|
self.lut = self.gradient.getLookupTable(n, alpha=alpha)
|
|
return self.lut
|
|
|
|
def regionChanged(self):
|
|
if self.imageItem() is not None:
|
|
self.imageItem().setLevels(self.getLevels())
|
|
self.sigLevelChangeFinished.emit(self)
|
|
|
|
def regionChanging(self):
|
|
if self.imageItem() is not None:
|
|
self.imageItem().setLevels(self.getLevels())
|
|
self.update()
|
|
self.sigLevelsChanged.emit(self)
|
|
|
|
def imageChanged(self, autoLevel=False, autoRange=False):
|
|
if self.imageItem() is None:
|
|
return
|
|
|
|
if self.levelMode == 'mono':
|
|
for plt in self.plots[1:]:
|
|
plt.setVisible(False)
|
|
self.plots[0].setVisible(True)
|
|
# plot one histogram for all image data
|
|
profiler = debug.Profiler()
|
|
h = self.imageItem().getHistogram()
|
|
profiler('get histogram')
|
|
if h[0] is None:
|
|
return
|
|
self.plot.setData(*h)
|
|
profiler('set plot')
|
|
if autoLevel:
|
|
mn = h[0][0]
|
|
mx = h[0][-1]
|
|
self.region.setRegion([mn, mx])
|
|
profiler('set region')
|
|
else:
|
|
mn, mx = self.imageItem().levels
|
|
self.region.setRegion([mn, mx])
|
|
else:
|
|
# plot one histogram for each channel
|
|
self.plots[0].setVisible(False)
|
|
ch = self.imageItem().getHistogram(perChannel=True)
|
|
if ch[0] is None:
|
|
return
|
|
for i in range(1, 5):
|
|
if len(ch) >= i:
|
|
h = ch[i-1]
|
|
self.plots[i].setVisible(True)
|
|
self.plots[i].setData(*h)
|
|
if autoLevel:
|
|
mn = h[0][0]
|
|
mx = h[0][-1]
|
|
self.region[i].setRegion([mn, mx])
|
|
else:
|
|
# hide channels not present in image data
|
|
self.plots[i].setVisible(False)
|
|
# make sure we are displaying the correct number of channels
|
|
self._showRegions()
|
|
|
|
def getLevels(self):
|
|
"""Return the min and max levels.
|
|
|
|
For rgba mode, this returns a list of the levels for each channel.
|
|
"""
|
|
if self.levelMode == 'mono':
|
|
return self.region.getRegion()
|
|
else:
|
|
nch = self.imageItem().channels()
|
|
if nch is None:
|
|
nch = 3
|
|
return [r.getRegion() for r in self.regions[1:nch+1]]
|
|
|
|
def setLevels(self, min=None, max=None, rgba=None):
|
|
"""Set the min/max (bright and dark) levels.
|
|
|
|
Arguments may be *min* and *max* for single-channel data, or
|
|
*rgba* = [(rmin, rmax), ...] for multi-channel data.
|
|
"""
|
|
if self.levelMode == 'mono':
|
|
if min is None:
|
|
min, max = rgba[0]
|
|
assert None not in (min, max)
|
|
self.region.setRegion((min, max))
|
|
else:
|
|
if rgba is None:
|
|
raise TypeError("Must specify rgba argument when levelMode != 'mono'.")
|
|
for i, levels in enumerate(rgba):
|
|
self.regions[i+1].setRegion(levels)
|
|
|
|
def setLevelMode(self, mode):
|
|
""" Set the method of controlling the image levels offered to the user.
|
|
Options are 'mono' or 'rgba'.
|
|
"""
|
|
assert mode in ('mono', 'rgba')
|
|
|
|
if mode == self.levelMode:
|
|
return
|
|
|
|
oldLevels = self.getLevels()
|
|
self.levelMode = mode
|
|
self._showRegions()
|
|
|
|
# do our best to preserve old levels
|
|
if mode == 'mono':
|
|
levels = np.array(oldLevels).mean(axis=0)
|
|
self.setLevels(*levels)
|
|
else:
|
|
levels = [oldLevels] * 4
|
|
self.setLevels(rgba=levels)
|
|
|
|
# force this because calling self.setLevels might not set the imageItem
|
|
# levels if there was no change to the region item
|
|
self.imageItem().setLevels(self.getLevels())
|
|
|
|
self.imageChanged()
|
|
self.update()
|
|
|
|
def _showRegions(self):
|
|
for i in range(len(self.regions)):
|
|
self.regions[i].setVisible(False)
|
|
|
|
if self.levelMode == 'rgba':
|
|
imax = 4
|
|
if self.imageItem() is not None:
|
|
# Only show rgb channels if connected image lacks alpha.
|
|
nch = self.imageItem().channels()
|
|
if nch is None:
|
|
nch = 3
|
|
xdif = 1.0 / nch
|
|
for i in range(1, nch+1):
|
|
self.regions[i].setVisible(True)
|
|
self.regions[i].setSpan((i-1) * xdif, i * xdif)
|
|
self.gradient.hide()
|
|
elif self.levelMode == 'mono':
|
|
self.regions[0].setVisible(True)
|
|
self.gradient.show()
|
|
else:
|
|
raise ValueError("Unknown level mode %r" % self.levelMode)
|
|
|
|
def saveState(self):
|
|
return {
|
|
'gradient': self.gradient.saveState(),
|
|
'levels': self.getLevels(),
|
|
'mode': self.levelMode,
|
|
}
|
|
|
|
def restoreState(self, state):
|
|
if 'mode' in state:
|
|
self.setLevelMode(state['mode'])
|
|
self.gradient.restoreState(state['gradient'])
|
|
self.setLevels(*state['levels'])
|