Exif data reader and extractor

3 files changed, 273 insertions, 3 deletions

diff --git a/bsie/apps/default_config.yaml b/bsie/apps/default_config.yaml
index 4d99e22..a59b0f3 100644
--- a/bsie/apps/default_config.yaml
+++ b/bsie/apps/default_config.yaml
@@ -11,7 +11,9 @@ ExtractorBuilder:
   - bsie.extractor.generic.stat.Stat: {}
 
   - bsie.extractor.image.colors_spatial.ColorsSpatial:
-      width: 2
-      height: 2
-      exp: 2
+      width: 32
+      height: 32
+      exp: 4
+
+  - bsie.extractor.image.photometrics.Exif: {}
 
diff --git a/bsie/extractor/image/photometrics.py b/bsie/extractor/image/photometrics.py
new file mode 100644
index 0000000..ae0a541
--- /dev/null
+++ b/bsie/extractor/image/photometrics.py
@@ -0,0 +1,219 @@
+"""
+
+Part of the bsie module.
+A copy of the license is provided with the project.
+Author: Matthias Baumgartner, 2022
+"""
+# standard imports
+from fractions import Fraction
+import typing
+
+# bsie imports
+from bsie.utils import bsfs, node, ns
+
+# inner-module imports
+from .. import base
+
+# exports
+__all__: typing.Sequence[str] = (
+    'Exif',
+    )
+
+
+## code ##
+
+def _gps_to_dec(coords: typing.Tuple[float, float, float]) -> float:
+    """Convert GPS coordinates from exif to float."""
+    # unpack args
+    deg, min, sec = coords
+    # convert to float
+    deg = float(Fraction(deg))
+    min = float(Fraction(min))
+    sec = float(Fraction(sec))
+
+    if float(sec) > 0:
+        # format is deg+min+sec
+        return (float(deg) * 3600 + float(min) * 60 + float(sec)) / 3600
+    else:
+        # format is deg+min
+        return float(deg) + float(min) / 60
+
+
+class Exif(base.Extractor):
+    """Extract information from EXIF/IPTC tags of an image file."""
+
+    CONTENT_READER = 'bsie.reader.exif.Exif'
+
+    def __init__(self):
+        super().__init__(bsfs.schema.from_string(base.SCHEMA_PREAMBLE + '''
+            #bse:t_capture rdfs:subClassOf bsfs:Predicate ;
+            #    rdfs:domain bsfs:File ;
+            #    rdfs:range xsd:float ;
+            #    bsfs:unique "true"^^xsd:boolean .
+            bse:exposure rdfs:subClassOf bsfs:Predicate ;
+                rdfs:domain bsfs:File ;
+                rdfs:range xsd:float ;
+                bsfs:unique "true"^^xsd:boolean .
+            bse:aperture rdfs:subClassOf bsfs:Predicate ;
+                rdfs:domain bsfs:File ;
+                rdfs:range xsd:float ;
+                bsfs:unique "true"^^xsd:boolean .
+            bse:iso rdfs:subClassOf bsfs:Predicate ;
+                rdfs:domain bsfs:File ;
+                rdfs:range xsd:integer ;
+                bsfs:unique "true"^^xsd:boolean .
+            bse:focal_length rdfs:subClassOf bsfs:Predicate ;
+                rdfs:domain bsfs:File ;
+                rdfs:range xsd:float ;
+                bsfs:unique "true"^^xsd:boolean .
+            bse:width rdfs:subClassOf bsfs:Predicate ;
+                rdfs:domain bsfs:File ;
+                rdfs:range xsd:integer ;
+                bsfs:unique "true"^^xsd:boolean .
+            bse:height rdfs:subClassOf bsfs:Predicate ;
+                rdfs:domain bsfs:File ;
+                rdfs:range xsd:integer ;
+                bsfs:unique "true"^^xsd:boolean .
+            bse:orientation rdfs:subClassOf bsfs:Predicate ;
+                rdfs:domain bsfs:File ;
+                rdfs:range xsd:integer ;
+                bsfs:unique "true"^^xsd:boolean .
+            bse:orientation_label rdfs:subClassOf bsfs:Predicate ;
+                rdfs:domain bsfs:File ;
+                rdfs:range xsd:string ;
+                bsfs:unique "true"^^xsd:boolean .
+            bse:altitude rdfs:subClassOf bsfs:Predicate ;
+                rdfs:domain bsfs:File ;
+                rdfs:range xsd:float ;
+                bsfs:unique "true"^^xsd:boolean .
+            bse:latitude rdfs:subClassOf bsfs:Predicate ;
+                rdfs:domain bsfs:File ;
+                rdfs:range xsd:float ;
+                bsfs:unique "true"^^xsd:boolean .
+            bse:longitude rdfs:subClassOf bsfs:Predicate ;
+                rdfs:domain bsfs:File ;
+                rdfs:range xsd:float ;
+                bsfs:unique "true"^^xsd:boolean .
+            '''))
+        # initialize mapping from predicate to callback
+        self._callmap = {
+            #self.schema.predicate(ns.bse.t_capture):         self._date,
+            self.schema.predicate(ns.bse.exposure):          self._exposure,
+            self.schema.predicate(ns.bse.aperture):          self._aperture,
+            self.schema.predicate(ns.bse.iso):               self._iso,
+            self.schema.predicate(ns.bse.focal_length):      self._focal_length,
+            self.schema.predicate(ns.bse.width):             self._width,
+            self.schema.predicate(ns.bse.height):            self._height,
+            self.schema.predicate(ns.bse.orientation):       self._orientation,
+            self.schema.predicate(ns.bse.orientation_label): self._orientation_label,
+            self.schema.predicate(ns.bse.altitude):          self._altitude,
+            self.schema.predicate(ns.bse.latitude):          self._latitude,
+            self.schema.predicate(ns.bse.longitude):         self._longitude,
+            }
+
+    def extract(
+            self,
+            subject: node.Node,
+            content: dict,
+            principals: typing.Iterable[bsfs.schema.Predicate],
+            ) -> typing.Iterator[typing.Tuple[node.Node, bsfs.schema.Predicate, typing.Any]]:
+        for pred in principals:
+            # find callback
+            clbk = self._callmap.get(pred)
+            if clbk is None:
+                continue
+            # get value
+            value = clbk(content)
+            if value is None:
+                continue
+            # produce triple
+            yield subject, pred, value
+
+    def _date(self, content: dict): # FIXME: Return type annotation
+        raise NotImplementedError()
+        #date_keys = (
+        #    'Exif.Photo.DateTimeOriginal',
+        #    'Exif.Photo.DateTimeDigitized',
+        #    'Exif.Image.DateTime',
+        #    )
+        #for key in date_keys:
+        #    if key in content:
+        #        dt = content[key].value
+        #        if dt.tzinfo is None:
+        #            dt = dt.replace(tzinfo=ttime.NoTimeZone)
+        #        return dt
+        #return None
+
+
+    ## photometrics
+
+    def _exposure(self, content: dict) -> typing.Optional[float]:
+        if 'Exif.Photo.ExposureTime' in content:
+            return 1.0 / float(Fraction(content['Exif.Photo.ExposureTime']))
+        return None
+
+    def _aperture(self, content: dict) -> typing.Optional[float]:
+        if 'Exif.Photo.FNumber' in content:
+            return float(Fraction(content['Exif.Photo.FNumber']))
+        return None
+
+    def _iso(self, content: dict) -> typing.Optional[int]:
+        if 'Exif.Photo.ISOSpeedRatings' in content:
+            return int(content['Exif.Photo.ISOSpeedRatings'])
+        return None
+
+    def _focal_length(self, content: dict) -> typing.Optional[float]:
+        if 'Exif.Photo.FocalLength' in content:
+            return float(Fraction(content['Exif.Photo.FocalLength']))
+        return None
+
+
+    ## image dimensions
+
+    def _width(self, content: dict) -> typing.Optional[int]:
+        # FIXME: consider orientation!
+        if 'Exif.Photo.PixelXDimension' in content:
+            return int(content['Exif.Photo.PixelXDimension'])
+        return None
+
+    def _height(self, content: dict) -> typing.Optional[int]:
+        # FIXME: consider orientation!
+        if 'Exif.Photo.PixelYDimension' in content:
+            return int(content['Exif.Photo.PixelYDimension'])
+        return None
+
+    def _orientation(self, content: dict) -> typing.Optional[int]:
+        if 'Exif.Image.Orientation' in content:
+            return int(content['Exif.Image.Orientation'])
+        return None
+
+    def _orientation_label(self, content: dict) -> typing.Optional[str]:
+        width = self._width(content)
+        height = self._height(content)
+        ori = self._orientation(content)
+        if width is not None and height is not None and ori is not None:
+            if ori <= 4:
+                return 'landscape' if width >= height else 'portrait'
+            else:
+                return 'portrait' if width >= height else 'landscape'
+        return None
+
+
+    ## location
+
+    def _altitude(self, content: dict) -> typing.Optional[float]:
+        if 'Exif.GPSInfo.GPSAltitude' in content:
+            return float(Fraction(content['Exif.GPSInfo.GPSAltitude']))
+        return None
+
+    def _latitude(self, content: dict) -> typing.Optional[float]:
+        if 'Exif.GPSInfo.GPSLatitude' in content:
+            return _gps_to_dec(content['Exif.GPSInfo.GPSLatitude'].split())
+        return None
+
+    def _longitude(self, content: dict) -> typing.Optional[float]:
+        if 'Exif.GPSInfo.GPSLongitude' in content:
+            return _gps_to_dec(content['Exif.GPSInfo.GPSLongitude'].split())
+        return None
+
+## EOF ##
diff --git a/bsie/reader/exif.py b/bsie/reader/exif.py
new file mode 100644
index 0000000..e087bec
--- /dev/null
+++ b/bsie/reader/exif.py
@@ -0,0 +1,49 @@
+"""
+
+Part of the bsie module.
+A copy of the license is provided with the project.
+Author: Matthias Baumgartner, 2022
+"""
+# standard imports
+import typing
+
+# external imports
+import pyexiv2
+
+# bsie imports
+from bsie.utils import errors, filematcher
+
+# inner-module imports
+from . import base
+
+# constants
+MATCH_RULE = 'mime=image/jpeg'
+
+# exports
+__all__: typing.Sequence[str] = (
+    'Exif',
+    )
+
+
+## code ##
+
+class Exif(base.Reader):
+    """Use pyexiv2 to read exif metadata from image files."""
+
+    def __init__(self):
+        self._match = filematcher.parse(MATCH_RULE)
+
+    def __call__(self, path: str) -> dict:
+        # perform quick checks first
+        if not self._match(path):
+            raise errors.UnsupportedFileFormatError(path)
+
+        try:
+            # open the file
+            img = pyexiv2.Image(path)
+            # read metadata
+            return img.read_exif()
+        except TypeError as err:
+            raise errors.ReaderError(path) from err
+
+## EOF ##