Verlustfreies Zoomen von Bildern (Interpolieren)

[Stanlay Hanks]

Hallo zusammen! Ich habe da ein Problem. Und zwar hab ich heute morgen ein Bitmap auf meiner HD befunden, das ich mir gerne als Cover Bild für eine Audio CD nehmen wollte. Nur das war zu klein => wenn ich es vergrößere wird es unscharf usw. Jetzt hab ich im Internet nach Tools gesucht, die verlustfrei vergrößern können. Da gibts einige. (u.A. das Programm S-Spline) Allerdings kosten die alle ne Menge. (ab 39 € was ich gesehen hab) Sind aber dafür auch gut. Naja...auf jeden Fall hab ich mir dann ganz profisorisch eine Prozedur zusammengeschustert, die ein Bild auf die doppelte Größe vergrößert. Die hat so funktioniert: Zuerst werden die Pixel des Original Bildes auf jedes 2. Pixel eines zweiten Images gemalt. Dadurch entsteht zwischen den Pixeln jeweils ein weißes, freies Pixel. Das hab ich gefüllt, indem ich den Mittelwert zwischen den Farben links und rechts von diesem Pixel berechnet hab. SO gabs einen Farbübergang. Jetzt habe ich nur folgende Probleme:
a) Ich hab das ganze mit Pixels[x,y] gemacht statt mit ScanLine :wall: (Weil ich mich mit Scanline nicht auskenne :oops:)
b) Diese Prozedur braucht dafür, ein 600x600 pixel bild auf 1200x1200 pixel zu zoomen ganze 10 Minuten (!!!).
Deshalb habe ich mir gedacht, ich frage einfach mal nach, ob ihr mir helfen könntet, eine neue Prozedur, die sowas kann, zu schreiben. Damit mich keiner falsch versteht: Ich will keinesfalls ganzen (oder kommentierten) Source, sondern ich würde mich schon sehr über Denkanstöße zu dem Thema freuen. Außerdem würde mich interessieren, ob das was ich da gemacht habe, überhaupt was mit "Interpolation" zu tun hat.

Danke schon mal. Man liest sich, Stanlay :hi:

[himitsu]

schau mal hier, da hat man sich schon mit sowas beschäftigt.

[S - tefano]

Hi,

mein Lexikon verriet mir folgendes:
"[...]2) Mathematik: Einschaltung von Zahlenwerten zwischen die Zahlen einer gegebenen Folge, damit sie so glatt wie möglich verläuft."
Demnach hast dus prinzipiell schonmal sehr richtig gemacht.
Hattest du schonmal Gelegenheit eines der professionellen Programme auszuprobieren? Vielleicht brauchen die ja genauso lange...
Und mich würd mal interessieren was Scanline ist...
U.U. ist dein Algorithmus auch nicht effektiv genug, es gibt viele verschiedene Wege einen Vorgang unter verschiedenen Verhältnissen zu wiederholen... Rekursion, verkettete Schleifen, verschachtelte Schleifen, vielleicht sind auch die Befehle die du verwendest zu langsam.
Aber ehe du keinen Vergleichswert hast, kannst du nicht sagen ob dein Prog zu lange braucht oder nicht.

Bis dann,

S - tefano

[Stanlay Hanks]

Hallo. Ich weiß schon, dass es diesen thread gibt...Ich hab ja vor ner halben Stunde ne Frage drinnen gestellt :wink: Aber ich dachte, das Antialiasing was anderes wäre, als Interpolation.

Man liest sich, Stanlay :hi:

[S - tefano]

Hups, hat sich wohl geklärt (siehe CodeLib)...

[Stanlay Hanks]

Hallo! NEIN :wink: es hat sich noch nicht geklährt. :mrgreen: Aber erstmal danke für deine ausführliche Antwort. Das war schon recht aufschlussreich für mich. Zu deiner Frage: Ja ich hatte schon Gelegenheit, S-Sline auszuprobieren. Da sieht man, wie sich die Pixel Reihe für Reihe von oben nach unten aufbauen. Und das ganze geht sehr schnell (5 Sekunden max!). Ich habe halt einfach immer in einer For Schleife (Das "to" konnte schon mal bis 1200 gehen) für die Reihen (von links nach rechts) und in einer anderen Schleife für die Spalten (von oben nach unten) die von mir beschriebenen Sachen durchgeführt...Das in der Code Lib glaube ich is doch was anderes, oder?

[himitsu]

Interpolation: Berechnug von Zwischenpixeln (Bildvergrößerung)
Antialiasing: ist im Grunde eine Kantenglättung (kann man aber gut ber der Bildvergrößerung/-verkleinerung verwenden)

Das Beispiel in der CodeLib ist allerdings nur für's reine Antialiasing ausgelegt. (nur Gättung, kein Zoom)

Bei dem anderen Thema kannst'e dir aber einige Anregungen für die Beschleunigung deiner Berechnung holen. (ScanLine, kein Round...) Deshalb hatte ich auch auf den Beitrag und nicht zur CodeLib verlinkt.

Es gibt aber auch zusätzliche Komponenten mit denen man Zoomen kann. (die in Delphi vorhanden glätten ja nicht)
Hab' jetzt leider keine Namen da, ist aber bestimmt schon hier im Forum schon mal aufgetaucht. (unter Grafikbearbeitung oder so)

[Stanlay Hanks]

Hallo. Danke für die Antwort. Ich wollte das eigentlich ohne extra Komponenten machen, weil ich dabei was lernen will. Im Moment brüte ich gerade über dem OI Eintrag von Scanline und dem Beispiel dazu.

[S - tefano]

Hm, dann hab ich das wohl verwechselt.
Wär ich nich so müde, würd ich mich jetz noch dahinterklemmen, aber ich werd wohl lieber mal in die Heia gehn.
Viel Erfolg wünsch ich noch,

S - tefano

[himitsu]

Bin wohl auch schon zu müde.
Dachte schon ich spinne - 10 = 2 (Signatur@S - tefano)
:gruebel: Hast mich jetzt total aus'm Konzept gebracht.

[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%

[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 :oops: :oops: :oops:

[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 :hello:
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 :hi:

[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 :hello:)
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 :hi:

[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 :party: Auch ich werd mich erstmal noch genau einlesen müssen, aber wie gesagt, der Groschen fällt langsam. :hello:

Man liest sich, Stanlay :hi:

[himitsu]

:nerd: 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.


:idea: 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. :firejump:

[S - tefano]

So langsam dämmerts mir... ich hatte vorher die ganze Zeit nur in einzeiligen Bildern gedacht, aber die sind ja zweidimensional... danke fürs Beispielbild, erleichtert das Verständnis.

Bis dann,

S - tefano