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. AspirinJunkie

Beiträge von AspirinJunkie

  • "Punktwolke" erstellen?

    • AspirinJunkie
    • 14. September 2015 um 11:03

    Soll die Punktwolke ein Muster haben oder einfach nur zufällig?
    Die Tabelle "Punkte" ist im zufälligen Fall ja schnell per Random in einer Schleife schnell erstellt.
    P.S: wenn es eine Punktwolke wie im Bild werden soll brauchst du noch zu x und y eine dritte Koordinate.

    Für die Nearest-Neighbour-Suche sollte man dann unbedingt auf entsprechende Algorithmen statt Brute-Force zurückgreifen (vor allem kd-Baum basierte Methoden).
    Schnell geht es mit der FLANN-Bibliothek. Für diese hab ich mal einen rudimentären Wrapper geschrieben: >>FLANN in AutoIt<<.

  • Skript-Zeile richtig ausgeben

    • AspirinJunkie
    • 12. September 2015 um 10:25

    bisschen OT:
    Das @ScriptLineNumber-Problem auch für kompilierte Skripte löse ich bei mir immer so:

    AutoIt
    #include <File.au3>
    
    
    Global Const $LineOffset = @ScriptLineNumber - 3 - 1 ; 3 = Zeilennummer hier in der Datei
    
    
    
    
    $d_Number = _FileCountLines("C:\irgendeinedateiwelchenichtexistiert.txt")
    If @error Then _Error("Fehler bei FileCountLines", $d_Number)
    
    
    
    
    Func _Error(Const $s_Text, Const $Ret = Default, Const $b_Exit = True, Const $Error = @error, Const $Extended = @extended, Const $ScriptLine = @ScriptLineNumber)
    	Local $s_Out = StringFormat('"%s"\n\nLine: %d\n@error: %d\n@extended: %d\nReturn: %s', $s_Text, $ScriptLine - $LineOffset, $Error, $Extended, $Ret)
    	MsgBox(48, "Error", $s_Out)
    	If $b_Exit Then Exit
    EndFunc   ;==>_Error
    Alles anzeigen
  • IP in IP-Bereich? Zerlegung in Hostbereich und Netzadresse

    • AspirinJunkie
    • 10. September 2015 um 21:38
    Zitat von FKFK

    Willst du daraus eine UDF machen?

    In­wie­fern handelt es sich hierbei nicht um eine UDF?

    Zum Thema Host-Angabe bei Subnetzmasken welche nicht an einer Byte-Grenze liegen: Ob es sinnvoll ist, dass so anzugeben weiß ich nicht. Falsch ist es zumindestens nicht. Hab deswegen noch die Bitdarstellung hinzugefügt damit es einem Nutzer vielleicht klarer wird worauf das ganze basiert.

  • IP in IP-Bereich? Zerlegung in Hostbereich und Netzadresse

    • AspirinJunkie
    • 2. September 2015 um 13:17

    Sowas (quick and dirty und nahezu ungetestet)?:

    AutoIt
    #include <Array.au3>
    
    
    ; Schreibweise 1
    $a_NetHost = _IP2NetHost("192.168.1.23/255.255.255.0")
    _ArrayDisplay($a_NetHost, "192.168.1.23/255.255.255.0")
    
    
    ; Schreibweise 2
    $a_NetHost = _IP2NetHost("192.168.1.23/24")
    _ArrayDisplay($a_NetHost, "192.168.1.23/24")
    
    
    ; Zerlegt eine IP/Subnetzkombi in Netz- und Hostanteil
    Func _IP2NetHost($s_IPpSubnet)
    ; by AspirinJunkie
    	Local $s_Pattern = "(?x)^\h*                                                                                                              " & @CRLF & _
            "((?:(?:25[0-5]|2[0-4]\d|[01]\d\d|\d?\d)(?(?=\.?\d)\.)){4}\b)      # erste IP-Adresse (mit Wertebereichscheck)                        " & @CRLF & _
            "(?:                                                               # Beginn der Netzmaske                                             " & @CRLF & _
            "    \s?/?\s?                                                      # das optionale Trennzeichen mit eventuellen Leerzeichen           " & @CRLF & _
            "    \b(                                                           # falls etwas existiert soll es auch als Group gematcht werden     " & @CRLF & _
            "        (?:[1-9]|[0-2][0-9]|3[0-2])(?!\.)                         # Die Netzmaske als einfache Zahl (=Anzahl der 1-Bits in der Maske)" & @CRLF & _
            "        |                                                                                                                            " & @CRLF & _
            "        (?:(?:0|128|192|224|240|248|252|254)\.0\.0\.0)|(?:255\.(?:(?:(?:0|128|192|224|240|248|252|254)\.0\.0)|(?:255\.(?:(?:(?:0|128|192|224|240|248|252|254)\.0)|255\.(?:0|128|192|224|240|248|252|254|255)))))  # Die Netzmaske als IP-Maske                                       " & @CRLF & _
            "    )(?:[^\d]|$)                                                                                                                     " & @CRLF & _
            ")\s*$"
    
    
    	Local $a_IPParts = StringRegExp($s_IPpSubnet, $s_Pattern, 3)
    	If @error Then Return SetError(1, @error, 0)
    	Local $b_IP = _IP_BinFromString($a_IPParts[0])
    	Local $b_SubMask = _IP_SubMask2Bin($a_IPParts[1])
    
    
    	Local $a_Ret[4] = [_IP_Bin2String(BitAND($b_IP, $b_SubMask)), _IP_Bin2String(BitAnd($b_IP, BitNOT($b_SubMask)))]
    	$a_Ret[2] = _IP_2BinString($a_Ret[0])
    	$a_Ret[3] = _IP_2BinString($a_Ret[1])
    	Return $a_Ret
    EndFunc
    
    
    ; Konvertiert eine Subnetzmaskenangabe (IP- oder Ganzzahlform) in ihre binäre Entsprechung
    Func _IP_SubMask2Bin($s_Subnet)
    ; by AspirinJunkie
    	If StringRegExp($s_Subnet, "^([1-9]|[0-2][0-9]|3[0-2])$") Then ; Ganzzahlform
    		Return Binary(BitNOT((2^(32-Int($s_Subnet,1)))-1))
    	ElseIf StringRegExp($s_Subnet, "^(?:(?:128|192|224|240|248|252|254)\.0\.0\.0)|(?:255\.(?:(?:(?:0|128|192|224|240|248|252|254)\.0\.0)|(?:255\.(?:(?:(?:0|128|192|224|240|248|252|254)\.0)|255\.(?:0|128|192|224|240|248|252|254|255)))))$") Then ; IP-Form
    		Return _IP_BinFromString($s_Subnet)
    	Else
    		Return SetError(1,0, 0)
    	EndIf
    EndFunc
    
    
    ; Konvertiert einen IP-Adressstring in deren binäre Entsprechung
    Func _IP_BinFromString($s_IP)
    ; by AspirinJunkie
    	Local $a_IPParts = StringRegExp($s_IP, '\b(25[0-5]|2[0-4]\d|[01]\d\d|\d?\d)\.(25[0-5]|2[0-4]\d|[01]\d\d|\d?\d)\.(25[0-5]|2[0-4]\d|[01]\d\d|\d?\d)\.(25[0-5]|2[0-4]\d|[01]\d\d|\d?\d)\b', 3)
    	If @error Then Return SetError(1, @error, 0)
    
    
    	Local $d_Ret = 0
    	For $i = 0 To 3
    		$d_Ret += BitShift(Int($a_IPParts[$i], 1), (-3+$i) * 8)
    	Next
    	Return Binary($d_Ret)
    EndFunc   ;==>_IP_BinFromString
    
    
    ; konvertiert eine binär vorliegende IP-Adresse in deren String-Darstellung
    Func _IP_Bin2String($b_IP)
    ; by AspirinJunkie
    	Local $s_Ret = ""
    	For $i = 0 To 3
    		$s_Ret &= StringFormat("%d.", BitAND(BitShift($b_IP, (3-$i) * 8), 255))
    	Next
    	Return StringTrimRight($s_Ret, 1)
    EndFunc
    
    
    ; Konvertiert eine IP-Adresse (String oder binär) in ihre binäre Stringdarstellung
    Func _IP_2BinString($b_IP)
    ; by AspirinJunkie
    	If IsString($b_IP) Then $b_IP = _IP_BinFromString($b_IP)
    	If @error Then Return SetError(1, @error, "")
    	Local $s_Ret = ""
    	For $i = 1 To 32
    		$s_Ret &= BitAND(BitShift($b_IP, 32-$i), 1)
    	Next
    	Return $s_Ret
    EndFunc
    Alles anzeigen
  • _WinAPI_EnumFiles im lokalen Netzwerk

    • AspirinJunkie
    • 29. August 2015 um 21:13

    Versuch doch mal statt \\localhost\ \\.\ oder \\?\.
    Dann ist es wirklich lokal.

  • _WinAPI_EnumFiles im lokalen Netzwerk

    • AspirinJunkie
    • 28. August 2015 um 21:39
    Zitat von Bioshade

    WinAPI ist der Ansicht, dass der Ordner gar nicht existiert:

    Kann es vielleicht sein, dass du die _WinAPI_FileExists() etwas missverstehst? Im Gegensatz zur internen FileExists (die sie auch mit verwendet) gibt die _WinAPI_FileExists() tatsächlich nur eine 1 zurück, wenn der übergebene Pfad eine Datei ist. Bei Ordnern gibt sie prinzipiell 0 zurück - egal ob sie existieren oder nicht.
    Bei existierenden Ordnern gibt sie stattdessen eine 0 zurück und setzt aber dafür @extended auf 1.
    Bei deinem Code, hast du zwar ein @extended verwendet, dieses hat aber so immer den Wert 0, da die _WinAPI_FileExists() erst nach dessen Expansion aufgerufen wird.

    Ansonsten: Bei UNC-Pfaden unter Windows - müsste es da nicht eher \\.\d\ heißen? Bzw. \\.\D:\ wenn es ein Laufwerk ist heißen?

  • AutoIt und redirected Desktop

    • AspirinJunkie
    • 22. August 2015 um 22:25

    Wirklich sicher sein kannst du eigentlich nicht (AutoIt = Closed Source).
    Eigentlich kannst du nur Hinweise sammeln.
    Einmal geistert noch ein uralter Quellcode von AutoIt im Netz herum als AutoIt noch Open-Source war auf der anderen Seite kannst du mal mit Tools wie API-Monitor checken welche API-Funktionen von AutoIt aufgerufen werden.

    Am einfachsten wäre sicherlich jedoch statt beim Kunden zu testen, einfach mal den Pfad bei dir umleiten und bei dir testen.

  • AutoIt und redirected Desktop

    • AspirinJunkie
    • 22. August 2015 um 22:19

    Ich geh einfach mal davon aus, dass das Makro @DesktopDir über die API-Funktion SHGetKnownFolderPath seinen Inhalt bekommt.
    Diese checkt auch Rederections.

  • FFFE aus Datei auslesen (beide Byte am Anfang)

    • AspirinJunkie
    • 19. August 2015 um 11:06

    Eigentlich sollte die Problematik nur bei ANSI-kodierten Dateien auftauchen.
    Wenn man in einer Datei die Zeichenfolge äöü' hat, dann hat man keine ASCII-Datei mehr sondern mindestens ANSI.
    Heißt die Zeichenkette muss also in der entsprechenden Kodierung vorliegen.
    Wenn die Datei UTF-X kodiert ist, ist alles fein - beim Auslesen wird die Kodierung von AutoIt korrekt erkannt und auch so eingelesen wie es in der Datei gemeint ist.
    Bei ANSI hingegen kann die automatische Kodierungserkennung die Datei nicht als ANSI-Datei erkennen sondern nimmt stattdessen UTF-8 an und liest die Datei auch entsprechend aus.

    Wie soll AutoIt auch ANSI korrekt erkennen wenn eine ANSI-Datei mit äöü' als Inhalt binär vollkommen equivalent ist zu einer UTF-8 (ohne BOM)-Datei mit dem Inhalt äöü'.
    Woran könnte man exakt festmachen, dass eine Datei mit dem Binärinhalt C3A4C3B6C3BC27  nun eine ANSI-Datei mit dem Inhalt äöü' ist oder eine UTF-8-Datei mit dem Inhalt äöü'?
    Es geht leider einfach nicht.
    Da kann man den Devs noch so lange auf den Hut hauen...
    Wenn es sich um eine ANSI-Datei handelt gibt es nur den Ausweg sie explizit als ANSI-Datei zu öffnen.

    Mal zum Spielen:

    AutoIt
    $Codings = ObjCreate("Scripting.Dictionary")
    $Codings(256) = "UTF-8"
    $Codings(512) = "ANSI"
    
    
    ; Ein AutoIt-String (= UTF-16 [UCS-2])
    $s_Text = "äöü'"
    
    
    #Region ANSI
    $s_FilePath = "Ansi.txt"
    $d_Enc = 512
    ; Datei in ANSI-Kodierung beschreiben
    $hFile = FileOpen($s_FilePath, 2 + $d_Enc)
    FileWrite($hFile, $s_Text)
    FileClose($hFile)
    ConsoleWrite(StringFormat("----------------%s ------------------\ndetektierte Kodierung:\t\t\t%s\nTextinhalt (detektierte Kodierung):\t%s\nTextinhalt (explizite Kodierung):\t%s\nBinärinhalt:\t\t\t\t%s\n\n", $s_FilePath, $Codings(FileGetEncoding($s_FilePath)), FileRead($s_FilePath), FileReadWithEncoding($s_FilePath, $d_Enc), FileReadWithEncoding($s_FilePath, 16)))
    #EndRegion ANSI
    
    
    
    
    #Region UTF-8
    $s_FilePath = "UTF-8.txt"
    $d_Enc = 256
    ; Datei in UTF-8-Kodierung beschreiben
    $hFile = FileOpen($s_FilePath, 2 + $d_Enc)
    FileWrite($hFile, $s_Text)
    FileClose($hFile)
    ConsoleWrite(StringFormat("----------------%s ------------------\ndetektierte Kodierung:\t\t\t%s\nTextinhalt (detektierte Kodierung):\t%s\nTextinhalt (explizite Kodierung):\t%s\nBinärinhalt:\t\t\t\t%s\n\n", $s_FilePath, $Codings(FileGetEncoding($s_FilePath)), FileRead($s_FilePath), FileReadWithEncoding($s_FilePath, $d_Enc), FileReadWithEncoding($s_FilePath, 16)))
    #EndRegion UTF-8
    
    
    
    
    #Region Binärvergleich
    ConsoleWrite("---------------- Binärvergleich ------------------" & @CRLF)
    $s_Text_ANSI = "äöü'"
    $s_Text_UTF8 = "äöü'"
    $bin_ANSI = StringToBinary($s_Text_ANSI, 1)
    $bin_UTF8 = StringToBinary($s_Text_UTF8, 4)
    ConsoleWrite("ANSI-String: " & $s_Text_ANSI & @CRLF)
    ConsoleWrite("UTF8-String: " & $s_Text_UTF8 & @CRLF)
    ConsoleWrite("ANSI-String binär: " & $bin_ANSI & @CRLF)
    ConsoleWrite("UTF8-String binär: " & $bin_UTF8 & @CRLF & @CRLF)
    #EndRegion Binärvergleich
    
    
    
    
    Func FileReadWithEncoding($s_FilePath, $dEnc = Default)
    	Local $hFile = FileOpen($s_FilePath, $dEnc)
    	Local $bin_Return = FileRead($hFile)
    	FileClose($hFile)
    	If $dEnc = 16 Then Return Hex($bin_Return)
    	Return $bin_Return
    EndFunc   ;==>FileReadWithEncoding
    Alles anzeigen


    @supernova
    Thema also gelöst? - schön
    Darf man fragen was das eigentliche Ziel hinter der Frage war?
    Wolltest du die Dateikodierung einer Datei herausfinden?

  • FFFE aus Datei auslesen (beide Byte am Anfang)

    • AspirinJunkie
    • 18. August 2015 um 17:35
    Zitat von Andy

    @AspirinJunkie,
    *whispermode ON* schau mal geschwind nach, was binarytostring($text) aus $text="0x656667" macht *whispermode OFF*

    "efg" - ist doch auch korrekt oder hab ich was übersehen?

  • FFFE aus Datei auslesen (beide Byte am Anfang)

    • AspirinJunkie
    • 18. August 2015 um 15:50
    Zitat von Andy

    ;3.versuch nur die letzten 5 Zeichen in UTF8
    $text3=binarytostring("0x"&stringright($text,20)) ;utf-8

    Du darfst dabei nicht vergessen, dass in UTF-8 "ä", "ö" und "ü" jewils zwei Bytes statt nur einem benötigen.
    Die Zeichen also zeichenweise über die Anzahl der Bytes auszulesen funktioniert in UTF-8 so nicht.

    Im übrigen schreibst du keine Bytes sondern den Hexstring als String in die Datei.
    Das binarytostring($text) macht so ja keinen Sinn, da $text ja nicht vom Typ Binary ist sondern immer noch ein String.
    So klappt alles wie es sollte:

    AutoIt
    $text="0x6D757374657264617465695F5554462D382E7478740D0AC3A4C3B6C3BC270D0A"
    
    
    ;1.Versuch textdatei mit UTF8-Anteil
    filedelete("utf8test.txt")
    filewrite("utf8test.txt", Binary($text))
    
    
    ConsoleWrite(fileread("utf8test.txt"))

    Und so wird noch ein entsprechendes BOM hinzugefügt:

    AutoIt
    $text="0x6D757374657264617465695F5554462D382E7478740D0AC3A4C3B6C3BC270D0A"
    
    
    ; Datei als UTF-16 LE mit BOM schreiben
    $hFile = FileOpen("utf8test.txt", 34)
    filewrite($hFile, BinaryToString(Binary($text), 2))
    FileClose($hFile)
    
    
    ; Datei als Binärdatei (also Byteweise) auslesen und ausgeben.
    $hFile = FileOpen("utf8test.txt", 16)
    ConsoleWrite(Hex(fileread($hFile)))
    FileClose($hFile)
    Alles anzeigen

    Und oh! - welch Wunder! Autoit liest tatsächlich korrekt FFFE aus. Ich dachte nur das wundersame Ultra-Edit wäre dazu in der Lage... :D

  • FFFE aus Datei auslesen (beide Byte am Anfang)

    • AspirinJunkie
    • 18. August 2015 um 15:27
    Zitat von gango

    es geht wie mir scheint nicht um den Editor, oder doch.
    habe beide Dateien abgeholt und sie entsprechen dem was Supernova bebildert hat.

    Wenn es so wäre wie bebildert hätten die beiden Dateien keine Größendifferenz von nur 4 Byte sondern von mehr als 30 Byte.
    Sieht man ja auch sehr schön im Bild. Dort werden 60 Bytes angezeigt. Die Größe der hochgeladenen Datei ist aber 32 Bytes.
    Die im Bild dargestellte Datei kann also gar nicht die hier hochgeladene Datei sein.

    Da du ebenfalls Ultra-Edit verwendest riecht es daher stark nach einer impliziten Konvertierung innerhalb Ultra-Edits.
    Ein reiner Hex-Editor zeigt die Datei an wie sie ist - definitiv ohne implizite Konvertierung.

    Nehmt einfach eine Textdatei mit irgendeinem Text und speichert diese explizit als UTF-16 LE mit BOM (z.B. mit Notepad++, Notepad2, Sublime Text etc.).
    Diese Datei dann mit dem obigen Code auslesen und es wird korrekt 0xFFFE zurück gegeben.
    Weil das BOM dann auch tatsächlich in der Datei steht.
    Im Gegensatz zu den hier hochgeladenen Dateien.

    Zitat von Andy

    nimm mal die 3.3.6.1....

    Ah ok - gut zu wissen woran es lag.

    Zitat von supernova

    hier das Ergebnis wenn man die datei mit FileOpen() und dem mode=16 einliest.


    [...Bild...]


    FFFE fehlt.

    Und nicht nur FFFE - auch die ganzen Zwischennullen.
    Könnte es vielleicht nicht doch zufällig daran liegen dass diese Datei nicht der Bilddarstellung entspricht weil dieses auf der implizite Konvertierung innerhalb Ultra-Edits beruht?...
    Wie gesagt: Auch Ultra-Edit zeigt mir keinerlei FFFE an.
    Erst wenn ich auf HEX-View/EBCDIC switche.

  • FFFE aus Datei auslesen (beide Byte am Anfang)

    • AspirinJunkie
    • 18. August 2015 um 14:00
    Zitat von Andy

    Fileread("dateiname.bla") ist es herzlich egal, in welchem Format eine Datei vorliegt, es werden BYTES eingelesen!

    Eigentlich nicht ganz... ;)
    Wenn man z.B. eine UTF-16 mit BOM ohne FileOpen() mit FileRead() ausliest wird erst intern die Kodierung gecheckt und in diesem Fall dann als UTF-16 LE erkannt.
    Das führt dann dazu, dass tatsächlich das BOM (FF FE) übersprungen wird (und es werden 2 Byte pro Zeichen gelesen statt 1).
    Deswegen (wie du ja auch schriebst) um sicher zu gehen: FileOpen mit Flag 16 und alles ist gut.

    Aber kann ich deinen Post als unabhängige Bestätigung ansehen, dass die herunterladbaren Dateien des TE tatsächlich kein BOM enthalten?

  • FFFE aus Datei auslesen (beide Byte am Anfang)

    • AspirinJunkie
    • 18. August 2015 um 12:29
    Zitat von supernova

    verhedere dich nicht mit den Bezeichnungen wie UTF-16 Little Ending.
    das alles interessiert nicht was wie eine Datei ggf sein soll/könnte.

    Keine Angst ich verheddere mich da nicht.
    Und doch - es interessiert durchaus.
    Bei UTF-8 wären die zusätzlichen Nullen nicht da (und auch das FFFE am Anfang).
    Das Bild der zweiten Datei zeigt also tatsächlich eine UTF-16 LE Datei und keine UTF-8-Datei.
    Die gepostete Datei zum Herunterladen ist hingegen eine UTF-8 ohne BOM (also ohne "EF BB BF" am Anfang).

    Zitat von supernova

    mein editor (ultraedit) zeigt alles an. nicht aber jeder editor kann/will das.

    Habe mir auch extra nochmal UltraEdit runtergeladen und installiert. Die Dateien nochmals heruntergeladen und wie gesagt: Auch Ultra-Edit meldet keinerlei FFFE. Sowohl in der normalen Ansicht als auch in der HEX-View.
    Das Texteditoren das BOM (wenn sie denn UTF-Unterstützung bieten) nicht anzeigen ist klar. Deswegen schrieb ich das man einen Hex-Editor zur Hilfe nehmen soll. Denn dieser schert sich nicht um Unicode-Marker sondern behandelt eine Datei nur als Ansammlung von Bytes (genauso wie das FileOpen oben mit dem Flag 16).
    In den von dir hochgeladenen Dateien existiert das BOM schlicht und einfach nicht.
    Lad sie am besten selbst noch einmal runter und schaue Sie dir in einem HEX-Editor deiner Wahl an (z.B. den von Ultra-Edit). Dabei aber darauf achten nicht zwischenzuspeichern (denn das könnte bei entsprechend gesetzter Formatierung das BOM noch hinzufügen).

    Zitat von supernova

    das siehst du auch an der echten grösse der datei.

    Die Dateien (zumindestens diese welche man hier herunterladen kann) unterscheiden sich in exakt 4 Bytes.
    Wenn es wie in deinem Bild dargestellt zwei Bytes pro Zeichen wären, wäre die zweite Datei doppelt so groß.
    Ist sie aber nicht.

    Im UltraEdit muss man übrigens aufpassen bei der HEX-Ansicht nicht "HEX Edit/EBCDIC" zu verwenden sondern nur den normalen Hex-Edit.
    Beim ersten wird der Inhalt zur Darstellung in EBCDIC konvertiert. Dann sieht es so aus wie oben in deinem zweiten Bild.
    Mit dem eigentlichen Inhalt der Datei hat das aber nichts zu tun - es ist nur zur Darstellung im Editor konvertiert.


    Vielleicht nochmal ein paar grundlegende Basics:

    Zitat von supernova

    eine datei in UTF-8 sieht so aus (beginnt immer mit FFFE)

    Eine UTF-8 Datei beginnt nie mit FFFE. Nur UTF-16 Dateien in Little-Endian mit gesetztem BOM beginnen so.
    UTF-8 Dateien können direkt mit dem Text beginnen oder mit dem Byte-Order-Mark von UTF-8 und dieses ist bei UTF-8 eben "EF BB BF" und nicht FFFE.
    Zusammengefasst: Es ist keine Pflicht (und auch kein Quasi-Standard) das eine UTF-8-Datei mit einem BOM beginnt.
    Nur anhand der ersten zwei Bytes kann man also nie mit Sicherheit UTF-8 erkennen weil das BOM eben optional ist.

  • FFFE aus Datei auslesen (beide Byte am Anfang)

    • AspirinJunkie
    • 18. August 2015 um 10:17

    Wo ignoriert es "FFFE"?
    Die Dateien, welche du angehangen hast, enthalten wie gesagt kein "FFFE" (Siehe Hexeditor).
    Speichere ich korrekt eine Datei als UTF-16 LE mit BOM wird mir mit obigen Code auch korrekt "FFFE" zurück gegeben.

  • FFFE aus Datei auslesen (beide Byte am Anfang)

    • AspirinJunkie
    • 18. August 2015 um 10:05
    Zitat von supernova

    eine datei in UTF-8 sieht so aus (beginnt immer mit FFFE)

    Meines Wissens nach ist dies das Byte-Order-Mark von UTF-16 Little-Endian.

    Diese Marks werden nur gesetzt wenn du explizit das Byte-Order-Mark mit speichern möchtest (das ist immer mit "BOM" gemeint).
    Bei UTF-8 wäre das BOM im Übrigen "EF BB BF". Aber eine Pflicht es zu setzen gibt es nicht.
    In den von dir angehangen Dateien wurde dies auch anscheinend unterlassen.
    Denn dort gibt es kein BOM.

    Anyway: Auslesen könntest du es (so es denn existiert) in AutoIt so:

    AutoIt
    $hFile = FileOpen("musterdatei_UTF-8.txt", 16)
    $s_First2Bytes = FileRead($hFile, 2)
    FileClose($hFile)
    MsgBox(0,"", "Die ersten 2 Bytes: " & Hex($s_First2Bytes))
  • Array auf Ursprungsgröße zurücksetzen

    • AspirinJunkie
    • 17. August 2015 um 22:37

    Das .Item kann man übrigens auch weglassen.
    Kurzform:

    AutoIt
    $dictArr($_sName) = $aTmp
  • Verschlüsselungsalgorithmus (Idee)

    • AspirinJunkie
    • 16. August 2015 um 22:08
    Zitat von Andy

    Das Rauschen hat nur deswegen ein Muster mit einer bestimmten Verteilung, weil vorher die [begründete Eliminierung von unerwünschten Seiteneffekten,]

    vorgenommen wurde. Denn genau diese Ausreißer sind doch zufällig?!

    Nein eben nicht.
    Jedes dieser Pixel hat eine bestimmte physische Beschaffenheit, welche deren Rauschverhalten in einer Dunkelaufnahme bedingt.
    So werden z.B. Pixel welche näher an einer Wärmequelle liegen höhere Messwerte erzeugen als solche welche davon weiter entfernt sind.
    Die Pixel selbst sind überdies alle unterschiedlich und eben nicht perfekt gleich beschaffen. Ihr Potentialtopf (also ihr Sättigungsvermögen) ist unterschiedlich und auch die Pixelfläche unterscheidet sich. Hot-Pixel haben z.b. einen viel zu kleinen Potentialtopf, weswegen man diesen Überlaufeffekt auf benachbarte Pixel beobachten kann.
    Es sind also systematische Ursachen welche ein reproduzierbares (und damit nicht zufälliges) Muster erzeugen.
    Wäre es zufällig wären z.B. die Hotpixel dauernd an anderen Positionen.
    Erst nach der Eliminerung des systematischen Anteils bleibt der zufällige Anteil übrig - nicht anders herum.

    Zitat von Andy

    Das heißt nichts anderes, als dass bei einer Dunkelaufnahme (ein bestimmter statistischer Grenzwert wird unterschritten) ALLE, d.h. auch die Sensoren, welche ZUFÄLLIG (!!) von einem länger dauernden Photonenschauer angeregt werden, an ebendiesen Grenzwert angeglichen werden.

    Welcher Photonenschauer?
    Dunkelrauschen ist zum größten Teil thermisch induziert. Heißt Elektronen werden aufgrund der Wärme gelöst und erhöhen so das gemessene Potential eines Pixels. Photonen kommen da überhaupt nicht vor. Dieses thermische Verhalten ist, wie gesagt, kein zufälliger Regen sondern durchaus systematisch. Erst wenn die Blende auf ist kommen die Photonen dazu und reißen Elektronen aus dem Sensormaterial.

    Zitat von Andy

    Schätzen hat aber nichts mit Wahrscheinlichkeiten zu tun, sonst bräuchte man nicht Schätzen sondern könnte sich auf Berechnungen verlassen!

    Doch. Schätzen basiert auf Stochastik. Ob du dabei konkret stochastische Berechnungen anstellst oder implizit (und unbewusst) eine Genauigkeitsvorstellung von Vorgängen in deinem Kopf hast ist hierbei egal - es ist und bleibt Stochastik.

    Zitat von Andy

    - Geräte fallen reihenweise aus, weil minderwertige Bauteile verwendet werden, und nicht weil die Ausfallrate dieser Bauteile in einem bestimmten Bereich liegen.
    - In der Medizin hilft ein Medikament 10000 Menschen, aber einer stirbt an der Unverträglichkeit. Für diesen einen ist es ziemlich unerheblich, ob das Medikament ein bestimmtes statistisches Verfahren erfolgreich (?!) durchlaufen hat! Aus welchem Grund sind selbst die Beipackzettel für 08/15-Medikamente seitenlang? Wieso schreibt man nicht einfach einen einzigen Satz hinein, "Machen sie sich keine Gedanken, die Möglichkeit einer Unverträglichkeit liegt statistisch nur bei 0,234 Promille".
    - Vor ca. 4500 Jahren haben Vermesser die Grundlage für den Bau noch heute stehender Pyramiden gelegt. Andere Bauwerke weltweit sind fast ebenso alt. Ich ging erst letzte Woche über eine von Römern vor 2000 Jahren erbaute Brücke. Auch bei deren Bau hat sicherllich ein Vermesser die Finger im Spiel gehabt!
    Es kann natürlich sein, dass heutige Vermesser ohne stochastische Mittel trotz tausendfach genauerer Meßgeräte aufgeschmissen sind!
    Ich gehe bei genauerer Betrachtung allerdings davon aus, wie sonst kann es sein, dass trotz hochmodernem Equipment die Halbwertszeit von Gebäuden immer kleiner wird?
    de.wikipedia.org/wiki/Schiersteiner_Brücke Da hat wohl die Stochastik nicht so ganz hingehauen...

    Wahrscheinlich hast du Recht - wir würden wahrscheinlich schon längst mit unserem privaten Raumschiff zum Urlaub nach Alpha Centauri fliegen wenn sich diese ganzen Idioten in nahezu allen Fachdisziplinen mal mit den wirklich wichtigen Sache beschäftigt hätten anstatt sich mit so nem Mumpitz wie "Stochastik" die Zeit zu vergeuden...

    Nur zum Thema alte Vermesser: Auch diese haben (zumindest weiß ich es von den Griechen) massiv auf Wiederholungsmessungen gesetzt.
    Das ist die Anwendung und Ausnutzung der Stochastik in Reinform...

    Und diese "tausendfach genaueren Meßgeräte" arbeiten nur deshalb tausendfach so genau weil sie intern die Stochastik ausnutzen. Ein Phasenbasiertes Streckenmessgerät misst z.b. bei jeder Auslesung hunderte kleine Einzelmessungen welche es dann zu einem einzigen Messwert ausgleicht und diesem dann dem Nutzer zurück gibt.

    Zitat von Andy

    Also überbestimmt Messen damit die Genauigkeit erhöht wird und gleichzeitig die systematischen Fehler unbedingt vermeiden. DAS ist ja spannend

    Jeder Vermesser lernt, dass es drei Fehlerarten gibt:

    • Grobe Fehler (Zahlendreher, falscher Messpunkt etc.) - diese kann man lediglich detektieren und rauschmeißen - mehr nicht.
    • Systematische Fehler - diese beeinflussen die Messwerte und müssen im Ausgleichungsmodell mit berücksichtigt werden. Durch Wiederholungsmessungen werden diese Einflüsse nicht eliminiert.
    • Zufällige Fehler - nicht durch ein systematisches Modell erfassbare Abweichungen, welche aber einer stochastischen Verteilungsart folgen und folglich durch Mehrfachmessungen erfasst werden können.

    Das wussten übrigens auch schon die alten Griechen...

    Zitat von Andy

    Aber um den Bogen zum Thema zu schlagen:
    Sind Bildsensoren bzw. deren Daten nicht für den von uns benötigten "Zufall" nutzbar?

    Ich habe bewusst OT vor meinen Beitrag geschrieben weil ich zum eigentlichen Thema nichts Fundiertes beitragen kann und möchte.
    Spannendes Thema und bisschen was weiß ich auch darüber aber wenn ich mir bewusst bin, dass ich zu einem Thema maximal Halbwissen beitragen kann versuche ich einfach mal die Klappe zu halten.

    Dennoch: Zufall ist nicht gleich Zufall. Welche Form des Zufalls benötigt Ihr? Eine Gleichverteilung? Hier sind die Daten erst dann zufällig wenn, wie gesagt, erst die systematischen Effekte abgezogen werden. Das verbliebene Restrauschen sollte dann tatsächlich hinreichend zufällig sein - aber halt normalverteilt.
    Ob und wie das in dem Fall weiterhilft - da ist jetzt für mich der Moment gekommen die Klappe zu halten ;)

  • Verschlüsselungsalgorithmus (Idee)

    • AspirinJunkie
    • 16. August 2015 um 18:03
    Zitat von Andy

    den Sinn der Wahrscheinlichkeitsrechnung/Stochastik

    Die Grundlage einer wahnwitzigen Palette an Anwendungen und Innovationen welche ohne sie schlicht nicht denkbar wären.
    Allein der Begriff einer "Genauigkeit" wäre ohne die Stochastik nicht denkbar.
    Man könnte keine Raumfahrtmissionen planen da man nicht abschätzen kann wie nah man an den gewünschten Himmelskörper gelangt.
    Geräte würden reihenweise ausfallen weil keiner wusste welche Ausfallrate die verbauten Bauteile besitzen.
    Homöopathie wäre das Standardverfahren in der Medizin weil keiner ihre Wirkung und das anderer Verfahren prüfen könnte.
    Und das Schlimmste von allen: Alle Vermesser wären arbeitslos! ;)

    Man sollte halt nicht beim Münzen werfen und Würfeln stehen bleiben...

    Zitat von Andy

    Die Fotodiode ist, abhängig von ihrer Verstärkerschaltung, als Einzelstück nur dann zu gebrauchen, wenn sie auf einen bestimmten Bereich kalibriert wurde!

    Und wie lässt sie sich kalibrieren?
    In dem man die systematischen Anteile von den stochastischen (im einfachsten Fall durch Mittelwertbildung) trennt.
    Das Restrauschen ist der "zufällige" Anteil.

    Im Falle einer Dunkelaufnahme weiß man eindeutig, dass die Werte keine Nutzinformationen sind.
    Es handelt sich um einen systematischen Anteil der die späteren Nutzdaten überlagert.
    Wenn man bessere Informationen für die Nutzdaten (also ein realistischeres Bild) haben möchte muss man diesen Effekt eliminieren.
    Die Eliminerung des Dunkelrauschens wird ergo nicht, wie du dachtest, durch Glättung erreicht sondern durch Kalibrierung.

    Zum Thema Hotpixel in den RAW-Daten:
    In den RAW-Daten sind diese noch vorhanden - erst die RAW-Software macht aus den Zusatzinformationen (die Position der Hotpixel) aus den eigentlichen RAW-Daten die korrigierten Bilder. Und das ist auch durchaus legitim, da die korrigierten Werte der Realität mehr entsprechen als die unbehandelten Hotpixel.

    Zitat von Andy

    Schaue ich mir aber die Spannung "genau" an, dann sehe ich einen Bereich zwischen 0,68500 und 0,69500 Volt! Und das bei 10khz! Dort einen immer sich ändernden Wert abzugreifen, ist "Zufall"

    Du darfst nicht systematische Einflüsse mit stochastischen (was für dich anscheinend gleich zufällig bedeutet) zusammenwürfeln.
    Wenn du die Werte mehrmals abgreifst, wirst du z.B. als Messwert 0,69 V ermitteln. Das ist die wichtige Information. Eine komplett genaue Messung ist nicht möglich - deswegen hast du natürlich Schwankungen drin. Aber die Aussage, dass der wahre Wert z.B. mit 99% zwischen 0,68 und 0,7 V liegt kann dir erstmal keiner nehmen.
    Wären die abgegriffenen Werte wirklich wie du sagst rein "zufällig" wüsstests du gar nichts über sie. Ob der tatsächliche Wert 0V oder 1000 V beträgt - keine Ahnung.
    Und genauso verhält es sich mit dem Dunkelrauschen auf einem Kamerasensor.
    Das Rauschen hat einen systematischen Grund und erzeugt daher ein Muster mit einer bestimmten Verteilung. Darüber liegt noch ein bisschen Rauschen. Die Werte welche du als zufällig bezeichnest sind also nur nur zu einem gewissen Anteil wirklich zufällig. Und daher ist es keine künstliche Schönfärberei wenn man Sensordaten mit Dark-Field-Informationen korrigiert sondern eine begründete Eliminierung von unerwünschten Seiteneffekten, da die Daten damit tatsächlich verbessert und nicht einfach nur "verändert" werden.

  • Verschlüsselungsalgorithmus (Idee)

    • AspirinJunkie
    • 16. August 2015 um 13:18

    OT:

    Zitat von Andy

    Wer das selbst mal testen möchte schiesst ein Bild in einem völlig dunklen Raum und schaut sich die "Raw"-Daten an. Kommt dort "nichts" an, d.h. die untersten Bits der Pixel sind alle (!) null und nicht zufällig verteilt, dann rechnet der Kamera-Prozessor das Bild "schön".

    Zitat von Andy

    Sensorrauschen (Dunkelrauschen/Photonenrauschen), hat immer den gleichen Grund, physikalische Beeinträchtigung vom Sensor(Material) und dem unbeeinflussbaren "Beschuss" mit Photonen. Und ein Photonenstrom ist zufällig.

    Sensorrauschen ist ein zum größten Teil kein zufälliger sondern ein systematischer Effekt welcher lediglich stochastisch verteilt ist.
    Deswegen (und nur deswegen) kann er auch (z.B. über eine Dark-Field-Aufnahme) korrigiert werden.
    Sonst wäre dies schlicht nicht möglich.
    Da wird nicht etwas künstlich schöner gerechnet als es ist, sondern die eigentliche Informationen (die Photonenverteilung eines Motivs) von systematischen Abweichungen (Wärmeinduzierte Spannung, Ausleserauschen etc.) getrennt.
    Das Wärmerauschen wird stochastisch (bei selben Aufnahmebedingungen) bei jeder Aufnahme das selbe Muster erzeugen. Es ist ergo nicht zufällig.
    RAW-Bilder enthalten oftmals Zusatzinformationen zu eben diesen Verhalten, welche durch eine Dark-Field-Kalibrierung ermittelt werden können.
    Deswegen kann es zu dem witzigen Effekt kommen, dass JPGs einer Kamera Hot-Pixel enthalten und die RAW-Bilder nicht.

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™