IIIF Viewers with IPFS #240
Comments
|
alright, just had a good chat with @pgte on this endeavor, he is in! To move forward:
Let's try to all meet this week :) |
|
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: (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! |
|
At the bottom of https://wellcomelibrary.org/annoservices/search/b18035723?q=gene you'll see a |
|
Let's find the time for that weekly standup @edsilv @pgte @flyingzumwalt @aeschylus please fill: https://doodle.com/poll/bqpzs9xxzfde25pcEveryone 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 :) |
|
\o/ woot, we have a schedule! :) Every friday at:
Zoom URL is: https://zoom.us/j/131133322 |
|
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. |
Standup Friday April 21Agenda
Misc:Recent Article about using pubsub on IPFS Notes
There are 2 main vierwers in the IIIF space
Main IIIF APIs:
Other Apis: search, annotation, etc.
The Demo: Serverless IIIF Image Annotations
Work Done so FarDrew 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:
Q: can we use js-ipfs? Current WorkNEED for demo:
Theatrics of the demo:
Where the work will happen:
Action Items:
What Ed & Drew need:
|
|
Created repo, can move it later to org: https://github.com/pgte/ipfs-iiif-annotations |
Standup Friday April 28Agenda
Notes
Video: it is being rendered and uploaded |
|
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 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/ |
|
@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 |
|
Hey,
Looks great! I'll have a play with it before the standup :-)
…On 4 May 2017 8:23 pm, "David Dias" ***@***.***> wrote:
@pgte <https://github.com/pgte> has finished the first milestone, you can
see it here: ipfs-shipyard/ipfs-iiif-db#1 (comment)
<ipfs-shipyard/ipfs-iiif-db#1 (comment)>
@edsilv <https://github.com/edsilv> @aeschylus
<https://github.com/aeschylus> can I get your ack? The example includes a
demo video
—
You are receiving this because you were mentioned.
Reply to this email directly, view it on GitHub
<#240 (comment)>, or mute
the thread
<https://github.com/notifications/unsubscribe-auth/ABRceUwzHYN_O0C4eH6MkBWiJkysRO1aks5r2iWegaJpZM4M-UZr>
.
|
|
Having a look now and getting our example put up. |
|
@flyingzumwalt @diasdavid Here's the designer/illustrator I mentioned: http://whitevinyldesign.com |
|
Also, here's the go-iiif lib: https://github.com/thisisaaronland/go-iiif#iiif-tile-seed |
Standup Friday May 5Agenda
Notes
First milestone finished - get + put
drew:
Validating the API
What about preservation? Can we set up a listener node that's archiving the annotations?
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 Next Next Milestone:Add in CRDTs: Swap out swarmjs or yjs in place of current simple pubsub library |
ROADMAPHere is a generated ROADMAP with what we have planned so far to help us be on the same page. Week May 8
Week May 15
Week May 22Week May 29Week May 5
|
|
Published on NPM: https://www.npmjs.com/package/ipfs-iiif-db |
|
|
How is the integration going @aeschylus @edsilv ? Need any help? |
|
Hi David,
Here's the repo:
https://github.com/viewdir/ipfs-experiments
I've set up the UV page, but it isn't hooked up to ipfs-iiif-db yet.
UV, Mirador, and the contents of
ipfs-iiif-db/examples/simple-producer-consumer/public/js are being copied
out of node_modules on `npm start`.
I've included app.js in uv.html, but am getting `Bignumber is not a
constructor`. Not sure why as it seems to be the same setup as in the
example.
app.js contains some UI-specific code ($startButton, $stopButton, etc).
Presumably we'll need to include the same UI elements in mirador.html and
uv.html?
I'm going to be at this for the rest of the week:
https://www.rijksmuseum.nl/en/2and3dphotography
I might be able to get away on Friday though to look more at this and join
the standup.
…On 9 May 2017 10:57 pm, "David Dias" ***@***.***> wrote:
How is the integration going @aeschylus <https://github.com/aeschylus>
@edsilv <https://github.com/edsilv> ? Need any help?
—
You are receiving this because you were mentioned.
Reply to this email directly, view it on GitHub
<#240 (comment)>, or mute
the thread
<https://github.com/notifications/unsubscribe-auth/ABRceWQstYGmhSdxInllwKl6fbJH_Hmoks5r4NNSgaJpZM4M-UZr>
.
|
|
Hi Ed, The bundle
Which pattern(s) suits your needs? |
|
I think #2 (the script tag) would be great in terms of reducing the amount
of overhead required to getting something up and running.
I was thinking that perhaps we could create a http://svelte.technology
component at some point to wrap up any reusable code and UI.This could be
used as a custom element in your page and provide a nice interface with
inline attributes and events you could listen for. You could imagine having
a `topic` attribute and `onchanged` event. Also, optional start/stop IPFS
buttons.
It could be a drop-in way to 'ipfs-ify' your application. I have some
experience with svelte and could help with such an effort.
…On 10 May 2017 10:22 am, "Pedro Teixeira" ***@***.***> wrote:
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?
—
You are receiving this because you were mentioned.
Reply to this email directly, view it on GitHub
<#240 (comment)>, or mute
the thread
<https://github.com/notifications/unsubscribe-auth/ABRceRpAi2tGCn54hUmTJFLoaGU9zeVbks5r4XPYgaJpZM4M-UZr>
.
|
|
@edsilv : Here are the instructions for dropping in a script tag: |
|
@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 :-) |
|
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 |
|
@edsilv I think that's a great idea. @diasdavid? |
|
@edsilv we can generate any kind of id if it's not defined, and we could create a random one. 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? |
|
@pgte Hmm, not sure. I think this is something we can discuss on the standup later. |
|
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 |
|
New 2.1.0 version of the |
|
@edsilv @aeschylus just released version 2.2.0. Relevant changes:
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: |
|
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 |
|
@flyingzumwalt instead of a CLI, we're going to use a web app (because WebRTC module is not yet stable on Node.js). The README should be self-explanatory, but ping me if you have any trouble. |
|
@flyingzumwalt quick demo: https://youtu.be/jg1qt0XpCmE |
|
@flyingzumwalt FYI, the annotationList id we're tracking on all parts of the demo is: |
|
@flyingzumwalt also, if you want to try it out without NPM installing it, you can go to Also, I added this URL to the pgte/ipfs-iiif-db-demo README. |
|
@flyingzumwalt Here is a list of the ipfs-iiif-db demo applications (demo video here): 1. Mutator
URLs:
2. Tracker
URLs:
3. Auto Mutator
URLs: |
\o/ IIIF Annotations on IPFS was an astonishing success \o/
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 |
|
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 :-) |
|
@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). Once this is usable, supporting more IIIF data types should be extremely easy. Do you have any time frame in mind? |
|
Sounds great! I'm happy to start helping with this whenever you're ready :-)
…On 4 Jul 2017 3:05 pm, "Pedro Teixeira" ***@***.***> wrote:
@edsilv <https://github.com/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?
—
You are receiving this because you were mentioned.
Reply to this email directly, view it on GitHub
<#240 (comment)>, or mute
the thread
<https://github.com/notifications/unsubscribe-auth/ABRceQXNZNSADaPT6n1X8cbhD36I04PYks5sKji0gaJpZM4M-UZr>
.
|
|
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? |
|
Two things that can be used as well: |
|
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. |
|
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 |
|
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
Full discussion here: libp2p/research-pubsub#18 |
|
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? |
|
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 :) |
|
Will give it a try! In possibly related news I've been working on a static IIIF generator: https://github.com/edsilv/biiif/ In this example I'd initially leave a placeholder for the hash in the 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. |
|
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? |
|
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" :-) |
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:
Annotation ListAnnotation Listfor each document.This converts into roughly the following milestones:
Annotation listthrough IPFS directly (using orbit-db or another CRDT library that is mounted on top of IPFSThis 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:
The text was updated successfully, but these errors were encountered: