Verlustfreies Zoomen von Bildern (Interpolieren)

[Stanlay Hanks]

Ich hab mich jetzt mal mit Scanline befasst (Is ja gar nicht so schwer, wie ich gedacht hatte :mrgreen:). Naja ich denke mal, mit Scanline sollte das schon wesentlich schneller gehen. Mein hauptproblem is aber nun, dass ich ja, mit der Methode, die ich angewendet habe, das Original Bild ja nur doppelt so groß machen kann, aber keine freie neue Größe bestimmen kann. Hat da wer ne Idee, wie ich das machen könnte? (Nicht böse sein, wenn ich nicht gleich zurückschreibe, ich bin heute nicht den ganzen Tag zu Hause :oops:)

Man liest sich, Stanlay :hi:

[Gandalfus]

Du kennt doch strechdraw oder?

Btw: http://www.irfanview.com/ damit kann leicht bilder vergrössern

[himitsu]

@Gandalfus
StrechDraw ist zwar einfach zu nutzen und vergrössert auch.
Glättet aber nicht, sonderen zeichnet nur die Pixel mehrfach.

Und wenn die Vergrösserung unglücklich gewählt ist (z.B. 150%), sieht es echt bescheuert aus.


Add:

Delphi-Quellcode:

QI = QuellImage
ZI = ZielImage
Variablen = Integerr
...I[X, Y] = entspricht einem Farbwert des Pixels (z.B. Rot)

For X = 0 to ZI.Width - 1 do
  For Y = 0 to ZI.Height - 1 do Begin
    X2 = Trunc(QI.Width * (X / ZI.Width));
    Y2 = Trunc(QI.Height * (Y / ZI.Height));
    PX = Frac(QI.Width * (X / ZI.Width));
    PY = Frac(QI.Height * (Y / ZI.Height)));
    ZI[X, Y] = QI[X2,     Y2]     * (1 - PX) * (1 - PY) +
               QI[X2 + 1, Y2]     * PX       * (1 - PY) +
               QI[X2,     Y2 + 1] * (1 - PX) * PY +
               QI[X2 + 1, Y2 + 1] * PX       * PY;
  End;

Ich hoffe, du verstehst was ich meine. Hab es möglichts einfach gehalten.
Soll nur das Prinzip für eine Vergrösserung mit linearen Übergängen darstellen.

[S - tefano]

Das Problem dabei ist nur, dass Stan ja immer jeden zweiten Pixel interpoliert hat, und wenn er einen beliebigen Vergrößerungsfaktor nimmt, hat er diese Regelmäßigkeit nicht mehr.
Ich würde dabei allerdings folgendes vorschlagen:
Wie bereits erwähnt erstmal das Bild mit Stretchdrwa vergrößern. Dann musst du herausfinden wieviele Pixel dazugekommen sind, also die (für die Breite) Width der neuen Bitmap minus die Width der alten. Da man die neuen Pixel ja gleichmäßig auf das Bild verteilen muss, muss man die neue Breite durch die Anzahl der neuen Pixel teilen.
Ein Beispiel:
Du hast 20 Pixel, stechst sie auf 25. Es gibt also 5 neue Pixel. 25/5=5, es müsste also jeder fünfte Pixel interpoliert werden. Gibts nur noch das Problem, dass der letzter zu interpolierende Pixel auch der letzte des Bildes ist, man also keinen zweiten Vergleichspixel hat. Naja, da kann man sich aushelfen indem man für den letzten Pixel einfach dieselben Werte nimmt wie für den vorletzten.
Ich bin mir nicht sicher ob das immer funktioniert, aber n Denkanstoß ist das doch bestimmt...

Bis dann,

S - tefano

[OregonGhost]

Wenn es nicht unter Windows 95 laufen muss, kannst du für sowas auch prima die GDI+ nehmen, die bei Windows XP dabei ist und die es als Redistributable für Windows 98/Me und NT4/2000 gibt. Eine entsprechende Delphi-Unit ist auch schnell gefunden. Die GDI+ unterstützt Alphablending, Antialiasing, "weiche" Skalierung (also das was du willst), und damit sparst du dir eine Menge Code.

Wenn du es dennoch von Hand machen willst, hier ein Tipp:
Wenn du z.B. 20 auf 25 Pixel vergrößern willst, dann musst du diese 20 Pixel GLEICHMÄSSIG auf die 25 verteilen, also auch mit Nachkommastellen. Dann kannst du nämlich für jeden Pixel (besser: Jedes Pixelzentrum) zwischen den beiden links und rechts davon gelegenen Pixeln deine lineare Interpolation durchführen.

Zum Beispiel vier auf fünf Pixel:

Code:

Das sind die originalen vier Pixel(-zentren):
1) X----X----X----X
Das sind die vier Pixel, verteilt auf die Länge von fünf Pixeln:
2) X------X------X------X
Und jetzt musst du für diese Stellen die lineare Interpolation berechnen:
3) X----X----X----X-----X

