nodegoat Tutorials

Wer den einen schnellen Erfolg mit nodegoat sucht, sollte mit Tutorial Nr. 10 (oder Nr. 13) beginnen. Tutorial Nr. 10 zeigt, wie man ein grundlegendes und einfaches Datenmodell erstellt, Forschungsdaten (Schiffspositionen) eines Klimaprojektes importiert und auf einer Karte visualisiert. Ein kurzes Video (kein Ton, keine Kommentare) zeigt von Grund auf, wie es geht. Für das Tutorial benötigts du einen nodegoat-Account und den Testdatensatz, den ich auf dieser Website bereitstelle. Wenn du noch keinen Account hast, erkundige dich bei deiner Institution (z.B. Universität), ob diese nodegoat als digitales Werkzeug zur Verfügung stellt (zum Beispiel nodegoat GO, eine Multi-User-Plattform). Wenn du an der Phil.-Hist. Fakultät der Universität Bern studierst oder arbeitest, kannst du bei den DH einen nodegoat-Account erhalten:

https://www.dh.unibe.ch/dienstleistungen/nodegoat_go/domain_account_beantragen/index_ger.html

Optional kannst du einen Account für Studierende direkt bei nodegoat beantragen: https://nodegoat.net

1. Ein Projekt erstellen
2. Eine Visualisierung erstellen
3. Ein Datum erfassen
4. Ein unsicheres Datum erfassen
5. Geodaten importieren (CSV-Daten)
6. Eine Beziehung zwischen Objekten erstellen
7. Eine Klassifizierung (Classification, Category) für Objekte erstellen
8. Datenmodell erweitern: Person mit ‘Event Birth’.
9. Eine Hintergrundkarte ändern, mehrere Hintergrundkarten einbinden
10. Importiere Excel-Daten, die Geokoordinaten enthalten und visualisieren die Daten auf einer Karte
11. Für Fortgeschrittene: Import und Visualisierung von Open Data (CSV)
12. Datenmodell: Beobachtungen zu Objekten in Listenform anzeigen
13. Import von Linked Open Data aus Wikidata mit dem Import-Modul
14. Import von Linked Open Data aus Wikidata mit dem Modul für dynamischen Import
15. Punkte auf einer Karte einfärben und eine Legende dazu erstellen
16. Eine Fläche selber zeichnen (GeoJSON) und als Karte einbinden
17. Netzwerkanalyse von Korrespondenzen mit nodegoat
18. Texte von Transkribus in nodegoat importieren (Ingestion)
19. Texte mit einem Vokabular abgleichen (Reconciliation)
20. Ein nodegoat-Datenmodell mit dem CIDOC-Referenzmodell klassifizieren
21. Import eines Datenmodells für Korrespondenzen-Netzwerke mit der nodegoat-Schnittstelle (API)
22. Export eines Datenmodells mit der nodegoat-Schnittstelle (API)

 

1. Erste Schritte: Erstelle dein erstes Projekt in “Management” / füge Objekttypen in “Model” hinzu / füge Objektbeschreibungen in “Model” hinzu / aktiviere die Objekttypen in “Management” / arbeite mit den Objekttypen in “Data”

Wenn du ein neues Nodegoat-Konto hast, folge nach dem Login einfach den Anweisungen im Video, um dein erstes Projekt mit einem Objekt und zwei Objektbeschreibungen zu erstellen (die Videos haben keinen Ton, keine Kommentare, schaue einfach genau hin, was gemacht wird). Zusätzlich gibt es nach dem Einloggen Infotexte in Nodegoat, die zeigen, was man tun muss , um ein neues Projekt zu erstellen.

 

2. Eine Visualisierung erstellen: Geodaten (Koordinaten) müssen im Sub-Objekt eines Objekts erfasst werden. Erstelle ein Sub-Objekt “Location” für ein Objekt in “Model”.

In diesem Video wird gezeigt, wie wir ein Datenbankfeld im Sub-Objekt hinzufügen für unser erstes Objekt, das “First Object”. Dort kommen die Koordinaten hin. Locations werden also nicht als Objektbeschreibungen erfasst (so wie zum Beispiel der Name eines Objekts), sondern im Sub-Objekt. Im Video wird auch gezeigt, wie man die Koordinaten einer Location ändert.

 

3. Ein Datum erfassen: Datumsangaben müssen im Sub-Objekt eines Objekts erfasst werden

In diesem Video werden wir ein Datum für unser Objekt “First Object” erfassen. Zudem passen wir das Datenmodell in ‘Model’ an, um ein Start- und ein Enddatum (period) erfassen zu können. Wir können somit in nodegoat für jedes Objekt einen Zeitpunkt oder einen Zeitabschnitt erfassen, abhängig von unserem Datenmodell. Zusätzlich können wir auch unsichere Angaben zu einem Datum oder zu einem Zeitabschnitt erfassen. Dies wird im nächsten Video gezeigt. Achtung wegen des Formats, das in nodegoat so aussehen muss (mit Bindestrichen): 1-8-2020 (nicht mit Punkten 1.8.2020)

 

4. Ein unsicheres Datum erfassen in Chronology (im Sub-Objekt)

In diesem Video wird mit einem einfachen Beispiel gezeigt wie wir unsichere Datumsangaben dennoch erfassen können. Dies ist nur eine Möglichkeit. Es gibt viele andere, um unsichere Datumsangeben erfassen zu können, siehe dazu die Anleitungen zu nodegoat: https://nodegoat.net/guides (working with temporal data). Im Beispiel kennen wir das genaue Startdatum nicht und schätzen es auf 5 Tage nach dem Startdatum (1-8-2020). Wir erstellen dazu ein ‘statement: 5 days after begin start date’. Solche ungefähren Angaben werden also im Sub-Objekt im Bereich ‘Chronology’ erfasst (und nicht als ‘point’).

Wenn du mehr zum Umgang mit ungefähren, zeitlichen Angaben in nodegoat wissen willst, schaue dir auch diese Präsentation an von Pim van Bree and Geert Kessels (LAB1100), den Entwicklern von nodegoat.

 

5. Geodaten importieren (CSV Daten): Koordinaten werden im Sub-Objekt erfasst

In diesem Video werden ein Objekt “Locations” und verschiedene Beschreibungen zu diesem Objekt erstellt. Anschliessend importieren wir CSV-Beispieldaten in das Objekt. Die Beispieldaten enthalten Standorte (40k) mit geonames.org-IDs und Geokoordinaten: Location1.csv

Hinweis: In Nodegoat sind etwa 130k Orte von geonames.org vorinstalliert (Typ: City). Diese Orte können von allen Nutzern einer Installation gemeinschaftlich genutzt und erweitert werden. Auch Länder (Country) sind vorinstalliert und können so gemeinsam genutzt werden.

6. Eine Beziehung zwischen Objekten erstellen

In diesem Video stellen wir eine Beziehung zwischen dem “First Object” und den Locations her, um die Locations als Georeferenz für das Objekt zu verwenden. In ‘Model’ wählen wir “Locations” als Georeferenz im Sub-Objekt des “First Object”. In ‘Data’ geben wir einen Ort ein und sehen, dass er nicht sofort visualisiert wird, weil wir erst die visuellen Einstellungen richtig konfigurieren müssen (Auswahl von “Location” als Referenz für die Visualisierung in den Visualisation Settings der Werkzeugleiste). Zudem aktivieren wir im Datenmodell die Option ‘quick search’, damit wir im Lupenfeld (in Data) einfach nach einem Ort suchen können.

7. Eine Klassifizierung (Classification, Category) für Objekte erstellen

In diesem Video erstellen wir eine Klassifizierung “Attribute” im Datenmodell. Dann gehen wir zum “First Object” im Datenmodell und fügen eine Objektbeschreibung “Attribute” hinzu, die mit der erstellten Klassifizierung verknüpft ist.

8. Datenmodell erweitern: Person mit ‘Event Birth’.

In diesem Video ändern wir das “First Object” in “Person” und fügen eine Klassifizierung im Datenmodell hinzu: ‘Event (kind of)’. Diese Klassifizierung verlinken wir im Sub-Objekt von Person. Dann fügen wir das Ereignis “Birth” zum Sub-Objekt hinzu. Damit haben wir ein einfaches Modell, um biografische Daten zu erfassen. Wir können dieses Modell um andere Ereignisse (wie Tod, Aktivitäten usw.) erweitern . Im Sub-Objekt können wir zu jedem dieser Ereignisse Datumsangaben und Orte hinzufügen.

9. Eine Hintergrundkarte ändern

In Nodegoat können wir beliebige Hintergrundkarten einbinden. Voraussetzungen: die Karten müssen auf einem sogenannten ‘Tile Server’ vorhanden und per Link verfügbar sein. Wir benötigen also nur diesen Link zur Karte und können diesen in Nodegoat einsetzen. Aber wo finden wir solche Links? Zum Beispiel via Google. Oder hier, in dieser kurzen Anleitung. Gehe zu den Visualisierungseinstellungen (Visualisation Settings):

Dann zum Visual Settings-Reiter. Von dort gelangen Sie zu den Geographical Settings, wo wir Einstellungen für Karten vornehmen können.

Standardmässig ist hier die Karte von Google vorhanden. Entfernen sie den Link zur Google Karte und kopieren sie den neuen Link, den sie zu einer Karte auf einem Tile Server haben, in das Feld wie in der nachfolgenden Abbildung. Passen sie das Copyright zur Karte an.

Save your Map settings:

Ich habe hier einige Links zusammengestellt, die sie verwenden können, um andere Hintergrundkarten einzubinden. Die Länge der Links ist unterschiedlich, lassen sie sich dadurch nicht irritieren.

Google Map

//mt{s}.googleapis.com/vt?pb=!1m5!1m4!1i{z}!2i{x}!3i{y}!4i256!2m3!1e0!2sm!3i336008092!3m14!2sen-US!3sUS!5e18!12m1!1e47!12m3!1e37!2m1!1ssmartmaps!12m4!1e26!2m2!1sstyles!2zcy5lOmd8cC5jOiNmZmY1ZjVmNSxzLmU6bHxwLnY6b2ZmLHMuZTpsLml8cC52Om9mZixzLmU6bC50LmZ8cC5jOiNmZjYxNjE2MSxzLmU6bC50LnN8cC5jOiNmZmY1ZjVmNSxzLnQ6MXxzLmU6Z3xwLnY6b2ZmLHMudDoyMXxzLmU6bC50LmZ8cC5jOiNmZmJkYmRiZCxzLnQ6MjB8cC52Om9mZixzLnQ6MnxwLnY6b2ZmLHMudDoyfHMuZTpnfHAuYzojZmZlZWVlZWUscy50OjJ8cy5lOmwudC5mfHAuYzojZmY3NTc1NzUscy50OjQwfHMuZTpnfHAuYzojZmZlNWU1ZTUscy50OjQwfHMuZTpsLnQuZnxwLmM6I2ZmOWU5ZTllLHMudDozfHAudjpvZmYscy50OjN8cy5lOmd8cC5jOiNmZmZmZmZmZixzLnQ6M3xzLmU6bC5pfHAudjpvZmYscy50OjUwfHMuZTpsLnQuZnxwLmM6I2ZmNzU3NTc1LHMudDo0OXxzLmU6Z3xwLmM6I2ZmZGFkYWRhLHMudDo0OXxzLmU6bC50LmZ8cC5jOiNmZjYxNjE2MSxzLnQ6NTF8cy5lOmwudC5mfHAuYzojZmY5ZTllOWUscy50OjR8cC52Om9mZixzLnQ6NjV8cy5lOmd8cC5jOiNmZmU1ZTVlNSxzLnQ6NjZ8cy5lOmd8cC5jOiNmZmVlZWVlZSxzLnQ6NnxzLmU6Z3xwLmM6I2ZmYzljOWM5LHMudDo2fHMuZTpsLnQuZnxwLmM6I2ZmOWU5ZTll

