Textur-Komprimierung: Größen-Optimierung
Die Textur-Komprimierung ist eine entscheidende Fähigkeit in der 3D-Grafik, die es ermöglicht, Grafiken so effizient wie möglich zu speichern und zu übertragen. Eine optimierte Größe ist jedoch nicht nur für die Übertragung, sondern auch für das Laden und Darstellen von Texturen im Spiel oder in anderen Anwendungen wichtig. In diesem Artikel werden wir uns mit verschiedenen Methoden der Textur-Komprimierung auseinandersetzen und wie man sie verwenden kann, um die Größe zu optimieren.
Verlustlose Komprimierung
Einige Formate wie PNG oder TGA unterstützen verlustfreie Komprimierungsmethoden. Diese Methode https://sugarcasino-de.com/ drückt Daten so effizient wie möglich zusammen, ohne dass es dabei zu einem Verlust an Bildqualität kommt. Ein Beispiel dafür ist die LZW-Komprimierung (Lempel-Ziv-Welch). Hierbei wird der Textur-Code in eine Liste von Mustern unterteilt und diese dann komprimiert werden.
Die LZW-Komprimierung eignet sich besonders gut für Texturen mit wiederholten Mustern. Hier ist ein Beispiel, wie man die LZW-Komprimierung verwendet:
#include <stdio.h> #include <zlib.h> int main() { // Textur-Daten als Bildschirm-Buffer unsigned char* tex_data = (unsigned char*)malloc(1024 * 768 * 3); // Einfache Datenkomprimierung mit LZW deflateInit2(&state, Z_DEFAULT_COMPRESSION, Z_DEFLATED, 31, 8, Z_DEFAULT_STRATEGY); // Komprimierte Daten abspeichern unsigned char* compressed = (unsigned char*)malloc(1024 * 768 * 3); deflate(tex_data, 1024 * 768 * 3, &state, compressed, 1024 * 768 * 3); return 0; }
Voraussetzungen für verlustfreie Komprimierung
Verlustfreie Komprimierung ist jedoch nur dann effektiv, wenn die Textur-Daten eine Menge von wiederholten Mustern und wenig zufälligen Daten enthalten. Wenn das Gegenteil der Fall ist, kann eine andere Methode wie DCT (Discrete Cosine Transform) besser geeignet sein.
Discrete Cosine Transform (DCT)
Die DCT-Komprimierung eignet sich gut für Texturen mit starken Mustern und vielen zufälligen Daten. Sie arbeitet auf Basis der Fourier-Transformation, wobei die Daten in Frequenzbereiche zerlegt werden. Diese Methode ist jedoch nicht verlustfrei.
Ein Beispiel, wie man die DCT-Komprimierung verwendet:
#include <stdio.h> #include <math.h> int main() { // Textur-Daten als Bildschirm-Buffer unsigned char* tex_data = (unsigned char*)malloc(1024 * 768 * 3); // Einfache Datenkomprimierung mit DCT float dct_array[256][256]; for(int x=0; x<256; x++) { for(int y=0; y<256; y++) { dct_array[x][y] = (float)(tex_data[(x+1)*1024+y*768]); } } // Komprimierte Daten abspeichern unsigned char* compressed = (unsigned char*)malloc(1024 * 768 * 3); for(int x=0; x<256; x++) { for(int y=0; y<256; y++) { compressed[x+1+(y*256)] = dct_array[x][y]; } } return 0; }
DCT als verlustfreie Methode
Es ist jedoch möglich, die DCT-Komprimierung zu einer verlustfreien Methode umzuwandeln. Dies wird erreicht durch eine vorherige Daten-Transformation in der Form von sinusförmigen Mustern, wie bei einem Farbfilter.
Ein Beispiel, wie man die verlustfreie DCT-Komprimierung verwendet:
#include <stdio.h> #include <math.h> int main() { // Textur-Daten als Bildschirm-Buffer unsigned char* tex_data = (unsigned char*)malloc(1024 * 768 * 3); // Einfache Datenkomprimierung mit DCT float dct_array[256][256]; for(int x=0; x<256; x++) { for(int y=0; y<256; y++) { dct_array[x][y] = (float)(tex_data[(x+1)*1024+y*768]); } } // Transformation in sinusförmige Muster float sine_filter[256]; for(int x=0; x<256; x++) { sine_filter[x] = sin(M_PI*x/128); } for(int x=0; x<256; x++) { for(int y=0; y<256; y++) { dct_array[x][y] *= sine_filter[x]; } } // Komprimierte Daten abspeichern unsigned char* compressed = (unsigned char*)malloc(1024 * 768 * 3); for(int x=0; x<256; x++) { for(int y=0; y<256; y++) { compressed[x+1+(y*256)] = dct_array[x][y]; } } return 0; }
Voraussetzungen für die DCT-Komprimierung
Die DCT-Komprimierung ist jedoch nur dann effektiv, wenn es sich um Texturen mit starken Mustern handelt. Wenn das Gegenteil der Fall ist, kann eine andere Methode wie verlustfreie LZW-Komprimierung besser geeignet sein.
Einfache Komprimierung
Eine einfache aber auch nicht sehr effektive Methode ist die Einfachkomprimierung. Hierbei werden Daten einfach entfernt und dabei wird versucht, dass der Verlust an Bildqualität so gering wie möglich ist. Diese Methode ist jedoch nur dann zu empfehlen, wenn es um eine schnellstmögliche Übertragung geht.
Ein Beispiel, wie man die einfache Komprimierung verwendet:
#include <stdio.h> int main() { // Textur-Daten als Bildschirm-Buffer unsigned char* tex_data = (unsigned char*)malloc(1024 * 768 * 3); // Einfache Datenkomprimierung mit Entfernung von Daten unsigned char* compressed = (unsigned char*)malloc(512 * 384 * 3); for(int x=0; x<512; x++) { for(int y=0; y<384; y++) { compressed[x+1+(y*512)] = tex_data[(x/2)*1024+y*768]; } } return 0; }
Einfache Komprimierung als Verlustverfahren
Es ist jedoch auch möglich, die einfache Komprimierung als ein Verlustverfahren zu verwenden. Hierbei werden Daten nicht entfernt, sondern sie werden einfach zusammengefasst. Dies kann jedoch zu einem deutlichen Bildrückgang führen.
Ein Beispiel, wie man die einfache Komprimierung als Verlustverfahren verwendet:
#include <stdio.h> int main() { // Textur-Daten als Bildschirm-Buffer unsigned char* tex_data = (unsigned char*)malloc(1024 * 768 * 3); // Einfache Datenkomprimierung mit Zusammenfassung von Daten unsigned char* compressed = (unsigned char*)malloc(512 * 384 * 3); for(int x=0; x<512; x++) { for(int y=0; y<384; y++) { int r = tex_data[(x/2)*1024+y*768]; int g = tex_data[(x/2+1)*1024+y*768]; int b = tex_data[(x/2)*1024+(y/2+1)*768]; compressed[x+1+(y*512)] = (r+g+b)/3; } } return 0; }
Voraussetzungen für einfache Komprimierung
Die einfache Komprimierung ist jedoch nur dann effektiv, wenn es sich um Texturen mit geringer Auflösung handelt. Wenn das Gegenteil der Fall ist, kann eine andere Methode wie verlustfreie LZW-Komprimierung besser geeignet sein.
In diesem Artikel haben wir uns mit verschiedenen Methoden der Textur-Komprimierung auseinandergesetzt und verschiedene Voraussetzungen diskutiert. Verlustfreie Komprimierungen wie die LZW-Komprimierung sind nur dann effektiv, wenn es sich um Texturen mit wiederholten Mustern handelt. Für Texturen mit starken Mustern eignet sich jedoch die DCT-Komprimierung besser. Wenn eine schnellstmögliche Übertragung gefordert ist, kann die einfache Komprimierung verwendet werden. Es ist jedoch wichtig zu beachten, dass die einfachste Methode nur dann effektiv ist, wenn es sich um Texturen mit geringer Auflösung handelt.
