Colormetry Problem (suche Formeln für Koeffizienten)

SagaraS

Hallo,

ich habe ein Problem in Bezug auf das Plugin ManualColorMatrix.

Und zwars suche ich die Formeln zur Errechnung der Matrix Koeffizienten.

Ich habe schon angefangen, aber die Werte für den UV Bereich kann ich irgendwie nicht ermitteln. Und zwars orientiere ich mich im Thread vom Plugin an das Beispiel mit der RGB -> YV24 Konvertierung mit BT.601 range 16-235

Daraus würde ich gerne ein Skript schreiben der mir anhand der 3 Kern Koeffizienten die anderen Koeffizienten errechnet.

Hier mal das was ich bisher habe (Als Kommentar daneben die Werte die rauskommen sollten):

Code

#BT.601Kr = 0.299
Kg = 0.587
Kb = 0.114




Range = 219. / 255 # TV Range = 219. / 255 (16 - 235) ; PC Range = 255. / 255 (0 - 255)




yy = Range * Kr
yu = Range * Kg
yv = Range * Kb




#Formel ?
uy = 0 #-0.148223
uu = 0 #-0.290992
uv = 0 #0.439215




vy = 0 #0.439215
vu = 0 #-0.367789
vv = 0 #-0.071426




BlankClip().Subtitle("yy = " + string(yy) + ", yu = " + string(yu) + ", yv = " + string(yv) \
                           + "\nuy = " + string(uy) + ", uu = " + string(uu) + ", uv = " + string(uv) \
                           + "\nvy = " + string(vy) + ", vu = " + string(vu) + ", vv = " + string(vv), lsp = 1)




# -> http://forum.doom9.org/showthread.php?t=161777
# ManualColorMatrix(0, yy, yu, yv, uy, uu, uv, vy, vu, vv, 16.0, 128.0, 128.0)

Alles anzeigen

Suchen tuhe ich die Formeln um die Koeffizienten für uy, uu, uv, vy, vu und vv zu errechnen aus den Werten die mir bekannt sind. Hoffe das mir da jemand helfen kann.

LigH

Basis der Berechnungen sind Verhältnisgleichungen (meist als Matrizen) zur Umrechnung zwischen RGB und YCbCr nach ITU-R, die auch in der englischen Wikipedia (YCbCr bzw. YUV) erwähnt werden; sich daraus Formeln zur direkten Berechnung aus RGB oder zwischen den YUV-Varianten herzuleiten ist aber etwas aufwändig... Ich vermute mal, dass man in Quelltexten zu ColorYUV-Funktionen und ähnlichen Plugins was findet. Verbreitet sind v.a. die Standards Rec. 601, Rec. 709 und Rec. 2020, auch wenn "Rec." wohl von "recommendation" = "Empfehlung" stammt.

SagaraS

Ich hab nach langen Suchen etwas gefunden gehabt wodurch ich dann auch endlich die entsprechenden anderen Koeffizienten herbekommen habe.

Für die, denen es interessiert erkläre ich es mal:

Man findet oft nur im Netz nur 2 Koeffizienten für die Farbmatrix.
Daraus kann man dann den 3ten Koeffizienten ermitteln.

Bsp:
Kr = 0.299
Kb = 0.114
Kg = 1 - Kr - Kb = 1 - 0.299 - 0.114 = 0.587

Das sind die Basis Koeffizienten für den Luma (Y) Anteil.

Die Koeffizienten des Luma müssen zusammen 1 ergeben

Für den U und V Bereich des Chroma muss die Summe 0 ergeben.

Bedeutet folgendes Schema für die Matrix:

HTML

|Y|    |      0.299   0.587       0.114  |   |  0.299  0.587  0.114 ||U| =  |     -0.299  -0.587  (1 - 0.114) | = | -0.299 -0.587  0.886 ||V|    | (1 - 0.299) -0.587      -0.114  |   |  0.701 -0.587 -0.114 |