Google Satellite Map (without places, topography)

https://mt{s}.google.com/vt/lyrs=s&x={x}&y={y}&z={z}

Hintergrundinformationen zu Google Maps: Der Standardlink für Google Maps-Kacheln sieht wie folgt aus:

https://mt.google.com/vt/lyrs=m&x={x}&y={y}&z={z}

If you want a different Google Map, just replace the letter in the URL at lyrs=

Will man eine andere Google Karte, muss man einfach den Buchstaben in der URL ersetzen bei lyrs=

Zum Beispiel: lyrs=m (dies zeigt die Standard Google Karte an)

Der ganze Link sieht dann so aus:

https://mt.google.com/vt/lyrs=m&x={x}&y={y}&z={z}

Mit diesen Buchstaben kannst du die Karte ändern:

h: shows only roads

m: is the standard roadmap

p: shows the terrain

r: is another roadmap

s: shows the satellit view

t: shows only the terrrain

y: is a hybrid map with terrain and roads

 

Graue Karte ohne Orte (nützlich für Datenvisualisierungen)

//mt{s}.googleapis.com/vt?pb=!1m5!1m4!1i{z}!2i{x}!3i{y}!4i256!2m3!1e0!2sm!3i336008092!3m14!2sen-US!3sUS!5e18!12m1!1e47!12m3!1e37!2m1!1ssmartmaps!12m4!1e26!2m2!1sstyles!2zcy5lOmd8cC5jOiNmZmY1ZjVmNSxzLmU6bHxwLnY6b2ZmLHMuZTpsLml8cC52Om9mZixzLmU6bC50LmZ8cC5jOiNmZjYxNjE2MSxzLmU6bC50LnN8cC5jOiNmZmY1ZjVmNSxzLnQ6MXxzLmU6Z3xwLnY6b2ZmLHMudDoyMXxzLmU6bC50LmZ8cC5jOiNmZmJkYmRiZCxzLnQ6MjB8cC52Om9mZixzLnQ6MnxwLnY6b2ZmLHMudDoyfHMuZTpnfHAuYzojZmZlZWVlZWUscy50OjJ8cy5lOmwudC5mfHAuYzojZmY3NTc1NzUscy50OjQwfHMuZTpnfHAuYzojZmZlNWU1ZTUscy50OjQwfHMuZTpsLnQuZnxwLmM6I2ZmOWU5ZTllLHMudDozfHAudjpvZmYscy50OjN8cy5lOmd8cC5jOiNmZmZmZmZmZixzLnQ6M3xzLmU6bC5pfHAudjpvZmYscy50OjUwfHMuZTpsLnQuZnxwLmM6I2ZmNzU3NTc1LHMudDo0OXxzLmU6Z3xwLmM6I2ZmZGFkYWRhLHMudDo0OXxzLmU6bC50LmZ8cC5jOiNmZjYxNjE2MSxzLnQ6NTF8cy5lOmwudC5mfHAuYzojZmY5ZTllOWUscy50OjR8cC52Om9mZixzLnQ6NjV8cy5lOmd8cC5jOiNmZmU1ZTVlNSxzLnQ6NjZ8cy5lOmd8cC5jOiNmZmVlZWVlZSxzLnQ6NnxzLmU6Z3xwLmM6I2ZmYzljOWM5LHMudDo2fHMuZTpsLnQuZnxwLmM6I2ZmOWU5ZTll

Dieser Link erzeugt eine dunkle Karte. Nützlich, um Freunde zu beeindrucken…

http://mt{s}.googleapis.com/vt?pb=!1m5!1m4!1i{z}!2i{x}!3i{y}!4i256!2m3!1e0!2sm!3i323349059!3m14!2sen-US!3sUS!5e18!12m1!1e47!12m3!1e37!2m1!1ssmartmaps!12m4!1e26!2m2!1sstyles!2zcy50OjF8cC52Om9mZixzLnQ6MnxwLnY6b2ZmLHMudDozfHAudjpvZmYscy50OjR8cC52Om9mZixzLnQ6NnxzLmU6bHxwLnY6b2ZmLHMudDo1fHMuZTpsfHAudjpvZmYscy50OjgxfHAudjpvZmYscy50OjZ8cy5lOmd8cC5sOi0xMDAscy50OjgyfHAuczotMTAwfHAubDotODM!4e0

Visualisation of the immigration of new citizens (blue) to cities in Europe in the Middle Ages.

Abb. Zuzug von Neubürgern in mittelalterliche Städte in Europa

 

Digitaler Atlas zum Römischen Reich

https://dh.gu.se/tiles/imperium/{z}/{x}/{y}.png

Siehe zu diesem Projekt: https://dh.gu.se/dare/

Mit dem Service von allmaps.org könnt ihr individuelle Hintergrundkarten erstellen und in nodegoat einbinden:

Siehe dazu auch: https://nodegoat.net/blog.s/68/use-any-iiif-published-map-as-a-background-in-your-geographic-visualisations

  1. Bei https://www.iiifhosting.com/ das Bild der Hintergrundkarte hochladen. Dadurch bekommt ihr einen Link, den ihr anschliessend bei https://editor.allmaps.org/ einfügen und damit eure Karte georeferenzieren könnt.
  2. Zuerst müsst ihr euch bei https://www.iiifhosting.com/ einloggen, dann das Bild hochladen. Klickt auf das Bild, das generiert dann zum Beispiel so einen Link https://free.iiifhosting.com/iiif/9dd9edd2bcf9bab289d68935bf0bfec866eda7492507f0bbbc2731b9d3cc95e7/
  3. Achtung! Beim genannten Link müsst ihr am Ende Folgendes hinzufügen wegen dem JSON-Format:  /manifest.json
  4. Diesen JSON-Link fügt ihr anschliessend bei https://editor.allmaps.org/ ein und beginnt, eure Karte zu georeferenzieren.
  5. Wechselt den Tab und geht zu ‘Results’. Dort findet ihr den Link, den ihr in nodgegoat einfügen könnt (in den Visual Settings). Hier das Beispiel für einen solchen Link: https://allmaps.xyz/maps/55936f460a611a52/{z}/{x}/{y}.png

Mehrere Hintergrundkarten einbinden

Es können mehrere Hintergrundkarten als verschiedene Ebenen eingebunden werden. Siehe die Dokumentation für die Einstellungen und das Video für ein praktisches Beispiel. Im Video sind zudem selbst gezeichnete Karten (Flächen) zu sehen, die mit der Legende (Conditions) ein- und ausgeblendet werden können. Dies ist eine weitere Funktion, die man als Szenario erstellen und als „Kontext“ in die Visualisierung integrieren kann.

https://nodegoat.net/documentation.s/84/geographical#settings

 

 

10. Importiere Excel-Daten, die Geokoordinaten enthalten und visualisieren die Daten auf einer Karte

In diesem Tutorium stelle ich Testdaten mit Geokoordinaten zur Verfügung, die einfach importiert und visualisiert werden können. Das Resultat zeigt die Karte unten mit Positionen von Schiffen, die aus Logbüchern (18.-19. Jahrhundert) berechnet wurden. Die Daten sind besonders für die historische Klimaforschung interessant.

Voraussetzung ist, dass du ein nodegoat account (=nodegoat Forschungsumgebung) hast. Kläre zuerst ab, ob deine Bildungseinrichtung nodegoat als digitales Tool zur Verfügung stellt, zum Beispiel mit der Mehrbenutzer-Plattform nodegoat GO. Wenn du an der Phil.-Hist Fakultät der Universität Bern arbeitest, kannst du hier einen nodegoat GO account beantragen: https://forms.gle/Gjm4682EJLsq5TCR7. Ohne institutionelle Anbindung kannst du direkt bei nodegoat einen account beantragen: https://nodegoat.net/

Das folgende Video zeigt von Grund auf, wie wir Schritt für Schritt ein einfaches Datenmodell erstelln. Das Video hat keinen Ton und keine Kommentare. Es beginnt mit dem Login in deinen nodegoat account. Die nächsten Schritte: ein Projekt erstellen, ein Objekt erstellen und die von mir vorbereiteten Daten herunterladen, die du dann importieren und visualisieren kannst: data sample:

Wenn du eine schriftliche Anleitung bevorzugst, kannst du hier fortfahren. Diese Anleitung ist identisch mit dem Video, enthält aber einige Hintergrundinformationen.

Es wird zuerst gezeigt, wie du einen Identifikator deinen Daten hinzufügen kannst. Die Daten im vorbreiteten Datensample enhalten bereits einen Identifikator. Du kannst den nachfolgenden Schritt also auch überspringen und gleich das Datensample (dem ich bereits Identifikatoren hinzugefügt habe) herunterladen und mit dem Erstellen des Datenmodells beginnen.

Loggen Sie sich in Ihr nodegoat-Konto ein. Importieren Sie die CSV-Daten in Ihr bereits bestehendes Projekt oder erstellen Sie ein neues Projekt: ‘climate project’. Wir werden Daten (Beispieldaten) aus einem interessanten Projekt über Logbücher von Schiffen importieren, die für Wetterbeobachtungen wichtig sind. Hier ist die Website des Projekts, wo die Daten verfügbar sind:

https://www.historicalclimatology.com/cliwoc.htmlClimatological Database for the World’s Oceans (CLIWOC)

“The database consists of 287,114 logbooks written aboard Dutch, English, French, and Spanish sailing ships. The vast majority of these logbooks date from between 1750 and 1850, yet four ship logbooks were incorporated that predate 1750. These were centuries of European imperial expansion, and so the logbooks record the activities of sailors – both civilian and military – in oceans that span the entire globe.”

Ich habe folgende Daten heruntergeladen: ‘Download as an Open Office Spreadsheet’

Dann habe ich die Daten in einem Google Sheet (gleich wie Excel) geöffnet und zuerst eine weitere Spalte ganz links hinzugefügt, um für die Daten einen eindeutigen Identifikator (unique identifier) hinzuzufügen. Folgende Formel habe ich ins Feld A2 hinzugefügt, das den ersten Dateneintrag enthält:

In dieser Zelle anschliessend doppelklicken auf die rechte, untere Ecke, um die ganze Spalte automatisch mit weiteren Identifikatoren ausfüllen zu lassen. Eindeutige Identifikatoren sind sehr wichtig. Sie sind die Grundvoraussetzung für den Datenaustausch (Vernetzung von Forschungsdaten). Aber auch, um später Objekte aktualisieren zu können. Deshalb importieren ich immer zuerst die Identifikatoren in nodegoat und füge anschliessend, basierend auf den Identifikatoren, weitere Daten hinzu. Im Import-Modul von nodegoat kannst du wählen, ob du neue Objekte hinzufügen oder bestehende aktualisieren (update) willst.

In nodegoat kannst du 50k data records (rows) auf einmal importieren. Wenn du also 200k Objekte importieren willst, musst du mehrere CSV-Dateien erstellen, um die Daten aufzutrennen. Im Datensample, das ich erstellt habe, sind 20k records vorhanden, die du nun importieren kannst. Ich habe nur die wichtigsten Objekte ins Datensample aufgenommen: Identifier, ship name, year, longitude and latitude. Du kannst das Datensample hier herunterladen:

Climate project test data for nodegoat (CSV)

Dein Datenmodell in Model sollte für diese Daten folgendermassen aussehen mit einem Objekttypen ‘climate project’:

Füge diesem Objekttypen ein Sub-Objekt ‘year + coordinates’ hinzu, gehe dazu zum Reiter ‘Sub-Object’:

Wir werden die Daten via Webinterface importieren durch manuellels Hochladen. Du kannst Daten in nodegoat auch dynamisch importieren oder mit der Kommandozeile via JSON-Schnittstelle (API) mit einem individuell von dir erstellten Skript.

Für das Hochladen des Datensamples gehen wir folgendermassen vor. Wir gehen zu Model > Import > CSV Files und laden dort das Datensample hoch (climate project test data).

Hintergrundinfo: Um Daten in nodegoat via Webinterface importieren zu können, müssen sie im Format UTF8 vorliegen. In Excel zum Beispiel kann man seine Daten im CSV-UTF8 abspeichern. CSV steht für kommagetrennte Werte. Wenn du eine solche CSV-Datei öffnest (zum Beispiel mit einem einfachen Textprogramm), siehst du die Werte, die mit Kommas voneinander getrennt sind.

Vom Reiter CSV Files wechselst du nach dem Hochladen zum Reiter Import Template. Mit dem Template erstellst du ein Datenmapping für den Import. Das heisst: du legst fest, welche Daten aus deinem CSV-File in welche Datenbankfelder deines Datenmodells importiert werden sollen. Für das year (YR), wähle das Datenbankfeld Date Start in deinem Datenmodell.

Nach dem Speichern des Templates kannst du rechts auf das grüne Icon ‘run’ klicken und den Datenimport starten. Es werden dir sogleich ein paar Beispiel für dein Datenmapping gezeigt, damit du nochmals prüfen kannst, ob die Zuweisungen korrekt sind. Starte nun den Import für die 20k Daten.

Nun kannst du dir einen Kaffee gönnen, da du heute schon viel erreicht hast.

Gehe nach dem Import auf ‘Geografical Visualisation’, um die Daten auf der Karte zu visualisieren.

So sollte die Visualisierung, das Ergebnis deines Datenimports, aussehen. Spiele ein wenig rum mit der Zoomfunktion (recht) und der Zeitleiste. Du wirst auch Schiffe in den Wüsten Afrikas finden auf der Karte. Dies sind fehlerhafte Koordinaten in den Ursprungsdaten des Forschungsprojekts, die nun mit einer solchen visuellen Datenexploration einfach entdeckt und korrigiert werden könne.

Du kannst die Punkte auf der Kart auch kleiner darstellen. Im Reiter, wo sich die Geographical Visualisation’ befindet, gehst du rechts davon auf die ‘Visual Settings’ und dann gleich nochmal darauf. Speichere deine Angaben, hier Grösse 3, und visualisiere die Daten nochmals auf der Karte, siehe dazu auch das Video.

Du könntest nun, basierend auf den Identifikatoren, deine Daten beliebig mit dem Importvorgang updaten. Wähle dazu im Import-Modul ‘Update Existing Objects’ und wähle den Identifikator, um die entsprechenden Objekte mit einem weiteren Datenmapping zu aktualisieren.

 

11. Für Fortgeschrittene: Import und Visualisierung von Open Data (CSV)

Benjamin West: Benjamin Franklin Drawing Electricity from the Sky

Benjamin West (1738-1820): Benjamin Franklin Drawing Electricity from the Sky, Philadelphia Museum of Art, image Source: Public domain, via Wikimedia Commons

1743 wurde die American Philosophical Society (APS) – die älteste gelehrte Gesellschaft in den USA – in Philadelphia von Benjamin Franklin, John Bartram, Francis Hopkinson und anderen mit dem Ziel gegründet, “nützliches Wissen zu fördern”, wie auf der APS Website nachzulesen ist. Heute verfolgt die APS eine Open-Data-Strategie, die Forscher dazu ermutigt, die unter einer Creative Commons Attribution 4.0 Lizenz bereitgestellten offenen Datensätze zu nutzen und wiederzuverwenden. In diesem Tutorial werden wir solche Daten in nodegoat importieren und visualisieren. Die Daten werden wie folgt zitiert: Heider, Cynthia, Bayard Miller and Scott Ziegler. Post Office Book, 1748-1752. BF85f6-8. Distributed by Philadelphia: American Philosophical Society Library & Museum, 2017. https://diglib.amphilsoc.org/islandora/object/compound:11.

Franklin war nicht nur der Gründer der Gesellschaft, er wurde 1737 auch Postmeister von Philadelphia. Für die anschliessende Zeit sind Aufzeichnungen von Briefen vorhanden, die in der APS-Bibliothek archiviert und als Open Data zur Verfügung gestellt werden, wie wir auf der APS-Website erfahren:

“Benjamin Franklin’s Post Office Records: Post Office Book, Philadelphia incoming and outgoing mail, 1748-1752. Created while Benjamin Franklin served as Postmaster of Philadelphia, these datasets reveal a wealth of previously untapped information about colonial correspondence.” (Source: APS website).

Im folgenden Tutorial werden wir nur die ausgehenden Briefe des Postamtes in Philadelphia in nodegoat importieren. Für das Tutorial gibt es drei Videos, die das Vorgehen von Grund auf zeigen. Die Videos haben keinen Ton und keine Kommentare. Voraussetzungen: Du hast einen nodegoat-Account und Google Sheets (oder Excel).

Die Herausforderung in Video 1 besteht darin, die Daten für den Import in nodegoat neu zu formatieren und das amerikanische Datumsformat in das europäische umzuwandeln. Ein zusätzlicher Ort (Philadelphia Post Office) wird zur Visualisierung hinzugefügt. Das Tutorial beginnt mit dem Download der Daten von der APS-Website:
https://diglib.amphilsoc.org/data

Video 1:

In Video 2 wird zunächst ein Datenmodell in nodegoat erstellt, das auf den Spaltennamen der Daten in Google Sheets basiert. Dann werden die Daten als CSV aus Google Sheets heruntergeladen und in nodegoat hochgeladen, die Datenfelder der CSV-Datei mit den Datenfeldern in nodegoat gemappt und der Importprozess gestartet. Während des Importvorgangs nimmt nodegoat automatisch Zuordnungen zu CSV-Daten vor, die akzeptiert oder abgelehnt werden können.

Video 2:

Video 3 zeigt, wie man mit den importierten Daten arbeitet. Zunächst wird eine Grundfunktion gezeigt: Wenn du nur ein Objekt in nodegoat auf einmal anklickst (es öffnet sich ein Fenster mit dem Objekt), wird nur dieses Objekt auf der Karte visualisiert (durch Klick auf das Globus-Symbol). Ruft man alle Objekte auf, z.B. durch Auswahl von “alle” rechts neben dem Filtersymbol (Screenshot unten) oder durch Blättern zwischen den Seiten (1,2,3 etc), werden alle Objekte visualisiert:

Wenn wir alle unsere Daten visualisieren, wie im Video, indem wir auf das Globus-Symbol klicken, werden die Orte, die wir zuvor während des Importprozesses zugewiesen haben, auf der Karte angezeigt. Nicht alle diese Orte sind korrekt verortet, da wir beim Import nicht geprüft haben, ob der Ort wirklich der richtige ist. Besser wäre es gewesen, wenn wir die Daten bereits VOR dem Datenimport in Google Sheets oder Excel bereinigt hätten, was immer zu empfehlen ist! Aber keine Sorge: Wir können die Daten auch nach dem Import noch bereinigen, wie ein Beispiel im Video zeigt. Das Video zeigt weiter, wie man ein Datenbankfeld ‘Kommentar’ zum Datenmodell hinzufügt und verwendet, z.B. wenn man angeben möchte, dass man sich über die Lage eines Ortes unsicher ist. Und das Video zeigt, wie man eine Filterabfrage erstellt, um Orte zu finden, die keine Geokoordinaten haben.

Video 3:

12. Datenmodell: Beobachtungen zu Objekten in Listenform anzeigen

Dieses Datenmodell, das hier in seinen Grundzügen dargestellt ist, funktioniert z.B. für:
Person (Objekt) – biographisches Ereignis (Beobachtung), d.h. für biographische Daten. Aber natürlich funktioniert es auch für andere Modelle, mit denen wir ein Objekt mit Beobachtungen genau beschreiben wollen. Es funktioniert somit für alle Arten von Objekten wie Bücher, Texte, Artefakte, Institutionen, Organisationen usw.

Mit den Beobachtungen (im Beispiel das “Ereignis”) kontextualisieren wir das Objekt in Zeit und Raum, indem wir diese Informationen im Sub-Objekt erfassen.

Beispiel:

In diesem Beispiel sehen wir die biografischen Ereignisse von Ludwig von Adlikon in einer Liste (mit grünen, blauen und roten Ereignissen). Oben sehen wir weitere Informationen zu ihm: Vorname, Nachname, Herkunft usw.

Wie sieht das Datenmodell in nodegoat aus? Es gibt zwei Objekte: Person und Ereignis. Im Beispiel sehen wir das Objekt ‘Person’. Die Ereignisse, die mit dieser Person zusammenhängen (und somit aufgelistet sind), werden im Objekt ‘Ereignis’ erfasst. So erstellen wir ein solches Datenmodell in nodegoat:

1) Im Bereich Model erstellen wir in nodegoat zwei Objekte: Person und Ereignis.

2) Im Sub-Objekt vom Ereignis erstellen wir eine Description ‘Person’, so wie hier:

Erstelle ein weiteres Sub-Objekt, so wie zuvor für ‘Person’, um Datum und Ort erfassen zu können. Wir nennen dieses Sub-Objekt Datum_Location. Nun können wir im Sub-Objekt ‘Person’ festlegen, dass Datum und Ort vom Sub-Objekts Datum_Location automatisch in das Sub-Objekt ‘Person’ übernommen werden sollen (wichtig für Visualisierungen und für die korrekte Speicherung der Daten im Allgemeinen). Bei Date wählen wir also Source und wählen die Felder wie folgt aus:

Und dies sind die Einstellung für Location. Schaue dir die Felder Reference und Source an und fülle sie entsprechend aus:

3) Im Bereich “Management” müssen wir im Objekt “Person” nun noch aktivieren, dass die Ereignisse in Listenform im Abschnitt “Daten” angezeigt werden: Management > das eigene Projekt wählen > Organise > Person > Cross-Referenced > Ereignis > Sub-Object Descriptions > Aktivieren Sie das Kontrollkästchen

Warum ist dieses Modell nützlich? Weil es die grundlegenden Prinzipen der Datenerhebung in den Geisteswissenschaften berücksichtigt: Beobachten und Beschreiben. Die Ereignisse in dem obigen Beispiel sind Beobachtungen zu biografischen Stationen. Stationen, die wir in Zeit und Raum verorten im Ereignis. Somit sind alle wichtigen Informationen darin enthalten: Person, Ereignis, Ort (Raum) und Zeit. Diese Informationen können wir nun sehr gut für Visualisierungen (Karten, Netzwerke, Zeitreihen) und Datenanalysen nutzen. Natürlich können wir dieses einfache Modell nun erweitern mit weiteren Beobachtungen und Informationen, oder auch ausbauen im Hinblick auf die Erfassung von Korrespondenzen.

13. Import von Linked Open Data aus Wikidata mit dem Import-Modul

In diesem Tutorial werden wir Daten aus Wikidata zu archäologischen Fundstellen in der Schweiz importieren und visualisieren. Die Idee zu diesem Tutorial kam mir durch ein interessantes studentisches Projekt an der Universität Bern zur Visualisierung von archäologischen Daten. Informationen zu diesem Projekt hier:

https://www.iaw.unibe.ch/forschung/bern_coda_lab/projects/student_projects/sparql_hs_2019/ssdi/index_ger.html

Dies ist jedoch nur eine Möglichkeit, Daten in nodegoat zu importieren. Im Tutorial Nr. 14 werden wir zeigen, wie wir dieselben Daten direkt (d.h. ohne Hochladen im Webbrowser) von Wikidata in nodegoat importieren können, indem wir das Modul zum dynamischen Datenimport verwenden.

Du kannst die folgende Datenabfrage von Wikidata auch überspringen und gleich die Daten dieser Abfrage hier herunterlanden, um direkt weiter zum Datenmodell zu gehen.

Mit der folgenden Datenabfrage suchen wir nach allen archäologischen Stätten in der Schweiz. Wir nutzen für die Datenabfrage den Query Service von Wikidata: https://query.wikidata.org

Gehe zur Datenabfrage mit diesem Link und führe sie aus:

Wir können das Ergebnis (über 1000 archäologische Stätten) als CSV-Daten herunterladen, d. h. als durch Kommata getrennte Werte. Diese CSV-Daten laden wir dann von unserem Computer über den Webbrowser in nodegoat hoch. Doch bevor wir die Daten für den Import hochladen können, müssen wir natürlich zunächst ein Projekt in nodegoat mit den gleichen Datenfeldern anlegen, die in den CSV-Daten für den Import vorhanden sind. In nodegoat müssten wir im Bereich ‘Management’ ein Projekt anlegen, das wir ‘Archeological sites’ nennen.

Nun wechseln wir in den Bereich “Model”, um die drei Datenfelder unseres Projekts zu erstellen und einen Objekttypen hinzuzufügen, der alle Daten enthalten wird. Wir passen die Datenfelder des Objekttyps an die CSV-Daten an, die die folgenden Kategorien enthalten: site, coord, siteLabel. Diese Kategorien (= Datenfelder) legen wir nun auch in unserem Objekttyp an, den wir “site” nennen. Wir verwenden site und siteLabel im Datenmodell für Beschreibungen dieses Objekts, während coord, d. h. die Geokoordinaten, in das Sub-Objekt dieses Objekts importiert werden, um die Daten visualisieren zu können.

Wir speichern unseren Objekttypen und gehen zurück zu “Management” und zu unserem Projekt (Archeological site), um den erstellten Objekttypen “site” in unserem Projekt unter “Model” zu aktivieren:

Nun laden wir die CSV-Datei via Webbrowser in nodegoat hoch:

Nach dem Hochladen erstellen wir ein Template für das Datenmapping. Im Template weisen wir also die Datenfelder der CSV-Datei den Datenbankfeldern in nodegoat zu.

Dann starten wir den Import indem wir auf ‘run’ klicken.

Nach dem Import visualisieren wir die Daten auf der Karte. Wir gehen in der Werkzeugleiste auf ‘Geographical Visualisation’.

Abb. Archäologische Stätten in der Schweiz (Daten von Wikidata)

Mit den Conditions in nodegoat können wir die Punkte auf der Karte unterschiedlich einfärben oder auch gewichten. Natürlich können wir nun in unserem Datenmodell weitere Felder und Informationen zu einer archäologischen Stätte hinzufügen und in der Karte darstellen.

Schließlich können wir die Daten wieder aus nodegoat exportieren und unsere Ergänzungen in Wikidata einpflegen. Ein ähnlicher Dienst wie Wikidata wird vom LOBID-Projekt angeboten, das viele sehr nützliche Daten bereitstellt. Von Wikidata, wie im nächsten Tutorial gezeigt wird, oder von LOBID können die Daten auch dynamisch in nodegoat importiert werden.

14. Import von Linked Open Data aus Wikidata mit dem Modul für dynamischen Import

Zuerst ein wichtiger Hinweis auf eine sehr nützliche Funktion zur Datenkonvertiertung (oder -bereinigung), die wir vor dem Import für jedes Datenbankfeld durchführen können. Konkretes Beispiel: eine Datenschnittstelle gibt die Wikidata-Nummer im folgenden Format aus: http://www.wikidata.org/entity/Q3324044. Wir möchten in nodegoat nun aber nur die Nummer ‘Q3324044’ importieren und den Rest weglassen. Dazu gehen wir zu Model > Linked Data > Conversions, legen dort eine neue Conversion an und tragen folgende Werte wie in der Abbildung in die Felder ein. Wir sehen, dass wir bei der URI einfach den vorderen Teil abschneiden und so nur die Nummer (Identifikator) importiert werden kann. Um das Ergebnis des Scipts zu sehen, klicken wir auf ‘test’.

Wo müssen wir diese Conversion hinzufügen, um sie anwenden zu können für den Import? Wir gehen zu Model > Linked Data und zu unserer Schnittstelle, die wir dort definiert haben. Unten bei den Zuweisungen der Datenbankfelder, die importiert werden sollen, können wir die Conversion hinzufügen (siehe Abbildung, wir haben die Conversion zuvor als ‘Convert URI to ID’ abgespeichert). Somit wird beim dynamischen Datenimport nur noch die Nummer importiert. Natürlich können auch Datumsformate oder alle anderen Werte, die ihr mit JavaScript umwandeln könnt, auf diese Weise importiert werden. Da JavaScript hierzu viele Möglichkeiten bietet, haben die Conversions grosses Potential.

Hier ein Beispiel für die Konvertierung eines Datumsformats:

Pro-Tip: falls die Daten aus der zu importierenden Datenquellen uneinheitlich sind (was eigentlich immer ein wenig der Fall ist), kann man zum Beispiel einen ‘doppelten Import’ durchführen. Zum Beispiel kann man Datumsangaben mit der Conversion vor dem Import bearbeiten und diese zugleich in das Datumsfeld in nodegoat importierten und zusätzlich als Text oder String in eine Object Description. Nach dem Import können die fehlerhaften Datumsangaben in der Object Description leicht herausgefiltert werden und so müssen wir nur noch diese bereinigen.

Weitere Informationen zu den Conversions hier: https://nodegoat.net/documentation.s/142/conversions

 

Hier beginnt nun das eigentliche Tutorial. Es baut auf Tutorial Nr. 13 auf. Wir importieren dieselben Daten wie in Tutorial 13, aber diesmal nicht durch Hochladen einer CSV-Datei über den Webbrowser, sondern direkt über die API-Schnittstelle von nodegoat mit dem Modul für den dynamischen Datenimport (dynamic data ingestion). Wir verwenden dasselbe Datenmodell wie in Tutorial Nr. 13.

Das dynamische Dateningestionsmodul wurde im Rahmen meines SNF SPARK-Projekts entwickelt. Informationen und Beispiele für die Anwendung des Moduls findest du hier.

Zuerst müssen wir das Modul für den dynamischen Datenimport in unserem Projekt aktivieren. Wir gehen zu “Management” und zum Projekt “Archeological site” > Projekt > Model > System > Ingestion

Für den dynamischen Datenimport müssen wir in unserer nodegoat-Umgebung zwei Dinge einrichten:

1) Linked Data Rescoure (Datenabruf über Schnittstelle)
2) Datenmapping (für den Import der Daten)

Wir gehen zu Model > Linked Data > Add Linked Data Resource

Hier definieren wir die Schnittstelle. In diesem Beispiel ein SPARQL-Endpunkt von Wikidata. Fülle die Felder wie folgt aus:

Now we add the same query that we already used in tutorial no. 13. You can find the query under this link. Click on ‘test’.

Jetzt fügen wir dieselbe Abfrage hinzu, die wir bereits im Tutorial Nr. 13 verwendet haben. Du findest die Abfrage unter diesem Link. . Klicke anschliessend auf “Test”.

Im Antwortfeld (Response) sehen wir das Ergebnis der Testabfrage. Klicke auf ‘use’, um die Daten von Wikidata in dein Datenmodell von nodegoat zu mappen.

Speichere die Linked Data Resource und gehe zu Data > Processes > Ingestion > Add Ingestion. Wähle als Source deine Linked Data Resource (Dynamic Data Ingestion). Target des Imports ist dein Objekt ‘site’. Weise die Datenfelder einander folgendermassen zu:

Speichere den ingestion process und klicke auf ‘run’. Das Ergebnis sieht so aus:

Klicke auf ‘Geographical Visualisation’.

Als Ergebnis wirst du diese Karte sehen mit allen archäologischen Stätten der Schweiz, die auf Wikidata hinterlegt sind.

Abb. Archäologischen Stätten in der Schweiz (Daten von Wikidata)

Der in diesem Tutorial vorgestellte Prozess des dynamischen Datenimports hat gezeigt, wie man eine Datensammlung zusammenstellen kann. Wir können diese Datensammlung nun mit einem weiteren Ingestion-Prozess anreichern, indem wir die Update-Funktion verwenden. Mit dieser Funktion können wir den gesamten oder einen Teil unseres Datenbestandes mit weiteren Daten anreichern, zum Beispiel von Wikidata oder LOBID, oder aus jeder anderen Datenquelle mit einer Datenausgabe im JSON-Format. Wir können unseren Datenbestand anschliessend etwa für die Netzwerkanalyse in nodegoat verwenden, wenn wir unser Datenmodell entsprechend vorbereitet haben.

Weitere Informationen zum dynamischen Datenimport findest du in der offiziellen Dokumentation von nodegoat und in diesem Blogbeitrag. Weitere Informationen und Beispiele findest du auch hier: SPARK Workshop on dynamic data ingestion.

15. Punkte auf einer Karte einfärben und eine Legend dazu erstellen

Dieses Tutorial baut auf den vorherigen Tutorials (13 und 14) auf. Es zeigt, wie wir Punkte (= Geopunkte) auf einer Karte einfärben und eine Farblegende erstellen können. Das beschriebene Verfahren kann generell auf Karten in nodegoat angewendet werden.
Zum Einfärben von Punkten und zum Erstellen einer Legende benötigen wir in nodegoat die sogenannten “Conditions”, die wir rechts oben in der Werkzeugleiste für die Visualisierungen finden. Mit den Conditions können wir gezielt festlegen, welche Punkte des Datenmodells wir in der Karte (oder in einem Netzwerk) nach welchen Kriterien einfärben wollen. Im folgenden Beispiel färben wir die Punkte, die auf einen “römischen Gutshof” hinweisen, rot ein. Weitere Informationen zu den Conditions findest du in den Guides zu nodegoat: https://nodegoat.net/documentation.s/88/conditions

Wir gehen zu unseren Daten in der Listenansicht und wählen das Symbol für Conditions (das zweite Symbol von rechts in der Werkzeugleiste). In der Registerkarte gehen wir auf ‘Nodes’ (=Punkte). Wir wählen ‘Object’ und als Titel für die Legende ‘Römischer Gutshof’ sowie eine beliebige Farbe, mit der die Punkte auf der Karte erscheinen sollen. Der Titel erscheint dann in der Legende, die automatisch für die Karte erstellt wird.

