Exif data reader and extractor

3 files changed, 186 insertions, 0 deletions

diff --git a/test/extractor/image/test_photometrics.py b/test/extractor/image/test_photometrics.py
new file mode 100644
index 0000000..6e3b661
--- /dev/null
+++ b/test/extractor/image/test_photometrics.py
@@ -0,0 +1,138 @@
+"""
+
+Part of the bsie test suite.
+A copy of the license is provided with the project.
+Author: Matthias Baumgartner, 2022
+"""
+# standard imports
+import unittest
+
+# bsie imports
+from bsie.extractor import base
+from bsie.utils import bsfs, node as _node, ns
+
+# objects to test
+from bsie.extractor.image.photometrics import Exif, _gps_to_dec
+
+
+## code ##
+
+class TestExif(unittest.TestCase):
+
+    def test_gps_to_dec(self):
+        # deg+min+sec format
+        self.assertAlmostEqual(_gps_to_dec('29/1 58/1 45/1'.split()), 29.979167, 6)
+        self.assertAlmostEqual(_gps_to_dec('31 08 03'.split()), 31.134167, 6)
+        self.assertAlmostEqual(_gps_to_dec('20 40 586/10'.split()), 20.682944, 6)
+        self.assertAlmostEqual(_gps_to_dec('88/1 34 68/10'.split()), 88.568556, 6)
+        # deg+min format
+        self.assertAlmostEqual(_gps_to_dec('13 472167/10000 0/1 '.split()), 13.786945, 6)
+        self.assertAlmostEqual(_gps_to_dec('104/1 3215/100 0/1'.split()), 104.535833, 6)
+
+    def test_eq(self):
+        # identical instances are equal
+        self.assertEqual(Exif(), Exif())
+        self.assertEqual(hash(Exif()), hash(Exif()))
+        # comparison respects type
+        class Foo(): pass
+        self.assertNotEqual(Exif(), Foo())
+        self.assertNotEqual(hash(Exif()), hash(Foo()))
+        self.assertNotEqual(Exif(), 1234)
+        self.assertNotEqual(hash(Exif()), hash(1234))
+        self.assertNotEqual(Exif(), None)
+        self.assertNotEqual(hash(Exif()), hash(None))
+
+    def test_schema(self):
+        self.assertSetEqual({pred.uri for pred in Exif().schema.predicates()}, {
+            ns.bsfs.Predicate,
+            ns.bse.exposure,
+            ns.bse.aperture,
+            ns.bse.iso,
+            ns.bse.focal_length,
+            ns.bse.width,
+            ns.bse.height,
+            ns.bse.orientation,
+            ns.bse.orientation_label,
+            ns.bse.altitude,
+            ns.bse.latitude,
+            ns.bse.longitude,
+            })
+
+    def test_extract(self):
+        ext = Exif()
+        node = _node.Node(ns.bsfs.File, '') # Blank node
+        content = {
+            'Exif.Photo.ExposureTime': '10/600',
+            'Exif.Photo.FNumber': '48/10',
+            'Exif.Photo.ISOSpeedRatings': '400',
+            'Exif.Photo.FocalLength': '460/10',
+            'Exif.Photo.PixelXDimension': '4288',
+            'Exif.Photo.PixelYDimension': '2848',
+            'Exif.Image.Orientation': '1',
+            'Exif.GPSInfo.GPSAltitude': '431/1',
+            'Exif.GPSInfo.GPSLatitude': '46/1 11397/625 0/1',
+            'Exif.GPSInfo.GPSLongitude': '7/1 131250/2500 0/1',
+            }
+
+        # invalid principals are ignored
+        self.assertSetEqual(set(ext.extract(node, content, {ns.bse.filename})), set())
+        # extract finds all relevant information
+        self.assertSetEqual(set(ext.extract(node, content, {ext.schema.predicate(ns.bse.exposure)})),
+            {(node, ext.schema.predicate(ns.bse.exposure), 60.0)})
+        self.assertSetEqual(set(ext.extract(node, content, {ext.schema.predicate(ns.bse.aperture)})),
+            {(node, ext.schema.predicate(ns.bse.aperture), 4.8)})
+        self.assertSetEqual(set(ext.extract(node, content, {ext.schema.predicate(ns.bse.iso)})),
+            {(node, ext.schema.predicate(ns.bse.iso), 400)})
+        self.assertSetEqual(set(ext.extract(node, content, {ext.schema.predicate(ns.bse.focal_length)})),
+            {(node, ext.schema.predicate(ns.bse.focal_length), 46.0)})
+        self.assertSetEqual(set(ext.extract(node, content, {ext.schema.predicate(ns.bse.width)})),
+            {(node, ext.schema.predicate(ns.bse.width), 4288)})
+        self.assertSetEqual(set(ext.extract(node, content, {ext.schema.predicate(ns.bse.height)})),
+            {(node, ext.schema.predicate(ns.bse.height), 2848)})
+        self.assertSetEqual(set(ext.extract(node, content, {ext.schema.predicate(ns.bse.orientation)})),
+            {(node, ext.schema.predicate(ns.bse.orientation), 1)})
+        self.assertSetEqual(set(ext.extract(node, content, {ext.schema.predicate(ns.bse.orientation_label)})),
+            {(node, ext.schema.predicate(ns.bse.orientation_label), 'landscape')})
+        self.assertSetEqual(set(ext.extract(node, content, {ext.schema.predicate(ns.bse.altitude)})),
+            {(node, ext.schema.predicate(ns.bse.altitude), 431.0)})
+        self.assertSetEqual(set(ext.extract(node, content, {ext.schema.predicate(ns.bse.latitude)})),
+            {(node, ext.schema.predicate(ns.bse.latitude), 46.30392)})
+        self.assertSetEqual(set(ext.extract(node, content, {ext.schema.predicate(ns.bse.longitude)})),
+            {(node, ext.schema.predicate(ns.bse.longitude), 7.875)})
+
+        # can pass multiple principals
+        self.assertSetEqual(set(ext.extract(node, content, {
+            ext.schema.predicate(ns.bse.exposure),
+            ext.schema.predicate(ns.bse.iso),
+            ext.schema.predicate(ns.bse.focal_length),
+            })), {
+            (node, ext.schema.predicate(ns.bse.exposure), 60.0),
+            (node, ext.schema.predicate(ns.bse.iso), 400),
+            (node, ext.schema.predicate(ns.bse.focal_length), 46.0),
+            })
+
+        # principals w/o content are ignored
+        self.assertSetEqual(set(ext.extract(
+            node,
+            content={'Exif.Photo.ExposureTime': '10/600'},
+            principals={
+                ext.schema.predicate(ns.bse.exposure),
+                ext.schema.predicate(ns.bse.iso),
+                ext.schema.predicate(ns.bse.focal_length),
+                })
+            ), {
+            (node, ext.schema.predicate(ns.bse.exposure), 60.0),
+            })
+
+        # empty content is acceptable
+        self.assertSetEqual(set(ext.extract(node, {}, set(ext.principals))), set())
+        # no principals is acceptable
+        self.assertSetEqual(set(ext.extract(node, content, set())), set())
+
+
+## main ##
+
+if __name__ == '__main__':
+    unittest.main()
+
+## EOF ##
diff --git a/test/reader/test_exif.py b/test/reader/test_exif.py
new file mode 100644
index 0000000..f1330da
--- /dev/null
+++ b/test/reader/test_exif.py
@@ -0,0 +1,48 @@
+"""
+
+Part of the bsie test suite.
+A copy of the license is provided with the project.
+Author: Matthias Baumgartner, 2022
+"""
+# standard imports
+import os
+import unittest
+
+# bsie imports
+from bsie.utils import errors
+
+# objects to test
+from bsie.reader.exif import Exif
+
+
+## code ##
+
+class TestExif(unittest.TestCase):
+    def test_call(self):
+        rdr = Exif()
+        # discards non-image files
+        self.assertRaises(errors.UnsupportedFileFormatError, rdr, 'invalid.doc')
+        # raises on invalid image files
+        self.assertRaises(errors.ReaderError, rdr, 'invalid.jpg')
+        # returns dict with exif info
+        self.assertDictEqual(rdr(os.path.join(os.path.dirname(__file__), 'testimage_exif.jpg')), {
+            'Exif.Image.Artist': 'nobody',
+            'Exif.Image.ExifTag': '110',
+            'Exif.Image.ResolutionUnit': '2',
+            'Exif.Image.XResolution': '300/1',
+            'Exif.Image.YCbCrPositioning': '1',
+            'Exif.Image.YResolution': '300/1',
+            'Exif.Photo.ColorSpace': '65535',
+            'Exif.Photo.ComponentsConfiguration': '1 2 3 0',
+            'Exif.Photo.ExifVersion': '48 50 51 50',
+            'Exif.Photo.FlashpixVersion': '48 49 48 48',
+            'Exif.Photo.ISOSpeedRatings': '200',
+            })
+
+
+## main ##
+
+if __name__ == '__main__':
+    unittest.main()
+
+## EOF ##
diff --git a/test/reader/testimage_exif.jpg b/test/reader/testimage_exif.jpg
new file mode 100644
index 0000000..a774bc2
--- /dev/null
+++ b/test/reader/testimage_exif.jpg