def __init__(self, targetImage=None, size=200, layer=None, parent=None):
super().__init__(layer=layer, targetImage=targetImage, parent=parent)
self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred)
self.setMinimumSize(size, 100)
self.Label_Hist = QLabel()
self.Label_Hist.setScaledContents(True)
self.Label_Hist.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Preferred)
self.setStyleSheet("QListWidget{border: 0px; font-size: 12px}")
# options
options1, optionNames1 = ['Original Image'], ['Source Image']
self.listWidget1 = optionsWidget(options=options1,
optionNames=optionNames1,
exclusive=False)
self.listWidget1.setMaximumSize(
self.listWidget1.sizeHintForColumn(0) + 5,
self.listWidget1.sizeHintForRow(0) * len(options1))
options2 = ['Color Chans']
self.listWidget2 = optionsWidget(options=options2, exclusive=False)
self.listWidget2.setMaximumSize(
self.listWidget2.sizeHintForColumn(0) + 5,
self.listWidget2.sizeHintForRow(0) * len(options2))
# default: show color hists
self.listWidget2.item(0).setCheckState(Qt.Checked)
self.options = {option: True for option in options1 + options2}
def onSelect1(item):
self.options[options1[0]] = item.checkState() is Qt.Checked
try:
self.targetImage.onImageChanged()
self.Label_Hist.update()
except AttributeError:
return
def onSelect2(item):
self.options[options2[0]] = item.checkState() is Qt.Checked
try:
self.targetImage.onImageChanged()
self.Label_Hist.update()
except AttributeError:
return
self.listWidget1.onSelect = onSelect1
self.listWidget2.onSelect = onSelect2
# layout
h = QHBoxLayout()
h.setContentsMargins(0, 0, 0, 2)
h.addWidget(self.listWidget1)
h.addWidget(self.listWidget2)
vl = QVBoxLayout()
vl.setAlignment(Qt.AlignTop)
vl.addWidget(self.Label_Hist)
vl.addLayout(h)
vl.setContentsMargins(0, 0, 0, 2) # left, top, right, bottom
self.setLayout(vl)
def __init__(self, targetImage=None, axeSize=500, layer=None, parent=None):
super().__init__(layer=layer, targetImage=targetImage, parent=parent)
# options
optionList, optionNames = ['Auto'], ['Auto Orange Mask Removing']
self.listWidget1 = optionsWidget(
options=optionList,
optionNames=optionNames,
exclusive=False,
changed=lambda: self.dataChanged.emit())
self.listWidget1.checkOption(self.listWidget1.intNames[0])
self.options = self.listWidget1.options
# layout
vl = QVBoxLayout()
vl.addWidget(self.listWidget1)
self.setLayout(vl)
self.setDefaults()
self.setWhatsThis("""
<b> Negative Inversion</b><br>
Negative films show an orange mask that must be corrected.<br>
Automatic correction try to sample the mask color
from an unexposed area of the negative film.<br>
To do a <b>manual correction</b>, uncheck 'Auto Orange Mask Removing' and, next,
Ctrl+Click the dark border of the image or, otherwise, a dark gray area.<br>
""") # end of setWhatsThis
def __init__(self, targetImage=None, axeSize=500, layer=None, parent=None):
super().__init__(layer=layer, targetImage=targetImage, parent=parent)
# options
optionList1, optionNames1 = ['Free', 'Rotation', 'Translation'], [
'Free Transformation', 'Rotation', 'Translation'
]
self.listWidget1 = optionsWidget(options=optionList1,
optionNames=optionNames1,
exclusive=True,
changed=self.dataChanged)
optionList2, optionNames2 = ['Transparent'
], ['Set Transparent Pixels To Black']
self.listWidget2 = optionsWidget(options=optionList2,
optionNames=optionNames2,
exclusive=False,
changed=self.dataChanged)
self.options = UDict(
(self.listWidget1.options, self.listWidget2.options))
# set initial selection to Perspective
self.listWidget1.checkOption(optionList1[0])
pushButton1 = QPushButton(' Reset Transformation ')
pushButton1.adjustSize()
pushButton1.clicked.connect(self.reset)
# layout
l = QVBoxLayout()
l.setAlignment(Qt.AlignTop)
l.addWidget(self.listWidget1)
l.addWidget(self.listWidget2)
hl = QHBoxLayout()
hl.setAlignment(Qt.AlignHCenter)
hl.addWidget(pushButton1)
l.addLayout(hl)
self.setLayout(l)
self.adjustSize()
self.setDefaults()
self.setWhatsThis("""
<b>Geometric transformation :</b><br>
Choose a transformation type and drag either corner of the image
using the small square red buttons.<br>
Ctrl+Alt+Drag to change the <b>initial positions</b> of buttons.
""") # end of setWhatsThis
def __init__(self, targetImage=None, axeSize=500, layer=None, parent=None, mainForm=None):
super().__init__(parent=parent)
self.defaultFilterStart = 0
self.defaultFilterEnd = 99
self.filterStart = self.defaultFilterStart
self.filterEnd = self.defaultFilterEnd
self.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred)
self.setMinimumSize(axeSize, axeSize)
self.setAttribute(Qt.WA_DeleteOnClose)
# link back to image layer
self.targetImage = weakProxy(targetImage)
self.img = weakProxy(targetImage)
self.layer = weakProxy(layer)
"""
# using weak ref for back links
if type(layer) in weakref.ProxyTypes:
self.layer = layer
else:
self.layer = weakref.proxy(layer)
"""
self.mainForm = mainForm
self.kernelCategory = filterIndex.UNSHARP
self.kernel = getKernel(self.kernelCategory)
# options
optionList, optionNames = ['Gradual Top', 'Gradual Bottom'], ['Top To Bottom', 'Bottom To Top']
filters = [blendFilterIndex.GRADUALTB, blendFilterIndex.GRADUALBT] #, blendFilterIndex.GRADUALNONE]
filterDict = dict(zip(optionList, filters))
self.listWidget1 = optionsWidget(options=optionList, optionNames=optionNames, exclusive=True, changed=self.dataChanged)
# set initial selection to gradual top
self.listWidget1.checkOption(optionList[0])
rs = QRangeSlider()
rs.setMaximumSize(16000, 10)
rs.tail.setStyleSheet(
'background: white; /*qlineargradient(x1:0, y1:0, x2:1, y2:0, stop:0 #222, stop:1 #888); margin 3px;*/')
rs.handle.setStyleSheet('background: qlineargradient(x1:0, y1:0, x2:1, y2:0, stop:0 black, stop:1 white);')
rs.head.setStyleSheet(
'background: black; /*qlineargradient(x1:0, y1:0, x2:1, y2:0, stop:0 #999, stop:1 #222);*/')
self.sliderFilterRange = rs
frLabel = QLabel('Range')
# filter range done event handler
def frUpdate(start, end):
if self.sliderFilterRange.isSliderDown() or (start == self.filterStart and end == self.filterEnd):
return
self.sliderFilterRange.startValueChanged.disconnect()
self.sliderFilterRange.endValueChanged.disconnect()
self.sliderFilterRange.rangeDone.disconnect()
self.filterStart, self.filterEnd = self.sliderFilterRange.getRange()
self.dataChanged.emit()
self.sliderFilterRange.startValueChanged.connect(frUpdate) # send new value as parameter
self.sliderFilterRange.endValueChanged.connect(frUpdate) # send new value as parameter
self.sliderFilterRange.rangeDone.connect(frUpdate)
self.sliderFilterRange.startValueChanged.connect(frUpdate) # send new value as parameter
self.sliderFilterRange.endValueChanged.connect(frUpdate) # send new value as parameter
self.sliderFilterRange.rangeDone.connect(frUpdate)
# data changed event handler
def updateLayer():
#enableSliders()
for key in self.listWidget1.options:
if self.listWidget1.options[key]:
self.kernelCategory = filterDict[key]
break
self.layer.applyToStack()
self.layer.parentImage.onImageChanged()
self.dataChanged.connect(updateLayer) # TODO 3/12/18 move to setDefaults
# layout
l = QVBoxLayout()
l.setAlignment(Qt.AlignBottom)
l.addWidget(self.listWidget1)
hl8 = QHBoxLayout()
hl8.addWidget(frLabel)
hl8.addWidget(self.sliderFilterRange)
l.addLayout(hl8)
l.setContentsMargins(20, 0, 20, 25) # left, top, right, bottom
self.setLayout(l)
self.setWhatsThis(
"""<b>Gradual neutral filter.</b><br>
It mimics the classical gradual gray filter often used by photographers to darken the sky.<br>
To control the regions of maximum and minimum intensities use the Range slider.
"""
) # end setWhatsThis
self.setDefaults()
def __init__(self,
targetImage=None,
axeSize=500,
layer=None,
parent=None,
mainForm=None):
super().__init__(targetImage=targetImage,
axeSize=axeSize,
layer=layer,
parent=parent,
mainForm=mainForm)
# Brightness curve
cubic = activeCubicSpline(axeSize)
graphicsScene = self.scene()
graphicsScene.addItem(cubic)
graphicsScene.cubicRGB = cubic
cubic.channel = channelValues.RGB
cubic.histImg = self.scene().layer.inputImg().histogram(
size=graphicsScene.axeSize,
bgColor=graphicsScene.bgColor,
chans=[],
mode='Luminosity')
cubic.initFixedPoints()
# Red curve
cubic = activeCubicSpline(axeSize)
graphicsScene.addItem(cubic)
graphicsScene.cubicR = cubic
cubic.channel = channelValues.Red
cubic.histImg = self.scene().layer.inputImg().histogram(
size=graphicsScene.axeSize,
bgColor=graphicsScene.bgColor,
chans=channelValues.Red)
cubic.initFixedPoints()
# Green curve
cubic = activeCubicSpline(axeSize)
graphicsScene.addItem(cubic)
graphicsScene.cubicG = cubic
cubic.channel = channelValues.Green
cubic.histImg = self.scene().layer.inputImg().histogram(
size=graphicsScene.axeSize,
bgColor=graphicsScene.bgColor,
chans=channelValues.Green)
cubic.initFixedPoints()
# Blue curve
cubic = activeCubicSpline(axeSize)
graphicsScene.addItem(cubic)
graphicsScene.cubicB = cubic
cubic.channel = channelValues.Blue
cubic.histImg = self.scene().layer.inputImg().histogram(
size=graphicsScene.axeSize,
bgColor=graphicsScene.bgColor,
chans=channelValues.Blue)
cubic.initFixedPoints()
# set current curve to brightness
graphicsScene.cubicItem = graphicsScene.cubicRGB
graphicsScene.cubicItem.setVisible(True)
# buttons
pushButton1 = QbLUePushButton("Reset Current")
pushButton1.move(100, 20)
pushButton1.adjustSize()
pushButton1.clicked.connect(self.resetCurve)
graphicsScene.addWidget(pushButton1)
pushButton2 = QbLUePushButton("Reset R,G,B")
pushButton2.move(100, 50)
pushButton2.adjustSize()
pushButton2.clicked.connect(self.resetAllCurves)
graphicsScene.addWidget(pushButton2)
# options
options = ['RGB', 'Red', 'Green', 'Blue']
self.listWidget1 = optionsWidget(options=options, exclusive=True)
self.listWidget1.setGeometry(
0, 10,
self.listWidget1.sizeHintForColumn(0) + 5,
self.listWidget1.sizeHintForRow(0) * len(options) + 5)
graphicsScene.addWidget(self.listWidget1)
# selection changed handler
curves = [
graphicsScene.cubicRGB, graphicsScene.cubicR, graphicsScene.cubicG,
graphicsScene.cubicB
]
curveDict = dict(zip(options, curves))
def onSelect1(item):
self.scene().cubicItem.setVisible(False)
self.scene().cubicItem = curveDict[item.text()]
pushButton2.setEnabled(item.text() != 'RGB')
self.scene().cubicItem.setVisible(True)
l = self.scene().layer
l.applyToStack()
l.parentImage.onImageChanged()
# Force redraw histogram
self.scene().invalidate(
QRectF(0.0, -self.scene().axeSize,
self.scene().axeSize,
self.scene().axeSize), QGraphicsScene.BackgroundLayer)
self.listWidget1.onSelect = onSelect1
# set initial selection to RGB
item = self.listWidget1.items[options[0]]
item.setCheckState(Qt.Checked)
self.listWidget1.select(item)
self.setWhatsThis("""<b>RGB curves</b><br>""" + self.whatsThis())
def f():
l = self.scene().layer
l.applyToStack()
l.parentImage.onImageChanged()
self.scene().cubicRGB.curveChanged.sig.connect(f)
self.scene().cubicR.curveChanged.sig.connect(f)
self.scene().cubicG.curveChanged.sig.connect(f)
self.scene().cubicB.curveChanged.sig.connect(f)
def __init__(self, targetImage=None, axeSize=500, layer=None, parent=None):
super().__init__(layer=layer, targetImage=targetImage, parent=parent)
self.setWindowTitle('grabcut')
button0 = QPushButton('Segment')
# button slot
def f():
self.layer.noSegment = False
self.layer.applyToStack()
window.label.img.onImageChanged()
# manual segmentation only
self.layer.noSegment = True
button0.clicked.connect(f)
button1 = QPushButton('Reset')
button1.clicked.connect(self.reset)
self.spBox = QSpinBox()
self.spBox.setRange(1, 10)
# spBox slot
def f2(iterCount):
self.nbIter = self.spBox.value()
self.dataChanged.emit()
self.spBox.valueChanged.connect(f2)
spBoxLabel = QLabel()
spBoxLabel.setText('Iterations')
self.spBox1 = QSpinBox()
self.spBox1.setRange(0, 20)
spBox1Label = QLabel()
spBox1Label.setText('Contour Redo Radius')
# spBox1 slot
def f1(margin):
self.contourMargin = self.spBox1.value()
self.dataChanged.emit()
self.spBox1.valueChanged.connect(f1)
# options
optionList1, optionNames1 = ['Clipping Layer'], ['Clipping Layer']
self.listWidget1 = optionsWidget(
options=optionList1,
optionNames=optionNames1,
exclusive=False,
changed=lambda: self.dataChanged.emit())
self.options = self.listWidget1.options
# option changed slot
def g(item):
self.layer.isClipping = self.options['Clipping Layer']
self.layer.applyToStack()
self.layer.parentImage.onImageChanged()
self.listWidget1.onSelect = g
# layout
hLay = QHBoxLayout()
hLay.addWidget(spBoxLabel)
hLay.addWidget(self.spBox)
hLay.addStretch(1)
hLay1 = QHBoxLayout()
hLay1.addWidget(spBox1Label)
hLay1.addWidget(self.spBox1)
hLay1.addStretch(1)
h2 = QHBoxLayout()
h2.addWidget(self.listWidget1)
vLay = QVBoxLayout()
vLay.setAlignment(Qt.AlignTop)
vLay.setContentsMargins(20, 8, 20, 25) # left, top, right, bottom
vLay.addLayout(hLay)
vLay.addLayout(hLay1)
vLay.addLayout(h2)
h3 = QHBoxLayout()
h3.addWidget(button0)
h3.addWidget(button1)
vLay.addLayout(h3)
self.setLayout(vLay)
self.setDefaults()
self.setWhatsThis(""" <b>Segmentation (Object extraction)</b><br>
Select the object to extract with the rectangle Marquee Tool. Next, press the <i>Segment</i> button.<br>
The background of the segmented image is transparent : to <b>mask the underlying layers</b> check the
option <i>Clipping Layer.</i><br>
To <b>fix the selection</b>, paint eventual misclassed pixels with the foreground (FG) or background (BG) tools.<br>
To <b>redo the segmentation of a region</b> (e.g. a border area) hold down the Ctrl key while painting the area
and press again <i>segment.</i><br>
To <b>redo the segmentation of the whole contour</b> set <i>Contour Redo Radius</i> to a value >= 1 and
press <i>Segment.</i><br>
To <b>smooth the contour</b> right click the layer row in the <i>Layers</i> panel
and choose <i>Smooth Mask</i> from the context menu.<br>
""") # end setWhatsThis
def __init__(self,
targetImage=None,
axeSize=500,
layer=None,
parent=None,
mainForm=None):
super().__init__(parent=parent)
self.tempCorrection = 6500
self.tintCorrection = 1.0
self.setStyleSheet(
'QRangeSlider * {border: 0px; padding: 0px; margin: 0px}')
self.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred)
self.setMinimumSize(axeSize, axeSize)
self.setAttribute(Qt.WA_DeleteOnClose)
# link back to image layer
self.layer = weakProxy(layer)
"""
# using weak ref for back links
if type(layer) in weakref.ProxyTypes:
self.layer = layer
else:
self.layer = weakref.proxy(layer)
"""
self.defaultTemp = sRGBWP # ref temperature D65
self.defaultTint = 0
# options
optionList, optionNames = ['Photo Filter', 'Chromatic Adaptation'
], ['Photo Filter', 'Chromatic Adaptation']
self.listWidget1 = optionsWidget(
options=optionList,
optionNames=optionNames,
exclusive=True,
changed=lambda: self.dataChanged.emit())
self.listWidget1.checkOption(self.listWidget1.intNames[1])
self.options = self.listWidget1.options
# temp slider
self.sliderTemp = QbLUeSlider(Qt.Horizontal)
self.sliderTemp.setStyleSheet(
QbLUeSlider.bLueSliderDefaultIColorStylesheet)
self.sliderTemp.setRange(
17, 100
) # 250) # valid range for spline approximation is 1667..25000, cf. colorConv.temperature2xyWP
self.sliderTemp.setSingleStep(1)
tempLabel = QbLUeLabel()
tempLabel.setMaximumSize(150, 30)
tempLabel.setText("Color temperature")
tempLabel.doubleClicked.connect(lambda: self.sliderTemp.setValue(
self.temp2Slider(self.defaultTemp)))
self.tempValue = QLabel()
font = self.tempValue.font()
metrics = QFontMetrics(font)
w = metrics.width("0000")
h = metrics.height()
self.tempValue.setMinimumSize(w, h)
self.tempValue.setMaximumSize(w, h)
self.tempValue.setText(
str("{:d}".format(self.sliderTemp2User(self.sliderTemp.value()))))
# tint slider
self.sliderTint = QbLUeSlider(Qt.Horizontal)
self.sliderTint.setStyleSheet(
QbLUeSlider.bLueSliderDefaultMGColorStylesheet)
self.sliderTint.setRange(
0, 100
) # 250) # valid range for spline approximation is 1667..25000, cf. colorConv.temperature2xyWP
self.sliderTint.setSingleStep(1)
tintLabel = QbLUeLabel()
tintLabel.setMaximumSize(150, 30)
tintLabel.setText("Tint")
tintLabel.doubleClicked.connect(lambda: self.sliderTint.setValue(
self.tint2Slider(self.defaultTint)))
self.tintValue = QLabel()
font = self.tintValue.font()
metrics = QFontMetrics(font)
w = metrics.width("0000")
h = metrics.height()
self.tintValue.setMinimumSize(w, h)
self.tintValue.setMaximumSize(w, h)
self.tintValue.setText(
str("{:d}".format(self.sliderTint2User(self.sliderTint.value()))))
# temp change event handler
def tempUpdate(value):
self.tempValue.setText(
str("{:d}".format(self.sliderTemp2User(value))))
# move not yet terminated or values not modified
if self.sliderTemp.isSliderDown() or self.slider2Temp(
value) == self.tempCorrection:
return
self.sliderTemp.valueChanged.disconnect()
self.sliderTemp.sliderReleased.disconnect()
self.tempCorrection = self.slider2Temp(value)
self.dataChanged.emit()
self.sliderTemp.valueChanged.connect(tempUpdate)
self.sliderTemp.sliderReleased.connect(
lambda: tempUpdate(self.sliderTemp.value()))
# tint change event handler
def tintUpdate(value):
self.tintValue.setText(
str("{:d}".format(self.sliderTint2User(value))))
# move not yet terminated or values not modified
if self.sliderTint.isSliderDown() or self.slider2Tint(
value) == self.tintCorrection:
return
self.sliderTint.valueChanged.disconnect()
self.sliderTint.sliderReleased.disconnect()
self.tintCorrection = self.slider2Tint(value)
self.dataChanged.emit()
self.sliderTint.valueChanged.connect(tintUpdate)
self.sliderTint.sliderReleased.connect(
lambda: tintUpdate(self.sliderTint.value()))
self.sliderTemp.valueChanged.connect(tempUpdate)
self.sliderTemp.sliderReleased.connect(
lambda: tempUpdate(self.sliderTemp.value()))
self.sliderTint.valueChanged.connect(tintUpdate)
self.sliderTint.sliderReleased.connect(
lambda: tintUpdate(self.sliderTint.value()))
# layout
l = QVBoxLayout()
l.setAlignment(Qt.AlignTop)
l.addWidget(self.listWidget1)
l.addWidget(tempLabel)
hl = QHBoxLayout()
hl.addWidget(self.tempValue)
hl.addWidget(self.sliderTemp)
l.addLayout(hl)
l.addWidget(tintLabel)
hl1 = QHBoxLayout()
hl1.addWidget(self.tintValue)
hl1.addWidget(self.sliderTint)
l.addLayout(hl1)
self.setLayout(l)
self.adjustSize()
self.dataChanged.connect(
self.updateLayer) # TODO move to setDefaults 3/12/18
self.setStyleSheet("QListWidget, QLabel {font : 7pt;}")
self.setDefaults()
self.setWhatsThis("""<b>Color Temperature</b><br>
<b>Photo Filter</b> uses the multiply blending mode to mimic a color filter
in front of the camera lens.<br>
<b>Chromatic Adaptation</b> uses multipliers in the linear sRGB
color space to adjust <b>temperature</b> and <b>tint</b>.
""") # end of setWhatsThis
def __init__(self, targetImage=None, axeSize=500, layer=None, parent=None):
super().__init__(layer=layer, targetImage=targetImage, parent=parent)
# connect layer selectionChanged signal
self.layer.selectionChanged.sig.connect(self.updateLayer)
self.kernelCategory = filterIndex.UNSHARP
# options
self.optionList = [
'Unsharp Mask', 'Sharpen', 'Gaussian Blur', 'Surface Blur'
]
filters = [
filterIndex.UNSHARP, filterIndex.SHARPEN, filterIndex.BLUR1,
filterIndex.SURFACEBLUR
]
self.filterDict = dict(
zip(self.optionList,
filters)) # filters is not a dict: don't use UDict here
self.listWidget1 = optionsWidget(options=self.optionList,
exclusive=True,
changed=self.dataChanged)
# set initial selection to unsharp mask
self.listWidget1.checkOption(self.optionList[0])
# sliders
self.sliderRadius = QbLUeSlider(Qt.Horizontal)
self.sliderRadius.setRange(1, 50)
self.sliderRadius.setSingleStep(1)
self.radiusLabel = QLabel()
self.radiusLabel.setMaximumSize(150, 30)
self.radiusLabel.setText("Radius")
self.radiusValue = QLabel()
font = self.radiusValue.font()
metrics = QFontMetrics(font)
w = metrics.width("1000 ")
h = metrics.height()
self.radiusValue.setMinimumSize(w, h)
self.radiusValue.setMaximumSize(w, h)
self.sliderAmount = QbLUeSlider(Qt.Horizontal)
self.sliderAmount.setRange(0, 100)
self.sliderAmount.setSingleStep(1)
self.amountLabel = QLabel()
self.amountLabel.setMaximumSize(150, 30)
self.amountLabel.setText("Amount")
self.amountValue = QLabel()
font = self.radiusValue.font()
metrics = QFontMetrics(font)
w = metrics.width("1000 ")
h = metrics.height()
self.amountValue.setMinimumSize(w, h)
self.amountValue.setMaximumSize(w, h)
self.toneValue = QLabel()
self.toneLabel = QLabel()
self.toneLabel.setMaximumSize(150, 30)
self.toneLabel.setText("Sigma")
self.sliderTone = QbLUeSlider(Qt.Horizontal)
self.sliderTone.setRange(0, 100)
self.sliderTone.setSingleStep(1)
font = self.radiusValue.font()
metrics = QFontMetrics(font)
w = metrics.width("1000 ")
h = metrics.height()
self.toneValue.setMinimumSize(w, h)
self.toneValue.setMaximumSize(w, h)
# value change/done slot
def formUpdate():
self.radiusValue.setText(str('%d ' % self.sliderRadius.value()))
self.amountValue.setText(str('%d ' % self.sliderAmount.value()))
self.toneValue.setText(str('%d ' % self.sliderTone.value()))
if self.sliderRadius.isSliderDown(
) or self.sliderAmount.isSliderDown(
) or self.sliderTone.isSliderDown():
return
try:
for slider in [
self.sliderRadius, self.sliderAmount, self.sliderTone
]:
slider.valueChanged.disconnect()
slider.sliderReleased.disconnect()
except RuntimeError:
pass
self.tone = self.sliderTone.value()
self.radius = self.sliderRadius.value()
self.amount = self.sliderAmount.value()
self.dataChanged.emit()
for slider in [
self.sliderRadius, self.sliderAmount, self.sliderTone
]:
slider.valueChanged.connect(formUpdate)
slider.sliderReleased.connect(formUpdate)
for slider in [self.sliderRadius, self.sliderAmount, self.sliderTone]:
slider.valueChanged.connect(formUpdate)
slider.sliderReleased.connect(formUpdate)
# layout
l = QVBoxLayout()
l.addWidget(self.listWidget1)
hl = QHBoxLayout()
hl.addWidget(self.radiusLabel)
hl.addWidget(self.radiusValue)
hl.addWidget(self.sliderRadius)
l.addLayout(hl)
hl = QHBoxLayout()
hl.addWidget(self.amountLabel)
hl.addWidget(self.amountValue)
hl.addWidget(self.sliderAmount)
l.addLayout(hl)
hl = QHBoxLayout()
hl.addWidget(self.toneLabel)
hl.addWidget(self.toneValue)
hl.addWidget(self.sliderTone)
l.addLayout(hl)
l.setContentsMargins(20, 0, 20, 25) # left, top, right, bottom
self.setLayout(l)
self.setDefaults()
self.setWhatsThis("""
<b>Unsharp Mask</b> and <b>Sharpen Mask</b> are used to sharpen an image.
Unsharp Mask usually gives best results.<br>
<b>Gaussian Blur</b> and <b>Surface Blur</b> are used to blur an image.<br>
In contrast to Gaussian Blur, Surface Blur preserves edges and reduces noise,
but it may be slow.<br>
It is possible to <b>limit the effect of a filter to a rectangular region of the image</b> by
drawing a selection rectangle on the layer with the marquee (rectangle) tool.<br>
Ctrl Click <b>clears the selection</b><br>
""") # end setWhatsThis
def __init__(self, targetImage=None, axeSize=500, layer=None, parent=None):
super().__init__(layer=layer, targetImage=targetImage, parent=parent)
self.setMinimumSize(axeSize, axeSize + 100)
# contrast spline viewer
self.contrastForm = None
# options
optionList1, optionNames1 = ['Multi-Mode',
'CLAHE'], ['Multi-Mode', 'CLAHE']
self.listWidget1 = optionsWidget(
options=optionList1,
optionNames=optionNames1,
exclusive=True,
changed=lambda: self.dataChanged.emit())
self.listWidget1.checkOption(self.listWidget1.intNames[0])
self.listWidget1.setStyleSheet(
"QListWidget {border: 0px;} QListWidget::item {border: 0px; padding-left: 0px;}"
)
optionList2, optionNames2 = ['High', 'manualCurve'], [
'Preserve Highlights', 'Show Contrast Curve'
]
def optionList2Change(item):
if item.internalName == 'High':
# force to recalculate the spline
self.layer.autoSpline = True
self.dataChanged.emit()
self.listWidget2 = optionsWidget(options=optionList2,
optionNames=optionNames2,
exclusive=False,
changed=optionList2Change)
self.listWidget2.checkOption(self.listWidget2.intNames[0])
self.listWidget2.setStyleSheet(
"QListWidget {border: 0px;} QListWidget::item {border: 0px; padding-left: 0px;}"
)
self.options = UDict(
(self.listWidget1.options, self.listWidget2.options))
# contrast slider
self.sliderContrast = QbLUeSlider(Qt.Horizontal)
self.sliderContrast.setStyleSheet(
QbLUeSlider.bLueSliderDefaultIBWStylesheet)
self.sliderContrast.setRange(0, 10)
self.sliderContrast.setSingleStep(1)
contrastLabel = QbLUeLabel()
contrastLabel.setMaximumSize(150, 30)
contrastLabel.setText("Contrast Level")
contrastLabel.doubleClicked.connect(
lambda: self.sliderContrast.setValue(
self.contrast2Slider(self.contrastDefault)))
self.contrastValue = QLabel()
font = self.contrastValue.font()
metrics = QFontMetrics(font)
w = metrics.width("100")
h = metrics.height()
self.contrastValue.setMinimumSize(w, h)
self.contrastValue.setMaximumSize(w, h)
self.contrastValue.setText(
str("{:d}".format(self.sliderContrast.value())))
# contrast changed event handler.
def contrastUpdate(value):
self.contrastValue.setText(
str("{:d}".format(self.sliderContrast.value())))
# move not yet terminated or value not modified
if self.sliderContrast.isSliderDown() or self.slider2Contrast(
value) == self.contrastCorrection:
return
self.sliderContrast.valueChanged.disconnect()
self.sliderContrast.sliderReleased.disconnect()
self.contrastCorrection = self.slider2Contrast(
self.sliderContrast.value())
# force to recalculate the spline
self.layer.autoSpline = True
self.dataChanged.emit()
self.sliderContrast.valueChanged.connect(contrastUpdate)
self.sliderContrast.sliderReleased.connect(
lambda: contrastUpdate(self.sliderContrast.value()))
self.sliderContrast.valueChanged.connect(contrastUpdate)
self.sliderContrast.sliderReleased.connect(
lambda: contrastUpdate(self.sliderContrast.value()))
# saturation slider
self.sliderSaturation = QbLUeSlider(Qt.Horizontal)
self.sliderSaturation.setStyleSheet(
QbLUeSlider.bLueSliderDefaultColorStylesheet)
self.sliderSaturation.setRange(0, 100)
self.sliderSaturation.setSingleStep(1)
saturationLabel = QbLUeLabel()
saturationLabel.setMaximumSize(150, 30)
saturationLabel.setText("Saturation")
saturationLabel.doubleClicked.connect(
lambda: self.sliderSaturation.setValue(
self.saturation2Slider(self.saturationDefault)))
self.saturationValue = QLabel()
font = self.saturationValue.font()
metrics = QFontMetrics(font)
w = metrics.width("100")
h = metrics.height()
self.saturationValue.setMinimumSize(w, h)
self.saturationValue.setMaximumSize(w, h)
self.saturationValue.setText(
str("{:+d}".format(self.sliderContrast.value())))
# saturation changed event handler
def saturationUpdate(value):
self.saturationValue.setText(
str("{:+d}".format(
int(
self.slidersaturation2User(
self.sliderSaturation.value())))))
# move not yet terminated or value not modified
if self.sliderSaturation.isSliderDown() or self.slider2Saturation(
value) == self.satCorrection:
return
self.sliderSaturation.valueChanged.disconnect()
self.sliderSaturation.sliderReleased.disconnect()
self.satCorrection = self.slider2Saturation(
self.sliderSaturation.value())
self.dataChanged.emit()
self.sliderSaturation.valueChanged.connect(saturationUpdate)
self.sliderSaturation.sliderReleased.connect(
lambda: saturationUpdate(self.sliderSaturation.value()))
self.sliderSaturation.valueChanged.connect(saturationUpdate)
self.sliderSaturation.sliderReleased.connect(
lambda: saturationUpdate(self.sliderSaturation.value()))
# brightness slider
self.sliderBrightness = QbLUeSlider(Qt.Horizontal)
self.sliderBrightness.setStyleSheet(
QbLUeSlider.bLueSliderDefaultBWStylesheet)
self.sliderBrightness.setRange(0, 100)
self.sliderBrightness.setSingleStep(1)
brightnessLabel = QbLUeLabel()
brightnessLabel.setMaximumSize(150, 30)
brightnessLabel.setText("Brightness")
brightnessLabel.doubleClicked.connect(
lambda: self.sliderBrightness.setValue(
self.brightness2Slider(self.brightnessDefault)))
self.brightnessValue = QLabel()
font = self.brightnessValue.font()
metrics = QFontMetrics(font)
w = metrics.width("100")
h = metrics.height()
self.brightnessValue.setMinimumSize(w, h)
self.brightnessValue.setMaximumSize(w, h)
self.brightnessValue.setText(
str("{:+d}".format(self.sliderContrast.value())))
# brightness changed event handler
def brightnessUpdate(value):
self.brightnessValue.setText(
str("{:+d}".format(
int(
self.sliderBrightness2User(
self.sliderBrightness.value())))))
# move not yet terminated or value not modified
if self.sliderBrightness.isSliderDown() or self.slider2Brightness(
value) == self.brightnessCorrection:
return
self.sliderBrightness.valueChanged.disconnect()
self.sliderBrightness.sliderReleased.disconnect()
self.brightnessCorrection = self.slider2Brightness(
self.sliderBrightness.value())
self.dataChanged.emit()
self.sliderBrightness.valueChanged.connect(brightnessUpdate)
self.sliderBrightness.sliderReleased.connect(
lambda: brightnessUpdate(self.sliderBrightness.value()))
self.sliderBrightness.valueChanged.connect(brightnessUpdate)
self.sliderBrightness.sliderReleased.connect(
lambda: brightnessUpdate(self.sliderBrightness.value()))
# attributes initialized in setDefaults, declared here
# for the sake of correctness
self.contrastCorrection = None # range
self.satCorrection = None # range -0.5..0.5
self.brightnessCorrection = None # range -0.5..0.5
# layout
l = QVBoxLayout()
l.setAlignment(Qt.AlignTop)
gb1 = QGroupBox()
gb1.setStyleSheet(
"QGroupBox {border: 1px solid gray; border-radius: 4px}")
l1 = QVBoxLayout()
ct = QLabel()
ct.setText('Contrast')
l.setAlignment(Qt.AlignTop)
l1.addWidget(ct)
l1.addWidget(self.listWidget1)
gb1.setLayout(l1)
l.addWidget(gb1)
l.addWidget(self.listWidget2)
l.addWidget(contrastLabel)
hl = QHBoxLayout()
hl.addWidget(self.contrastValue)
hl.addWidget(self.sliderContrast)
l.addLayout(hl)
l.addWidget(brightnessLabel)
hl3 = QHBoxLayout()
hl3.addWidget(self.brightnessValue)
hl3.addWidget(self.sliderBrightness)
l.addLayout(hl3)
l.addWidget(saturationLabel)
hl2 = QHBoxLayout()
hl2.addWidget(self.saturationValue)
hl2.addWidget(self.sliderSaturation)
l.addLayout(hl2)
self.setLayout(l)
self.adjustSize()
self.setStyleSheet("QListWidget, QLabel {font : 7pt;}")
self.setDefaults()
self.setWhatsThis("""<b>Contrast Brightness Saturation</b><br>
<b>Contrast</b> is enhanced using one of these two methods:<br>
- <b>CLAHE</b> : increases the local contrast.<br>
- <b>Multi-Mode</b> : increases the local contrast and the contrast between regions of the image.<br>
For both methods the contrast slider controls the level of the correction.<br>
With Multi-Mode enabled, use the option <b>Show Contrast Curve</b> to edit the correction curve and check
<b>Preserve Highlights</b> for softer highlights.<br>
<b>Brightness</b> and <b>Saturation</b> corrections are non linear to limit clipping.<br>
Sliders are <b>reset</b> to their default value by double clicking the name of the slider.<br>
""") # end setWhatsThis
def __init__(self, targetImage=None, axeSize=500, layer=None, parent=None, mainForm=None):
super().__init__(targetImage=targetImage, axeSize=axeSize, layer=layer, parent=parent, mainForm=mainForm)
graphicsScene = self.scene()
#########
# L curve
#########
cubic = activeCubicSpline(axeSize)
graphicsScene.addItem(cubic)
graphicsScene.cubicR = cubic
cubic.channel = channelValues.L
# get histogram as a Qimage
cubic.histImg = graphicsScene.layer.inputImg().histogram(size=graphicsScene.axeSize,
bgColor=graphicsScene.bgColor, range=(0, 1),
chans=channelValues.L, mode='Lab')
# L curve use the default axes
cubic.axes = graphicsScene.defaultAxes
cubic.initFixedPoints()
cubic.axes.setVisible(False)
cubic.setVisible(False)
##########
# a curve (Green--> Magenta axis)
#########
cubic = activeCubicSpline(axeSize)
graphicsScene.addItem(cubic)
graphicsScene.cubicG = cubic
cubic.channel = channelValues.a
cubic.histImg = graphicsScene.layer.inputImg().histogram(size=graphicsScene.axeSize,
bgColor=graphicsScene.bgColor, range=(-100, 100),
chans=channelValues.a, mode='Lab')
# add specific axes
gradient = QRadialGradient()
gradient.setCenter(QPoint(0, 1))
gradient.setRadius(axeSize*1.4)
gradient.setColorAt(0.0, Qt.green)
gradient.setColorAt(1.0, Qt.magenta)
cubic.axes = self.drawPlotGrid(axeSize, gradient)
graphicsScene.addItem(cubic.axes)
cubic.initFixedPoints()
cubic.axes.setVisible(False)
cubic.setVisible(False)
# b curve (Blue-->Yellow axis)
cubic = activeCubicSpline(axeSize)
graphicsScene.addItem(cubic)
graphicsScene.cubicB = cubic
cubic.channel = channelValues.b
cubic.histImg = graphicsScene.layer.inputImg().histogram(size=graphicsScene.axeSize,
bgColor=graphicsScene.bgColor, range=(-100, 100),
chans=channelValues.b, mode='Lab')
# add specific axes
gradient.setColorAt(0.0, Qt.blue)
gradient.setColorAt(1.0, Qt.yellow)
cubic.axes = self.drawPlotGrid(axeSize, gradient)
graphicsScene.addItem(cubic.axes)
cubic.initFixedPoints()
cubic.axes.setVisible(False)
cubic.setVisible(False)
# set current to L curve and axes
graphicsScene.cubicItem = graphicsScene.cubicR
graphicsScene.cubicItem.setVisible(True)
graphicsScene.cubicItem.axes.setVisible(True)
# buttons
pushButton1 = QPushButton("Reset Current")
pushButton1.move(100, 20)
pushButton1.adjustSize()
pushButton1.clicked.connect(self.resetCurve)
graphicsScene.addWidget(pushButton1)
pushButton2 = QPushButton("Reset All")
pushButton2.move(100, 50)
pushButton2.adjustSize()
pushButton2.clicked.connect(self.resetAllCurves)
graphicsScene.addWidget(pushButton2)
# options
options = ['L', 'a', 'b']
self.listWidget1 = optionsWidget(options=options, exclusive=True)
self.listWidget1.setGeometry(0, 10, self.listWidget1.sizeHintForColumn(0) + 5, self.listWidget1.sizeHintForRow(0) * len(options) + 5)
graphicsScene.addWidget(self.listWidget1)
# selection changed handler
curves = [graphicsScene.cubicR, graphicsScene.cubicG, graphicsScene.cubicB]
curveDict = dict(zip(options, curves))
def onSelect1(item):
cubicItem = self.scene().cubicItem
cubicItem.setVisible(False)
cubicItem.axes.setVisible(False)
self.scene().cubicItem = curveDict[item.text()]
self.scene().cubicItem.setVisible(True)
self.scene().cubicItem.axes.setVisible(True)
# Force to redraw histogram
self.scene().invalidate(QRectF(0.0, -self.scene().axeSize, self.scene().axeSize, self.scene().axeSize),
QGraphicsScene.BackgroundLayer)
self.listWidget1.onSelect = onSelect1
# set initial selection to L
item = self.listWidget1.items[options[0]]
item.setCheckState(Qt.Checked)
self.listWidget1.select(item)
self.setWhatsThis("""<b>Lab curves</b><br>""" + self.whatsThis())
def f():
l = graphicsScene.layer
l.applyToStack()
l.parentImage.onImageChanged()
self.scene().cubicR.curveChanged.sig.connect(f)
self.scene().cubicG.curveChanged.sig.connect(f)
self.scene().cubicB.curveChanged.sig.connect(f)
def __init__(self, targetImage=None, axeSize=500, layer=None, parent=None, colorModel='HSV'):
super().__init__(targetImage=targetImage, axeSize=axeSize, layer=layer, parent=parent)
graphicsScene = self.scene()
graphicsScene.colorModel = colorModel
# hue curve init.
cubic = activeCubicSpline(axeSize)
graphicsScene.addItem(cubic)
graphicsScene.cubicR = cubic
cubic.channel = channelValues.Hue
cubic.initFixedPoints()
# sat curve init.
cubic = activeCubicSpline(axeSize)
graphicsScene.addItem(cubic)
graphicsScene.cubicG = cubic
cubic.channel = channelValues.Sat
cubic.initFixedPoints()
# brightness curve init.
cubic = activeCubicSpline(axeSize)
graphicsScene.addItem(cubic)
graphicsScene.cubicB = cubic
cubic.channel = channelValues.Br
cubic.initFixedPoints()
# init histograms
self.updateHists()
# set current curve to sat
graphicsScene.cubicItem = graphicsScene.cubicG
graphicsScene.cubicItem.setVisible(True)
# buttons
pushButton1 = QPushButton("Reset Current")
pushButton1.clicked.connect(self.resetCurve)
pushButton2 = QPushButton("Reset All")
pushButton2.clicked.connect(self.resetAllCurves)
# options
options = ['H', 'S', 'B']
self.listWidget1 = optionsWidget(options=options, exclusive=True)
self.listWidget1.setGeometry(0, 0, self.listWidget1.sizeHintForColumn(0) + 5,
self.listWidget1.sizeHintForRow(0) * len(options) + 5)
# selection changed handler
curves = [graphicsScene.cubicR, graphicsScene.cubicG, graphicsScene.cubicB]
curveDict = dict(zip(options, curves))
def onSelect1(item):
self.scene().cubicItem.setVisible(False)
self.scene().cubicItem = curveDict[item.text()]
self.scene().cubicItem.setVisible(True)
# draw histogram
self.scene().invalidate(QRectF(0.0, -self.scene().axeSize, self.scene().axeSize,
self.scene().axeSize), QGraphicsScene.BackgroundLayer)
self.listWidget1.onSelect = onSelect1
# set initial selection to Saturation
item = self.listWidget1.items[options[1]]
item.setCheckState(Qt.Checked)
self.listWidget1.select(item)
# layout
gl = QGridLayout()
gl.addWidget(self.listWidget1, 0, 0, 2, 1)
for i, button in enumerate([pushButton1, pushButton2]):
gl.addWidget(button, i, 1)
self.addCommandLayout(gl)
self.setWhatsThis("""<b>HSV curves</b><br>""" + self.whatsThis())
def f():
layer = graphicsScene.layer
layer.applyToStack()
layer.parentImage.onImageChanged()
self.scene().cubicR.curveChanged.sig.connect(f)
self.scene().cubicG.curveChanged.sig.connect(f)
self.scene().cubicB.curveChanged.sig.connect(f)
def __init__(self, targetImage=None, axeSize=500, layer=None, parent=None):
super().__init__(layer=layer, targetImage=targetImage, parent=parent)
self.defaultFilterStart = 0
self.defaultFilterEnd = 99
self.filterStart = self.defaultFilterStart
self.filterEnd = self.defaultFilterEnd
self.kernelCategory = blendFilterIndex.GRADUALNONE # TODO kernelCategory should be renamed as filterIndex 5/12/18
# options
optionList, optionNames = ['Gradual Top', 'Gradual Bottom'], ['Top To Bottom', 'Bottom To Top']
filters = [blendFilterIndex.GRADUALTB, blendFilterIndex.GRADUALBT] # , blendFilterIndex.GRADUALNONE]
self.filterDict = dict(zip(optionList, filters))
self.listWidget1 = optionsWidget(options=optionList, optionNames=optionNames, exclusive=True,
changed=self.dataChanged)
# set initial selection to gradual top
self.listWidget1.checkOption(optionList[0])
rs = QRangeSlider()
rs.setMaximumSize(16000, 10)
rs.tail.setStyleSheet(
'background: white; /*qlineargradient(x1:0, y1:0, x2:1, y2:0, stop:0 #222, stop:1 #888); margin 3px;*/')
rs.handle.setStyleSheet('background: qlineargradient(x1:0, y1:0, x2:1, y2:0, stop:0 black, stop:1 white);')
rs.head.setStyleSheet(
'background: black; /*qlineargradient(x1:0, y1:0, x2:1, y2:0, stop:0 #999, stop:1 #222);*/')
self.sliderFilterRange = rs
frLabel = QLabel('Range')
# filter range done event handler
def frUpdate(start, end):
if self.sliderFilterRange.isSliderDown() or (start == self.filterStart and end == self.filterEnd):
return
try:
self.sliderFilterRange.startValueChanged.disconnect()
self.sliderFilterRange.endValueChanged.disconnect()
self.sliderFilterRange.rangeDone.disconnect()
except RuntimeError:
pass
self.filterStart, self.filterEnd = self.sliderFilterRange.getRange()
self.dataChanged.emit()
self.sliderFilterRange.startValueChanged.connect(frUpdate) # send new value as parameter
self.sliderFilterRange.endValueChanged.connect(frUpdate) # send new value as parameter
self.sliderFilterRange.rangeDone.connect(frUpdate)
self.sliderFilterRange.startValueChanged.connect(frUpdate) # send new value as parameter
self.sliderFilterRange.endValueChanged.connect(frUpdate) # send new value as parameter
self.sliderFilterRange.rangeDone.connect(frUpdate)
# layout
l = QVBoxLayout()
l.addWidget(self.listWidget1)
hl8 = QHBoxLayout()
hl8.addWidget(frLabel)
hl8.addWidget(self.sliderFilterRange)
l.addLayout(hl8)
l.setContentsMargins(20, 0, 20, 25) # left, top, right, bottom
self.setLayout(l)
self.setWhatsThis(
"""<b>Gradual neutral filter.</b><br>
It mimics the classical gradual gray filter often used by
photographers to darken the sky.<br>
To control the regions of maximum and minimum intensities use the Range slider.
"""
) # end setWhatsThis
self.setDefaults()
def __init__(self, targetImage=None, axeSize=500, layer=None, parent=None):
super().__init__(layer=layer, targetImage=targetImage, parent=parent)
self.tempCorrection = 6500
self.tintCorrection = 1.0
self.defaultTemp = sRGBWP # ref temperature D65
self.defaultTint = 0
# options
optionList, optionNames = ['Photo Filter', 'Chromatic Adaptation'
], ['Photo Filter', 'Chromatic Adaptation']
self.listWidget1 = optionsWidget(
options=optionList,
optionNames=optionNames,
exclusive=True,
changed=lambda: self.dataChanged.emit())
self.listWidget1.checkOption(self.listWidget1.intNames[1])
self.options = self.listWidget1.options
# temp slider
self.sliderTemp = QbLUeSlider(Qt.Horizontal)
self.sliderTemp.setStyleSheet(
QbLUeSlider.bLueSliderDefaultIColorStylesheet)
self.sliderTemp.setRange(
17, 100
) # 250) # valid range for spline approximation is 1667..25000, cf. colorConv.temperature2xyWP
self.sliderTemp.setSingleStep(1)
tempLabel = QbLUeLabel()
tempLabel.setMaximumSize(150, 30)
tempLabel.setText("Filter Temperature")
tempLabel.doubleClicked.connect(lambda: self.sliderTemp.setValue(
self.temp2Slider(self.defaultTemp)))
self.tempValue = QLabel()
font = self.tempValue.font()
metrics = QFontMetrics(font)
w = metrics.width("00000")
h = metrics.height()
self.tempValue.setMinimumSize(w, h)
self.tempValue.setMaximumSize(w, h)
self.tempValue.setText(
str("{:d}".format(self.sliderTemp2User(self.sliderTemp.value()))))
# tint slider
self.sliderTint = QbLUeSlider(Qt.Horizontal)
self.sliderTint.setStyleSheet(
QbLUeSlider.bLueSliderDefaultMGColorStylesheet)
self.sliderTint.setRange(
0, 100
) # 250) # valid range for spline approximation is 1667..25000, cf. colorConv.temperature2xyWP
self.sliderTint.setSingleStep(1)
self.tintLabel = QbLUeLabel()
self.tintLabel.setMaximumSize(150, 30)
self.tintLabel.setText("Tint")
self.tintLabel.doubleClicked.connect(lambda: self.sliderTint.setValue(
self.tint2Slider(self.defaultTint)))
self.tintValue = QLabel()
font = self.tintValue.font()
metrics = QFontMetrics(font)
w = metrics.width("0000")
h = metrics.height()
self.tintValue.setMinimumSize(w, h)
self.tintValue.setMaximumSize(w, h)
self.tintValue.setText(
str("{:d}".format(self.sliderTint2User(self.sliderTint.value()))))
# temp change slot
def tempUpdate(value):
self.tempValue.setText(
str("{:d}".format(self.sliderTemp2User(value))))
# move not yet terminated or values not modified
if self.sliderTemp.isSliderDown() or self.slider2Temp(
value) == self.tempCorrection:
return
try:
self.sliderTemp.valueChanged.disconnect()
self.sliderTemp.sliderReleased.disconnect()
except RuntimeError:
pass
self.tempCorrection = self.slider2Temp(value)
self.dataChanged.emit()
self.sliderTemp.valueChanged.connect(tempUpdate)
self.sliderTemp.sliderReleased.connect(
lambda: tempUpdate(self.sliderTemp.value()))
# tint change slot
def tintUpdate(value):
self.tintValue.setText(
str("{:d}".format(self.sliderTint2User(value))))
# move not yet terminated or values not modified
if self.sliderTint.isSliderDown() or self.slider2Tint(
value) == self.tintCorrection:
return
try:
self.sliderTint.valueChanged.disconnect()
self.sliderTint.sliderReleased.disconnect()
except RuntimeError:
pass
self.tintCorrection = self.slider2Tint(value)
self.dataChanged.emit()
self.sliderTint.valueChanged.connect(tintUpdate)
self.sliderTint.sliderReleased.connect(
lambda: tintUpdate(self.sliderTint.value()))
self.sliderTemp.valueChanged.connect(tempUpdate)
self.sliderTemp.sliderReleased.connect(
lambda: tempUpdate(self.sliderTemp.value()))
self.sliderTint.valueChanged.connect(tintUpdate)
self.sliderTint.sliderReleased.connect(
lambda: tintUpdate(self.sliderTint.value()))
# layout
l = QVBoxLayout()
l.setAlignment(Qt.AlignTop)
l.addWidget(self.listWidget1)
l.addWidget(tempLabel)
hl = QHBoxLayout()
hl.addWidget(self.tempValue)
hl.addWidget(self.sliderTemp)
l.addLayout(hl)
l.addWidget(self.tintLabel)
hl1 = QHBoxLayout()
hl1.addWidget(self.tintValue)
hl1.addWidget(self.sliderTint)
l.addLayout(hl1)
self.setLayout(l)
self.adjustSize()
self.setDefaults()
self.setWhatsThis("""<b>Color Temperature</b><br>
<b>Photo Filter</b> uses the multiply blending mode to mimic a warming or cooling filter
put in front of the camera lens. The luminosity of the resulting image is corrected.<br>
<b>Chromatic Adaptation</b> uses multipliers in the linear sRGB
color space to adjust <b>temperature</b> and <b>tint</b>.
""") # end of setWhatsThis
def __init__(self, cModel, targetImage=None, axeSize=500, LUTSize=LUTSIZE, layer=None, parent=None, mainForm=None):
"""
@param cModel: color space used by colorPicker, slider2D and colorPicker
@type cModel: cmConverter object
@param axeSize: size of the color wheel
@type axeSize: int
@param targetImage:
@type targetImage: imImage
@param LUTSize:
@type LUTSize: int
@param layer: layer of targetImage linked to graphics form
@type layer : QLayer
@param parent:
@type parent:
"""
super().__init__(targetImage=targetImage, layer=layer, parent=parent)
self.mainForm = mainForm # used by saveLUT()
# context help tag
self.helpId = "LUT3DForm"
self.cModel = cModel
border = 20
self.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred)
self.setMinimumSize(axeSize + 90, axeSize + 250)
self.setAttribute(Qt.WA_DeleteOnClose)
self.setBackgroundBrush(QBrush(Qt.black, Qt.SolidPattern))
self.currentHue, self.currentSat, self.currentPb = 0, 0, self.defaultColorWheelBr
self.currentR, self.currentG, self.currentB = 0, 0, 0
self.size = axeSize
# currently selected grid node
self.selected = None
# init LUT
freshLUT3D = LUT3D(None, size=LUTSize, alpha=True)
self.graphicsScene.lut = freshLUT3D
# init 2D slider (color wheel)
swatchImg = hueSatPattern(axeSize, axeSize, cModel, bright=self.defaultColorWheelBr, border=border)
slider2D = colorChooser(cModel, swatchImg, target=self.targetImage, size=axeSize, border=border)
#########################################################################
# CAUTION : sliedr2D has a non null offset
# slider2D (and QImg) topleft corner is at scene pos -slider2D.offset()
#########################################################################
self.graphicsScene.addItem(slider2D)
self.graphicsScene.slider2D = slider2D
##############################
# neutral and working markers
##############################
offset = slider2D.offset()
neutralMarker = activeMarker.fromCross(parent=slider2D)
neutralMarker.setPos(swatchImg.width() / 2 + offset.x(), swatchImg.height() / 2 + offset.y())
self.workingMarker = activeMarker.fromCross(parent=slider2D)
# default pos: average skin tone
pt = QPointF(*swatchImg.GetPoint(*rgb2hsB(*cmyk2rgb(6, 25, 30, 0))[:2])) + offset
self.workingMarker.setPos(pt.x(), pt.y())
self.workingMarker.onMouseMove = lambda e, x, y: self.displayStatus()
# swatch event handler
def f1(p, r, g, b):
h, s, br = self.cModel.rgb2cm(r, g, b)
self.currentHue, self.currentSat, self.currentPb = h, s, br
self.currentR, self.currentG, self.currentB = r, g, b
self.bSliderUpdate()
self.displayStatus()
self.graphicsScene.slider2D.onMouseRelease = f1
# Brightness slider
self.bSliderHeight = 20
self.bSliderWidth = self.graphicsScene.slider2D.QImg.width()
px = brightnessPattern(self.bSliderWidth, self.bSliderHeight, cModel, self.currentHue, self.currentSat).rPixmap
self.graphicsScene.bSlider = QGraphicsPixmapItem(px, parent=self.graphicsScene.slider2D)
self.graphicsScene.bSlider.setPos(QPointF(-border, self.graphicsScene.slider2D.QImg.height() - border))
bSliderCursor = activeMarker.fromTriangle(parent=self.graphicsScene.bSlider)
bSliderCursor.setMoveRange(QRectF(0.0, bSliderCursor.size, self.graphicsScene.bSlider.pixmap().width(), 0.0))
bSliderCursor.setPos(self.graphicsScene.bSlider.pixmap().width() * self.defaultColorWheelBr, bSliderCursor.size)
# bSlider event handlers
def f2(e, p, q):
self.currentPb = p / float(self.bSliderWidth)
self.graphicsScene.slider2D.QImg.setPb(self.currentPb)
self.graphicsScene.slider2D.setPixmap(self.graphicsScene.slider2D.QImg.rPixmap)
QToolTip.showText(e.screenPos(), (str(int(self.currentPb * 100.0))), self)
bSliderCursor.onMouseMove = f2
def f3(e, p, q):
self.currentPb = p / float(self.bSliderWidth)
# self.graphicsScene.slider2D.QImg.setPb(self.currentPb)
# self.graphicsScene.slider2D.setPixmap(self.graphicsScene.slider2D.QImg.rPixmap)
self.displayStatus()
bSliderCursor.onMouseRelease = f3
# grid
self.grid = activeGrid(self.graphicsScene.lut.size, self.cModel, parent=self.graphicsScene.slider2D)
self.graphicsScene.grid = self.grid
# buttons
pushButton1 = QbLUePushButton("Reset Grid")
pushButton1.clicked.connect(self.onReset)
pushButton2 = QbLUePushButton("Save LUT")
pushButton2.clicked.connect(self.saveLUT)
pushButton3 = QbLUePushButton("Smooth Grid")
pushButton3.clicked.connect(self.onSmoothGrid)
pushButton4 = QbLUePushButton('Set Mask')
pushButton4.clicked.connect(self.setMask)
# pushButton4 needs enabling/disabling
self.pushButton4 = pushButton4
# options
options1, optionNames1 = ['use image', 'use selection'], ['Use Image', 'Use Selection']
self.listWidget1 = optionsWidget(options=options1, optionNames=optionNames1, exclusive=True)
self.listWidget1.setFocusPolicy(Qt.NoFocus)
# set initial selection to 'use image'
self.listWidget1.checkOption(self.listWidget1.intNames[0])
options2, optionNames2 = ['add node', 'remove node'], ['Add Node', 'Remove Node']
self.listWidget2 = optionsWidget(options=options2, optionNames=optionNames2, exclusive=True)
# set initial selection to 'add node'
self.listWidget2.checkOption(self.listWidget2.intNames[0])
options3 = ['select neighbors', 'reset removed nodes', 'show histogram', 'keep alpha']
optionNames3 = ['Select Neighbors', 'Reset Removed', 'Show Histogram', 'Keep Alpha']
self.listWidget3 = optionsWidget(options=options3, optionNames=optionNames3, exclusive=False)
self.listWidget3.checkOption(self.listWidget3.intNames[0])
self.listWidget3.checkOption(self.listWidget3.intNames[1])
def onSelect3(item):
option = item.internalName
if option == 'show histogram':
self.graphicsScene.slider2D.showTargetHist = self.graphicsScene.options[option]
self.graphicsScene.slider2D.updatePixmap()
return
if option == 'keep alpha':
self.enableButtons()
self.layer.applyToStack()
self.listWidget3.onSelect = onSelect3
# set initial selection to 'select naighbors'
item = self.listWidget3.items[options3[0]]
item.setCheckState(Qt.Checked)
self.graphicsScene.options = UDict((self.listWidget1.options, self.listWidget2.options,
self.listWidget3.options))
for wdg in [self.listWidget1, self.listWidget2, self.listWidget3]:
wdg.setMinimumWidth(wdg.sizeHintForColumn(0))
wdg.setMinimumHeight(wdg.sizeHintForRow(0)*len(wdg.items))
# color format combo
infoCombo = QComboBox()
oDict = OrderedDict([('RGB', 0), ('CMYK', 1), ('HSV', 2)])
for key in oDict:
infoCombo.addItem(key, oDict[key])
labelFormat = QLabel()
def colorInfoFormatChanged(value):
self.colorInfoFormat = infoCombo.itemData(value)
if self.colorInfoFormat == 0:
labelFormat.setText('RGB')
elif self.colorInfoFormat == 1:
labelFormat.setText('CMYK')
elif self.colorInfoFormat == 2:
labelFormat.setText('HSV')
self.displayStatus()
infoCombo.currentIndexChanged.connect(colorInfoFormatChanged)
# working marker position editor
self.info = QLineEdit()
self.info.setMaximumSize(120, 40)
# returnPressed slot
def infoDone():
try:
token = self.info.text().split(' ')
if self.colorInfoFormat == 0: # RGB
r, g, b = [int(x) for x in token if x.isdigit()]
pt = QPointF(*swatchImg.GetPoint(*rgb2hsB(r, g, b)[:2])) + offset
elif self.colorInfoFormat == 1: # CMYK
c, m, y, k = [int(x) for x in token if x.isdigit()]
pt = QPointF(*swatchImg.GetPoint(*rgb2hsB(*cmyk2rgb(c, m, y, k))[:2])) + offset
elif self.colorInfoFormat == 2: # HSV
h, s, _ = [int(x) for x in token if x.isdigit()]
if not 0 <= s <= 100:
raise ValueError
pt = QPointF(*swatchImg.GetPoint(h, s / 100.0)) + offset
else:
raise ValueError
self.workingMarker.setPos(pt.x(), pt.y())
except ValueError:
dlgWarn("Invalid color")
self.info.returnPressed.connect(infoDone)
# layout
gl = QGridLayout()
for i, button in enumerate([pushButton1, pushButton3, pushButton2]):
gl.addWidget(button, 0, i)
gl.addWidget(pushButton4, 1, 0)
gl.addWidget(infoCombo, 1, 1)
for i, widget in enumerate([self.listWidget1, self.listWidget2, self.listWidget3]):
gl.addWidget(widget, 2 if i < 2 else 1, i, 1 if i < 2 else 2, 1, 0)
hl = QHBoxLayout()
hl.addWidget(labelFormat)
hl.addWidget(self.info)
gl.addLayout(hl, 3, 0, -1, -1)
self.addCommandLayout(gl)
# set defaults
self.colorInfoFormat = 0 # RGB
colorInfoFormatChanged(self.colorInfoFormat)
# whatsthis
self.setWhatsThis(
""" <b>2.5D LUT Editor</b><br>
<b>Select nodes</b> with mouse clicks on the image. Selected nodes are shown
as small black circles on the color wheel.<br>
<b>Modify the color</b> of a node by dragging it on
the wheel. Several nodes can be moved simultaneously by grouping them.<br>
<b>Group nodes</b> :<br>
1 - group nodes with the mouse : while pressing the mouse left button,
drag a rubber band around the nodes to group;<br>
2 - next, right click any one of the selected nodes and
choose group from the context menu<br>
<b>Unselect nodes</b> :<br>
1 - check the option Remove Node;<br>
2 - ungroup;<br>
3 - on the image, click the pixels to unselect.<br>
<b>Warning</b> : Selecting/unselecting nodes with the mouse is enabled only when
the Color Chooser is closed.<br>
Press the <b> Smooth Grid</b> button to smooth color transitions between neighbor nodes.<br>
<b>Crosshair</b> markers indicate neutral gray tones and average
skin tones. They can be moved with the mouse.
The position of the second marker is reflected in the editable
bottom right box. Due to inherent properties
of the CMYK color model, CMYK input values may be modified silently.<br>
<b>The grid can be zoomed</b> with the mouse wheel.<br>
Check the <b>Keep Alpha</b> option to forward the alpha channel without modifications.<br>
This option must be unchecked to build a mask from the 3D LUT.<br>
HSpB layer is slower than HSV, but usually gives better results.<br>
"""
) # end of setWhatsThis
def __init__(self,
targetImage=None,
axeSize=500,
layer=None,
parent=None,
mainForm=None):
super().__init__(parent=parent)
defaultRadius = 10
defaultTone = 100.0
defaultAmount = 50.0
self.radius = defaultRadius
self.tone = defaultTone
self.amount = defaultAmount
self.targetImage = targetImage
self.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred)
self.setMinimumSize(axeSize, axeSize)
self.setAttribute(Qt.WA_DeleteOnClose)
self.img = targetImage
# link back to image layer
self.layer = weakProxy(layer)
"""
# using weak ref for back links
if type(layer) in weakref.ProxyTypes:
self.layer = layer
else:
self.layer = weakref.proxy(layer)
"""
self.mainForm = mainForm
self.kernelCategory = filterIndex.UNSHARP
# options
self.optionList = [
'Unsharp Mask', 'Sharpen', 'Gaussian Blur', 'Surface Blur'
]
filters = [
filterIndex.UNSHARP, filterIndex.SHARPEN, filterIndex.BLUR1,
filterIndex.SURFACEBLUR
]
self.filterDict = dict(zip(self.optionList, filters))
self.listWidget1 = optionsWidget(options=self.optionList,
exclusive=True,
changed=self.dataChanged)
# set initial selection to unsharp mask
item = self.listWidget1.checkOption(self.optionList[0])
# sliders
self.sliderRadius = QbLUeSlider(Qt.Horizontal)
#self.sliderRadius.setTickPosition(QSlider.TicksBelow)
self.sliderRadius.setRange(1, 50)
self.sliderRadius.setSingleStep(1)
self.radiusLabel = QLabel()
self.radiusLabel.setMaximumSize(150, 30)
self.radiusLabel.setText("Radius")
self.radiusValue = QLabel()
font = self.radiusValue.font()
metrics = QFontMetrics(font)
w = metrics.width("1000 ")
h = metrics.height()
self.radiusValue.setMinimumSize(w, h)
self.radiusValue.setMaximumSize(w, h)
self.sliderAmount = QbLUeSlider(Qt.Horizontal)
#self.sliderAmount.setTickPosition(QSlider.TicksBelow)
self.sliderAmount.setRange(0, 100)
self.sliderAmount.setSingleStep(1)
self.amountLabel = QLabel()
self.amountLabel.setMaximumSize(150, 30)
self.amountLabel.setText("Amount")
self.amountValue = QLabel()
font = self.radiusValue.font()
metrics = QFontMetrics(font)
w = metrics.width("1000 ")
h = metrics.height()
self.amountValue.setMinimumSize(w, h)
self.amountValue.setMaximumSize(w, h)
self.toneValue = QLabel()
self.toneLabel = QLabel()
self.toneLabel.setMaximumSize(150, 30)
self.toneLabel.setText("Sigma")
self.sliderTone = QbLUeSlider(Qt.Horizontal)
#self.sliderTone.setTickPosition(QSlider.TicksBelow)
self.sliderTone.setRange(0, 100)
self.sliderTone.setSingleStep(1)
font = self.radiusValue.font()
metrics = QFontMetrics(font)
w = metrics.width("1000 ")
h = metrics.height()
self.toneValue.setMinimumSize(w, h)
self.toneValue.setMaximumSize(w, h)
# layout
l = QVBoxLayout()
l.setAlignment(Qt.AlignBottom)
l.addWidget(self.listWidget1)
hl = QHBoxLayout()
hl.addWidget(self.radiusLabel)
hl.addWidget(self.radiusValue)
hl.addWidget(self.sliderRadius)
l.addLayout(hl)
hl = QHBoxLayout()
hl.addWidget(self.amountLabel)
hl.addWidget(self.amountValue)
hl.addWidget(self.sliderAmount)
l.addLayout(hl)
hl = QHBoxLayout()
hl.addWidget(self.toneLabel)
hl.addWidget(self.toneValue)
hl.addWidget(self.sliderTone)
l.addLayout(hl)
l.setContentsMargins(20, 0, 20, 25) # left, top, right, bottom
self.setLayout(l)
# value changed event handler
def sliderUpdate():
self.radiusValue.setText(str('%d ' % self.sliderRadius.value()))
self.amountValue.setText(str('%d ' % self.sliderAmount.value()))
self.toneValue.setText(str('%d ' % self.sliderTone.value()))
# value done event handler
def formUpdate():
sR, sA, sT = self.sliderRadius.isEnabled(
), self.sliderAmount.isEnabled(), self.sliderTone.isEnabled()
self.sliderRadius.setEnabled(False)
self.sliderAmount.setEnabled(False)
self.sliderTone.setEnabled(False)
self.tone = self.sliderTone.value()
self.radius = self.sliderRadius.value()
self.amount = self.sliderAmount.value()
sliderUpdate()
self.dataChanged.emit()
self.sliderRadius.setEnabled(sR)
self.sliderAmount.setEnabled(sA)
self.sliderTone.setEnabled(sT)
self.sliderRadius.valueChanged.connect(sliderUpdate)
self.sliderRadius.sliderReleased.connect(formUpdate)
self.sliderAmount.valueChanged.connect(sliderUpdate)
self.sliderAmount.sliderReleased.connect(formUpdate)
self.sliderTone.valueChanged.connect(sliderUpdate)
self.sliderTone.sliderReleased.connect(formUpdate)
self.dataChanged.connect(self.updateLayer)
# init
self.sliderRadius.setValue(defaultRadius)
self.sliderAmount.setValue(defaultAmount)
self.sliderTone.setValue(defaultTone)
self.enableSliders()
sliderUpdate()
self.setWhatsThis("""
<b>Unsharp Mask</b> and <b>Sharpen Mask</b> are used to sharpen an image.<br>
<b>Gaussian Blur</b> and <b>Surface Blur</b> are used to blur an image.<br>
In contrast to Gaussian Blur, Surface Blur preserves edges and reduces noise.<br>
It is possible to <b>limit the effect of a filter to a rectangular region of the image</b> by
drawing a selection rectangle on the layer with the marquee tool.<br>
Ctrl-Click to <b>clear the selection</b><br>
""") # end setWhatsThis
def __init__(self, cModel, targetImage=None, axeSize=500, LUTSize=LUTSIZE, layer=None, parent=None, mainForm=None):
"""
@param cModel: color space used by colorPicker, slider2D and colorPicker
@type cModel: cmConverter object
@param axeSize: size of the color wheel
@type axeSize: int
@param targetImage:
@type targetImage: imImage
@param LUTSize:
@type LUTSize: int
@param layer: layer of targetImage linked to graphics form
@type layer : QLayer
@param parent:
@type parent:
"""
super().__init__(parent=parent)
self.mainForm = mainForm # used by saveLUT()
# context help tag
self.helpId = "LUT3DForm"
self.cModel = cModel
border = 20
self.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred)
self.setMinimumSize(axeSize + 90, axeSize + 200)
self.setAttribute(Qt.WA_DeleteOnClose)
self.setBackgroundBrush(QBrush(Qt.black, Qt.SolidPattern))
self.currentHue, self.currentSat, self.currentPb = 0, 0, self.defaultColorWheelBr
self.currentR, self.currentG, self.currentB = 0, 0, 0
self.size = axeSize
# back links to image
self.targetImage = weakProxy(targetImage)
self.layer = weakProxy(layer)
# currently selected grid node
self.selected = None
self.graphicsScene = QGraphicsScene()
self.graphicsScene.options = None
self.setScene(self.graphicsScene)
# back to image layer
self.graphicsScene.layer = weakProxy(layer)
# init LUT
freshLUT3D = LUT3D(None, size=LUTSize, alpha=True)
self.graphicsScene.lut = freshLUT3D
# init 2D slider
QImg = hueSatPattern(axeSize, axeSize, cModel, bright=self.defaultColorWheelBr, border=border)
self.graphicsScene.slider2D = colorChooser(cModel, QImg, target=self.targetImage, size=axeSize, border=border)
self.graphicsScene.selectMarker = activeMarker.fromCross(parent=self.graphicsScene.slider2D)
self.graphicsScene.selectMarker.setPos(axeSize / 2, axeSize / 2)
# color wheel event handler
def f1(p, r, g, b):
h, s, br = self.cModel.rgb2cm(r, g, b)
self.currentHue, self.currentSat, self.currentPb = h, s, br
self.currentR, self.currentG, self.currentB = r, g, b
self.bSliderUpdate()
self.displayStatus()
self.graphicsScene.slider2D.onMouseRelease = f1
self.graphicsScene.addItem(self.graphicsScene.slider2D)
# Brightness slider
self.bSliderHeight = 20
self.bSliderWidth = self.graphicsScene.slider2D.QImg.width()
px = brightnessPattern(self.bSliderWidth, self.bSliderHeight, cModel, self.currentHue, self.currentSat).rPixmap
self.graphicsScene.bSlider = QGraphicsPixmapItem(px, parent=self.graphicsScene.slider2D)
self.graphicsScene.bSlider.setPos(QPointF(-border, self.graphicsScene.slider2D.QImg.height() - border))
bSliderCursor = activeMarker.fromTriangle(parent=self.graphicsScene.bSlider)
bSliderCursor.setMoveRange(QRectF(0.0, bSliderCursor.size, self.graphicsScene.bSlider.pixmap().width(), 0.0))
bSliderCursor.setPos(self.graphicsScene.bSlider.pixmap().width() * self.defaultColorWheelBr, bSliderCursor.size)
# cursor event handlers
def f2(e, p, q):
self.currentPb = p / float(self.bSliderWidth)
QToolTip.showText(e.screenPos(), (str(int(self.currentPb * 100.0))), self)
bSliderCursor.onMouseMove = f2
def f3(e, p, q):
self.currentPb = p / float(self.bSliderWidth)
self.graphicsScene.slider2D.QImg.setPb(self.currentPb)
self.graphicsScene.slider2D.setPixmap(self.graphicsScene.slider2D.QImg.rPixmap)
self.displayStatus()
bSliderCursor.onMouseRelease = f3
# status bar
offset = 60
self.graphicsScene.statusBar = QGraphicsTextItem()
self.graphicsScene.statusBar.setPos(-20, axeSize + offset)
self.graphicsScene.statusBar.setDefaultTextColor(QColor(255, 255, 255))
self.graphicsScene.statusBar.setPlainText('')
self.graphicsScene.addItem(self.graphicsScene.statusBar)
self.displayStatus()
# self.setRenderHints(QPainter.Antialiasing | QPainter.SmoothPixmapTransform)
# grid
self.grid = activeGrid(self.graphicsScene.lut.size, self.cModel, parent=self.graphicsScene.slider2D)
self.graphicsScene.grid = self.grid
# buttons
pushButton1 = QbLUePushButton("Reset Grid")
pushButton1.clicked.connect(self.onReset)
pushButton2 = QbLUePushButton("Save LUT")
pushButton2.clicked.connect(self.saveLUT)
pushButton3 = QbLUePushButton("Smooth Grid")
pushButton3.clicked.connect(self.onSmoothGrid)
pushButton4 = QbLUePushButton('Set Mask')
pushButton4.clicked.connect(self.setMask)
# pushButton4 needs enabling/disabling
self.pushButton4 = pushButton4
# options
options1, optionNames1 = ['use image', 'use selection'], ['Use Image', 'Use Selection']
self.listWidget1 = optionsWidget(options=options1, optionNames=optionNames1, exclusive=True)
"""
def onSelect1(item):
self.graphicsScene.options['use selection'] = item is self.listWidget1.items['use selection']
self.listWidget1.onSelect = onSelect1
"""
self.listWidget1.setFocusPolicy(Qt.NoFocus)
# set initial selection to 'use image'
self.listWidget1.checkOption(self.listWidget1.intNames[0])
options2, optionNames2 = ['add node', 'remove node'], ['Add Node', 'Remove Node']
self.listWidget2 = optionsWidget(options=options2, optionNames=optionNames2, exclusive=True)
"""
def onSelect2(item):
self.graphicsScene.options['add node'] = item is self.listWidget2.items['add node']
self.listWidget2.onSelect = onSelect2
"""
# set initial selection to add node'
self.listWidget2.checkOption(self.listWidget2.intNames[0])
options3 = ['select neighbors', 'reset removed nodes', 'show histogram', 'keep alpha']
optionNames3 = ['Select Neighbors', 'Reset Removed', 'Show Histogram', 'Keep Alpha']
self.listWidget3 = optionsWidget(options=options3, optionNames=optionNames3, exclusive=False)
self.listWidget3.checkOption(self.listWidget3.intNames[0])
self.listWidget3.checkOption(self.listWidget3.intNames[1])
def onSelect3(item):
option = item.internalName
if option == 'show histogram':
self.graphicsScene.slider2D.showTargetHist = self.graphicsScene.options[option] # .isChecked()
self.graphicsScene.slider2D.updatePixmap()
return
if option == 'keep alpha':
self.enableButtons()
self.layer.applyToStack()
self.listWidget3.onSelect = onSelect3
# set initial selection to 'select naighbors'
item = self.listWidget3.items[options3[0]]
item.setCheckState(Qt.Checked)
self.graphicsScene.options = UDict((self.listWidget1.options, self.listWidget2.options,
self.listWidget3.options))
# layouts
hlButtons = QHBoxLayout()
hlButtons.addWidget(pushButton1)
hlButtons.addWidget(pushButton3)
hlButtons.addWidget(pushButton2)
hl = QHBoxLayout()
vl1 = QVBoxLayout()
vl1.addWidget(self.listWidget1)
vl1.addWidget(pushButton4)
hl.addLayout(vl1)
hl.addWidget(self.listWidget2)
hl.addWidget(self.listWidget3)
vl = QVBoxLayout()
for l in [hlButtons, hl]:
vl.addLayout(l)
# Init QWidget container for adding buttons and options to graphicsScene
container = QWidget()
container.setObjectName("container")
container.setLayout(vl)
ss = """QWidget#container{background: black}\
QListWidget{background-color: black; selection-background-color: black; border: none; font-size: 7pt}\
QListWidget::item{color: white;}\
QListWidget::item::selected{background: black; border: none}"""
container.setStyleSheet(ss)
for wdg in [self.listWidget1, self.listWidget2, self.listWidget3]:
wdg.setMinimumWidth(wdg.sizeHintForColumn(0))
wdg.setMinimumHeight(wdg.sizeHintForRow(0)*len(wdg.items))
container.setGeometry(-offset//2, axeSize + offset - 20, axeSize + offset, 20)
self.graphicsScene.addWidget(container)
#container.setStyleSheet("QPushButton {color: white;}\
# QPushButton:pressed, QPushButton:hover {background-color: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1, stop: 0 #0d5ca6, stop: 1 #2198c0);}")
self.setWhatsThis(
""" <b>2.5D LUT Editor</b><br>
HSpB layers are slower than HSV, but usually they give better results.<br>
<b>Select nodes</b> with mouse clicks on the image. Selected nodes are shown
as small black circles on the color wheel.<br>
<b>Modify the color</b> of a node by dragging it on
the wheel. Several nodes can be moved simultaneously by grouping them.<br>
<b>Group nodes</b> :<br>
1 - select them with the mouse : while pressing the mouse left button, drag a rubber band around the nodes to select;<br>
2 - next, right click any one of the selected nodes and choose group from the context menu<br>
<b>unselect nodes</b> :<br>
1 - check the option Remove Node;<br>
2 - ungroup;<br>
3 - on the image, click the pixels to unselect.<br>
<b>Caution</b> : Selecting nodes with the mouse is enabled only when
the Color Chooser is closed.<br>
Click the <b> Smooth Grid</b> button to smooth color transitions between neighbor nodes.<br>
Check the <br>Keep Alpha</b> option to forward the alpha channel without modifications.<br>
This option must be unchecked to build a mask from the 3D LUT.<br>
"""
) # end of setWhatsThis
def __init__(self,
targetImage=None,
axeSize=500,
layer=None,
parent=None,
colorModel='HSV',
mainForm=None):
super().__init__(targetImage=targetImage,
axeSize=axeSize,
layer=layer,
parent=parent,
mainForm=mainForm)
graphicsScene = self.scene()
graphicsScene.colorModel = colorModel
# hue curve init.
cubic = activeCubicSpline(axeSize)
graphicsScene.addItem(cubic)
graphicsScene.cubicR = cubic
cubic.channel = channelValues.Hue
"""
cubic.histImg = graphicsScene.layer.histogram(size=axeSize,
bgColor=graphicsScene.bgColor, range=(0, 360),
chans=channelValues.Hue, mode='HSpB')
"""
cubic.initFixedPoints()
# sat curve init.
cubic = activeCubicSpline(axeSize)
graphicsScene.addItem(cubic)
graphicsScene.cubicG = cubic
cubic.channel = channelValues.Sat
"""
cubic.histImg = graphicsScene.layer.histogram(size=axeSize,
bgColor=graphicsScene.bgColor, range=(0,1),
chans=channelValues.Sat, mode='HSpB')
"""
cubic.initFixedPoints()
# brightness curve init.
cubic = activeCubicSpline(axeSize)
graphicsScene.addItem(cubic)
graphicsScene.cubicB = cubic
cubic.channel = channelValues.Br
"""
cubic.histImg = graphicsScene.layer.histogram(size=axeSize,
bgColor=graphicsScene.bgColor,
range=(0,1), chans=channelValues.Br, mode='HSpB')
"""
cubic.initFixedPoints()
# init histograms
self.updateHists()
# set current curve to sat
graphicsScene.cubicItem = graphicsScene.cubicG
graphicsScene.cubicItem.setVisible(True)
# buttons
pushButton1 = QPushButton("Reset Current")
pushButton1.move(100, 20)
pushButton1.adjustSize()
pushButton1.clicked.connect(self.resetCurve)
graphicsScene.addWidget(pushButton1)
pushButton2 = QPushButton("Reset All")
pushButton2.move(100, 50)
pushButton2.adjustSize()
pushButton2.clicked.connect(self.resetAllCurves)
graphicsScene.addWidget(pushButton2)
# options
options = ['H', 'S', 'B']
self.listWidget1 = optionsWidget(options=options, exclusive=True)
self.listWidget1.setGeometry(
0, 10,
self.listWidget1.sizeHintForColumn(0) + 5,
self.listWidget1.sizeHintForRow(0) * len(options) + 5)
graphicsScene.addWidget(self.listWidget1)
# selection changed handler
curves = [
graphicsScene.cubicR, graphicsScene.cubicG, graphicsScene.cubicB
]
curveDict = dict(zip(options, curves))
def onSelect1(item):
self.scene().cubicItem.setVisible(False)
self.scene().cubicItem = curveDict[item.text()]
self.scene().cubicItem.setVisible(True)
# draw histogram
self.scene().invalidate(
QRectF(0.0, -self.scene().axeSize,
self.scene().axeSize,
self.scene().axeSize), QGraphicsScene.BackgroundLayer)
self.listWidget1.onSelect = onSelect1
# set initial selection to Saturation
item = self.listWidget1.items[options[1]]
item.setCheckState(Qt.Checked)
self.listWidget1.select(item)
self.setWhatsThis("""<b>HSV curves</b><br>""" + self.whatsThis())
def f():
layer = graphicsScene.layer
layer.applyToStack()
layer.parentImage.onImageChanged()
self.scene().cubicR.curveChanged.sig.connect(f)
self.scene().cubicG.curveChanged.sig.connect(f)
self.scene().cubicB.curveChanged.sig.connect(f)
def __init__(self, layer=None):
super(segmentForm, self).__init__()
self.setWindowTitle('grabcut')
self.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred)
self.setMinimumSize(200, 200)
self.setAttribute(Qt.WA_DeleteOnClose)
# link back to image layer
self.layer = weakProxy(layer)
pushButton = QPushButton('apply')
# button slot
def f():
self.layer.noSegment = False
self.layer.applyToStack()
window.label.img.onImageChanged()
# do manual segmentation only
layer.noSegment = True
pushButton.clicked.connect(f)
pushButton1 = QPushButton('Reset')
pushButton1.clicked.connect(lambda : self.reset())
self.spBox = QSpinBox()
self.spBox.setRange(1,10)
# spBox Slot
def f2(iterCount):
self.spBox.valueChanged.disconnect()
self.dataChanged.emit()
self.spBox.valueChanged.connect(f2)
self.spBox.valueChanged.connect(f2)
spBoxLabel = QLabel()
spBoxLabel.setText('Iterations')
self.spBox1 = QSpinBox()
self.spBox1.setRange(0, 20)
spBox1Label = QLabel()
spBox1Label.setText('Contour Margin')
# spBox1 slot
def f1(margin):
self.spBox1.valueChanged.disconnect()
self.dataChanged.emit()
self.spBox1.valueChanged.connect(f1)
self.spBox1.valueChanged.connect(f1)
# options
optionList1, optionNames1 = ['Clipping Layer'], ['Clipping Layer']
self.listWidget1 = optionsWidget(options=optionList1, optionNames=optionNames1, exclusive=False)
self.options = self.listWidget1.options
# option changed slot
def g(item):
self.layer.isClipping = self.options['Clipping Layer']
self.layer.applyToStack()
self.layer.parentImage.onImageChanged()
self.listWidget1.onSelect = g
# attributes initialized in setDefaults, declared here
# for the sake of correctness
self.start = None
self.nbIter = None
self.contourMargin = None
# layout
hLay = QHBoxLayout()
hLay.addWidget(spBoxLabel)
hLay.addWidget(self.spBox)
hLay.addStretch(1)
hLay1 = QHBoxLayout()
hLay1.addWidget(spBox1Label)
hLay1.addWidget(self.spBox1)
hLay1.addStretch(1)
h2 = QHBoxLayout()
h2.addWidget(self.listWidget1)
vLay = QVBoxLayout()
vLay.setAlignment(Qt.AlignTop)
vLay.setContentsMargins(20, 8, 20, 25) # left, top, right, bottom
vLay.addLayout(hLay)
vLay.addLayout(hLay1)
vLay.addLayout(h2)
h3 = QHBoxLayout()
h3.addWidget(pushButton)
h3.addWidget(pushButton1)
vLay.addLayout(h3)
self.setLayout(vLay)
self.setDefaults()
self.setWhatsThis(
""" <b>Object extraction</b><br>
Select the object to extract with the rectangle Marquee Tool. Next, click the Apply button.<br>
Correct (roughly) if needed the foreground (FG) and the background (BG) regions using the FG and BG tools (Ctrl to undo) and click again the Apply button.<br>
To get a smoother contour increase the value of the Contour Margin and click the Apply Button.<br>
By default the mask is displayed as a color mask. To view it as an opacity mask, right click on the Segmentation layer row in the right pane and check Enable Mask As > Opacity Mask in the context menu.
Use the same context menu to copy/paste the object to a new image layer or the mask to another layer.<br>
"""
) # end setWhatsThis
def __init__(self,
targetImage=None,
size=200,
layer=None,
parent=None,
mainForm=None):
super().__init__(parent=parent)
self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred)
self.setMinimumSize(size, 100)
self.setAttribute(Qt.WA_DeleteOnClose)
self.targetImage = weakProxy(targetImage)
self.img = weakProxy(targetImage)
# link back to image layer
# using weak ref for back links
self.layer = layer if (layer is None or type(layer)
in weakref.ProxyTypes) else weakref.proxy(layer)
self.Label_Hist = QLabel()
self.Label_Hist.setScaledContents(True)
self.Label_Hist.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Preferred)
#self.setStyleSheet("QListWidget{background-color: rgb(200,200,200); selection-background-color: rgb(200,200,200); border: 0px; font-size: 9px}")
self.setStyleSheet("QListWidget{border: 0px; font-size: 12px}")
# options. We want the items displayed horizontally, so we use 2 lists
options1, optionNames1 = ['Original Image'], ['Source']
self.listWidget1 = optionsWidget(options=options1,
optionNames=optionNames1,
exclusive=False)
self.listWidget1.item(0).setSizeHint(QSize(100, 10))
self.listWidget1.setMaximumSize(
self.listWidget1.sizeHintForColumn(0) + 5,
self.listWidget1.sizeHintForRow(0) * len(options1))
options2 = ['Color Chans']
self.listWidget2 = optionsWidget(options=options2, exclusive=False)
self.listWidget2.item(0).setSizeHint(QSize(100, 10))
self.listWidget2.setMaximumSize(
self.listWidget2.sizeHintForColumn(0) + 5,
self.listWidget2.sizeHintForRow(0) * len(options2))
# default: show color hists
self.listWidget2.item(0).setCheckState(Qt.Checked)
self.options = {option: True for option in options1 + options2}
def onSelect1(item):
self.options[options1[0]] = item.checkState() is Qt.Checked
try:
self.targetImage.onImageChanged()
self.Label_Hist.update()
except AttributeError:
return
def onSelect2(item):
self.options[options2[0]] = item.checkState() is Qt.Checked
try:
self.targetImage.onImageChanged()
self.Label_Hist.update()
except AttributeError:
return
self.listWidget1.onSelect = onSelect1
self.listWidget2.onSelect = onSelect2
# layout
h = QHBoxLayout()
h.addWidget(self.listWidget1)
h.addWidget(self.listWidget2)
l = QVBoxLayout()
l.setAlignment(Qt.AlignTop)
l.addWidget(self.Label_Hist)
l.addLayout(h)
l.setContentsMargins(0, 0, 0, 2) # left, top, right, bottom
self.setLayout(l)
def __init__(self, axeSize=500, layer=None, parent=None):
super(noiseForm, self).__init__(parent=parent)
self.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred)
self.setMinimumSize(axeSize, axeSize)
self.setAttribute(Qt.WA_DeleteOnClose)
# link back to image layer
# using weak ref for back links
if type(layer) in weakref.ProxyTypes:
self.layer = layer
else:
self.layer = weakref.proxy(layer)
# attribute initialized in setDefaults
# defined here for the sake of correctness
self.noiseCorrection = 0
# options
optionList = ['Wavelets', 'Bilateral', 'NLMeans']
self.listWidget1 = optionsWidget(
options=optionList,
exclusive=True,
changed=lambda: self.dataChanged.emit(True))
self.listWidget1.checkOption(self.listWidget1.intNames[0])
self.options = self.listWidget1.options
# threshold slider
self.sliderThr = QbLUeSlider(Qt.Horizontal)
self.sliderThr.setStyleSheet(QbLUeSlider.bLueSliderDefaultBWStylesheet)
self.sliderThr.setTickPosition(QSlider.TicksBelow)
self.sliderThr.setRange(0, 10)
self.sliderThr.setSingleStep(1)
self.sliderThr.valueChanged.connect(self.thrUpdate)
self.sliderThr.sliderReleased.connect(lambda: self.thrUpdate(
self.sliderThr.value())) # signal has no parameter)
self.thrLabel = QLabel()
self.thrLabel.setMaximumSize(150, 30)
self.thrLabel.setText("level")
self.thrValue = QLabel()
font = self.thrValue.font()
metrics = QFontMetrics(font)
w = metrics.width("0000")
h = metrics.height()
self.thrValue.setMinimumSize(w, h)
self.thrValue.setMaximumSize(w, h)
self.thrValue.setText(
str("{:.0f}".format(self.slider2Thr(self.sliderThr.value()))))
# self.dataChanged.connect(self.updateLayer)
# self.setStyleSheet("QListWidget, QLabel {font : 7pt;}")
# layout
l = QVBoxLayout()
#l.setAlignment(Qt.AlignBottom)
l.addWidget(self.listWidget1)
hl1 = QHBoxLayout()
hl1.addWidget(self.thrLabel)
hl1.addWidget(self.thrValue)
hl1.addWidget(self.sliderThr)
l.addLayout(hl1)
l.setContentsMargins(20, 0, 20, 25) # left, top, right, bottom
#l.setContentsMargins(10, 10, 10, 10) # left, top, right, bottom
self.setLayout(l)
self.adjustSize()
self.setDefaults()
self.setWhatsThis("""<b>Noise Reduction</b><br>
<b>Bilateral Filtering</b> is the fastest method.<br>
<b>NLMeans</b> (Non Local Means) and <b>Wavelets</b> are slower,
but they usually give better results.<br>
It is possible to <b>limit the application of all methods to a rectangular region of the image</b>
by drawing a selection rectangle on the layer with the marquee tool.<br>
Ctrl-Click to <b>clear the selection</b><br>
""") # end of setWhatsThis
def __init__(self, targetImage=None, axeSize=500, layer=None, parent=None):
super().__init__(layer=layer, targetImage=targetImage, parent=parent)
#######################################
# Libraw correspondences:
# rgb_xyz_matrix is libraw cam_xyz
# camera_whitebalance is libraw cam_mul
# daylight_whitebalance is libraw pre_mul
# dng correspondences:
# ASSHOTNEUTRAL tag value is (X,Y,Z) = 1 / rawpyObj.camera_whitebalance
##########################################
rawpyObj = layer.parentImage.rawImage
# constants and as shot values
self.XYZ2CameraMatrix = rawpyObj.rgb_xyz_matrix[:3, :]
self.XYZ2CameraInverseMatrix = np.linalg.inv(self.XYZ2CameraMatrix)
# initial post processing multipliers (as shot)
m1, m2, m3, m4 = rawpyObj.camera_whitebalance
self.asShotMultipliers = (
m1 / m2, 1.0, m3 / m2, m4 / m2
) # normalization is mandatory : for nef files white balance is around 256
self.asShotTemp, self.asShotTint = multipliers2TemperatureAndTint(
*1 / np.array(self.asShotMultipliers[:3]), self.XYZ2CameraMatrix)
self.rawMultipliers = self.asShotMultipliers # rawpyObj.camera_whitebalance # = 1/(dng ASSHOTNEUTRAL tag value)
self.sampleMultipliers = False
self.samples = []
########################################
# XYZ-->Camera conversion matrix:
# Last row is zero for RGB cameras (cf. rawpy and libraw docs).
# type ndarray, shape (4,3)
#########################################
# attributes initialized in setDefaults, declared here for the sake of correctness
self.tempCorrection, self.tintCorrection, self.expCorrection, self.highCorrection,\
self.contCorrection, self.satCorrection, self.brCorrection = [None] * 7
# contrast spline vie (initialized by setContrastSpline)
self.contrastForm = None
# tone spline view (initialized by setToneSpline)
self.toneForm = None
# dock containers for contrast and tome forms
self.dockC, self.dockT = None, None
# options
optionList0, optionNames0 = ['Auto Brightness', 'Preserve Highlights'
], ['Auto Expose', 'Preserve Highlights']
optionList1, optionNames1 = ['Auto WB', 'Camera WB', 'User WB'
], ['Auto', 'Camera (As Shot)', 'User']
optionList2, optionNames2 = [
'cpLookTable', 'cpToneCurve', 'manualCurve'
], [
'Use Camera Profile Look Table', 'Show Tone Curves',
'Show Contrast Curve'
]
self.listWidget1 = optionsWidget(
options=optionList0,
optionNames=optionNames0,
exclusive=False,
changed=lambda: self.dataChanged.emit(1))
self.listWidget2 = optionsWidget(
options=optionList1,
optionNames=optionNames1,
exclusive=True,
changed=lambda: self.dataChanged.emit(1))
self.listWidget3 = optionsWidget(
options=optionList2,
optionNames=optionNames2,
exclusive=False,
changed=lambda: self.dataChanged.emit(2))
self.options = UDict(
(self.listWidget1.options, self.listWidget2.options,
self.listWidget3.options))
# display the 'as shot' temperature
item = self.listWidget2.item(1)
item.setText(item.text() + ' : %d' % self.asShotTemp)
# temperature slider
self.sliderTemp = QbLUeSlider(Qt.Horizontal)
self.sliderTemp.setStyleSheet(
QbLUeSlider.bLueSliderDefaultColorStylesheet)
self.sliderTemp.setRange(
0, 100) # TODO 130 changed to 100 12/11/18 validate
self.sliderTemp.setSingleStep(1)
self.tempLabel = QLabel()
self.tempLabel.setText("Temp")
self.tempValue = QLabel()
font = self.tempValue.font()
metrics = QFontMetrics(font)
w = metrics.width("10000")
h = metrics.height()
self.tempValue.setMinimumSize(w, h)
self.tempValue.setMaximumSize(w, h)
self.tempValue.setText(
str("{:.0f}".format(self.slider2Temp(self.sliderTemp.value()))))
self.sliderTemp.valueChanged.connect(
self.tempUpdate) # signal send new value as parameter
self.sliderTemp.sliderReleased.connect(lambda: self.tempUpdate(
self.sliderTemp.value())) # signal pass no parameter
# tint slider
self.sliderTint = QbLUeSlider(Qt.Horizontal)
self.sliderTint.setStyleSheet(
QbLUeSlider.bLueSliderDefaultIMGColorStylesheet)
self.sliderTint.setRange(0, 150)
self.sliderTint.setSingleStep(1)
self.tintLabel = QLabel()
self.tintLabel.setText("Tint")
self.tintValue = QLabel()
font = self.tempValue.font()
metrics = QFontMetrics(font)
w = metrics.width("100")
h = metrics.height()
self.tintValue.setMinimumSize(w, h)
self.tintValue.setMaximumSize(w, h)
self.tintValue.setText(
str("{:.0f}".format(self.sliderTint2User(
self.sliderTint.value()))))
self.sliderTint.valueChanged.connect(self.tintUpdate)
self.sliderTint.sliderReleased.connect(lambda: self.tintUpdate(
self.sliderTint.value())) # signal pass no parameter)
######################
# From libraw and dcraw sources:
# Exposure and brightness are curve transformations.
# Exposure curve is y = alpha*x, with cubic root ending; it is applied before demosaicing.
# Brightness is (similar to) y = x**alpha and part of gamma transformation from linear sRGB to RGB.
# Exposure and brightness both dilate the histogram towards highlights.
# Exposure dilatation is uniform (homothety), brightness dilataion is
# maximum for the midtones and the highlghts are preserved.
# As a consequence, normal workflow begins with the adjustment of exposure,
# to fill the entire range of the histogram and to adjust the highlights. Next,
# one adjusts the brightness to put the midtones at the level we want them to be.
# Cf. https://www.cambridgeincolour.com/forums/thread653.htm
#####################
# profile combo
self.dngDict = self.setCameraProfilesCombo()
# cameraProfilesCombo index changed event handler
def cameraProfileUpdate(value):
self.dngDict = self.cameraProfilesCombo.itemData(value)
if self.options['cpToneCurve']:
toneCurve = dngProfileToneCurve(
self.dngDict.get('ProfileToneCurve', []))
self.toneForm.baseCurve = [
QPointF(x * axeSize, -y * axeSize)
for x, y in zip(toneCurve.dataX, toneCurve.dataY)
]
self.toneForm.update()
# recompute as shot temp and tint using new profile
self.asShotTemp, self.asShotTint = multipliers2TemperatureAndTint(
*1 / np.array(self.asShotMultipliers[:3]),
self.XYZ2CameraMatrix, self.dngDict)
# display updated as shot temp
item = self.listWidget2.item(1)
item.setText(item.text().split(":")[0] + ': %d' % self.asShotTemp)
# invalidate cache
self.layer.bufCache_HSV_CV32 = None
self.dataChanged.emit(2) # 2 = no postprocessing
self.cameraProfilesCombo.currentIndexChanged.connect(
cameraProfileUpdate)
# denoising combo
self.denoiseCombo = QComboBox()
items = OrderedDict([('Off', 0), ('Medium', 1), ('Full', 2)])
for key in items:
self.denoiseCombo.addItem(key, items[key])
# denoiseCombo index changed event handler
def denoiseUpdate(value):
self.denoiseValue = self.denoiseCombo.itemData(value)
self.dataChanged.emit(1)
self.denoiseCombo.currentIndexChanged.connect(denoiseUpdate)
# overexposed area restoration
self.overexpCombo = QComboBox()
items = OrderedDict([('Clip', 0), ('Ignore', 1), ('Blend', 2),
('Reconstruct', 3)])
for key in items:
self.overexpCombo.addItem(key, items[key])
# overexpCombo index changed event handler
def overexpUpdate(value):
self.overexpValue = self.overexpCombo.itemData(value)
self.dataChanged.emit(1)
self.overexpCombo.currentIndexChanged.connect(overexpUpdate)
# exp slider
self.sliderExp = QbLUeSlider(Qt.Horizontal)
self.sliderExp.setStyleSheet(QbLUeSlider.bLueSliderDefaultBWStylesheet)
self.sliderExp.setRange(0, 100)
self.sliderExp.setSingleStep(1)
self.expLabel = QLabel()
self.expLabel.setText("Exp.")
self.expValue = QLabel()
font = self.expValue.font()
metrics = QFontMetrics(font)
w = metrics.width("+1.0")
h = metrics.height()
self.expValue.setMinimumSize(w, h)
self.expValue.setMaximumSize(w, h)
self.expValue.setText(
str("{:.1f}".format(self.slider2Exp(self.sliderExp.value()))))
# exp done event handler
def expUpdate(value):
self.expValue.setText(
str("{:+.1f}".format(
self.sliderExp2User(self.sliderExp.value()))))
# move not yet terminated or value not modified
if self.sliderExp.isSliderDown() or self.slider2Exp(
value) == self.expCorrection:
return
try:
self.sliderExp.valueChanged.disconnect()
self.sliderExp.sliderReleased.disconnect()
except RuntimeError:
pass
# rawpy: expCorrection range is -2.0...3.0, boiling down to exp_shift range 2**(-2)=0.25...2**3=8.0
self.expCorrection = self.slider2Exp(self.sliderExp.value())
self.dataChanged.emit(1)
self.sliderExp.valueChanged.connect(
expUpdate) # send new value as parameter
self.sliderExp.sliderReleased.connect(lambda: expUpdate(
self.sliderExp.value())) # signal pass no parameter
self.sliderExp.valueChanged.connect(
expUpdate) # send new value as parameter
self.sliderExp.sliderReleased.connect(lambda: expUpdate(
self.sliderExp.value())) # signal pass no parameter
# brightness slider
brSlider = QbLUeSlider(Qt.Horizontal)
brSlider.setRange(1, 101)
self.sliderExp.setSingleStep(1)
brSlider.setStyleSheet(QbLUeSlider.bLueSliderDefaultBWStylesheet)
self.sliderBrightness = brSlider
brLabel = QLabel()
brLabel.setText("Bright.")
self.brValue = QLabel()
font = self.expValue.font()
metrics = QFontMetrics(font)
w = metrics.width("+99")
h = metrics.height()
self.brValue.setMinimumSize(w, h)
self.brValue.setMaximumSize(w, h)
self.brValue.setText(
str("{:+d}".format(
int(self.brSlider2User(self.sliderBrightness.value())))))
# brightness done event handler
def brUpdate(value):
self.brValue.setText(
str("{:+d}".format(
int(self.brSlider2User(self.sliderBrightness.value())))))
# move not yet terminated or value not modified
if self.sliderBrightness.isSliderDown() or self.slider2Br(
value) == self.brCorrection:
return
try:
self.sliderBrightness.valueChanged.disconnect()
self.sliderBrightness.sliderReleased.disconnect()
except RuntimeError:
pass
self.brCorrection = self.slider2Br(self.sliderBrightness.value())
self.dataChanged.emit(1)
self.sliderBrightness.sliderReleased.connect(
lambda: brUpdate(self.sliderBrightness.value()))
self.sliderBrightness.valueChanged.connect(
brUpdate) # send new value as parameter
self.sliderBrightness.valueChanged.connect(
brUpdate) # send new value as parameter
self.sliderBrightness.sliderReleased.connect(
lambda: brUpdate(self.sliderBrightness.value()))
# contrast slider
self.sliderCont = QbLUeSlider(Qt.Horizontal)
self.sliderCont.setStyleSheet(
QbLUeSlider.bLueSliderDefaultBWStylesheet)
self.sliderCont.setRange(0, 20)
self.sliderCont.setSingleStep(1)
self.contLabel = QLabel()
self.contLabel.setText("Cont.")
self.contValue = QLabel()
font = self.contValue.font()
metrics = QFontMetrics(font)
w = metrics.width("100")
h = metrics.height()
self.contValue.setMinimumSize(w, h)
self.contValue.setMaximumSize(w, h)
self.contValue.setText(
str("{:.0f}".format(self.slider2Cont(self.sliderCont.value()))))
# cont done event handler
def contUpdate(value):
self.contValue.setText(
str("{:.0f}".format(self.slider2Cont(
self.sliderCont.value()))))
# move not yet terminated or value not modified
if self.sliderCont.isSliderDown() or self.slider2Cont(
value) == self.tempCorrection:
return
try:
self.sliderCont.valueChanged.disconnect()
self.sliderCont.sliderReleased.disconnect()
except RuntimeError:
pass
self.contCorrection = self.slider2Cont(self.sliderCont.value())
self.contValue.setText(str("{:+d}".format(self.contCorrection)))
# force to recalculate the spline
self.layer.autoSpline = True
self.dataChanged.emit(
3) # no postprocessing and no camera profile stuff
self.sliderCont.valueChanged.connect(
contUpdate) # send new value as parameter
self.sliderCont.sliderReleased.connect(lambda: contUpdate(
self.sliderCont.value())) # signal has no parameter
self.sliderCont.valueChanged.connect(
contUpdate) # send new value as parameter
self.sliderCont.sliderReleased.connect(lambda: contUpdate(
self.sliderCont.value())) # signal has no parameter
# saturation slider
self.sliderSat = QbLUeSlider(Qt.Horizontal)
self.sliderSat.setStyleSheet(
QbLUeSlider.bLueSliderDefaultColorStylesheet)
self.sliderSat.setRange(0, 100)
self.sliderSat.setSingleStep(1)
satLabel = QLabel()
satLabel.setText("Sat.")
self.satValue = QLabel()
font = self.satValue.font()
metrics = QFontMetrics(font)
w = metrics.width("+10")
h = metrics.height()
self.satValue.setMinimumSize(w, h)
self.satValue.setMaximumSize(w, h)
self.satValue.setText(
str("{:+d}".format(self.slider2Sat(self.sliderSat.value()))))
"""sat done event handler"""
def satUpdate(value):
self.satValue.setText(
str("{:+d}".format(self.slider2Sat(self.sliderSat.value()))))
# move not yet terminated or value not modified
if self.sliderSat.isSliderDown() or self.slider2Sat(
value) == self.satCorrection:
return
try:
self.sliderSat.valueChanged.disconnect()
self.sliderSat.sliderReleased.disconnect()
except RuntimeError:
pass
self.satCorrection = self.slider2Sat(self.sliderSat.value())
self.dataChanged.emit(
3) # no post processing and no camera profile stuff
self.sliderSat.valueChanged.connect(
satUpdate) # send new value as parameter
self.sliderSat.sliderReleased.connect(lambda: satUpdate(
self.sliderSat.value())) # signal has no parameter
self.sliderSat.valueChanged.connect(
satUpdate) # send new value as parameter
self.sliderSat.sliderReleased.connect(lambda: satUpdate(
self.sliderSat.value())) # signal has no parameter
# self.dataChanged.connect(self.updateLayer) # TODO 30/10/18 moved to base class
self.setStyleSheet("QListWidget, QLabel {font : 7pt;}")
# layout
l = QVBoxLayout()
l.addWidget(self.listWidget3)
hl01 = QHBoxLayout()
hl01.addWidget(QLabel('Camera Profile'))
hl01.addWidget(self.cameraProfilesCombo)
l.addLayout(hl01)
hl0 = QHBoxLayout()
hl0.addWidget(QLabel('Denoising'))
hl0.addWidget(self.denoiseCombo)
l.addLayout(hl0)
hl00 = QHBoxLayout()
hl00.addWidget(QLabel('Overexp. Restoration'))
hl00.addWidget(self.overexpCombo)
l.addLayout(hl00)
hl1 = QHBoxLayout()
hl1.addWidget(self.expLabel)
hl1.addWidget(self.expValue)
hl1.addWidget(self.sliderExp)
l.addLayout(hl1)
hl8 = QHBoxLayout()
hl8.addWidget(brLabel)
hl8.addWidget(self.brValue)
hl8.addWidget(self.sliderBrightness)
l.addLayout(hl8)
l.addWidget(self.listWidget1)
self.listWidget2.setStyleSheet(
"QListWidget {border: 0px;} QListWidget::item {border: 0px; padding-left: 20px;}"
)
vl1 = QVBoxLayout()
vl1.addWidget(QLabel('White Balance'))
vl1.addWidget(self.listWidget2)
gb1 = QGroupBox()
gb1.setStyleSheet(
"QGroupBox {border: 1px solid gray; border-radius: 4px}")
hl2 = QHBoxLayout()
hl2.addWidget(self.tempLabel)
hl2.addWidget(self.tempValue)
hl2.addWidget(self.sliderTemp)
hl3 = QHBoxLayout()
hl3.addWidget(self.tintLabel)
hl3.addWidget(self.tintValue)
hl3.addWidget(self.sliderTint)
vl1.addLayout(hl2)
vl1.addLayout(hl3)
gb1.setLayout(vl1)
l.addWidget(gb1)
hl4 = QHBoxLayout()
hl4.addWidget(self.contLabel)
hl4.addWidget(self.contValue)
hl4.addWidget(self.sliderCont)
hl7 = QHBoxLayout()
hl7.addWidget(satLabel)
hl7.addWidget(self.satValue)
hl7.addWidget(self.sliderSat)
# separator
sep = QFrame()
sep.setFrameShape(QFrame.HLine)
sep.setFrameShadow(QFrame.Sunken)
l.addWidget(sep)
l.addLayout(hl4)
l.addLayout(hl7)
l.addStretch(1)
self.setLayout(l)
self.adjustSize()
self.setDefaults()
self.setWhatsThis("""<b>Development of raw files</b><br>
<b>Default settings</b> are a good starting point.<br>
A <b>Tone Curve</b> is applied to the raw image prior to postprocessing.<br>
The cuvre can be edited by checking the option
<b>Show Tone Curve</b>; this option works best with manual exposure.<br>
<b>Contrast</b> correction is based on an automatic algorithm
well suited to multi-mode histograms.<br>
<b>Brightness, Contrast</b> and <b>Saturation</b> levels</b> are
adjustable with the correponding sliders.<br>
The <b>Contrast Curve</b> can be edited manually by checking
the option <b>Show Contrast Curve</b>.<br>
Uncheck <b>Auto Expose</b> to adjust the exposure manually.<br>
The <b>OverExp. Rest.</b> slider controls the mode of restoration of overexposed areas.
Valid values are 0 to 3 (0=clip;1=unclip;2=blend;3=rebuild); (with Auto Exposed
checked the mode is clip).<br>
""") # end of setWhatsThis
def __init__(self, targetImage=None, axeSize=500, layer=None, parent=None):
super().__init__(layer=layer, targetImage=targetImage, parent=parent)
# self.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred)
# self.setMinimumSize(axeSize, axeSize)
# self.setAttribute(Qt.WA_DeleteOnClose)
# back links to image
# self.targetImage = weakProxy(targetImage)
# self.img = weakProxy(targetImage)
# self.layer = weakProxy(layer)
# options
options_dict = {
'Normal Clone': cv2.NORMAL_CLONE,
'Mixed Clone': cv2.MIXED_CLONE,
'Monochrome Transfer': cv2.MONOCHROME_TRANSFER
}
options = list(options_dict.keys())
self.layer.cloningMethod = options_dict['Normal Clone']
self.layer.maskIsEnabled = True
self.layer.maskIsSelected = True
# mask all pixels, use a semi transparent mask
self.layer.resetMask(maskAll=True, alpha=128)
self.layer.autoclone = False # cloning is slow : no cloning is performed by applyToStack() calls
self.layer.cloningMethod = cv2.NORMAL_CLONE
self.options = {}
for op in options:
self.options[op] = False
self.listWidget1 = optionsWidget(options=options, exclusive=True)
sel = options[0]
self.listWidget1.select(self.listWidget1.items[sel])
self.options[sel] = True
# select slot
def onSelect1(item):
for key in self.options:
self.options[key] = item is self.listWidget1.items[key]
if self.options[key]:
self.layer.cloningMethod = options_dict[key]
self.listWidget1.onSelect = onSelect1
# set initial selection to normal cloning
item = self.listWidget1.items[options[0]]
item.setCheckState(Qt.Checked)
self.listWidget1.select(item)
pushButton1 = QPushButton('Clone')
# Clone button clicked slot
def f():
layer = self.layer
if vImage.isAllMasked(layer.mask):
dlgWarn('Nothing to clone: unmask some pixels')
return
if layer.xAltOffset == 0.0 and layer.yAltOffset == 0.0:
dlgWarn('Nothing to clone: Ctr+Alt+Drag the image ')
return
layer.applyCloning(seamless=True)
layer.parentImage.onImageChanged()
pushButton1.clicked.connect(f)
pushButton2 = QPushButton('Reset')
# reset button clicked slot
def g():
layer = self.layer
# mask all pixels
layer.resetMask(maskAll=True, alpha=128)
layer.setMaskEnabled(color=True)
# reset clone layer
layer.xAltOffset, layer.yAltOffset = 0.0, 0.0
layer.AltZoom_coeff = 1.0
layer.applyCloning(seamless=False, showTranslated=True)
layer.parentImage.onImageChanged()
pushButton2.clicked.connect(g)
# layout
layout = QVBoxLayout()
layout.setContentsMargins(20, 0, 20, 25) # left, top, right, bottom
self.setLayout(layout)
layout.addWidget(self.listWidget1)
hl = QHBoxLayout()
hl.addWidget(pushButton1)
hl.addWidget(pushButton2)
layout.addLayout(hl)
self.setDefaults()
self.setWhatsThis("""
<b>Cloning</b> :
Seamless replacement of a region of the image by another region from the same image
(e.g. to erase an object):<br>
1) Select the Unmask/FG tool and paint the pixels to erase
(use the Mask/BG tool to adjust if needed); <br>
2) Select the drag tool and while pressing <b>Ctrl-Alt</b>, drag
or zoom the image shown in the painted region with the mouse;<br>
3) Click the Clone button to start the cloning.<br>
Redo steps 1 to 3 until the result is satisfactory. Eventually
use <b>Mask Erode</b> from the layer context menu to smooth mask edges.<br>
<b> While executing steps 1 to 4 above, make sure that
the cloning layer is the topmost visible layer</b><br>
""") # end of setWhatsthis
def __init__(self,
targetImage=None,
axeSize=500,
layer=None,
parent=None,
mainForm=None):
super(transForm, self).__init__(parent=parent)
self.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred)
self.setMinimumSize(axeSize, axeSize)
self.setAttribute(Qt.WA_DeleteOnClose)
# back links to image
self.targetImage = weakProxy(targetImage)
self.img = weakProxy(targetImage)
self.layer = weakProxy(layer)
self.mainForm = mainForm
# options
optionList1, optionNames1 = ['Free', 'Rotation', 'Translation'], [
'Free Transformation', 'Rotation', 'Translation'
]
self.listWidget1 = optionsWidget(options=optionList1,
optionNames=optionNames1,
exclusive=True)
optionList2, optionNames2 = ['Transparent'
], ['Set Transparent Pixels To Black']
self.listWidget2 = optionsWidget(options=optionList2,
optionNames=optionNames2,
exclusive=False)
self.options = UDict(
(self.listWidget1.options, self.listWidget2.options))
# set initial selection to Perspective
self.listWidget1.checkOption(optionList1[0])
# option changed handler
def g(item):
l = self.layer
l.tool.setBaseTransform()
#self.layer.tool.setVisible(True)
l.applyToStack()
l.parentImage.onImageChanged()
self.listWidget1.onSelect = g
self.listWidget2.onSelect = g
pushButton1 = QPushButton(' Reset Transformation ')
pushButton1.adjustSize()
def f():
self.layer.tool.resetTrans()
pushButton1.clicked.connect(f)
# layout
l = QVBoxLayout()
l.setAlignment(Qt.AlignTop)
l.addWidget(self.listWidget1)
l.addWidget(self.listWidget2)
hl = QHBoxLayout()
hl.setAlignment(Qt.AlignHCenter)
hl.addWidget(pushButton1)
l.addLayout(hl)
self.setLayout(l)
self.adjustSize()
self.setWhatsThis("""
<b>Geometric transformation :</b><br>
Choose a transformation type and drag either corner of the image using the small square red buttons.<br>
Ctrl+Alt+Drag to change the <b>initial positions</b> of buttons.
""")