Was müssen wir nun noch tun? Wir müssen nodegoat sagen, welche Punkte (Nodes) wir einfärben wollen. Dazu klicken wir auf ‘filter’ und tragen dort als Bedingung (Condition) ‘römischer Gutshof’ in das Feld ‘site label’ ein.

Wir speichern unsere Eingaben und gehen auf das Globus-Symbol in der Werkzeugleiste, um das Ergebnis auf der Karte anzuzeigen. Die Legende ist interaktiv. Wir können auf den farbigen roten Balken klicken, um die entsprechenden Punkte auf der Karte ein- oder auszublenden. Dies ist hilfreich für die visuelle Datenanalyse, insbesondere wenn wir viele verschiedenfarbige Punkte auf einer Karte anzeigen und auseinanderhalten wollen.

Wir können nun die Legende in den Conditions nach beliebigen Kriterien erweitern. So können wir zum Beispiel neben den römischen Gutshöfen auch Gräber und andere Funde, die in unserem Datenbstand vorhanden sind, mit der Legende auf der Karte anzeigen. Hinweis: Die von uns erstellten Conditions werden vorübergehend gespeichert. Wenn wir sie dauerhaft speichern wollen, öffnen wir die Conditions und klicken oben links auf die blaue Schaltfläche “save”.

Wir können nun auch eine andere Hintergrundkarte einbinden. Zum Beispiel den ‘Digitalen Atlas des Römischen Reiches’. Die Vorgehensweise dazu ist bereits im Tutorial Nr. 9 beschrieben. Hier ist die Kurzfassung.

In der Werkzeugleiste gehen wir auf: Visual Settings > Visual Settings > Geographical > Map

In das Feld ‘Map’ kopieren wir den folgenden Link:

https://dh.gu.se/tiles/imperium/{z}/{x}/{y}.png

Nun gehen wir zurück zu unseren Daten und klicken auf das Globussymbol in der Werkzeugleiste, um die neue Hintergrundkarte anzuzeigen.

Abb. Archäologischen Stätten in der Schweiz (Daten von Wikidata)

16. Eine Fläche selber zeichnen (GeoJSON) und als Karte einbinden

In nodegoat können wir beliebige Flächen als eigenständige Karten oder als Hintergrundkarten für Visualisierungen einbinden. Flächen für zum Beispiel Diözesen, Fürstentümer, Grafschaften, historische Landes- und Herrschaftsgrenzen aber auch selber definierte Räume, etwa für archäologische Ausgrabungen oder um einen spezifischen Raum einer Untersuchung besonders hervorzuheben. Voraussetzung: die Flächen müssen im frei verfügbaren Format GeoJSON als Polygon (für eine Fläche) gezeichnet werden. Der GeoJSON Code wird dann in ein vorgegebenes Feld in nodegoat kopiert. Also: eine einfache Copy / Paste Übung. Sobald die Fläche in nodegoat gespeichert ist, können wir sie mit den Conditions einfärben (Ränder, Flächen) und beschriften (dies wird in einem späteren Tutorial erklärt).

Hintergrund: das Datenformat JSON wird in nodegoat allgemein verwendet für die Organisation (Strukturierung) der Daten. GeoJSON ist die geografische Variante dieses Datenformats.

Nachdem wir online bei GeoJSON ein Polygon gezeichnet haben, erscheint der JSON Code für diese Fläche in der rechten Spalte. Diesen Code kopieren wir vollständig und fügen ihn anschliessend in das Sub-Objekt eines Objekts in nodegoat ein.

Wir erstellen also vorgängig in nodegoat ein Objekt, das wir zum Beispiel ‘Geo Space’ nennen. Für dieses erstellen wir ein Sub-Objekt, das wir als ‘Area’ bezeichnen. Wer keine Fläche zeichnen möchte kann hier den GeoJSON Code für die historischen Grenzen der Diözese Minden in der Zeit um 1500 herunterladen (PDF). Zur Verfügung gestellt wird dieser Code durch das Forschungsprojekt Germania Sacra.

Im Bereich ‘Management’ aktivieren wir das neu erstellte Objekt ‘Geo Space’ in unserem Projekt, um es im Bereich ‘Data’ verwenden zu können.

Dann erstellen wir im Bereich ‘Data’ ein neues Objekt ‘Geo Space’ und fügen den JSON Code in das Feld ein. Wir wählen dazu ‘Geometry’ aus dem Menü (bei Location):

Wir speichern die Eingabe und visualisieren die Fläche mit einem Klick auf das Globussymbol in der Werkzeugleiste (ganz links).

Mit der Zoomleiste (links in der Darstellung) können wir die Ansicht verkleinern und sehen so das Ergebnis, die Diözese Minden:

Um diese Karte als Hintergrundkarte für eine Visualisierung in nodegoat einzubinden, müssen wir ein Szenario in unserem Geo Space-Objekt erstellen.
Ein Szenario besteht aus einer Filterabfrage und Visualisierungseinstellungen. Nachdem wir ein solches Szenario erstellt haben, können wir es in den Visualisierungseinstellungen > Context auswählen und so erscheint die Karte des Szenarios als Hintergrundkarte.

Erstellen Sie einen Filter ‘Szenario Geo Space’. Wählen Sie das Objekt “Szenario Geo Space” und speichern Sie den Filter:

Erstellen Sie ein Szenario, wähle das Symbol ganz rechts:

Wähle einen Namen für das Szenario und den zuvor erstellten Filter:

Gehe zu Visualisation Settings (Werkzeugleiste) und wähle ‘Context’. Dort kannst du im Objekt Geo Space dein Scenario auswählen und so als Hintergrundkarte einbinden:

17. Netzwerkanalyse von Korrespondenzen in nodegoat

Dieses Tutorial baut auf auf dem Datenmodell von Tutorial Nr. 12 auf. Dieses Datenmodell zeigt nur eine von vielen Möglichkeiten für eine Netzwerkanalyse mit nodegoat. Ein anderes Model (für Korrespondenzen) wird etwa in den Guides auf nodegoat.net Schritt für Schritt erklärt:

https://nodegoat.net/guide.s/4/create-your-first-object-type

Besonders an diesem Modell ist die Verwendung der Funktion der automatischen Datenübernahme von einer Objektbeschreibung in das entsprechende Datenfeld im Sub-Objekt: https://nodegoat.net/guide.s/9/add-a-related-object-type. Praktisch bedeutet dies, dass wir etwa einen Personennamen nur einmal erfassen müssen (in der Objektbeschreibung) und er dadurch automatisch auch im Sub-Objekt gespeichert wird. In einem anderen Tutorial werden wir uns diese Funktion der automatischen Datenübernahme genauer anschauen.

Kommen wir nun zum Datenmodell dieses Tutorials. In Tutorial Nr. 12 haben wir ein Datenmodell erstellt, das aus Personen, Ereignissen und Locations besteht. Mit diesen drei grundlegenden Objekten könnt ihr ganz unterschiedliche Fragestellungen angehen. Ihr könnt dieses Modell auch erweitern, zum Beispiel mit einem zusätzlichen Objekt, das ihr einfach ‘Objekt’ nennt. Ein solches Objekt kann dann zum Beispiel ein beliebiger Gegenstand sein, so wie ein Buch, ein Manuskript, oder auch für Bauten stehen, für archäologische Funde u.s.w. Mit dem Datenmodell Person – Ereignis – Objekt – Location habt ihr also ein sehr umfassendes und vielseitig einsetzbares Modell.

Für dieses Tutorial verwenden wir jedoch das Modell Person – Ereignis – Location, wobei wir als ‘Ereignis’ Korrespondenzen erfassen werden. ‘Korrespondenz’ ist somit ein Ereignistyp. Das Datenmodell funktioniert so, dass wir beim ‘Ereignis’ im Sub-Objekt die damit verbundenen Personen, hier die Korrespondenten, erfassen. Im Datenmodell erstellen wir dazu zwei Sub-Objekte im Objekt ‘Ereignis’, welche wir ‘Absender’ und ‘Empfänger’ nennen (oder auch: ‘Adressat’). Ein drittes Sub-Objekt erstellen wir zudem für Personen, die in den Korrespondenzen erwähnt werden, zum Beispiel als Sub-Objekt ‘Person erwähnt’. Wenn wir auch die Themen der Korrespondenzen schlagwortartig erfassen wollen, können wir ein weiteres Sub-Objekt erstellen, das wir zum Beispiel ‘Gegenstand’ nennen.

Das Datenmodell sieht damit folgendermassen aus:

Objekt: Ereignis

Sub-Objekte des Ereignis: Absender / Empfänger / Person erwähnt / Gegenstand

‘Single’ und ‘Required’ aktivieren wir für Absender und Empfänger im Sub-Objekt, da diese pro Ereignis nur einmal vorkommen dürfen (‘Single’) und wir immer eine Angabe haben wollen zu beiden (‘Required’). Wenn Absender und / oder Empfänger unbekannt sind, dann erstellen wir eine entsprechende ‘Person unbekannt’.

Bei den weiteren Sub-Objekten (Person erwähnt und Gegenstand), die wir gleich wie Absender und Emfpänger erstellen, aktivieren wir die Felder ‘Single’ und ‘Required’ nicht, da diese Sub-Objekte mehrfach vorkommen können, aber nicht zwingend vorkommen müssen.

Im Tab ‘Descriptions’ müssen wir nun im Datenmodell angeben, wo sich das Objekt mit den Personen befindet, um diese bei der Dateneingabe erfassen (auswählen) zu können.

Wir erstellen dazu eine ‘Description’ ‘Absender’ und verbinden sie mit der Reference: Object Type: Person, wie hier dargestellt. Gleich verfahren wir mit den Sub-Objekten ‘Empfänger’ und ‘Person erwähnt’.

Wie in jedem Sub-Objekt können wir nun auch in unserem Modell Datenfelder für zeitliche (Date) und räumliche (Location) Angaben erstellen. Wir wechseln zum Tab ‘Date’ und wählen dort ‘Period’. Dies gibt uns die Möglichkeit, bei der Datumserfassung 2 verschiedenen Daten einzutragen und damit eine Zeitspanne abzubilden, in der die Korrespondenz geschrieben / versendet wurde. Falls wir nur 1 Datum in einem Brief vorfinden, dann tragen wir nur dieses ein. Es wird automatisch in das weitere Datumsfeld übernommen bei der Speicherung. Falls wir keine Datumsangaben vorfinden, können wir einen Brief dennoch in eine chronolgische Reihenfolge bringen mit einer ungefähren Datumsangabe. Siehe dazu Tutorial Nr. 4.

Nun wählen wir im Tab ‘Location’ den Object Type, der die Geo-Referenzen (mit Koordinaten) enthält. In unserem Beispiel ist dies der Type ‘Location’, in dem wird die Namen und die Koordinaten von Ortschaften / Städten speichern:

Diesen Object Type müssen wir, bevor wir ihn hier auswählen können, natürlich zuerst erstellen. Siehe dazu etwa das Tutorial Nr. 5. Um den hier verwendeten Type ‘Location’ zu erstellen, musst du lediglich dem Object einen Namen (‘Location’) geben und ein Sub-Objekt ‘Geo coordinates’. Die Namen können auch verschieden sein und können, wie immer in nodegoat, beliebig festgelegt werden.

