1. Dashboard
  2. Mitglieder
    1. Letzte Aktivitäten
    2. Benutzer online
    3. Team
    4. Mitgliedersuche
  3. Forenregeln
  4. Forum
    1. Unerledigte Themen
  • Anmelden
  • Registrieren
  • Suche
Alles
  • Alles
  • Artikel
  • Seiten
  • Forum
  • Erweiterte Suche
  1. AutoIt.de - Das deutschsprachige Forum.
  2. Mitglieder
  3. Mars

Beiträge von Mars

  • Probleme mit Arrays

    • Mars
    • 6. Februar 2016 um 14:28

    Habe gerade gesehen, dass autoBerts Lösung durch den Regex ca. 10x schneller ist als meine Lösung...
    Also habe ich mal nachgerüstet :D (Sollte jetzt ca. 2x schneller sein als autoBerts Lösung)

    AutoIt
    #include <Array.au3>
    
    
    Local $sRead = FileRead('log.txt')
    Local $aLog = LogToArray($sRead)
    
    
    _ArrayDisplay($aLog)
    
    
    Func LogToArray($sLog)
    	Local $aSplit = StringRegExp(StringReplace(StringReplace($sLog, '[', '', 0, 1), ']', '', 0, 1), 'Ihr erhaltet: (.*)', 3), $iUbound = UBound($aSplit), $aRet[$iUbound][2], $aTmp, $iUboundCnt = $iUbound
    	For $i = 0 To $iUbound - 1 Step 1 ; Aufräumen und Zahlen finden
    		$aTmp = StringSplit($aSplit[$i], ' ')
    		$aRet[$i][1] = StringInStr($aSplit[$i], ' x ', 0, 1) ? $aTmp[$aTmp[0]] : 1
    		$aRet[$i][0] = StringStripWS($aRet[$i][1] > 1 ? StringLeft($aSplit[$i], StringInStr($aSplit[$i], ' x ', 0, 1)) : $aSplit[$i], 3)
    	Next
    	For $i = $iUbound - 1 To 0 Step -1 ; Zusammenfassen
    		For $ii = $i - 1 To 0 Step -1
    			If $aRet[$i][0] = $aRet[$ii][0] Then ; Doppelter Eintrag gefunden
    				$aRet[$ii][1] += $aRet[$i][1]    ; Anzahl addieren
    				For $u = $i To $iUboundCnt - 2 Step 1 ; Quasi wie ArrayDelete für ein 2D Array mit [n][2]
    					$aRet[$u][0] = $aRet[$u + 1][0]   ; Allerdings wird das Array nicht verkleinert, sodass
    					$aRet[$u][1] = $aRet[$u + 1][1]   ; kein ReDim aufgerufen wird -> ReDim ist (relativ) langsam.
    				Next
    				$iUboundCnt -= 1 ; Der hier zeigt an wie groß das Array eigentlich sein sollte.
    				ExitLoop
    			EndIf
    		Next
    	Next
    	ReDim $aRet[$iUboundCnt][2] ; Nur 1x Redim
    	Return _ArraySort($aRet, 1, 0, 0, 1) ? $aRet : 0  ;Sortieren
    EndFunc
    Alles anzeigen

    lg
    M

  • Probleme mit Arrays

    • Mars
    • 6. Februar 2016 um 12:07

    Oh... da habe ich nicht drauf geachtet... Habe nicht bemerkt, dass da Leerzeichen am Ende übrig bleiben.
    Ist gefixt, jetzt müsste das Ergebnis bei uns beiden gleich sein.

    AutoIt: Skript
    #include <Array.au3>
    
    
    Local $sRead = FileRead('log.txt')
    Local $aLog = LogToArray($sRead)
    
    
    _ArrayDisplay($aLog)
    
    
    Func LogToArray($sLog)
    	Local $aSplit = StringSplit(StringReplace($sLog, @CR, ''), @LF, 2)
    	For $i = UBound($aSplit) - 1 To 0 Step -1 ; Splitten und unnützes Zeug löschen
    		If $aSplit[$i] = '' Or Not (StringMid($aSplit[$i], 11, 13) == 'Ihr erhaltet:') Then _ArrayDelete($aSplit, $i)
    	Next
    	Local $aRet[UBound($aSplit)][2], $aTmp
    	For $i = 0 To UBound($aRet) - 1 Step 1 ; Aufräumen und Zahlen finden
    		$aRet[$i][0] = StringTrimLeft($aSplit[$i], 24)
    		$aTmp = StringSplit($aRet[$i][0], ' ')
    		$aRet[$i][1] = StringInStr($aRet[$i][0], ' x ', 0, 1) ? $aTmp[$aTmp[0]] : 1
    		$aRet[$i][0] = $aRet[$i][1] > 1 ? StringLeft($aRet[$i][0], StringInStr($aRet[$i][0], ' x ', 0, 1)) : $aRet[$i][0]
    		If StringRight($aRet[$i][0], 1) = ' ' Then $aRet[$i][0] = StringTrimRight($aRet[$i][0], 1)
    	Next
    	For $i = UBound($aRet) - 1 To 0 Step -1 ; Zusammenfassen
    		For $ii = $i - 1 To 0 Step -1
    			If $aRet[$i][0] = $aRet[$ii][0] Then ; Doppelt
    				$aRet[$ii][1] += $aRet[$i][1] ; Anzahl addieren
    				_ArrayDelete($aRet, $i) ; Doppeltes Element löschen
    				ExitLoop
    			EndIf
    		Next
    	Next
    	_ArraySort($aRet, 1, 0, 0, 1) ; Sortieren
    	Return $aRet
    EndFunc
    Alles anzeigen

    lg
    M

  • Probleme mit Arrays

    • Mars
    • 6. Februar 2016 um 11:53

    Das _ArrayDisplay ist natürlich völlig unnötig, es ist nur um das fertige Array anzuzeigen.

    Das Skript funktioniert so:
    1. Include Array -> Damit werden Arrayfunktionen wie _ArrayDisplay, _ArraySort, usw freigeschaltet
    3. $sRead = FileRead(Hier den Pfad zur Logdatei eingeben) -> In der Variable $sRead steht nun der Inhalt der Logdatei als String
    4. $aLog = LogToArray($sRead) -> Wandelt den String in ein Array um (Das müsste das Array sein, das du haben wolltest)
    6. _ArrayDisplay($aLog) -> Zeigt das fertige Array an
    8. Funktionsbeginn der Funktion die aus dem String das Array macht
    29. Optionales Sortieren -> Dmit ist das Item was am häufigsten gefunden wurde an Stelle 1. Kann aber auskommentiert werden, wenn man es nicht sortiert haben möchte.
    10, 20, 21. Rückwärts Loop -> Dadurch ist es wesentlich einfacher Arrayelemente zu löschen. Beim Löschen wird die Arraygröße um 1 verringert, sodass man nicht mehr zum vorherbestimmten Ende des Arrays durchlaufen kann (In dem Fall müsste man den Index manuell um 1 verringern, oder die Schleife neu starten). Läuft man aber Rückwärts werden nur Elemente gelöscht die man sowieso nicht mehr besucht hätte, sodass man sich Sonderfälle und Ausnahmen schenken kann.

    Edit: Villeicht liest du dir https://www.autoitscript.com/wiki/Best_coding_practices durch. Da ist eine Liste der Prefixe die man üblicherweise in AutoIt verwendet (das ist kein muss, erleichtert aber sich im Skript zurechtzufinden. z.B. ist $sRead -> s + Read -> s = String + Read = Variablenname oder aLog -> a + Log -> a = Array + Log = Variablenname)

    Edit2:

    Zitat von Raupi

    @autoBert, warum hast du deinen letzten Beitrag deaktiviert?

    Weil er es kann :D

    lg
    M

  • Probleme mit Arrays

    • Mars
    • 5. Februar 2016 um 22:20

    Man wird ja wohl noch etwas diskutieren dürfen :P
    Manchmal ist es schon okay, dass ein bisschen geschwätzt wird, wir sind schließlich keine Roboter die mit einem Input ohne irgendwas zu sagen direkt einen Output liefern.

    Hier meine Lösung, leider habe ich einen anderen Programmierstil und daher die komplette Funktion nochmal geschrieben... ohne ArrayUnique, ohne RegEx., ohne Zauberei.

    AutoIt
    #include <Array.au3>
    
    
    Local $sRead = FileRead('log.txt')
    Local $aLog = LogToArray($sRead)
    
    
    _ArrayDisplay($aLog)
    
    
    Func LogToArray($sLog)
    	Local $aSplit = StringSplit(StringReplace($sLog, @CR, ''), @LF, 2)
    	For $i = UBound($aSplit) - 1 To 0 Step -1 ; Splitten und unnützes Zeug löschen
    		If $aSplit[$i] = '' Or Not (StringMid($aSplit[$i], 11, 13) == 'Ihr erhaltet:') Then _ArrayDelete($aSplit, $i)
    	Next
    	Local $aRet[UBound($aSplit)][2], $aTmp
    	For $i = 0 To UBound($aRet) - 1 Step 1 ; Aufräumen und Zahlen finden
    		$aRet[$i][0] = StringTrimLeft($aSplit[$i], 24)
    		$aTmp = StringSplit($aRet[$i][0], ' ')
    		$aRet[$i][1] = StringInStr($aRet[$i][0], ' x ', 0, 1) ? $aTmp[$aTmp[0]] : 1
    		$aRet[$i][0] = $aRet[$i][1] > 1 ? StringLeft($aRet[$i][0], StringInStr($aRet[$i][0], ' x ', 0, 1)) : $aRet[$i][0]
    	Next
    	For $i = UBound($aRet) - 1 To 0 Step -1 ; Zusammenfassen
    		For $ii = $i - 1 To 0 Step -1
    			If $aRet[$i][0] = $aRet[$ii][0] Then ; Doppelt
    				$aRet[$ii][1] += $aRet[$i][1] ; Anzahl addieren
    				_ArrayDelete($aRet, $i) ; Doppeltes Element löschen
    				ExitLoop
    			EndIf
    		Next
    	Next
    	_ArraySort($aRet, 1, 0, 0, 1) ; Sortieren
    	Return $aRet
    EndFunc
    Alles anzeigen

    lg

    M

  • Probleme mit Arrays

    • Mars
    • 5. Februar 2016 um 20:51

    Moin,

    Ich will hier nicht flamen, sondern nur eigene Erfahrung (die ich erst kürzlich gemacht habe) teilen. Ich durfte für ein anderes MMO (Aura Kingdom) nichtmal eine Uhr die mir Events im Spiel die zu bestimmten Zeiträumen auftreten anzeigt herstellen. Ich hatte vorher selbstversträndlich die AGBs gelesen und nichts anstößiges gefunden, weiterhin hat mein Programm in keinster Weise auf irgendwelche Dateien des spiels zugegriffen, oder irgendetwas im Spiel angezeigt. Es war nur ein einfaches Windowsfenster das anzeigen konnte wann das nächste Event startet. Von einem GameMaster habe ich gehört, dass mein Acc gesperrt wird, wenn ich dieses Tool nicht sofort aus dem Internetz nehme, warum konnte mir aber leider nicht gesagt werden (der GM selbst wusste nicht gegen was für Regeln ich verstoße, er hat die Sache auch nur an irgendwen weitergeleitet).

    Daher mein Rat: Frage nach ob du das was du vorhast überhaupt darfst, MMO Entwickler/Publisher fackeln nicht lange, da wird man beim kleinsten Vorfall (selbst wenn niemand versteht was daran nun ein Verstoß sein soll) direkt getötet. Nimm bitte auch die Namen deiner Gruppenmitglieder aus dem Startpost raus.

    Edit: Gerade bei Rift habe ich gehört, dass man bereits gebannt wird, wenn man sich negativ über Dev's, sonstige Teammitglieder, p2w, und alles was denen nicht in den Kram passt äußert.

    Edit2: Versuche Anonym zu fragen ohne Verweis auf diesen Thread. Wenn du weißt ob du es darfst, dann kann man sich hier darum kümmern. Falls dem nicht so ist wird es hier keinen Support geben. Wir haben auch unsere Regeln ;)

    lg
    M

  • Alles gute Andy!

    • Mars
    • 4. Februar 2016 um 17:06

    Ein halbes Jahrhundert !

  • _ArraySmooth

    • Mars
    • 3. Februar 2016 um 21:19

    Moin,

    Anbei eine Möglichkeit um 1D Arrays eine "Kantenglättung" zu verpassen. Genutzt wird die übliche Quadratmethode (also 25% des linken Nachbarn + 25% des rechten Nachbarn + 50% der Mitte = Inhalt des neuen Elements).

    Wissenswertes:
    - Das Array darf nur Zahlen enthalten (int oder float)
    - Es wird das gesamte Array verändert, im ersten Element darf also kein UBound stehen
    - Für große Unschärfewerte (iSmooth) und große Arrays nimmt die Funktion viel Zeit in Anspruch (ein 5000 Teile Array benötigt ca. 1 Sekunde für 100x Glättung)
    - Der letzte Parameter ermöglicht es einzustellen ob Start- und Endpunkt fixiert werden sollen.
    - Es wird angenommen, dass der Abstand zwischen zwei Arrayteilen immer gleich ist. Daher ist diese Glättungsmethode für Ereignisse mit Zeitstempel vollkommen ungeeignet.

    [Blockierte Grafik: http://i.imgur.com/qLMaFaf.png]

    AutoIt: _ArraySmooth.au3
    ; Nur für die Anzeige im Testskript
    #include <Array.au3>
    
    
    Local $aTest = DefaultArray()
    _ArrayDisplay($aTest)
    
    
    ;~ _ArraySmooth($aTest, 15, True)
    Local $t = TimerInit()
    _ArraySmooth($aTest, 15, False)
    ConsoleWrite(TimerDiff($t) & @CRLF)
    _ArrayDisplay($aTest)
    
    
    Func DefaultArray($n = 50) ; Zufälliges Array mit einer Kurve erzeugen
    	Local $aRet[$n], $o = Random(0, 10)
    	For $i = 0 To $n - 1 Step 1
    		$aRet[$i] = Round(Sin($i/5 + $o) * Random(5, 10) + Random(5, 10), 0) + 1
    	Next
    	Return $aRet
    EndFunc
    
    
    ; #INDEX# =======================================================================================================================
    ; Title .........: _ArraySmooth
    ; AutoIt Version : 3.3.14.1
    ; Date ..........: 02.02.2016
    ; Modified ......:
    ; Language ......: Deutsch
    ; Description ...: Funktion um ein 1D Array welches nur Zahlen enthält zu glätten
    ; Author(s) .....: Mars
    ; ===============================================================================================================================
    
    
    ; #CURRENT# =====================================================================================================================
    ; _ArraySmooth
    ; ===============================================================================================================================
    
    
    ; #INTERNAL_USE_ONLY# ===========================================================================================================
    ; __ArraySmooth
    ; __ArraySum
    ; ===============================================================================================================================
    
    
    ; #FUNCTION# ====================================================================================================================
    ; Author ........: Mars
    ; Description ...: Glättet ein 1D Array welches nur Zahlen enthält mit Quadratischer Unschärfe
    ; Parameter .....: $aArray  - Enthält vom ersten, bis zum letzten Element nur Zahlen
    ;                  $iSmooth - Anzahl Durchläufe der Glättfunktion. Höhere Zahlen bedeuten stärkeres glätten
    ;                  $bFix    - True: Start, und Endpunkt bleiben unverändert, False: Start und Endpunkt werden mit geglättet
    ; ===============================================================================================================================
    Func _ArraySmooth(ByRef $aArray, $iSmooth = 1, $bFix = False)
    	If Not IsArray($aArray) Then Return SetError(1, 0, 0)
    	If UBound($aArray, 0) <> 1 Then Return SetError(2, 0, 0)
    	If Not IsInt($iSmooth) Or $iSmooth < 1 Or $iSmooth > 1e9 Then Return SetError(3, 0, 0)
    	For $i = 1 To $iSmooth Step 1
    		$aArray = __ArraySmooth($aArray, $bFix)
    	Next
    EndFunc
    
    
    ; #INTERNAL_USE_ONLY# ===========================================================================================================
    ; Author ........: Mars
    ; Description ...: Glättet ein 1D Array ein einziges Mal quadratisch, Rückgabe ist das geglättete Array.
    ; ===============================================================================================================================
    Func __ArraySmooth($aArray, $bFix)
    	Local $iUBound = UBound($aArray), $aCopy[$iUBound], $nSum = $bFix ? __ArraySum($aArray, 1, $iUBound - 1) : 0, $nSum2
    	$aCopy[0] = $bFix ? $aArray[0] : 0.75 * $aArray[0] + 0.25 * $aArray[1]
    	For $i = 1 To $iUBound - 2 Step 1
    		$aCopy[$i] = 0.25 * $aArray[$i - 1] + 0.5 * $aArray[$i] + 0.25 * $aArray[$i + 1]
    	Next
    	$aCopy[$iUBound - 1] = $bFix ? $aArray[$iUBound - 1] : 0.75 * $aArray[$iUBound - 1] + 0.25 * $aArray[$iUBound - 2]
    	$nSum2 = $bFix ? __ArraySum($aCopy, 1, $iUBound - 1) : 0
    	If $bFix Then
    		For $i = 1 To $iUBound - 2 Step 1
    			$aCopy[$i] *= $nSum/$nSum2
    		Next
    	EndIf
    	Return $aCopy
    EndFunc
    
    
    ; #INTERNAL_USE_ONLY# ===========================================================================================================
    ; Author ........: Mars
    ; Description ...: Summiert alle Elemente eines 1D Arrays von einem Startpunkt bis zu einem Zielpunkt
    ; ===============================================================================================================================
    Func __ArraySum(ByRef $aArray, $iStart = 0, $iEnd = -1)
    	If $iEnd = -1 Then $iEnd = UBound($aArray)
    	Local $n
    	For $i = $iStart To $iEnd - 1 Step 1
    		$n += $aArray[$i]
    	Next
    	Return $n
    EndFunc
    Alles anzeigen

    Falls es jemand gebrauchen kann, hier ist es :P

    Edit: Hatte noch C&P Fragmente im UDF-Header... Diese wurden entfernt.

    Edit2: Erklärung der Quadratmethode.
    Jeder Wert aus dem ursprünglichen Array wird in drei Teile mit den Faktoren 1/4 | 1/2 | 1/4 aufgespalten. Der Mittlere Teil wandert "geradeaus" zum Element des neuen Arrays mit gleichem Index, die beiden kleinen Teile wandern zum linken, bzw. rechten Nachbarn. Nach zweimaliger Anwendung dieser Methode ist ein Element des ursprünglichen Arrays also auf fünf Teile mit den Faktoren 1/16 | 4/16 | 6/16 | 4/16 | 1/16 verteilt. In Analogie zum Pascalschen-Dreieck (1x Anwenden = 1 2 1, 2x Anwenden = 1 4 6 4 1, usw) ergibt sich als Grenzwert (viele Anwendungen) eine Normalverteilung. Man sieht, dass trotz der extrem einfachen Überlegung im Endeffekt die mathematisch kompliziertere Gauß'sche Unschärfe angewendet werden kann, ohne irgendwelche nicht elementar integrierbaren Funktionen numerisch zu integrieren, oder sonstige anspruchsvolle Berechnungen durchzuführen.

    lg
    M

  • subscribt used on non-accessible variable.

    • Mars
    • 3. Februar 2016 um 01:23

    Bitte keine Doppelthreads zum gleichen Thema.

    lg
    M

  • Hotkeyset entfernen / befehl in einem neuen Fenster ausführen

    • Mars
    • 3. Februar 2016 um 00:49

    Moin,

    Für mich gibt es hier hauptsächlich 3 Mögliche Optionen:
    - Das X-Y-Problem liegt vor. In diesem Fall erkläre uns bitte was du erreichen willst, und nicht wie du es erreichen willst.
    - Die Fragestellung ist gerechtfertigt, da das Fernzusteuernde Programm eine Fernsteuerung erlaubt. Erkläre bitte (mit Screenshot) wie das Fenster aussieht und um was es geht.
    - Es ist ein Bot für ein Spiel. Bitte die Forenregeln lesen.

    Ohne weitere Aufklärung ist es nicht möglich sinnvolle Hilfestellungen zu deinem Problem zu liefern. Daher bitte ich um Aufklärung.

    Edit: Mit deinem Wissensstand empfiehlt es sich erstmal ein Hello World, dann einen Taschenrechner und schließlich Snake zu programmieren. Danach sollten sich ca. 95% deiner bisherigen Probleme mit dem Programmieren von selbst gelöst haben.

    lg
    M

  • CPU Kühler i7 6700k

    • Mars
    • 1. Februar 2016 um 16:01

    Wie viel Leistung der Lüfter braucht hängt hauptsächlich von ein Paar Sachen ab
    - Willst du den Rechner über einen längeren Zeitraum voll auslasten ?
    - Wie ist die Lufttemperatur im Gehäuse ? (z.B. kann man mit 60°C heißer Luft nichts abkühlen)
    - Wie ist die sonstige Belüftung des Gehäuses ? Wie warm ist die Umgebung ?

    Eine gute/konkrete Aussage lässt sich da leider schwer treffen, man kann aber etwas schätzen.

    Kühle Außentemperatur + gute Gehäusebelüftung => Kühle Luft im Gehäuse => schwächerer Kühler reicht aus.
    Schlechte Gehäusebelüftung => Luft heizt sich auf und verliert nach einer Weile die Kühlwirkung.
    usw.

    Ich glaube, dass die Elektronik inzwischen relativ hohe Temperaturen locker aushalten kann. Immerhin gibt es Laptops die so heiß werden, dass man einen Kaffee darauf kochen kann. Aber lass dich lieber etwas weiter beraten, ich bin kein Kühlerprofi sondern nur jemand der ab und zu mal einen Computer bastelt :P

    lg
    M

  • Eigentlich schon zu spät...

    • Mars
    • 27. Januar 2016 um 23:55

    Das wir hier sehr schnell verurteilen stimmt schon, allerdings sind wir meistens auch bereit zurückzurudern, sofern bei den betreffenden Leuten Einsicht für ihr Fehlverhalten eintritt. In fast jedem steckt eine Person die die Community bereichern kann, nur weiß die Person das manchmal selbst nicht.

    Dieses Zitat ist nicht durch Kürzungen verunstaltet worden.

    Zitat von Bioshade

    Sophie [...] 22 Jahre alt [...] "nen echt geiler Mensch" [...] Kaffee

    Mehr braucht man doch garnicht :thumbup:
    Gude und "nen" sagen doch nur Hessen oder ?

    lg
    M

  • schärferes Mittel als ProcessClose

    • Mars
    • 25. Januar 2016 um 22:02

    Es gibt bestimmt eine Methode wie das machbar ist. Ich habe bisher keinen eingefrohrenen Prozess gehabt die sich nur durch einen Systemneustart beenden lässt. Normalerweise kann der Taskmanager alles was abgestürzt ist beenden.

    Es gibt aber einige Sperren die Windows verhängen kann. Z.B. kann man ja auch keine Datei löschen, während ein anderes Programm ein Handle der Datei offenhält. Also ist es auch gut vorstellbar, dass es Prozesse gibt die von einem Windowsprozess offengehalten werden, sodass sie nicht beendet werden können, solange der Prozess sie nicht freigibt. Wie man sich da Abhilfe schafft weiß ich leider nicht. Auf meinem Rechner läuft im Hintergrund ein in AutoIt geschriebener Taskkiller der unerwünschtes Zeug zuverlässig mit der BuildIn Funktion ProcessClose beendet, hatte bisher nie ein Problem damit...

  • [GDI+] Asteroiden Generator

    • Mars
    • 18. Januar 2016 um 18:06

    Die Zufallsverteilung bei meinem Skript ist nicht sehr gut (habe ich eben gesehen. Da läuft wohl irgendetwas nicht ganz rund...), das ist aber nicht weiter tragisch, da ja nicht die Zufallsverteilung interessant ist, sondern die "perfekte" Anordnung in der alle Punkte den gleichen minimalen Abstand zu ihrem nächsten Nachbarn haben.

    Das skript aus Post 4 kann jetzt folgendes zusätzlich:
    - Multiplikator: Beschleunigt die Berechnung und erhöht die Ungenauigkeit (vorallem zu Beginn). Später ist man mit einem Wert 1.000 < x < 100.000 gut bedient, höher ist nutzlos, da die Geschwindigkeit durch Rundungsfehler verringert wird. Im Allgemeinen sollte er so eingestellt werden, dass er für die gegebene Verteilung nicht zu ungenau und nicht zu langsam ist.
    - Berechnung pausieren (sodass man wieder eine flüssige Rotation bei normaler Geschwindigkeit hat)
    - Speichern: Speichert die Koordinaten aller Punkte in einer Datei ab. (Obacht, es wird NICHT überschrieben. Also immer eine neue Datei anlegen)
    - Laden: Läd eine vorher abgespeicherte Datei und zeigt die Punkte an.

    Jetzt können Vertielungen berechnet und gespeichert werden. Man kann sie später laden und das Skript etwas weiterrechnen lassen (dann wird die Verteilung nach beliebig langer Zeit beliebig gleichmäßig), oder die gewonnenen Daten für irgendetwas benutzen. (ich habe aber bisher keine Ahnung wozu man soetwas gebrauchen könnte^^).

    Im Anhang sind ein paar Verteilungen für 60, 100, 200, 300, 400 vorberechnet, sodass man sich ein Bild machen kann was dieses Skript bezwecken soll.

    lg
    M

    Dateien

    KugelTest 02.zip 38,45 kB – 422 Downloads
  • [GDI+] Asteroiden Generator

    • Mars
    • 17. Januar 2016 um 22:27

    Doppelpostalarm, aber es gibt auch etwas neues :)

    Ich habe mir überlegt lieber auf 3D umzusteigen und später aus den Koordinaten von Punkten auf einer Kugel durch transformation die Asteroidenoberfläche zu bekommen. Nach sehr vielen Ansätzen wie man die Punkte mit bestmöglicher Verteilung platziert habe ich keine mathematische Lösung gefunden und bin auf das Vielkörperproblem umgestiehen, das man ja numerisch mit sehr viel Rechenzeit lösen kann.

    Genutzt wird also eine Einheitskugel mit einer gewissen Anzahl Punkte aus der Oberfläche. Diese stoßen sich gegenseitig ab, sodass sie nach einiger Zeit den größt möglichen Abstand zueinander haben. Die daraus entstehenden Koordinaten kann man für jede Anzahl Punkte abspeichern, sodass diese nur 1x berechnet werden müssen. (Später kann man die Koordinaten im eigentlichen Generator einfach laden und damit weiterarbeiten).

    Anbei ist das Skript welches (mit schöner 3D Animation) die einzelnen Punkte während des Rechenvorgangs anzeigt. (Ein Dank geht hier an die wunderbare 3D GDI+ UDF von Starg aus dem englischen Forum: [Klick mich])

    lg
    M

    Dateien

    KugelTest.zip 6,48 kB – 449 Downloads
  • [GDI+] Asteroiden Generator

    • Mars
    • 13. Januar 2016 um 00:02

    Darüber habe ich auch schon nachgedacht... allerdings ist das ohne eine Dll oder ASM nicht zu bewerkstelligen. Ich wollte erstmal rein in AutoIt bleiben. (und dort sollte die Rechnung in unter 100ms fertig sein).

    Was ich vergessen habe zu erwähnen: Die normale Größe die benötigt wird liegt zwischen 12 und ca. 56 Pixeln. Deshalb ist es nicht soooo schlimm, dass die Asteroiden mit 100+ Pixeln etwas hässlich aussehen.

  • [GDI+] Asteroiden Generator

    • Mars
    • 12. Januar 2016 um 19:52

    Moin,

    Im Prinzip wollte ich einen Thread im Hilfebereich aufmachen, da ich hier etwas Hilfe (oder eine "zündende" Idee) brauche, aber es gibt schon ein funktionierendes Skript, also sind wir im Skriptbereich.

    Das Tool soll folgendes tun: Einen Asteroiden (in 2D, GDI+) generieren.

    Anforderungen (ein Teil davon ist zum Teil erfüllt, das meiste aber nicht)
    - Der Asteroid soll möglichst nicht "schlecht" aussehen. (z.B. eine einfarbige Fläche wäre nicht sonderlich gut).
    - Die Laufzeit sollte unter 100ms betragen um einen Asteroiden zu generieren (da später mal eine ganze Menge gebraucht werden und niemand 5 Min Ladezeit haben will).
    - Der Asteroid braucht eine Art "Rohstoff" (in diesem Fall Grün, jede andere Farbe geht aber auch) der ohne Formveränderung des Asteroiden bei gleichem Seed Einstellbar sein sollte.
    - ggf eine Beleuchung mit 1-2 Lichtquellen. (Hier habe ich keine Idee, wie soetwas in annehmbarer Zeit via GDI+ machbar ist. Ich glaube aber, dass es hier mal eine kleine GDI+ Demonstration mit Leuchteffekten gab.)

    Natürlich könnte ich jetzt noch stundenlang weiterbasteln bis alles eingebaut ist was ich gerne hätte und anschließend herumoptimieren bis die Zeit (halbwegs) stimmt. Ich möchte aber ggf vorher ein paar Ideen von einigen GDI+ Leuten einholen :)
    Für alle anderen Gilt: Habt Spaß und generiert euch Asteroiden :P (Und falls ihr interessante Farbkombinationen findet könnt ihr sie gerne posten)

    AutoIt: Asteroiden Generator
    #include-once
    #include <GDIPlus.au3>
    #include <Array.au3>
    
    
    _GDIPlus_Startup()
    
    
    Global $hAsteroid, $bRefresh = True
    Global $bPaint = False
    Global $iW = 400, $iH = 200
    Global $hGUI = GUICreate('Asteroid Generator', $iW, $iH)
    Global $hGfx = _GDIPlus_GraphicsCreateFromHWND($hGUI)
    Global $hBmp = _GDIPlus_BitmapCreateFromScan0($iH, $iH)
    Global $hBuf = _GDIPlus_ImageGetGraphicsContext($hBmp)
    GUICtrlCreateEdit('Größe', $iH + 5, 5, 50, 20, 2049)
    Global $hSli1 = GUICtrlCreateSlider($iH + 60, 5, $iW - $iH - 65 - 50, 20)
    Global $hLab1 = GUICtrlCreateEdit('76', $iW - 50, 5, 45, 20, 2049)
    GUICtrlSetData($hSli1, Round(GUICtrlRead($hLab1)/1.5 - 4, 0))
    
    
    GUICtrlCreateEdit('Col3%', $iH + 5, 30, 50, 20, 2049)
    Global $hSli2 = GUICtrlCreateSlider($iH + 60, 30, $iW - $iH - 65 - 50, 20)
    Global $hLab2 = GUICtrlCreateEdit('50', $iW - 50, 30, 45, 20, 2049)
    GUICtrlSetData($hSli2, GUICtrlRead($hLab2))
    
    
    GUICtrlCreateEdit('Seed', $iH + 5, 55, 50, 20, 2049)
    Global $hBtn3 = GUICtrlCreateButton('Random', $iH + 60, 55, $iW - $iH - 65 - 50, 20)
    Global $hLab3 = GUICtrlCreateEdit(Random(0, 999999, 1), $iW - 50, 55, 45, 20, 1)
    
    
    GUICtrlCreateEdit('Col 1', $iH + 5, 80, 62, 18, 2049)
    GUICtrlCreateEdit('Col 2', $iH + 69, 80, 62, 18, 2049)
    GUICtrlCreateEdit('Col 3', $iH + 133, 80, 62, 18, 2049)
    
    
    Global $hCol1 = GUICtrlCreateEdit('FF602000', $iH + 5, 100, 62, 18, 1)
    GUICtrlSetFont(-1, 7, 400, 0, 'Arial', 5)
    Global $hCol2 = GUICtrlCreateEdit('FF909090', $iH + 69, 100, 62, 18, 1)
    GUICtrlSetFont(-1, 7, 400, 0, 'Arial', 5)
    Global $hCol3 = GUICtrlCreateEdit('FF00FF00', $iH + 133, 100, 62, 18, 1)
    GUICtrlSetFont(-1, 7, 400, 0, 'Arial', 5)
    
    
    Global $hNew = GUICtrlCreateButton('Redraw', $iH + Round(($iW - $iH)/2, 0) - 50, 125, 100, 25)
    Global $hSave = GUICtrlCreateButton('Save', $iH + Round(($iW - $iH)/2, 0) - 50, 155, 100, 25)
    
    
    GUISetState()
    GUIRegisterMsg(0xF, 'WM_PAINT')
    
    
    WM_PAINT()
    
    
    While True
    	Switch GUIGetMsg()
    		Case -3
    			ExitLoop
    		Case $hSli1, $hSli2
    			$xTmp = Round(1.5 * GUICtrlRead($hSli1) + 8, 0)
    			GUICtrlSetData($hLab1, $xTmp)
    			GUICtrlSetData($hLab2, GUICtrlRead($hSli2))
    			$bRefresh = True
    		Case $hBtn3
    			GUICtrlSetData($hLab3, Random(0, 999999, 1))
    			$bRefresh = True
    		Case $hNew
    			$bRefresh = True
    		Case $hSave
    			$xTmp = FileSaveDialog('Zieldatei eingeben', @ScriptDir, '(*.png)')
    			_GDIPlus_ImageSaveToFile($hAsteroid, $xTmp)
    	EndSwitch
    
    
    	If $bRefresh Then
    		$bRefresh = False
    		$bPaint = False
    		$xTmp = Round(1.5 * GUICtrlRead($hSli1) + 8, 0)
    		_GDIPlus_BitmapDispose($hAsteroid)
    		$hAsteroid = _AsteroidCreateBitmap($xTmp, GUICtrlRead($hSli2), GUICtrlRead($hLab3), '0x' & GUICtrlRead($hCol1), '0x' & GUICtrlRead($hCol2), '0x' & GUICtrlRead($hCol3))
    		_GDIPlus_GraphicsClearCheckboard($hBuf, 0xFF9F9F9F, 0xFFE2E2E2, 200, 200)
    		_GDIPlus_GraphicsDrawImage($hBuf, $hAsteroid, Round($iH/2 - $xTmp/2, 0), Round($iH/2 - $xTmp/2, 0))
    		$bPaint = True
    		WM_PAINT()
    	EndIf
    
    
    WEnd
    
    
    Func _GDIPlus_GraphicsClearCheckboard($hGFX, $iCol1, $iCol2, $iW, $iH)
    	Local $hBRU1 = _GDIPlus_BrushCreateSolid($iCol1)
    	Local $hBRU2 = _GDIPlus_BrushCreateSolid($iCol2)
    	Local $iD = Round(($iW ^ 2 + $iH ^ 2) ^ 0.25 / 2, 0)
    	For $x = 0 To Int($iW / $iD) - 1 Step 1
    		For $y = 0 To Int($iH / $iD) - 1 Step 1
    			_GDIPlus_GraphicsFillRect($hGfx, $x * $iD, $y * $iD, $iD, $iD, IsInt($x/2) ? (IsInt($y/2) ? $hBRU1 : $hBRU2) : (IsInt($y/2) ? $hBRU2 : $hBRU1))
    		Next
    	Next
    	_GDIPlus_BrushDispose($hBRU1)
    	_GDIPlus_BrushDispose($hBRU2)
    EndFunc
    
    
    _GDIPlus_BitmapDispose($hAsteroid)
    _GDIPlus_GraphicsDispose($hBuf)
    _GDIPlus_BitmapDispose($hBmp)
    _GDIPlus_GraphicsDispose($hGfx)
    
    
    Func WM_PAINT()
    	If $bPaint Then _GDIPlus_GraphicsDrawImage($hGfx, $hBmp, 0, 0)
    EndFunc
    
    
    
    
    
    
    
    
    ;~ SRandom(@MSEC + @SEC*1000 + @MIN*1000*60)
    ;~ Global $t = TimerInit()
    ;~ For $i = 1 To 4 Step 1
    ;~ 	_AsteroidCreateBitmap(48, 0, $i*2)
    ;~ Next
    ;~ ConsoleWrite(Round(TimerDiff($t)/($i-1),0) & ' ms' & @CRLF)
    
    
    _GDIPlus_Shutdown()
    
    
    Func _AsteroidCreateBitmap($iSizePx = 32, $iCrystalPercent = 25, $iSeed = Default, $iCol1 = 0xFF602000, $iCol2 = 0xFF909090, $iCol3 = 0xFF00FF00)
    	Local $hBmp = _GDIPlus_BitmapCreateFromScan0($iSizePx, $iSizePx)
    	Local $hPen = _GDIPlus_PenCreate(0x40000000, $iSizePx^0.25/1.5)
    	Local $hBru = _GDIPlus_BrushCreateSolid()
    	Local $hGfx = _GDIPlus_ImageGetGraphicsContext($hBmp)
    	Local Const $fDegToRad = 3.141592653589793 / 180
    	_GDIPlus_GraphicsSetSmoothingMode($hGfx, 2)
    	_GDIPlus_GraphicsSetPixelOffsetMode($hGfx, 2)
    
    
    	If $iSeed <> Default Then SRandom($iSeed)
    
    
    	; Schritt 1: Umriss definieren
    	Local $iPoints = Round($iSizePx^0.45*2.5, 0), $aPoints[$iPoints + 1][2] = [[$iPoints, 0]], $iRandomOffset
    	For $i = 1 To $iPoints Step 1
    		$iRandomOffset = Random(-90/$iPoints, 90/$iPoints) * $fDegToRad
    		$aPoints[$i][0] = ($iSizePx * 0.4 * Cos($i/($iPoints)*$fDegToRad*360 + $iRandomOffset) + $iSizePx * 0.5) * Random(0.9^(1/($iPoints^0.25)), 1.1^(1/($iPoints^0.25)))
    		$aPoints[$i][1] = ($iSizePx * 0.4 * Sin($i/($iPoints)*$fDegToRad*360 + $iRandomOffset) + $iSizePx * 0.5) * Random(0.9^(1/($iPoints^0.25)), 1.1^(1/($iPoints^0.25)))
    	Next
    	_PointsStauchen($aPoints, $iSizePx * 0.5, Random(0.75, 1))
    	_PointsRotate($aPoints, $iSizePx * 0.5, $iSizePx * 0.5, Random(0, 360))
    
    
    	; Schritt 2: Textur Erzeugen
    	Local $hTex = _TextureCreate($iSizePx, $iSizePx, $iCol1, $iCol2, $iCol3, $iCrystalPercent / 100)
    
    
    	; Schritt 3: Zeichnen
    	_GDIPlus_GraphicsClear($hGfx, 0)
    	_GDIPlus_GraphicsFillPolygon($hGfx, $aPoints, $hTex)
    	_GDIPlus_PenSetAlignment($hPen, 1)
    	_GDIPlus_GraphicsDrawPolygon($hGfx, $aPoints, $hPen)
    	_GDIPlus_PenSetWidth($hPen, 0.75)
    	_GDIPlus_PenSetColor($hPen, 0xEE000000)
    	_GDIPlus_PenSetAlignment($hPen, 0)
    	_GDIPlus_GraphicsDrawPolygon($hGfx, $aPoints, $hPen)
    
    
    ;~ 	_GDIPlus_ImageSaveToFile($hBmp, Random(100, 999, 1) & '.png')
    
    
    	_GDIPlus_BrushDispose($hTex)
    	_GDIPlus_GraphicsDispose($hGfx)
    	_GDIPlus_BrushDispose($hBru)
    	_GDIPlus_PenDispose($hPen)
    
    
    
    
    ;~ 	_GDIPlus_BitmapDispose($hBmp)
    	Return $hBmp
    EndFunc
    
    
    Func _TextureCreate($iW, $iH, $iCol1, $iCol2, $iCol3, $iMenge = 0.5)
    	; iCol1  : Erste Grundfarbe des Ateroiden
    	; iCol2  : Zweite Grundfarbe des Asteroiden
    	; iCol3  : Farbe von besonderem Gestein auf der Oberfläche
    	; iMenge : Menge von 0 bis 1 des besonderen Gesteins
    	Local $hBmp = _GDIPlus_BitmapCreateFromScan0($iW, $iH)
    	Local $hGfx = _GDIPlus_ImageGetGraphicsContext($hBmp)
    	Local $hBRU = _GDIPlus_BrushCreateSolid()
    	Local $aPoints = [[2, 0], [-$iW/10, -$iH/10], [$iW*1.1, $iH*1.1]]
    	_PointsRotate($aPoints, $iW/2, $iH/2, Random(0, 360))
    	Local $hLine = _GDIPlus_LineBrushCreate($aPoints[1][0], $aPoints[1][1], $aPoints[2][0], $aPoints[2][1], $iCol1, $iCol2)
    	_GDIPlus_GraphicsSetSmoothingMode($hGfx, 2)
    
    
    	; Grundfarbe
    	_GDIPlus_GraphicsFillRect($hGfx, -$iW/10, -$iH/10, $iW * 1.1, $iH*1.1, $hLine)
    	Local $iD, $aMulti = [4, 3, 2, 2]
    
    
    	For $n = 0 To 3 Step 1
    		For $i = 0 To Round(($iW ^ 2 + $iH ^ 2) ^ 0.5 * $aMulti[$n], 0) Step 1
    			_GDIPlus_BrushSetSolidColor($hBRU, BitOR('0x' & Hex(Int(Round(Random(24 / $aMulti[$n], 56 / $aMulti[$n])*$iMenge, 0)), 2) & '000000', BitAND($iCol3, 0xFFFFFF)))
    			$iD = Random($iW/18*$aMulti[$n], $iW/12*$aMulti[$n]) * ((Random(0, 4, 1) = 0) ? 4 : 1)
    			$aPoints = _PointsFromRect(0, 0, $iD, $iD)
    			_PointsRotate($aPoints, $iD/2, $iD/2, Random(0, 360))
    			_PointsTranslate($aPoints, Random(-$iD, $iW + $iD), Random(-$iD, $iH + $iD))
    			_GDIPlus_GraphicsFillPolygon($hGfx, $aPoints, $hBRU)
    			_GDIPlus_BrushSetSolidColor($hBRU, BitOR('0x' & Hex(Int(Random(16 / $aMulti[$n], 48 / $aMulti[$n], 1)), 2) & '000000', BitAND($iCol1, 0xFFFFFF)))
    			$iD = Random($iW/9*$aMulti[$n], $iW/4*$aMulti[$n])
    			$aPoints = _PointsFromRect(0, 0, $iD, $iD)
    			_PointsRotate($aPoints, $iD/2, $iD/2, Random(0, 360))
    			_PointsTranslate($aPoints, Random(-$iD, $iW + $iD), Random(-$iD, $iH + $iD))
    			_GDIPlus_GraphicsFillPolygon($hGfx, $aPoints, $hBRU)
    			_GDIPlus_BrushSetSolidColor($hBRU, BitOR('0x' & Hex(Int(Random(16 / $aMulti[$n], 48 / $aMulti[$n], 1)), 2) & '000000', BitAND($iCol2, 0xFFFFFF)))
    			$iD = Random($iW/12*$aMulti[$n], $iW/8*$aMulti[$n])
    			$aPoints = _PointsFromRect(0, 0, $iD, $iD)
    			_PointsRotate($aPoints, $iD/2, $iD/2, Random(0, 360))
    			_PointsTranslate($aPoints, Random(-$iD, $iW + $iD), Random(-$iD, $iH + $iD))
    			_GDIPlus_GraphicsFillPolygon($hGfx, $aPoints, $hBRU)
    			_GDIPlus_BrushSetSolidColor($hBRU, '0x' & Hex(Int(Random(8, 16, 1)), 2) & '000000')
    			$iD = Random($iW/12*$aMulti[$n], $iW/8*$aMulti[$n])
    			$aPoints = _PointsFromRect(0, 0, $iD, $iD)
    			_PointsRotate($aPoints, $iD/2, $iD/2, Random(0, 360))
    			_PointsTranslate($aPoints, Random(-$iD, $iW + $iD), Random(-$iD, $iH + $iD))
    			_GDIPlus_GraphicsFillPolygon($hGfx, $aPoints, $hBRU)
    		Next
    	Next
    
    
    ;~ 	_GDIPlus_ImageSaveToFile($hBmp, Random(100, 999, 1) & '.png')
    
    
    	Local $hTex = _GDIPlus_TextureCreate($hBmp)
    
    
    	_GDIPlus_BrushDispose($hLine)
    	_GDIPlus_BrushDispose($hBru)
    	_GDIPlus_GraphicsDispose($hGfx)
    	_GDIPlus_BitmapDispose($hBmp)
    	Return $hTex
    EndFunc
    
    
    Func _PointsTranslate(ByRef $aPoints, $iX, $iY)
    	For $i = 1 To $aPoints[0][0] Step 1
    		$aPoints[$i][0] += $iX
    		$aPoints[$i][1] += $iY
    	Next
    EndFunc
    
    
    Func _PointsStauchen(ByRef $aPoints, $mY, $nFaktor = 1)
    	For $i = 1 To $aPoints[0][0] Step 1
    		$aPoints[$i][1] = ($aPoints[$i][1] - $mY) * $nFaktor + $mY
    	Next
    EndFunc
    
    
    Func _PointsRotate(ByRef $aPoints, $mX, $mY, $nDegAngle)
    	Local $x, $fAngle = $nDegAngle / 180 * 3.141593
    	For $i = 1 To $aPoints[0][0] Step 1
    		$x = $mX + Cos($fAngle) * ($aPoints[$i][0] - $mX) - Sin($fAngle) * ($aPoints[$i][1] - $mY)
    		$aPoints[$i][1] = $mY + Sin($fAngle) * ($aPoints[$i][0] - $mX) + Cos($fAngle) * ($aPoints[$i][1] - $mY)
    		$aPoints[$i][0] = $x
    	Next
    EndFunc
    
    
    Func _PointsFromRect($iX, $iY, $iW, $iH)
    	Local $aPoints[5][2]
    	$aPoints[0][0] = 4
    	$aPoints[1][0] = $iX
    	$aPoints[1][1] = $iY
    	$aPoints[2][0] = $iX + $iW
    	$aPoints[2][1] = $iY
    	$aPoints[3][0] = $iX + $iW
    	$aPoints[3][1] = $iY + $iH
    	$aPoints[4][0] = $iX
    	$aPoints[4][1] = $iY + $iH
    	Return $aPoints
    EndFunc
    Alles anzeigen


    PS: Ich weiß, dass das Skript sehr Spaghetticodeartig ist. Optimierungen sind erstmal nicht nötig, solange das Ergebnis noch nicht stimmt ;)

    lg
    Mars

  • Bestimmtes Bit im Hex-Wert auf 1 setzten

    • Mars
    • 7. Januar 2016 um 01:02

    Habe kurz 2 Funktionen zusammengebastelt. Sie sind nur kurz getestet, es sollte vllt nochmal jemand drüberschauen. Nach meiner Einschätzung tun sie genau was du willst.

    AutoIt
    Local $Var = 123456
    
    
    ConsoleWrite($Var & ': ')
    For $i = 0 To 31 Step 1
    	ConsoleWrite(GetBit($Var, $i) & ' ')
    Next
    ConsoleWrite(@CRLF)
    
    
    ; Obacht, gezählt wird ab 0. Also Das erste Bit ist das 0te Bit.
    SetBit($Var, 19, 1) ; 19tes Bit auf 1
    SetBit($Var, 14, 0) ; 14tes Bit auf 0
    SetBit($Var,  3, 1) ;  3tes Bit auf 1
    
    
    ConsoleWrite($Var & ': ')
    For $i = 0 To 31 Step 1
    	ConsoleWrite(GetBit($Var, $i) & ' ')
    Next
    ConsoleWrite(@CRLF)
    
    
    
    
    Func SetBit(ByRef $iVar, $iPos, $iValue)
    	$iValue = $iValue ? 1 : 0
    	If IsInt($iPos) And $iPos >= 0 And $iPos < 32 And GetBit($iVar, $iPos) <> $iValue Then
    		$iVar = $iVar + 2 ^ $iPos * (BitAND($iVar, 2^$iPos) ? -1 : 1)
    	Else
    		Return SetError(1, 0, 0)
    	EndIf
    EndFunc
    
    
    Func GetBit($iVar, $iPos)
    	If IsInt($iPos) And $iPos >= 0 And $iPos < 32 Then Return BitAND($iVar, 2^$iPos) ? 1 : 0
    	Return SetError(1, 0, 0)
    EndFunc
    Alles anzeigen

    lg
    M

  • X-Mas

    • Mars
    • 24. Dezember 2015 um 19:19

    X-Mas ist ein Unwort :)

    Allen frohe Weihnachten, seit nicht am PC sondern esst Lebkuchen !

    lg
    M

  • GDI+ Wave

    • Mars
    • 22. Dezember 2015 um 11:03

    Ich weiß, dass man das in AutoIt nicht machen darf, aber als Beispiel hab ich die Funktion kurz gebastelt. (Müsste natürlich noch optimiert und in ASM portiert werden).

    Edit: Also das wäre mein Lösungsansatz zu diesem Problem. Weil diese "Lücken" irgendwie IMMER Auftauchen, egal was man anstellt (Hatte ich auch schon mehrfach, dagegen gibt es kein Heilmittel^^)

    Dateien

    LinienKleber.zip 181,91 kB – 418 Downloads
  • GDI+ Wave

    • Mars
    • 22. Dezember 2015 um 10:32

    Meinst du die Linien die entstehen, wenn die Vordergrundbilder nicht genau Kante an Kante gezeichnet werden ?

    Ich glaube (bin mir aber nicht sicher), dass sowas im Regelfall seeehr Primitiv gelöst wird.
    - Man checkt für jeden Pixel, ob er die Hintergrundfarbe hat.
    - Wenn er dann von 3 Pixeln umgeben ist die eine andere Farbe haben kopiert man den Inhalt eines dieser Pixel.
    - Weiter zum nächsten.
    Die Methode ist schnell und bei Animationen achtet eh niemand auf einen einzigen Pixel der dann die gleiche Farbe wie der Nachbar hat. Allerdings wäre das eine nachträgliche Bildbearbeitung, die nur funktioniert wenn die Linien die Hintergrundfarbe haben (oder transparent sind, ist ja egal in welchem Umfeld man sich befindet).

Spenden

Jeder Euro hilft uns, Euch zu helfen.

Download

AutoIt Tutorial
AutoIt Buch
Onlinehilfe
AutoIt Entwickler
  1. Datenschutzerklärung
  2. Impressum
  3. Shoutbox-Archiv
Community-Software: WoltLab Suite™