Pointer auf Daten einer TBitmap erhalten

[ken_jones]

Hallo Zusammen,
nach einigen Stunden suchen wende ich mich an die Spezialisten

Ich möchte auf die Pixeldaten einer TBitmap direkt zugreifen können. Grund: Ich habe diverse Fotofilter erstellt, die zwar funktionieren, aber die Performance lässt zu wünschen übrig. Klar, es gibt die ScanLine, aber auch da reicht die Perfomance nicht, da ich in der Bitmap nicht linear sondern ziemlich wild zwischen Zeilen und Spalten wechseln muss. Ist die Scanline einmal geholt, gehts schon schnell, aber wenn pro Bitmap die Scanline 1000x mal geholt werden muss...
Ah ja, es soll keine 3rd Library nötig sein, nur Delphi Standard.

Was hab ich bereits gefunden habe:

Zugriff über Canvas.Pixels: Gääähn, no comment...
Zugriff über Scanline: Geht schneller, aber dauert noch immer zu lange
Zugriff über Pointer auf Daten: Perfekt, aber dazu hab ich die TBitmap Klasse modifizieren müssen, das will ich nicht, es sollen keine Delphi-Libraries geändert werden.
Zugriff über GetDIBits: Ja geht auch, aber ich muss jedes mal die Daten über GetDIBits kopieren, das frisst wieder Zeit.

Gibt es wirklich keine andere Möglichkeit einfach einen simplen Pointer auf die bereits existierenden Pixeldaten (und nicht nur auf eine Linie davon) zu erhalten?

Danke für Vorschläge und Ideen!

[omata]

Bilddurchlaufen und mittels Scanline die Pointer auf die Pixel in einer eigenen Datenstruktur ablegen. Dann ist der Zugriff sofort möglich.

[Namenloser]

Du könntest das TBitmap32 aus der Graphics32-Lib verwenden. Dort liegen alle Pixeldaten in einem Stück vor.
Ach sorry, hab überlesen, dass es keine 3rd-Party-Libs sein sollen...

[Medium]

Direkter als Scanline geht nicht. Du musst die auch nicht dauernd neu holen, da langt reine Pointerarithmetik: Scanline ist nämlich ein etwas dumm gewählter Name. Nach dem Ende einer Zeile via Scanline folgt nämlich die nächste, ohne dass du den Pointer neu holen müsstest . Es gibt nur ggf. nen Stride zu beachten, wo man aber genau die Byteanzahl des Strides auslesen konnte, und ob das Bitmap Top-Down oder Bottom-Up im Speicher liegt weiss ich leider nicht mehr so genau - ist schon was her. Viel mehr als das düfte aber die Scanline-Property auch nicht machen, ich hab aber die Quellen grad nicht zur Hand. (Alles andere würde aber wenig Sinn ergeben.)
Wenn das noch zu langsam ist, musst du an deine Filter ran. Die Scanline IST genau das, was dein Titel fordert: Ein unmittelbarer Pointer auf das Bitmap, genau dort hin wo es wirklich liegt.

[ken_jones]

Vielen Dank für die Antworten!

@Medium: Danke, ich glaub du hast mir den entscheidenden Hinweis gegeben! Ich hab versucht über die Liniengrenze von Scanline hinweg Daten zu lesen und schreiben, was aber zu AV's geführt hat. Aber an den Stride oder dass die Daten Bottom-Up liegen könnten, hab ich nicht gedacht. Ich ging davon aus, dass Scanline mir einfach eine Zeile zur Verfügung stellt. Super, jetzt hab ich wieder neue Ansätze für morgen

So, konnte es nicht lassen und habs probiert. Und es funktioniert! Wenn ich die Scanline[Bitmap.Height-1] nehme, bin ich am Anfang der Bitmap und dann funktioniert auch meine Pointerarithmetik.

[himitsu]

Jupp, bei einen TBitmap liegen die Zeilen rückwärts aneinandergereiht da.

Also mit einem Pointer auf die Scanline hat man theoretisch alle Daten zusammen.

Achtung: Die Zeilen sind an Integergrenzen ausgerichtet, also jeweils an Byte.

Nur bei pf32bit hat man somit alle Daten wirklich direkt aneinander liegen. Bei allem anderem muß mn eventuell einen Offset je Zeile einrechnen.


PS: Man kann sich auch zu anfang einfach ein Array of PRGB (bei 24bit ansonsten ein passenderer Pointer) anlegen, wo man alle Scanlines reinkopiert.
Dann nur noch MyArray[x, y] und schon hat man das gewünschte Pixel.

[Medium]

Zitat von himitsu:

Jupp, bei einen TBitmap liegen die Zeilen rückwärts aneinandergereiht da.

Nicht immer! Ich weiss echt leider die Quelle nicht mehr, da bestimmt 4-5 Jahre her, aber beides kann vorliegen. Irgendwie kam man via FooDIBbar() aber da dran meine ich dunkel im Hinterkopf zu haben. Ich hatte damals den hübschen Fall eines 32 Bit Bildes, dass zudem "vorwärts" im Speicher war, so dass ich einfach stumpf inkrementieren konnte, bzw. via einer MyPixels[x+(Width*y)] Array-Property das flott auf 2D Koordinaten abbilden konnte. Das war Best-Case, aber man kann halt auch auf Bottom-Up "Breite mod 4 = 3" 256-Graustufenbilder treffen

[himitsu]

Das Array meiner letzen Zeile macht quasi nicht viel anderes, wie deine Rechnung x+(MaxX*y)

MyPixels[x + (MaxX * y)] = MyPixels + (x + (MaxX * y)) * 4 = MyPixels + (x + (MaxX * y))

MyArray[x, y] = MyArray[x][y] = (MyArray + x * 4)^ + y * 4 = (MyArray + x)^ + y

wobei die *4 nicht als eigenständige Operation (Assemblerbefehl) vorhanden sind, sondern in dem Addition-Befehl mit reinoptimiert sind, also beide jeweils 3 Assembler
Allerdings einmal MUL+ADD+ADD gegen ADD+MOV+ADD ... kommt also nur noch drauf an, was die CPU wie schnell abarbeitet.
(z * 4 = z shl 2)

Und es ist bei dem Array egal, in welcher Reihenfolge die Zeilen liegen.
Gut, dafür muß man hier am Anfang einmal alle ScanLines holen, wärend man bei dem Anderen nur die Letzte/Erste holen muß.


die Berechnungen basieren auf 32 Bit-Bildern

[freeway]

ein Pointer auf Daten ist nicht wirklich soviel schneller,
die meiste zeit geht schlicht und einfach beim Datentransfer Speicher - CPU - Speicher drauf

[Union]

Es hat zwar den Nachteil des zusätzlichen Datentransfers, aber Du kannst auch das Bitmap in einen Stream schreiben und dann mit Memory^ auf die Daten direkt zugreifen. Dafür hast Du dann aber auch ein sauberes Device Independent Bitmap.