Damit hast du nun bereits ein einfaches Datenmodell für die Erfassung von Korrespondenzen. Ein Modell, das du deinen Anforderungen und Fragestellungen entsprechend erweitern kannst:

Person – Ereignis (Korrespondenz) – Location.

Achte darauf, dass du diese 3 Object Types in ‘Management’ für dein Projekt aktiviert hast (Check-Boxes ausgewählt). Geht nun zum ‘Data’ Bereich und erfasst ein neues ‘Ereignis’. Das Formular für die Datenerfassung sollte so aussehen:

‘Absender’ und ‘Empfänger’ erscheinen automatisch, da wir sie als ‘Required’ definiert haben im Datenmodell. ‘Person erwähnt’ und ‘Gegenstand’ müsst ihr dagegen mit einem Klick auf das Plus-Zeichen aufklappen, um Daten dort zu erfassen. Voraussetzung um Personen erfassen zu können ist freilich, dass wir im Datenmodell bei ‘Person’ mindestens 1 Feld mit dem Namen oder der Bezeichnung erstellt haben im Datenmodell. Ebenso bei ‘Location’, wo wir im Datenmodell, wie erwähnt, zusätzlich ein Sub-Objekt ‘Geo coordinates’ erstellt haben. Sind diese Angaben im Datenmodell für Person, Ereignis und Location vorhanden, können wir im oben dargestellten Formular des ‘Ereignis’ mit der Datenerfassung beginnen. Wir können neue Personen und Locations gleich in diesem Formular hinzufügen (auf ‘new’ klicken, wenn ihr in das Lupenfeld geklickt habt).

Erfasst testweise eine ‘Person 1’ als Absender und eine ‘Person 2’ als Empfänger sowie 2 verschiedene Locations mit ihren Geokoordinaten, die ihr etwa bei GeoNames.org findet (oder ihr könnt den Ort auch direkt auf der interaktiven Karte in nodegoat markieren, wodurch die Geokoordinaten automatisch eingefügt werden). Siehe dazu auch das Tutorial Nr. 5.

Für das vorliegende Beispiel haben wir zwei Personen erfasst: Person 1 und Person 2. Sowie 2 Locations: Basel und Prague. Das Ereignis haben wir ‘Korrespondenz 1’ genannt.

Achtet darauf bei der Erfassung der Geokoordinaten, dass ihr bei Location ‘Point’ ausgewählt habt. Mit einem Klick auf ‘Map’ könnt ihr die Koordinaten interaktiv auf der Karte auswählen:

So sollte das vorläufige Ergebnis der Datenerfassung aussehen (noch ohne Datumsangaben):

Diese Korrespondenz wird automatisch auf der Karte visualisiert, indem ihr in der Werkzeugleiste auf das Globussymbol links klickt.

Mit der Legende (rot / blau) könnt ihr für die explorative Datenanalyse die Daten ein- und ausblenden.

Zum Schluss könnt ihr noch Datumsangaben zur ‘Korrespondenz 1’ hinzufügen im Sub-Objekt (Date). Sobald geschehen, übernimmt die Zeitleiste diese Angaben und ihr könnt damit die Daten auf der Karte dynamisch darstellen.

Mit einem Klick in der Werkzeugleiste auf das Symbol zur Netzwerkanalyse (rechts neben dem Gobussymbol) seht ihr wie das Ereignis ‘Korrespondenz 1’ die beiden Personen miteinander verbindet. Hierbei handelt es sich um ein einfaches, aber vielfach einsetzbares Grundmodell für eure Netzwerkanalyse, da wir die Ereignisse beliebig erweitern können sowie, wie wir oben gesehen haben, anreichern können mit weiteren Personen (Person erwähnt) oder auch mit Inhalten (Gegenstand):

 

18. Texte von Transkribus in nodegoat importieren (Ingestion)

Voraussetzungen:

Ihr habt bereits ein Konto für nodegoat und eines für Transkribus. Im Tutorial arbeiten wir mit der Webversion von Transkribus ( ‘Transkribus lite’): https://app.transkribus.eu/de.

Eine Einführung zu Transkribus findet ihr hier:

Die wichtigsten Schritte für den Import der Texte in nodegoat:

1. In Transkribus habt ihr ein Dokument als PDF oder im Bild-Format hochgeladen, dann die Layout-Analyse sowie die Texterkennung für das Dokument durchgeführt. Beginnt am besten mit einem gedruckten Dokument, das Transkribus gut erkennt. Handschriften sind etwas schwieriger. Je regelmässiger eine Schrift jedoch ist (auch eine Handschrift), umso besser wird sie durch den Computer erkannt.

2. In nodegoat müssen wir zwei Schnittstellen (Linked Data Resource genannt) konfigurieren. Über diesen Schnittstellen werden die Texte und Bilder aus Transkribus in nodegoat importiert. Die Konfiguration der Schnittstellen müssen wir nur 1 x durchführen. Anschliessend können die beiden Schnittstellen für alle weiteren Dokumente in unserem Transkribus-Konto wiederverwendet werden.

  1. Schnittstelle: Transkribus Pages & Pictures
  2. Schnittstelle: Transkribus Texts

Der Import funktioniert nach den folgenden Prinzipien:

Wir importieren mit der Schnittstelle 1 und der Ingestion 1 zuerst alle Seiten (Pages) sowie die Bilder zu den Seiten zu einem Document (in Transkribus besteht ein Document aus Texten und den dazugehörigen Bildern). Danach importieren wir die Texte für alle Seiten mit der Schnittstelle 2 und der Ingestion 2.

3. Die Schnittstellen stellen dabei nur die Verbindung her zu Transkribus. Die Inhalte (Texte und Bilder) importieren wir in einem weiteren Schritt mit dem Ingestion-Modul von nodegoat. Im Ingestion-Modul konfigurieren wir, in welche Felder in unserem nodegoat-Datenmodell die Texte und Bilder importiert werden sollen (Stichworte: Feldzuweisungen, data mapping).

Für Schnittstelle 1 müssen wir dazu die Ingestion 1 einrichten.

Für Schnittstelle 2 müssen wir dazu die Ingestion 2 einrichten.

Insgesamt müssen wir also 2 Schnittstellen und 2 Ingestion-Prozesse (Feldzuweisungen für den Import) für diese Schnittstellen in nodegoat einrichten.

2 x

2 x

Zuerst erstellen wir das Datenmodell für Seiten, Bilder und Texte, die wir aus Transkribus in nodegoat importieren.

1. Datenmodell erstellen

Das Datenmodell besteht aus 2 Objects:

– Transkribus Document

Transkribus Pages, Pictures & Texts

Transkribus Document brauchen wir dabei nur, um die Document-ID zu speichern. Das ist die ID des Documents in Transkribus, zu dem wir die Texte und Bilder importieren wollen. Dazu unten mehr.

Das Datenmodell für Transkribus Document:

Das Datenmodell für Transkribus Pages, Pictures & Texts

Nun richten wir die Schnittstellen 1 und 2 ein.

1. Schnittstelle: Transkribus Pages & Pictures

URL

https://transkribus.eu/TrpServer/rest/collections/

URL Options

?JSESSIONID=deine Session-ID (eure Session-ID, siehe die nachfolgenden Erläuterungen dazu):

Wichtig: Um eine Verbindung mit Transkribus herstellen zu können (via Schnittstellen), benötigen wir eine aktuelle Session-ID von Transkribus. Die Session-ID hat eine begrenzte zeitliche Gültigkeit (das ist von Transkribus für die Schnittstelle so festgelegt). Ist die Zeit abgelaufen, funktioniert der Import in nodegoat nicht mehr. Dann muss man wieder eine neue Sesssion-ID generieren mit einer Abfrage via Terminal (OSX, Linux). Auf Windows geht das mit einem Command Prompt.

Die Session-ID findet ihr also, wenn ihr euch bei Transkribus via Schnittstelle einloggt:

Login für OSX Terminal (die folgenden Zeilen ins Terminal kopieren):

curl https://transkribus.eu/TrpServer/rest/auth/login -d “user=max.mustermann@universität_xy.ch&pw=mein Passwort”

Im Ergebnis der Eingabe (im Terminal) den Abschnitt mit der Session-ID suchen, dann nur die lange Zeichenkette mit Nummern und Zahlen kopieren und in die nodegoat Schnittstellen (1 und 2) einfügen (?JSESSIONID=….) und speichern.

Beispiel für eine Session-ID, wie sie nach der Abfrage im Terminal-Fenster erscheint:

</loginTime><sessionId>5C83373403B08808B496E348F8AA1E40</sessionId><userAgent>

Für Windows ist die Eingabe für das Login identisch: curl https://transkribus.eu/TrpServer/rest/auth/login -d “user=max.mustermann@universität_xy.ch&pw=mein Passwort”

Um die Eingabe (Login) auszuführen, müsst ihr in Windows in das schwarze Prompt-Eingabefeld wechseln, wie bei OSX auch dort die Eingabe per copy / paste einfügen und ausführen mit Enter:

Tipp: Ihr müsst die Eingabe im OSX- und im Windows-Terminal (Prompt) nicht jedes Mal neu erstellen. Durch Drücken der Pfeiltaste (aufwärts) erscheint eure letzte Eingabe wieder. Eure Eingaben werden also in den Terminals gespeichert.

Sobald ihr die aktuelle Session-ID gespeichert hat, könnt ihr hier weiterfahren (immer noch in derselben Schnittstelle):

123456

Das ist eure Collection-ID bei Transkribus (nicht die Document-ID). Ihr findet die Collection-ID unter Collections (Sammlungen). In diesem Beispiel sind zwei Collection-IDs sichtbar:

Query

123456/[query=document][variable=id]1616757[/variable][/query]/fulldoc

Die Collection-ID ist in diesem Beispiel ‘123456’. Fügt eure Collection-ID in die Query ein.

Die Document-ID fügt ihr ebenfalls in die Query ein. Ihr findet die Document-ID in Transkribus, wenn ihr auf das kleine ‘i’ klickt oder auf die drei Punkte und dann auf ‘Edit’. Im folgenden Beispiel ist die ID: 1616757.

Wichtig: Solange ihr in Transkribus immer mit derselben Collection arbeitet und von dort Texte in nodegoat importiert, müsst ihr die Collection-ID in der Linked Data Resource nicht ändern. Erst wenn ihr aus einer anderen Collection Texte importieren wollt, müsst ihr die Collection-ID in der Query vorgängig ändern.

Die folgenden Werte kopiert ihr bei eurer Linked Data Resource in die entsprechenden Felder.

URI

{“pageList”:{“pages”:{“[]”:{“pageId”:””}}}}

Label

{“pageList”:{“pages”:{“[]”:{“pageNr”:””}}}}

Image

{“pageList”:{“pages”:{“[]”:{“key”:””}}}}

Transkribus page key to URL: dieses Feld kann erst ausgewählt werden, wenn die Konvertierung für die Bilder eingerichtet wurde (damit diese als URL importiert werden können). Wie das geht zeigt das folgende Bild. Auch dieses Konvertierung muss nur 1 x konfiguriert werden und kann danach wiederverwendet werden.

Document ID

{“pageList”:{“pages”:{“[]”:{“docId”:””}}}}

INPUT=UDAYJZMDFGILBTRSGXEGETHV

Script

const key = INPUT;
const url = ‘https://files.transkribus.eu/iiif/2/’ + key + ‘/full/1500,/0/default.jpg’
OUTPUT = {url:url}

OUTPUT=

{
“url”: “”
}

