Verlustfreies Zoomen von Bildern (Interpolieren)

[Stanlay Hanks]

Hallo. Tut mir leid, aber ich kann nicht ganz nachvollziehen, was du mit "überlagern" meinst. Können sich Pixel auch überlagern? ich meine, die liegen doch nebeneinander, oder?
Allgemein muss ich gestehen, dass ich bei deinem Beispiel leider nicht ganz durchblicke

[S - tefano]

Hiho,

jau, also in diesem Beispiel blicke ich auch nicht ganz durch.
Und Stanlay, wo ich gerade aufm Pott saß ist mir das selbe Problem in den Kopf gekommen. Ich denke, sobald man vergrößerungsmäßig in Bereiche über 2faches Original kommt, muss man ein wenig umdenken. Wenn man zum Beispiel ein Bild hat das fünfmal so groß ist wie das Original... dann wäre jeder fünfte Pixel ein original-Pixel, und die jeweils anderen 4 Pixel (jetzt mal in einer 5er- Reihe) müssten interpoliert werden.
Genau darin sehe ich das Problem. Wie interpoliert man einen Pixel, wenn man dessen Nachbarn auch interpolieren muss, und erst von deren Nachbarn die Originale zu finden sind? Ich denke dass sich das zwar machen lässt, aber nicht mit der selben Methode die man verwenden würde wenn jeder zu interpolierende Pixel zwei original-Nachbarn hätte.
In der Verteilung der zu interpolierenden Pixel sehe ich dabei ein kleineres Problem. Diese fiesen Kommastellen kann man umgehen, indem man sich nicht fragt wo die zu interpolierenden Pixel hin sollen, sondern wo die original-Pixel hin sollen. Bei einem Vergrößerungsfaktor über 2 sollte man also nicht die neue Breite durch die Anzahl der neuen Pixel teilen, sondern die neue Breite durch die Anzahl der originalen Pixel teilen. Dann könnte man die Zeilen mit ner Schleife durchgehen die sich jeden Pixel anguckt und dann je nach dem ob es ein originaler oder ein neuer ist weitermacht.
Das Problem wo ich denkmäßig nicht weiterkomme ist halt wie man vier nebeneinanderliegende Pixel interpoliert.
Wobei... man könnte sich damit aushelfen, dass man das Bild nicht auf einen Schlag auf die gewünschte Größe vergrößert. Man teilt die geplante neue Größe durch zwei, wobei dann u.U. ne Kommazahl rauskommt. Interpolierung bei zweifacher Vergrößerung ist ja kein Problem. Daher nehmen merken wir und die Kommastellen hinter dem Ergebnis von x=neueGröße/2 und schneiden sie erstmal ab. Und dann gehen wir in eine Schleife, die uns das Bild x-Mal verdoppelt und interpoliert, wobei wir bei jeder neuen Vergrößerung die vorher interpolierte Vergrößerung als Original für den nächsten Vorgang nehmen. Danach vergrößern wir das Bild um 1,"nachkommastellen von x" und interpolieren jeden y. Pixel, wobei y der Kehrwert aus den Nachkommastellen ist. Glaub ich.

Ist jetzt nur son Denkkonstrukt, aber vielleicht gehts ja so...

Bis dann,

S - tefano

[Stanlay Hanks]

Hallo. Danke für die ausführliche Antwort
Das mit den Original Pixeln is gut... Das hab ich soweit glaub ich auch kapiert. Aber wenn man, wie du gesagt hast, das ganze in "2er Schritten" macht, bekommt man ja immer eine Größe, die ein Vielfaches von 2 ist. Das könnte dann bei einer Vergrößerung von, sagen wir mal 2,5 Prozent ein Problem geben. Aber es hat mir schon riesig geholfen, dass ich das mit den "Original Pixeln" kapiert hab
Zu dem Interpolieren von z.B. 4 Pixeln ohne direkten Original Nachbarn:
Das müsste doch theoretisch so funktionieren: Den ersten Pixel in der Reihe nach dem ersten Original Pixel interpoliert man mit dem ersten und dem letzten Originalpixel (oixxxo |o=Original)
Dann interpoliert man den 2. Pixel mit dem vorherigen und dem letzten Pixel usw...dann müsste das doch eigentlich gehen, oder?

Man liest sich, Stanlay