Dann muss für Kr und Kb die Scala von 1 auf -0.5 und +0.5 erstellt werden. Das heißt die Werte die in der Matrix von 1 abgezogen wurden eben, sind die 0.5 Werte. Die beiden daneben stehenden Zahlen müssen dann zusammen -0.5 ergeben. Sodass halt am Ende 0 herauskommt.

Das macht man wie folgt:

HTML

Pb_diff = 0.5 / (1 - 0.114)Pr_diff = 0.5 / (1 - 0.299)

Aus diesen Werten kann man dann die fehlenden Koeffizienten ermitteln:

HTML

|Y|   |   0.299              0.587              0.114            |   |  0.299     0.587     0.114    ||U| = | (-0.299 * Pb_diff) (-0.587 * Pb_diff)   0.5              | = | -0.168736 -0.331264  0.5      ||V|   |   0.5              (-0.587 * Pr_diff) (-0.114 * Pr_diff) |   |  0.5      -0.418688 -0.081312 |

Diese 9 Koeffizienten in der Matrix werden dann noch mit der Farb-Range multipliziert.
Diese ergibt sich aus:

HTML

RangeMin = 16RangeMax = 235Range = (RangeMax - RangeMin) / 255 = 219 / 255

Bedeutet für TV Range (16 - 235) ergibt sich der Wert: 0,85882352941176470588235294117647...

Und dann hat man alle Werte für das Plugin ManualColorMatrix

In AVISynth sieht das so aus dann:

Code

# BT.601 TV Range
Kr = 0.299
Kg = 0.587 # = 1 - Kr - Kb
Kb = 0.114




Rmin = 16.
Rmax = 235.




Range = (Rmax - Rmin) / 255.




yy = Kr * Range
yu = Kg * Range
yv = Kb * Range




Pb = 0.5 / (1. - Kb)
Pr = 0.5 / (1. - Kr)




uy = -Kr * Pb * Range
uu = -Kg * Pb * Range
uv = 0.5 * Range




vy = 0.5 * Range
vu = -Kg * Pr * Range
vv = -Kb * Pr * Range




BlankClip().Subtitle("yy = " + string(yy) + ", yu = " + string(yu) + ", yv = " + string(yv) \
      + "\nuy = " + string(uy) + ", uu = " + string(uu) + ", uv = " + string(uv) \
      + "\nvy = " + string(vy) + ", vu = " + string(vu) + ", vv = " + string(vv), lsp = 1)




ManualColorMatrix(0, yy, yu, yv, uy, uu, uv, vy, vu, vv, Rmin, 128.0, 128.0)

Alles anzeigen

LigH

Ich glaube, am Anfang ist dir ein Zeilenumbruch verloren gegangen:

Code

# BT.601 TV Range| « das folgende sieht aus, als wäre die Zuweisung nützlich:
Kr = 0.299

Und viel mehr als 4 Nachkommastellen brauchst du sicher nicht, um für 8 bit hinreichend exakt zu rechnen.

SagaraS

Aber ich habe es herausbekommen xD

So doof hab ich gar nicht erst gedacht. Aber wenn man das erst mal weiß ist das gut

Die Quelle wie ich dazu gekommen bin habe ich aus einer Leseprobe aus einem E-Book entnommen: https://books.google.de/books?id=MUQ31…epage&q&f=false

Auf Seite 301 (Link führt auf die entsprechende Seite) wird erklärt wie das funktioniert.

Joa. Und die Zuweisungen sind halt die Kern-Koeffizienten für den Luma. Das andere errechnet sich daraus.

Sprich man gibt min. 2 Koeffizienten der jeweiligen Farbmatrix an + den Farbbereich.

Ist ziemlich cool. Weil ich nun damit auch meine RGB Videos in YUV BT.2020 konvertieren kann. Und x264 sollte denk ich auch BT.2020 unterstützen.
Mal sehen wie die 4K Auflösungen damit aussehen.

LigH

Zitat von SagaraS

Und x264 sollte denk ich auch BT.2020 unterstützen.

Tut es:

Code