Im nächsten Schritt konfigurieren wir die Ingestion (Feldzuweisungen) für den Import der Seiten und Bilder in das Object Transkribus Pages, Pictures & Texts. Dazu gehen wir zuerst in den Bereich Management von nodegoat und aktivieren für unser Projekt Transkribus die Ingestion und die Reconciliation (die Reconciliation können wir nach dem Import für den Abgleich eines Vokuabulars mit den Texten gebrauchen).

 

2. Schnittstelle Transkribus Texts

Der obere Teil mit der URL ist identisch zur 1. Schnittstelle. Anpassen müsst ihr folgende Felder:

Query

123456/[query=document][variable=id]1612084[/variable][/query]/[query=page][variable=nr]2[/variable][/query]/text

URI

{“PcGts”:{“Page”:{“@attributes”:{“imageFilename”:””}}}}

Label

{“PcGts”:{“Page”:{“@attributes”:{“imageFilename”:””}}}}

Values Text

{“PcGts”:{“Page”:{“TextRegion”:{“[*]TextLine”:{“[]”:{“TextEquiv”:{“Unicode”:””}}}, “<“:”join:\n”}}}}

 

1. Ingestion Pages & Pictures

Wichtig: Damit die Ingestion funktioniert, müssen wir die Document ID des Documents, das wir importieren wollen (Seiten, Bilder, Texte) von Transkribus in das Feld des Objects Transkribus Document kopieren. Damit sagen wir der Ingestion, für welches Document in Transkribus wir die Seiten, Bilder und Texte importieren wollen.

(Wir könnten die Document-ID auch mit einer Ingestion direkt in nodegoat importieren. Dann müssten wir aber eine Schnittstelle 3 und eine Ingestion 3 einrichten. Wenn wir die ID von Hand kopieren machen wir uns zudem bewusster, was wir tun.)

Im Bereich Data konfigurieren wir nun die 1. Ingestion (Transkribus Pages & Pictures), die Seiten und Bilder aus Transkribus in nodegoat importieren wird. Diese 1. Ingestion funktioniert also mit der 1. Schnittstelle zusammen, die wir vorher bereits konfiguriert haben.

Speichert die Ingestion und führt den Import aus ‘run’. Leert vorher allenfalls noch den Cache (Status: Reset). Nach dem Import seht ihr im Object ‘Transkribus Pages & Pictures’ die Seiten und Bilder eures Dokuments. Jetzt fehlen nur noch die Texte.

2. Ingestion Texts

Diese importieren wir mit der 2. Schnittstelle und der 2. Ingestion. Das Prinzip dabei ist, dass wir die bereits importierten Seiten mit den Texten aktualisieren (update). Die Seiten (zusammen mit der Document ID) geben also das Gerüst vor, das wir nun mit den Texten füllen (durch den Import). Die 2. Ingestion konfigurieren wir folgendermassen.

Wichtig ist also, den Mode Update Existing Objects zu wählen, nicht Add New Objects wie vorher bei den Seiten und Bildern.

Fertig. Wenn alles geklappt hat, seht ihr nun im Object Transkribus Pages & Texts eure Texte. (Kontrolliert, ob ihr in Transkribus tatsächlich Texte vorhanden habt, falls nichts erscheinen sollte.)

Siehe zur Ingestion von Transkribus zu nodegoat auch das Tutorial auf nodegoat.net:

https://nodegoat.net/guide.s/136/ingest-transcription-data-from-transkribus

Neben der Ingestion könnt ihr Texte auch via CSV in nodegoat importieren oder per copy / paste einfügen.

 

19. Texte mit einem Vokabular abgleichen (Reconciliation)

Dieses Tutorial ergänzt das vorangehenden Tutorial (Nr. 18), wobei die Funktionsweise des Reconciliation-Moduls grundsätzlich erläutert wird.

Die von Transkribus importierten Texte (siehe Tutorial Nr. 18) könnt ihr mit dem Reconciliation-Modul automatisch mit einem Vokabular, das ihr als Object erstellt, abgleichen.

Der Abgleich mit einem Vokabular, das ihr selber definieren könnt, hilft euch vor allem bei grossen Textmengen (Corpus), einen Überblick über die Inhalte zu gewinnen. Da ihr das Vokabular selber definiert, also mit euren Begriffen, Orten oder Personen u.s.w., ist dies ein pattern machting, nicht ein pattern recognition. Im ersten Fall habt ihr also schon eine Ahnung davon, was in den Texten vorkommen könnte an interessierenden Begriffen – wie zum Beispiel in der historischen Forschung, wo es zu den Kernkompetenzen gehört, Quellentexte nach Form und Inhalt grundsätzlich bewerten zu können. Im zweiten Fall dagegen würde ein Algorithmus von sich aus nach auffälligen Begriffen (je nach Typ und Suchmodus) des Algorithmus suchen.

Ihr könnt in nodegoat zudem mehrere Vokabulare definieren und abgleichen. Zum Beispiel eines mit Begriffen, eines mit Orten oder Institutionen, oder eines mit Personen, Werken, Gegenständen etc. Grundsätzlich entspricht ein solcher Abgleich dann einem Named Entity Matching.

Zum Vorgehen

Im Datenmodell für ihr ein Object Vocabulary sowie das Object City, das also Vorlage schon vorhanden ist, hinzu. City benötigen wir im Sub-Object, um Orte, die wir mit dem Vokabular abgleichen, georeferenzieren können. Damit können wir im Anschluss an den Abgleich umgehend eine Karte der gefundenen Orte erstellen. Gleich können wir mit Begriffen ohne Georeferenz (Koordinaten) vorgehen, mit denen wir ein Netzwerk erstellen können.

Das Sub-Object im Datenmodell:

Im Object Transkribus Pages, Pictures & Texts fügen wir zudem eine Object Description hinzu, wo die gefundenen Begriffe (patterns) gespeichert werden sollen. Diese Description werden wir gleich nachfolgend im Reconciliation-Modul auswählen.

Im Management aktivieren wir das Reconciliation-Modul (falls nicht schon im Tutorial Nr. 18 gemacht). Im Vocabulary fügen wir nun beliebige Begriffe hinzu, die abgegelichen werden sollen. Wie wir einen Ort mit Koordination (die im Object City gespeichert sind, das wir als Referenzwert nutzen) hinzufügen, seht ihr hier:

Nun richten wir die Reconciliation ein. Dabei definieren wir, welche Felder mit welchem Vokabular abgeglichen werden sollen. Wir haben verschiedene Einstellungsmöglichkeiten. Das folgende Beispiel zeigt nur eine davon.

Nun gehen wir auf ‘run’, um die Reconciliation zu starten. Den Status (roter Button) setzen wir zurück, falls noch Objects angezeigt werden (Objects Processed), was im folgenden Beispiel aber nicht der Fall ist.

Wir haben nun viele weitere Einstellungsmöglichkeiten, wie der Algorithmus suchen soll. Wir wählen hier nur die Option Auto-Save: Any Result. Ihr könnt weitere Einstellungen, je nach Ergebnis, später vornehmen und die Reconciliation nochmals starten.

Nach der Reconciliation klickt ihr auf das Netzwerk-Icon, um das Netzwerk der gefundenen Begriff anzuzeigen. Klickt auf das Globus-Icon, um die Karte zu erstellen (in den Visual Settings müsst ihr dazu noch einstellen, wo die Koordinaten gespeichert sind). Visual Setttings:

Dieses Beispiel einer Reconciliation zeigt nur einen einfachen Anwendungsfall. Es gibt zahlreiche weitere Konfigurationsmöglichkeiten, um spezifischen Fragestellungen, die ihr an Texte habt, mit nodegoat zu analysieren.

Siehe zur Reconciliation von Texten auch das Tutorial auf nodegoat.net:

https://nodegoat.net/guide.s/145/reconcile-textual-data

 

20. Ein nodegoat-Datenmodell mit dem CIDOC-Referenzmodell klassifizieren

Mit dem CIDOC-Referenzmodell werden Informationen vereinheitlicht, indem sie den Begriffen des CIDOC CRM (Conceptual Reference Model) zugeordnet werden. Ziel der Vereinheitlichung ist ein vereinfachter Austausch von Informationen, etwa zwischen Forschungsprojekten. Das CIDOC CRM  wurde ursprünglich für den Bereich des kulturellen Erbes entwickelt.

Das CIDOC-Referenzmodell besteht aus Klassen (Entities) und Eigenschaften (Properties), die Daten oder Datenmodellen zugeordnet werden könen. Damit stimmt das CIDOC CRM Datenmodell mit dem Datenmodell in nodegoat grundsätzlich überein, da beide Konzepte einen objektorientierten Aufbau verfolgen. Die Klassen von CIDOC entsprechen den Objects und die Eigenschaften den Categories (Classifications) in nodegoat. Aus der Sicht der Datenerhebung entsprechen Klassen somit mehr kategorisierenden Daten und Eigenschaften mehr beschreibenden Daten.

Durch die flexible Datenmodellierung kann mit nodeogat auch ein RDF-Datenmodell erstellt werden mit der bekannten RDF-Gliederung: Subject – predicate – object. Das Ressource Description Framework (RDF) ist ein W3C Standard um Informationen im Semantic Web abzubilden und auszudrücken. Subjekt und Objekt sind Ressourcen, die durch Prädikate (Eigenschaften) mit anderen Ressourcen oder mit Literalen (Zahl, Zeichen, Datum etc.) zu Aussagen verknüpft werden.

Im objektorientierten Datenbankmodell in nodegoat entsprechen RDF-Subjekt und RDF-Objekt den Objects und die Eigenschaften den Object descriptions. Ein einfaches Datenmodell in nodegoat, um Daten im Format Subject – predicate – object zu erfassen, besteht zum Beispiel aus 3 Objects:

SubjectPredicate (Literals)Object

Im Modell werden im nodegoat-Object Subject 2 Object descriptions für das Object und für das Predicate erstellt. Im Object Predicate können zusätzlich Literals (Zahl, Zeichen, Datum etc.) erfasst werden mit denen die Objekte ebenfalls verknüpft werden können. Dies ist nur eine Möglichkeit eines an RDF orientierten Datenmodells. Die Literals etwa könnten auch in einem eigenen Object in nodegoat erfasst werden.

Es gibt verschiedene Möglichkeiten, die Klassen und Eigenschaften des CIDOC CRM in einem nodegoat-Projekt für die Zuordnungen zu verwenden. Wenn man sich an CIDOC orientieren will, dann ist es natürlich am besten, zu Beginn eines Projekts das Datenmodell entsprechend anzupassen. Nachfolgend wird das Vorgehen für eine dynamische Zuordnung zu einem Referenzdatensatz beschrieben. Dieses Vorgehen eignet sich vor allem auch für eine nachträgliche Klassifizierung eines Datenmodells mit CIDOC.

Zuerst werden für ein nodegoat-Projekt die Klassen und Eigenschaften des CIDOC CRM via CSV-Upload importiert. Das CSV-File findet ihr hier zum Herunterladen:

CIDOC__classes_properties.csv

Die Klassen und Eigenschaften werden im CSV-File nicht unterschieden. Ihr könnt sie nach dem Import in nodegoat (oder vorher in Excel) bei Bedarf trennen. Für einen einfachen Anwendungsfall ist dies aber nicht notwendig. Der Import von CSV-Daten in nodegoat wird in anderen Tutorials bereits beschrieben.

