Im Zuge eines Bildprojekts war es erforderlich, die Abmessungen des Bildes, den genauen Aufnahmezeitpunkt und die Geo-Koordinaten zu erfragen.

Um es vorweg zu nehmen: viel ist gelungen, das abschließende Programm liest die verfügbaren Parameter aus der Bilddatei, doch die GPS-Koordinaten sind noch verborgen.

Dennoch zeigt dieses Projekt den Weg, wie man die intimen Daten einer Aufnahme mit einem Programm abfragen und auswerten kann.

EXIF-Daten

Was eine Kamera über ein Bild zu sagen hat, wird in den so genannten EXIF-Daten (Exchangeable Image File Format) gespeichert. Und diese Daten befinden sich im jeweiligen Dateiformat Jpeg oder Raw. (Es werden auch Musik- und Videodateien durch das EXIF-Format beschrieben.)

Das Format hat es in sich. Die Darstellung des Datenformats in einem PDF-Dokument füllt 200 Seiten (siehe Links). Was immer man vorhat, ein vollständiges, systematisches Auslesen aller Werte ist keine Kleinigkeit, und man muss sich praktisch immer auf spezielle Fragestellungen beschränken. Die Schwierigkeit liegt darin, dass viele der Daten weitergehende Bedeutungen haben und diese ebenfalls in die Auswertung aufgenommen werden müssten.

Leider sind aber die EXIF-Daten nur der einigermaßen genormte Teil der Bilddaten, denn viele weitere Daten sind je nach Hersteller und Kamera ganz verschieden zu interpretieren. Um einen EIndruck von der Komplexität dieses Projekts zu geben, hier die Liste aller Datentypen, die in diesem Zusammenhang analysiert werden müssen:

AFCP, AIFF, APE, APP12, ASF, Apple, Audible, BMP BPG, Canon, CanonCustom, CanonRaw, CanonVRD, Casio, Composite, DICOM, DJI, DNG, DPX, DV, DarwinCore, DjVu, EXE, EXIF, Extra, FITS JSON, FLAC, FLIF, FLIR, Flash, FlashPix, Font, FotoStation, FujiFilm, GE, GIF, GIMP, GPS, GeoTiff, GoPro, H264, HP, HTML, ICC_Profile, ID3, IPTC, ISO, ITC, JFIF, JPEG, JVC, Jpeg2000, Kodak Leaf, KyoceraRaw MinoltaRaw, LNK, Lytro, M2TS, MIE, MIFF, MNG, MOI, MPC, MPEG, MPF, MWG, MXF, MacOS, Matroska, Microsoft, Minolta, Motorola, Nikon, NikonCapture, NikonCustom, Nintendo, OOXML, Ogg, Olympus, OpenEXR, Opus Theora, PCX, PDF, PGF, PICT, PLIST, PLUS, PNG, PSP, Palm, Panasonic, PanasonicRaw, Pentax, PhaseOne, PhotoCD, PhotoMechanic, Photoshop, PostScript, PrintIM, Qualcomm, QuickTime, RIFF, RSRC, RTF, Radiance, Rawzor, Real, Reconyx, Red, Ricoh, Samsung, Sanyo, Scalado, Shortcuts, Sigma, SigmaRaw, Sony, SonyIDC, Stim, Tag Table Index, Torrent, Unknown, VCard, Vorbis, WTV, XMP, ZIP, iWork

Die EXIF-Daten sind nur ein kleiner Teil in diesem Dschungel.

EXIF-Programme

Es gibt eigene Programme sich um diese Daten bemühen, aber das Datum der letzten Updates solcher Programme deutet darauf hin, dass man sie nicht mehr wirklich benötigt, weil moderne Bildbearbeitungsprogramme und auch das Windows-Betriebssystem alle Details zu den Bildern verraten.

EXIF in Windows

Mit Windows ist das Auslesen der EXIF-Daten eine leichte Übung. Ein Rechtsklick auf die Bilddatei öffnet das Kontextmenü, man wählt die Eigenschaften und im Reiter “Details” findet man die Abschnitte Beschreibung, Ursprung, Bild, Kamera, Erweiterte Fotoeigenschaften, GPS und Datei. Und in den Daten in diesen Abschnitten befindet sich alles Wissenswerte über ein bestimmtes Bild.

Exif-Viewer von Thomas Kolkmann

Ein Programm aus dem Jahr 2012 ist der Exif-Viewer.
https://www.giga.de/downloads/exif-viewer-2/

Bei der Installation muss man einen Ordner wählen. Achtung: Das Programm legt keinen eigenen Ordner an, sondern kopiert alle Dateien in den angegebenen Ordner. Man muss daher diesen Ordner zuerst manuell anlegen und dann bei der Installation explizit angeben. Die Installation dauert ungewöhnlich lang, das Programm selbst läuft aber flott.

ExifTool von Phil Harvey

https://www.sno.phy.queensu.ca/~phil/exiftool/index.html

Es handelt sich um ein mächtiges Kommandozeilen-Programm, das ich nicht weiter erforscht habe, aber die Homepage des Programms bietet eine genaue Übersicht über Exif-Tags, und die waren auch die Grundlage für die eigenen Programmierversuche:

(Achtung, die Großschreibung ist hier wichtig, …/exif.html funktioniert nicht)

Wer Bilddaten eines Bildes benötigt, besuche die Seite von Phil Harvey, lade sich die Datei exiftook(-k).exe (umbenennen in exiftook.exe) und starte sie mit einer Bilddatei als Argument. Hier das Ergebnis:

PS S:\desktop> s:\desktop\exiftool.exe IMG_20190624_092010.jpg
ExifTool Version Number : 11.60 File Name : IMG_20190624_092010.jpg Directory : . File Size : 492 kB File Modification Date/Time : 2019:06:24 22:56:45+02:00 File Access Date/Time : 2019:06:24 22:56:45+02:00 File Creation Date/Time : 2019:06:24 07:20:10+02:00 File Permissions : rw-rw-rw- File Type : JPEG File Type Extension : jpg MIME Type : image/jpeg JFIF Version : 1.01 Exif Byte Order : Big-endian (Motorola, MM) Image Description : hdrpl Make : HUAWEI Camera Model Name : LYA-L29 Orientation : Unknown (0) X Resolution : 72 Y Resolution : 72 Resolution Unit : inches Software : LYA-L29 9.0.0.266(C432E10R1P16) Modify Date : 2019:06:24 09:20:11 Y Cb Cr Positioning : Centered Document Name : Exposure Time : 1/33 F Number : 1.8 Exposure Program : Program AE ISO : 400 Exif Version : 0210 Date/Time Original : 2019:06:24 09:20:11 Create Date : 2019:06:24 09:20:11 Components Configuration : Y, Cb, Cr, - Compressed Bits Per Pixel : 0.95 Shutter Speed Value : 1/999963365 Aperture Value : 1.8 Brightness Value : 0 Exposure Compensation : 0 Max Aperture Value : 1.8 Metering Mode : Multi-segment Light Source : Daylight Flash : No Flash Focal Length : 5.6 mm Warning : [minor] Unrecognized MakerNotes Maker Note Unknown Text : Auto Sub Sec Time : 300409 Sub Sec Time Original : 300409 Sub Sec Time Digitized : 300409 Flashpix Version : 0100 Color Space : sRGB Exif Image Width : 2736 Exif Image Height : 3648 Interoperability Index : R98 - DCF basic file (sRGB) Interoperability Version : 0100 Sensing Method : One-chip color area File Source : Digital Camera Scene Type : Directly photographed Custom Rendered : Custom Exposure Mode : Auto White Balance : Auto Digital Zoom Ratio : 1 Focal Length In 35mm Format : 27 mm Scene Capture Type : Standard Gain Control : None Contrast : Normal Saturation : Normal Sharpness : Normal Subject Distance Range : Unknown GPS Version ID : 2.2.0.0 GPS Latitude Ref : North GPS Longitude Ref : East GPS Altitude Ref : Below Sea Level GPS Time Stamp : 07:20:10 GPS Processing Method : GPS GPS Date Stamp : 2019:06:24 Device Setting Description : (Binary data 4 bytes, use -b option to extract) Compression : JPEG (old-style) Thumbnail Offset : 9010 Thumbnail Length : 29088 Image Width : 2736 Image Height : 3648 Encoding Process : Baseline DCT, Huffman coding Bits Per Sample : 8 Color Components : 3 Y Cb Cr Sub Sampling : YCbCr4:2:0 (2 2) Aperture : 1.8 Image Size : 2736x3648 Megapixels : 10.0 Scale Factor To 35 mm Equivalent: 4.8 Shutter Speed : 1/33 Create Date : 2019:06:24 09:20:11.300409 Date/Time Original : 2019:06:24 09:20:11.300409 Modify Date : 2019:06:24 09:20:11.300409 Thumbnail Image : (Binary data 29088 bytes, use -b option to extract) GPS Altitude : 0 m Above Sea Level GPS Date/Time : 2019:06:24 07:20:10Z GPS Latitude : 48 deg 10' 25.74" N GPS Longitude : 16 deg 21' 50.93" E Circle Of Confusion : 0.006 mm Field Of View : 67.4 deg Focal Length : 5.6 mm (35 mm equivalent: 27.0 mm) GPS Position : 48 deg 10' 25.74" N, 16 deg 21' 50.93" E Hyperfocal Distance : 2.79 m Light Value : 4.8

exiftool.exe analysiert die Daten von Zehntausenden Tags und gibt sein Wissen auch über die Kommandozeile bekannt, zum Beispiel mit exiftool.exe -list.

EXIF-Daten per Programm

Im Beitrag “Dateieigenschaften” wurde beschrieben, dass man über ein COM-Objekt einige Bildeigenschaften abfragen kann aber bei Weitem nicht alle, die eine Kamera in die Bilddatei einträgt.

Gewünscht ist, dass man Bilddaten per Programm auslesen kann, um zum Beispiel ein Bild korrekt skalieren und beschriften zu können. Skalieren ist für die Ausgabe auf Webseiten wichtig, den die Bilder aus der Kamera sind dafür viel zu groß. Für eine Bilddokumentation kann es nützlich sein, den genauen Aufnahmezeitpunkt und die Geo-Koordinaten in die Bildbeschriftung mit aufnehmen zu können.

