Handleiding voorbeelden COINS 2.0

Transcriptie

1 RWS BEDRIJFSINFORMATIE Handleiding voorbeelden COINS 2.0 Voorbeelden voor werken met COINS in BIM-projecten op basis van de RWS Objecttypenbibliotheek (OTL) Uitgegeven door Programma BIM Rijkswaterstaat Informatie Maikel Boom Datum 20 maart 2017 Status Informatief Versie 1.1

2

3 RWS BEDRIJFSINFORMATIE Handleiding voorbeelden COINS 2.0 versie maart 2017 Inhoud Inleiding 5 1 Wegwijzer COINS 6 2 Sparql toegang tot de OTL Sparql en Sparql software Sparql queries voor de OTL Zoek een RWS-OTL object Geef alle mogelijke simpele kenmerken Geef alle mogelijke decomposities Geef alle mogelijke DirectedConnection relaties Lifecycle rollen 14 3 OTL COINS Containers ontwikkelen met behulp van COINS 2.0 API Netwerk instantiëren Decompositie ruimtelijke netwerk Simpele Kenmerken Interacties van ruimtelijke netwerken Realisatie van Ruimtelijke objecten Enumeraties Documenten ShapeRepresentation Lifecycle role Lifecycle met een document 32 4 Bijlage UML Class diagram van COINS

4

5 RWS BEDRIJFSINFORMATIE Handleiding COINS 2.0 versie maart 2017 Inleiding Dit document beschrijft hoe COINS 2.0 gebruikt wordt om project data op te slaan en over te dragen in Rijkswaterstaat BIM projecten in combinatie met de RWS- Objecttypenbibliotheek (OTL). Het document is in de eerste plaats bedoeld voor externe partijen die de OTL gebruiken om projectdata te structureren volgens de eisen van Rijkswaterstaat. Waar de Instructie modelleren op basis van de OTL vooral bedoeld is voor medewerkers bij de opdrachtnemer die de database vult, is dit document bedoeld voor de medewerkers die zich bezighouden met de systemen waarin de data opgeslagen wordt en de manier waarop het daar in en uit gehaald wordt. In deze handleiding wordt COINS zelf kort toegelicht en de twee belangrijkste manieren om data in COINS te benaderen en bewerken: 1. Via de Sparql W3c Standaard. 2. Via de COINS 2.0 API. Daarnaast zijn een aantal voorbeelden uitgewerkt van COINS 2.0 data i.c.m. de OTL 2.1. Pagina 5 van 34

6 RWS BEDRIJFSINFORMATIE Handleiding voorbeelden COINS 2.0 versie maart Wegwijzer COINS In dit hoofdstuk vind je een korte introductie van de COINS systematiek. COINS (Constructieve Objecten en de INtegratie van Processen en Systemen) is een flexibele standaard voor de uitwisseling van BIM-informatie. Het biedt een uitwisselingsformaat door middel van een container voor BIM-gerelateerde informatie. COINS ondersteunt de uitwisseling van digitale informatie tussen verschillende IT-platforms en omgevingen van partijen die betrokken zijn bij bouwprojecten. De standaard zorgt ervoor dat verschillende soorten informatie in samenhang in één database kunnen worden vastgelegd, zoals functies, eisen- en objectenbomen, GIS-data, 2D-tekeningen, 3D-modellen, pdf-documenten, IFCmodellen en de RWS Objecttypenbibliotheek (OTL). COINS vormt een aanvulling op standaarden die uitgebracht worden door W3C en buildingsmart zoals IFC, IFD Library en IDM. De kern wordt gevormd door een neutraal, software-onafhankelijk datamodel, van waaruit data in een neutraal format kunnen worden verzonden en vertaald naar de software van verschillende projectpartners. Daarmee heeft de standaard grote invloed op BIM-processen. De uitwisseling van informatie via COINS gaat via een COINS container. Het betreft hier een zip file met de extensie ccr met een gefixeerde folderstructuur waarin alle documenten geplaatst kunnen worden. Zie onderstaande afbeelding. Alle informatie wordt via een RDF/OWL informatiemodel in de BIM folder verder beschreven. Dit model wordt het semantisch BIM-model genoemd en bevat alle projectinformatie. Dit model maakt gebruik van het COINS-Core model (cbim- 2.0.rdf) en de OTL (otl-2.1.ttl) en het RWS referentiekader (coins-20- referentiekader-2.0.ttl).deze modellen staan in de repository folder van een container. Pagina 6 van 34

7 RWS BEDRIJFSINFORMATIE Handleiding COINS 2.0 versie maart 2017 Meer informatie over COINS is te vinden via De website: Downloadbare COINS bestanden: De wiki: es Het downloadbare documentatie pakket: 01%20Coins%202.0%20Documentatie.zip COINS validator software: Pagina 7 van 34

