aboutsummaryrefslogtreecommitdiffstats
path: root/test/extractor/image
diff options
context:
space:
mode:
Diffstat (limited to 'test/extractor/image')
-rw-r--r--test/extractor/image/__init__.py0
-rw-r--r--test/extractor/image/test_colors_spatial.py95
-rw-r--r--test/extractor/image/test_photometrics.py143
-rw-r--r--test/extractor/image/testimage.jpgbin0 -> 349264 bytes
4 files changed, 238 insertions, 0 deletions
diff --git a/test/extractor/image/__init__.py b/test/extractor/image/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/test/extractor/image/__init__.py
diff --git a/test/extractor/image/test_colors_spatial.py b/test/extractor/image/test_colors_spatial.py
new file mode 100644
index 0000000..902ab6d
--- /dev/null
+++ b/test/extractor/image/test_colors_spatial.py
@@ -0,0 +1,95 @@
+
+# standard imports
+import os
+import unittest
+
+# external imports
+import PIL.Image
+
+# bsie imports
+from bsie.extractor import base
+from bsie.utils import bsfs, ns, node as _node
+
+# objects to test
+from bsie.extractor.image.colors_spatial import ColorsSpatial
+
+
+## code ##
+
+class TestColorsSpatial(unittest.TestCase):
+ def setUp(self):
+ # content id with default constructors (width=32, height=32, exp=4)
+ self.instance_prefix = 'https://schema.bsfs.io/ie/Literal/Array/Feature/ColorsSpatial'
+ self.predicate_prefix = 'https://schema.bsfs.io/ie/Node/Entity#colors_spatial_'
+ self.uuid = 'adee8d6c43687021e1c5bffe56bcfe727f1638d792744137181304ef889dac2a'
+
+ def test_essentials(self):
+ # clones are equal
+ self.assertEqual(ColorsSpatial(32, 32, 4), ColorsSpatial(32, 32, 4))
+ self.assertEqual(hash(ColorsSpatial(32, 32, 4)), hash(ColorsSpatial(32, 32, 4)))
+ # equal respects type
+ self.assertNotEqual(ColorsSpatial(32, 32, 4), 'hello world')
+ self.assertNotEqual(hash(ColorsSpatial(32, 32, 4)), hash('hello world'))
+ # equals respects width
+ self.assertNotEqual(ColorsSpatial(32, 32, 4), ColorsSpatial(16, 32, 4))
+ self.assertNotEqual(hash(ColorsSpatial(32, 32, 4)), hash(ColorsSpatial(16, 32, 4)))
+ # equals respects height
+ self.assertNotEqual(ColorsSpatial(32, 32, 4), ColorsSpatial(32, 16, 4))
+ self.assertNotEqual(hash(ColorsSpatial(32, 32, 4)), hash(ColorsSpatial(32, 16, 4)))
+ # equals respects exp
+ self.assertNotEqual(ColorsSpatial(32, 32, 4), ColorsSpatial(32, 32, 8))
+ self.assertNotEqual(hash(ColorsSpatial(32, 32, 4)), hash(ColorsSpatial(32, 32, 8)))
+ # string representation
+ self.assertEqual(str(ColorsSpatial()), 'ColorsSpatial')
+ self.assertEqual(repr(ColorsSpatial(64, 16, 2)), 'ColorsSpatial(64, 16, 2)')
+
+ def test_dimension(self):
+ self.assertEqual(ColorsSpatial.dimension(32, 32, 4), 3 * (32*32 + 8*8 + 2*2))
+ self.assertEqual(ColorsSpatial.dimension(16, 16, 8), 3 * (16*16 + 2*2))
+ self.assertEqual(ColorsSpatial.dimension(64, 64, 16), 3 * (64*64 + 4*4))
+
+ def test_schema(self):
+ schema = bsfs.schema.from_string(base.SCHEMA_PREAMBLE + f'''
+ <{self.instance_prefix}> rdfs:subClassOf bsa:Feature ;
+ # annotations
+ rdfs:label "Spatially dominant colors"^^xsd:string ;
+ schema:description "Domiant colors of subregions in an image."^^xsd:string ;
+ bsfs:dtype xsd:integer .
+
+ <{self.instance_prefix}#{self.uuid}> rdfs:subClassOf <{self.instance_prefix}> ;
+ bsfs:dimension "3276"^^xsd:integer ;
+ # annotations
+ <{self.instance_prefix}/args#width> "32"^^xsd:integer ;
+ <{self.instance_prefix}/args#height> "32"^^xsd:integer ;
+ <{self.instance_prefix}/args#exp> "4"^^xsd:float .
+
+ <{self.predicate_prefix}{self.uuid}> rdfs:subClassOf bsfs:Predicate ;
+ rdfs:domain bsn:Entity ;
+ rdfs:range <{self.instance_prefix}#{self.uuid}> ;
+ bsfs:unique "true"^^xsd:boolean .
+ ''')
+ self.assertEqual(schema, ColorsSpatial().schema)
+
+ def test_extract(self):
+ ext = ColorsSpatial(2,2,2)
+ img = PIL.Image.open(os.path.join(os.path.dirname(__file__), 'testimage.jpg'))
+ node = _node.Node(ns.bsn.Entity, bsfs.URI('http://example.com/entity#1234'))
+ principals = set(ext.principals)
+ self.assertEqual(len(principals), 1)
+ # valid invocation yields feature
+ ret = list(ext.extract(node, img, principals))
+ self.assertEqual(ret[0], (
+ node,
+ list(principals)[0],
+ (91, 127, 121, 94, 138, 167, 163, 134, 190, 138, 170, 156, 121, 142, 159)))
+ # principals is respected
+ self.assertListEqual(list(ext.extract(node, img, {})), [])
+
+
+
+## main ##
+
+if __name__ == '__main__':
+ unittest.main()
+
+## EOF ##
diff --git a/test/extractor/image/test_photometrics.py b/test/extractor/image/test_photometrics.py
new file mode 100644
index 0000000..fb219e2
--- /dev/null
+++ b/test/extractor/image/test_photometrics.py
@@ -0,0 +1,143 @@
+
+# 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)})
+
+ # check orientation label
+ self.assertSetEqual(set(ext.extract(
+ node, {
+ 'Exif.Photo.PixelXDimension': '4288',
+ 'Exif.Photo.PixelYDimension': '2848',
+ 'Exif.Image.Orientation': '5',
+ },
+ {ext.schema.predicate(ns.bse.orientation_label)})),
+ {(node, ext.schema.predicate(ns.bse.orientation_label), 'portrait')})
+
+ # 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/extractor/image/testimage.jpg b/test/extractor/image/testimage.jpg
new file mode 100644
index 0000000..c80bb48
--- /dev/null
+++ b/test/extractor/image/testimage.jpg
Binary files differ
generated by cgit v1.2.3 (git 2.25.1) at 2025-08-02 21:49:35 +0000