Für solche Aufgaben eignet sich am besten PowerShell. Sehr bewährt hat sich als Editor Visual Studio Code, denn es ist dort auch ein Debugger enthalten, mit dem man das Programm Zeile für Zeile abarbeiten kann.

Die Eigenschaften für ein Bildobjekt findet man an drei Stellen:

  • Eigenschaften einer Datei
  • Eigenschaften des Objekts Bitmap
  • Eigenschaften der EXIF-Daten

Eigenschaften einer Datei

Eine Datei wird durch die Klasse FileInfo der Assembly System.IO beschrieben. Die Klasse wird durch den new-Operator mit dem Bild D15A0663.JPG in das Objekt $FileInfo abgebildet.

Objekte sind in Powershell durch das Get-Member-Applet einfach zu untersuchen.

$FileInfo | Get-Member

GetAccessControl          Method         System.Security.AccessControl.FileSecurity GetAccessControl(), System.Security.AccessContr... 
GetHashCode               Method         int GetHashCode()
GetLifetimeService        Method         System.Object GetLifetimeService()
GetObjectData             Method         void GetObjectData(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Ser... 
GetType                   Method         type GetType()
InitializeLifetimeService Method         System.Object InitializeLifetimeService()
MoveTo                    Method         void MoveTo(string destFileName)
Open                      Method         System.IO.FileStream Open(System.IO.FileMode mode), System.IO.FileStream Open(System.IO.Fi... 
OpenRead                  Method         System.IO.FileStream OpenRead()
OpenText                  Method         System.IO.StreamReader OpenText()
OpenWrite                 Method         System.IO.FileStream OpenWrite()
Refresh                   Method         void Refresh()
Replace                   Method         System.IO.FileInfo Replace(string destinationFileName, string destinationBackupFileName), ... 
SetAccessControl          Method         void SetAccessControl(System.Security.AccessControl.FileSecurity fileSecurity)
ToString                  Method         string ToString()
Attributes                Property       System.IO.FileAttributes Attributes {get;set;}
CreationTime              Property       datetime CreationTime {get;set;}
CreationTimeUtc           Property       datetime CreationTimeUtc {get;set;}
Directory                 Property       System.IO.DirectoryInfo Directory {get;}
DirectoryName             Property       string DirectoryName {get;}
Exists                    Property       bool Exists {get;}
Extension                 Property       string Extension {get;}
FullName                  Property       string FullName {get;}
IsReadOnly                Property       bool IsReadOnly {get;set;}
LastAccessTime            Property       datetime LastAccessTime {get;set;}
LastAccessTimeUtc         Property       datetime LastAccessTimeUtc {get;set;}
LastWriteTime             Property       datetime LastWriteTime {get;set;}
LastWriteTimeUtc          Property       datetime LastWriteTimeUtc {get;set;}
Length                    Property       long Length {get;}
Name                      Property       string Name {get;}
BaseName                  ScriptProperty System.Object BaseName {get=if ($this.Extension.Length -gt 0){$this.Name.Remove($this.Name... 
VersionInfo               ScriptProperty System.Object VersionInfo {get=[System.Diagnostics.FileVersionInfo]::GetVersionInfo($this.... 

Man erhält alle Eigenschaften (Property) und Methoden (Method). Die Werte der Eigenschaften erhält man mit

$FileInfo | Select-Object -Property * 

Mode              : -a----
VersionInfo       : File:             s:\desktop\test\D15A0663.JPG
                    InternalName:
                    OriginalFilename:
                    FileVersion:
                    FileDescription:
                    Product:
                    ProductVersion:
                    Debug:            False
                    Patched:          False
                    PreRelease:       False
                    PrivateBuild:     False
                    SpecialBuild:     False
                    Language:

BaseName          : D15A0663
Target            : {}
LinkType          :
Name              : D15A0663.JPG
Length            : 6035123
DirectoryName     : s:\desktop\test
Directory         : s:\desktop\test
IsReadOnly        : False
Exists            : True
FullName          : s:\desktop\test\D15A0663.JPG
Extension         : .JPG
CreationTime      : 25.07.2019 23:05:49
CreationTimeUtc   : 25.07.2019 21:05:49
LastAccessTime    : 25.07.2019 23:05:49
LastAccessTimeUtc : 25.07.2019 21:05:49
LastWriteTime     : 22.07.2019 19:41:54
LastWriteTimeUtc  : 22.07.2019 17:41:54
Attributes        : Archive

Benötigt man nur eine bestimmte Eigenschaft (Beispiel Länge), schreibt man

$FileInfo | Select-Object -Property Length
 Length
 ------
6035123

Wenn die Länge der Datei als Variable in einem Programm weiterverwendet werden soll:

$Length = $FileInfo.Length
$Length
6035123

Eigenschaften des Objekts Bitmap

Für das Dateisystem sind alle Dateien gleich und es weiß daher nur allgemeine administrative Daten über sie. Für Bilder gibt es die spezialisierte Klasse Bitmap.

Man wendet diese Klasse ganz ähnlich an wie beim Dateisystem, nur der Name ist halt verschieden. Die Zeile Add-Type macht die Assembly System.Drawing bekannt, denn anders als die Assembly System.IO des Dateisystems werden die Bilder-Klassen nicht bei Start von Powershell geladen.

Add-type -AssemblyName System.Drawing 
$Image = [System.Drawing.Bitmap]::new($ImagePath)
$Image | Get-Member

  TypeName: System.Drawing.Bitmap

Name                      MemberType Definition
----                      ---------- ----------
Clone                     Method     System.Drawing.Bitmap Clone(System.Drawing.Rectangle rect, System.Drawing.Imaging.PixelFormat ... 
CreateObjRef              Method     System.Runtime.Remoting.ObjRef CreateObjRef(type requestedType)
Dispose                   Method     void Dispose(), void IDisposable.Dispose()
Equals                    Method     bool Equals(System.Object obj)
GetBounds                 Method     System.Drawing.RectangleF GetBounds([ref] System.Drawing.GraphicsUnit pageUnit)
GetEncoderParameterList   Method     System.Drawing.Imaging.EncoderParameters GetEncoderParameterList(guid encoder)
GetFrameCount             Method     int GetFrameCount(System.Drawing.Imaging.FrameDimension dimension)
GetHashCode               Method     int GetHashCode()
GetHbitmap                Method     System.IntPtr GetHbitmap(), System.IntPtr GetHbitmap(System.Drawing.Color background)
GetHicon                  Method     System.IntPtr GetHicon()
GetLifetimeService        Method     System.Object GetLifetimeService()
GetObjectData             Method     void ISerializable.GetObjectData(System.Runtime.Serialization.SerializationInfo info, System.R... 
GetPixel                  Method     System.Drawing.Color GetPixel(int x, int y)
GetPropertyItem           Method     System.Drawing.Imaging.PropertyItem GetPropertyItem(int propid)
GetThumbnailImage         Method     System.Drawing.Image GetThumbnailImage(int thumbWidth, int thumbHeight, System.Drawing.Image+G... 
GetType                   Method     type GetType()
InitializeLifetimeService Method     System.Object InitializeLifetimeService()
LockBits                  Method     System.Drawing.Imaging.BitmapData LockBits(System.Drawing.Rectangle rect, System.Drawing.Imagi... 
MakeTransparent           Method     void MakeTransparent(), void MakeTransparent(System.Drawing.Color transparentColor)
RemovePropertyItem        Method     void RemovePropertyItem(int propid)
RotateFlip                Method     void RotateFlip(System.Drawing.RotateFlipType rotateFlipType)
Save                      Method     void Save(string filename), void Save(string filename, System.Drawing.Imaging.ImageFormat form... 
SaveAdd                   Method     void SaveAdd(System.Drawing.Imaging.EncoderParameters encoderParams), void SaveAdd(System.Draw...
SelectActiveFrame         Method     int SelectActiveFrame(System.Drawing.Imaging.FrameDimension dimension, int frameIndex)
SetPixel                  Method     void SetPixel(int x, int y, System.Drawing.Color color)
SetPropertyItem           Method     void SetPropertyItem(System.Drawing.Imaging.PropertyItem propitem)
SetResolution             Method     void SetResolution(float xDpi, float yDpi)
ToString                  Method     string ToString()
UnlockBits                Method     void UnlockBits(System.Drawing.Imaging.BitmapData bitmapdata)
Flags                     Property   int Flags {get;}
FrameDimensionsList       Property   guid[] FrameDimensionsList {get;}
Height                    Property   int Height {get;}
HorizontalResolution      Property   float HorizontalResolution {get;}
Palette                   Property   System.Drawing.Imaging.ColorPalette Palette {get;set;}
PhysicalDimension         Property   System.Drawing.SizeF PhysicalDimension {get;}
PixelFormat               Property   System.Drawing.Imaging.PixelFormat PixelFormat {get;}
PropertyIdList            Property   int[] PropertyIdList {get;}
PropertyItems             Property   System.Drawing.Imaging.PropertyItem[] PropertyItems {get;}
RawFormat                 Property   System.Drawing.Imaging.ImageFormat RawFormat {get;}
Size                      Property   System.Drawing.Size Size {get;}
Tag                       Property   System.Object Tag {get;set;}
VerticalResolution        Property   float VerticalResolution {get;}
Width                     Property   int Width {get;}

Wieder erhält man eine Übersicht über alle Methoden und Eigenschaften und die Werte der Eigenschaften erhalten wir wie vorher:

$Image | Select-Object -Property *  

Tag                  :
PhysicalDimension    : {Width=5472, Height=3648}
Size                 : {Width=5472, Height=3648}
Width                : 5472
Height               : 3648
HorizontalResolution : 72
VerticalResolution   : 72
Flags                : 77840
RawFormat            : [ImageFormat: b96b3cae-0728-11d3-9d7b-0000f81ef32e]
PixelFormat          : Format24bppRgb
Palette              : System.Drawing.Imaging.ColorPalette
FrameDimensionsList  : {7462dc86-6180-4c7e-8e3f-ee7333a7a483}
PropertyIdList       : {271, 272, 282, 283...}
PropertyItems        : {271, 272, 282, 283...}

Man erfährt Länge und Breite des Bildes, das ist schon ein Teil der Fragestellung. Um die Bildhöhe allein auszugeben, schreibt man

"Höhe:" + $Image.Height 
Höhe:3648

Um einen bestimmten Index abzufragen schreibt man:

Die hier dargestellten Daten sind offenbar jene, die man zu Bearbeitung in Windows benötigt. Alle weitergehenden Daten sieht man nicht explizit. Sie befinden sich in der Eigenschaft PropertyItems. PropertyItems ist ein Array von Arrays, die alle über einen Index abrufbar sind. Die Liste dieser Indizes befindet sich in PropertyIdList. Die Werte eines bestimmten Index bestimmt man ganz einfach:

$Image.PropertyIdList[0]
271

$Image.PropertyItems[0]

 Id Len Type Value
 -- --- ---- -----
271   6    2 {67, 97, 110, 111...}

Die Id ist eine Wiederholung der Id aus PopertyIdList, Len ist die Anzahl der Stellen im Feld Value, Type ist der Datentyp in Value und Value ist ein Byte-Array (byte[]).

Die erste Frage ist die Bedeutung des Type-Feldes. Wenn man meint, dass in der zugehörigen Microsoft-Dokumentation diese Typen aufgezählt und erklärt sind, dann ist man auf dem Holzweg. Man behilft sich mit Fundstellen im Internet.

TypeDescription
1A Byte object
2An array of Byte object encoded as ASCII
3A 16-bit integer
4A 32-bit integer
5An array of two Byte objects that represent a rational number
6Not used
7Undefined
8Not used
9Slong
10Srational

Wie gut die Werte in dieser Tabelle ermittelt wurden, kann man daran ablesen, dass die jetzt ins Spiel kommenden EXIF-Ids und deren Bedeutung ebenfalls einen Typ enthalten. Aber diese beiden Typen stimmen leider nicht immer überein.

Das Auslesen der Bilddimensionen wäre also mit diesem Programm bereits erledigt, doch wollte man auch etwas über das Aufnahmedatum und die Geo-Koordinaten wissen, doch davon zeigen die Eigenschaften nichts, wenigstens nicht explizit. Es gibt einfache Eigenschaften wie Width und Height aber auch zusammengesetzte Eigenschaften wie Size, PropertyIdList und PropertyItems. Und genau in den beiden letzteren verbergen sich die gewünschten Angaben. Es wieder so ähnlich wie bei den Dateieigenschaften, dass es davon eine nicht klar definierte Anzahl gibt. Aber im Falle der EXIF-Daten gibt es sehr aufschlussreiche Verzeichnisse, die eine möglichst lückenlose Landkarte dieser Eigenschaften beschreiben.

Die PropertyIdList enthält alle in diesem Bild definierten EXIF-Ids. Das sind ganze Zahlen im Bereich 0…65635. Von den 65536 Positionen sind 475 definiert und für jede definierte Position ist auch deren Bedeutung bekannt. Es gibt bei einigen Ids noch viele weitergehende Informationen, die dann vom Hersteller und oft auch vom Kameratyp abhängen. In der oben gezeigten Ausgabe sieht man, dass die Ids 271, 272, 282, 283… definiert sind und dass danach noch viele weitere folgen.

Wie kann man also alle diese Kameradaten aus dem Objekt herausholen und – vor allem – was bedeuten diese Zahlen?

Welche Ids sind definiert?

$Image.PropertyIdList | ForEach-Object { Write-Host "$id " -NoNewline } 

Diese Zeile gibt alle Ids der Eigenschaft PropertyIdList des Bildobjekts $Image aus.

271 272 282 283 296 305 306 315 531 33432 33434 33437 34850 34855 34864 34866 36864 36867 36868 37121 37377 37378 37380 37383 37385 37386 37500 37510 37520 37521 37522 40960 40961 40962 40963 20545 20546 4097 4098 41486 41487 41488 41985 41986 41987 41990 42016 42032 42033 42034 42036 42037 0 1 2 3 4 5 20507 20515 20525 20526 20528 513 514 20625 20624

Unser Bild verfügt über 67 EXIF-Einträge. Die Ids sind nicht geordnet, und das ist etwas unübersichtlich. Mit Beteiligung des Sort-Object wird die Ausgabe übersichtlicher:

$Image.PropertyIdList | Sort-Object | ForEach-Object { Write-Host "$_ " -NoNewLine}
0 1 2 3 4 5 271 272 282 283 296 305 306 315 513 514 531 4097 4098 20507 20515 20525 20526 20528 20545 20546 20624 20625 33432 33434 33437 34850 34855 34864 34866 36864 36867 36868 37121 37377 37378 37380 37383 37385 37386 37500 37510 37520 37521 37522 40960 40961 40962 40963 41486 41487 41488 41985 41986 41987 41990 42016 42032 42033 42034 42036 42037 

Jede dieser Zahlen ist ein Index aus den EXIF-Daten.

Jetzt lassen wir und die zur PropIdList gehörigen Werte ausgeben – aber gleich sortiert. Hier muss man beachten, dass es sich um ein Array handelt, und man muss dem Sort-Object mitteilen, nach welcher Spalte sortiert werden soll.

$Image.PropertyItems | Sort-Object -Property Id 

   Id  Len Type Value
   --  --- ---- -----
    0    4    1 {2, 2, 0, 0}
    1    2    2 {78, 0}
    2   24    5 {48, 0, 0, 0...}
    3    2    2 {69, 0}
    4   24    5 {16, 0, 0, 0...}
    5    1    1 {0}
  271    6    2 {67, 97, 110, 111...}
  272   21    2 {67, 97, 110, 111...}
  282    8    5 {72, 0, 0, 0...}
  283    8    5 {72, 0, 0, 0...}
  296    2    3 {2, 0}
  305    7    2 {80, 105, 99, 97...}
  306   20    2 {50, 48, 49, 57...}    
  315    7    2 {80, 105, 99, 97...}
  513    4    4 {142, 40, 0, 0}
  514    4    4 {191, 21, 0, 0}
  531    2    3 {2, 0}
 4097    4    4 {96, 21, 0, 0}
 4098    4    4 {64, 14, 0, 0}
20507 5567    1 {255, 216, 255, 224...}
20515    2    3 {6, 0}
20525    8    5 {72, 0, 0, 0...}
20526    8    5 {72, 0, 0, 0...}
20528    2    3 {2, 0}
20545    4    2 {82, 57, 56, 0}
20546    4    7 {48, 49, 48, 48}       
20624  128    3 {1, 0, 1, 0...}
20625  128    3 {1, 0, 1, 0...}
33432    1    2 {0}
33434    8    5 {1, 0, 0, 0...}
33437    8    5 {56, 0, 0, 0...}
34850    2    3 {2, 0}
34855    2    3 {160, 0}
34864    2    3 {2, 0}
34866    4    4 {160, 0, 0, 0}
36864    4    7 {48, 50, 51, 48}
36867   20    2 {50, 48, 49, 57...}
36868   20    2 {50, 48, 49, 57...}
37121    4    7 {1, 2, 3, 0}
37377    8   10 {0, 160, 7, 0...}      
37378    8    5 {0, 0, 5, 0...}
37380    8   10 {0, 0, 0, 0...}
37383    2    3 {5, 0}
37385    2    3 {16, 0}
37386    8    5 {124, 0, 0, 0...}
42032    1    2 {0}
42033   13    2 {48, 54, 51, 48...}
42034   32    5 {16, 0, 0, 0...}
42036   44    2 {84, 65, 77, 82...}
42037   11    2 {48, 48, 48, 48...}

Was bedeuten diese Indexzahlen und wie geht man mit deren Werten, die ja offenbar – je nach Typ – immer etwas anderes bedeuten?

Verzeichnis der EXIF-Indizes

Phil Harvey lüftet in seinem EXIF-Tool auf der Seite der EXIF-Tags die Bedeutung der Ids und wir nutzen seine Erkenntnisse, um den nichtssagenden Zahlen die richtige Bedeutung zu geben.

Aus der Liste aus Phils Webseite wurde die Tabelle in ein Excel-Sheet kopiert, die Erklärungsspalte gelöscht, ebenso alle Zeilen, die nicht mit einer Id beginnen und danach als Datei exif.csv gespeichert. Die erste Spalte der .csv-Datei ist die Id im Hex-Format und die zweite Spalte ist die Erklärung dazu. Man erhält eine Datei mit 475 Zeilen. Diese Excel-Tabelle befindet sich im ZIP-Archiv zu diesem Beitrag.

Tabelle der EXIF-Daten

Aus dieser Tabelle wurde eine CSV-Tabelle gebildet. Die ersten Zeilen sind:

0x0001;InteropIndex;string!;InteropIFD;;
0x0002;InteropVersion;undef!:;InteropIFD;;
0x000b;ProcessingSoftware;string;IFD0;;
0x00fe;SubfileType;int32u!;IFD0;;
0x00ff;OldSubfileType;int16u!;IFD0;;
0x0100;ImageWidth;int32u!;IFD0;;
0x0101;ImageHeight;int32u!;IFD0;;
0x0102;BitsPerSample;int16u[n]!;IFD0;;
0x0103;Compression;int16u!:;IFD0;;
0x0106;PhotometricInterpretation;int16u!;IFD0;;
0x0107;Thresholding;int16u!;IFD0;;
0x0108;CellWidth;int16u!;IFD0;;
0x0109;CellLength;int16u!;IFD0;;
0x010a;FillOrder;int16u!;IFD0;;
0x010d;DocumentName;string;IFD0;;
0x010e;ImageDescription;string;IFD0;;
0x010f;Make;string;IFD0;;
0x0110;Model;string;IFD0;;
0x0111;StripOffsets ;no;-;;
0x0112;Orientation;int16u;IFD0;;
0x0115;SamplesPerPixel;int16u!;IFD0;;
0x0116;RowsPerStrip;int32u!;IFD0;;
0x0117;StripByteCounts ;no;-;;
0x0118;MinSampleValue;int16u;IFD0;;
0x0119;MaxSampleValue;int16u;IFD0;;
0x011a;XResolution;rational64u:;IFD0;;
0x011b;YResolution;rational64u:;IFD0;;
0x011c;PlanarConfiguration;int16u!;IFD0;;
0x011d;PageName;string;IFD0;;
0x011e;XPosition;rational64u;IFD0;;
0x011f;YPosition;rational64u;IFD0;;
0x0120;FreeOffsets;no;-;;
0x0121;FreeByteCounts;no;-;;
0x0122;GrayResponseUnit;int16u;IFD0;;
0x0123;GrayResponseCurve;no;-;;
0x0124;T4Options;no;-;;
0x0125;T6Options;no;-;;
0x0128;ResolutionUnit;int16u:;IFD0;;
0x0129;PageNumber;int16u[2];IFD0;;
0x012c;ColorResponseUnit;no;-;;
0x012d;TransferFunction;int16u[768]!;IFD0;;
0x0131;Software;string;IFD0;;
0x0132;ModifyDate;string;IFD0;;
0x013b;Artist;string;IFD0;;
0x013c;HostComputer;string;IFD0;;
0x013d;Predictor;int16u!;IFD0;;
0x013e;WhitePoint;rational64u[2];IFD0;;
0x013f;PrimaryChromaticities;rational64u[6];IFD0;;
0x0140;ColorMap;no;-;;
0x0141;HalftoneHints;int16u[2];IFD0;;
0x0142;TileWidth;int32u!;IFD0;;
0x0143;TileLength;int32u!;IFD0;;
0x0144;TileOffsets;no;-;;
0x0145;TileByteCounts;no;-;;
0x0146;BadFaxLines;no;-;;
0x0147;CleanFaxData;no;-;;
0x0148;ConsecutiveBadFaxLines;no;-;;
0x014a;SubIFD ;-;-;;
0x014c;InkSet;int16u;IFD0;;
0x014d;InkNames;no;-;;
0x014e;NumberofInks;no;-;;
0x0150;DotRange;no;-;;
0x0151;TargetPrinter;string;IFD0;;
0x0152;ExtraSamples;no;-;;
0x0153;SampleFormat;no;SubIFD;;
0x0154;SMinSampleValue;no;-;;
0x0155;SMaxSampleValue;no;-;;
0x0156;TransferRange;no;-;;
0x0157;ClipPath;no;-;;
0x0158;XClipPathUnits;no;-;;
0x0159;YClipPathUnits;no;-;;
0x015a;Indexed;no;-;;
0x015b;JPEGTables;no;-;;
0x015f;OPIProxy;no;-;;
0x0190;GlobalParametersIFD;-;-;;
0x0191;ProfileType;no;-;;
0x0192;FaxProfile;no;-;;
0x0193;CodingMethods;no;-;;
0x0194;VersionYear;no;-;;
0x0195;ModeNumber;no;-;;
0x01b1;Decode;no;-;;
0x01b2;DefaultImageColor;no;-;;
0x01b3;T82Options;no;-;;
0x01b5;JPEGTables;no;-;;
0x0200;JPEGProc;no;-;;
0x0201;ThumbnailOffset ;int32u*;IFD1;;
0x0202;ThumbnailLength ;int32u*;IFD1;;
0x0203;JPEGRestartInterval;no;-;;
0x0205;JPEGLosslessPredictors;no;-;;
0x0206;JPEGPointTransforms;no;-;;
0x0207;JPEGQTables;no;-;;
0x0208;JPEGDCTables;no;-;;
0x0209;JPEGACTables;no;-;;
0x0211;YCbCrCoefficients;rational64u[3]!;IFD0;;
0x0212;YCbCrSubSampling;int16u[2]!;IFD0;  ;'2 2' = YCbCr4:2:0 (2 2) 
0x0213;YCbCrPositioning;int16u!:;IFD0;;
0x0214;ReferenceBlackWhite;rational64u[6];IFD0;;
0x022f;StripRowCounts;no;-;;
0x02bc;ApplicationNotes;int8u!;IFD0;;
0x0320;Image Title;;;;
0x03e7;USPTOMiscellaneous;no;-;;
0x1000;RelatedImageFileFormat;string!;InteropIFD;;
0x1001;RelatedImageWidth;int16u!;InteropIFD;;
0x1002;RelatedImageHeight;int16u!;InteropIFD;;
0x4746;Rating;int16u/;IFD0;;
0x4747;XP_DIP_XML;no;-;;
0x4748;StitchInfo;-;-;;
0x4749;RatingPercent;int16u/;IFD0;;
0x5090;Luminance Table;;;;
0x5091;Chrominance Table;;;;
0x7000;SonyRawFileType;no;-;;
0x7010;SonyToneCurve;no;-;;
0x7031;VignettingCorrection;int16s!;SubIFD;;
0x7032;VignettingCorrParams;int16s[17]!;SubIFD;;
0x7034;ChromaticAberrationCorrection;int16s!;SubIFD;;
0x7035;ChromaticAberrationCorrParams;int16s[33]!;SubIFD;;
0x7036;DistortionCorrection;int16s!;SubIFD;;
0x7037;DistortionCorrParams;int16s[17]!;SubIFD;;
0x74c7;SonyCropTopLeft;int32u[2]!;SubIFD;;
0x74c8;SonyCropSize;int32u[2]!;SubIFD;;
0x800d;ImageID;no;-;;
0x80a3;WangTag1;no;-;;
0x80a4;WangAnnotation;no;-;;
0x80a5;WangTag3;no;-;;
0x80a6;WangTag4;no;-;;
0x80b9;ImageReferencePoints;no;-;;
0x80ba;RegionXformTackPoint;no;-;;
0x80bb;WarpQuadrilateral;no;-;;
0x80bc;AffineTransformMat;no;-;;
0x80e3;Matteing;no;-;;
0x80e4;DataType;no;-;;
0x80e5;ImageDepth;no;-;;
0x80e6;TileDepth;no;-;;
0x8214;ImageFullWidth;no;-;;
0x8215;ImageFullHeight;no;-;;
0x8216;TextureFormat;no;-;;
0x8217;WrapModes;no;-;;
0x8218;FovCot;no;-;;
0x8219;MatrixWorldToScreen;no;-;;
0x821a;MatrixWorldToCamera;no;-;;
0x827d;Model2;no;-;;
0x828d;CFARepeatPatternDim;int16u[2]!;SubIFD;;
0x828e;CFAPattern2;int8u[n]!;SubIFD;;
0x828f;BatteryLevel;no;-;;
0x8290;KodakIFD;-;-;;
0x8298;Copyright;string;IFD0;;
0x829a;ExposureTime;rational64u;ExifIFD;;
0x829d;FNumber;rational64u;ExifIFD;;
0x82a5;MDFileTag;no;-;;
0x82a6;MDScalePixel;no;-;;
0x82a7;MDColorTable;no;-;;
0x82a8;MDLabName;no;-;;
0x82a9;MDSampleInfo;no;-;;
0x82aa;MDPrepDate;no;-;;
0x82ab;MDPrepTime;no;-;;
0x82ac;MDFileUnits;no;-;;
0x830e;PixelScale;double[3];IFD0;;
0x8335;AdventScale;no;-;;
0x8336;AdventRevision;no;-;;
0x835c;UIC1Tag;no;-;;
0x835d;UIC2Tag;no;-;;
0x835e;UIC3Tag;no;-;;
0x835f;UIC4Tag;no;-;;
0x83bb;IPTC-NAA;int32u!;IFD0;;
0x847e;IntergraphPacketData;no;-;;
0x847f;IntergraphFlagRegisters;no;-;;
0x8480;IntergraphMatrix;double[n];IFD0;;
0x8481;INGRReserved;no;-;;
0x8482;ModelTiePoint;double[n];IFD0;;
0x84e0;Site;no;-;;
0x84e1;ColorSequence;no;-;;
0x84e2;IT8Header;no;-;;
0x84e3;RasterPadding;no;-;;
0x84e4;BitsPerRunLength;no;-;;
0x84e5;BitsPerExtendedRunLength;no;-;;
0x84e6;ColorTable;no;-;;
0x84e7;ImageColorIndicator;no;-;;
0x84e8;BackgroundColorIndicator;no;-;;
0x84e9;ImageColorValue;no;-;;
0x84ea;BackgroundColorValue;no;-;;
0x84eb;PixelIntensityRange;no;-;;
0x84ec;TransparencyIndicator;no;-;;
0x84ed;ColorCharacterization;no;-;;
0x84ee;HCUsage;no;-;;
0x84ef;TrapIndicator;no;-;;
0x84f0;CMYKEquivalent;no;-;;
0x8546;SEMInfo;string;IFD0;;
0x8568;AFCP_IPTC;-;-;;
0x85b8;PixelMagicJBIGOptions;no;-;;
0x85d7;JPLCartoIFD;no;-;;
0x85d8;ModelTransform;double[16];IFD0;;
0x8602;WB_GRGBLevels;no;-;;
0x8606;LeafData;-;-;;
0x8649;PhotoshopSettings;-;IFD0;;
0x8769;ExifOffset;-;IFD0;;
0x8773;ICC_Profile;-;IFD0;;
0x877f;TIFF_FXExtensions;no;-;;
0x8780;MultiProfiles;no;-;;
0x8781;SharedData;no;-;;
0x8782;T88Options;no;-;;
0x87ac;ImageLayer;no;-;;
0x87af;GeoTiffDirectory;undef;IFD0;;
0x87b0;GeoTiffDoubleParams;undef;IFD0;;
0x87b1;GeoTiffAsciiParams;string;IFD0;;
0x87be;JBIGOptions;no;-;;
0x8822;ExposureProgram;int16u;ExifIFD;;
0x8824;SpectralSensitivity;string;ExifIFD;;
0x8825;GPSInfo;-;IFD0;;
0x8827;ISO;int16u[n];ExifIFD;;
0x8828;Opto-ElectricConvFactor;no;-;;
0x8829;Interlace;no;-;;
0x882a;TimeZoneOffset;int16s[n];ExifIFD;;
0x882b;SelfTimerMode;int16u;ExifIFD;;
0x8830;SensitivityType;int16u;ExifIFD;;
0x8831;StandardOutputSensitivity;int32u;ExifIFD;;
0x8832;RecommendedExposureIndex;int32u;ExifIFD;;
0x8833;ISOSpeed;int32u;ExifIFD;;
0x8834;ISOSpeedLatitudeyyy;int32u;ExifIFD;;
0x8835;ISOSpeedLatitudezzz;int32u;ExifIFD;;
0x885c;FaxRecvParams;no;-;;
0x885d;FaxSubAddress;no;-;;
0x885e;FaxRecvTime;no;-;;
0x8871;FedexEDR;no;-;;
0x888a;LeafSubIFD;-;-;;
0x9000;ExifVersion;undef:;ExifIFD;;
0x9003;DateTimeOriginal;string;ExifIFD;;
0x9004;CreateDate;string;ExifIFD;;
0x9009;GooglePlusUploadCode;undef[n];ExifIFD;;
0x9010;OffsetTime;string;ExifIFD;;
0x9011;OffsetTimeOriginal;string;ExifIFD;;
0x9012;OffsetTimeDigitized;string;ExifIFD;;
0x9101;ComponentsConfiguration;undef[4]!:;ExifIFD;  ;4 = R 
0x9102;CompressedBitsPerPixel;rational64u!;ExifIFD;;
0x9201;ShutterSpeedValue;rational64s;ExifIFD;;
0x9202;ApertureValue;rational64u;ExifIFD;;
0x9203;BrightnessValue;rational64s;ExifIFD;;
0x9204;ExposureCompensation;rational64s;ExifIFD;;
0x9205;MaxApertureValue;rational64u;ExifIFD;;
0x9206;SubjectDistance;rational64u;ExifIFD;;
0x9207;MeteringMode;int16u;ExifIFD;;
0x9208;LightSource;int16u;ExifIFD;;
0x9209;Flash;int16u;ExifIFD;;
0x920a;FocalLength;rational64u;ExifIFD;;
0x920b;FlashEnergy;no;-;;
0x920c;SpatialFrequencyResponse;no;-;;
0x920d;Noise;no;-;;
0x920e;FocalPlaneXResolution;no;-;;
0x920f;FocalPlaneYResolution;no;-;;
0x9210;FocalPlaneResolutionUnit;no;-;;
0x9211;ImageNumber;int32u;ExifIFD;;
0x9212;SecurityClassification;string;ExifIFD;;
0x9213;ImageHistory;string;ExifIFD;;
0x9214;SubjectArea;int16u[n];ExifIFD;;
0x9215;ExposureIndex;no;-;;
0x9216;TIFF-EPStandardID;no;-;;
0x9217;SensingMethod;no;-;;
0x923a;CIP3DataFile;no;-;;
0x923b;CIP3Sheet;no;-;;
0x923c;CIP3Side;no;-;;
0x923f;StoNits;no;-;;
0x927c;MakerNoteApple ;undef;ExifIFD;;
0x9286;UserComment;undef;ExifIFD;;
0x9290;SubSecTime;string;ExifIFD;;
0x9291;SubSecTimeOriginal;string;ExifIFD;;
0x9292;SubSecTimeDigitized;string;ExifIFD;;
0x932f;MSDocumentText;no;-;;
0x9330;MSPropertySetStorage;no;-;;
0x9331;MSDocumentTextPosition;no;-;;
0x935c;ImageSourceData;undef!;IFD0;;
0x9400;AmbientTemperature;rational64s;ExifIFD;;
0x9401;Humidity;rational64u;ExifIFD;;
0x9402;Pressure;rational64u;ExifIFD;;
0x9403;WaterDepth;rational64s;ExifIFD;;
0x9404;Acceleration;rational64u;ExifIFD;;
0x9405;CameraElevationAngle;rational64s;ExifIFD;;
0x9c9b;XPTitle;int8u;IFD0;;
0x9c9c;XPComment;int8u;IFD0;;
0x9c9d;XPAuthor;int8u;IFD0;;
0x9c9e;XPKeywords;int8u;IFD0;;
0x9c9f;XPSubject;int8u;IFD0;;
0xa000;FlashpixVersion;undef:;ExifIFD;;
0xa001;ColorSpace;int16u:;ExifIFD;;
0xa002;ExifImageWidth;int16u:;ExifIFD;;
0xa003;ExifImageHeight;int16u:;ExifIFD;;
0xa004;RelatedSoundFile;string;ExifIFD;;
0xa005;InteropOffset;-;-;;
0xa010;SamsungRawPointersOffset;no;-;;
0xa011;SamsungRawPointersLength;no;-;;
0xa101;SamsungRawByteOrder;no;-;;
0xa102;SamsungRawUnknown?;no;-;;
0xa20b;FlashEnergy;rational64u;ExifIFD;;
0xa20c;SpatialFrequencyResponse;no;-;;
0xa20d;Noise;no;-;;
0xa20e;FocalPlaneXResolution;rational64u;ExifIFD;;
0xa20f;FocalPlaneYResolution;rational64u;ExifIFD;;
0xa210;FocalPlaneResolutionUnit;int16u;ExifIFD;;
0xa211;ImageNumber;no;-;;
0xa212;SecurityClassification;no;-;;
0xa213;ImageHistory;no;-;;
0xa214;SubjectLocation;int16u[2];ExifIFD;;
0xa215;ExposureIndex;rational64u;ExifIFD;;
0xa216;TIFF-EPStandardID;no;-;;
0xa217;SensingMethod;int16u;ExifIFD;;
0xa300;FileSource;undef;ExifIFD;;
0xa301;SceneType;undef;ExifIFD;;
0xa302;CFAPattern;undef;ExifIFD;;
0xa401;CustomRendered;int16u;ExifIFD;;
0xa402;ExposureMode;int16u;ExifIFD;;
0xa403;WhiteBalance;int16u;ExifIFD;;
0xa404;DigitalZoomRatio;rational64u;ExifIFD;;
0xa405;FocalLengthIn35mmFormat;int16u;ExifIFD;;
0xa406;SceneCaptureType;int16u;ExifIFD;;
0xa407;GainControl;int16u;ExifIFD;;
0xa408;Contrast;int16u;ExifIFD;;
0xa409;Saturation;int16u;ExifIFD;;
0xa40a;Sharpness;int16u;ExifIFD;;
0xa40b;DeviceSettingDescription;no;-;;
0xa40c;SubjectDistanceRange;int16u;ExifIFD;;
0xa420;ImageUniqueID;string;ExifIFD;;
0xa430;OwnerName;string;ExifIFD;;
0xa431;SerialNumber;string;ExifIFD;;
0xa432;LensInfo;rational64u[4];ExifIFD;;
0xa433;LensMake;string;ExifIFD;;
0xa434;LensModel;string;ExifIFD;;
0xa435;LensSerialNumber;string;ExifIFD;;
0xa460;CompositeImage;int16u;ExifIFD;;
0xa461;CompositeImageCount;int16u[2];ExifIFD;;
0xa462;CompositeImageExposureTimes;undef;ExifIFD;;
0xa480;GDALMetadata;string;IFD0;;
0xa481;GDALNoData;string;IFD0;;
0xa500;Gamma;rational64u;ExifIFD;;
0xafc0;ExpandSoftware;no;-;;
0xafc1;ExpandLens;no;-;;
0xafc2;ExpandFilm;no;-;;
0xafc3;ExpandFilterLens;no;-;;
0xafc4;ExpandScanner;no;-;;
0xafc5;ExpandFlashLamp;no;-;;
0xbc01;PixelFormat;no;-;;
0xbc02;Transformation;no;-;;
0xbc03;Uncompressed;no;-;;
0xbc04;ImageType;no;-;;
0xbc80;ImageWidth;no;-;;
0xbc81;ImageHeight;no;-;;
0xbc82;WidthResolution;no;-;;
0xbc83;HeightResolution;no;-;;
0xbcc0;ImageOffset;no;-;;
0xbcc1;ImageByteCount;no;-;;
0xbcc2;AlphaOffset;no;-;;
0xbcc3;AlphaByteCount;no;-;;
0xbcc4;ImageDataDiscard;no;-;;
0xbcc5;AlphaDataDiscard;no;-;;
0xc427;OceScanjobDesc;no;-;;
0xc428;OceApplicationSelector;no;-;;
0xc429;OceIDNumber;no;-;;
0xc42a;OceImageLogic;no;-;;
0xc44f;Annotations;no;-;;
0xc4a5;PrintIM;undef;IFD0;;
0xc573;OriginalFileName;no;-;;
0xc580;USPTOOriginalContentType;no;-;;
0xc5e0;CR2CFAPattern;no;-;;
0xc612;DNGVersion;int8u[4]!;IFD0;;
0xc613;DNGBackwardVersion;int8u[4]!;IFD0;;
0xc614;UniqueCameraModel;string;IFD0;;
0xc615;LocalizedCameraModel;string;IFD0;;
0xc616;CFAPlaneColor;no;SubIFD;;
0xc617;CFALayout;no;SubIFD;;
0xc618;LinearizationTable;int16u[n]!;SubIFD;;
0xc619;BlackLevelRepeatDim;int16u[2]!;SubIFD;;
0xc61a;BlackLevel;rational64u[n]!;SubIFD;;
0xc61b;BlackLevelDeltaH;rational64s[n]!;SubIFD;;
0xc61c;BlackLevelDeltaV;rational64s[n]!;SubIFD;;
0xc61d;WhiteLevel;int32u[n]!;SubIFD;;
0xc61e;DefaultScale;rational64u[2]!;SubIFD;;
0xc61f;DefaultCropOrigin;int32u[2]!;SubIFD;;
0xc620;DefaultCropSize;int32u[2]!;SubIFD;;
0xc621;ColorMatrix1;rational64s[n]!;IFD0;;
0xc622;ColorMatrix2;rational64s[n]!;IFD0;;
0xc623;CameraCalibration1;rational64s[n]!;IFD0;;
0xc624;CameraCalibration2;rational64s[n]!;IFD0;;
0xc625;ReductionMatrix1;rational64s[n]!;IFD0;;
0xc626;ReductionMatrix2;rational64s[n]!;IFD0;;
0xc627;AnalogBalance;rational64u[n]!;IFD0;;
0xc628;AsShotNeutral;rational64u[n]!;IFD0;;
0xc629;AsShotWhiteXY;rational64u[2]!;IFD0;;
0xc62a;BaselineExposure;rational64s!;IFD0;;
0xc62b;BaselineNoise;rational64u!;IFD0;;
0xc62c;BaselineSharpness;rational64u!;IFD0;;
0xc62d;BayerGreenSplit;int32u!;SubIFD;;
0xc62e;LinearResponseLimit;rational64u!;IFD0;;
0xc62f;CameraSerialNumber;string;IFD0;;
0xc630;DNGLensInfo;rational64u[4];IFD0;;
0xc631;ChromaBlurRadius;rational64u!;SubIFD;;
0xc632;AntiAliasStrength;rational64u!;SubIFD;;
0xc633;ShadowScale;rational64u!;IFD0;;
0xc634;SR2Private ;-;IFD0;;
0xc635;MakerNoteSafety;int16u;IFD0;;
0xc640;RawImageSegmentation;no;-;;
0xc65a;CalibrationIlluminant1;int16u!;IFD0;;
0xc65b;CalibrationIlluminant2;int16u!;IFD0;;
0xc65c;BestQualityScale;rational64u!;SubIFD;;
0xc65d;RawDataUniqueID;int8u[16]!;IFD0;;
0xc660;AliasLayerMetadata;no;-;;
0xc68b;OriginalRawFileName;string!;IFD0;;
0xc68c;OriginalRawFileData;undef!;IFD0;;
0xc68d;ActiveArea;int32u[4]!;SubIFD;;
0xc68e;MaskedAreas;int32u[n]!;SubIFD;;
0xc68f;AsShotICCProfile;undef!;IFD0;;
0xc690;AsShotPreProfileMatrix;rational64s[n]!;IFD0;;
0xc691;CurrentICCProfile;undef!;IFD0;;
0xc692;CurrentPreProfileMatrix;rational64s[n]!;IFD0;;
0xc6bf;ColorimetricReference;int16u!;IFD0;;
0xc6c5;SRawType;no;IFD0;;
0xc6d2;PanasonicTitle;undef;IFD0;;
0xc6d3;PanasonicTitle2;undef;IFD0;;
0xc6f3;CameraCalibrationSig;string!;IFD0;;
0xc6f4;ProfileCalibrationSig;string!;IFD0;;
0xc6f5;ProfileIFD;-;IFD0;;
0xc6f6;AsShotProfileName;string!;IFD0;;
0xc6f7;NoiseReductionApplied;rational64u!;SubIFD;;
0xc6f8;ProfileName;string!;IFD0;;
0xc6f9;ProfileHueSatMapDims;int32u[3]!;IFD0;;
0xc6fa;ProfileHueSatMapData1;float[n]!;IFD0;;
0xc6fb;ProfileHueSatMapData2;float[n]!;IFD0;;
0xc6fc;ProfileToneCurve;float[n]!;IFD0;;
0xc6fd;ProfileEmbedPolicy;int32u!;IFD0;;
0xc6fe;ProfileCopyright;string!;IFD0;;
0xc714;ForwardMatrix1;rational64s[n]!;IFD0;;
0xc715;ForwardMatrix2;rational64s[n]!;IFD0;;
0xc716;PreviewApplicationName;string!;IFD0;;
0xc717;PreviewApplicationVersion;string!;IFD0;;
0xc718;PreviewSettingsName;string!;IFD0;;
0xc719;PreviewSettingsDigest;int8u!;IFD0;;
0xc71a;PreviewColorSpace;int32u!;IFD0;;
0xc71b;PreviewDateTime;string!;IFD0;;
0xc71c;RawImageDigest;int8u[16]!;IFD0;;
0xc71d;OriginalRawFileDigest;int8u[16]!;IFD0;;
0xc71e;SubTileBlockSize;no;-;;
0xc71f;RowInterleaveFactor;no;-;;
0xc725;ProfileLookTableDims;int32u[3]!;IFD0;;
0xc726;ProfileLookTableData;float[n]!;IFD0;;
0xc740;OpcodeList1;undef!;SubIFD;;
0xc741;OpcodeList2;undef!;SubIFD;;
0xc74e;OpcodeList3;undef!;SubIFD;;
0xc761;NoiseProfile;double[n]!;SubIFD;;
0xc763;TimeCodes;int8u[n];IFD0;;
0xc764;FrameRate;rational64s;IFD0;;
0xc772;TStop;rational64u[n];IFD0;;
0xc789;ReelName;string;IFD0;;
0xc791;OriginalDefaultFinalSize;int32u[2]!;IFD0;;
0xc792;OriginalBestQualitySize;int32u[2]!;IFD0;;
0xc793;OriginalDefaultCropSize;rational64u[2]!;IFD0;;
0xc7a1;CameraLabel;string;IFD0;;
0xc7a3;ProfileHueSatMapEncoding;int32u!;IFD0;;
0xc7a4;ProfileLookTableEncoding;int32u!;IFD0;;
0xc7a5;BaselineExposureOffset;rational64s!;IFD0;;
0xc7a6;DefaultBlackRender;int32u!;IFD0;;
0xc7a7;NewRawImageDigest;int8u[16]!;IFD0;;
0xc7a8;RawToPreviewGain;double!;IFD0;;
0xc7aa;CacheVersion;int32u!;SubIFD2;;
0xc7b5;DefaultUserCrop;rational64u[4]!;SubIFD;;
0xc7d5;NikonNEFInfo;-;-;;
0xea1c;Padding;undef!;ExifIFD;;
0xea1d;OffsetSchema;int32s!;ExifIFD;;
0xfde8;OwnerName;string/;ExifIFD;;
0xfde9;SerialNumber;string/;ExifIFD;;
0xfdea;Lens;string/;ExifIFD;;
0xfe00;KDC_IFD;-;-;;
0xfe4c;RawFile;string/;ExifIFD;;
0xfe4d;Converter;string/;ExifIFD;;
0xfe4e;WhiteBalance;string/;ExifIFD;;
0xfe51;Exposure;string/;ExifIFD;;
0xfe52;Shadows;string/;ExifIFD;;
0xfe53;Brightness;string/;ExifIFD;;
0xfe54;Contrast;string/;ExifIFD;;
0xfe55;Saturation;string/;ExifIFD;;
0xfe56;Sharpness;string/;ExifIFD;;
0xfe57;Smoothness;string/;ExifIFD;;
0xfe58;MoireFilter;string/;ExifIFD;;

Beim Vergleich dieser ersten Zeilen mit den Ids, die das Bitmap-Objekt des Testbildes ausgibt, fällt ein Widerspruch auf, denn im Testbild werden die Ids 1,2,3,4,5, definiert, aber in der Liste der EXIF-Tags sind 3,4,5 nicht enthalten. Das Bild-Objekt liefert daher EXIF-Einträge, die in der Dokumentation nicht genannt sind. Umgekehrt gibt es auch sehr viele Exif-Indizes, die in den Eigenschaften des Bild-Objekt keine Entsprechung haben.

Da mein Interesse den Geo-Koordinaten galt, suchte ich nach Hinweisen zu diesen Daten. Das Feld, das auf diese Daten verweist hat den Index 0x8825. Das Problem: dieses Feld ist in den Kamera-Daten nicht definiert und daher bleiben die GPS-Daten verborgen, obwohl sie natürlich in irgendeinem der Felder unerkannt schlummern.

EXIF-Daten in Powershell einlesen

Um diese CSV-Datei in PowerShell bekannt zu machen, kann man sie mit dem Befehl Import-Csv importieren, allerdings nicht ohne Ergänzungen, denn man muss auch noch sagen, wie die Spalten heißen und welches das Trennzeichen ist. Das Kommando dazu lautet:

$exif = Import-Csv -Path s:\desktop\exif.csv -Header 'IDH','Title','Type','Comment' -Delimiter ';'

Man kann nun eine bestimmte EXIF-Eigenschaft oder ein bestimmtes Feld dieser Eigenschaft so abfragen:

PS C:\Users\franz> $exif[1] 
 IDH    Title          Type    Comment
 ---    -----          ----    -------   
 0x0002 InteropVersion undef!: InteropIFD

PS C:\Users\franz> $exif[13].Title
 FillOrder

Hex -> Dez

Eine Schwierigkeit ist, dass die EXIF-Eigenschaften im Hex-Format angegeben sind und man zum Ansprechen eine Dezimalzahl verwenden muss. Hier wurde das so gelöst, dass eine zusätzliche Spalte Id importiert wurde und Werte für diese Spalte aus den Werten der Spalte IDH berechnet wurden:

$exif = Import-Csv -Path s:\desktop\exif.csv -Header 'IDH','Title','Type','Comment' -Delimiter ";" | Select *,Id

$exif | ForEach { $_.Id = [Convert]::ToInt64($_.IDH,16) }

PS C:\Users\franz> $exif[13].IDH
 0x010a
PS C:\Users\franz> $exif[13].ID 
 266

Ausgabe der Bytefolgen

Alle eingetragenen Eigenschaften werden in Byte-Folgen übergeben. Diese Bytefolgen können sein: Strings, ganze Zahlen (16, 32 und 64 Bit) mit oder ohne Vorzeichen sowie Verhältnisse, die als zwei 32-Bit-Zahlen in einer 64-Bit-Zahl kodiert werden. Weiters gibt es Spezialformate für Farbpaletten und einfach auch unbekannte Formate.

Um für die wichtigsten EXIF-Vatiablen eine vernünftige Ausgabe zu erhalten, wurden vier Funktionen formuliert: GetString, GetNumber16, GetNumber32, GetRatio64.

Beispiel: GetNumber16

 function GetNumber16 { 
    Param ([byte[]]$b)
    return $b[0] + 256 * $b[1];
} 

Am Ende steht ein Programm, das zu einer gegebenen Bilddatei bekannt gibt, was alle diese Daten aus dem Dateisystem, dem Bild-Objekt und den EXIF-Daten im Bild-Objekt hergeben. Die Ausgabe erfolgt – was die EXIF-Daten anlangt – als CSV-Datei. Man kann daher die Ausgabe in ein Excel-Sheet kopieren und verschiedene Bilder oder Kameras miteinander vergleichen.

exif.ps1

#Ermittelt die EXIF-Parameter einer Datei
#========================================

Param ([string]$ImagePath = "s:\desktop\test\D15A0663.JPG") #"s:\desktop\test\IMG_20190602_160848.jpg") 

if (!([System.IO.File]::Exists($ImagePath))) { "Bild existiert nicht"; return }
$ImageTypes = ".jpg", ".jpeg", ".png", ".tif", ".bmp"
$Extension = [System.IO.Path]::GetExtension($ImagePath).ToLower()
if (!($ImageTypes.Contains($Extension))) { "Kein erlaubtes Format"; return }

$CRLF = [char]13 + [char]10
function GetRatio64 { 
	Param ([byte[]]$b)
	$First = $b[0] + 256 * $b[1] + 65536 * $b[2] + 16777216 * $b[3] 
	$Second = $b[4] + 256 * $b[5] + 65536 * $b[6] + 16777216 * $b[7]  
	
	if ($First -gt 2147483648) { $First = $First - 4294967296 } 
	if ($Second -gt 2147483648) { $Second = $Second - 4294967296 }  
	if ($Second -eq 0) { $Second = 1 }  
	
	if (($First -eq 1) -and ($Second -ne 1)) { return ("1/" + $Second) } 
	else { return ($First / $Second) }
}
function GetNumber16 { 
	Param ([byte[]]$b)
	return $b[0] + 256 * $b[1];
}
function GetNumber32 { 
	Param ([byte[]]$b)
	return $b[0] + 256 * $b[1] + 65536 * $b[2] + 16777216 * $b[3]
}
function GetString { 
	Param ([byte[]]$b)
	$s = ''
	for ($i = 0; $i -lt $b.Length; $i++) { $s += [char]$b[$i] }
	return $s
}
$s = "Eigenschaften des Bildes $ImagePath"
$s += $CRLF + "".PadLeft($s.Length, '=') + $CRLF + $CRLF
$s = $CRLF + $s
$s += "Eigenschaften der Datei$CRLF$CRLF"
$FileInfo = [System.IO.FileInfo]::new($ImagePath)
$s += "Name: " + $FileInfo.Name + $CRLF
$s += "Verzeichnisname: " + $FileInfo.DirectoryName + $CRLF
$s += "Vollständiger Name: " + $FileInfo.FullName + $CRLF
$s += "Erweiterung: " + $FileInfo.Extension + $CRLF
$s += "Nur Lesen: " + $FileInfo.IsReadOnly + $CRLF
$s += "Länge: " + $FileInfo.Length + $CRLF
$s += "Mode: " + $FileInfo.Mode + $CRLF
$s += "Attribute: " + $FileInfo.Attributes + $CRLF
$s += "CreationTime: " + $FileInfo.CreationTime + $CRLF
$s += "LastAccessTime: " + $FileInfo.LastAccessTime + $CRLF
$s += "LastWriteTime: " + $FileInfo.LastWriteTime + $CRLF
$s += "CreationTimeUtc: " + $FileInfo.CreationTimeUtc + $CRLF
$s += "LastAccessTimeUtc: " + $FileInfo.LastAccessTimeUtc + $CRLF
$s += "LastWriteTimeUtc: " + $FileInfo.LastWriteTimeUtc + $CRLF
$s += $CRLF

Add-type -AssemblyName System.Drawing 
$s += "Eigenschaften des Bitmap-Objekts$CRLF$CRLF"
$Image = [System.Drawing.Bitmap]::new($ImagePath)
$Items = $Image.PropertyItems | Sort-Object -Property Id 
$PropertyIdList_sort = $Image.PropertyIdList | Sort-Object
$PropertyIdListHex_sort = $PropertyIdList_sort | ForEach-Object { "0x" + [Convert]::ToString($_, 16) }
#https://www.c-sharpcorner.com/uploadfile/mahesh/reading-metadata-of-images-in-gdi/
$Types = "", "byte", "byte[]", "int16", "int32", "rational64", "unused", "undef", "unused", "long", "rational"

$s += "Tag: " + $Image.Tag + $CRLF
$s += "PhysicalDimension: " + $Image.PhysicalDimension + $CRLF
$s += "Size: " + $Image.Size + $CRLF
$s += "Width: " + $Image.Width + $CRLF
$s += "Height: " + $Image.Height + $CRLF
$s += "HorizontalResolution: " + $Image.HorizontalResolution + $CRLF
$s += "VerticalResolution: " + $Image.VerticalResolution + $CRLF
$s += "Flags: " + $Image.Flags + $CRLF
$s += "RawFormat: " + $Image.RawFormat + $CRLF
$s += "PixelFormat: " + $Image.PixelFormat + $CRLF
$s += "Palette: " + $Image.Palette + $CRLF
$s += "FrameDimensionsList: " + $Image.FrameDimensionsList + $CRLF
$s += "PropertyIdListCount: " + $Image.PropertyIdList.Length + $CRLF
$s += "PropertyIdList: " + $PropertyIdList_sort + $CRLF
$s += "PropertyIdListHex: " + $PropertyIdListHex_sort + $CRLF
$s += "PropertyItems: + $CRLF"
$s += "IdHex;Id;Type;TypeText;Length;Bytes;ExifName;ExifType;ExifValue" + $CRLF
$s += $CRLF
$s += "Eigenschaften der EXIF-Daten$CRLF$CRLF"
$ExifTable = Import-Csv -Path s:\desktop\exif\exif.csv -Header 'IDH', 'Title', 'Type', 'Comment' -Delimiter ";" | Select-Object *, Id
$ExifTable | ForEach-Object { $_.Id = [Convert]::ToInt64($_.IDH, 16) }
$ExifEntries = 0
$ExifEntriesNone = 0
foreach ($Item in $Items) { 
	$s1 = ''
	$s1 += "0x" + ([String][Convert]::ToString($Item.Id, 16)).PadLeft(4, '0') + ";" + [string]$Item.Id + ";" + [string]$Item.Type + ";" + $Types[$Item.Type] + ";" + [string]$Item.Len + ";" 
	for ($i = 0; $i -lt $Item.Len; $i++) {
		$s1 += [string]$Item.Value[$i] + " "
		if ($i -eq 10) { 
			if ($Item.Len -gt 10) {
				$s1 += "..."
				break 
			}
		}
	}
	$Id = $Item.Id
	$ExifItem = $ExifTable | Where-Object { $_.Id -eq $Id }
	$ExifName = $ExifItem.Title
	$ExifType = $ExifItem.Type
	if ($null -eq $ExifItem) {
		$ExifEntriesNone++
		$s1 += ";NOEXIF;;" 
		#switch ($Id) {
		#	20507 {
		#		$s1 += GetString $Item.Value
		#	}
		#	default {
		#	}
		#}
		$s1 += $CRLF 
	}
	else {
		$Value = $Item.Value
		switch -Wildcard ($ExifType) {
			'string*' { $s0 = GetString $Value }
			'int16*' { $s0 = GetNumber16 $Value } 
			'int32*' { $s0 = GetNumber32 $Value } 
			'rational64*' { $s0 = GetRatio64 $Value } 
			default { 
				$s0 = '' 
			}
		}
		$s1 += ";$ExifName;$ExifType;$s0$CRLF"
	}
	$s += $s1
	$ExifEntries++
}
$s
"EXIF-Einträge: $ExifEntries, None: $ExifEntriesNone"

 

exif.ps1 – Ausgabe

Die Ausgabe besteht aus drei Teilen:

  • Eigenschaften der Datei
  • Eigenschaften des Bitmap-Objekts
  • Eigenschaften der EXIF-Daten
Eigenschaften des Bildes s:\desktop\test\D15A0663.JPG
=====================================================

Eigenschaften der Datei

Name: D15A0663.JPG
Verzeichnisname: s:\desktop\test
Vollständiger Name: s:\desktop\test\D15A0663.JPG
Erweiterung: .JPG
Nur Lesen: False
Länge: 6035123
Mode: -a----
Attribute: Archive
CreationTime: 07/25/2019 23:05:49
LastAccessTime: 07/25/2019 23:05:49
LastWriteTime: 07/22/2019 19:41:54
CreationTimeUtc: 07/25/2019 21:05:49
LastAccessTimeUtc: 07/25/2019 21:05:49
LastWriteTimeUtc: 07/22/2019 17:41:54

Eigenschaften des Bitmap-Objekts

Tag:
PhysicalDimension: {Width=5472, Height=3648}
Size: {Width=5472, Height=3648}
Width: 5472
Height: 3648
HorizontalResolution: 72
VerticalResolution: 72
Flags: 77840
RawFormat: [ImageFormat: b96b3cae-0728-11d3-9d7b-0000f81ef32e]
PixelFormat: Format24bppRgb
Palette: System.Drawing.Imaging.ColorPalette
FrameDimensionsList: 7462dc86-6180-4c7e-8e3f-ee7333a7a483
PropertyIdListCount: 67
PropertyIdList: 0 1 2 3 4 5 271 272 282 283 296 305 306 315 513 514 531 4097 4098 20507 20515 20525 20526 20528 20545 20546 20624 20625 33432 33434 33437 34850 34855 34864 34866 36864 36867 36868 37121 37377 37378 37380 37383 37385 37386 37500 37510 37520 37521 37522 40960 40961 40962 40963 41486 41487 41488 41985 41986 41987 41990 42016 42032 42033 42034 42036 42037
PropertyIdListHex: 0x0 0x1 0x2 0x3 0x4 0x5 0x10f 0x110 0x11a 0x11b 0x128 0x131 0x132 0x13b 0x201 0x202 0x213 0x1001 0x1002 0x501b 0x5023 0x502d 0x502e 0x5030 0x5041 0x5042 0x5090 0x5091 0x8298 0x829a 0x829d 0x8822 0x8827 0x8830 0x8832 0x9000 0x9003 0x9004 0x9101 0x9201 
0x9202 0x9204 0x9207 0x9209 0x920a 0x927c 0x9286 0x9290 0x9291 0x9292 0xa000 0xa001 0xa002 0xa003 0xa20e 0xa20f 0xa210 0xa401 0xa402 0xa403 0xa406 0xa420 0xa430 0xa431 0xa432 0xa434 0xa435
Eigenschaften der EXIF-Daten
PropertyItems: 
IdHex;Id;Type;TypeText;Length;Bytes;ExifName;ExifType;ExifValue
0x0000;0;1;byte;4;2 2 0 0 ;NOEXIF;;
0x0001;1;2;byte[];2;78 0 ;InteropIndex;string!;N
0x0002;2;5;rational64;24;48 0 0 0 1 0 0 0 11 0 0 ...;InteropVersion;undef!:;
0x0003;3;2;byte[];2;69 0 ;NOEXIF;;
0x0004;4;5;rational64;24;16 0 0 0 1 0 0 0 19 0 0 ...;NOEXIF;;
0x0005;5;1;byte;1;0 ;NOEXIF;;
0x010f;271;2;byte[];6;67 97 110 111 110 0 ;Make;string;Canon
0x0110;272;2;byte[];21;67 97 110 111 110 32 69 79 83 32 55 ...;Model;string;Canon EOS 7D Mark II
0x011a;282;5;rational64;8;72 0 0 0 1 0 0 0 ;XResolution;rational64u:;72
0x011b;283;5;rational64;8;72 0 0 0 1 0 0 0 ;YResolution;rational64u:;72
0x0128;296;3;int16;2;2 0 ;ResolutionUnit;int16u:;2
0x0131;305;2;byte[];7;80 105 99 97 115 97 0 ;Software;string;Picasa
0x0132;306;2;byte[];20;50 48 49 57 58 48 55 58 50 50 32 ...;ModifyDate;string;2019:07:22 19:41:54
0x013b;315;2;byte[];7;80 105 99 97 115 97 0 ;Artist;string;Picasa
0x0201;513;4;int32;4;142 40 0 0 ;ThumbnailOffset ;int32u*;10382
0x0202;514;4;int32;4;191 21 0 0 ;ThumbnailLength ;int32u*;5567
0x0213;531;3;int16;2;2 0 ;YCbCrPositioning;int16u!:;2
0x1001;4097;4;int32;4;96 21 0 0 ;RelatedImageWidth;int16u!;5472
0x1002;4098;4;int32;4;64 14 0 0 ;RelatedImageHeight;int16u!;3648
0x501b;20507;1;byte;5567;255 216 255 224 0 16 74 70 73 70 0 ...;NOEXIF;;
0x5023;20515;3;int16;2;6 0 ;NOEXIF;;
0x502d;20525;5;rational64;8;72 0 0 0 1 0 0 0 ;NOEXIF;;
0x502e;20526;5;rational64;8;72 0 0 0 1 0 0 0 ;NOEXIF;;
0x5030;20528;3;int16;2;2 0 ;NOEXIF;;
0x5041;20545;2;byte[];4;82 57 56 0 ;NOEXIF;;
0x5042;20546;7;undef;4;48 49 48 48 ;NOEXIF;;
0x5090;20624;3;int16;128;1 0 1 0 1 0 1 0 1 0 2 ...;Luminance Table;;
0x5091;20625;3;int16;128;1 0 1 0 1 0 2 0 4 0 4 ...;Chrominance Table;;
0x8298;33432;2;byte[];1;0 ;Copyright;string;
0x829a;33434;5;rational64;8;1 0 0 0 200 0 0 0 ;ExposureTime;rational64u;1/200
0x829d;33437;5;rational64;8;56 0 0 0 10 0 0 0 ;FNumber;rational64u;5.6
0x8822;34850;3;int16;2;2 0 ;ExposureProgram;int16u;2
0x8827;34855;3;int16;2;160 0 ;ISO;int16u[n];160
0x8830;34864;3;int16;2;2 0 ;SensitivityType;int16u;2
0x8832;34866;4;int32;4;160 0 0 0 ;RecommendedExposureIndex;int32u;160
0x9000;36864;7;undef;4;48 50 51 48 ;ExifVersion;undef:;
0x9003;36867;2;byte[];20;50 48 49 57 58 48 55 58 50 50 32 ...;DateTimeOriginal;string;2019:07:22 15:35:08
0x9004;36868;2;byte[];20;50 48 49 57 58 48 55 58 50 50 32 ...;CreateDate;string;2019:07:22 15:35:08
0x9101;37121;7;undef;4;1 2 3 0 ;ComponentsConfiguration;undef[4]!:;
0x9201;37377;10;rational;8;0 160 7 0 0 0 1 0 ;ShutterSpeedValue;rational64s;7.625
0x9202;37378;5;rational64;8;0 0 5 0 0 0 1 0 ;ApertureValue;rational64u;5
0x9204;37380;10;rational;8;0 0 0 0 1 0 0 0 ;ExposureCompensation;rational64s;0
0x9207;37383;3;int16;2;5 0 ;MeteringMode;int16u;5
0x9209;37385;3;int16;2;16 0 ;Flash;int16u;16
0x920a;37386;5;rational64;8;124 0 0 0 1 0 0 0 ;FocalLength;rational64u;124
0x927c;37500;7;undef;8896;41 0 1 0 3 0 49 0 0 0 174 ...;MakerNoteApple ;undef;
0x9286;37510;7;undef;264;0 0 0 0 0 0 0 0 0 0 0 ...;UserComment;undef;
0x9290;37520;2;byte[];3;51 56 0 ;SubSecTime;string;38
0x9291;37521;2;byte[];3;51 56 0 ;SubSecTimeOriginal;string;38
0x9292;37522;2;byte[];3;51 56 0 ;SubSecTimeDigitized;string;38
0xa000;40960;7;undef;4;48 49 48 48 ;FlashpixVersion;undef:;
0xa001;40961;3;int16;2;1 0 ;ColorSpace;int16u:;1
0xa002;40962;4;int32;4;96 21 0 0 ;ExifImageWidth;int16u:;5472
0xa003;40963;4;int32;4;64 14 0 0 ;ExifImageHeight;int16u:;3648
0xa20e;41486;5;rational64;8;0 127 83 0 131 3 0 0 ;FocalPlaneXResolution;rational64u;6086.76307007786
0xa20f;41487;5;rational64;8;0 170 55 0 87 2 0 0 ;FocalPlaneYResolution;rational64u;6090.15025041736
0xa210;41488;3;int16;2;2 0 ;FocalPlaneResolutionUnit;int16u;2
0xa401;41985;3;int16;2;0 0 ;CustomRendered;int16u;0
0xa402;41986;3;int16;2;0 0 ;ExposureMode;int16u;0
0xa403;41987;3;int16;2;0 0 ;WhiteBalance;int16u;0
0xa406;41990;3;int16;2;0 0 ;SceneCaptureType;int16u;0
0xa420;42016;2;byte[];33;51 53 99 53 100 55 99 48 52 101 101 ...;ImageUniqueID;string;35c5d7c04ee7fd530261674ec6cf52b3
0xa430;42032;2;byte[];1;0 ;OwnerName;string;
0xa431;42033;2;byte[];13;48 54 51 48 50 49 48 48 52 54 57 ...;SerialNumber;string;063021004695
0xa432;42034;5;rational64;32;16 0 0 0 1 0 0 0 44 1 0 ...;LensInfo;rational64u[4];16
0xa434;42036;2;byte[];44;84 65 77 82 79 78 32 49 54 45 51 ...;LensModel;string;TAMRON 16-300mm F/3.5-6.3 Di II VC PZD B016
0xa435;42037;2;byte[];11;48 48 48 48 48 48 48 48 48 48 0 ...;LensSerialNumber;string;0000000000

EXIF-Einträge: 67, None: 11

Die EXIF-Daten (PropertyItems) wurden als CSV-Tabelle ausgegeben. Man kann sie daher einfach in Excel importieren und übersichtlich weiterbearbeiten.

Am Ende sieht man, dass es 67 EXIF-Einträge gibt, dass aber die Bedeutung von 11 unbekannt ist.

Bildvergleich

Verglichen werden die EXIF-Daten einer CANON-Kamera mit einer HUAWEI-Kamera. Die folgende Tabelle zeigt den Anfang dieser Excel-Tabelle, die alle Datenzeilen enthält, die aus den Bilddateien ausgelesen werden können. Die Spalten CANON-Value und HUAWEI-Value wurden aus den Spalten CANON-Bytes und HUAWEI-Bytes berechnet. Es sind insgesamt 60 Zeilen. Die grün gekennzeichneten Zeilen sind sowohl bei CANON als auch bei HUAWEI definiert, die anderen Zeilen nur bei einer der beiden Kameratypen. Die Excel-Tabelle ist in dem ZIP-Archiv enthalten.

Von den 475 definierten EXIF-Einträgen sind also bei der Abfrage des Bildes nur etwa 60 belegt. Und verschiedene Kameras benutzen nicht immer dieselben Felder. Es gibt einige Kuriositäten. Zum Beispiel den EXIF-Index 0x10e=270 "Image Description". CANON lässt dieses Feld leer, HUAWEI schreibt hier "fznor" hinein. Dieser Text steht auch irritierenderweise im Kommentar zu einem Kamera-Bild, das man in WordPress importiert. Man muss diese sinnlosen Buchstaben explizit löschen. Noch kurioser ist, dass diese Buchstaben nicht immer dieselben sind, manchmal steht dort auch etwas anderes. Das war sowohl beim Mate 9 der Fall und ist es noch beim Mate 20.

Ebenfalls rätselhaft ist das EXIF-Feld 0x501b=20507. Es verweist auf ein mehrere Tausend Byte großes Datenfeld. Wahrscheinlich ist hier ein Vorschaubild gespeichert. Das und viele weitere Unklarheiten müssten noch weiter analysiert werden.

Mit dem Auslesen der EXIF-Daten allein ist es nicht gelungen die GPS-Koordinaten auszulesen, man müsste dafür etwas tiefer in die Tausenden verfügbaren Indizes eintauchen, die mit dem Kommandozeilentool exiftool.exe ausgegeben werden.


Walter schreibt

Zum exiftool habe ich eine ‘alte’ aber sehr funktionable Oberfläche ‘ExifToolGUI v5’ Im Web gefunden. Hiermit lassen sich einige, für mich wesentliche Änderungen an den Exif-Daten bequem ausführen. Das Programm mag keine ‘file-anzahl’ über ca. 120 zur Manipulation, es hängt sich dann auf. Link: http://u88.n24.queensu.ca/exiftool/forum/index.php?topic=2750.0. Hier ist ein Bericht zum Gui: https://www.heise.de/download/product/exiftoolgui-63032

Links

Franz Fiala

Präsident Clubcomputer / Herausgeber PCNEWS bei ClubComputer.at
Franz ist pensionierter HTL Lehrer (TGM), Präsident von ClubComputer, Herausgeber der Clubzeitung PCNEWS und betreut unser Clubtelefon und Internet Support. Er ist leidenschaftlicher Rapid Wien Fan.

Letzte Artikel von Franz Fiala (Alle anzeigen)