Herd Software Entwicklung
DaVinci Grafikbibliothek
DaVinci Dokumentation

Vereinfachte Verarbeitung mit 32-Bit DIBs

Wenn Ihr Anwendungsprogramm DIBs nur anzeigen muß, ohne sie direkt zu modifizieren, können Sie DIB-Daten direkt an die entsprechenden Funktionen von Windows und Leonardo geben, die sich um die unterschiede zwischen DIBs mit 1,4,8,16,24 und 32 Bit Farbtiefe kümmern.

Sobald Sie aber in Ihrer Anwendung die DIB-Grafiken bearbeiten wollen, müssen Sie unterschiedliche Routinen für die DIB-Formate entwickeln, oder Sie verwenden die RWxxxx – Funktionen zum Pixelweisen abstrakten Zugriff auf DIB-Daten..

Um die Entwicklung sehr schneller Anwendungsprogramme zu vereinfachen, können Sie DIBs mit beliebiger Farbtiefe mit der Funktion ConvertDIB in eine DIB mit 32-Bit Farbtiefe überführen. Diese Routine ist auf eine hohe Verarbeitungsgeschwindigkeit optimiert. Darüber hinaus können sie durch Angabe des Flags IPDIBF_IMPORT_32BIT beim Aufruf von ipImportInd eine Grafik gleich beim Import in das 32-Bit Format bringen lassen, was eine noch höhere Performance ermöglicht.

Vorteile:

• Eingabeformate mit 1,4,16,24,32 oder 48 Bit Farbtiefe mit einem Programmcode
  
  
• einfacherer Aufbau der DIB (keine Farbpalette und daher keine RGBQUAD-Strukturen)
  
  
• keine Stopfbytes am Ende eine DIB-Zeile
  
  
• besonders schnelle Verarbeitung, da jedem Pixel eine physikalische Speicheradresse entspricht
  
  
• bsonders einfacher Programmcode
  
  
• bei 16-Bit Software weniger Probleme mit huge Zeiger-arithmetik..

Nachteile:

• hoher Speicherbedarf der DIB (32 fach höher wie monochrom...)
  
  
• die Rückumwandlung in eine DIB mit weniger als 16 Bit Farbtiefe ist mit Qualitätsverlusten behaftet.

  Aufbau einer 32-Bit DIB:

Bei DIBs im Speicher DIBs in einer BMP-Datei

entfällt BITMAPFILEHEADER

BITMAPINFOHEADER BITMAPINFOHEADER

Bitmap-Daten Bitmap-Daten

Die Bitmap-Daten sind in 4 Bytes je Pixel für Blau, Grün, Rot und ein Füllbyte abgelegt. Diese Definition entspricht der Definition der RGBQUAD-Struktur.

Während DIBs mit 8 oder 24 Bit Farbtiefe am Ende der Zeile auf eine durch 4 Bytes teilbare Länge mit 0-Bytes aufgefüllt werden, ist dies bei 32-Bit DIBs nicht notwendig. Daher kann Ihr Programmcode in einer einzigen Schleife sämtliche Pixel verarbeiten.

Reduzieren auf 24 oder weniger Bit:

Die Reduktion der Farbtiefe von 32-Bit auf weniger Bit pro Pixel kann entweder mit den Funktionen ConvertDIB, DitherTo1ID, DitherTo4, DitherTo8, ConvertDIB oder TransformDIB erfolgen:

Die Funktion ConvertDIB benutzt dabei ein einfaches mapping und eignet sich eher für Skizzen und Bildschirmfotos, während die Ditherxxx-Routinen- sich eher für Photos eignen.

Speichern von DIBs mit 32 Bit:

DIBs können als 32-Bit DIBs in BMP-Dateien gespeichert werden, jedoch wird dieses Datenformat offiziell erst ab Windows NT 3.5/ Windows 95 unterstützt. Windows 3.1-Anwendungen werden solche DIBs in Einzelfällen nicht verarbeiten.

Beim Export von 32-Bit DIBs in den Datenformaten PNG, TIF und JPG führt DaVinci automatisch eine Konvertierung ins 24-Bit format durch.

Benutzung von HUGE-Zeigern bei 16-Bit Anwendungen:

Um DIBs mit mehr als 64 KByte in einem 16-Bit Anwendungsprogramm zu verarbeiten, müssen Sie in Ihrer Anwendung HUGE Zeiger verwenden:

DWORD huge *	hpdWord;

Das Inkrementieren eines solchen Zeigers ist ein relativ langsamer Vorgang. Bei DIBs mit 24-Bit Farbtiefe müssen Sie jedes Byte einzeln inkrementieren, bei 32-Bit Farbtiefe dagegen können Sie einen 32-Bit Zugriff ausführen und anschließend nur einmal um 32 Bit inkrementieren.

Beispiel: Durchschnittliche Helligkeit einer 32-Bit DIB bestimmen

int AvarageBrightness(HDIB hDIB)
{
	LPBITMAPINFOHEADER	lpbmi = (LPBITMAPINFOHEADER) GlobalLock(hDIB);
	DWORD HUGE *	hpPixel = (DWORD HUGE *) (lpbmi+1);
	DWORD	dwPixelCount = lpbmi->biWidth * lpbmi->biHeight,
		dwPixelsLeft,
		dwPixelValue,
		dwSum;

	for (dwSum=0, dwPixelsLeft=dwPixelCount; dwPixelsLeft-->0;)
	{
		dwPixelValue = *hpPixel++;
		dwSum += 	GetRValue(dwPixelValue)
			+ GetGValue(dwPixelValue)
			+ GetBValue(dwPixelValue);
	}

	return dwSum / dwPixelCount / 3;
}