8 RWS BEDRIJFSINFORMATIE Handleiding voorbeelden COINS 2.0 versie maart Sparql toegang tot de OTL 2.1 Sparql en Sparql software Het semantisch BIM model in een COINS 2.0 container maakt gebruik van de RDF/OWL techniek. Alle RDF/OWL instrumenten kunnen daarom gebruikt worden om te werken met het COINS semantisch BIM model inclusief het COINS core model en dus ook met de OTL. Een krachtig instrument daarbij is de gestandaardiseerde query taal SPARQL. Met behulp van SPARQL is het mogelijk om de OTL te ondervragen. Tevens is het mogelijk om SPARQL te gebruiken om nieuwe informatie toe te voegen volgens de Sparql update standaard. De uiteindelijke container is een zip file met daarin de RDF/OWL files en andere documenten. De Sparql standaard werkt alleen op de RDF/OWL bestanden. Inpakken en uitpakken van de zip file en het beheer van de container en andere documenten valt buiten deze sparql standaard. Er zijn redelijk wat software systemen op de markt, zowel commercieel als opensource, die in staat zijn om RDF/OWL files in te lezen en te ondervragen via SPARQL. Naam Wat Open-source url RDF4J RDF(s) ja Virtuoso triplestore x/ nee MarkLogic Triplestore nee StarDog Triplestore/ nee Jena/ Triplestore/API ja Topbraid RDF/OWL Editor Nee FreeVersion Protege RDF/OWL Editor ja Oracle12c Triplestore nee Daarnaast ondersteunt de COINS 2.0 API ook het gebruik van SPARQL. Meer informatie over Sparql is te vinden via Sparql queries voor de OTL De volgende paragrafen laten zien hoe Sparql gebruikt kan worden om informatie uit de RWS-OTL te halen. De sparql queries werken met rdf datasets. In dit geval zijn dat het COINS core model (cbim-2.0.rdf) en de OTL (otl-2.1.ttl). De precieze naamgeving kan veranderen vanwege bijvoorbeeld updates in de OTL. Merk op dat er 2 bestandsformaten zijn: een RDF/XML bestand en een ttl bestand (Turtle). RDF data kan op meerdere manieren geserialiseerd worden naar een bestand waarvan Turtle en RDF/XML voorbeelden zijn. De meeste rdf implementaties ondersteunen alle gestandaardiseerde formaten. De getoonde screenshots zijn gemaakt in TopBraidComposer. TopBraidComposer is een relatief laagdrempelige tool voor het bevragen en bewerken van ontologieën. Het turtle bestand (OTL*.ttl) uit de COINS container is in te laden in TopBraidComposer. Pagina 8 van 34

9 RWS BEDRIJFSINFORMATIE Handleiding COINS 2.0 versie maart 2017 Dit bestand is gebaseerd op het COINS core model (cbim-2.0.rdf). TBC zal automatisch op zoek gaan naar dit bestand. Indien het lokaal al geregistreerd is in TBC dan zal deze file gebruikt worden. Anders zal TBC online dit bestand downloaden. In de imports tab kan geïnspecteerd worden of het COINS model geïmporteerd is (zie volgend screenshot). Op de FAQ pagina TopBraidComposer is meer informatie te vinden over hoe een ontologie ingeladen kan worden: In alle onderstaande voorbeelden wordt de OTL 2.1 in COINS 2.0 zelf bevraagd, dit is het bestand otl-2.1.ttl. Tip: let bij queries op prefixes in de voorbeeld queries. Pagina 9 van 34

