Bild bearbeiten

RedHead

hey leute, ich kam auf folgende idee!
ich möchte mir ein program schreiben das die pixel-anzahl eines bildes erhöht. ich habe mir das ungefähr so gedacht das 2 nebeneinander stehende pixel im bild "auseinander gezogen" werden und dazwischen ein neuer pixel eingefügt wird. dieser neue pixel soll noch "leer" sein, also noch garkeine farbe/farbinformation enthalten. anschließen soll die farbe der beiden pixel, die auseinander gezogen wurden, bestimmt werden und eine art "mittelwert" berechnet werden (z.b. wenn der eine pixel dunkelblau ist und der andere hellblau, sodass man dann als ergebnis eine "normales" blau erhält)! der zuvor neu entstandene pixel, der noch "leer" ist, soll nun mit diesem mittelwert eingefärbt werden.
nun meine frage ist ob soetwas mit autoit möglich wäre und wenn ja, ob mir einer dabei einen kleinen denkanstoß geben könnte

**chip**

Das ganze wird dann aber aussehen wie außeinander gezogen also upropotional.

James · AutoIt Version (Prod): 3.3.14.2

chip Wenn das Bild in jede Richtung um 50% größer wird, hat es doch immernoch das gleiche Seitenverhältnis, oder etwa nicht?

RedHead

Zitat von James1337

chip Wenn das Bild in jede Richtung um 50% größer wird, hat es doch immernoch das gleiche Seitenverhältnis, oder etwa nicht?

ja wenn man es gleichmäßig in alle richtung erweitert sollte sich dich eigentlich nichts verändern, also würde es doch theoretisch nicht wie außeinander gezogen aussehen

**chip**

Zitat von James1337

chip Wenn das Bild in jede Richtung um 50% größer wird, hat es doch immernoch das gleiche Seitenverhältnis, oder etwa nicht?

Dann ja, aber laut seiner Beschreibung macht er genau das nicht:

Zitat

ich habe mir das ungefähr so gedacht das 2 nebeneinander stehende pixel im bild "auseinander gezogen" werden

RedHead

ups, dann habe ich mich wohl falsch ausgedrückt

ich meinte das ungefähr so:
p = "alter" pixel
n = "neuer" pixel

vorher:
pppp
pppp
pppp
pppp

überarbeitet:
1.möglichkeit:
pnpnpnp
npnpnpn
pnpnpnp
npnpnpn

2.möglichkeit
pnpnpnp
pnpnpnp
pnpnpnp
pnpnpnp

die farbe der "n" pixel soll jeweil aus den angrenzenden "alten" pixel "berechnen" werden
(hoffe das es jetzt verständlicher ist )

um auf meine anfängliche frage zurück zu kommen...
wäre sowas denn mit autoit möglich und wenn ja, ob mir einer dabei einen denkanstoß geben könnte

**chip**

Und genau so wird das ganze verzerrt sein.

Dein n müsst eine Schnittmenge aus den jeweils vier benachbarten p Pixeln sein.

Ansonst müsstest da so in etwa machen wenn die Schnittmenge nicht errechnest:

pnnpnnpn
nnnnnnnn
nnnnnnnn
pnnpnnpn

K4z

Wenn dir mal langweilig ist, kannst du dich ja mal mit den verschiedenen Interpolationsverfahren auseinandersetzen... Hab da mal ne GFS drüber gehalten.
Edit: Einfach mal nach Nearest Neighbor suchen, da findest du einiges, z.B.
Nearest Neighbor Image Scaling

**UEZ**

Warum das Rad neu erfinden?

In der GDIp.au3 ist bereits die Funktion _GDIPlus_GraphicsSetInterpolationMode() implementiert, die beim Scalen eines Bildes 7 verschiedene Interploationsmodis mitbringt.

Spoiler anzeigen

[autoit]