--colorprim <string>    Specify color primaries ['undef']
                                  - undef, bt709, bt470m, bt470bg, smpte170m,
                                    smpte240m, film, bt2020
      --transfer <string>     Specify transfer characteristics ['undef']
                                  - undef, bt709, bt470m, bt470bg, smpte170m,
                                    smpte240m, linear, log100, log316,
                                    iec61966-2-4, bt1361e, iec61966-2-1,
                                    bt2020-10, bt2020-12
      --colormatrix <string>  Specify color matrix setting ['???']
                                  - undef, bt709, fcc, bt470bg, smpte170m,
                                    smpte240m, GBR, YCgCo, bt2020nc, bt2020c

Alles anzeigen

Jetzt brauch ich nur noch eine Anleitung, wie man die drei Parameter von ihrem Sinn und Zweck her unterscheidet...

SagaraS

Zitat von LigH

Tut es:

Code

--colorprim <string>    Specify color primaries ['undef']                                  - undef, bt709, bt470m, bt470bg, smpte170m,                                    smpte240m, film, bt2020      --transfer <string>     Specify transfer characteristics ['undef']                                  - undef, bt709, bt470m, bt470bg, smpte170m,                                    smpte240m, linear, log100, log316,                                    iec61966-2-4, bt1361e, iec61966-2-1,                                    bt2020-10, bt2020-12      --colormatrix <string>  Specify color matrix setting ['???']                                  - undef, bt709, fcc, bt470bg, smpte170m,                                    smpte240m, GBR, YCgCo, bt2020nc, bt2020c

Jetzt brauch ich nur noch eine Anleitung, wie man die drei Parameter von ihrem Sinn und Zweck her unterscheidet...

Also bezüglich der Farbmatrix kann man sich zur Kontrolle FFMS2 sich zu Rate ziehen.

Und zwars läd man da die FFMS2.avsi wo man dann im Skript die FFInfo() aufrufen tut. Das encodierte x264 Video muss dann natürlich auch via FFMS2 geladen werden. Sonst geht es nicht.

Und dann kann man sich schon mal den Farbraum bezüglich der Matrix anschauen. Diese werden aus dem Parameter --colormatrix entnommen das man vorher beim x264 Encoder angegeben hat.

Dabei ist z.B. smpte170m das gleiche wie BT.601, bt470bg (Ist ein Update von BT.601) und smpte240m entspricht fast BT.709. BT.2020 gibt es einmal in einer Nicht Konstanten und einmal in einer Konstanten Form.

Das sind erst mal die wichtigsten die häufig genutzt werden denk ich.

Wenn man ohne der Angabe von --colormatrix das Video encodieren tut, steht der Wert auf undef - Undefiniert. x264 encodiert dann in BT.709, nach der Analyse mit FFMS2.

Also ist das schon mal die wichtigste Angabe in Bezug der Farbmatrix.

Mit dieser Angabe sorgt der Encoder dafür das die entsprechenden Koeffizienten der angegeben Farbmatrix nutzen.

--transfer sorgt dafür das die Charakteristika einer Farbmatrix mit dem der angegeben Farbmatrix korrigiert wird. Meist wird da der Luma Bereich gerichtet, wärend der UV Bereich unangetastet bleibt.

Beispiel: Y entsprich nach dem Transfer BT.709 und UV entspricht den der Farbmatrix BT.601
Dann steht da sowas wie:

HTML

Transfer characteristics                 : BT.709Matrix coefficients                      : BT.601

Und --colorprim sorgt dafür das die Konvertierung von den Primärfarben in RGB gemacht werden können. Meist wird dann der Wert vom Transfer genommen, da der Helligkeitsanteil (Y) auch der Schlüssel den UV Bereich ist. Sprich damit es im Endeffekt nach der Konvertierung wieder eine PC Range hat, obwohl das Video selbst eine TV Range besitzt.

Wenn alle Werte für diese 3 Angaben auf einen Nenner sind, dann wäre alles korrekt.

Ich denke mal das ich das so richtig aus dem Netz entnehmen konnte. Weiß jetzt aber nicht 100% ob das so stimmt. Auf jedenfall kann ich den Parameter --colormatrix eindeutig belegen mit FFMS2.

