Tips and Tricks

More on using your own images

1. Commercial Hosting: http://www.iiifhosting.com/

2. Using Mirador-Desktop

   1. https://stanford.app.box.com/v/mirador-desktop/folder/40394351244

   2. WARNING: You will not be able to paste the URL for your manifest into Desktop Mirador, although you can type it in manually.

3. Setting up an image server (advanced)

   1. Set up one of the many available image servers (we’ll be using Loris below)

   2. Install Docker (Community Edition):

      1. All platforms: https://docs.docker.com/install/

      2. Quicker method for Mac: install via Homebrew

         1. Install Homebrew: https://brew.sh

         2. In Terminal:

            1. $ brew tap caskroom/cask

            2. $ brew cask install docker

   3. Working on the command line:

      1. $ docker -v [which version are you running?]

      2. $ docker images [which images do you have?]

      3. $ docker pull bdlss/loris-grok-docker

      4. $ docker run -p 5004:5004 -v/{path to your images}:/usr/local/share/images bdlss/loris-grok-docker

   4. [it’s now running - but you can’t see anything yet]

      1. Test: In browser, go to http://localhost:5004/{name of one of your images}/info.json

      2. Want to see an image?

         1. http://localhost:5004/{name of your image}/full/full/0/default.jpg

   5. Auxiliary tools

      1. Loris Image server. In github: https://github.com/loris-imageserver/loris

      2. Docker: https://www.docker.com/

         1. Community edition: https://www.docker.com/get-docker

Biblissima (Gallica and BVMM) patterns for iiif manifests and individual images can be found here: http://doc.biblissima-condorcet.fr/entrepots-iiif-biblissima

--N.B., https is now required [not http] for manifests and images

Online json reader

Copy a manifest into this site http://jsonviewer.stack.hu/ to generate a collapsable manifest.

How do you make a multi-page object in mirador? What does that manifest or creation of manifest look like?

Creating your own manifest.

What if you want to grab a single leaf and not the entire manuscript?

• Open full manifest for the manuscript (.json)

• Find URL for single leaf you want (ends in default.jpg)

• For Parker on the Web, you have to replace one part of the URL to make it work. Just before the MS no, delete the forward slash, and replace it with %252F

  • Original: https://stacks.stanford.edu/image/iiif/zh635rv2202/402_001_V_TC_46/full/full/0/default.jpg

  • Modified: https://stacks.stanford.edu/image/iiif/zh635rv2202%252F402_001_V_TC_46/full/full/0/default.jpg

• For most collections, grabbing the URL ending in default.jpg should work

• Then, you can add the URL for the single leaf to the Canvas Metadata as you create a new manifest in http://iiif.bodleian.ox.ac.uk/manifest-editor

IIIF-ifying and Mirador-ing Your Images: A Step-by-step Guide

Ben and Lisa’s Four-Step (well actually there are 30) Method for IIIF-ing and Mirador-ing your favorite manuscript image(s), if they’re online JPGs that aren’t already IIIFed:

1. IIIF your image

   1. Open in browser: http://iiif.archivelab.org/iiif/url2iiif?url= + your JPG URL (e.g. http://iiif.archivelab.org/iiif/url2iiif?url=https://cdn.ymaws.com/www.medievalacademy.org/resource/resmgr/Images/LFD/Minnesota_Ege_15v.jpg). Be patient.

   2. Copy the resulting URL.

2. Create your manifest

   1. Open the Bodleian IIIF Editor: iiif.bodleian.ox.ac.uk/manifest-editor/

   2. Create a new manifest

   3. Add canvas(es) and image(s) to the manifest

      1. Click “Add canvas”

      2. Click on the new canvas

      3. Open Canvas Metadata

      4. Click “Add image to canvas”

      5. Select “From info json”

      6. Paste the URL from step 1.b + /info.json (e.g. http://iiif.archivelab.org/iiif/url2iiif$33f0508b690c5e9bf491e689319c0b9b2d7b46f8bd8f4b65854fa2e83cf475b9/info.json)

      7. Repeat 1.a - 2.vi as necessary until your manifest is done

      8. Rearrange images as necessary using drag-and-drop

      9. Optional but probably a good idea: label canvases with shelfmarks, folio numbers, etc.

   4. Save and name your manifest

      1. Don’t forget to edit the manifest label before you save!

   5. Open your manifest (it should automatically open into a text editor)

   6. Copy the entire manifest (don’t forget to include the curly brackets!)

3. Create your gist

   1. Open https://gist.github.com/

   2. Name your gist (something.json)

   3. Paste the manifest that you copied in step 2.f into the gist editor

   4. Click “Create secret gist”

   5. Fix that thing that needs fixing

      1. Click “raw”

      2. Copy the resulting URL

      3. Go back (hit the back arrow on your browser to go back one screen)

      4. Click edit

      5. Paste the URL in the second line, replacing everything in quotation marks

      6. Click “Update secret gist”

4. Add your shiny new manifest to Mirador

   1. Open your Mirador viewer

   2. Add a resource

   3. Paste the string that you copied in step 3.e.ii into the “Add new object from URL” box

   4. Click load

SUCCESS! Now do it again.

Here is a step-by-step guide to

Hosting Derivative Manifests

To make your derivative manifest compliant with linked data standards, you must do two more things: A) Put the file on the web (someplace), and

B) Modify the @id of the file to correspond to the URL of its new location.

Until reusable IIIF manifest repository software exists, this might be most easily done using the Gist service of Github:

1. Create a Github account if you don't already have one.

2. Go to https://gist.github.com/ and create a new gist.

3. Cut-and-paste (or upload) the manifest file.

4. Call the filename manifest.json (or another filename that ends with manifest.json and has no spaces)

5. Click “Create a Public Gist” to save the file.

6. From the human-readable view of the file, you should have the options “edit” and “raw”.

7. Click the “raw” button to see the file by itself in machine-readable form. Copy the URL of that page. That URL is the URL (or “IRI” in IIIF terms) of your derivative manifest.

8. Click your browser back button to return to the human-readable gist.

9. Click “edit” to edit the file within the gist website.

10. Replace the original manifest URL in the @id field with the URL you copied.

11. Save the updated gist.

12. Test that this works – copy the @id from the human-readable gist into your browser bar and verify that your browser shows you the machine-readable gist.

Now your derivative manifest is ready to use! You can open it in Mirador or the Universal Viewer to make sure everything is working well, and that you only see the pages you care about for your edition. If you return to https://gist.github.com/, you should see all your derivative manifests under “My Gists”.

Configuring Mirador

• See an example with multi-up windows and different canvases: http://dms-data.stanford.edu/data/m22/index_chaucer.html

  • Note - change layout and change windows objects

  • See developer view for the underlying html

Creating Manifests

• How do you create manifests? There are a number of tools out there - the following links might be of use: https://github.com/IIIF/awesome-iiif#presentation-manifest-tools