; #FUNCTION# ====================================================================================================================
; Name...........: _GDIPlus_GraphicsSetInterpolationMode
; Description ...: Sets the interpolation mode of a Graphics object
; Syntax.........: _GDIPlus_GraphicsSetInterpolationMode($hGraphics, $iInterpolationMode)
; Parameters ....: $hGraphics - Pointer to a Graphics object
; $iInterpolationMode - Interpolation mode:
; |0 - Default interpolation mode
; |1 - Low-quality mode
; |2 - High-quality mode
; |3 - Bilinear interpolation. No prefiltering is done
; |4 - Bicubic interpolation. No prefiltering is done
; |5 - Nearest-neighbor interpolation
; |6 - High-quality, bilinear interpolation. Prefiltering is performed to ensure high-quality shrinking
; |7 - High-quality, bicubic interpolation. Prefiltering is performed to ensure high-quality shrinking
; Return values .: Success - True
; Failure - False and either:
; |@error and @extended are set if DllCall failed
; |$GDIP_STATUS contains a non zero value specifying the error code
; Remarks .......: The interpolation mode determines the algorithm that is used when images are scaled or rotated
; Related .......: _GDIPlus_GraphicsGetInterpolationMode
; Link ..........; @@MsdnLink@@ GdipSetInterpolationMode
; Example .......; No
; ===============================================================================================================================
Func _GDIPlus_GraphicsSetInterpolationMode($hGraphics, $iInterpolationMode)
Local $aResult = DllCall($ghGDIPDll, "uint", "GdipSetInterpolationMode", "handle", $hGraphics, "int", $iInterpolationMode)

[/autoit] [autoit][/autoit] [autoit]

If @error Then Return SetError(@error, @extended, False)
$GDIP_STATUS = $aResult[0]
Return $aResult[0] = 0
EndFunc ;==>_GDIPlus_GraphicsSetInterpolationMode

[/autoit]

Gruß,
UEZ

K4z

Das ist mir bekannt:D Ich denke nur, dass er das mal selber nachmachen wollte... Mit FASM könntem man da glaube ich relativ einfach erledigen.

RedHead

cool, das es sowas schon gibt wusste ich garnicht habs nämlich nicht gefunden

Zitat von K4z

Das ist mir bekannt:D Ich denke nur, dass er das mal selber nachmachen wollte...

genau ich wollte soetwas mal selber machen um die gedankengänge/ ideen die dahinter stecken besser zu verstehen

K4z

Mhh ich hab jetzt mal bissle was mit FASM probiert:

Spoiler anzeigen

[autoit]

Func _asm()
_("use32")
_("mov edi, [esp+4]") ; Pointer Bitmap alt
_("mov esi, [esp+8]") ; Pointer Bitmap neu
_("mov edx, [esp+12]") ; Width
_("mov ecx, [esp+16]") ; PixelCount
_("mov ebx, edx") ; EBX=EDX

[/autoit] [autoit][/autoit] [autoit]

_("_nextPixel:")

[/autoit] [autoit][/autoit] [autoit]

_("mov eax, dword[edi]") ; EAX: PixelFarbe
_("mov dword[esi], eax") ; SetPixelFarbe

[/autoit] [autoit][/autoit] [autoit]

_("add edi, 4")
_("add esi, 8")

[/autoit] [autoit][/autoit] [autoit]

_("sub ebx, 1") ;
_("ja _widthnz") ; Wenn die Bildbreite erreicht ist,
_("mov eax, edx") ; dann wird die Bildbreite*8 auf ESI
_("imul eax, 8") ; dazuaddiert
_("add esi, eax") ;
_("mov ebx, edx")
_("_widthnz:") ;

[/autoit] [autoit][/autoit] [autoit]

_("sub ecx, 1")
_("ja _nextPixel")

[/autoit] [autoit][/autoit] [autoit]

_("ret")
EndFunc ;==>_asm

[/autoit]

Wie gesagt, ich bin in Assmbler noch ein ziemlicher Anfänger, aber es mach aus

Spoiler anzeigen