Edit:
Habe für das ManualColorMatrix Plugin eine Funktion für AVISynth geschrieben.
Wer es nutzen möchte, nur zu

Code

LoadPlugin(".\Plugins\PlanarTools.dll")
LoadPlugin(".\Plugins\ManualColorMatrix_26.dll")


AVISource("G:\RGB_Video.avi").AssumeFPS(30, 1)


RGBtoYUV(4, "BT.709", false) # Output as YV12 with BT.709 colormatrix and limited (TV) range


# RGBtoYUV
# ---------------------
# mode: 0 - YV24, 1 - RGB24, 2 - RGB32, 3 - YUY2, 4 - YV12
# matrix: "BT.601", "BT.709", "BT.2020", "GBR", "FCC", "YCGCO", "OPP"
# range: false = TV range, true = PC range
# planer: true = YUY2 -> YV16, false = YUY2
# info: true = show info text
# fontsize: font size of info text




Function RGBtoYUV(clip clip0, int "mode", string "matrix", bool "range", bool "planer", bool "info", int "fontsize") {
    mode = Default(mode, 4)
    matrix = Default(matrix, "BT.709")
    range = Default(range, false)
    planer = Default(planer, false)
    info = Default(info, false)
    fontsize = Default(fontsize, 18)

    #BT.2020 , BT.709, BT.601, GBR, FCC, YCgCo and OPP base coefficients
    Kr = (ucase(matrix) == "BT.2020") ? 0.2627 : (ucase(matrix) == "BT.709") ? 0.2126 : (ucase(matrix) == "BT.601") ? 0.299 : (ucase(matrix) == "GBR") ? 0 : (ucase(matrix) == "FCC") ? 0.30 : (ucase(matrix) == "YCGCO") ? 0.25 : (ucase(matrix) == "OPP") ? 1. / 3. : 9
    Kg = (ucase(matrix) == "BT.2020") ? 0.6780 : (ucase(matrix) == "BT.709") ? 0.7152 : (ucase(matrix) == "BT.601") ? 0.587 : (ucase(matrix) == "GBR") ? 1 : (ucase(matrix) == "FCC") ? 0.59 : (ucase(matrix) == "YCGCO") ? 0.50 : (ucase(matrix) == "OPP") ? 1. / 3. : 9
    Kb = (ucase(matrix) == "BT.2020") ? 0.0593 : (ucase(matrix) == "BT.709") ? 0.0722 : (ucase(matrix) == "BT.601") ? 0.114 : (ucase(matrix) == "GBR") ? 0 : (ucase(matrix) == "FCC") ? 0.11 : (ucase(matrix) == "YCGCO") ? 0.25 : (ucase(matrix) == "OPP") ? 1. / 3. : 9

    #Standard coefficients for output
    matrix = (Kr == 9 && Kg == 9 && Kb ==9) ? "BT.709" : matrix
    Kr = (Kr == 9) ? 0.2126 : Kr
    Kg = (Kg == 9) ? 0.7152 : Kg
    Kb = (Kb ==9) ? 0.0722 : Kb

    # Color range
    Rmin = (range == false) ? 16. : 0.
    Rmax = (range == false) ? 235. : 255.
    cRange = (Rmax - Rmin) / 255.
    URange = 256 / 2.
    VRange = 256 / 2.

    UaRange = URange / 256.
    VaRange = Vrange / 256.




    # Colormetry
    # Luma
    # Y channel
    yy = Kr * cRange
    yu = Kg * cRange
    yv = Kb * cRange

    # Chroma
    # Change the value from 0 <-> 1 to -0.5 <-> 0.5
    Pb = UaRange / (1. - Kb)
    Pr = VaRange / (1. - Kr)

    # U channel
    uy = -Kr * Pb * cRange
    uu = -Kg * Pb * cRange
    uv = UaRange * cRange

    # V channel
    vy = VaRange * cRange
    vu = -Kg * Pr * cRange
    vv = -Kb * Pr * cRange

    # Convert video in the colorspace with manual colormatrix from the colormetry
    clip0 = clip0.ManualColorMatrix(mode, yy, yu, yv, uy, uu, uv, vy, vu, vv, Rmin, URange, VRange)

    # Colorspace info for info text output
    co = (mode == 0) ? "YV24" : (mode == 1) ? "RGB24" : (mode == 2) ? "RGB32" : (mode == 3) ? "YUY2" : "YV12"
    co = (mode == 3) ? (planer == true) ? "YV16" : co : co

    # Convert packed format to planar format without changing the pixel values. (YUY2 -> YV16 for avs4x264mod pipeline)
    clip0 = (mode == 3) ? (planer == true) ? clip0.PackedToPlanar() : clip0 : clip0

    range = (range == true) ? "Full (0 - 255) | PC Range" : "Limited (16 - 235) | TV Range"

    matrix = (ucase(matrix) == "GBR") ? "GBR (RGB Matrix)" : matrix

    # Return clip or clip with info text for user
    return (info == true) ? clip0.Subtitle("Colorspace: " + co + "\nMatrix: " + ucase(matrix) + "\nRange: " + string(range) + "\n\nMatrix" \ 
      + "\nY | yy: " + string(yy) + ", yu:  " + string(yu) + ", yv: " + string(yv) + ", yadd = " + string(Rmin)  + ", (" + string(int(Rmin)) + " - " + string(int(Rmax)) + ")" \
      + "\nU | uy: " + string(uy) + ", uu: " + string(uu) + ", uv: " + string(uv) + ", uadd = " + string(URange) + ", (" + string(int(Rmin)) + " - " + string(int(Rmax)) + ")" \
      + "\nV | vy: " + string(vy) + ", vu: " + string(vu) + ", vv: " + string(vv) + ", vadd = " + string(VRange) + ", (" + string(int(Rmin)) + " - " + string(int(Rmax)) + ")", lsp = 1, size = fontsize) : clip0 
}

