def make_manifest_json(image_pages, thumbnail_images, identifier, page=None):
fac = ManifestFactory()
fac.set_base_prezi_uri(get_manifest_url(''))
fac.set_debug("error")
if page is None:
page = {
"title": image_pages[0]['title'],
"extract": "(single wikimedia image)"
}
manifest = fac.manifest(ident=identifier, label=page['title'])
manifest.description = sanitise(page['extract'])
sequence = manifest.sequence(ident="normal", label="default order")
for image_page in image_pages:
page_id = image_page.get('pageid', None)
wiki_info = image_page.get('imageinfo', [None])[0]
if wiki_info is not None and wiki_info['mime'] == "image/jpeg":
canvas = sequence.canvas(ident='c%s' % page_id,
label=image_page['title'])
canvas.set_hw(wiki_info['thumbheight'], wiki_info['thumbwidth'])
set_canvas_metadata(wiki_info, canvas)
anno = canvas.annotation(ident='a%s' % page_id)
img = anno.image(ident=wiki_info['thumburl'], iiif=False)
img.set_hw(wiki_info['thumbheight'], wiki_info['thumbwidth'])
thumb_page = thumbnail_images.get(str(page_id), None)
if thumb_page is not None:
thumb_info = thumb_page['imageinfo'][0]
canvas.thumbnail = fac.image(ident=thumb_info['thumburl'])
canvas.thumbnail.format = "image/jpeg"
canvas.thumbnail.set_hw(thumb_info['thumbheight'],
thumb_info['thumbwidth'])
return manifest.toJSON(top=True)
def build_manifest(book_id, book_path, metadata, pages):
fac = ManifestFactory()
base_url = flask.request.url_root[:-1]
fac.set_base_prezi_uri(base_url +
flask.url_for('get_book_manifest', book_id=book_id))
fac.set_base_image_uri(base_url + '/iiif/image/v2')
fac.set_iiif_image_info(2.0, 2)
manifest = fac.manifest(label=book_id)
manifest.set_description("Automatically generated from HOCR")
seq = manifest.sequence(ident='0')
for idx, (page_id, img_path, width, height) in enumerate(pages):
canvas = seq.canvas(ident=page_id, label='Page {}'.format(idx))
anno = canvas.annotation(ident=page_id)
img = anno.image('{}:{}'.format(book_id, page_id), iiif=True)
img.set_hw(height, width)
canvas.height = img.height
canvas.width = img.width
canvas.annotationList(
base_url +
flask.url_for('get_page_lines', book_id=book_id, page_id=page_id),
label="Transcribed Text")
if not seq.canvases:
logger.error("{} has no images!".format(book_path))
return None
else:
return manifest
def generate(coll):
metadata = get_metadata()
mf = ManifestFactory()
mf.set_base_prezi_uri(MANIFEST_BASE)
mf.set_base_image_uri(IMAGE_BASE)
mf.set_iiif_image_info(2.0, 0)
manifest = None
seq = None
page_num = 0
for folder in glob("data/%s/*" % coll):
jpegs = glob(folder + "/*.jpg")
jpegs.sort()
if len(jpegs) == 0:
continue
folder_name = os.path.basename(folder)
item_id = "%s-%s" % (coll, folder_name)
folder_metadata = metadata.get(item_id, {})
title = folder_metadata.get('Title', item_id)
manifest = mf.manifest(label=title)
desc = folder_metadata.get('Description/Summary')
if desc:
manifest.set_description(desc)
manifest.set_metadata(folder_metadata)
seq = manifest.sequence()
page_num = 0
for jpeg in jpegs:
image_info = generate_tiles(jpeg)
if not image_info:
break
page_num += 1
id = BASE_URL + "/%s/%s/%s" % (coll, folder_name, page_num)
canvas = seq.canvas(ident=id + "/canvas",
label=os.path.basename(jpeg).replace(
'.jpg', ''))
canvas.thumbnail = get_thumbnail(image_info)
rel_path = image_info['@id'].replace(IMAGE_BASE, '')
anno = canvas.annotation(ident=id + "/annotation")
image = anno.image(ident=rel_path, iiif=True)
image.height = image_info['height']
image.width = image_info['width']
canvas.height = image.height
canvas.width = image.width
write_manifest(manifest, coll, item_id)
def generate_iiif(images, pdf):
"""Generate IIIF 2.0 static image-service and manifest"""
# configure manifest factory
manifest_factory = ManifestFactory()
manifest_factory.set_base_prezi_dir(str(manifest_path))
manifest_factory.set_base_prezi_uri("http://localhost:8000")
manifest_factory.set_base_image_uri("http://localhost:8000/images")
manifest_factory.set_iiif_image_info(2.0, 1)
manifest = manifest_factory.manifest(label="Example Manifest from PDF")
manifest.description = "Sample P2 manifest with images from PDF"
manifest.set_metadata({"Generated from": pdf})
# configure tile generator for static assets
tile_generator = IIIFStatic(dst=str(image_path),
prefix="http://localhost:8000/images",
tilesize=512,
api_version="2.1",
extras=['/full/90,/0/default.jpg',
'/full/200,/0/default.jpg']) # thumbnail for UV
seq = manifest.sequence()
idx = 0
for i in images:
print(f"processing image {idx}")
image_id = i.stem
# create a canvas with an annotation
canvas = seq.canvas(ident=image_id, label=f"Canvas {idx}")
# create an annotation on the Canvas
annotation = canvas.annotation(ident=f"page-{idx}")
# add an image to the anno
img = annotation.image(image_id, iiif=True)
img.service.profile = 'http://iiif.io/api/image/2/level0.json'
# set image + canvas hw
img.set_hw_from_file(str(i))
canvas.height = img.height
canvas.width = img.width
# generate image-pyramid
tile_generator.generate(src=i, identifier=image_id)
idx = idx + 1
manifest.toFile(compact=False)
def _make_empty_manifest(ident: str, label: str, base_url: str) -> Manifest:
"""Generate an empty IIIF manifest.
:param ident: Identifier for the manifest, that is not a URL, but
the `<ident>` in `https://..../<ident>/manifest`
:param label: Label for the manifest
:param base_url: Root URL for the application, e.g. https://example.com
:returns: The empty manifest
"""
manifest_factory = ManifestFactory()
manifest_ident = f'{base_url}/iiif/{ident}/manifest'
manifest_factory.set_base_prezi_uri(f'{base_url}/iiif/{ident}')
manifest_factory.set_base_image_uri(f'{base_url}/iiif/image')
manifest_factory.set_iiif_image_info('2.0', 0)
manifest = manifest_factory.manifest(ident=manifest_ident, label=label)
return manifest
def get(self, request, *args, **kwargs):
fec_entity = self.get_object()
fac = ManifestFactory()
fac.set_base_prezi_uri(getattr(settings, 'BASE_PREZI_URI', 'http://127.0.0.1:8000/'))
# Default Image API information
fac.set_base_image_uri(getattr(settings, 'BASE_IMAGE_URI', 'http://127.0.0.1:8182/iiif/2/'))
fac.set_iiif_image_info(2.0, 2)
fac.set_debug("error")
manifest = fac.manifest(label=fec_entity.title)
manifest.set_metadata(self.assemble_metadata(fec_entity))
manifest.viewingDirection = "left-to-right"
manifest.attribution = 'Radio Free Europe/Free Europe Committee - Encrypted Telex Communication<br/>' \
'Vera & Donald Blinken Open Society Archives'
seq = manifest.sequence()
for p in range(1, fec_entity.pages + 1):
# Create a canvas with uri slug of page-p, and label of Page 1
canvas_id = "fec-%s-page-%s" % (fec_entity.doc_name, str(p))
cvs = seq.canvas(ident=canvas_id, label="Page %s" % p)
underscore_idx = fec_entity.doc_name.find('_')
image_id = urllib.quote_plus(
"fec/%s/%s_%s_%02d.jpg" % (
fec_entity.doc_name[:underscore_idx],
fec_entity.doc_name[:underscore_idx],
fec_entity.doc_name[underscore_idx + 1:],
p
)
)
cvs.set_image_annotation(image_id, iiif=True)
return self.render_json_response(manifest.toJSON(top=True))
def make_manifest_json(image_pages, thumbnail_images, identifier, page=None):
"""Generate the raw json for manifest."""
fac = ManifestFactory()
fac.set_base_prezi_uri(identifier)
fac.set_debug('error')
if page is None:
page = {
"title":
"Media on Wikimedia Commons with the Category: {}".format(
CATEGORY_STRING),
"extract":
"Generated by the ScienceStories.io API"
}
manifest = fac.manifest(ident=identifier, label=page['title'])
manifest.description = sanitise(page['extract'])
sequence = manifest.sequence(ident="normal", label="default order")
for image_page in image_pages:
page_id = image_page.get('pageid', None)
wiki_info = image_page.get('imageinfo', [None])[0]
# TODO: Extend support for more MIME Types
# Currently universalviewer does not support: "image/tiff"
verified_mimes = ["image/jpeg", "image/png"]
if wiki_info is not None and wiki_info['mime'] in verified_mimes:
canvas = sequence.canvas(ident='c%s' % page_id,
label=image_page['title'])
canvas.set_hw(wiki_info['thumbheight'], wiki_info['thumbwidth'])
set_canvas_metadata(wiki_info, canvas)
anno = canvas.annotation(ident='a%s' % page_id)
img = anno.image(ident=wiki_info['thumburl'], iiif=False)
img.set_hw(wiki_info['thumbheight'], wiki_info['thumbwidth'])
thumb_page = thumbnail_images.get(str(page_id), None)
if thumb_page is not None:
thumb_info = thumb_page['imageinfo'][0]
canvas.thumbnail = fac.image(ident=thumb_info['thumburl'])
canvas.thumbnail.format = "image/jpeg"
canvas.thumbnail.set_hw(thumb_info['thumbheight'],
thumb_info['thumbwidth'])
manifest_serialized = manifest.toJSON(top=True)
return manifest_serialized
def test11_set_multiple_descriptions(self):
# XXX Decide if the following should also work
# m.description = []
# m.description = "a"
# m.description = "b"
# self.assertEqual(m.description, ["a", "b"])
mf = ManifestFactory(mdbase="aa", imgbase="bb")
m = mf.manifest('a manifest')
m.description = ["a", "b"]
self.assertEqual(m.description, ["a", "b"])
m.description = []
m.description = {"en": "fish"}
self.assertEqual(
m.description,
OrderedDict([('@value', 'fish'), ('@language', 'en')]))
m.description = []
m.description = ["bar", {"en": "fish"}]
self.assertEqual(
m.description,
["bar",
OrderedDict([('@value', 'fish'), ('@language', 'en')])])
from iiif_prezi.factory import ManifestFactory
imageWidth = 693
imageHeight = 786
identifier = "test"
# Configure the factory
fac = ManifestFactory()
fac.set_base_metadata_uri("http://ids.lib.harvard.edu/iiif/metadata/")
fac.set_base_image_uri("http://ids.lib.harvard.edu/ids/view/" + identifier + '/')
fac.set_iiif_image_conformance(1.1, 1)
# Build the Manifest
mf = fac.manifest(ident="manifest", label="Example Manifest")
mf.set_metadata({"test label":"test value", "next label":"next value"})
mf.attribution = "Provided by the Houghton Library, Harvard University"
mf.viewingHint = "paged"
mf.description = "Description of Manuscript MS Richardson 44 Goes Here"
# And walk through the pages
seq = mf.sequence(ident="normal", label="Normal Order")
for st in range(3):
# Build the Canvas
cvs = seq.canvas(ident="c%s" % st,label="Test Canvas %s" % st)
cvs.set_hw(imageHeight, imageWidth)
# Build the Image Annotation
anno = cvs.annotation(ident="a%s" % st)
ranges_done = []
manifests = []
def save_manifest(ms):
data = manifest.toString(compact=False)
fh = open("manifests/" + ms[1] + '.json', mode="w", encoding="utf-8")
fh.write(data)
fh.close()
print('Manifest for ' + ms[0] + ' saved')
for ms in sheet.iter_rows(min_row=3, values_only=True):
if (ms[2] == None) and (ms[0] not in ranges_done): # Check that it's not a range row.
manifests.append(ms[0]) # Add it to the list of created manifests
title = ms[0]
manifest = fac.manifest(ident="manifest/" + ms[1] + ".json", label=title)
manifest.set_metadata({"Physical description": ms[4], 'Bibliography': ms[8], 'Library record ID': str(ms[9])})
manifest.attribution = "<span>Photo: © Archives & Special Collections, University of Glasgow Library. Terms of use: <a href=\"https://creativecommons.org/licenses/by-nc/4.0/\">CC-BY-NC</a></span>"
if ms[7] != None:
manifest.set_metadata({"Commentary": ms[7]})
manifest.description = ms[6]
seq = manifest.sequence(ident=ms[1] + ".json", label='Current page order')
image_dir = "/Users/luca/Documents/development/iiif-prezi/images/" + ms[1] + "/images/"
fac.set_base_image_dir(image_dir)
fac.set_base_image_uri("https://iiif.gla.ac.uk/iiif/" + ms[1] + "/images")
print('Getting data for ' + ms[0])
for fn in sorted(os.listdir(image_dir)):
if fn.endswith(".jp2"): # Makes sure that it picks up only images
ident = fn[:-4]
cvs_title = ident.replace("_", " ").title().split(' ')[-1]
cvs = seq.canvas(ident=ident, label=cvs_title)
"""iiif-prezi example code to build a manifest from a directory of images
"""
from iiif_prezi.factory import ManifestFactory
import os
image_dir = "/path/to/images"
prezi_dir = "/tmp"
fac = ManifestFactory()
fac.set_debug("error")
fac.set_base_image_uri("http://localhost/iiif")
fac.set_base_image_dir(image_dir)
fac.set_iiif_image_info()
fac.set_base_metadata_uri("http://localhost/prezi/")
fac.set_base_metadata_dir(prezi_dir)
mflbl = os.path.split(image_dir)[1].replace("_", " ").title()
mfst = fac.manifest(label=mflbl)
seq = mfst.sequence()
for fn in os.listdir(image_dir):
ident = fn[:-4]
title = ident.replace("_", " ").title()
cvs = seq.canvas(ident=ident, label=title)
cvs.add_image_annotation(ident, True)
mfst.toFile(compact=False)
from iiif_prezi.factory import ManifestFactory
imageWidth = 693
imageHeight = 786
identifier = "test"
# Configure the factory
fac = ManifestFactory()
fac.set_base_metadata_uri("http://ids.lib.harvard.edu/iiif/metadata/")
fac.set_base_image_uri("http://ids.lib.harvard.edu/ids/view/" + identifier +
'/')
fac.set_iiif_image_conformance(1.1, 1)
# Build the Manifest
mf = fac.manifest(ident="manifest", label="Example Manifest")
mf.set_metadata({"test label": "test value", "next label": "next value"})
mf.attribution = "Provided by the Houghton Library, Harvard University"
mf.viewingHint = "paged"
mf.description = "Description of Manuscript MS Richardson 44 Goes Here"
# And walk through the pages
seq = mf.sequence(ident="normal", label="Normal Order")
for st in range(3):
# Build the Canvas
cvs = seq.canvas(ident="c%s" % st, label="Test Canvas %s" % st)
cvs.set_hw(imageHeight, imageWidth)
# Build the Image Annotation
anno = cvs.annotation(ident="a%s" % st)
img = anno.image(ident="image-%s" % st, iiif=True)
def main():
mf = ManifestFactory()
mf.set_base_prezi_uri(config['hostname'])
mf.set_iiif_image_info(2.0, 0)
last_item_id = None
manifest = None
seq = None
page_num = 0
for row in csv.reader(open("data.csv")):
# only interested in images
if row[4].startswith('.') or not row[4].lower().endswith('.jpg'):
continue
# unpack the metadata
site, archive, locator, item_type, filename, title = row[0:6]
# only processing things with titles
if not title:
continue
# only processing things where we can find the path
image_path = os.path.join(config["data"], *row[0:5])
if not os.path.isfile(image_path):
continue
title = "%s - %s" % (site, title)
item_id = slugify(title)
image_info = generate_tiles(image_path)
if not image_info:
break
# when the title changes that's our queue to write the manifest
if not manifest or item_id != last_item_id:
if manifest:
write_manifest(manifest, item_id)
manifest = mf.manifest(label=title)
manifest.location = archive
manifest.set_metadata({
"title": title,
"archive": archive,
"locator": locator,
"type": item_type
})
seq = manifest.sequence()
page_num = 0
# add the image to the manifest sequence
page_num += 1
canvas = seq.canvas(ident="page-%s" % page_num,
label="Page %s" % page_num)
canvas.thumbnail = get_thumbnail(image_info)
anno = canvas.annotation()
image = anno.image(image_info['@id'], iiif=True)
image.height = image_info['height']
image.width = image_info['width']
canvas.height = image.height
canvas.width = image.width
last_item_id = item_id
# write the last one
write_manifest(manifest, item_id)
prezi_uri = "http://ufdcimages.uflib.ufl.edu/UF/00/07/88/91/00001/"
prezi_dir = "//flvc.fs.osg.ufl.edu/flvc-ufdc/resources/AA/00/00/00/01/00001"
# prezi_dir = "/c/Users/desai.kirti/Desktop/New folder/iiif-pre/tmp"
fac = ManifestFactory()
# fac.set_debug("error")
fac.set_base_image_uri("https://iiif.io/api/image/2.1/")
fac.set_iiif_image_info(2.0, 2)
fac.set_base_prezi_uri(prezi_uri)
fac.set_base_prezi_dir(prezi_dir)
# fac.set_debug("warn")
# mflbl = os.path.split(image_dir)[1].replace("_", " ").title()
mfst = fac.manifest(label="example")
seq = mfst.sequence()
# for fn in os.listdir(image_dir):
# ident = fn[:-4]
# title = ident.replace("_", " ").title()
# cvs = seq.canvas(ident=ident, label=title)
# cvs.add_image_annotation(ident, True)
for p in range(1,10):
# Create a canvas with uri slug of page-1, and label of Page 1
cvs = seq.canvas(ident="page-%s" % p, label="Page %s" % p)
# Create an annotation on the Canvas
anno = cvs.annotation()
# Add Image: http://www.example.org/path/to/image/api/p1/full/full/0/native.jpg
class ImageProcessor:
"""Manage generation of IIIF resources from manuscript dictionary."""
_failed = []
def __init__(self, generate_image_pyramid: bool = True):
"""Inits ImageProcessor and configures manifest factory.
:param generate_image_pyramid:if True, pyramid map will be generated. Else, only manifest is generated.
"""
if not os.path.exists(MANIFEST_OUTPUT_DIR):
os.makedirs(MANIFEST_OUTPUT_DIR)
self._manifest_factory = ManifestFactory()
self._manifest_factory.set_base_prezi_uri(MANIFEST_BASE_URL)
self._manifest_factory.set_base_prezi_dir(MANIFEST_OUTPUT_DIR)
self._manifest_factory.set_base_image_uri(IMAGE_BASE_URL)
self._manifest_factory.set_iiif_image_info(2.0, 1) # Version, ComplianceLevel
self._image_reader = ImageReader(IMAGE_SOURCE_DIR)
if generate_image_pyramid:
self._tile_generator = IIIFStatic(dst=IMAGE_FILE_OUTPUT_DIR, prefix=IMAGE_BASE_URL)
self._generate_images = generate_image_pyramid
def generate_iiif_resources(self, manuscript_data: Iterable[ManuscriptRow]) -> None:
"""Generate static IIIF resources for every manuscript record.
IIIF resources include image pyramid and manifests.
:param manuscript_data:list of dictionaries containing manuscript metadata.
:return:None
"""
for manuscript in manuscript_data:
self._process_manuscript(manuscript)
if self._failed:
print("Errors encountered processing following manuscripts: ")
print(*self._failed, sep=", ")
def _process_manuscript(self, manuscript: ManuscriptRow) -> None:
mhs_number = manuscript.get(ColumnKeys.MHS_NUMBER)
# noinspection PyBroadException
try:
if Path(os.path.join(MANIFEST_OUTPUT_DIR, f"{mhs_number}.json")).is_file():
print(f"{mhs_number} already processed. Skipping")
return
manifest = self._create_manifest(manuscript)
self._add_canvases(manuscript, manifest)
manifest.toFile(compact=False)
except Exception as e:
print(f"**Error processing {mhs_number}. {e}")
self._failed.append(mhs_number)
def _create_manifest(self, manuscript: ManuscriptRow) -> Manifest:
mhs_number = manuscript.get(ColumnKeys.MHS_NUMBER)
alternative_name = manuscript.get(ColumnKeys.ALTERNATIVE_NAME)
print(f"creating manifest for {mhs_number}")
manifest = self._manifest_factory.manifest(label=f"{mhs_number} - {alternative_name}", ident=mhs_number)
# add all non-empty fields as metadata (excluding "No" field as this is just internal id)
manifest.set_metadata({k: v for (k, v) in manuscript.items() if v and k != ColumnKeys.NO
and k != ColumnKeys.COMMENTS})
manifest.description = manuscript.get(ColumnKeys.COMMENTS)
return manifest
def _add_canvases(self, manuscript: ManuscriptRow, manifest: Manifest) -> None:
manuscript_images = self._image_reader.get_files_for_manuscript(manuscript)
mhs_number = manuscript.get(ColumnKeys.MHS_NUMBER)
image_count = len(manuscript_images)
print(f"creating {image_count} canvases for {mhs_number}..")
seq = manifest.sequence()
for p in range(image_count):
image_id = f"{mhs_number}-{p}"
start = time.time()
print(f"processing {image_id}..")
cvs = seq.canvas(ident=image_id, label=f"Page {p}")
# Create an annotation on the Canvas
annotation = cvs.annotation(ident=f"page-{p}")
# set source of image data
img = annotation.image(image_id, iiif=True)
# Set image height and width, and canvas to same dimensions
image_file = manuscript_images[p]
img.set_hw_from_file(image_file)
cvs.height = img.height
cvs.width = img.width
self._generate_image_pyramid(image_file, image_id, img.width, img.height)
end = time.time()
print(f"processed {image_id} in {end - start} secs")
def _generate_image_pyramid(self, image_file: str, image_id: str, width: int, height: int) -> None:
if not self._generate_images:
return
self._tile_generator.generate(src=image_file, identifier=image_id)
# generate a 90-wide thumb for UV (see: https://github.com/UniversalViewer/universalviewer/issues/102)
self._tile_generator.generate_tile("full", [90, None])
# generate a 1000-wide /full/ image for UV download
h = 1000 / (width / height)
self._tile_generator.generate_tile("full", [1000, h])
# generate a max-width /full/ image for UV download
self._tile_generator.generate_tile("full", [width, None])
"""Simple example for iiif_prezi.factory.ManifestFactory()."""
from iiif_prezi.factory import ManifestFactory
factory = ManifestFactory()
factory.set_base_prezi_uri("http://example.org/iiif/prezi/")
factory.set_base_image_uri("http://example.org/iiif/image/")
factory.set_iiif_image_info(version="2.0", lvl="2")
mf = factory.manifest(label="Manifest")
mf.viewingHint = "paged"
seq = mf.sequence()
for x in range(1):
cvs = seq.canvas(ident="c%s" % x, label="Canvas %s" % x)
cvs.set_hw(1000, 1000)
anno = cvs.annotation()
img = factory.image("f1r.c", iiif=True)
img2 = factory.image("f1r", iiif=True)
chc = anno.choice(img, [img2])
# print(mf.toString(compact=False))
"""iiif-prezi example code to build a manifest from a directory of images
"""
from iiif_prezi.factory import ManifestFactory
import os
image_dir = "/path/to/images"
prezi_dir = "/tmp"
fac = ManifestFactory()
fac.set_debug("error")
fac.set_base_image_uri("http://localhost/iiif")
fac.set_base_image_dir(image_dir)
fac.set_iiif_image_info()
fac.set_base_metadata_uri("http://localhost/prezi/")
fac.set_base_metadata_dir(prezi_dir)
mflbl = os.path.split(image_dir)[1].replace("_", " ").title()
mfst = fac.manifest(label=mflbl)
seq = mfst.sequence()
for fn in os.listdir(image_dir):
ident = fn[:-4]
title = ident.replace("_", " ").title()
cvs = seq.canvas(ident=ident, label=title)
cvs.add_image_annotation(ident, True)
mfst.toFile(compact=False)