10 RWS BEDRIJFSINFORMATIE Handleiding voorbeelden COINS 2.0 versie maart 2017 Bovenstaande screenshot is van TopBraidComposer waarin de OTL 2.1 is ingeladen Zoek een RWS-OTL object De volgende Sparql query zoekt naar OTL objecten waarin de string Ruimte voorkomt in de naam van het OTL object. Om alleen de OTL Objecten te doorzoeken en dus niet OTL waardelijsten of OTL kenmerken, moet het te zoeken object een verfijning zijn van OB OB is gedefinieerd in de OTL als een (root) Object. In deze query wordt geen prefix gebruikt. Daarom is de gehele URI van het concept nodig. SELECT * WHERE { #Geef mij?otl die uiteindelijk (*) een subtype (rdfs:subclassof) zijn van OTL objecttype "Object" (OB00000)?otl rdfs:subclassof* < # Van?otl geef mij label (rdfs:label), noem dit label?otl rdfs:label?label. # Toon alleen resultaat waar label de tekst "Ruimte" bevat, zoek hoofdletterongevoelig ( "i") filter (regex(?label,"ruimte","i")) } Dit levert het volgende resultaat op: In de linker kolom zijn alle IRI s te vinden van RWS OTL objecten die voldoen aan de zoek query. In de rechter kolom zijn alle labels te vinden waarin Ruimte (hoofdletter ongevoelig) voorkomt. De IRI s zijn gegevens die later gebruikt kunnen worden om objecten te creëren Geef alle mogelijke simpele kenmerken De volgende query geeft alle simpele kenmerken van een OTL object. In dit geval is dat otl:in Het is tevens mogelijk om de simpele kenmerken verder te filteren. Zo is het mogelijk om alleen alle StringProperty objecten te zoeken. 1 Let op: In de OTL 2.1 is het concept OB00000 verwijderd. Pagina 10 van 34

11 RWS BEDRIJFSINFORMATIE Handleiding COINS 2.0 versie maart 2017 Hiervoor kun je in plaats van?property rdfs:subclassof* coins:entityproperty, het volgende gebruiken :?property rdfs:subclassof* coins:stringproperty. prefix coins:< prefix otl:< SELECT?hasProperty?property WHERE { # Vraag van otl objecttype Wegment (otl:in00029) zijn supertypes op ^rdfs:subclassof* # ^ is inverse.?concept ^rdfs:subclassof* otl:in # Haal eigenschappen op van concept.?hasproperty rdfs:domain?concept; # Deze eigenschappen moeten zijn van type coins:hasproperties # Als je dit niet doet kun je ook andere type relaties terugkrijgen rdfs:subpropertyof* coins:hasproperties; # Tot slot; haal de property zelf op. rdfs:range?property. #Beperk tot alleen de StringProperties #?property rdfs:subclassof* coins:stringproperty # Beperk tot alleen de (COINS) EntityProperties?property rdfs:subclassof* coins:entityproperty } Dit levert het volgende op: De OTL van RWS definieert zogenaamde subproperties van de COINS: hasproperties property. Deze worden in de [hasproperty] kolom weergegeven. Met behulp van deze IRI kan er een relatie gelegd worden tussen een object en een Property dat weergegeven is in de [propertyobject] kolom. Beide IRI s zijn nodig om kenmerken aan objecten te koppelen. Dit wordt in een volgend hoofdstuk verder uitgelegd Geef alle mogelijke decomposities De volgende sparql query zoekt naar alle mogelijke decompositie objecten voor Object object met IRI otl:in Pagina 11 van 34

12 RWS BEDRIJFSINFORMATIE Handleiding voorbeelden COINS 2.0 versie maart 2017 prefix coins:< prefix otl:< SELECT distinct?assembly?hascontainsrelations?containsrelation?partof?part WHERE { # Vraag van otl objecttype Wegment (otl:in00029) zijn supertypes op ^rdfs:subclassof*?assembly ^rdfs:subclassof* otl:in # Haal containsrelaties op van concept.?hascontainsrelations rdfs:domain?assembly; # Deze eigenschappen moeten zijn van type coins:hascontainsrelation # Als je dit niet doet kun je ook andere type relaties terugkrijgen rdfs:subpropertyof* coins:hascontainsrelation; # Tot slot; haal de relatie zelf op. rdfs:range?containsrelation. # Haal de onderdelen (coins:partof) zelf op?partof rdfs:range?containsrelation; rdfs:subpropertyof* coins:partof; rdfs:domain?part. } COINS heeft een decompositiestructuur gemodelleerd door een Assembly via een ContainsRelation te koppelen aan een Part. De RWS OTL heeft beperkingen gedefinieerd voor OTL objecten tot welke Parts acceptabel zijn. De achtergrond en strekking van deze beperkingen wordt verder toegelicht in de hoofdstukken `Decompositie van de fysieke objecten en `Voorbeeld uitwerking fysieke decompositie` van de Instructie modelleren op basis van de OTL. Om deze beperkingen te vinden in het COINS bestand worden eerst alle bovenliggende objecten in de taxonomy van OTL:IN00029 (inclusief OTL:IN00029 zelf) doorzocht of er zulke beperkingen bestaan. Zo n beperking is in de OTL gedefinieerd door de introductie van een subproperty van de hascontainsrelation. Voor elke subproperty die verbindbaar is met OTL:IN00029 wordt de bijbehorende ContainsRelation opgezocht en de daarmee verbonden subproperty van PartOf die de daadwerkelijke beperking bevat via rdfs:domain. De Sparql query levert het volgende resultaat op: De [assembly] kolom geeft aan waar de beperking vandaan komt. Het kan natuurlijk zo zijn dat een parent in de taxonomy van klasse een restrictie heeft die via inheritance dan natuurlijk overgedragen wordt aan de childeren. De OTL modelleert de restricties via subproperties van de Coins: hascontainsrelation. Deze subproperties worden weergegeven in de kolom hascontainsrelations. De subproperties verwijzen naar SubClasses van Coins-ContainsRelation in de kolom containsrelation. Deze klasse is weer verbonden met een subproperty van Pagina 12 van 34

13 RWS BEDRIJFSINFORMATIE Handleiding COINS 2.0 versie maart 2017 Coins:partOf, zoals weergegeven in kolom partof. Het rdfs:domain van deze subproperty is weergegeven in de kolom part waarmee een klasse is gevonden die via de subproperties en subtype van ContainsRelation verbonden mag worden met IN Oftewel alle informatie in de tabel is nodig om tot een goede decompositie relatie te komen Geef alle mogelijke DirectedConnection relaties Naast decompositie relaties kunnen objecten ook op andere manieren verbonden worden met elkaar. Een voorbeeld is de realisatie van ruimtelijke objecten door fysieke objecten (in de OTL versie is dit de BoundedBy relatie, in versie 2.1 is het de Realised by relatie). Hiervoor heeft Coins de Connection klasse geïntroduceerd. De DirectedConnection klasse is hiervan een specialisatie. In dit voorbeeld wordt er gezocht naar mogelijke DirectedConnections van het OTL object OBB0030 (Verharde weg). Hiervoor wordt de volgende Sparql query gebruikt: prefix coins:< prefix otl:< SELECT?connection?prop?object?prop2?object2 { { select?connection?prop?object { # de connection moet een subclass (rdfs:subclassof* ) zijn van de coins klasse coins:directedconnection.?connection rdfs:subclassof* coins:directedconnection.?connection rdfs:subclassof*?restriction.?restriction a owl:restriction.?restriction owl:onproperty?prop.?restriction owl:allvaluesfrom/owl:oneof/rdf:rest*/rdf:first?object. # Filter op Verharde weg filter (?ob=< ^rdfs:subclassof*?ob. filter (?ob=< } } optional {?connection rdfs:subclassof*?restriction2.?restriction2 a owl:restriction.?restriction2 owl:onproperty?prop2.?restriction2 owl:allvaluesfrom/owl:oneof/rdf:rest*/rdf:first?object2. } } In deze query wordt er gezocht naar subclasses van coins DirectedConnection waar een owl:restriction aanwezig is via owl:allvaluesfrom. Pagina 13 van 34

14 RWS BEDRIJFSINFORMATIE Handleiding voorbeelden COINS 2.0 versie maart 2017 Vervolgens wordt er in de lijst van owl:allvaluesfrom gezocht naar OBB0030 of bovenliggende objecten in de taxonomie. Deze query vindt de onderstaande mogelijkheden. De [connection] kolom geeft de subclass aan van een DirectedConnection die verbonden kan worden via de prop kolom waarde met een de waarde in de object kolom. Vervolgens kan via de waarde van prop2 de DirectedConnection verbonden worden met de waarde uit object2. Het gaat hier om de realisatie relatie die van Wegvak (IN00025) loopt naar Weg (fysiek object) (OB01083). Weg (fysiek object) is het supertype van Verharde weg (OBB0030), het objecttype waar de query mee begonnen is Lifecycle rollen In de OTL versie 2.1 is het rollenmodel toegevoegd. Voor een uitgebreide uitleg over de rollen kan de handleiding voor het referentiekader gebruikt worden. In de volgende SPARQL query wordt bevraagd welke rollen een Aquaduct kan realiseren. Let op dat de LifeCycle role ook gewoon een OTL klasse is en deze net als een OTL Object een decompositie, kenmerken en directed connections kan hebben. PREFIX coins:< PREFIX otl:< PREFIX mc-mi-types:< PREFIX rf:< SELECT?specification?specLabel?role?roleLabel WHERE { #Selecteer alleen een Aquaduct en haal de specificaties op values?otlconcept { otl:ob00415 }?hasspecification rdfs:domain?otlconcept ; rdfs:range?specification. #pak alleen de relation-roletype, zorgt ervoor dat relation-simple relaties gefiltered worden?specification rdfs:subclassof mc-mi-types:relation-roletype; rdfs:label?speclabel. #Haal vervolgens de rol op die bij de specificatie hoort?hasrealisation rdfs:range?specification ; rdfs:domain?role. #rol moet subclass zijn van Role?role rdfs:subclassof* rf:role; rdfs:label?rolelabel. } En het resultaat: Pagina 14 van 34

15 RWS BEDRIJFSINFORMATIE Handleiding COINS 2.0 versie maart OTL COINS Containers ontwikkelen met behulp van COINS 2.0 API Dit hoofdstuk laat zien hoe je via de COINS 2.0 API COINS containers kunt creëren met daarin gegevens gestructureerd volgens de OTL. Via de COINS website kun je meer informatie vinden over het downloaden en installeren van de COINS API. Tevens zijn er voorbeelden aanwezig hoe je een COINS container kunt creëren. In de volgende paragrafen worden steeds voorbeelden getoond hoe je een COINS container kunt creëren met daarin de OTL met instanties via de COINS 2.0 API in C# Andere mogelijkheden zijn bijvoorbeeld Visual Basic en Java. In de voorbeelden wordt gebruikt gemaakt van een aantal helper functies, deze zijn als volgt: private JenaCoinsContainer constructcontainer(string project_namespace) { //Initialize the container with a model and a project namesapce var modelfactory = new JenaModelFactory(); var container = new JenaCoinsContainer(modelFactory, project_namespace); //Add OTL and reference model default to the container container.addimport(otl21, " true, true, true); container.addimport(otlreference, " referentiekader.rdf#", true, true, true); } return container; Deze functie wordt bij elk voorbeeld automatisch aangeroepen. Vervolgens: /// <summary> /// Creeër een COINS object en typeer deze gelijk volgens het meegegeven OTL Type. /// </summary> /// <param name="otltypeuri">het OTL type. Bijvoorbeeld </param> /// <returns>referentie naar het OTL concept</returns> protected nl.coinsweb.cbim.object createotlconcept(string otltypeuri) { var concept = new nl.coinsweb.cbim.object(container); concept.addtype(otltypeuri); return concept; } Deze bovenstaande code zorgt er dan voor dat er een instantie aangemaakt wordt en deze gelijk volgens de OTL getypeerd is. Pagina 15 van 34

16 RWS BEDRIJFSINFORMATIE Handleiding voorbeelden COINS 2.0 versie maart 2017 Voor het maken van een DirectedConnection wordt de onderstaande code gebruikt; /// <summary> /// Creeër een directed connection tussen een from en to object. Bijvoorbeeld een bounds relatie. /// </summary> /// <param name="fromobject">een OTL getypeerde instantie</param> /// <param name="outgoingrelationuri">het predicate waarmee de role from instantie en de relatie verbonden kunnen worden. Bijvoorbeeld </param> /// <param name="toobject">een OTL getypeerde instantie</param> /// <param name="incomingrelationuri">het predicate waarmee de role to instantie en de relatie verbonden kunnen worden. Bijvoorbeeld /// <returns>the directed connection. Let op dat je deze ZELF nog via <code>.addtype(string)</code> moet typeren als een OTL relatie.</returns> protected DirectedConnection adddirectedconnection(nl.coinsweb.cbim.object fromobject, string outgoingrelationuri, nl.coinsweb.cbim.object toobject, string incomingrelationuri) { //from and to, are already objects, no need to add object as a type var directedconnection = new DirectedConnection(container); //OTL binding fromobject.addobject(outgoingrelationuri, directedconnection); toobject.addobject(incomingrelationuri, directedconnection); //COINS binding directedconnection.setfromobject(fromobject); directedconnection.settoobject(toobject); } return directedconnection; Bovenstaande code zorgt er dan automatisch voor dat het fromobject en toobject aan elkaar gekoppeld worden. De nieuw aangemaakte DirectedConnection moet dan nog wel in een later stadium getypeerd worden volgens de OTL. Pagina 16 van 34

17 RWS BEDRIJFSINFORMATIE Handleiding COINS 2.0 versie maart 2017 Voor het maken van decompositie relaties wordt het volgende gebruikt: /// <summary> /// Creeër decompositie tussen twee OTL instanties. Bijvoorbeeld tussen een beheerobject en element. /// </summary> /// <param name="parent">de Assembly instantie</param> /// <param name="parentrelationuri">het predicate waarmee de OTL assembly en relatie verbonden zijn. Bijvoorbeeld hascontains </param> /// <param name="child">de Part istantie</param> /// <param name="childrelationuri">het predicate waarmee de OTL Part en relatie verbonden zijn. Bijvoorbeeld haspart </param> /// <returns>de decompositierelatie. Let op dat je deze ZELF nog via <code>.addtype(string)</code> moet typeren als een OTL relatie.</returns> protected ContainsRelation adddecomposition(nl.coinsweb.cbim.object parent, string parentrelationuri, nl.coinsweb.cbim.object child, string childrelationuri) { parent.addtype(assembly.classuri); child.addtype(part.classuri); var containsrelation = new ContainsRelation(container); parent.addobject(parentrelationuri, containsrelation); child.addobject(childrelationuri, containsrelation); containsrelation.sethaspart(child.geturi()); containsrelation.sethasassembly(parent.geturi()); } return containsrelation; In deze routine wordt een parent object gekoppeld aan een child object via een instantie van een ContainsRelation. Om deze relatie te mogen gebruiken moet de parent eerst lid worden van de Assembly klasse en moet het child object lid worden van de Part klasse. De API zorgt ervoor dat er geen dubbelingen in de database komen. Vervolgens kan een instantie van ContainsRelation gemaakt worden en gekoppeld worden aan de assembly en part. Zorg ervoor dat je wel de OTL relaties gebruikt tussen bijvoorbeeld een assembly en een containsrelatie. Deze relaties zijn weer te vinden via de sparql queries uit het vorige hoofdstuk. Ook de decompositie relatie heeft waarschijnlijk een extra typering nodig. Tot slot voor het wegschrijven van een container: /// <summary> /// Serializeer het BIM model (de coins container) naar.ccr formaat. /// </summary> /// <param name="path">het pad waar de container opgeslagen dient te worden. Bijvoorbeeld <code>testcontainer.ccr</code></param> protected void serializecontainer(string path) { container.batchaddcoinscontainerobjecttype(); container.export(path); //release resources container.close(); container = null; } Een interessante notitie hier is container.batchaddcoinscontainerobjecttype(). Dit is een handige functie van de COINS2.0 SDK, die alle instanties in het BIM model het type CoinsContainerObject geeft. Pagina 17 van 34

18 RWS BEDRIJFSINFORMATIE Handleiding voorbeelden COINS 2.0 versie maart Netwerk instantiëren Resultaat container: 01_NetwerkRuimteVoorbeeld_OTL21.ccr Het objecttype dat hier geïnstantieerd wordt is Wegennetwerk. Deze instantie wordt vervolgens voorzien van een naam, beschrijving en een userid. De volgende structuur wordt opgebouwd: 2 De volgende code is nodig om de deze structuur op te bouwen. Eerst wordt een COINS Container aangemaakt en wordt via addimport de OTL toegevoegd aan de container. Hiermee is de OTL beschikbaar in de Container in de repository folder van de container. Vervolgens kan er een Cbim:Object geïnstantieerd worden die weer extra getypeerd wordt volgens een URI van de OTL ( Deze URI kan o.a. gevonden worden via de OTL zoek query uit het vorige hoofdstuk. 2 P is in de C# code hernoemt naar wegennetwerk ten behoeve van de leesbaarheid van de code. Pagina 18 van 34

19 RWS BEDRIJFSINFORMATIE Handleiding COINS 2.0 versie maart 2017 class NetwerkRuimteVoorbeeld : ExampleContainer { public NetwerkRuimteVoorbeeld() : base(" { } public override void createcontainerdata() { //Maakt een wegennetwerk aan getypeerd als een OTL Wegennetwerk var wegennetwerk = createotlconcept(" wegennetwerk.setname("wegennetwerk"); wegennetwerk.setdescription("het wegennetwerk"); wegennetwerk.setuserid("id0001"); } public override void serializecontainer() { serializecontainer("01_netwerkruimtevoorbeeld_otl21.ccr"); } } De code levert een COINS container op met daarin de OTL in de repository folder. In de BIM folder is een content.rdf file te vinden (Zie volgende structuur). bim content.rdf repository BranchVersioning.rdf cbim-2.0.rdf COINSWOA.rdf otl-2.1.ttl rws-coins-20-referentiekader-2.0.ttl units-2.0.rdf doc woa woa.rdf Pagina 19 van 34

20 RWS BEDRIJFSINFORMATIE Handleiding voorbeelden COINS 2.0 versie maart 2017 De content.rdf heeft de volgende inhoud: <rdf:rdf xmlns=" xmlns:rdf=" rdf syntax ns#" xmlns:coins2=" 2.0.rdf#" xmlns:owl=" xmlns:xsd=" xmlns:j.0=" xmlns:rdfs=" schema#" xml:base=" <owl:ontology rdf:about=""> <owl:imports rdf:resource=" 2.0.rdf#"/> <coins2:containerid rdf:datatype=" >166e32b5 fbff a </coins2:containerId> <owl:imports rdf:resource=" anchversioning#"/> <owl:imports rdf:resource=" 2.0.rdf#"/> <coins2:creator rdf:resource=" <owl:imports rdf:resource=" <owl:imports rdf:resource=" <owl:imports rdf:resource=" <rdf:type rdf:resource=" 2.0.rdf#CoinsContainerObject"/> </owl:ontology> <coins2:coinscontainerobject rdf:about="# a a8ba a5c57"> <coins2:userid rdf:datatype=" >ID0001</coins2:userID> <coins2:description rdf:datatype=" >Het wegennetwerk</coins2:description> <coins2:name rdf:datatype=" >Wegennetwerk</coins2:name> <rdf:type rdf:resource=" <coins2:creationdate rdf:datatype=" me" > T11:01:12.227Z</coins2:creationDate> <coins2:creator rdf:resource=" <rdf:type rdf:resource=" 2.0.rdf#Object"/> </coins2:coinscontainerobject> </rdf:rdf> 3.2 Decompositie ruimtelijke netwerk 02_DecompositieWegNetwerk1_OTL21.ccr 03_DecompositieWegNetwerk2_OTL21.ccr De volgende voorbeelden laten een decompositie zien van meerdere ruimtelijke objecten. De decompositie relaties worden uit de OTL gehaald. Pagina 20 van 34

21 RWS BEDRIJFSINFORMATIE Handleiding COINS 2.0 versie maart 2017 Vervolgens wordt er een Wegennetwerk gedecomponeerd naar een Wegment. //Maakt een wegennetwerk aan getypeerd als een OTL Wegennetwerk var wegennetwerk = createotlconcept(" wegennetwerk.setname("wegennetwerk"); wegennetwerk.setdescription("het wegennetwerk"); wegennetwerk.setuserid("id0001"); //Maak een wegment aan getypeerd als een OTL Wegment var wegment = createotlconcept(" wegment.setname("wegment#1"); //Creeër vervolgens de decompositie en typeer deze als een OTL decompositie. adddecomposition( wegennetwerk, " rt0002 IN00005 hascontainsrelation", wegment, " rt0002 IN00005 partof" ).addtype(" rt0002 IN00025"); serializecontainer("02_decompositiewegnetwerk1_otl21.ccr"); Met behulp van bovenstaande code wordt een wegennetwerk aangemaakt en vervolgens een Wegment. Daarna wordt een decompositie relatie gelegd tussen het Wegennetwerk en het Wegment en ontstaat de volgende datastructuur: Pagina 21 van 34

22 RWS BEDRIJFSINFORMATIE Handleiding voorbeelden COINS 2.0 versie maart 2017 De volgende code laat een diepere decompositie zien van een ruimtelijk netwerk: //Maakt een wegennetwerk aan getypeerd als een OTL Wegennetwerk var wegennetwerk = createotlconcept(" wegennetwerk.setname("wegennetwerk"); wegennetwerk.setdescription("het wegennetwerk"); wegennetwerk.setuserid("id0001"); //Maak een wegment aan getypeerd als een OTL Wegment var wegment = createotlconcept(" wegment.setname("wegment#1"); //Creeër vervolgens de decompositie en typeer deze als een OTL decompositie. adddecomposition( wegennetwerk, " rt0002 IN00005 hascontainsrelation", wegment, " rt0002 IN00005 partof" ).addtype(" rt0002 IN00025"); //Maak een wegbaan aan getypeerd als een OTL wegbaan var wegbaan = createotlconcept(" wegbaan.setname("wegbaan#2"); //Wegment heeft als onderdeel wegbaan adddecomposition( wegment, " hascontainsrelation", wegbaan, " partof" ).addtype(" //Maak een wegvak aan getypeerd als een OTL wegvak var wegvak1 = createotlconcept(" wegvak1.setname("wegvak#1"); //Wegbaan heeft als onderdeel wegvak adddecomposition( wegbaan, " hascontainsrelation", wegvak1, " partof" ).addtype(" //Maak een 2e wegvak aan getypeerd als een OTL wegvak var wegvak2 = createotlconcept(" adddecomposition( wegbaan, " hascontainsrelation", wegvak2, " partof" ).addtype(" Pagina 22 van 34

23 RWS BEDRIJFSINFORMATIE Handleiding COINS 2.0 versie maart Simpele Kenmerken 04_PropertiesWegment_OTL21.ccr In COINS 2.0 zijn er zogenaamde simpele kenmerken zoals Floats, Strings, DateTime, enz. Het volgende voorbeeld laat zien hoe een dergelijk kenmerk gemaakt kan worden en hoe deze gekoppeld kan worden aan een object. //Maak een wegment aan getypeerd als een OTL Wegment var wegment = createotlconcept(" wegment.setname("wegment#1"); //Maak nu een property DVK letter aan var dvkletter = new StringProperty(Container); dvkletter.addtype(" PRW0041"); dvkletter.setsimpleproperty("hrr"); //Koppel de property volgens de OTL aan de wegment instantie wegment.addobject(" PRW0041 hasproperty", dvkletter); serializecontainer("04_propertieswegment_otl21.ccr"); In dit voorbeeld wordt een IN00029 object aangemaakt en wordt dit object gekoppeld aan een StringProperty met de waarde HRR. Ook kenmerken zoals in dit geval StringProperty moeten getypeerd worden volgens de OTL ( ). Daarnaast wordt een koppeling verwacht het object IN0002 en de StringProperty via ( ). Dit levert de volgende structuur op: Om alle instanties weer lid te maken van COINSContainer object wordt weer het batchaddcoinscontainertype gebruikt. 3.4 Interacties van ruimtelijke netwerken 05_ConnectedWegmenten_OTL21.ccr De OTL heeft enkele type relaties die gelegd kunnen worden tussen objecten. Zo is er natuurlijk de decompositie relatie maar ook de zogenaamde interactie relatie. Deze relatie kan bijvoorbeeld gebruikt worden om twee wegmenten met elkaar te verbinden via een Intersectie. Dit wordt in het volgende voorbeeld uitgewerkt. Pagina 23 van 34

24 RWS BEDRIJFSINFORMATIE Handleiding voorbeelden COINS 2.0 versie maart 2017 In het voorbeeld wordt een wegment gekoppeld aan een intersectie via een COINS DirectedConnection. Alle objecten zijn weer getypeerd volgens de OTL en worden via de batchaddcoinscontainerobjecttype routine weer lid van CoinsContainerObject. Dit resulteert in de volgende code: var wegment1 = createotlconcept(" wegment1.setname("wegment#1"); var intersection = createotlconcept(" intersection.setname("interaction#1"); var connection = adddirectedconnection( wegment1, " hasoutgoingconnections", intersection, " hasincomingconnections" ); connection.setname("wegmentintersectie"); connection.addtype(" serializecontainer("05_connectedwegmenten_otl21.ccr"); 3.5 Realisatie van Ruimtelijke objecten 06_RealisedWegvak_OTL21.ccr De OTL heeft enkele type relaties die gelegd kunnen worden tussen objecten. Hoog in de taxonomie wordt onderscheid gemaakt tussen ruimtelijke en fysieke objecten. Tussen deze twee typeringen is een zogenaamde realisatie relatie mogelijk. Het volgende voorbeeld legt zo n realisatie relatie tussen een wegvak (ruimtelijk object) en een weg (fysiek object). Pagina 24 van 34

25 RWS BEDRIJFSINFORMATIE Handleiding COINS 2.0 versie maart 2017 De volgende code genereert dit voorbeeld. Eerst worden de objecten Wegvak en Weg aangemaakt en vervolgens een DirectedConnection getypeerd volgens de OTL. Vanaf deze connection worden de relateis naar Wegvak en Weg gelegd. Uiteindelijk worden alle instanties weer lid gemaakt van CoinContainerObject. var wegvak = createotlconcept(" wegvak.setname("wegvak#1"); var weg = createotlconcept(" weg.setname("weg#1"); adddirectedconnection( wegvak, " hasoutgoingconnections", weg, " hasincomingconnections" ).addtype(" serializecontainer("06_realisedwegvak_otl21.ccr"); 3.6 Enumeraties 07_WegvakEnum_OTL21.ccr Met enumeraties wordt bedoeld dat een kenmerkwaarde een element is uit een bestaande lijst. Oftewel, de gebruiker moet een keuze maken uit een bestaande lijst van mogelijkheden. De bestaande elementen zijn in de OTL vaak instanties van Coins ComplexPropertyValue. Een ComplexProperty verwijst naar de klasse van deze ComplexPropertyValues. Het volgende voorbeeld laat zien hoe de administratieve richtingscode wordt ingesteld voor een wegvak. In de COINS container worden twee instanties aangemaakt, te weten een wegvak (cbim:object) een richtingscode (cbim:complexproperty). De objectvalue van de richtingscode verwijst naar een bestaande instantie in de OTL (otl#dtib00018). Pagina 25 van 34

26 RWS BEDRIJFSINFORMATIE Handleiding voorbeelden COINS 2.0 versie maart 2017 var wegvak = createotlconcept(" wegvak.setname("wegvak#1"); var administratievecode = new ComplexProperty(Container); administratievecode.addtype(" wegvak.addobject(" hasproperty", administratievecode); administratievecode.addobjectvalue(" serializecontainer("07_wegvakenum_otl21.ccr"); Bovenstaande code genereert een wegvak met een administratieve richtingscode. 3.7 Documenten 10_DocumentReference_OTL21.ccr Het is mogelijk om documenten toe te voegen aan de COINS container en deze te koppelen aan objecten in het BIM-model. Het volgende voorbeeld laat zien hoe een wegment object gekoppeld kan worden aan een documentverwijzing naar voorbeeld.pdf. De volgende code laat zien hoe je deze structuur kunt creëren. Tevens wordt het document toegevoegd aan de container in de doc folder. Pagina 26 van 34

27 RWS BEDRIJFSINFORMATIE Handleiding COINS 2.0 versie maart 2017 var wegment = createotlconcept(" wegment.setname("wegment#1"); var hasdocument = new HasDocument(Container); wegment.addhasproperties(hasdocument); Container.addAttachment("resources/voorbeeld.pdf"); InternalDocumentReference voorbeelddocumentreference = new InternalDocumentReference(Container); hasdocument.addobjectvalue(voorbeelddocumentreference); var filepath = new StringProperty(Container); filepath.setsimpleproperty("voorbeeld.pdf"); voorbeelddocumentreference.setfilepath(filepath); serializecontainer("10_documentreference_otl21.ccr"); 3.8 ShapeRepresentation 09_ExternalShapeRepresentation_OTL21.ccr Naast alle objectinformatie vraagt de OTL ook geometrie van deze objecten uit. Hiervoor zijn zogenaamde inwininstructies opgesteld hoe deze geometrie aangeleverd dient te worden. RWS gebruikt voor GIS de GML standaard aangevuld met het RWS xsd. De inwininstructies zelf zijn terug te vinden in de OTL-Publicatie omgeving of in de OTL. Meer informatie over de inwininstructies is te vinden in het hoofdstuk Geometrie van de Instructie modelleren op basis van de OTL. Pagina 27 van 34

28 RWS BEDRIJFSINFORMATIE Handleiding voorbeelden COINS 2.0 versie maart 2017 In het volgende voorbeeld wordt een Faunaraster gekoppeld aan een feature in een GML file resulterend in de volgende informatiestructuur. Pagina 28 van 34

29 RWS BEDRIJFSINFORMATIE Handleiding COINS 2.0 versie maart 2017 De volgende code laat zien hoe je deze structuur kunt genereren via de COINS API. De GML file wordt toegevoegd aan de CoinsContainer en alle instanties worden weer lid van CoinsContainerObject via de batchaddcoinscontainerobjecttype functie. var faunaraster = createotlconcept(" faunaraster.setname("faunaraster#1"); var geometrischelijn = createotlconcept(" //Koppel een geometrische lijn aan een Faunaraster. var vormprojectie = adddirectedconnection( faunaraster, " ct0050 ct0056 ct0016 OB00715 hasoutgoingconnections", geometrischelijn, " ct0050 ct0056 ct0016 OB00715 hasincomingconnections" ); vormprojectie.addtype(" ct0050 ct0056 ct0016 OB00715"); //Koppel de eigenschap Datum inwinning aan de geometrische lijn var datuminwinning = new DateTimeProperty(Container); datuminwinning.setsimpleproperty(new java.util.date()); //nieuwste datum datuminwinning.addtype(" geometrischelijn.addobject(" hasproperty", datuminwinning); //Vorm projectie is ook een ShapeRepresentationProperty vormprojectie.addtype(hasshaperepresentation.classuri); var shapeproperty = (HasShapeRepresentation) vormprojectie.@as(typeof(hasshaperepresentation)); //Creeër nu de ShapeRepresentation Container.addAttachment("resources/wegenvoorbeeld.gml"); var shaperepresentation = new Shaperepresentation(Container); shaperepresentation.addtype(internaldocumentreference.classuri); shapeproperty.addobjectvalue(shaperepresentation); var documentreference = new InternalDocumentReference(Container, shaperepresentation.geturi(), true); StringProperty filepath = new StringProperty(Container); filepath.setsimpleproperty("wegenvoorbeeld.gml"); documentreference.setfilepath(filepath); StringProperty documentfragment = new StringProperty(Container); documentfragment.setsimpleproperty("gml ID 10"); shaperepresentation.setdocumentfragment(documentfragment);serializecontainer("09_exter nalshaperepresentation_otl21.ccr"); Pagina 29 van 34

30 RWS BEDRIJFSINFORMATIE Handleiding voorbeelden COINS 2.0 versie maart Lifecycle role 11_AquaductLifecycle_OTL21.ccr Wanneer de lifecycle via een specificatie instantie gekoppeld wordt aan een OTL instantie, dan kunnen bijvoorbeeld eigenschappen, relaties en decomposities gekoppeld zijn aan de lifecycle role. In dit geval is er een beheerder aan de lifecycle role beheerobject gekoppeld. Zie hieronder de structuur; 3 3 Voor leesbaarheid is de eigenschap van het viaduct even weggelaten. Pagina 30 van 34

31 RWS BEDRIJFSINFORMATIE Handleiding COINS 2.0 versie maart 2017 In code ziet dat er dan als volgt uit. Eerst wordt een aquaduct gemaakt en vervolgens een lifecycle. Om achter de URI s te komen kan de lifecycle rollen SPARQL gebruikt worden. Vervolgens wordt er een beheerder gekoppeld. Om te weten wat er aan de lifecycle verder hangt kan bijvoorbeeld de directed connection SPARQL gebruikt worden. var aquaduct = createotlconcept(" aquaduct.setname("aquaduct#1"); aquaduct.setuserid("aq0001"); aquaduct.setdescription("aquaduct over de weg"); var beheerobject = createotlconcept(" pc#ncs "); beheerobject.setdescription("aquaduct#1 wordt met deze rol een beheerobject."); //creeër de specification waarmee de rol en aquaduct verbonden zijn var aquaductspeficifeertbeheerobject = createotlconcept(" real OB00415"); aquaduct.addobject(" pc#ncs real OB00415 hasspecification", aquaductspeficifeertbeheerobject); beheerobject.addobject(" pc#ncs real OB00415 hasrealisation", aquaductspeficifeertbeheerobject); //Eigenschap specifiek voor de aquaduct var diskcode = new StringProperty(Container); diskcode.setsimpleproperty("88d "); diskcode.addtype(" NCR "); aquaduct.addobject(" NCR hasproperty", diskcode); //Koppel een beheerder aan beheerobject, deze geld dan ook voor het aquaduct, via de lifecycle dus. var beheerder = createotlconcept(" orgtype#otl orgtypeafdeling"); beheerder.setname("picobello B.V."); beheerder.setdescription("de lokale loodgieter."); beheerder.setuserid("pbv0001"); adddirectedconnection( beheerobject, " pc#ncr hasoutgoingconnections", beheerder, " pc#ncr hasincomingconnections" ).addtype(" pc#ncr "); serializecontainer("11_aquaductlifecycle_otl21.ccr"); Pagina 31 van 34

32 RWS BEDRIJFSINFORMATIE Handleiding voorbeelden COINS 2.0 versie maart Lifecycle met een document 12_LifecycleOTLDocument_OTL21.ccr In de OTL is het ook mogelijk om dan aan de Lifecycle een OTL document te koppelen. Een foto voor een beheerobject is bijvoorbeeld verplicht. Hieronder een model hoe de foto dan gekoppeld is aan het lifecycle object. Zoals het bovenstaande diagram aangeeft wordt een foto op een vergelijkbare manier gekoppeld zoals in het vorige voorbeeld een beheerder gekoppeld is. Wat afwijkt is dat de foto, naast dat het een OTL typering krijgt, ook als een InternalDocumentReference getypeerd is uit COINS. Dit zorgt ervoor dat er een documentkoppeling aangemaakt moet worden, zoals in voorbeeld 10 gedemonstreerd is. Pagina 32 van 34

33 RWS BEDRIJFSINFORMATIE Handleiding COINS 2.0 versie maart 2017 /Creeër een foto met een datum opgesteld en koppel vervolgens de foto als een internal Document var foto = new InternalDocumentReference(Container); foto.addtype(" doctype#dt00180"); //Add foto as a document, but recast it to a Internal Document first var hasdocument = new HasDocument(Container); hasdocument.addobjectvalue(foto); //Bind the foto in the document folder Container.addAttachment("resources/aquaduct.jpg"); var filepath = new StringProperty(Container); filepath.setsimpleproperty("aquaduct.jpg"); foto.setfilepath(filepath); //Add a property to the photo object var datumopgesteld = new DateTimeProperty(Container); datumopgesteld.setsimpleproperty(new java.util.date()); datumopgesteld.addtype(" doctype#ncr "); foto.addobject(" doctype#ncr hasproperty", datumopgesteld); //Bind the foto to the Lifecycle object adddirectedconnection( beheerobject, " pc#ncr hasoutgoingconnections", (nl.coinsweb.cbim.object)foto.@as(typeof(nl.coinsweb.cbim.object)), " pc#ncr hasincomingconnections" ).addtype(" pc#ncr "); serializecontainer("12_lifecycleotldocument_otl21.ccr"); Pagina 33 van 34

34 RWS BEDRIJFSINFORMATIE Handleiding voorbeelden COINS 2.0 versie maart Bijlage UML Class diagram van COINS 2.0 Pagina 34 van 34