Alles anzeigen

LigH

Nachdem im VideoHelp-Forum das Thema aufkam, und ich im doom9-Forum auch was passendes fand, wollte ich hier noch mal auf das YCgCo-Farbmodell eingehen.

Wie andere YUV-Farbmodelle auch, handelt es sich um ein Farbdifferenzmodell, das im Vergleich zu RGB mit drei gleichwertigen Komponenten eher eine mittlere Helligkeit und vom neutralen Grau abweichende Farbdifferenzen codiert und dabei ausnutzt, dass Änderungen in der Helligkeit für den Menschen auffälliger sind als Änderungen in der Farbigkeit. Während die Koeffizienten für die Umrechnung der Farbräume von RGB in YCbCr nach ITU-R BT.601 bzw. BT.709 aus den Leuchteigenschaften von Bildschirmen (CRT, LCD/Plasma) abgeleitet wurden, verwendet YCgCo dagegen Koeffizienten, die binär sehr schnell und verlustarm zu berechnen sind:

YCgCo.png

Außerdem erwähnt die Wikipedia eine bessere Dekorrelation (Unabhängigkeit der Farbdifferenzen voneinander, da sie zueinander rechtwinklig im RGB-Raum stehen, was bei ITU-R wohl nicht ganz der Fall ist).

Einige Encoder unterstützen diesen Farbraum auch intern, wenn man dies per Parameter angibt (x264, x265: --colormatrix YCgCo zusammen mit --range pc --input-range pc bzw. --range full). AviSynth sollte damit weitgehend umgehen können, da für die meisten Funktionen nur das grundlegende Farbmodell YUV und die Speicherorganisation interessant sind; zur Konvertierung kann man das Plugin ConvertToYCgCo verwenden, bzw. ManualColorMatrix. Am PC unterstützt u.a. madVR die Wiedergabe.

Ich bin neugierig, ob AviSynth+ vielleicht durch die Unterstützung größerer Farbtiefe hier auch einen Vorteil sieht, denn verlustlose Konvertierung von und zu RGB wäre bereits mit nur einem zusätzlichen Bit für die Chrominanz-Differenzwerte möglich.

Colormetry Problem (suche Formeln für Koeffizienten)

Jetzt mitmachen!

Benutzer online in diesem Thema