[S - tefano]

Hi,

das mit den Zweierschritten meinte ich ja auch nur für Vergrößerungen über das zweifache hinaus. Bei den kleineren als zweifach kann man es ganz normal so machen wie ich es auf der vorherigen Seite bereits geschrieben habe.
Dein Vorschlag zur Interpolierung würde zwar funktionieren, aber ich glaube dass du damit das Prinzip der I. nicht ganz befolgst, weil ja normalerweise ein Pixel immer nach seinen direkten Nachbarn interpoliert wird. Klar ist es in dieser Situation nicht möglich, aber vielleicht sollte man es dann wenigstens so machen dass die Nachbarn nach denen interpoliert wird gleich weit vom Pixel entfernt sind - was aber wohl leider nur dann vernünftig laufen kann, wenn zwischen zwei orig.Pixeln eine ungerade Zahl neuer Pixel sind, wo also ein Pixel genau in der Mitte liegt.
Von daher... fürs erste kann man da deine Methode sicherlich benutzen.
Und wie gesagt, das mit den Zweierschritten halt nur für Vergrößerungen die über die Verdoppelung hinausgehen.

Bis dann,

S - tefano

[himitsu]

BitMap zusammen mit der neuen Größe übergeben:
z.B.: Zoom(Image1.Picture.Bitmap, 800, 600);

(QI = QuellImage, ZI = ZielImage)

Delphi-Quellcode:

Procedure Zoom(Var QI: TBitMap; ZI_Width, ZI_Height: Integer);
  {Pixel in die Grundfarben zerlegen}
  Function R(Pixel: TColor): Byte;
    Begin  Result := Pixel mod 256;  End;

  Function G(Pixel: TColor): Byte;
    Begin  Result := (Pixel shr 8) mod 256;  End;

  Function B(Pixel: TColor): Byte;
    Begin  Result := (Pixel shr 16) mod 256;  End;

  Var X, Y: Integer;
    R, G, B: Byte;
    ZI: TBitMap;
    
  Begin
    ZI := TBitMap.Create(self);
    ZI.Width := ZI_Width;
    ZI.Height := ZI_Height;
    ZI.PixelFormat := QI.PixelFormat;
    For X = 0 to ZI_Width - 1 do 
      For Y = 0 to ZI_Height - 1 do Begin     
        {Berechnet die Position des neuen Piexels im alten Bild}
        {entspricht der Position des linken oberen der 4 verwendeten Pixel}
        X2 = Trunc(QI.Width * (X / ZI_Width));    
        Y2 = Trunc(QI.Height * (Y / ZI_Height));
        {Berechnet die Wertigkeit der umliegenden Pixel im altenBild}
        {fürs rechte untere der 4 verwendeten Pixel}
        PX = Frac(QI.Width * (X / ZI_Width));
        PY = Frac(QI.Height * (Y / ZI_Height)));
        {Neuen Farbwert berechnen - rot}
              {QuellPixel}                        {Wertigkeit (%)}
        R = R(QI.Canvas.Pixels[X2,     Y2])     * (1 - PX) * (1 - PY) + 
            R(QI.Canvas.Pixels[X2 + 1, Y2])     * PX       * (1 - PY) + 
            R(QI.Canvas.Pixels[X2,     Y2 + 1]) * (1 - PX) * PY + 
            R(QI.Canvas.Pixels[X2 + 1, Y2 + 1]) * PX       * PY; 
        {Neuen Farbwert berechnen - grün}
        G = G(QI.Canvas.Pixels[X2,     Y2])     * (1 - PX) * (1 - PY) + 
            G(QI.Canvas.Pixels[X2 + 1, Y2])     * PX       * (1 - PY) + 
            G(QI.Canvas.Pixels[X2,     Y2 + 1]) * (1 - PX) * PY + 
            G(QI.Canvas.Pixels[X2 + 1, Y2 + 1]) * PX       * PY; 
        {Neuen Farbwert berechnen - blau}
        B = B(QI.Canvas.Pixels[X2,     Y2])     * (1 - PX) * (1 - PY) + 
            B(QI.Canvas.Pixels[X2 + 1, Y2])     * PX       * (1 - PY) + 
            B(QI.Canvas.Pixels[X2,     Y2 + 1]) * (1 - PX) * PY + 
            B(QI.Canvas.Pixels[X2 + 1, Y2 + 1]) * PX       * PY; 
        {Farben zusammensetzen und Pixel zeichnen}
        ZI.Canvas.Pixels[X, Y] := RGB(R, G, B);
      End;
    QI := ZI;  {Bildübergabe eventuell noch ändern}
    ZI.Free;
  End;

