Holen Sie sich das QColor an einer willkürlichen Position innerhalb des 0-1-Bereichs eines Qgradienten ⇐ C++

[Anonymous]

objektiv
Ich möchte die visuelle Farbe an einer willkürlichen Position innerhalb des 0.0 -

Code: Select all

1.0

Bereich eines bestimmten Qgradienten. schien vernünftig. Die Endwerte der Animation müssen ebenfalls mit der relativen ersten und letzten Farbe festgelegt werden. Implementierung: < /p>
Beachten Sie, dass ich keinen C ++ - Code schreiben kann. Daher werde ich Python -basierten Code für die folgenden Beispiele bereitstellen. C ++ basierende Antworten werden jedoch auch gut empfangen.

Code: Select all

def gradientColorAt(grad, pos):
if pos = 1:
return grad.stops()[-1][1]
ani = QVariantAnimation()
ani.setDuration(1000)
startDone = False
for stop, color in grad.stops():
if not startDone:
startDone = True
ani.setStartValue(color)
if not stop:
continue
ani.setKeyValueAt(stop, color)
if stop < 1:
ani.setEndValue(color)
ani.setCurrentTime(round(1000 * pos))
return ani.currentValue()

Die obige funktioniert anscheinend einwandfrei, solange alle Farben vollständig undurchsichtig sind. Ich erkannte später, dass ein ähnlicher Beitrag in einigen seiner Antworten auch einen ähnlichen Ansatz vorschlug. /> qt scheint der Konvention zu folgen, die auch in modernen Webbrowsern verwendet wird, für die die Übergänge zwischen Farben nicht streng lineare Werte in ihren Komponenten folgen (rot, grün, blau und alpha), auch wenn man die "transparente" Farbe basierend auf dem möglichen Übergang zu einer anderen Farbe berücksichtigt, und obwohl das Konzept der transparenten < /code> transparent ist, ist ". Qcolor (qt.transparent) ist genau qcolor (0, 0, 0, 0) . Obwohl Qcolor (255, 0, 0, 0) das gleiche Ergebnis für die Zwecke von Gradienten in sowohl Qt als auch gemeinsame Browser haben würde, ist es nicht dieselbe Farbe.

Code: Select all

from PyQt5.QtCore import *
from PyQt5.QtGui import *
from PyQt5.QtWidgets import *

app = QApplication([])

win = QWidget()
lay = QVBoxLayout(win)

grad = QLinearGradient(0, 0, 1, 0)
grad.setCoordinateMode(grad.ObjectBoundingMode)
grad.setColorAt(1, Qt.green)

transBlack = QColor(Qt.transparent)
transRed = QColor(255, 0, 0, 0)
pal = app.palette()

for color in (transBlack, transRed):
grad.setColorAt(0, color)
pal.setBrush(QPalette.Window, QBrush(grad))
widget = QWidget()
widget.setAutoFillBackground(True)
widget.setPalette(pal)
lay.addWidget(widget)

win.resize(400, 400)
win.show()

app.exec()

Und hier ist das Ergebnis:


Final request
Während der letzte Versuch wie erwartet funktioniert, gefällt es mir aus den folgenden Gründen nicht wirklich: < /p>

[*] Soweit ich verstehen kann, erstellt QT bereits einen internen "Farbtabellen" -Cache, und obwohl es offensichtlich nicht extern zugegriffen werden kann, scheinen die Farbwerte zu erstellen, die nicht sehr effizient sind. vermutete basierend auf den Pixeldaten von Qimage;
Aufgrund all der oben genannten müsste jede temporäre Berechnung von Zwischenfarben eine Qvariantanimation erstellen. Um korrekte Farbwerte bereitzustellen, wie in einem visuell gestrichenen Gradienten von qt? Es scheint, dass Qgradient/Qbrush es ermöglicht, zwei verschiedene Arten von Interpolationen festzulegen (

Code: Select all

ColorInterpolation

und componentInterpolation ): Was ist der Unterschied? Ergibt sich eine von diesen dazu, dass die lineare Berechnung, die von Qvariantanimation verwendet wird, tatsächlich tut? Ist es möglich, das entgegengesetzte Verhalten Malerei zu erhalten, nur nach linearer Berechnung?