[Blockierte Grafik: http://s1.directupload.net/images/120224/lbw6noly.jpg]

das:

Spoiler anzeigen

[Blockierte Grafik: http://s7.directupload.net/images/120224/k4rgufn4.jpg]

Dann hättest du zumindest schon mal das Grundgerüst:)
Das ganze könnte man natürlich auch in AutoIt lösen

EDIT: So klappts dann bei mir, aber irgendwie ist das etwas umständlich

Spoiler anzeigen

[autoit]

Func _asm()
_("use32")
_("mov edi, [esp+4]") ; Pointer Bitmap alt
_("mov esi, [esp+8]") ; Pointer Bitmap neu
_("mov edx, [esp+12]") ; Width
_("mov ecx, [esp+16]") ; PixelCount
_("mov ebx, edx")

[/autoit] [autoit][/autoit] [autoit]

_("_nextPixel:")

[/autoit] [autoit][/autoit] [autoit]

_("mov eax, dword[edi]") ; EAX: PixelFarbe
_("mov dword[esi], eax") ; SetPixelFarbe
_("mov dword[esi+4], eax") ; SetPixelFarbe(rechts)

[/autoit] [autoit][/autoit] [autoit]

_("push ebx")
_("mov ebx, edx")
_("imul ebx, 8")
_("add ebx, esi")
_("mov dword[ebx], eax") ; SetPixelFarbe(links unten)
_("mov dword[ebx+4], eax") ; SetPixelFarbe(rechts unten)
_("pop ebx")

[/autoit] [autoit][/autoit] [autoit]

_("add edi, 4")
_("add esi, 8")

[/autoit] [autoit][/autoit] [autoit]

_("sub ebx, 1") ;
_("ja _withnz") ; Wenn die Bildbreite erreicht ist,
_("mov eax, edx") ; dann wird die Bildbreite*8 auf ESI
_("imul eax, 8") ; dazuaddiert
_("add esi, eax") ;
_("mov ebx, edx")
_("_withnz:") ;

[/autoit] [autoit][/autoit] [autoit]

_("sub ecx, 1")
_("ja _nextPixel")

[/autoit] [autoit][/autoit] [autoit]

_("ret")
EndFunc ;==>_asm

[/autoit]

Würde dann danach so aussehn:

Spoiler anzeigen

[Blockierte Grafik: http://s14.directupload.net/images/120224/89vunnlr.jpg]

RedHead

also die umwandlung (grundgerüst), wie das bild danach aussieht finde ich schon echt super aber die neuen pixel sollen ja nicht die selbe farbe haben wie die alten sonder ein "mittelwert" als farbe haben

allerdings verstehe ich den code , den du geschrieben hast überhaupt nicht

K4z

hui, das wird dann aber relativ kompliziert und ich weiß nicht ob das nacher ein besseres Ergebnis erzielt. Ich kann's mir ehrlichgesagt gar nicht vorstellen, wie das funktionieren soll, ohne dass irgendwelche Streifen oder ähnliches enstehen...

RedHead

Zitat von K4z

hui, das wird dann aber relativ kompliziert und ich weiß nicht ob das nacher ein besseres Ergebnis erzielt. Ich kann's mir ehrlichgesagt gar nicht vorstellen, wie das funktionieren soll, ohne dass irgendwelche Streifen oder ähnliches enstehen...

das war bisher ja nur eine idee die ich hatte. wie das ergebnis am ende aussieht, wenn ich es überhaupt schaffe, kann man ja noch nicht sagen ;D aber ich glaube iwie auch das da am ende streifen sein werden
naja...jetzt zu meiner anderen frage. gibt es denn eine möglichkeit, wie man den "mittelwert" zweier farben berechnen/heraus finden kann?? (z.b. wäre der "mittelwert" von hellblau und dunkelblau ein "normales" blau )

name22

Wie wäre es wenn du die drei Farbkomponenten (RGB) beider Farben jeweils einzeln addierst, und dann durch zwei teilst? Dann hast du die exakte (mathematische) Mitte zwischen den beiden Farbtönen. Aber ob das dann auch so aussieht weiß ich nicht.

K4z

Ja ich hab mich grad sowieso gefragt, was er unter einem Mittelwert zwischen zwei Farben versteht:D Wenn man nämlich einfach die Mittelwerte von den Hex-Werten bildet kommt sowas dabei heraus (obere Zeile):

Spoiler anzeigen

[Blockierte Grafik: http://s14.directupload.net/images/120224/3xu3wafr.jpg]

Das ist natürlich Quark:D ich machs mal mit den einzelnen Mittelwerten der Farbkomponenten..

EDIT:
Mittelwerte der einzelnen Farbkomponenten:

Spoiler anzeigen

[Blockierte Grafik: http://s1.directupload.net/images/120224/jxc47476.jpg]

Ich frag mich trotzdem wie man das umsetzten könnte, soll dann ab der zweiten Zeile der Mittelwert der vierumgebenden Pixel genommen werden?! Wie siehts mit dem rechten und unteren Rand aus? Oder soll der Mittelwert womöglich von allen 8 angrenzenden Pixel gebildet werde? usw, usw....
Ich denke das ist ein relativ harter Brocken, aber wenn du dich damit beschäftigen möchtest, viel Spaß
Du kannst dir ja mal Bilineare Interpolation anschaun, aber ob du dich ernsthaft damit beschäftigen möchtest bezweifle ich:D

RedHead

ok deine beispiele schauen iwie nicht so aus wie ich es mir vorgestellt habe
naja trotzdem danke für die denkanstöße ich werde mal schauen wie ich das umsetze

K4z

Wie gesagt, dein Vorhaben trifft am ehesten die Bilineare Filterung, aber an der Stelle steig ich aus... Ich sollt mal langsam was fürs Abi machen:D