noch nicht getestet.

[Stanlay Hanks]

Hallo. Das bringt mich schon wieder erheblich weiter (Schon allein wegen der Kommentare )
An manchen Stellen kommen noch Fehlermeldungen wegen inkompatibler Typen (Byte/Extended) aber das krieg ich bestimmt noch hin. Danke vielmals auf jeden Fall! Danke auch an S-tefano! Ich muss gestehen, für eure Gedankgänge fehlt mir ab und zu einfach die nötige Logik. Aber schön langsam fällt der Groschen, glaub ich.

Man liest sich, Stanlay

[himitsu]

> Byte/Extended inkompatibl = nicht gerundet
> Function/Variable selbe Namen
...

Hab's überarbeitet und als Beispiel angehängt.

Achtung: Eine Optimierung folgender Art ist nicht möglich. Fehler bei Positionsberechnung.
(stimmt zwar rechnerisch, funktioniert aber nicht - es entstehen unschöne Linien im Bild)

Delphi-Quellcode:

X2 := Trunc(QI.Width * (X / ZI_Width));
=>
X2 := QI.Width * X div ZI_Width;

[S - tefano]

Huiuiui, gut geworden...
aber ich werd mich da noch ein wenig einlesen müssen, mir wird noch nicht ganz klar warum du x2 und y2 so berechnest wie du es tust und was es mit px und py und dieser "Wertigkeit" auf sich hat...

Schade nur, dass man irgendwann an die Grenzen des Bildes stößt und es zwar nicht pixelig, aber optisch unscharf wird.

Bis dann,

S - tefano

[Stanlay Hanks]

Also erstmal vielen Dank für die Überarbeitung und den Source Auch ich werd mich erstmal noch genau einlesen müssen, aber wie gesagt, der Groschen fällt langsam.

Man liest sich, Stanlay

[himitsu]

Scharf bekommt man die gezoomten Bilder nicht beim interpolieren.
Die einzige Möglichkeit in deinem Bild scharfe Kanten zu bekommen ist den linken Button [Zoom] zu benutzen.

Mit X2/Y2 lege ich fest, welche 4 Pixel für die Berechnung des neuen Pixels verwendet werden.
Und mit der "Wertigkeit" wird bestimmt welchen Einfluss diese Pixel auf den neuen Farbwert haben.
D.h. je näher ein Pixel ist, desto größer ist auch dessen Einfluss.

Hab' mal im Beispielbild eine Vergrößerung von 5 gewählt, um es einfach zu halten.
In diesem 3x3 Pixel großen Bild sind die "Hauptpixel" und der Farbverlauf zwischen den 4 Pixeln unten rechts eingezeichnet.
Hier ist auch erkennbar das, wenn ein berechnetes Pixel einem "Hauptpixel" näher kommt es ihm immer ähnlicher wird.

Hierbei sollte aber auch erkennbar werden, dass am rechten und unteren Rand des Bildes sich ein Fehler einschleicht, da hier die Farbwerte mit den Randpixeln und Pixeln außerhalb des Bildes berechnet werden.
Diesen Fehler hab ich aber nicht behoben, um euch die Arbeit und das erkennen des Prinzips nicht zu erschweren.
Es handelt sich dabei um einen Rand von Aufrunden(eins * Zoomfaktor[%]) Pixeln. Und da die Pixel außerhalb des BitMaps als schwarz erkannt werden, gibt es dort einen schwarzen Farbverlauf in Richtung Bildrand. (fällt also kaum auf)
Wenn ihr irgendwann mal diesen "unbedeutenden" Fehler beheben wollt, könnt ich euch melden. Die Adresse habt ihr ja.


Die einzige Möglichkeit die ich sehe, das Bild zu gleich scharf und nicht pixelig zu bekommen, währe so etwas wie 'ne KI zu verwenden. Die dann entscheidet, wann ein scharfer oder ein weicher Übergang nötig ist.


Also dann noch viel Spaß damit.