Das wäre auch noch mal eine Option, einfach mal 3 Dateien in einem zip hochzuladen. Vielleicht können wir ja anhand der Datei die Version ermitteln.
reverse engineering.....denn Wikipedia sagt: "Die Dokumentation der Dateistruktur ist nicht frei erhältlich."
Die Windowsversion ist völlig egal...
[autoit]#Region ;**** Directives created by AutoIt3Wrapper_GUI ****
#AutoIt3Wrapper_outfile=c:\notepad.exe
#EndRegion ;**** Directives created by AutoIt3Wrapper_GUI ****
msgbox(0,"Notepad.exe","Hallo, ich bin Notepad.exe")
Programm compilieren, erstellt eine notepad.exe in c:\
Eingabeaufforderung öffnen (irgendein Verzeichnis), notepad eingeben, enter drücken, notepad startet (Windows sucht im PATH bzw in der Registry und öffnet Notepad.exe im Windowsverzeichnis)
dann in der Eingabeaufforderung cd c:\ eingeben, enter drücken, aktuelles Verzeichnis ist c:\
notepad eingeben, enter drücken und die Msgbox "unseres" neuen Notepads erscheint.....
Es wird immer zuerst die Programmversion im aktuellen Verzeichnis gestartet bevor die Registry ins Spiel kommt!
/EDIT/ da die Pfade zu den einzelnen Programmversionen sowieso bekannt sind, setzt man auch gleichzeitig das @WorkingDir
Also ich kapiers nicht...
Bei Doppelklick auf ein *.dwg öffnet sich das AutoItscript, soweit sollte es klappen.
Dann eine Auswahlliste in der sämtliche AutoCad-Versionen stehen, click auf die Version startet per shellexecute AutoCadX im entsprechenden Verzeichnis mit der *.dwg als Parameter...
Somit startet AutocadX aus dem Verzeichnis von AutoCadX. Was in der Registry steht ist somit uninteressant, da sämtliche relevanten Informationen (Version usw) aus der AutoCad.exe bzw aus dem Programmverzeichnis kommen.
Die Registry ist doch nur dann interessant, wenn "in irgendeinem Verzeichnis" ein *.dwg angeklickt wird. Dann sucht Windows in der Registray nach dem Verweis und startet das entsprechende Programm.
Habe das eben mit einigen Programmen durchgespielt, sobald ich ins Programmverzeichnis wechsele und das Programm mit dem Parameter PfadZurDatei.xyz starte, wird auch genau diese Programmversion gestartet....
Wie werden denn die "Fehler" eurer Software von euch selbst erkannt?
ok, also musst du für Kunde A mit Version X arbeiten, und für Kunde B mit Version Y?
Dann kommst du nicht drumrum, dir entweder
- für jede Version ein Verzeichnis anzulegen, in dem NUR die Dateien enthalten sind, die mit Version X arbeiten, oder
-eine art "Datenbank" die anhand des Dateinamens ermittelt welcher Kunde bzw welche Version zum Öffnen/bearbeiten verwendet wird. Die Datenbank kann auch eine einfache Textdatei sein...
und wie findest du heraus, mit welcher Versionsnr. die Zeichnung gespeichert wurde?
Regread
[/autoit]sollte dir weiterhelfen, hier im Forum gibt es auch einiges zur automatischen Installation
und wie kann am besten abgefragt werden ob die installation erfolgreich war?
Indem die Log-Datei des Programm-Installers keine Fehler aufweist 
also in der letzten Zeile des Logs steht "Program sucessfully installed" oder etwas in der Richtung...
Zur Not kann man den Installer starten und den Installer-Prozess überwachen, wenn dieser Prozess nicht mehr aktiv ist, dann ist das Programm installiert. Das würde auch bei Silent-Installs klappen
Hallo,
du kannst die Registry direkt abfragen, falls dort die installierte Software Einträge hinterlässt.
Willst du prüfen ob die Insallation geklappt hat, oder ob von irgendwoher installierte (in einem bestimmten Verzeichnis neue) Programme vorhanden sind?
Hi,
schönes Panel, was ich noch nicht kapiert habe, wie fragst du im Emulator das Pad ab? Wenn das Ding beispielsweise am Gameport hängt, dann nützt Send() nicht sonderlich viel....
jaaa...so sollte es werden 
Das Script ist noch ziemlich buggy, aber das Gröbste klappt schon mal. Ab und zu hängt es sich beim ändern der Frequenz während des Abspielens auf....
Eigentlich hatte ich es als "Steuermodul" für die Ausgabe einer elektrischen Spannung über den LineOUT für Bastelkram vorgesehen. Gewissermaßen als Ersatz für die weggefallenen RS232 und parallelen Schnittstellen....
Objektorientierte Programmierung hat dann Sinn, wenn du einen Vorteil davon hast. D.h. wenn du in Teams arbeitest, in denen auch diese Sprachen verwendet werden.
Für dich allein im stillen Kämmerlein macht es nämlich idR keinen Unterschied, ob du mit einer prozeduralen Sprache oder mit OO zum Ziel kommst. Das Ergebnis zählt. Dem Prozessor ist es auch völlig schnurz, für den zählen nur die Opcodes, und ob die nun ein C#-Compiler oder ein C-Compiler fabriziert hat, ist nachher nicht mehr festzustellen....
Bisher steht der Beweis der kürzeren Entwicklungszeiten noch aus.
OOP ist nicht umsonst ein "Paradigma", mit Weltanschauung ließe sich das treffend bezeichnen. Und darüber streiten sich schon seit tausenden von Jahren diverse Religionen/Philosophen/Physiker/Techniker/Menschen.....
genauso, Datei binär einlesen (soweit hast du es schon) , FOR/TO Schleife bis len(binstring) und die Bytes auslesen....
Hi,
aufgrund einer Nachfrage habe ich mal in meinen halbfertigen Asservaten gewühlt. Der Generator erstellt bisher nur Sinuswellen, die Parameter sollte man einstellen können, bzw. wissen, was man wozu braucht. Die WAV-Datei wird im Speicher abgespielt, kann aber auch als Datei abgelegt werden.
Naja, ich setz mich dran um den Code mal zu entwursteln und den Rest einzubauen^^
#include <EditConstants.au3>
#include <WindowsConstants.au3>
#include <GUIConstantsEx.au3>
;Das Script erstellt eine WAV-Datei im Speicher, spielt diese ab und speichert anschließend in eine Datei
[/autoit] [autoit][/autoit] [autoit];Opt("GUIOnEventMode", 1)
[/autoit] [autoit][/autoit] [autoit]Global Const $pi = 4 * ATan(1) ;pi=3,1415926....
Global $struct, $wavstruct, $sekunden, $samplingrate, $Channels, $samplefaktor
Global $freq_sliderold = 440, $volm_sliderold = 50
$gui = GUICreate("Wave Generator ", 450, 450, -1, -1)
;label
$freq_lbl = GUICtrlCreateLabel("Frequenz Hz", 16, 16, 64, 17)
$grph_lbl = GUICtrlCreateLabel("Wave Form", 16, 184, 59, 17)
$samp_lbl = GUICtrlCreateLabel("Sampling Bits/Sec", 16, 48, 90, 17)
$bits_lbl = GUICtrlCreateLabel("Bits per Sample", 16, 120, 90, 17)
$chan_lbl = GUICtrlCreateLabel("Channels", 16, 152, 48, 17)
$show_lbl = GUICtrlCreateLabel("Show Samples ", 16, 216, 77, 17)
$volm_lbl = GUICtrlCreateLabel("Volume", 16, 80, 39, 17)
;input
Global $freq_inp = GUICtrlCreateInput("440.0", 120, 16, 81, 21, $ES_NUMBER)
Global $volm_inp = GUICtrlCreateInput("50", 120, 80, 81, 21, $ES_NUMBER)
;combo
$bits_cbo = GUICtrlCreateCombo("", 120, 120, 81, 25)
GUICtrlSetData(-1, "8|16|24", "16")
$samp_cbo = GUICtrlCreateCombo("", 120, 48, 81, 21)
GUICtrlSetData(-1, "8000|11025|12000|16000|22050|24000|32000|44100|48000", "22050")
$chan_cbo = GUICtrlCreateCombo("", 120, 152, 81, 25)
GUICtrlSetData(-1, "1|2|4", "1")
$form_cbo = GUICtrlCreateCombo("", 120, 184, 81, 25)
GUICtrlSetData(-1, "Sinus|Dreieck|Rechteck", "Sinus")
;slider
$freq_sld = GUICtrlCreateSlider(216, 16, 217, 25)
GUICtrlSetLimit($freq_sld, 20000, 1)
GUICtrlSetData($freq_sld, 441)
$volm_sld = GUICtrlCreateSlider(216, 80, 217, 25)
GUICtrlSetData($volm_sld, 100, 50)
GUICtrlSetData($volm_sld, 50)
;button
$test_btn = GUICtrlCreateButton("Test Channels", 224, 152, 105, 25, $WS_GROUP)
$play_btn = GUICtrlCreateButton("Play Wave", 16, 400, 129, 25, $WS_GROUP)
$save_btn = GUICtrlCreateButton("Save Wave to File", 160, 400, 129, 25, $WS_GROUP)
$exit_btn = GUICtrlCreateButton("Exit", 304, 400, 129, 25, $WS_GROUP)
;graphic
$graphic_line = GUICtrlCreateGraphic(16, 235, 420, 150)
GUISetState(@SW_SHOW)
[/autoit] [autoit][/autoit] [autoit][/autoit] [autoit][/autoit] [autoit]While Sleep(20)
$nMsg = GUIGetMsg(1)
Switch $nMsg[0]
Case $GUI_EVENT_CLOSE
Exit
Case $play_btn
If GUICtrlRead($play_btn) = "Stop playing" Then
GUICtrlSetData($play_btn, "Play Wave")
_playsound("") ;sound stoppen
Else
GUICtrlSetData($play_btn, "Stop playing")
_playwave(0) ;sound abspielen
EndIf
Case $GUI_EVENT_MOUSEMOVE
$mpos=GUIGetCursorInfo()
if $mpos[4]=$freq_sld and $mpos[2] then _freq_sld() ;nur wenn maus über slider und mausbutton down, dann neue frequenz holen
if $mpos[4]=$volm_sld and $mpos[2] then _volm_sld()
Case $save_btn
_playwave(1) ;sound speichern
EndSwitch
WEnd
Func _playwave($save = 0) ;bei save=1 datei speichern
[/autoit] [autoit][/autoit] [autoit]$sekunden = 5 ;so lange soll der ton inb der abgespeicherten Datei abgespielt werden
$samplingrate = GUICtrlRead($samp_cbo) ;abtastungen pro sekunde
$BitsPerSample = GUICtrlRead($bits_cbo);guictrlread( ;8,16,24 äquivalent die "Farbtiefe bei einem Bild",
$Channels = GUICtrlRead($chan_cbo) ;1,2,4, Kanäle, mono, stereo usw
$block = Int($Channels * $BitsPerSample / 
;1
$bytes = $samplingrate * $block
$samplefaktor = $BitsPerSample / 8 ;lokale hilfsvariable
$filesize = $samplefaktor * $sekunden * $samplingrate * $Channels + 44 - 8
;struktur mit dem Header einer WAV-Datei erstellen
Local $struct = DllStructCreate("byte[" & $samplefaktor * $sekunden * $samplingrate * $Channels + 44 & "]") ;platz für unser sampling
Local $s = "char RIFF [4];" & _ ;RIFF
"uint FileSize;" & _ ;Dateigröße-8 Bytes
"char WAVE [4];" & _ ;WAVE
"char fmt [4];" & _ ;fmt Header Signatur
"uint fmt_len;" & _ ;länge restl. fmt
"word Format;" & _ ;Datenformat s. Tabelle z.B. Wikipedia 1=PCM
"word Channels;" & _ ;Anzahl Kanäle 1=MONO
"uint Samplerate;" & _ ;Abtastrate pro Sekunde (22050)
"uint Bytes;" & _ ;Abtastrate * Block (22050)
"word Block;" & _ ;Channels * BitsPerSample / 8 (1)
"word BitsPerSample;" & _ ;8, 16, oder 24 (8)
"char DATA [4];" & _ ;DATA Header Signatur
"uint Len;" ;Länge des folgenden Datenblocks
Switch $samplefaktor ;je nach einstellungen platz für die wav-Daten reservieren
Case 1
$s &= "byte WAVDATA[" & $sekunden * $samplefaktor * $samplingrate * $Channels & "]"
Case 2
$s &= "word WAVDATA[" & $sekunden * $samplefaktor * $samplingrate * $Channels & "]"
Case 4
$s &= "dword WAVDATA[" & $sekunden * $samplefaktor * $samplingrate * $Channels & "]"
EndSwitch
Local $wavstruct = DllStructCreate($s, DllStructGetPtr($struct)) ;struct "überlagern" damit alle Daten byteweise in eine Datei geschrieben werden können
[/autoit] [autoit][/autoit] [autoit];Unsere Daten für die Sinuswelle
$f = GUICtrlRead($freq_inp) ;frequenz in hertz
ConsoleWrite('@@ Debug(' & @ScriptLineNumber & ') : $f = ' & $f & @CRLF & '>Error code: ' & @error & @CRLF) ;### Debug Console
$w = 2 * $pi * $f ;omega=2*pi*f für Maschinenbauer gilt: OMEGA das weiß ich, Pi mal N durch dreißig!!! :o)
$Amplitude = (GUICtrlRead($volm_inp) * 1.81019) ^ $samplefaktor ;Lautstärke, bei 8 bit maximal 2^8, bei 16 bit maximal 2^16
ConsoleWrite('@@ Debug(' & @ScriptLineNumber & ') : $Amplitude = ' & $Amplitude & @CRLF & '>Error code: ' & @error & @CRLF) ;### Debug Console
$i = 0 ;anzahl der geschriebenen bytes (funktionswerte)
If $save = 1 Then
$f = 1 / $sekunden ;falls gespeichert werden soll, anzahl Sekunden festlegen
Else
GUICtrlDelete($graphic_line) ;grafik kurven-linien löschen
GUICtrlSetColor($graphic_line, 0)
$graphic_line = GUICtrlCreateGraphic(16, 235, 420, 150) ;kurven-linien
GUICtrlSetGraphic(-1, $GUI_GR_MOVE, 0, 75)
GUICtrlSetGraphic($graphic_line, $GUI_GR_LINE, 420, 75)
GUICtrlSetColor($graphic_line, 0xFF0000)
GUICtrlSetBkColor($graphic_line, 0xFFFFFF)
GUICtrlSetGraphic($graphic_line, $GUI_GR_COLOR, 0xFF0000, 0xFFFFF0)
;GUICtrlSetGraphic($graphic_line, $GUI_GR_RECT, 0, 0, 20, 150)
EndIf
;hier gehts los, wir erstellen eine komplette sinuswelle, diese wird so lange wiederholt, bis die Abspieldauer in sekunden erreicht ist
For $t = 0 To 1 / $f Step 1 / $samplingrate ;samplingrate y(t)-Werte ()Amplituden) ermitteln
$i += 1 ;anzahl der samples
$yt = Int($Amplitude * Sin($w * $t)) ;unsere altbekannte formel
If $i < 210 Then ConsoleWrite($i & " " & $yt & @CRLF)
DllStructSetData($wavstruct, "WAVDATA", $yt, $i) ;schreiben von y(t) in die struct
If $save = 0 Then ;wenn speichern gewählt, keine welle zeichnen
GUICtrlSetGraphic($graphic_line, $GUI_GR_MOVE, Int(420 * $f * $t), 75) ;punkt auf x-achse
GUICtrlSetGraphic($graphic_line, $GUI_GR_LINE, Int($t * 420 * $f), Int(75 - ($yt / $Amplitude * 75 * GUICtrlRead($volm_inp) / 100))) ;linie zeichnen (hoehe y(t))
EndIf
If $Channels = 2 Then ;wenn 2 kanäle (stereo), dann das byte für den 2. Kanal hinzufügen
$i += 1
DllStructSetData($wavstruct, "WAVDATA", $yt, $i)
EndIf
Next
GUICtrlSetGraphic($graphic_line, $GUI_GR_REFRESH)
;jetzt werden die Daten in die struct geschrieben, es entsteht eine WAV-Datei im Speicher
DllStructSetData($wavstruct, "RIFF", "RIFF")
DllStructSetData($wavstruct, "FileSize", $filesize)
DllStructSetData($wavstruct, "WAVE", "WAVE")
DllStructSetData($wavstruct, "fmt", "fmt ")
DllStructSetData($wavstruct, "fmt_len", 16)
DllStructSetData($wavstruct, "Format", 1) ;PCM
DllStructSetData($wavstruct, "Channels", $Channels)
DllStructSetData($wavstruct, "Samplerate", $samplingrate)
DllStructSetData($wavstruct, "Bytes", $bytes) ;samplerate*block
DllStructSetData($wavstruct, "Block", $block)
DllStructSetData($wavstruct, "BitsPerSample", $BitsPerSample)
DllStructSetData($wavstruct, "DATA", "data")
DllStructSetData($wavstruct, "Len", ($samplingrate / $f * $Channels * $samplefaktor));hier wird NUR DIE LÄNGE DER ERSTEN SINUSWELLE eingetragen, um den Sound im speicher abzuspielen
ConsoleWrite('@@ Debug(' & @ScriptLineNumber & ') : ($samplingrate / $f * $Channels * $samplefaktor) = ' & ($samplingrate / $f * $Channels * $samplefaktor) & @CRLF & '>Error code: ' & @error & @CRLF) ;### Debug Console
;~ $data = ""
;~ For $i = 1 To 14 ;anzeigen des WAV-Headers
;~ $data &= DllStructGetData($wavstruct, $i) & @CRLF
;~ Next
;MsgBox(0, "Daten WAV-Header", StringLeft($data, 100))
If $save = 0 Then
_playsound("") ;aktuellen sound beenden
_Playsound(DllStructGetPtr($wavstruct), 1) ;abspielen des sounds aus dem speicher, Ton wird immer wiederholt
Else
$sdat = DllStructGetData($struct, 1) ;struktur in eine Datei schreiben
$wavdata = StringLeft(BinaryToString($sdat), $sekunden * $samplingrate * $Channels * $samplefaktor + 44)
ConsoleWrite('@@ Debug(' & @ScriptLineNumber & ') : $wavdata = ' & StringLen($wavdata) & @CRLF & '>Error code: ' & @error & @CRLF) ;### Debug Console
$wav = FileOpen("test1.wav", 18)
$bindata = FileWrite($wav, $wavdata)
ConsoleWrite('@@ Debug(' & @ScriptLineNumber & ') : $bindata = ' & $bindata & @CRLF & '>Error code: ' & @error & @CRLF) ;### Debug Console
FileClose($wav)
ShellExecute("test1.wav") ;wavedatei abspielen
EndIf
;Msgbox(0,"Ton mit Frequenz "&$f&" Hz","Spieldauer "&$sekunden&" Sekunden",$sekunden)
EndFunc ;==>_playwave
Func _freq_sld()
If GUICtrlRead($freq_sld) = $freq_sliderold Then Return
$freq_sliderold = GUICtrlRead($freq_sld)
GUICtrlSetData($freq_inp, GUICtrlRead($freq_sld))
If GUICtrlRead($play_btn) = "Stop playing" Then _playwave()
EndFunc ;==>_freq_sld
Func _volm_sld()
If GUICtrlRead($volm_sld) = $volm_sliderold Then Return
$volm_sliderold = GUICtrlRead($freq_sld)
GUICtrlSetData($volm_inp, GUICtrlRead($volm_sld))
If GUICtrlRead($play_btn) = "Stop playing" Then _playwave()
EndFunc ;==>_volm_sld
Func _PlaySound($sSoundFile, $mem = 0) ;mem=1 spielt sound aus dem speicher, dann muss $sSoundfile der pointer zum anfang der struct sein
Local Const $SND_ALIAS = 0x10000
Local Const $SND_ALIAS_ID = 0x110000
Local Const $SND_APPLICATION = 0x80
Local Const $SND_ASYNC = 0x1
Local Const $SND_FILENAME = 0x20000
Local Const $SND_LOOP = 0x8
Local Const $SND_MEMORY = 0x4
Local Const $SND_NODEFAULT = 0x2
Local Const $SND_NOSTOP = 0x10
Local Const $SND_NOWAIT = 0x2000
Local Const $SND_PURGE = 0x40
Local Const $SND_RESOURCE = 0x40004
Local Const $SND_SYNC = 0x0
If $sSoundFile = "" Then
DllCall('winmm.dll', 'int', 'PlaySoundA', 'ptr', 0, 'int', 0, 'int', 0)
Return
EndIf
If $mem = 1 Then
$a = DllCall('winmm.dll', 'int', 'PlaySoundA', 'ptr', $sSoundFile, 'int', 0, 'int', BitOR(4, 1, 8))
Else
$a = DllCall('winmm.dll', 'int', 'PlaySoundA', 'str', $sSoundFile, 'int', 0, 'int', BitOR(1, 2, 0x10))
EndIf
ConsoleWrite('@@ Debug(' & @ScriptLineNumber & ') : $a = ' & $a[0] & @CRLF & '>Error code: ' & @error & @CRLF) ;### Debug Console
EndFunc ;==>_PlaySound
Hi,
wenn ich das jetzt richtig verstanden habe, dann ist das "Bild" eigentlich egal. Wichtig ist einzig die "Höhe" (als 16-Bit-Wort) in der RAW-Datei?
Was Photoshop da genau macht, kann ich auch nicht sagen, habe den Import jetzt mit einigen Programmen gemacht, immer sieht das Ergebnis so aus wie beim RAW-Viewer. Da der Kontrast beim Photoshop-Bild ziemlich flau ist, vermute ich irgendeinen bestimmten Algorithmus 16Bit --> Graustufen
Wenn du das "Objekt" an einer bestimmten Stelle plazieren möchtest, dann brauchst du doch nur an dieser Koordinate den dazugehörenden Wert des 16-Bit-Worts in der RAW Datei zu bestimmen?!
Angenommen, dein Objekt steht an der Position zeile=80, spalte=50 (1.Pixel oben links ist 0,0) dann kannst du die 3 Zeilen aus dem Script benutzen um die Höhe aus der RAW-Datei auszulesen:
$highbyte = Asc(StringMid($bindata, 262 * $zeile + $spalte * 2 + 1, 1)) ;byte aus dem binärstring holen
$lowbyte = Asc(StringMid($bindata, 262 * $zeile + $spalte * 2 + 2, 1))
$bit16 = ($highbyte + 256 * $lowbyte) ;aus high und lowbyte ein 16-Bit-Wort machen
In $Bit16 steht dann die "Höhe", sollte das nicht klappen, High- und Lowbyte tauschen. Hast du die richtige Reihenfolge der beiden Bytes gefunden, gehts dann natürlch direkt mit nur einer Zeile (direkt die 2 Bytes auslesen)
Hi,
die Datei besteht aus 34322 Byte. Geteilt durch 131 Pixel Breite, geteilt durch 131 Pixel Höhe ergibt 2. Das bedeutet, jedes "Pixel" besteht aus 2 Byte = 16 Bit
Aus diesen 16 Bit muss man, um "normale" Graustufen (RGB=RotGrünBlau) in einer Bitmap zu erzeugen, 3 Byte machen. Wenn jeder Farbwert für R,G, und B gleich ist, dann hat man einen "Grauton". Also ist "grau" immer dann, wenn R=G=B
Wie bekommt man nun aus 16 Bit ein "GRAU" aus 3 Byte RGB?
Es gibt verschiedene Möglichkeiten, man teilt z.B. die 16 Bit in 3x5 Bit (5/5/5) oder in 5Bit,6Bit,5Bit (5/6/5) oder oder auf. Ich hab das einfach mit IrfanView ausprobiert, das Programm bietet beim Einlesen verschiedenste Filter an.
Beispiel:
Aus den ersten 2 Byte=16 Bit ( Hexcodes FB B8 ) der Datei einen Grauton erstellen:
IBM PC soll wohl auf das Intel-Format little Endian hinweisen. Das bedeutet, daß das niederwertigste Byte am Anfang steht, also B8FB.
Mit Hilfe des Windowstaschenrechners (wissenschaftliche Darstellung ^^) kann man aus den beiden Bytes B8FB die Binärdarstellung machen:
1011100011111011
wird zerlegt in 5/6/5 Bit
10111 000111 11011
die ersten 5 Bit für Rot, die nächsten 6 Bit für Grün und die letzten 5 Bit für Blau
Umformen in dezimal:
10111 = 23 ROT
000111 = 7 GRÜN
11011 = 27 BLAU
Um jetzt die 5-Bit-Zahl zu einer 8-Bit-Zahl zu machen (wir brauchen ja einen regulären 8-Bit-Wert für Rot), schauen wir uns den Zahlenbereich an. Die größte Zahl, die man mit 5 Bit darstellen kann ist 31, die grösste Zahl, die man mit 8 Bit darstellen kann ist 255 also ist der Faktor 255/31 = 8,22. Das heisst, um eine 5-Bit-Zahl in eine 8-Bit-Zahl zu transformieren, muss man sie mit 8,22 multiplizieren.
Das heisst, um eine 6-Bit-Zahl in eine 8-Bit-Zahl zu transformieren, muss man sie mit 255/63 = 4 multiplizieren.
Wie oben beschrieben, ist "GRAU", wenn R=G=B
Also zählt man R+G+B zusammen und teilt durch 3, das ergibt den Durchschnitt dieser "Farbe", also den Grauton
Rgrau=Ggrau=Bgrau= (R + G + B)/3
Rgrau=Ggrau=Bgrau= (5-Bit-Zahl * 8,22 + 6-Bit-Zahl * 4 + 5-Bit-Zahl * 8,22)/3
Rgrau=Ggrau=Bgrau= (23 * 8,22 + 7 * 4 + 27 * 8,22)/3
Rgrau=Ggrau=Bgrau= 146 = 0x92 also ist unser "Grau" die Farbe 0x929292 und so stehts als erste Farbe auch im Array^^
damit 0x929292 entsteht, muss man 0x920000 + 0x009200 + 0x000092 addieren
0x920000 = 0x92 * 256 * 256 (16 Bit nach links schieben)
0x009200 = 0x92 * 256 (8 Bit nach links schieben)
BTW, habe das Script nun angepasst, und oben editiert! Wie gesagt ist das eine der Möglichkeiten, wie man die Graustufen bestimmen KANN, ob Photoshop das genauso macht, weiß ich nicht ^^. IrfanView hat jedenfalls ähnlich importiert, das Bild sieht genauso aus....
Ich weiss jetzt nicht genau was du mit "wichtig" meinst....
/EDIT/ ersetze oben im script mal $c = round((4.632 * $g1 + 7.627 * $g2 + 4.632 * $g3) / 3) ;5 Bit nach 8 bit Näherung
Damit wirds noch ein Stück besser
Bereits in der Diskussion, und zwar HIER
Möglichkeit: (man könnte dafür ein Script schreiben 
)
Beitrag schreiben, Beitrag mit CTRL+C kopieren, Rechtsklick, Seitenspezifische Einstellungen, Scripte, Haken bei Javascript aktivieren entfernen, nach OK einmal F5 (Seite neu laden, diesmal ohne JS), Beitrag mit CTRL+C in Editorfenster hineinkopieren, Beitrag abschicken.....ggf JS wieder aktivieren...
Wenn man weder exzessiv Smilies, noch BB-Code (ausser die AutoIt-Tags *GRINS*) verwendet, braucht man bei AutoIt.de auch kein JS....NETSCAPE FTW 
Hi, hab mal etwas gebastelt....die RAW (131*131) wird angezeigt und ein Array mit allen Graustufenwerten wird ausgegeben. Du kannst es ja noch etwas umbauen....
#include <Array.au3>
$gdi32 = DllOpen("gdi32.dll")
$user32 = DllOpen("user32.dll")
Dim $farbcodes[131][131]
$hgui = GUICreate("RAW-Viewer", 400, 300, -1, -1)
$gui_DC = getdc(WinGetHandle($hgui))
$load_btn = GUICtrlCreateButton("RAW-Datei laden", 300, 20)
GUISetState()
[/autoit] [autoit][/autoit] [autoit]While 1
If GUIGetMsg() = $load_btn Then _loadfile()
If GUIGetMsg() = -3 Then Exit
WEnd
Func _loadfile()
[/autoit] [autoit][/autoit] [autoit]$file = FileOpenDialog("RAW öffnen", @DesktopDir & "\", "(*.raw)", 1)
If @error Then
MsgBox(0, "RAW-Viewer", "RAW-Datei konnte nicht gefunden werden")
Exit
EndIf
$datei = FileOpen($file, 16) ;binärmodus lesen
$bindata = (FileRead($datei))
FileClose($datei)
ConsoleWrite('@@ Debug(' & @ScriptLineNumber & ') : $bindata = ' & $bindata & @CRLF & '>Error code: ' & @error & @CRLF) ;### Debug Console
$bindata = BinaryToString($bindata)
$max = 0
$min = 0xFFFFFF
For $zeile = 0 To 130
For $spalte = 0 To 130 ;2 Byte = ein pixel
$highbyte = Asc(StringMid($bindata, 262 * $zeile + $spalte * 2 + 1, 1)) ;byte aus dem binärstring holen
$lowbyte = Asc(StringMid($bindata, 262 * $zeile + $spalte * 2 + 2, 1))
$bit16 = ($highbyte + 256 * $lowbyte) ;aus high und lowbyte ein 16-Bit-Wort machen
;16 Bit in 5/6/5 Bits splitten
$g1 = BitShift($bit16, 11) ;erste 5 bit holen
$g2 = BitShift(BitAND($bit16, 2016), 5) ;6 bit holen
$g3 = BitAND($bit16, 31) ;letzte 5 bit holen
$c = Int((8.22 * $g1 + 4 * $g2 + 8.22 * $g3) / 3) ;5 Bit nach 8 bit näherung
$col = 256 * 256 * $c + 256 * $c + $c ; Grau ist, wenn R=G=B
If $col > $max Then $max = $col ;größte Farbe
If $col < $min Then $min = $col ;kleinste Farbe
$farbcodes[$zeile][$spalte] = Hex($col, 6) ;farben ins array schreiben
setpixel($gui_DC, $spalte * 2, $zeile * 2, $col)
setpixel($gui_DC, $spalte * 2 + 1, $zeile * 2, $col)
setpixel($gui_DC, $spalte * 2, $zeile * 2 + 1, $col)
setpixel($gui_DC, $spalte * 2 + 1, $zeile * 2 + 1, $col)
Next
Next
_ArrayDisplay($farbcodes)
MsgBox(262144, 'Debug line ~' & @ScriptLineNumber, 'Selection:' & @LF & '$max' & @LF & @LF & 'Return:' & @LF & Hex($max)) ;### Debug MSGBOX
MsgBox(262144, 'Debug line ~' & @ScriptLineNumber, 'Selection:' & @LF & '$min' & @LF & @LF & 'Return:' & @LF & Hex($min)) ;### Debug MSGBOX
EndFunc ;==>_loadfile
Func setpixel($dc, $x, $y, $color) ;pixel mit farbe an koordinaten setzen
DllCall($gdi32, "long", "SetPixel", "long", $dc, "long", $x, "long", $y, "long", $color)
EndFunc ;==>setpixel
Func GetDC($handle)
$dc = DllCall($user32, "int", "GetDC", "hwnd", $handle)
Return $dc[0]
EndFunc ;==>GetDC
/EDIT/ Script angepasst
SOWAS? MAP-Formate gibts genausoviele wie RAW. Häng doch einfach mal eine Beispiel-Datei an.
"DAS" RAW-Format gibts nicht, das wird je nach Gutdünken desjenigen festgelegt, der es erstellt. Bei Digitalkameras also der Hersteller. Du öffnest auch in Photoshop kein RAW, sondern das RAW deines Kameramodells! Einige Hersteller legen ihr Format offen und liefern sogar ein SDK, andere Verschlüsseln ihre Daten sogar.
Daher ist eine universelle Lösung garnicht möglich...
$vakuum=30
[/autoit][autoit][/autoit][autoit]for $vergleich=29.5 to 31 step 0.05
if abs(round(($vergleich-$vakuum),4))<=0.1 then consolewrite ($vergleich & @CRLF )
;ConsoleWrite('@@ Debug(' & @ScriptLineNumber & ') : $vergleich-$vakuum = ' & $vergleich-$vakuum & @crlf & '>Error code: ' & @error & @crlf) ;### Debug Console
next
Allerdings sollte man, wie bei sämtlichen Floatingpointberechnungen, die Rechenungenauigkeit beachten, daher ROUND auf die relevante Anzahl der Nachkommastellen.
