Skip to content
This repository has been archived by the owner on Feb 8, 2023. It is now read-only.

IIIF Viewers with IPFS #240

Open
daviddias opened this issue Apr 15, 2017 · 67 comments
Open

IIIF Viewers with IPFS #240

daviddias opened this issue Apr 15, 2017 · 67 comments
Labels
Candidate Dev RFP

Comments

@daviddias
Copy link
Member

daviddias commented Apr 15, 2017 •
edited
Loading

IIIF (International Image Interoperability Framework) is hosting a conference at the Vatican on June 5-9. We (@diasdavid and @flyingzumwalt) will be present at that conference to talk about the benefits of using decentralized Web technologies that institutions like IIIF can benefit from.

We will be collaborating with @edsilv and @aeschylus to prepare a demo to showcase at the conference, of both Mirador and UniversalViewer using IPFS to exchange and update annotations made on the images. This issue will be used to coordinate this effort as a main central hub.

Mirador and UniversalViewer are both viewers of IIIF data that follow IIIF defined data model, they are created by independent researchers, but there is a lot of collaboration and idea sharing.

From the design thinking we've done, we know that we need:

  • A way to propagate changes on the Annotation List
  • A way to synchronize the state of the Annotation List for each document.

This converts into roughly the following milestones:

  1. Mechanism to propagate changes on the annotation list (this can be using libp2p pubsub directly)
  2. Synchronize the Annotation list through IPFS directly (using orbit-db or another CRDT library that is mounted on top of IPFS
  3. Load the entire collection of images into the viewer through IPFS itself
  4. Load and run the entire viewer using only js-ipfs, requiring no plugins installed.

This suggested that we just need to create primitives for get and put with the ability to follow changes or updated in a document, once that part is done, it can be fully integrated.

Other important pieces of context:
@daviddias
Copy link
Member Author

alright, just had a good chat with @pgte on this endeavor, he is in!

To move forward:

  • @edsilv and @aeschylus, could you provide current Annotation List examples, changes, updates and so on.
  • There is a lot of room to explore here, but I feel that the milestones described above are the best to start with, let me know if you feel something should be added from the start.
  • We should set a weekly standup to make sure this demo is progressing and needs are met. @edsilv, @aeschylus, @flyingzumwalt would you be available to do this? I can set up a Doodle.

Let's try to all meet this week :)

@edsilv
Copy link

edsilv commented Apr 17, 2017 •
edited
Loading

Great! Here's an example of an AnnotationList:

https://wellcomelibrary.org/annoservices/search/b18035723?q=gene

(http://iiif.io/model/shared-canvas/1.0/#AnnotationList)

This is the format Mirador uses to store annotations and the UV uses to display search results.

This will eventually be replaced with the Web Annotation Data Model as part of IIIF Presentation API 3.0, but this is still some way off:

IIIF/api#496

(https://www.w3.org/TR/annotation-model/#annotation-collection)

Milestone 3 states that the images should be loaded over IPFS. Currently we only have this very simple fully-IPFS-enabled IIIF manifest: http://universalviewer.io/examples/?manifest=https%3A%2F%2Fipfs.io%2Fipfs%2FQmYomyCpT1vKNovYvTjAStYq31JoaH8xdivjmWcDj5mpM1

Milestone 4 would require some work from @aeschylus to port Mirador to be able to be loaded over IPFS. Currently the UV can be loaded using the ipfs.io gateway. Are you suggesting that we bypass the gateway and use js-ipfs to load all of the viewer assets?

Perhaps in order to keep things manageable initially we could focus on enabling serverless communication between the viewers over js-ipfs, with the viewers themselves and IIIF manifests being loaded over HTTP. We could then move on to fully IPFS-ifying the viewers and IIIF manifests + assets?

I need to complete the work that will allow me to update the UV search results programmatically as opposed to on user interaction. This will be necessary to be able to respond to the IPFS annotation endpoint. I'm working on giving the UV an external API and expect this to be ready in the next few weeks.

We will also need to be able to specify the annotation endpoint to subscribe to somehow when starting the viewers. Perhaps a text field that we paste the name of the endpoint into?

A weekly standup sounds good!

@edsilv
Copy link

edsilv commented Apr 18, 2017

At the bottom of https://wellcomelibrary.org/annoservices/search/b18035723?q=gene you'll see a hits array. This is extra data to provide context to search results. We don't need to worry about this as the UV doesn't require it.

@daviddias
Copy link
Member Author

Let's find the time for that weekly standup

@edsilv @pgte @flyingzumwalt @aeschylus please fill: https://doodle.com/poll/bqpzs9xxzfde25pc

Everyone else is welcome to add their availability if they are interested in actively participating in this endeavor, otherwise, we will have to favor the schedule of the people contributing. Thank you :)

@daviddias
Copy link
Member Author

\o/ woot, we have a schedule! :)

Every friday at:

image

Zoom URL is: https://zoom.us/j/131133322

@aeschylus
Copy link

aeschylus commented Apr 20, 2017 •
edited
Loading

Great!

I'll look forward to speaking to everyone on the 28th. For reference, here is the link to a fork of orbitdb we've made where the main example has been tossed up to work as a textarea.

https://github.com/viewdir/orbit-db/tree/initial-hacking

More context is in orbitdb/orbitdb#213, noted above.

@flyingzumwalt
Copy link

Standup Friday April 21

Agenda

  • Welcome
  • Round of Intros
  • Define target for next week

Misc:

Recent Article about using pubsub on IPFS

Notes

There are 2 main vierwers in the IIIF space

  • Mirador (Stanford, Mellon-funded), which is more of a scholarly workbench and a tool for authoring annotations.
  • Universal Viewer, aka "UV"(Wellcome Trust, British Library) - more of a generic viewer for many data formats (Image, PDF, Video, 3D objects...)

Main IIIF APIs:

  • Images api - way to display images from an image service
  • Presentation api - way of listing canvases (ie. a series of pages)

Other Apis: search, annotation, etc.

  • new annotations API will use the WebAnnotations Model (w3c spec)
    • lets you create AnnotationList objects

The Demo: Serverless IIIF Image Annotations

  • mirador producing annotations, writing them ot IPFS & UV showing those annotations -- completely serverless collaborative editing of the annotations

Work Done so Far

Drew and Ed got a basic version of UV running on orbit-db. they got it working but ran into troubles with orbit and confusion about what they should do

Questions:

  • Will the IPFS daemon run in the browser? Will people have to run a go-ipfs daemon in order to use IPFS pubsub?
    • 2 attempts: one in november 2016 with @dignifiedquire. Then again in March 2017 using the latest orbit-db (hoping that they would be able to to pure js implementation)

Q: can we use js-ipfs?
A: you can use either. go-ipfs has some features that js-ipfs doesn't have

Current Work

NEED for demo:
Easy way for everyone in the room to get the demo code, including a working IPFS node

  • needs ipfs-download.js, or something similar

Theatrics of the demo:

  • everyone downloading ipfs binaries over HTTP will be slow
  • everyone downloading IIIF tiles over HTTP will be slow
  • everyone downloading IIIF tiles over IPFS ifs they have ipfs running will (should?) be much faster

Where the work will happen:

  • @pgte will create a repo for this annotations-pubsub work in github.com/pgte/ ... we might create an "ipfs-labs" github org for this kind of work to live
  • the first-pass version of this demo only relies on ipfs, which includes ipfs-pubsub. it doesn't need CRDTs, so doesn't need orbit-db
  • if we have time before the demo, we will add CRDT support.

Action Items:

  • figure out what the annotations pubsub API should look like
  • get basic annotations on pubsub working in both viewers
    • updates are the whole blob of annotations (refresh the whole list on every change)
  • prepare the theatrics of the demo
  • Add CRDTs (deal with chronological order of annotations with many editors)

What Ed & Drew need:

  • (pubsub consumer) a way for mirador & UV to listen for an event telling you that something has changed
  • (pubsub producer) a way to send updates when you have changed something
  • a way to declare a pubsub topic/channel and subscribe to it

@pgte
Copy link

pgte commented Apr 21, 2017

Created repo, can move it later to org: https://github.com/pgte/ipfs-iiif-annotations

@flyingzumwalt flyingzumwalt mentioned this issue Apr 26, 2017
Closed
@edsilv
Copy link

edsilv commented Apr 28, 2017

Here's the event on sched: https://2017iiifconferencethevatican.sched.com/event/AChW/presentation-interoperable-peer-to-peer-research-with-iiif-and-ipfs-room-5

@daviddias
Copy link
Member Author

daviddias commented Apr 28, 2017 •
edited
Loading

Standup Friday April 28

Agenda

  • Standup

Notes

Video: it is being rendered and uploaded

@edsilv
Copy link

edsilv commented Apr 28, 2017 •
edited
Loading

Some more notes from the 28/04/17 standup:

We are currently using the Open Annotation spec which is what the UV and Mirador both support and is perfect for an MVP. However, IIIF will use the Web Annotation Data Model in future. This has support for AnnotationPages which would allow us to break up the data into more manageable chunks instead of a single large json blob.

It also supports agents which would allow us to identify and filter by user.

The model uses IRIs for ids, which means fs:/ipfs/<hash> is a valid identifier if we want to permit content addressing.

Also worth noting that AnnotationPages are based upon Activity Streams Collections. Activity Streams is a more generic specification and can be applied to many other types of actions.

Create a front end test harness? Use Jest: https://facebook.github.io/jest/

@daviddias
Copy link
Member Author

@pgte has finished the first milestone, you can see it here: ipfs-shipyard/ipfs-iiif-db#1 (comment)

@edsilv @aeschylus can I get your ack? The example includes a demo video

@edsilv
Copy link

edsilv commented May 5, 2017 via email

@aeschylus
Copy link

Having a look now and getting our example put up.

@edsilv
Copy link

edsilv commented May 5, 2017

@flyingzumwalt @diasdavid Here's the designer/illustrator I mentioned: http://whitevinyldesign.com
I worked with Luke on https://blokdust.com

@edsilv
Copy link

edsilv commented May 5, 2017

Also, here's the go-iiif lib: https://github.com/thisisaaronland/go-iiif#iiif-tile-seed

@daviddias
Copy link
Member Author

daviddias commented May 6, 2017 •
edited
Loading

Standup Friday May 5

Agenda

  • standup: updates from everyone
  • first milestone finished - get+put primitives are done, propagates data
  • validate the api - can we build on the interface
  • set up next milestone
  • generating tiles

Notes

First milestone finished - get + put

  • doesn't use CRDTs but supports basic pubsub for propagation of changes

drew:

  • created IPFS experiments repo in IIIF github
  • how will we serve the code? npm link from github? publish on npm?
    • npm link locally and then browserify
  • seems to have everything we need
  • future feature: would be nice to be able to look back in history
    • A: there will be a proper CRDT structure to show log
      pedro:
  • done with 1st iteration of the library. nothing IIIF specific, just a JSON blob going back & forth
  • next: CRDTs and make the libary better at handling concurrency
    ed:
  • working on UV for stanford
    • plays into what we need for the demo, smoothing off rough edges around supporting IIIF v3

Validating the API

  • looks right. next validation: actually build the demo with it
  • how does it find peers?
    • one way nodes find peers: auto-discover using WebRTC signaling
    • another way: websockets, using a preconfigured bootstrap list
      • we will probably use this for the demo so the nodes connect with peers that have the IIIF data loaded

What about preservation? Can we set up a listener node that's archiving the annotations?

  • yes. we can create a listener node that listens to the topic an pins all of the annotations on that topic

every time someone makes an annotation, the annotation goes on IPFS and the node publishes a link to that annotation on the pubsub topic. There is not a global log for all annoations

Next Milestone:

Drew: get mirador using pedro's new pubsub library, using browserify version. would like to also incorporate into electron version of mirador
Ed: integrate into UV
Pedro: support Ed + Drew, integrate proper CRDT-based log
Matt: think about structure of demo, theatrics and visuals/illustrations

Next Next Milestone:

Add in CRDTs: Swap out swarmjs or yjs in place of current simple pubsub library

@daviddias
Copy link
Member Author

daviddias commented May 6, 2017 •
edited
Loading

I've created a roadmap to help us have a notion of time we have left and the sync the things we have planned for each week. I'll keep updating this roadmap as things progress and we set new goals. Right now it clearly lists the goals for this week and how much time we have till the conf.

ROADMAP

Here is a generated ROADMAP with what we have planned so far to help us be on the same page.

Week May 8

  • publish iiif-db to npm
  • Integrate Mirador with iiif-db
  • Integrate Universal Viewer with iiif-db
  • sync annotations with both viewers
  • upgrade iiif-db to support custom IPFS configs
  • upgrade iiif-db to support switching between go-ipfs and js-ipfs nodes (see how it is done in js-ipfs tests)
  • create two branchs of iiif-db, one using swarmjs, other using yjs offering the same API
  • create an outline of the demo + presentation
  • add namespace support (extra channel) to support pinning.

Week May 15

  • (@aeschylus) - Implementing endpoint for Mirador
  • (@flyingzumwalt) - Design the final demo and write an outline for it
  • (@pgte + @edsilv ) Figure out how to shard the annotations list
  • (@pgte) pick one of the CRDT libraries and invest the time of changing its internals to use js-ipfs directly

Week May 22

Week May 29

Week May 5

  • The conference

@edsilv edsilv mentioned this issue May 6, 2017
Open
@pgte
Copy link

pgte commented May 8, 2017

Published on NPM: https://www.npmjs.com/package/ipfs-iiif-db

@pgte
Copy link

pgte commented May 8, 2017

  • Support custom IPFS configs
  • Released ipfs-iiif-db v0.1.0.

@daviddias
Copy link
Member Author

How is the integration going @aeschylus @edsilv ? Need any help?

@edsilv
Copy link

edsilv commented May 9, 2017 via email

@pgte
Copy link

pgte commented May 10, 2017 •
edited
Loading

Hi Ed,

The bundle node_modules/ipfs-iiif-annotations/examples/simple-producer-consumer/public/js/app.js is specific to that example. Instead, I guess you could try to somehow use the library from within the app:

  1. If you're going to use a bundler like browserify or webpack, you could use it like a node.js or an ES6 module from inside your app.
  2. Alternatively, the ipfs-iiif-db library could provide a bundle that you could include on a script tag.

Which pattern(s) suits your needs?

@edsilv
Copy link

edsilv commented May 10, 2017 via email

@pgte
Copy link

pgte commented May 10, 2017

@edsilv :
Just published version 0.2.0, which now includes a packaged dist.

Here are the instructions for dropping in a script tag:
https://github.com/pgte/ipfs-iiif-db/tree/master#using-a-script-tag-in-a-browser

@edsilv
Copy link

edsilv commented May 10, 2017 •
edited
Loading

@pgte I've updated https://github.com/viewdir/ipfs-experiments to use the unpkg.com script instead. mirador.html has a button that submits the contents of a textfield and this is console.logged in uv.html. So the plumbing works :-)

@edsilv
Copy link

edsilv commented May 12, 2017

Hey, preservation didn't get mentioned on the standup. We should aim to make it trivially easy to have your ipfs node "watch" a topic and pin new annotations. Perhaps ipfs-iiif-db could have a cli like ipfs-iiif-db watch mytopic ?

@pgte
Copy link

pgte commented May 13, 2017

@edsilv I think that's a great idea. @diasdavid?

@pgte
Copy link

pgte commented May 18, 2017 •
edited
Loading

@edsilv we can generate any kind of id if it's not defined, and we could create a random one.
The first argument of the db.annotationList() is supposed to be an id, a unique identifier for that annotationList. Could be a URI, any string that has some identification meaning to you.

We can create an alternative API where the ID can (or not) be defined inside the originalValue, and if it's not defined, we create a random one. Something like:

db.annotationList({
    "@context": "http://iiif.io/api/search/0/context.json",
    "@id": "https://wellcomelibrary.org/annoservices/search/b18035723?q=gene",
    "@type": "sc:AnnotationList",
    "within": {
        "@type": "sc:Layer"
    },
    "startIndex": 0,
    "resources": []
})

(in this case we wouldn't create an id since it already has one).

Another option is to enforce an id.

Which API suites you best?

@edsilv
Copy link

edsilv commented May 19, 2017

@pgte Hmm, not sure. I think this is something we can discuss on the standup later.

@flyingzumwalt
Copy link

flyingzumwalt commented May 19, 2017 •
edited
Loading

Here's my outline for the demo. We can discuss + refine on today's call. It's in this hackpad

Same info in slide deck form (slightly outdated): Serverless IIIF with IPFS.pdf ... and here's the Keynote file

@daviddias daviddias mentioned this issue May 19, 2017
Closed
14 tasks
@pgte
Copy link

pgte commented May 20, 2017

New 2.1.0 version of the ipfs-iiif-db package just released.
Supports new semantics for the @id attribute of an annotationList and passing in only the id or the initial annotationList.
// @edsilv @aeschylus

@pgte
Copy link

pgte commented May 22, 2017

@edsilv @aeschylus just released version 2.2.0. Relevant changes:

  • code: If you're using the <script> tag, the URL has now changed.
  • store: You can now use "memory", "indexeddb" (browser only) or "leveldb" (node.js only, not relevant to your case) as local stores (see docs):
const db = DB({store: "indexeddb"})

(If you got confused by this store thing, it's ok. This store is the local store where to keep the intermediary CRDT values, it still uses IPFS to propagate the changes anyway.)

If you're going to start using the "indexeddb" store, make sure that you listen to the "started" event and take that opportunity to render the AnnotationList, since the local history is now relevant.

You can keep referring back to the example app, which is being kept up to date with the latest API changes:
https://github.com/pgte/ipfs-iiif-db/blob/master/examples/simple-producer-consumer/src/app.js#L36-L61

@pgte
Copy link

pgte commented May 22, 2017

Just completed and released a CLI tracker.

As proposed by @edsilv, I created a CLI tool that tracks a partition (defaults to "iiif"). Each node will repeatedly announce all known records, and this CLI tool will track it, participating on all CRDTs as an equal node, persisting the changes to a local LevelDB database.

CLI Docs here: https://github.com/pgte/ipfs-iiif-db#cli

@pgte
Copy link

pgte commented Jun 1, 2017 •
edited by daviddias
Loading

@flyingzumwalt instead of a CLI, we're going to use a web app (because WebRTC module is not yet stable on Node.js).
I've put together all the tools and CLIs we were talking about into one repo: https://github.com/pgte/ipfs-iiif-db-demo

The README should be self-explanatory, but ping me if you have any trouble.

@pgte
Copy link

pgte commented Jun 1, 2017

@flyingzumwalt quick demo: https://youtu.be/jg1qt0XpCmE

@pgte
Copy link

pgte commented Jun 1, 2017

@flyingzumwalt FYI, the annotationList id we're tracking on all parts of the demo is:

http://wellcomelibrary.org/iiif/b18035723/manifest#ipfs-iiif-db-example

@pgte
Copy link

pgte commented Jun 1, 2017

@flyingzumwalt also, if you want to try it out without NPM installing it, you can go to
http://pgte.github.io/ipfs-iiif-db-demo/public/

Also, I added this URL to the pgte/ipfs-iiif-db-demo README.

@pgte
Copy link

pgte commented Jun 2, 2017

@flyingzumwalt Here is a list of the ipfs-iiif-db demo applications (demo video here):

1. Mutator

  • User can add or remove a random annotation from the annotation list (using the add and remove buttons).
  • Tracks changes to the annotation list and prints the latest
  • Lists the connected peers

URLs:

2. Tracker

  • Tracks changes to all annotation lists in the 'iiif' partition
  • Lists the connected peers

URLs:

3. Auto Mutator

  • Every 2 seconds, adds a random annotation from the annotation list.
  • Tracks changes to the annotation list and prints the latest
  • Lists the connected peers

URLs:

@daviddias
Copy link
Member Author

daviddias commented Jul 4, 2017 •
edited
Loading

\o/ IIIF Annotations on IPFS was an astonishing success \o/

img_0183

@edsilv and @aeschylus demoing IIIF DB with Mirador and UV

img_0185

The room was packed

Thanks again to @aeschylus, @edsilv and @pgte for making it happen at the IIIF Conf at the Vatican and now at the IPFS All Hands, so that we have a recording to share with the rest of the community.

If you are interested in the demo, you can check it out at: https://youtu.be/hmAniA6g9D0?t=10m40s

I guess the question now is: "What's next?" :D

@edsilv
Copy link

edsilv commented Jul 4, 2017

Excited to work on more similar projects :-D

This is the other project I've been working on recently:

https://www.youtube.com/watch?v=itFJDsxI2xs&t=1s

At the end of the video you can see that the IIIF Collection the user is creating is being stored using js-ipfs.

We'd like to be able to track these collections as per ipfs-iiif-db. So if you're a gallery or museum hosting an exhibition, visitors can create and share their collections, and they are preserved by the host institution(s).

I think the ability to create IIIF Collections using CRDTs would be quite a generally useful thing. There is a lot of discussion in the IIIF community around discovery, and the ability to easily create and share collections could aid with this. For example, see https://github.com/ryanfb/iiif-universe which is a curated top-level 'collection of collections'.

The UV and Mirador also have their own separately stored collections of manifests to use as examples, e.g:

http://universalviewer.io/examples/

The drop down box under the UV is generated from a IIIF Collection.

It would be cool if it were trivial to generate these collections and have them preserved by interested parties. We could use https://github.com/viewdir/iiif-explorer-component to navigate them :-)

@pgte
Copy link

pgte commented Jul 4, 2017

@edsilv would be happy to collaborate in this project, a set of shared open collections backed by IPFS!

Right now the goal is to extract enough into a shared library that reduces ipfs-iiif-db to a set of declarative configuration parameters (the schema for the data structures, basically).
Right now it's a little more than a declaration of intents, but you can track it here:
https://github.com/ipfs-labs/ipfs-live-db

Once this is usable, supporting more IIIF data types should be extremely easy.

Do you have any time frame in mind?

@edsilv
Copy link

edsilv commented Jul 4, 2017 via email

@edsilv
Copy link

edsilv commented Jul 6, 2017 •
edited
Loading

Something we'll need to think about is how to do auth for creating new annotations/collection items/whatever.

In the HoloLens collections example I link to above, I'm thinking that users will get a unique anonymous session each time, and a link to their collection will be optionally emailed to them. Similar to the pattern we used when making blokdust.com where we delegated responsibility for identity to other platforms, and just dealt in unique public and anonymous URLs.

Currently our annotations system is using something akin to this model.

The IIIF Auth API is at version 1 right now: http://iiif.io/api/auth/1.0/#workflow-from-the-browser-client-perspective

This will be extended in future to permit "state changing operations", as well as just requesting data.

The pattern allows you to plug in any cookie and token service you like.

One of the use cases we discussed is allowing academic institutions to track annotations created by their own staff/students.

Once we start introducing user identities into the mix we need to start thinking about how to protect them.

Is there any prior art in the decentralised tech sphere that could be relevant?

@edsilv
Copy link

edsilv commented Jul 6, 2017

https://decentralized-identity.github.io/ ?

@victorb
Copy link
Member

victorb commented Jul 6, 2017

Two things that can be used as well:

@edsilv
Copy link

edsilv commented Jul 6, 2017

ConsenSys (uPort) is a member of DIF. Just watching this: https://www.youtube.com/watch?v=l5laRZfn8AI

I like what Ryan Shea (Blockstack) has to say about interoperability.

@edsilv
Copy link

edsilv commented Jul 6, 2017

Quite a rabbit hole! Just posting this here for reference: https://github.com/WebOfTrustInfo/rebooting-the-web-of-trust-spring2017/blob/master/topics-and-advance-readings/did-family-of-specifications.md

@daviddias
Copy link
Member Author

To everyone following this thread, check out the latest Tutorial published by @pgte on how to use PubSub to create Real-Time apps over IPFS

image

Full discussion here: libp2p/research-pubsub#18

@edsilv
Copy link

edsilv commented Jul 12, 2017

One thing that came up on the IIIF Software Devs call when discussing this is whether peers could index annotations for search as well as preserve them?

@daviddias daviddias mentioned this issue Jul 27, 2017
Open
@daviddias daviddias mentioned this issue Aug 28, 2017
Closed
@daviddias
Copy link
Member Author

Quick update that I think this crowd will be interested in! IPFS Station -- https://github.com/ipfs-shipyard/station -- just got a refresh by @hacdias, bug fixes, new features and a whole new look. One of the next requested features is to have a pane for simple file pinning ipfs/ipfs-desktop#518 which can make things like pin the IIIF annotations simpler :)

@edsilv
Copy link

edsilv commented Dec 5, 2017

Will give it a try!

In possibly related news I've been working on a static IIIF generator: https://github.com/edsilv/biiif/
I thought about trying to get it to generate IPFS hashes to use as id IRIs so everything can be resolvable over the IPFS network, but as we've seen before, this is difficult (impossible?) e.g.

{
  "id": "fs:/ipfs/<hash>/index.json",
  "type": "Collection",
  "label": "Bones",
  "members": [
     {
      "id": "fs:/ipfs/<hash>/vertebra/index.json",
      "type": "Manifest",
      "label": "Vertebra",
      "thumbnail": [
        {
          "id": "fs:/ipfs/<hash>/vertebra/thumb.jpg",
          "type": "Image"
        }
      ]
    }
  ]
}

In this example I'd initially leave a placeholder for the hash in the ids, hash the folder containing all of the index.jsons (IIIF manifests), thumbnails, objs etc, then add that hash to all of the index.json id placeholders. But this obviously then changes the hash :-)

It ultimately boils down to files not being able to contain their own hashes.

This doesn't prevent us however from only hashing the assets themselves (obj, jpg, mp4, etc) and referring to them by their hash in the regular json manifests - sort of a HTTP+IPFS hybrid.

@edsilv
Copy link

edsilv commented Dec 6, 2017

Ah, I forgot about IPNS. I guess you could publish an IPNS hash and use that as a mutable endpoint for your data? Just checking ipfs/js-ipfs#209 - can you do this from nodejs?

@edsilv
Copy link

edsilv commented Dec 14, 2017 •
edited
Loading

There's now a starter project for anyone who wants to build a IIIF-enabled website using the UV and biiif: https://github.com/UniversalViewer/uv-app-starter

I made a portfolio for @sophiedixon to test it here: https://sophiedixon.github.io/3d-portfolio/

In terms of IPFS, I'd love to add support to biiif as discussed above, but also to revisit the work @pgte did on ipfs-iiif-db to create a simple commenting system for these objects. We can use annotations with a "commenting" motivation for this: https://www.w3.org/TR/annotation-model/

This could later be extended to annotating specific regions of objects as opposed to the whole object.

I think wrapping this commenting system in a web component would be great too, enabling it to be used anywhere.

IPFS could also solve a big problem the IIIF Discovery group have run into regarding who should host a centralised index of all collections. My answer at the Toronto working group meeting was "everyone hosts it" :-)

Sign up for free to subscribe to this conversation on GitHub. Already have an account? Sign in.
Assignees
No one assigned
Labels
Candidate Dev RFP
Projects
None yet
Milestone
No milestone
Development

No branches or pull requests
8 participants
@BigBlueHat @pgte @jbenet @flyingzumwalt @aeschylus @victorb @daviddias @edsilv