Vergleicht zur Sicherheit immer eure Klassen und Eigenschaften mit den neusten Entwicklungen im CIDOC CRM, es kann in den neuen Versionen immer wieder Änderungen geben:

https://www.cidoc-crm.org/versions-of-the-cidoc-crm

In euerem Datenmodell erstellt ihr vor dem Import ein Object (oder eine Category) mit z.B. der Bezeichnung ‘CIDOC’ und aktiviert dieses Object  für eure Projekt. Dann importiert ihr die CIDOC CSV-Daten in dieses Object (oder in die Category). Empfehlenswert ist es allerdings, ein CIDOC Object erstellen, weil es sich um einen zentralen Bestandteil des Projekts handelt. Nach dem Import könnt ihr im Lupenfeld (aktiviere ‘Quick search’ im Datenmodell für die Durchsuchbarkeit des Datenfelds) nach Klassen oder Eigenschaften von CIDOC suchen.

In eurem Datenmodell erstellt ihr anschliessend Object descriptions oder Sub-Object descriptions die sich auf das Object (oder die Category) ‘CIDOC’ beziehen. Bei Bedarf könnt ihr mehrere descriptions für ein Object oder ein Sub-Object erstellen.

Nun erstellt ihr einen Referenzdatensatz, bei dem anschliessend sämtliche Datenfelder mit beispielhaften Werden ausgefüllt werden. In diesem Datensatz, den ihr z.B. ‘CIDOC’ nennt, wählt ihr in den Object descriptions die entsprechende Klasse oder Eigenschaft aus dem CIDOC-Object aus.

Das folgende Beispiel zeigt ein grundsätzliche Anwendung. Im Object ‘Person’ wurde im Datenmodell eine description für CIDOC erstellt. Optional könnt ihr eine description CIDOC reference data set erstellen und anschliessend euren Referenzdatensatz im Data-Bereich mit ‘yes’ markieren. Alle anderen Datensätze haben per Voreinstellung ‘no’. So könnt ihr euren Referenzdatensatz auf einfache Weise aus den anderen Datensätzen herausfiltern.

Im Referenzdatensatz beginnt ihr am besten mit einer Zuweisung der Klassen und verfeinert das Ganze mit den Eigenschaften. Den Referenzdatensatz könnt ihr als CSV-Datei aus nodegoat herunterladen, dann in einem READM-File beschreiben und zusammen mit euren Daten, die ihr mit nodegoat erhoben und ebenfalls als CSV-Daten heruntergeladen habt, der digitalen Langzeitarchivierung überantworten. Optional könnt ihr den Referenzdatensatz sowie die Daten auch via die in nodegoat integrierte JSON-Schnittstelle (API) dynamisch publizieren.

21. Import eines Datenmodells für Korrespondenzen-Netzwerke mit der nodegoat-Schnittstelle (API)

Dieses Datenmodell, mit dem ihr Personen und Korrespondenzen erfassen könnt, entspricht dem Modell, das auf nodegoat.net in den Guides beschrieben wird. Es wird dort gezeigt, wie ihr das Modell in nodegoat zusammenstellen und Daten erfassen könnt. Durch den Import des Datemodells können wir direkt mit der Datenerfassung beginnen, die hier beschrieben ist: https://nodegoat.net/guide.s/6/enter-your-first-data

Das Datenmodell enthält grundsätzliche Feldfunktionen von nodegoat, welche ihr vor oder im Laufe der Datenerfassung anpassen könnt. Das Modell ist so konfiguriert, dass ihr auf einfache Weise auf Karten, in Netzwerken und in Zeitreihen Personen und Korrespondenzen visualisieren könnt.

Voraussetzungen: Ihr müsst in eurer nodegoat-domain im Management die API-Funktion zur Verfügung haben, was bei einer institutionellen nodegoat-Installation grundsätzlich der Fall ist.

Zuerst erstellen wir einen Zugang (API Client) für unsere nodegoat-Umgebung (domain).

Dann fügen wir einen User zum API Client hinzu.

Durch das Hinzufügen eines Users wird für diesen ein Passkey (token) erstellt. Der Passkey ist unser Passwort für das Login zu unserer nodegoat domain via Kommandozeile (Terminal, Prompt).

So gelangt ihr in Windows in das Prompt-Eingabefeld (Kommandozeile):

In OSX (Mac) müsst ihr das Programm ‘Terminal’ öffnen, um in die Kommandozeile zu gelangen.

In der Kommandozeile fügt ihr folgende Angaben ein, um euch einloggen und das Modell importieren zu können. Den Passkey (rot hervorgehoben) kopieren wir in der Kommandozeile (Terminal, Prompt) an die Stelle wie hier gezeigt. Achtet darauf, dass die Anführungszeichen hochgestellt sind. Am besten verwendet ihr die Anführungszeichen, die im Terminal oder Prompt verfügbar sind.

curl -H “Authorization: Bearer N4zU7eX8TnC00N9D20boEAUkhSqecd8TLmbbaz5kK3123456” https://api.nodegoat.yourdomain.com/model/type -X PUT -d @

Bei your.domain.com (blau) fügen wir unsere nodegoat-Domain ein. Sollte diese euch nicht bekannt sein, fragt bei der Administration eurer nodegoat-Installation nach.

Tipp: Ihr müsst die Eingabe in der OSX (Terminal) – und in der Windows-Kommandozeile (Prompt) nicht jedes Mal neu erstellen. Durch Drücken der Pfeiltaste (aufwärts) erscheint eure letzte Eingabe wieder. Eure Eingaben werden also in den Terminals gespeichert.

Das Modell ‘Correspondence network’, das wir als Beispiel für den Import verwenden, findet ihr hier zum herunterladen:

Correspondence_network_Template_Personal.json (zipped)

Entzippt (entkomprimiert) das Modell (JSON-File) nach dem Herunterladen. Das File sieht dann so aus: ‘Correspondence_network_Template_Personal.json’

Bewegt das File anschliessend mit der Maus an die Stelle nach dem @ auf der Kommandozeile. Mit ‘Enter’ startet ihr den Import des Datenmodells. War dieser erfolgreich, erscheint eine entsprechende Meldung in der Kommandozeile.

Nun könnt ihr die importierten Objekte (3) und Kategorien (1) des Modells im Management eurer nodegoat-domain für beliebige Projekte aktivieren. Für das importierte City-Objekt könnt ihr bei Bedarf zusätzlich Orte mit Koordinaten importieren (via CSV-upload), oder Orte einzeln manuell hinzufügen. Optional könnt ihr anstelle auch das vorinstallierte City-Objekt in nodegoat verwenden und dies im importierten Datenmodell entsprechend anpassen.

Das Tutorial zeigt nur eine Anwendungsmöglichkeit der nodegoat-Schnittstelle. Weitere Informationen sind in der nodegoat documentation zu finden:

https://nodegoat.net/documentation.s/59/api

https://nodegoat.net/documentation.s/96/basic-principles

https://nodegoat.net/documentation.s/98/query

https://nodegoat.net/documentation.s/103/store

22. Export eines Datenmodells mit der nodegoat-Schnittstelle (API)

Aus nodegoat können Datenmodelle (und auch Daten) im JSON-Format vollumfänglich exportiert werden. Ein exportiertes Datenmodell kann in eine andere nodegoat-Installation importiert und so Datenmodelle in der Community ausgetauscht werden.

Voraussetzungen: Ihr müsst in eurer nodegoat-domain im Management die API-Funktion zur Verfügung haben, was bei einer institutionellen nodegoat-Installation grundsätzlich der Fall ist.

Zuerst erstellen wir einen Zugang (API Client) für unsere nodegoat-Umgebung (domain).

Dann fügen wir einen User zum API Client hinzu.

Durch das Hinzufügen eines Users wird für diesen ein Passkey (token) erstellt. Der Passkey ist unser Passwort für das Login zu unserer nodegoat domain via Kommandozeile (Terminal, Prompt).

Nun wechseln wir zur Kommandozeile für das Login.

So gelangt ihr in Windows in das Prompt-Eingabefeld (Kommandozeile):

In OSX (Mac) müsst ihr das Programm ‘Terminal’ öffnen, um in die Kommandozeile zu gelangen.

In der Kommandozeile fügt ihr folgende Angaben ein, um euch einloggen und das Modell exportieren zu können. Den Passkey (rot hervorgehoben) kopieren wir in der Kommandozeile (Terminal, Prompt) an die Stelle wie hier gezeigt. Achtet euch darauf, dass die Anführungszeichen hochgestellt sind.

curl -H “Authorization: Bearer N4zU7eX8TnC00N9D20boEAUkhSqecd8TLmbbaz5kK3123456” https://api.nodegoat.your.domain.com/project/1234/model/template/type/123456,123457,123458,123459\?output=template

Bei your.domain.com (blau) fügen wir unsere nodegoat-Domain ein. Sollte diese euch nicht bekannt sein, fragt bei der Administration eurer nodegoat-Installation nach. Nach /project/ tragen wir die ID unseres Projekts ein (pink) sowie die IDs der Types und Classifications (grün), die wir exportieren wollen. Die IDs von eurem Projekt findet ihr in Management und im Model die IDs von Types und Classifications:

Tipp: Ihr müsst die Eingabe in der OSX (Terminal) – und in der Windows-Kommandozeile (Prompt) nicht jedes Mal neu erstellen. Durch Drücken der Pfeiltaste (aufwärts) erscheint eure letzte Eingabe wieder. Eure Eingaben werden also in den Terminals gespeichert.

Mit ‘Enter’ startet ihr den Export. Das exportierte Datenmodell erscheint in eurer Kommandozeile. Von dort könnt ihr es von Hand per copy / paste in ein Textfile kopieren (darauf achten, dass das Textfile unformatiert ist (UTF-8-Formatierung).

Nun kommt der wichtigste Schritt: Damit wir das Datenmodell importieren können, müssen wir von Hand im Kopfbereich des Textfiles kleine Anpassungen vornehmen. So sieht der Kopfteil des Datenmodells im Textfile aus:

1. Löscht den violetten Teil (darauf achten, dass es links oben noch eine Klammer hat)
2. Ersetzt “types” durch “add” (die Anführungszeichen müssen hochgestellt sein)
3. Löscht ganz am Ende des Files 1 eckige Klammer (da wir im violetten Teil auch 1 gelöscht haben)
4. Darauf achten, dass ganz am Ende des Files der Text nur durch die Klammer abgeschlossen wird und nicht durch andere Zeichen
5. Auf die Fomatierung achten, eine rohe Formatierung (UTF-8) wählen.
6. Dem Textfile, das nun das Datenmodell enthält, müsst ihr die Endung .json hinzufügen, um das Datenmodell importieren zu können.
7. Öffnet das Textfile mit dem Browser. Wenn alles stimmt, wird keine Fehlermeldung angezeigt, sondern die Baumstruktur des Modells, wie hier (links oben seht ihr das “add”, das wir hinzugefügt haben):

Dieses Datenmodell könnt ihr nun, wie in Tutorial Nr. 21 beschrieben, in eine andere nodegoat-Installation importieren.

Das Tutorial zeigt nur eine Anwendungsmöglichkeit der nodegoat-Schnittstelle. Weitere Informationen sind in der nodegoat documentation zu finden:

https://nodegoat.net/documentation.s/59/api

https://nodegoat.net/documentation.s/96/basic-principles

https://nodegoat.net/documentation.s/98/query

https://nodegoat.net/documentation.s/103/store