Verstehste?
Der zweite Pixel von links liegt etwa auf dreiviertel der Strecke der "originalen gestreckten" Pixel, also wird er 1/4 mal der linke Pixel und 3/4 mal der rechte Pixel usw.

[Stanlay Hanks]

Hallo! Entschuldigt bitte die späte Antwort, aber ich bin grade erst nach Hause gekommen.

Erstmal vielen Dank für die vielen Anregungen und Erklährungen :hello:
StrechDraw, muss ich gestehen, kannte ich vorher noch nicht...Ich hab immer versucht, das mit der Strech Eigenschaft des Images zu machen :oops: Aber das hat nicht hingehauen.
S-Tefano hat mein Problem genau erkannt. Mir fehlt diese Regelmäßigkeit. Aber eure Ideen sind echt gut und werde die jetzt auch gleich mal alle genau durchdenken und ausprobieren.
@OregonGhost Was du genau meinst, habe ich leider nicht genau verstanden :oops: Ich meine das, was du über "Komma Stellen" gesagt hast. Ich meine, es gibt doch keine kleinere Einheit mehr, als ein Pixel, oder? (aber wahrscheinlich hab ich da was falsch verstanden...

Um deine Prozedur zu verstehen, himitsu, muss ich mir erstmal noch diese "Trun und Frac" Sachen in der OI anschauen. Aber das wird sich bestimmt schnell klähren. Auf jeden Fall schon mal danke an alle! Ich werd mich wieder melden, wenn ich das ganze a) fertig habe oder b) noch probleme habe.

Man liest sich, Stanlay :hi:

[Stanlay Hanks]

Hallo. Ja...ich bins schon wieder :oops:
Ich hab gerade versucht, das Beispiel von S-tefano in Delphi zu verwirklichen. Und weil ich sehen wollte, ob das auch mit "außergewöhnlichen" Vergrößerungsfaktoren (also nicht nur 2x, 3x, 4x) geht, hab ich ein 98 x 98 großes Bidl (das DP Logo :wink: :dp:) genommen und es mit Strechdraw auf 200 Pixel Größe zeichnen lassen. Jetzt hab ich ein wenig gerechnet: Das "Gestretchte" Bild ist um 102 Pixel größer als das Original. Demzufolge müsste ich jetzt doch jetzt jedes 1,96078431372549. Pixel interpolieren. :gruebel: Aber wie geht das? Ich meine, ich kann doch nicht "zwischen den Pixeln" zeichnen oder interpolieren. (Mein Gedankengang ist der, dass man ein Pixel doch in Integerwerten angeben muss und nicht in Fließkommawerten). Kann mir da wer auf die Sprünge helfen? (Tut mir ehrlich leid, wenn ich jetzt schon langsam nerve, aber ich verstehs nicht richtig :oops:)

Danke, Stanlay :hi:

[himitsu]

Wenn du dir mal mein Beispiel anschaust wirst du merken, das hier nicht nur die Zwischenpixel, sondern auch die "Hauptpixel" (wie sie hier überall genannt wurden), an Hand der 4 nächstliegensten Pixel und entsprechend ihres Abstands interpoliert werden.

Wenn zum Beispiel bei einer regelmäßigen Struktur Pixel (Zeilen/Spalten) eingefügt werden und sich die "Hauptpixel" nicht ändern, kann es unschön ausseh'n.


S-tefano meinte das z.B. so:

Delphi-Quellcode:

Org:  --------------------
Zoom: ----i---i---i---i---i----

i = werden interpoliert

[Stanlay Hanks]

Hallo. Du meinst also, ich soll das ganze Bild interpolieren? Also zum Beispiel:

Code:

Gestretchtes Bild:
xxxxxxxxxxxxxxxxxxxx
1. Schleifendurchgang:
xixxxxxxxxxxxxxxxxxx
2. Schleifendurchgang:
xxixxxxxxxxxxxxxxxxx

Hast du das so gemeint?

Was S-Tefano gemeint hat, hab ich schon verstanden, nur es ist halt manchmal so, dass es rein rechnerisch nötig wäre, nicht jeder 4,5 oder 6. Pixel zu interpolieren, sondern zum Beispiel jedes 1,237582. Pixel. verstehst du, was ich meine :(

Man liest sich, Stanlay :hi:

[himitsu]

Das Beispiel sucht für jedes Pixel einzeln die 4 Pixel, welche dieses überlagern, und berechnet daraus einen entsprechenden Wert.

Delphi-Quellcode:

1          2   |   1   2
    I          |     I
               |   3   4
               |
               |   z.B.: 1*25% + 2*25% + 3*25% + 4*25%
3          4   |
               |
z.B.: 1*50% + 2*23% + 3*17% + 4*10%