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 test10_set_hw_from_file_image_magick(self):
mf = ManifestFactory()
self.assertNotEqual( mf.whichid, '' ) #Expect to find ImageMagick
self.assertRaises( ConfigurationError, mf.image, 'name' )
mf.set_base_image_uri( 'testimages' )
img = mf.image('an_image')
self.assertEqual( img.set_hw_from_file('testimages/nci-vol-2303-72.jpg'), None )
self.assertEqual( img.width, 648 )
self.assertEqual( img.height, 432 )
def test09_set_hw_from_iiif(self):
mf = ManifestFactory()
mf.set_base_image_uri('file:tests/testdata')
img = mf.image('image1', iiif=True)
self.assertEqual(img.set_hw_from_iiif(), None)
self.assertEqual(img.width, 3000)
self.assertEqual(img.height, 4000)
# Error cases
img._identifier = ""
self.assertRaises(ConfigurationError, img.set_hw_from_iiif)
img._identifier = "image-does-not-exist"
self.assertRaises(ConfigurationError, img.set_hw_from_iiif)
img._identifier = "image2_bad"
self.assertRaises(ConfigurationError, img.set_hw_from_iiif)
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))
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)
#cvs.add_image_annotation(fn, True)
anno = cvs.annotation(ident=ident + ".json", label=title)
image = anno.image(ident=fn, iiif=True)
image.set_hw_from_iiif()
cvs.set_hw(image.height, image.width)
if ms[0] not in ms_with_ranges: # If it's not a ms with ranges add the title and save the manifest
if ms[5] != None:
"""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)
"""iiif-prezi example code to build a manifest"""
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
manifestUrl = config['manifest_base_url']
# Configure XML namespaces
nss = {'mets': "http://www.loc.gov/METS/",
'dc': 'http://purl.org/dc/elements/1.1/',
'dcterms': 'http://purl.org/dc/terms/',
'dnx': 'http://www.exlibrisgroup.com/dps/dnx',
'xsi': 'http://www.w3.org/2001/XMLSchema-instance'}
sigPropsPath = "/mets:mets/mets:amdSec[@ID='%s-amd']/mets:techMD/mets:mdWrap/mets:xmlData/dnx:dnx/dnx:section[@id='significantProperties']"
widthPath = "./dnx:record[./dnx:key[@id='significantPropertiesType']/text()='nisoImage.imageWidth']/dnx:key[@id='significantPropertiesValue']/text()"
heightPath = "./dnx:record[./dnx:key[@id='significantPropertiesType']/text()='nisoImage.imageLength']/dnx:key[@id='significantPropertiesValue']/text()"
# Configure the Manifest factory
fac = ManifestFactory()
fac.set_base_image_uri(imageUrl)
fac.set_iiif_image_conformance(2.0, 2)
# Need to set base manifest directory and url per object
def fetch_mets(identifier):
url = "%sentity/%s" % (rosetta, identifier)
resp = requests.get(url, headers={"Authorization":auth})
data = resp.content
dom = etree.XML(data)
return dom
def fetch_image(identifier, ident, rep, image):
# Check we don't already have it:
destDir = "%s%s" % (imageDir, ident)
destImage = "%s/%s.jp2" % (destDir, image)
"""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)
"""iiif-prezi example code to build a manifest"""
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
from iiif_prezi.factory import ManifestFactory
import os
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
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))
import os import pymongo import glob databaseaddress_capitolare_mongo ="mongodb+srv://giacomo:[email protected]/testcapit?retryWrites=true&w=majority" client = pymongo.MongoClient(databaseaddress_capitolare_mongo) folder = "imageapi/m0171_0" image_dir = os.path.join(os.getcwd(),folder) segnatura_id = os.path.basename(folder) var = client.capitolare.codici.find_one({'segnatura_idx': segnatura_id}) prezi_dir = "/tmp" fac = ManifestFactory() fac.set_debug("error") fac.set_base_image_uri(os.path.join("http://lezioni.meneghetti.univr.it//",folder)) fac.set_base_image_dir(image_dir) fac.set_iiif_image_info() fac.set_base_prezi_uri("http://lezioni.meneghetti.univr.it//manifests/") fac.set_base_prezi_dir(prezi_dir) mflbl = os.path.split(image_dir)[1].replace("_", " ").title() mfst = fac.manifest(label=mflbl) seq = mfst.sequence() listadir = glob.glob(folder+"/*.jp2") for fn in [i for i in os.listdir(image_dir) if i.endswith('.jp2')]: ident = fn[:-4] title = ident.replace("_", " ").title() cvs = seq.canvas(ident=ident, label=title) cvs.add_image_annotation(fn,iiif=True)
imageUris = [BASEURL + "resources/page1-full.png", BASEURL + "resources/page2-full.png"]
textUris = [BASEURL + "resources/page1.txt", BASEURL + "resources/page2.txt"]
htmlUris = [BASEURL + "resources/page1.html", BASEURL + "resources/page2.html"]
transcriptions = [
["Top of First Page to Display", "Middle of First Page on Angle", "Bottom of First Page to Display"],
["Top of Second Page to Display", "Middle of Second Page on Angle", "Bottom of Second Page on Angle"]
]
line1Dims = "225,70,750,150"
# Configure the factory
fac = ManifestFactory()
fac.set_base_prezi_uri(BASEURL)
fac.set_base_prezi_dir(HOMEDIR)
fac.set_base_image_uri(IMAGE_BASEURL)
fac.set_iiif_image_info(2.0, 1)
fac.set_debug('error')
testInfo = {
# Done
1 : {"title": "Minimum Required Fields"},
2 : {"title": "Metadata Pairs", 'mfprops': [('metadata',{'date': 'some date'})]},
3 : {"title": "Metadata Pairs with Languages", 'mfprops': [('metadata', {'date': {'en':'some data','fr':'quelquetemps'}})]},
4 : {"title": "Metadata Pairs with Multiple Values in same Language", 'mfprops':[('metadata',{'date': ['some date', 'some other date']})]},
5 : {"title": "Description field", 'mfprops': [('description',"This is a description")]},
6 : {"title": "Multiple Descriptions", 'mfprops': [('description',["This is one description", {"en":"This is another"}])]},
7 : {"title": "Rights Metadata", 'mfprops': [('attribution', "Owning Institution"), ('license','http://creativecommons.org/licenses/by-nc/3.0/')]},
8 : {"title": "SeeAlso link / Manifest", 'mfprops':[('seeAlso','http://www.example.org/link/to/metadata')]},
9 : {"title": "Service link / Manifest", 'mfprops':[('service','http://www.example.org/link/to/searchService')]},
"Top of First Page to Display", "Middle of First Page on Angle",
"Bottom of First Page to Display"
],
[
"Top of Second Page to Display",
"Middle of Second Page on Angle",
"Bottom of Second Page on Angle"
]]
line1Dims = "225,70,750,150"
# Configure the factory
fac = ManifestFactory()
fac.set_base_prezi_uri(BASEURL)
fac.set_base_prezi_dir(HOMEDIR)
fac.set_base_image_uri(IMAGE_BASEURL)
fac.set_iiif_image_info(2.0, 1)
fac.set_debug('error')
testInfo = {
# Done
1: {
"title": "Minimum Required Fields"
},
2: {
"title": "Metadata Pairs",
'mfprops': [('metadata', {
'date': 'some date'
})]
},
