glColorTable: Unterschied zwischen den Versionen

Aus DGL Wiki
Wechseln zu: Navigation, Suche
(Beschreibung)
K (Link korrigiert)
 
(9 dazwischenliegende Versionen von 3 Benutzern werden nicht angezeigt)
Zeile 1: Zeile 1:
{{Unvollständig}}
+
= glColorTable =
 +
 
  
= glColorTable =
 
  
<br>
 
 
== Name ==
 
== Name ==
 
'''glColorTable''' - definiert eine Lookup-Tabelle für Farben.
 
'''glColorTable''' - definiert eine Lookup-Tabelle für Farben.
Zeile 32: Zeile 31:
 
|-
 
|-
 
! ''table''
 
! ''table''
| Ein Pointer zu einem eindimensionalen Array mit Pixeldaten, der dazu verwendet wird, die Farb-Tabelle zu erzeugen.
+
| Ein Pointer zu einem eindimensionalen Array mit Pixeldaten, der dazu verwendet wird, die Farbtabelle zu erzeugen.
 
|}
 
|}
  
  
 
== Beschreibung ==  
 
== Beschreibung ==  
'''glColorTable''' kann für zwei Methoden verwendet werden: Um die aktuelle Größe und Farb-Auflösung einer Lookup-Tabelle mit einem bestimmten Satz von Parametern zu testen, oder um die Inhalte einer Farb-Lookup-Tabelle zu laden. Für den ersten Fall benutze man für die ''target''s '''GL_PROXY_*''', für den zweiten die anderen Konstanten.
+
'''glColorTable''' kann für zwei Methoden verwendet werden: Um die aktuelle Größe und Farb-Auflösung einer Lookup-Tabelle mit einem bestimmten Satz von Parametern zu testen, oder um die Inhalte einer Farbtabelle zu laden. Für den ersten Fall benutze man für die ''target''s '''GL_PROXY_*''', für den zweiten die anderen Konstanten.
  
  
Wenn ''target'' den Wert '''GL_COLOR_TABLE''', '''GL_POST_CONVOLUTION_COLOR_TABLE''' oder      '''GL_POST_COLOR_MATRIX_COLOR_TABLE''' hat, erzeugt '''glColorTable''' eine Farb-Lookup-Tabelle aus einem Array von Pixeln. Das Pixelarray - spezifiziert mit ''width'', ''format'', ''type'' und ''table'' - wird aus dem Speicher geholt und verarbeitet, wie wenn [[glDrawPixels]] aufgerufen worden wäre, aber die Verarbeitung hält, nachdem die finale Verarbeitung nach RGBA vervollständigt wurde.
+
Wenn ''target'' den Wert '''GL_COLOR_TABLE''', '''GL_POST_CONVOLUTION_COLOR_TABLE''' oder      '''GL_POST_COLOR_MATRIX_COLOR_TABLE''' hat, erzeugt '''glColorTable''' eine Farbtabelle aus einem Array von Pixeln. Das Pixelarray - spezifiziert mit ''width'', ''format'', ''type'' und ''table'' - wird aus dem Speicher geholt und verarbeitet, wie wenn [[glDrawPixels]] aufgerufen worden wäre, aber die Verarbeitung hält, nachdem die finale Verarbeitung nach RGBA vervollständigt wurde.
  
  
Zeile 77: Zeile 76:
  
  
Wenn ''target'' vom Typ '''GL_PROXY_*''' ist, berechnet und speichert '''glColorTable''' die Werte der Proxy-Farb-Tabelle für '''GL_COLOR_TABLE_FORMAT, '''GL_COLOR_TABLE_WIDTH''', '''GL_COLOR_TABLE_RED_SIZE''', '''GL_COLOR_TABLE_GREEN_SIZE''', '''GL_COLOR_TABLE_BLUE_SIZE''', '''GL_COLOR_TABLE_ALPHA_SIZE''', '''GL_COLOR_TABLE_LUMINANCE_SIZE''' und '''GL_COLOR_TABLE_INTENSITY_SIZE'''. Das hat keine Auswirkungen auf das Bild oder den Zustand irgendeiner aktiven Farb-Tabelle. Wenn die angegebene Farb-Tabelle zu groß ist, um unterstützt zu werden, werden alle Proxy-State-Variablen, die oben genannt wurden, auf 0 gesetzt. Anderenfalls wird die Farb-Tabelle durch '''glColorTable''' unterstützt und die Proxy-State-Variablen werden so gesetzt, als wenn ''target'' festgelegt worden wäre.
+
Wenn ''target'' vom Typ '''GL_PROXY_*''' ist, berechnet und speichert '''glColorTable''' die Werte der Proxy-Farb-Tabelle für '''GL_COLOR_TABLE_FORMAT''', '''GL_COLOR_TABLE_WIDTH''', '''GL_COLOR_TABLE_RED_SIZE''', '''GL_COLOR_TABLE_GREEN_SIZE''', '''GL_COLOR_TABLE_BLUE_SIZE''', '''GL_COLOR_TABLE_ALPHA_SIZE''', '''GL_COLOR_TABLE_LUMINANCE_SIZE''' und '''GL_COLOR_TABLE_INTENSITY_SIZE'''. Das hat keine Auswirkungen auf das Bild oder den Zustand irgendeiner aktiven Farbtabelle. Wenn die angegebene Farbtabelle zu groß ist, um unterstützt zu werden, werden alle Proxy-State-Variablen, die oben genannt wurden, auf 0 gesetzt. Anderenfalls wird die Farbtabelle durch '''glColorTable''' unterstützt und die Proxy-State-Variablen werden so gesetzt, als wenn ''target'' festgelegt worden wäre.
  
  
Die Proxy-State-Variablen kann man durch einen Aufruf von [[glCetColorTableParameter]] mit dem Token '''GL_PROXY_*''' auslesen. Das macht es dem Programm möglich, zu entscheiden, ob ein bestimmter '''glColorTable'''-Befehl erfolgreich verlaufen würde und um herauszufinden, was die resultierenden Farb-Tabellen-Attribute wären.
+
Die Proxy-State-Variablen kann man durch einen Aufruf von [[glGetColorTableParameter]] mit dem Token '''GL_PROXY_*''' auslesen. Das macht es dem Programm möglich, zu entscheiden, ob ein bestimmter '''glColorTable'''-Befehl erfolgreich verlaufen würde und um herauszufinden, was die resultierenden Farbtabellen-Attribute wären.
  
  
Wenn eine Farb-Tabelle aktiviert ist und ihre Größe (''width'') nicht gleich 0 ist, dann werden ihre Inhalte dazu verwendet, einen Teil der Komponenten - basierend auf dem internen Format der Tabelle - jeder RGBA-Pixelgruppe zu ersetzen.
+
Wenn eine Farbtabelle aktiviert ist und ihre Größe (''width'') nicht gleich 0 ist, dann werden ihre Inhalte dazu verwendet, einen Teil der Komponenten - basierend auf dem internen Format der Tabelle - jeder RGBA-Pixelgruppe zu ersetzen.
  
  
Jede Pixelgruppe hat Farbkomponenten (R, G, B, A), die im Bereich [0.0,1.0] abgegeben sind. Die Farbkomponenten werden neu auf die Größe der Farb-Lookup-Tabelle skaliert. Dann wird ein Teil der Komponenten - basierend auf dem internen Format der Tabelle - durch den Eintrag, der durch ''index'' ausgewählt wurde, ersetzt. Die Farb-Komponenten und -Inhalte der Tabelle werden folgendermaßen dargestellt:
+
Jede Pixelgruppe hat Farbkomponenten (R, G, B, A), die im Bereich [0.0,1.0] abgegeben sind. Die Farbkomponenten werden neu auf die Größe der Farbtabelle skaliert. Dann wird ein Teil der Komponenten - basierend auf dem internen Format der Tabelle - durch den Eintrag, der durch ''index'' ausgewählt wurde, ersetzt. Die Farb-Komponenten und -Inhalte der Tabelle hängen folgendermaßen zusammen:
<b><i>
 
Representation    Meaning
 
        r                  Table index computed from R
 
        g                  Table index computed from G
 
        b                  Table index computed from B
 
        a                  Table index computed from A
 
        L[i]              Luminance value at table index i
 
        I[i]              Intensity value at table index i
 
        R[i]              Red value at table index i
 
        G[i]              Green value at table index i
 
        B[i]              Blue value at table index i
 
        A[i]              Alpha value at table index i
 
  
  
then the result of color table lookup is as follows:
+
{| border="1" rules="all"
 +
! '''Wert'''
 +
| '''Bedeutung'''
 +
|-
 +
! '''r'''
 +
| Aus R berechneter Tabellen-Index
 +
|-
 +
! '''g'''
 +
| Aus g berechneter Tabellen-Index
 +
|-
 +
! '''b'''
 +
| Aus B berechneter Tabellen-Index
 +
|-
 +
! '''L[i]'''
 +
| Beleuchtungswert bei Tabellenindex ''i''
 +
|-
 +
! '''I[i]'''
 +
| Intensitätswert bei Tabellenindex ''i''
 +
|-
 +
! '''R[i]'''
 +
| Rot-Wert bei Tabellenindex ''i''
 +
|-
 +
! '''G[i]'''
 +
| Grün-Wert bei Tabellenindex ''i''
 +
|-
 +
! '''B[i]'''
 +
| Blau-Wert bei Tabellenindex ''i''
 +
|-
 +
! '''A[i]'''
 +
| Alpha-Wert bei Tabellenindex ''i''
 +
|-
 +
|}
  
 +
Das Ergebnis der Farbtabelle sieht dann so as:
  
Table Internal    Resulting Texture Components
+
{| border="1" rules="all"
        Format             R     G     B     A
+
! Format
 
+
! R
        GL_ALPHA           R     G     B     A[a]
+
! G
        GL_LUMINANCE       L[r] L[g] L[b] At
+
! B
        GL_LUMINANCE_ALPHA L[r] L[g] L[b] A[a]
+
! A
        GL_INTENSITY       I[r] I[g] I[b] I[a]
+
|-
        GL_RGB             R[r] G[g] B[b] A
+
! GL_ALPHA
        GL_RGBA           R[r] G[g] B[b] A[a]
+
| R
 
+
| G
 +
| B
 +
| A[a]
 +
|-
 +
! GL_LUMINANCE
 +
| L[r]
 +
| L[g]
 +
| L[b]
 +
| At
 +
|-
 +
! GL_LUMINANCE_ALPHA
 +
| L[r]
 +
| L[g]
 +
| L[b]
 +
| A[a]
 +
|-
 +
! GL_INTENSITY
 +
| I[r]
 +
| I[g]
 +
| I[b]
 +
| I[a]
 +
|-
 +
! GL_RGB
 +
| R[r]
 +
| G[g]
 +
| B[b]
 +
| A
 +
|-
 +
! GL_RGBA
 +
| R[r]
 +
| G[g]
 +
| B[b]
 +
| A[a]
 +
|}
  
 
+
Wenn '''GL_COLOR_TABLE''' aktiviert ist, dann werden die Farben, die aus der Pixel-Verschiebungs-Operation (falls sie aktiviert ist) resultieren, anschließend auf die Farbtabelle gemapped, bevor sie an die [[Convolution]]-Operation weitergegeben werden. Die Farbem, die aus der Convolution-Operation kommen, werden druch die "Post-Convolution-Farb-Tabelle" modifizeirt, falls '''GL_POST_CONVOLUTION_COLOR_TABLE''' aktiviert ist. Diese modifizierten Farben werden dann an die Farb-Matrix-Operation gesendet. Abschließend werden - wenn '''GL_POST_COLOR_MATRIX_COLOR_TABLE''' aktiviert ist - die Farben, die aus der Farb-Matrix-Operation resultieren, durch die "Postcolor-Matrix-Farben-Lookup-Tabelle" gemapped, bevor die [[Histogramm]]-Operation angewendet wird.
When GL_COLOR_TABLE is enabled, the colors resulting from the pixel map
 
      operation  (if  it  is  enabled) are  mapped by the color lookup table
 
      before being passed to the convolution operation. The colors  resulting
 
      from  the  convolution  operation  are modified by the post convolution
 
      color lookup table  when  GL_POST_CONVOLUTION_COLOR_TABLE is  enabled.
 
      These  modified  colors  are  then  sent to the color matrix operation.
 
      Finally, if GL_POST_COLOR_MATRIX_COLOR_TABLE  is  enabled, the  colors
 
      resulting  from the color matrix operation are mapped by the post color
 
      matrix color lookup table before being used by the histogram operation.
 
 
 
</i></b>
 
  
 
== Hinweise ==
 
== Hinweise ==
Zeile 148: Zeile 189:
 
'''GL_TABLE_TOO_LARGE''' wird generiert, wenn die angeforderte Farbtabelle zu groß ist und wenn ''target'' gleichzeitig nicht vom Typ '''GL_PROXY_*''' ist.
 
'''GL_TABLE_TOO_LARGE''' wird generiert, wenn die angeforderte Farbtabelle zu groß ist und wenn ''target'' gleichzeitig nicht vom Typ '''GL_PROXY_*''' ist.
  
'''GL_INVALID_OPERATION''' wird generiert, wenn glColorTable innerhalb eines [[glBegin]]-[[glEnd]] Blocks aufgerufen wird.  
+
'''GL_INVALID_OPERATION''' wird generiert, wenn glColorTable innerhalb eines [[glBegin]]-[[glEnd]]-Blocks aufgerufen wird.  
 +
 
 +
 
  
<br>
 
  
 
== Zugehörige Wertrückgaben ==
 
== Zugehörige Wertrückgaben ==

Aktuelle Version vom 26. Juli 2011, 10:21 Uhr

glColorTable

Name

glColorTable - definiert eine Lookup-Tabelle für Farben.


Delphi-Spezifikation

procedure glColorTable(internalformat : GLenum; width : GLsizei; format : GLenum;
                       type : GLenum; const table PGLvoid)


Parameter

target Muss einer der folgenden Konstanten sein: GL_COLOR_TABLE, GL_POST_CONVOLUTION_COLOR_TABLE, GL_POST_COLOR_MATRIX_COLOR_TABLE, GL_PROXY_COLOR_TABLE, GL_PROXY_POST_CONVOLUTION_COLOR_TABLE oder GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE.
internalformat Die interne Farben-Tabelle. Zulässige Werte sind GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_ALPHA12, GL_ALPHA16, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, GL_LUMINANCE12, GL_LUMINANCE16, GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12, GL_LUMINANCE16_ALPHA16, GL_INTENSITY, GL_INTENSITY4, GL_INTENSITY8, GL_INTENSITY12, GL_INTENSITY16, GL_R3_G3_B2, GL_RGB, GL_RGB4, GL_RGB5, GL_RGB8, GL_RGB10, GL_RGB12, GL_RGB16, GL_RGBA, GL_RGBA2, GL_RGBA4, GL_RGB5_A1, GL_RGBA8, GL_RGB10_A2, GL_RGBA12 und GL_RGBA16.
width Die Anzahl der Einträge in der Farben-Lookup-Tabelle, die mit table angegeben wurde.
format Das Format der Pixeldaten in table. Zulässig sind GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_LUMINANCE, GL_LUMINANCE_ALPHA, GL_RGB, GL_BGR, GL_RGBA und GL_BGRA.
type Der Typ der Pixeldaten in table. Zulässig sind GL_UNSIGNED_BYTE, GL_BYTE, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2 und GL_UNSIGNED_INT_2_10_10_10_REV.
table Ein Pointer zu einem eindimensionalen Array mit Pixeldaten, der dazu verwendet wird, die Farbtabelle zu erzeugen.


Beschreibung

glColorTable kann für zwei Methoden verwendet werden: Um die aktuelle Größe und Farb-Auflösung einer Lookup-Tabelle mit einem bestimmten Satz von Parametern zu testen, oder um die Inhalte einer Farbtabelle zu laden. Für den ersten Fall benutze man für die targets GL_PROXY_*, für den zweiten die anderen Konstanten.


Wenn target den Wert GL_COLOR_TABLE, GL_POST_CONVOLUTION_COLOR_TABLE oder GL_POST_COLOR_MATRIX_COLOR_TABLE hat, erzeugt glColorTable eine Farbtabelle aus einem Array von Pixeln. Das Pixelarray - spezifiziert mit width, format, type und table - wird aus dem Speicher geholt und verarbeitet, wie wenn glDrawPixels aufgerufen worden wäre, aber die Verarbeitung hält, nachdem die finale Verarbeitung nach RGBA vervollständigt wurde.


Die vier scale- und die vier bias-Parameter, die für die Tabelle angegeben wurden, werden anschließend verwendet, um die R, G, B und A-Komponenten für jedes Pixel zu skalieren und zu beeinflussen. (Man verwende glColorTableParameter, um diese scale- und bias-Parameter zu setzen)


Als nächstes werden die R-, G-, B- und A-Werte an den [0,1]-Bereich angepasst. Jeder Pixel wird dann in das interne Format - angegeben mit internalformat - konvertiert. Diese Umwandlung verschiebt die Komponenten-Werte von den Pixeln (R, G, B und A) zu den Werten, die mit internalformat angegeben wurden (rot, grün, blau, alpha, Beleuchtung und Intensität). Das Verschieben verläuft folgendermaßen:


Internes Format Verschobene Komponente
GL_ALPHA A=Alpha
GL_LUMINANCE R=Luminance
GL_LUMINANCE_ALPHA A=Alpha, R=Luminance
GL_INTENSITY R=Intensity
GL_RGB R=Red, G=Green, B=Blue
GL_RGBA R=Red, G=Green, B=Blue, A=Alpha


Zum Schluss werden die roten, blauen, grünen, Beleuchtungs- und/oder Intensitäts-Komponenten des resultierenden Pixels in der Farb-Tabelle gespeichert. Sie bilden eine eindimensionale Tabelle mit Numerierung im Bereich 0 bis width - 1.


Wenn target vom Typ GL_PROXY_* ist, berechnet und speichert glColorTable die Werte der Proxy-Farb-Tabelle für GL_COLOR_TABLE_FORMAT, GL_COLOR_TABLE_WIDTH, GL_COLOR_TABLE_RED_SIZE, GL_COLOR_TABLE_GREEN_SIZE, GL_COLOR_TABLE_BLUE_SIZE, GL_COLOR_TABLE_ALPHA_SIZE, GL_COLOR_TABLE_LUMINANCE_SIZE und GL_COLOR_TABLE_INTENSITY_SIZE. Das hat keine Auswirkungen auf das Bild oder den Zustand irgendeiner aktiven Farbtabelle. Wenn die angegebene Farbtabelle zu groß ist, um unterstützt zu werden, werden alle Proxy-State-Variablen, die oben genannt wurden, auf 0 gesetzt. Anderenfalls wird die Farbtabelle durch glColorTable unterstützt und die Proxy-State-Variablen werden so gesetzt, als wenn target festgelegt worden wäre.


Die Proxy-State-Variablen kann man durch einen Aufruf von glGetColorTableParameter mit dem Token GL_PROXY_* auslesen. Das macht es dem Programm möglich, zu entscheiden, ob ein bestimmter glColorTable-Befehl erfolgreich verlaufen würde und um herauszufinden, was die resultierenden Farbtabellen-Attribute wären.


Wenn eine Farbtabelle aktiviert ist und ihre Größe (width) nicht gleich 0 ist, dann werden ihre Inhalte dazu verwendet, einen Teil der Komponenten - basierend auf dem internen Format der Tabelle - jeder RGBA-Pixelgruppe zu ersetzen.


Jede Pixelgruppe hat Farbkomponenten (R, G, B, A), die im Bereich [0.0,1.0] abgegeben sind. Die Farbkomponenten werden neu auf die Größe der Farbtabelle skaliert. Dann wird ein Teil der Komponenten - basierend auf dem internen Format der Tabelle - durch den Eintrag, der durch index ausgewählt wurde, ersetzt. Die Farb-Komponenten und -Inhalte der Tabelle hängen folgendermaßen zusammen:


Wert Bedeutung
r Aus R berechneter Tabellen-Index
g Aus g berechneter Tabellen-Index
b Aus B berechneter Tabellen-Index
L[i] Beleuchtungswert bei Tabellenindex i
I[i] Intensitätswert bei Tabellenindex i
R[i] Rot-Wert bei Tabellenindex i
G[i] Grün-Wert bei Tabellenindex i
B[i] Blau-Wert bei Tabellenindex i
A[i] Alpha-Wert bei Tabellenindex i

Das Ergebnis der Farbtabelle sieht dann so as:

Format R G B A
GL_ALPHA R G B A[a]
GL_LUMINANCE L[r] L[g] L[b] At
GL_LUMINANCE_ALPHA L[r] L[g] L[b] A[a]
GL_INTENSITY I[r] I[g] I[b] I[a]
GL_RGB R[r] G[g] B[b] A
GL_RGBA R[r] G[g] B[b] A[a]

Wenn GL_COLOR_TABLE aktiviert ist, dann werden die Farben, die aus der Pixel-Verschiebungs-Operation (falls sie aktiviert ist) resultieren, anschließend auf die Farbtabelle gemapped, bevor sie an die Convolution-Operation weitergegeben werden. Die Farbem, die aus der Convolution-Operation kommen, werden druch die "Post-Convolution-Farb-Tabelle" modifizeirt, falls GL_POST_CONVOLUTION_COLOR_TABLE aktiviert ist. Diese modifizierten Farben werden dann an die Farb-Matrix-Operation gesendet. Abschließend werden - wenn GL_POST_COLOR_MATRIX_COLOR_TABLE aktiviert ist - die Farben, die aus der Farb-Matrix-Operation resultieren, durch die "Postcolor-Matrix-Farben-Lookup-Tabelle" gemapped, bevor die Histogramm-Operation angewendet wird.

Hinweise

glColorTable ist nur verfügbar, wenn GL_ARB_imaging von glGetString mit dem Argmument GL_EXTENSIONS zurückgeliefert wird.


Wenn target den Wert GL_COLOR_TABLE, GL_POST_CONVOLUTION_COLOR_TABLE oder GL_POST_COLOR_MATRIX_COLOR_TABLE hat, muss width vom Typ 2^n (n: Integer) sein. Ansonsten wird der Fehler GL_INVALID_VALUE erzeugt.


Fehlermeldungen

GL_INVALID_ENUM wird generiert, wenn target keinen der zulässigen Werte hat.

GL_INVALID_ENUM wird generiert, wenn internalformat keinen der zulässigen Werte hat.

GL_INVALID_VALUE wird generiert, wenn width kleiner als 0 ist.

GL_INVALID_ENUM wird generiert, wenn format keinen der zulässigen Werte hat.

GL_INVALID_ENUM wird generiert, wenn type keinen der zulässigen Werte hat.

GL_TABLE_TOO_LARGE wird generiert, wenn die angeforderte Farbtabelle zu groß ist und wenn target gleichzeitig nicht vom Typ GL_PROXY_* ist.

GL_INVALID_OPERATION wird generiert, wenn glColorTable innerhalb eines glBegin-glEnd-Blocks aufgerufen wird.



Zugehörige Wertrückgaben

glGetColorTableParameter


Siehe auch

glColorSubTable, glColorTableParameter, glCopyColorTable, glCopyColorSubTable, glGetColorTable