3395 lines
225 KiB
Python
3395 lines
225 KiB
Python
import json, sys
|
|
from flask import Flask, request, jsonify
|
|
from ifcProject import project
|
|
from ifcShape import shape
|
|
from ifcGeometricContext import geometric
|
|
from rdflib import Graph, Namespace, URIRef, Literal, RDF, RDFS, XSD
|
|
from rdflib import Graph
|
|
from SPARQLWrapper import SPARQLWrapper, POST, BASIC, URLENCODED
|
|
|
|
# Create a new RDF graph
|
|
g = Graph()
|
|
# Define a custom namespace
|
|
ontology = Namespace("http://sincere.org/s1#")
|
|
resource = Namespace("http://sincere.org/s1/resource/")
|
|
g.bind('sincere', ontology)
|
|
|
|
def jsonReader():
|
|
# Open the JSON file for reading
|
|
with open('models/pipes.json', 'r') as file:
|
|
# Load the JSON data
|
|
ifcJson = json.load(file)
|
|
|
|
return ifcJson
|
|
|
|
def parser(ifcJson):
|
|
timestamp, schemaIdentifier, originatingSystem, preprocessorVersion = ifcJson["timeStamp"], ifcJson["schemaIdentifier"], ifcJson["originatingSystem"], ifcJson["preprocessorVersion"]
|
|
|
|
IfcBuildingStorey, IfcRelDefinesByType, IfcBeamType, IfcRelFillsElement, IfcDoor, IfcOwnerHistory, ifcSlabType, IfcRelContainedInSpatialStructure, IfcRelAssociatesMaterial, \
|
|
IfcBuilding, IfcColumnType, IfcColumn, IfcMemberType, IfcSite, IfcOpeningElement, IfcRelAggregates, IfcGeometricRepresentationContext, IfcWindowLiningProperties, IfcRelVoidsElement, \
|
|
IfcDoorType, IfcGeometricRepresentationSubContext, IfcDoorLiningProperties, IfcRelDefinesByProperties, IfcWallType, IfcWindowType, IfcWall, IfcWindow, IfcGroup, IfcRelAssignsToGroup, \
|
|
IfcProject, IfcPropertySet, IfcSlab, IfcDoorPanelProperties, IfcMember, IfcElementQuantity, IfcBeam, IfcShapeRepresentation \
|
|
= [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], []
|
|
|
|
types = []
|
|
for data in ifcJson["data"]:
|
|
types.append(data['type'])
|
|
if data['type'] == "IfcBuildingStorey":
|
|
IfcBuildingStorey.append(data)
|
|
elif data['type'] == "IfcRelDefinesByType":
|
|
IfcRelDefinesByType.append(data)
|
|
elif data['type'] == "IfcBeamType":
|
|
IfcBeamType.append(data)
|
|
elif data['type'] == "IfcRelFillsElement":
|
|
IfcRelFillsElement.append(data)
|
|
elif data['type'] == "IfcDoor":
|
|
IfcDoor.append(data)
|
|
elif data['type'] == "IfcOwnerHistory":
|
|
IfcOwnerHistory.append(data)
|
|
elif data['type'] == "IfcSlabType":
|
|
ifcSlabType.append(data)
|
|
elif data['type'] == "IfcRelContainedInSpatialStructure":
|
|
IfcRelContainedInSpatialStructure.append(data)
|
|
elif data['type'] == "IfcRelAssociatesMaterial":
|
|
IfcRelAssociatesMaterial.append(data)
|
|
elif data['type'] == "IfcBuilding":
|
|
IfcBuilding.append(data)
|
|
elif data['type'] == "IfcColumnType":
|
|
IfcColumnType.append(data)
|
|
elif data['type'] == "IfcColumn":
|
|
IfcColumn.append(data)
|
|
elif data['type'] == "IfcMemberType":
|
|
IfcMemberType.append(data)
|
|
elif data['type'] == "IfcSite":
|
|
IfcSite.append(data)
|
|
elif data['type'] == "IfcOpeningElement":
|
|
IfcOpeningElement.append(data)
|
|
elif data['type'] == "IfcRelAggregates":
|
|
IfcRelAggregates.append(data)
|
|
elif data['type'] == "IfcGeometricRepresentationContext":
|
|
IfcGeometricRepresentationContext.append(data)
|
|
elif data['type'] == "IfcWindowLiningProperties":
|
|
IfcWindowLiningProperties.append(data)
|
|
elif data['type'] == "IfcRelVoidsElement":
|
|
IfcRelVoidsElement.append(data)
|
|
elif data['type'] == "IfcDoorType":
|
|
IfcDoorType.append(data)
|
|
elif data['type'] == "IfcGeometricRepresentationSubContext":
|
|
IfcGeometricRepresentationSubContext.append(data)
|
|
elif data['type'] == "IfcDoorLiningProperties":
|
|
IfcDoorLiningProperties.append(data)
|
|
elif data['type'] == "IfcRelDefinesByProperties":
|
|
IfcRelDefinesByProperties.append(data)
|
|
elif data['type'] == "IfcWallType":
|
|
IfcWallType.append(data)
|
|
elif data['type'] == "IfcWindowType":
|
|
IfcWindowType.append(data)
|
|
elif data['type'] == "IfcWall":
|
|
IfcWall.append(data)
|
|
elif data['type'] == "IfcWindow":
|
|
IfcWindow.append(data)
|
|
elif data['type'] == "IfcGroup":
|
|
IfcGroup.append(data)
|
|
elif data['type'] == "IfcRelAssignsToGroup":
|
|
IfcRelAssignsToGroup.append(data)
|
|
elif data['type'] == "IfcProject":
|
|
IfcProject.append(data)
|
|
elif data['type'] == "IfcPropertySet":
|
|
IfcPropertySet.append(data)
|
|
elif data['type'] == "IfcSlab":
|
|
IfcSlab.append(data)
|
|
elif data['type'] == "IfcDoorPanelProperties":
|
|
IfcDoorPanelProperties.append(data)
|
|
elif data['type'] == "IfcMember":
|
|
IfcMember.append(data)
|
|
elif data['type'] == "IfcElementQuantity":
|
|
IfcElementQuantity.append(data)
|
|
elif data['type'] == "IfcBeam":
|
|
IfcBeam.append(data)
|
|
elif data['type'] == "IfcShapeRepresentation":
|
|
IfcShapeRepresentation.append(data)
|
|
|
|
return IfcBuildingStorey, IfcRelDefinesByType, IfcBeamType, IfcRelFillsElement, IfcDoor, IfcOwnerHistory, ifcSlabType, IfcRelContainedInSpatialStructure, IfcRelAssociatesMaterial,\
|
|
IfcBuilding, IfcColumnType, IfcColumn, IfcMemberType, IfcSite, IfcOpeningElement, IfcRelAggregates, IfcGeometricRepresentationContext, IfcWindowLiningProperties, IfcRelVoidsElement, \
|
|
IfcDoorType, IfcGeometricRepresentationSubContext, IfcDoorLiningProperties, IfcRelDefinesByProperties, IfcWallType, IfcWindowType, IfcWall, IfcWindow, IfcGroup, IfcRelAssignsToGroup, \
|
|
IfcProject, IfcPropertySet, IfcSlab, IfcDoorPanelProperties, IfcMember, IfcElementQuantity, IfcBeam, IfcShapeRepresentation
|
|
|
|
def ifcBuildingStoreyFunction(IfcBuildingStorey):
|
|
for building in IfcBuildingStorey:
|
|
buildingID = building['globalId']
|
|
#basic information
|
|
g.add((resource[buildingID], RDF.type, ontology.BuildingStorey))
|
|
try:#add history
|
|
buildingHistory = building['ownerHistory']['ref']
|
|
g.add((resource[buildingHistory], RDF.type, ontology.History))
|
|
g.add((resource[buildingID], ontology.hasHistory, resource[buildingHistory]))
|
|
except Exception:
|
|
pass
|
|
try:#decompose is not always there
|
|
for representation in building['decomposes']:
|
|
rep = representation['ref']
|
|
g.add((resource[rep], RDF.type, ontology.Object))
|
|
g.add((resource[buildingID], ontology.decomposes, resource[rep]))
|
|
except Exception:
|
|
pass
|
|
try:#definedby is not always there
|
|
for defined in building['isDefinedBy']:
|
|
issdefined= defined['ref']
|
|
g.add((resource[issdefined], RDF.type, ontology.PropertySet))
|
|
g.add((resource[buildingID], ontology.isDefinedBy, resource[issdefined]))
|
|
except Exception:
|
|
pass
|
|
try:#containsElements is not always there
|
|
for representation in building['containsElements']:
|
|
rep = representation['ref']
|
|
g.add((resource[rep], RDF.type, ontology.Structure))
|
|
g.add((resource[buildingID], ontology.containsElements, resource[rep]))
|
|
except Exception:
|
|
pass
|
|
try:#add composition
|
|
buildingType = building['compositionType']
|
|
g.add((resource[buildingID], ontology.composition, Literal(buildingType)))
|
|
except Exception:
|
|
pass
|
|
try:#add longName
|
|
longNameType = building['longName']
|
|
g.add((resource[buildingID], ontology.longName, Literal(longNameType)))
|
|
except Exception:
|
|
pass
|
|
try:#add elevation
|
|
buildingElevation = building['elevation']
|
|
g.add((resource[buildingID], ontology.elevation, Literal(buildingElevation)))
|
|
except Exception:
|
|
pass
|
|
try:#add objectType
|
|
buildingObjectType = building['objectType']
|
|
g.add((resource[buildingID], ontology.type, Literal(buildingObjectType)))
|
|
except Exception:
|
|
pass
|
|
try:#name is not always there
|
|
buildingName = building['name']
|
|
g.add((resource[buildingID], ontology.name, Literal(buildingName)))
|
|
except Exception:
|
|
pass
|
|
try:#name is not always there
|
|
buildingNameLong = building['longName']
|
|
g.add((resource[buildingID], ontology.longName, Literal(buildingNameLong)))
|
|
except Exception:
|
|
pass
|
|
|
|
try:#representationMaps data
|
|
g.add((resource[buildingID], ontology.hasPlacement, resource["plamenent_" + buildingID + "_1"]))
|
|
g.add((resource["plamenent_" + buildingID + "_1"], RDF.type, ontology.Placement))
|
|
g.add((resource["plamenent_" + buildingID + "_1"], ontology.xlocation, Literal(building['objectPlacement']['relativePlacement']['location']['coordinates'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + buildingID + "_1"], ontology.ylocation, Literal(building['objectPlacement']['relativePlacement']['location']['coordinates'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + buildingID + "_1"], ontology.zlocation, Literal(building['objectPlacement']['relativePlacement']['location']['coordinates'][2], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + buildingID + "_1"], ontology.xaxis,
|
|
Literal(building['objectPlacement']['relativePlacement']['axis']['directionRatios'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + buildingID + "_1"], ontology.yaxis,
|
|
Literal(building['objectPlacement']['relativePlacement']['axis']['directionRatios'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + buildingID + "_1"], ontology.zaxis,
|
|
Literal(building['objectPlacement']['relativePlacement']['axis']['directionRatios'][2], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + buildingID + "_1"], ontology.xdirection,
|
|
Literal(building['objectPlacement']['relativePlacement']['refDirection']['directionRatios'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + buildingID + "_1"], ontology.ydirection,
|
|
Literal(building['objectPlacement']['relativePlacement']['refDirection']['directionRatios'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + buildingID + "_1"], ontology.zdirection,
|
|
Literal(building['objectPlacement']['relativePlacement']['refDirection']['directionRatios'][2], datatype=XSD.decimal)))
|
|
except Exception:
|
|
pass
|
|
try:
|
|
g.add((resource[buildingID], ontology.hasPlacement, resource["plamenent_" + buildingID + "_2"]))
|
|
g.add((resource["plamenent_" + buildingID + "_2"], RDF.type, ontology.Placement))
|
|
g.add((resource["plamenent_" + buildingID + "_2"], ontology.xlocation, Literal(building['objectPlacement']['placementRelTo']['relativePlacement']['location']['coordinates'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + buildingID + "_2"], ontology.ylocation, Literal(building['objectPlacement']['placementRelTo']['relativePlacement']['location']['coordinates'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + buildingID + "_2"], ontology.zlocation, Literal(building['objectPlacement']['placementRelTo']['relativePlacement']['location']['coordinates'][2], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + buildingID + "_2"], ontology.xaxis,
|
|
Literal(building['objectPlacement']['placementRelTo']['relativePlacement']['axis']['directionRatios'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + buildingID + "_2"], ontology.yaxis,
|
|
Literal(building['objectPlacement']['placementRelTo']['relativePlacement']['axis']['directionRatios'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + buildingID + "_2"], ontology.zaxis,
|
|
Literal(building['objectPlacement']['placementRelTo']['relativePlacement']['axis']['directionRatios'][2], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + buildingID + "_2"], ontology.xdirection,
|
|
Literal(building['objectPlacement']['placementRelTo']['relativePlacement']['refDirection']['directionRatios'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + buildingID + "_2"], ontology.ydirection,
|
|
Literal(building['objectPlacement']['placementRelTo']['relativePlacement']['refDirection']['directionRatios'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + buildingID + "_2"], ontology.zdirection,
|
|
Literal(building['objectPlacement']['placementRelTo']['relativePlacement']['refDirection']['directionRatios'][2], datatype=XSD.decimal)))
|
|
except Exception:
|
|
pass
|
|
try:
|
|
g.add((resource[buildingID], ontology.hasPlacement, resource["plamenent_" + buildingID + "_3"]))
|
|
g.add((resource["plamenent_" + buildingID + "_3"], RDF.type, ontology.Placement))
|
|
g.add((resource["plamenent_" + buildingID + "_3"], ontology.xlocation, Literal(building['objectPlacement']['placementRelTo']['placementRelTo']['relativePlacement']['location']['coordinates'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + buildingID + "_3"], ontology.ylocation, Literal(building['objectPlacement']['placementRelTo']['placementRelTo']['relativePlacement']['location']['coordinates'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + buildingID + "_3"], ontology.zlocation, Literal(building['objectPlacement']['placementRelTo']['placementRelTo']['relativePlacement']['location']['coordinates'][2], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + buildingID + "_3"], ontology.xaxis,
|
|
Literal(building['objectPlacement']['placementRelTo']['placementRelTo']['relativePlacement']['axis']['directionRatios'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + buildingID + "_3"], ontology.yaxis,
|
|
Literal(building['objectPlacement']['placementRelTo']['placementRelTo']['relativePlacement']['axis']['directionRatios'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + buildingID + "_3"], ontology.zaxis,
|
|
Literal(building['objectPlacement']['placementRelTo']['placementRelTo']['relativePlacement']['axis']['directionRatios'][2], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + buildingID + "_3"], ontology.xdirection,
|
|
Literal(building['objectPlacement']['placementRelTo']['placementRelTo']['relativePlacement']['refDirection']['directionRatios'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + buildingID + "_3"], ontology.ydirection,
|
|
Literal(building['objectPlacement']['placementRelTo']['placementRelTo']['relativePlacement']['refDirection']['directionRatios'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + buildingID + "_3"], ontology.zdirection,
|
|
Literal(building['objectPlacement']['placementRelTo']['placementRelTo']['relativePlacement']['refDirection']['directionRatios'][2], datatype=XSD.decimal)))
|
|
except Exception:
|
|
pass
|
|
return 1
|
|
|
|
def ifcRelDefinesByTypeFunction(IfcRelDefinesByType):
|
|
for bytype in IfcRelDefinesByType:
|
|
bytypeID = bytype['globalId']
|
|
#basic information
|
|
g.add((resource[bytypeID], RDF.type, ontology.Representation))
|
|
try:#add history
|
|
bytypeHistory = bytype['ownerHistory']['ref']
|
|
g.add((resource[bytypeHistory], RDF.type, ontology.History))
|
|
g.add((resource[bytypeID], ontology.hasHistory, resource[bytypeHistory]))
|
|
except Exception:
|
|
pass
|
|
try:
|
|
for related in bytype['relatedObjects']:
|
|
g.add((resource[related['ref']], RDF.type, ontology.Object))
|
|
g.add((resource[bytypeID], ontology.relatedObject, resource[related['ref']]))
|
|
except Exception:
|
|
pass
|
|
try:
|
|
g.add((resource[bytype['relatingType']['ref']], RDF.type, ontology.Representation))
|
|
g.add((resource[bytypeID], ontology.relatingType, resource[bytype['relatingType']['ref']]))
|
|
except Exception:
|
|
pass
|
|
return 1
|
|
|
|
def ifcBeamTypeFunction(IfcBeamType):
|
|
for beamtype in IfcBeamType:
|
|
beamID = beamtype['globalId']
|
|
#basic information
|
|
g.add((resource[beamID], RDF.type, ontology.BeamType))
|
|
try:#name is not always there
|
|
beamName = beamtype['name']
|
|
g.add((resource[beamID], ontology.name, Literal(beamName)))
|
|
except Exception:
|
|
pass
|
|
try:#name is not always there
|
|
beamPredefinedType = beamtype['predefinedType']
|
|
g.add((resource[beamID], ontology.predefineType, Literal(beamPredefinedType)))
|
|
except Exception:
|
|
pass
|
|
try:#add history
|
|
beamOwnerHistory = beamtype['ownerHistory']['ref']
|
|
g.add((resource[beamOwnerHistory], RDF.type, ontology.History))
|
|
g.add((resource[beamID], ontology.hasHistory, resource[ beamOwnerHistory]))
|
|
except Exception:
|
|
pass
|
|
try:#add history
|
|
beamTag = beamtype['tag']
|
|
g.add((resource[beamID], ontology.tag, Literal(beamTag)))
|
|
except Exception:
|
|
pass
|
|
try:#material is not always there
|
|
for material in beamtype['hasAssociations']:
|
|
ismaterial = material['ref']
|
|
g.add((resource[ismaterial], RDF.type, ontology.Material))
|
|
g.add((resource[beamID], ontology.associatesMaterial, resource[ismaterial]))
|
|
except Exception:
|
|
pass
|
|
try:#material is not always there
|
|
for typed in beamtype['types']:
|
|
istyped = typed['ref']
|
|
g.add((resource[istyped], RDF.type, ontology.TypeCategory))
|
|
g.add((resource[beamID], ontology.hasType, resource[istyped]))
|
|
except Exception:
|
|
pass
|
|
try:#object is not always there
|
|
count = 1
|
|
for prp in beamtype['hasPropertySets']:
|
|
isprp = prp['ref']
|
|
g.add((resource["propertyset_" + isprp + "_" + str(count)], RDF.type, ontology.PropertySet))
|
|
g.add((resource[beamID], ontology.hasProperty, resource["propertyset_" + isprp + "_" + str(count)]))
|
|
count += 1
|
|
except Exception:
|
|
pass
|
|
try:#representationMaps data
|
|
for maps in beamtype['representationMaps']:
|
|
#print(maps['mappingOrigin'])
|
|
g.add((resource[beamID], ontology.hasRepresentationType, resource[ maps['mappedRepresentation']['ref']]))
|
|
g.add((resource[ maps['mappedRepresentation']['ref']], RDF.type, ontology.Representation))
|
|
g.add((resource[ maps['mappedRepresentation']['ref']], ontology.xlocation, Literal(maps['mappingOrigin']['location']['coordinates'][0], datatype=XSD.decimal)))
|
|
g.add((resource[ maps['mappedRepresentation']['ref']], ontology.ylocation, Literal(maps['mappingOrigin']['location']['coordinates'][1], datatype=XSD.decimal)))
|
|
g.add((resource[ maps['mappedRepresentation']['ref']], ontology.zlocation, Literal(maps['mappingOrigin']['location']['coordinates'][2], datatype=XSD.decimal)))
|
|
|
|
except Exception:
|
|
pass
|
|
try:#representationMaps data
|
|
for maps in beamtype['representationMaps']:
|
|
#print(maps['mappingOrigin'])
|
|
g.add((resource[beamID], ontology.hasRepresentationType, resource[ maps['mappedRepresentation']['ref']]))
|
|
g.add((resource[ maps['mappedRepresentation']['ref']], ontology.xaxis,
|
|
Literal(maps['mappingOrigin']['axis']['directionRatios'][0], datatype=XSD.decimal)))
|
|
g.add((resource[ maps['mappedRepresentation']['ref']], ontology.yaxis,
|
|
Literal(maps['mappingOrigin']['axis']['directionRatios'][1], datatype=XSD.decimal)))
|
|
g.add((resource[ maps['mappedRepresentation']['ref']], ontology.zaxis,
|
|
Literal(maps['mappingOrigin']['axis']['directionRatios'][2], datatype=XSD.decimal)))
|
|
except Exception:
|
|
pass
|
|
try:#representationMaps data
|
|
for maps in beamtype['representationMaps']:
|
|
|
|
g.add((resource[ maps['mappedRepresentation']['ref']], ontology.xdirection,
|
|
Literal(maps['mappingOrigin']['refDirection']['directionRatios'][0], datatype=XSD.decimal)))
|
|
g.add((resource[ maps['mappedRepresentation']['ref']], ontology.ydirection,
|
|
Literal(maps['mappingOrigin']['refDirection']['directionRatios'][1], datatype=XSD.decimal)))
|
|
g.add((resource[ maps['mappedRepresentation']['ref']], ontology.zdirection,
|
|
Literal(maps['mappingOrigin']['refDirection']['directionRatios'][2], datatype=XSD.decimal)))
|
|
except Exception:
|
|
pass
|
|
return 1
|
|
|
|
def ifcRelFillsElementFunction(IfcRelFillsElement):
|
|
for fills in IfcRelFillsElement:
|
|
fillsID = fills['globalId']
|
|
#basic information
|
|
g.add((resource[fillsID], RDF.type, ontology.Object))
|
|
try:#add history
|
|
fillsHistory = fills['ownerHistory']['ref']
|
|
g.add((resource[fillsHistory], RDF.type, ontology.History))
|
|
g.add((resource[fillsID], ontology.hasHistory, resource[fillsHistory]))
|
|
except Exception:
|
|
pass
|
|
try:#relatingOpeningElement is not always there
|
|
relating = fills['relatingOpeningElement']['ref']
|
|
g.add((resource[relating], RDF.type, ontology.Opening))
|
|
g.add((resource[fillsID], ontology.relatingOpeningElement, resource[relating]))
|
|
except Exception:
|
|
pass
|
|
try:#relatedBuildingElement is not always there
|
|
related = fills['relatedBuildingElement']['ref']
|
|
g.add((resource[related], RDF.type, ontology.Object))
|
|
g.add((resource[fillsID], ontology.relatedBuildingElement, resource[related]))
|
|
except Exception:
|
|
pass
|
|
return 1
|
|
|
|
def ifcDoorFunction(IfcDoor):
|
|
for door in IfcDoor:
|
|
doorID, doorHeight, doorWidth = door['globalId'], door['overallHeight'], door['overallWidth']
|
|
#basic information
|
|
g.add((resource[doorID], RDF.type, ontology.Door))
|
|
g.add((resource[doorID], ontology.height, Literal(doorHeight)))
|
|
g.add((resource[doorID], ontology.width, Literal(doorWidth)))
|
|
try:#add history
|
|
doorHistory = door['ownerHistory']['ref']
|
|
g.add((resource[doorHistory], RDF.type, ontology.History))
|
|
g.add((resource[doorID], ontology.hasHistory, resource[doorHistory]))
|
|
except Exception:
|
|
pass
|
|
try:#tag is not always there
|
|
doorTag = door['tag']
|
|
g.add((resource[doorID], ontology.tag, Literal(doorTag)))
|
|
except Exception:
|
|
pass
|
|
try:#predefinedType is not always there
|
|
doorType = door['predefinedType']
|
|
g.add((resource[doorID], ontology.predefinedType, Literal(doorType)))
|
|
except Exception:
|
|
pass
|
|
try:#operationType is not always there
|
|
doorOperation = door['operationType']
|
|
g.add((resource[doorID], ontology.operationType, Literal(doorOperation)))
|
|
except Exception:
|
|
pass
|
|
try:#operationType is not always there
|
|
doorObject = door['objectType']
|
|
g.add((resource[doorID], ontology.type, Literal(doorObject)))
|
|
except Exception:
|
|
pass
|
|
try:#name is not always there
|
|
doorName = door['name']
|
|
g.add((resource[doorID], ontology.name, Literal(doorName)))
|
|
except Exception:
|
|
pass
|
|
try:#definedby is not always there
|
|
for defined in door['isDefinedBy']:
|
|
issdefined= defined['ref']
|
|
g.add((resource[issdefined], RDF.type, ontology.PropertySet))
|
|
g.add((resource[doorID], ontology.isDefinedBy, resource[issdefined]))
|
|
except Exception:
|
|
pass
|
|
try:#representation is not always there
|
|
for representation in door['representation']['representations']:
|
|
rep = representation['ref']
|
|
g.add((resource[rep], RDF.type, ontology.Context))
|
|
g.add((resource[doorID], ontology.hasContext, resource[rep]))
|
|
except Exception:
|
|
pass
|
|
try:#isTypedBy is not always there
|
|
for typed in door['isTypedBy']:
|
|
istyped = typed['ref']
|
|
g.add((resource[istyped], RDF.type, ontology.TypeCategory))
|
|
g.add((resource[doorID], ontology.hasType, resource[istyped]))
|
|
except Exception:
|
|
pass
|
|
try:#fillsVoid is not always there
|
|
for void in door['fillsVoids']:
|
|
isvoid = void['ref']
|
|
g.add((resource[isvoid], RDF.type, ontology.Void))
|
|
g.add((resource[doorID], ontology.fillsVoid, resource[isvoid]))
|
|
except Exception:
|
|
pass
|
|
try:#structure is not always there
|
|
for structure in door['containedInStructure']:
|
|
isstructure= structure['ref']
|
|
g.add((resource[isstructure], RDF.type, ontology.Structure))
|
|
g.add((resource[doorID], ontology.inStructure, resource[isstructure]))
|
|
except Exception:
|
|
pass
|
|
try:#boundaries is not always there
|
|
for boundary in door['providesBoundaries']:
|
|
isboundary = boundary['ref']
|
|
g.add((resource[isboundary], RDF.type, ontology.Boundaries))
|
|
g.add((resource[doorID], ontology.providesBoundaries, resource[isboundary]))
|
|
except Exception:
|
|
pass
|
|
try:#decompose is not always there
|
|
for representation in door['decomposes']:
|
|
rep = representation['ref']
|
|
g.add((resource[rep], RDF.type, ontology.Object))
|
|
g.add((resource[doorID], ontology.decomposes, resource[rep]))
|
|
except Exception:
|
|
pass
|
|
try:#material is not always there
|
|
for material in door['hasAssociations']:
|
|
ismaterial = material['ref']
|
|
g.add((resource[ismaterial], RDF.type, ontology.Material))
|
|
g.add((resource[doorID], ontology.associatesMaterial, resource[ismaterial]))
|
|
except Exception:
|
|
pass
|
|
try:#hasAssociations is not always there
|
|
for typed in door['hasAssignments']:
|
|
iselement = typed['ref']
|
|
g.add((resource[iselement], RDF.type, ontology.Group))
|
|
g.add((resource[doorID], ontology.hasAssignments, resource[iselement]))
|
|
except Exception:
|
|
pass
|
|
try: # representationMaps data
|
|
g.add((resource[doorID], ontology.hasPlacement, resource["plamenent_" + doorID + "_1"]))
|
|
g.add((resource["plamenent_" + doorID + "_1"], RDF.type, ontology.Placement))
|
|
g.add((resource["plamenent_" + doorID + "_1"], ontology.xlocation,
|
|
Literal(door['objectPlacement']['relativePlacement']['location']['coordinates'][0],
|
|
datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + doorID + "_1"], ontology.ylocation,
|
|
Literal(door['objectPlacement']['relativePlacement']['location']['coordinates'][1],
|
|
datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + doorID + "_1"], ontology.zlocation,
|
|
Literal(door['objectPlacement']['relativePlacement']['location']['coordinates'][2],
|
|
datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + doorID + "_1"], ontology.xaxis,
|
|
Literal(door['objectPlacement']['relativePlacement']['axis']['directionRatios'][0],
|
|
datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + doorID + "_1"], ontology.yaxis,
|
|
Literal(door['objectPlacement']['relativePlacement']['axis']['directionRatios'][1],
|
|
datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + doorID + "_1"], ontology.zaxis,
|
|
Literal(door['objectPlacement']['relativePlacement']['axis']['directionRatios'][2],
|
|
datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + doorID + "_1"], ontology.xdirection,
|
|
Literal(door['objectPlacement']['relativePlacement']['refDirection']['directionRatios'][0],
|
|
datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + doorID + "_1"], ontology.ydirection,
|
|
Literal(door['objectPlacement']['relativePlacement']['refDirection']['directionRatios'][1],
|
|
datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + doorID + "_1"], ontology.zdirection,
|
|
Literal(door['objectPlacement']['relativePlacement']['refDirection']['directionRatios'][2],
|
|
datatype=XSD.decimal)))
|
|
except Exception:
|
|
pass
|
|
try:
|
|
g.add((resource[doorID], ontology.hasPlacement, resource["plamenent_" + doorID + "_2"]))
|
|
g.add((resource["plamenent_" + doorID + "_2"], RDF.type, ontology.Placement))
|
|
g.add((resource["plamenent_" + doorID + "_2"], ontology.xlocation, Literal(
|
|
door['objectPlacement']['placementRelTo']['relativePlacement']['location']['coordinates'][0],
|
|
datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + doorID + "_2"], ontology.ylocation, Literal(
|
|
door['objectPlacement']['placementRelTo']['relativePlacement']['location']['coordinates'][1],
|
|
datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + doorID + "_2"], ontology.zlocation, Literal(
|
|
door['objectPlacement']['placementRelTo']['relativePlacement']['location']['coordinates'][2],
|
|
datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + doorID + "_2"], ontology.xaxis,
|
|
Literal(
|
|
door['objectPlacement']['placementRelTo']['relativePlacement']['axis']['directionRatios'][0],
|
|
datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + doorID + "_2"], ontology.yaxis,
|
|
Literal(
|
|
door['objectPlacement']['placementRelTo']['relativePlacement']['axis']['directionRatios'][1],
|
|
datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + doorID + "_2"], ontology.zaxis,
|
|
Literal(
|
|
door['objectPlacement']['placementRelTo']['relativePlacement']['axis']['directionRatios'][2],
|
|
datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + doorID + "_2"], ontology.xdirection,
|
|
Literal(door['objectPlacement']['placementRelTo']['relativePlacement']['refDirection'][
|
|
'directionRatios'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + doorID + "_2"], ontology.ydirection,
|
|
Literal(door['objectPlacement']['placementRelTo']['relativePlacement']['refDirection'][
|
|
'directionRatios'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + doorID + "_2"], ontology.zdirection,
|
|
Literal(door['objectPlacement']['placementRelTo']['relativePlacement']['refDirection'][
|
|
'directionRatios'][2], datatype=XSD.decimal)))
|
|
except Exception:
|
|
pass
|
|
try:
|
|
g.add((resource[doorID], ontology.hasPlacement, resource["plamenent_" + doorID + "_3"]))
|
|
g.add((resource["plamenent_" + doorID + "_3"], RDF.type, ontology.Placement))
|
|
g.add((resource["plamenent_" + doorID + "_3"], ontology.xlocation, Literal(
|
|
door['objectPlacement']['placementRelTo']['placementRelTo']['relativePlacement']['location'][
|
|
'coordinates'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + doorID + "_3"], ontology.ylocation, Literal(
|
|
door['objectPlacement']['placementRelTo']['placementRelTo']['relativePlacement']['location'][
|
|
'coordinates'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + doorID + "_3"], ontology.zlocation, Literal(
|
|
door['objectPlacement']['placementRelTo']['placementRelTo']['relativePlacement']['location'][
|
|
'coordinates'][2], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + doorID + "_3"], ontology.xaxis,
|
|
Literal(door['objectPlacement']['placementRelTo']['placementRelTo']['relativePlacement']['axis'][
|
|
'directionRatios'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + doorID + "_3"], ontology.yaxis,
|
|
Literal(door['objectPlacement']['placementRelTo']['placementRelTo']['relativePlacement']['axis'][
|
|
'directionRatios'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + doorID + "_3"], ontology.zaxis,
|
|
Literal(door['objectPlacement']['placementRelTo']['placementRelTo']['relativePlacement']['axis'][
|
|
'directionRatios'][2], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + doorID + "_3"], ontology.xdirection,
|
|
Literal(door['objectPlacement']['placementRelTo']['placementRelTo']['relativePlacement'][
|
|
'refDirection']['directionRatios'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + doorID + "_3"], ontology.ydirection,
|
|
Literal(door['objectPlacement']['placementRelTo']['placementRelTo']['relativePlacement'][
|
|
'refDirection']['directionRatios'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + doorID + "_3"], ontology.zdirection,
|
|
Literal(door['objectPlacement']['placementRelTo']['placementRelTo']['relativePlacement'][
|
|
'refDirection']['directionRatios'][2], datatype=XSD.decimal)))
|
|
except Exception:
|
|
pass
|
|
try:
|
|
g.add((resource[doorID], ontology.hasPlacement, resource["plamenent_" + doorID + "_4"]))
|
|
g.add((resource["plamenent_" + doorID + "_4"], RDF.type, ontology.Placement))
|
|
g.add((resource["plamenent_" + doorID + "_4"], ontology.xlocation, Literal(door['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['location']['coordinates'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + doorID + "_4"], ontology.ylocation, Literal(door['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['location']['coordinates'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + doorID + "_4"], ontology.zlocation, Literal(door['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['location']['coordinates'][2], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + doorID + "_4"], ontology.xaxis,
|
|
Literal(door['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['axis']['directionRatios'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + doorID + "_4"], ontology.yaxis,
|
|
Literal(door['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['axis']['directionRatios'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + doorID + "_4"], ontology.zaxis,
|
|
Literal(door['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['axis']['directionRatios'][2], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + doorID + "_4"], ontology.xdirection,
|
|
Literal(door['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['refDirection']['directionRatios'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + doorID + "_4"], ontology.ydirection,
|
|
Literal(door['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['refDirection']['directionRatios'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + doorID + "_4"], ontology.zdirection,
|
|
Literal(door['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['refDirection']['directionRatios'][2], datatype=XSD.decimal)))
|
|
except Exception:
|
|
pass
|
|
try:#representationMaps data
|
|
g.add((resource[doorID], ontology.hasPlacement, resource["plamenent_" + doorID + "_5"]))
|
|
g.add((resource["plamenent_" + doorID + "_5"], RDF.type, ontology.Placement))
|
|
g.add((resource["plamenent_" + doorID + "_5"], ontology.xlocation, Literal(door['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['location']['coordinates'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + doorID + "_5"], ontology.ylocation, Literal(door['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['location']['coordinates'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + doorID + "_5"], ontology.zlocation, Literal(door['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['location']['coordinates'][2], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + doorID + "_5"], ontology.xaxis,
|
|
Literal(door['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['axis']['directionRatios'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + doorID + "_5"], ontology.yaxis,
|
|
Literal(door['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['axis']['directionRatios'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + doorID + "_5"], ontology.zaxis,
|
|
Literal(door['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['axis']['directionRatios'][2], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + doorID + "_5"], ontology.xdirection,
|
|
Literal(door['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['refDirection']['directionRatios'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + doorID + "_5"], ontology.ydirection,
|
|
Literal(door['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['refDirection']['directionRatios'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + doorID + "_5"], ontology.zdirection,
|
|
Literal(door['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['refDirection']['directionRatios'][2], datatype=XSD.decimal)))
|
|
except Exception:
|
|
pass
|
|
try:#representationMaps data
|
|
g.add((resource[doorID], ontology.hasPlacement, resource["plamenent_" + doorID + "_6"]))
|
|
g.add((resource["plamenent_" + doorID + "_6"], RDF.type, ontology.Placement))
|
|
g.add((resource["plamenent_" + doorID + "_6"], ontology.xlocation, Literal(door['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['location']['coordinates'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + doorID + "_6"], ontology.ylocation, Literal(door['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['location']['coordinates'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + doorID + "_6"], ontology.zlocation, Literal(door['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['location']['coordinates'][2], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + doorID + "_6"], ontology.xaxis,
|
|
Literal(door['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['axis']['directionRatios'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + doorID + "_6"], ontology.yaxis,
|
|
Literal(door['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['axis']['directionRatios'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + doorID + "_6"], ontology.zaxis,
|
|
Literal(door['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['axis']['directionRatios'][2], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + doorID + "_6"], ontology.xdirection,
|
|
Literal(door['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['refDirection']['directionRatios'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + doorID + "_6"], ontology.ydirection,
|
|
Literal(door['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['refDirection']['directionRatios'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + doorID + "_6"], ontology.zdirection,
|
|
Literal(door['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['refDirection']['directionRatios'][2], datatype=XSD.decimal)))
|
|
except Exception:
|
|
pass
|
|
return 1
|
|
|
|
def ifcOwnerHistoryFunction(IfcOwnerHistory):
|
|
for history in IfcOwnerHistory:
|
|
historyID = history['globalId']
|
|
#basic information
|
|
g.add((resource[historyID], RDF.type, ontology.History))
|
|
try:#creationDate is not always there
|
|
creation = history['creationDate']
|
|
g.add((resource[historyID], ontology.creationDate, Literal(creation)))
|
|
except Exception:
|
|
pass
|
|
try:#lastModifiedDate is not always there
|
|
modified = history['lastModifiedDate']
|
|
g.add((resource[historyID], ontology.lastModifiedDate, Literal(modified)))
|
|
except Exception:
|
|
pass
|
|
try:#changeAction is not always there
|
|
change = history['changeAction']
|
|
g.add((resource[historyID], ontology.changeAction, Literal(change)))
|
|
except Exception:
|
|
pass
|
|
try:#changeAction is not always there
|
|
change = history['creationDate']
|
|
g.add((resource[historyID], ontology.creationDate, Literal(change)))
|
|
except Exception:
|
|
pass
|
|
try:#state is not always there
|
|
state = history['state']
|
|
g.add((resource[historyID], ontology.state, Literal(state)))
|
|
except Exception:
|
|
pass
|
|
try:#person is not always there
|
|
person = history['owningUser']['thePerson']
|
|
g.add((resource["person_" + historyID], RDF.type, ontology.Person))
|
|
g.add((resource[historyID], ontology.hasPerson, resource["person_" + historyID]))
|
|
g.add((resource["person_" + historyID], ontology.name, Literal(person['givenName'])))
|
|
except Exception:
|
|
pass
|
|
try:#organisation is not always there
|
|
organisation = history['owningUser']['theOrganization']
|
|
g.add((resource["organisation_" + historyID], RDF.type, ontology.Organisation))
|
|
g.add((resource[historyID], ontology.hasOrganisation, resource["organisation_" + historyID]))
|
|
g.add((resource["organisation_" + historyID], ontology.name, Literal(organisation['name'])))
|
|
except Exception:
|
|
pass
|
|
try:#application is not always there
|
|
application = history['owningApplication']
|
|
g.add((resource["application_" + historyID], RDF.type, ontology.Application))
|
|
g.add((resource[historyID], ontology.hasApplication, resource["application_" + historyID]))
|
|
g.add((resource["application_" + historyID], ontology.version, Literal(application['version'])))
|
|
g.add((resource["application_" + historyID], ontology.name, Literal(application['applicationFullName'])))
|
|
g.add((resource["application_" + historyID], ontology.identifier, Literal(application['applicationIdentifier'])))
|
|
|
|
g.add((resource["developer_" + historyID], RDF.type, ontology.Developer))
|
|
g.add((resource["application_" + historyID], ontology.hasDeveloper, resource["developer_" + historyID]))
|
|
g.add((resource["developer_" + historyID], ontology.name, Literal(application['applicationDeveloper']['name'])))
|
|
except Exception:
|
|
pass
|
|
return 1
|
|
|
|
def ifcSlabTypeFunction(ifcSlabType):
|
|
for slabtype in ifcSlabType:
|
|
slabID, slabPredefinedType = slabtype['globalId'], slabtype['predefinedType']
|
|
#basic information
|
|
g.add((resource[slabID], RDF.type, ontology.SlabType))
|
|
g.add((resource[slabID], ontology.type, Literal(slabPredefinedType)))
|
|
try:#name is not always there
|
|
slabName = slabtype['name']
|
|
g.add((resource[slabID], ontology.name, Literal(slabName)))
|
|
except Exception:
|
|
pass
|
|
try:#name is not always there
|
|
slabPredefinedType = slabtype['predefinedType']
|
|
g.add((resource[slabID], ontology.predefinedType, Literal(slabPredefinedType)))
|
|
except Exception:
|
|
pass
|
|
try:#add history
|
|
slabOwnerHistory = slabtype['ownerHistory']['ref']
|
|
g.add((resource[ slabOwnerHistory], RDF.type, ontology.History))
|
|
g.add((resource[slabID], ontology.hasHistory, resource[ slabOwnerHistory]))
|
|
except Exception:
|
|
pass
|
|
try:#add history
|
|
slabTag = slabtype['tag']
|
|
g.add((resource[slabID], ontology.tag, resource[slabTag]))
|
|
except Exception:
|
|
pass
|
|
try:#material is not always there
|
|
for material in slabtype['hasAssociations']:
|
|
ismaterial = material['ref']
|
|
g.add((resource[ismaterial], RDF.type, ontology.Material))
|
|
g.add((resource[slabID], ontology.associatesMaterial, resource[ismaterial]))
|
|
except Exception:
|
|
pass
|
|
try:#material is not always there
|
|
for typed in slabtype['types']:
|
|
istyped = typed['ref']
|
|
g.add((resource[istyped], RDF.type, ontology.TypeCategory))
|
|
g.add((resource[slabID], ontology.hasType, resource[istyped]))
|
|
except Exception:
|
|
pass
|
|
try:#object is not always there
|
|
count = 1
|
|
for prp in slabtype['hasPropertySets']:
|
|
isprp = prp['ref']
|
|
g.add((resource["propertyset_" + isprp + "_" + str(count)], RDF.type, ontology.PropertySet))
|
|
g.add((resource[slabID], ontology.hasProperty, resource["propertyset_" + isprp + "_" + str(count)]))
|
|
count += 1
|
|
except Exception:
|
|
pass
|
|
try:#representationMaps data
|
|
for maps in slabtype['representationMaps']:
|
|
#print(maps['mappingOrigin'])
|
|
g.add((resource[slabID], ontology.hasRepresentationType, resource[ maps['mappedRepresentation']['ref']]))
|
|
g.add((resource[ maps['mappedRepresentation']['ref']], RDF.type, ontology.Representation))
|
|
g.add((resource[ maps['mappedRepresentation']['ref']], ontology.xlocation, Literal(maps['mappingOrigin']['location']['coordinates'][0], datatype=XSD.decimal)))
|
|
g.add((resource[ maps['mappedRepresentation']['ref']], ontology.ylocation, Literal(maps['mappingOrigin']['location']['coordinates'][1], datatype=XSD.decimal)))
|
|
g.add((resource[ maps['mappedRepresentation']['ref']], ontology.zlocation, Literal(maps['mappingOrigin']['location']['coordinates'][2], datatype=XSD.decimal)))
|
|
g.add((resource[ maps['mappedRepresentation']['ref']], ontology.xaxis,
|
|
Literal(maps['mappingOrigin']['axis']['directionRatios'][0], datatype=XSD.decimal)))
|
|
g.add((resource[ maps['mappedRepresentation']['ref']], ontology.yaxis,
|
|
Literal(maps['mappingOrigin']['axis']['directionRatios'][1], datatype=XSD.decimal)))
|
|
g.add((resource[ maps['mappedRepresentation']['ref']], ontology.zaxis,
|
|
Literal(maps['mappingOrigin']['axis']['directionRatios'][2], datatype=XSD.decimal)))
|
|
g.add((resource[ maps['mappedRepresentation']['ref']], ontology.xdirection,
|
|
Literal(maps['mappingOrigin']['refDirection']['directionRatios'][0], datatype=XSD.decimal)))
|
|
g.add((resource[ maps['mappedRepresentation']['ref']], ontology.ydirection,
|
|
Literal(maps['mappingOrigin']['refDirection']['directionRatios'][1], datatype=XSD.decimal)))
|
|
g.add((resource[ maps['mappedRepresentation']['ref']], ontology.zdirection,
|
|
Literal(maps['mappingOrigin']['refDirection']['directionRatios'][2], datatype=XSD.decimal)))
|
|
except Exception:
|
|
pass
|
|
return 1
|
|
|
|
def ifcRelContainedInSpatialStructureFunction(IfcRelContainedInSpatialStructure):
|
|
for spatial in IfcRelContainedInSpatialStructure:
|
|
spatialID = spatial['globalId']
|
|
#basic information
|
|
g.add((resource[spatialID], RDF.type, ontology.Structure))
|
|
try:#add history
|
|
spatialHistory = spatial['ownerHistory']['ref']
|
|
g.add((resource[spatialHistory], RDF.type, ontology.History))
|
|
g.add((resource[spatialID], ontology.hasHistory, resource[spatialHistory]))
|
|
except Exception:
|
|
pass
|
|
try:#relatingStructure is not always there
|
|
structure = spatial['relatingStructure']
|
|
g.add((resource[structure['ref']], RDF.type, ontology.Structure))
|
|
g.add((resource[spatialID], ontology.relatingStructure, resource[structure['ref']]))
|
|
except Exception:
|
|
pass
|
|
try:#name is not always there
|
|
spatialName = spatial['name']
|
|
g.add((resource[spatialID], ontology.name, Literal(spatialName)))
|
|
except Exception:
|
|
pass
|
|
try:#name is not always there
|
|
spatialDescription = spatial['description']
|
|
g.add((resource[spatialID], ontology.description, Literal(spatialDescription)))
|
|
except Exception:
|
|
pass
|
|
try:#relatedElements is not always there
|
|
for related in spatial['relatedElements']:
|
|
element = related['ref']
|
|
g.add((resource[element], RDF.type, ontology.Object))
|
|
g.add((resource[spatialID], ontology.relatedElements, resource[element]))
|
|
except Exception:
|
|
pass
|
|
return 1
|
|
|
|
def ifcRelAssociatesMaterialFunction(IfcRelAssociatesMaterial):
|
|
for material in IfcRelAssociatesMaterial:
|
|
materialID = material['globalId']
|
|
#basic information
|
|
g.add((resource[materialID], RDF.type, ontology.Material))
|
|
try:#add history
|
|
materialHistory = material['ownerHistory']['ref']
|
|
g.add((resource[materialHistory], RDF.type, ontology.History))
|
|
g.add((resource[materialID], ontology.hasHistory, resource[materialHistory]))
|
|
except Exception:
|
|
pass
|
|
try:#name is not always there
|
|
classificationName = material['name']
|
|
g.add((resource[materialID], ontology.name, Literal(classificationName)))
|
|
except Exception:
|
|
pass
|
|
try:#name is not always there
|
|
classificationDescription = material['description']
|
|
g.add((resource[materialID], ontology.description, Literal(classificationDescription)))
|
|
except Exception:
|
|
pass
|
|
try:#cardinalPoint is not always there
|
|
cardinal = material['cardinalPoint']
|
|
g.add((resource[materialID], ontology.cardinalPoint, Literal(cardinal)))
|
|
except Exception:
|
|
pass
|
|
try:#referenceExtent is not always there
|
|
extent = material['referenceExtent']
|
|
g.add((resource[materialID], ontology.referenceExtent, Literal(extent)))
|
|
except Exception:
|
|
pass
|
|
try: # related objects
|
|
for obj in material['relatedObjects']:
|
|
propertyObject = obj['ref']
|
|
g.add((resource[propertyObject], RDF.type, ontology.Object))
|
|
g.add((resource[materialID], ontology.relatedObject, resource[propertyObject]))
|
|
except Exception:
|
|
pass
|
|
try:#add details of material
|
|
materialType, materialName = material['relatingMaterial']['type'], material['relatingMaterial']['name']
|
|
g.add((resource[materialID], ontology.type, Literal(materialType)))
|
|
g.add((resource[materialID], ontology.name, Literal(materialName)))
|
|
except Exception:
|
|
pass
|
|
try:#add details of material
|
|
materialCategory = material['relatingMaterial']['category']
|
|
g.add((resource[materialID], ontology.category, Literal(materialCategory)))
|
|
except Exception:
|
|
pass
|
|
try:#add details of material
|
|
for obj in material['relatingMaterial']['materials']:
|
|
materialType, materialName = obj['type'], obj['name']
|
|
g.add((resource[materialID], ontology.type, Literal(materialType)))
|
|
g.add((resource[materialID], ontology.name, Literal(materialName)))
|
|
except Exception:
|
|
pass
|
|
try:#add details of material
|
|
count = 1
|
|
for obj in material['relatingMaterial']['materialConstituents']:
|
|
g.add((resource["constituent_" + str(materialID) + "_" + str(count)], RDF.type, ontology.MaterialConstituent))
|
|
g.add((resource[materialID], ontology.hasConstituent, resource["constituent_" + str(materialID) + "_" + str(count)]))
|
|
if "type" in list(obj.keys()):
|
|
materialType = obj['type']
|
|
g.add((resource["constituent_" + str(materialID) + "_" + str(count)], ontology.type, Literal(materialType)))
|
|
if "name" in list(obj.keys()):
|
|
materialName = obj['name']
|
|
g.add((resource["constituent_" + str(materialID) + "_" + str(count)], ontology.name, Literal(materialName)))
|
|
if "category" in list(obj.keys()):
|
|
materialCategory = obj['category']
|
|
g.add((resource["constituent_" + str(materialID) + "_" + str(count)], ontology.category, Literal(materialCategory)))
|
|
if "type" in list(obj['material'].keys()):
|
|
materialType = obj['material']['type']
|
|
g.add((resource["constituent_" + str(materialID) + "_" + str(count)], ontology.materialType, Literal(materialType)))
|
|
if "name" in list(obj['material'].keys()):
|
|
materialName = obj['material']['name']
|
|
g.add((resource["constituent_" + str(materialID) + "_" + str(count)], ontology.materialName, Literal(materialName)))
|
|
if "category" in list(obj['material'].keys()):
|
|
materialCategory = obj['material']['category']
|
|
g.add((resource["constituent_" + str(materialID) + "_" + str(count)], ontology.materialCategory, Literal(materialCategory)))
|
|
count += 1
|
|
except Exception:
|
|
pass
|
|
try:#add details of material
|
|
if "type" in list(material["relatingMaterial"]["forProfileSet"].keys()):
|
|
materialType = material["relatingMaterial"]["forProfileSet"]['type']
|
|
g.add((resource[materialID], ontology.profileType, Literal(materialType)))
|
|
if "name" in list(material["relatingMaterial"]["forProfileSet"].keys()):
|
|
materialName = material["relatingMaterial"]["forProfileSet"]['name']
|
|
g.add((resource[materialID], ontology.profileName, Literal(materialName)))
|
|
for profile in material["relatingMaterial"]["forProfileSet"]["materialProfiles"]:
|
|
if "type" in list(profile["material"].keys()):
|
|
g.add((resource[materialID], ontology.materialType, Literal(profile["material"]["type"])))
|
|
if "name" in list(profile["material"].keys()):
|
|
g.add((resource[materialID], ontology.materialName, Literal(profile["material"]["name"])))
|
|
if "category" in list(profile["material"].keys()):
|
|
g.add((resource[materialID], ontology.materialCategory, Literal(profile["material"]["category"])))
|
|
if "type" in list(profile["profile"].keys()):
|
|
g.add((resource[materialID], ontology.profile2Type, Literal(profile["profile"]["type"])))
|
|
if "profileType" in list(profile["profile"].keys()):
|
|
g.add((resource[materialID], ontology.profile2Name, Literal(profile["profile"]["profileType"])))
|
|
if "profileName" in list(profile["profile"].keys()):
|
|
g.add((resource[materialID], ontology.profileName, Literal(profile["profile"]["profileName"])))
|
|
if "radius" in list(profile["profile"].keys()):
|
|
g.add((resource[materialID], ontology.profile2Radius, Literal(profile["profile"]["radius"])))
|
|
if "wallThickness" in list(profile["profile"].keys()):
|
|
g.add((resource[materialID], ontology.profile2WallThickness, Literal(profile["profile"]["wallThickness"])))
|
|
if "offsetValues" in list(profile["profile"].keys()):
|
|
g.add((resource[materialID], ontology.offSetX, Literal(profile["offsetValues"][0])))
|
|
if "offsetValues" in list(profile["profile"].keys()):
|
|
g.add((resource[materialID], ontology.offSetY, Literal(profile["offsetValues"][1])))
|
|
if "depth" in list(profile["profile"].keys()):
|
|
g.add((resource[materialID], ontology.depth, Literal(profile["profile"]["depth"])))
|
|
if "flangeWidth" in list(profile["profile"].keys()):
|
|
g.add((resource[materialID], ontology.flangeWidth, Literal(profile["profile"]["flangeWidth"])))
|
|
if "webThickness" in list(profile["profile"].keys()):
|
|
g.add((resource[materialID], ontology.webThickness, Literal(profile["profile"]["webThickness"])))
|
|
if "flangeThickness" in list(profile["profile"].keys()):
|
|
g.add((resource[materialID], ontology.flangeThickness, Literal(profile["profile"]["flangeThickness"])))
|
|
if "filletRadius" in list(profile["profile"].keys()):
|
|
g.add((resource[materialID], ontology.filletRadius, Literal(profile["profile"]["filletRadius"])))
|
|
if "overallWidth" in list(profile["profile"].keys()):
|
|
g.add((resource[materialID], ontology.overallWidth, Literal(profile["profile"]["overallWidth"])))
|
|
if "overallDepth" in list(profile["profile"].keys()):
|
|
g.add((resource[materialID], ontology.overallDepth, Literal(profile["profile"]["overallDepth"])))
|
|
if "cardinalPoint" in list(material["relatingMaterial"].keys()):
|
|
g.add((resource[materialID], ontology.cardinalPoint, Literal(material["relatingMaterial"]["cardinalPoint"])))
|
|
except Exception:
|
|
pass
|
|
try:
|
|
type = material['relatingMaterial']['type']
|
|
g.add((resource[materialID], ontology.type, Literal(type)))
|
|
if "name" in list(material['relatingMaterial'].keys()):
|
|
name = material['relatingMaterial']['name']
|
|
g.add((resource[materialID], ontology.name, Literal(name)))
|
|
for obj in material['relatingMaterial']['materialProfiles']:
|
|
type, name = obj['type'], obj['name']
|
|
materialType, materialName = obj['material']['type'], obj['material']['name']
|
|
g.add((resource[materialID], ontology.profileType, Literal(type)))
|
|
g.add((resource[materialID], ontology.profileName, Literal(name)))
|
|
g.add((resource[materialID], ontology.materialType, Literal(materialType)))
|
|
g.add((resource[materialID], ontology.materialName, Literal(materialName)))
|
|
profileType, profileName = obj['profile']['profileType'], obj['profile']['profileName']
|
|
g.add((resource[materialID], ontology.profileType, Literal(profileType)))
|
|
g.add((resource[materialID], ontology.profileName, Literal(profileName)))
|
|
g.add((resource[materialID], ontology.xcoordinate, Literal(obj['profile']['position']['location']['coordinates'][0])))
|
|
g.add((resource[materialID], ontology.ycoordinate, Literal(obj['profile']['position']['location']['coordinates'][1])))
|
|
g.add((resource[materialID], ontology.overallWidth, Literal(obj['profile']['overallWidth'])))
|
|
g.add((resource[materialID], ontology.overallDepth, Literal(obj['profile']['overallDepth'])))
|
|
g.add((resource[materialID], ontology.webThickness, Literal(obj['profile']['webThickness'])))
|
|
g.add((resource[materialID], ontology.flangeThickness, Literal(obj['profile']['flangeThickness'])))
|
|
g.add((resource[materialID], ontology.filletRadius, Literal(obj['profile']['filletRadius'])))
|
|
if "priority" in list(obj.keys()):
|
|
g.add((resource[materialID], ontology.priority, Literal(obj['priority'])))
|
|
if "cardinalPoint" in list(obj.keys()):
|
|
g.add((resource[materialID], ontology.priority, Literal(obj['cardinalPoint'])))
|
|
except Exception:
|
|
pass
|
|
try:
|
|
type = material['relatingMaterial']['type']
|
|
g.add((resource[materialID], ontology.type, Literal(type)))
|
|
if "name" in list(material['relatingMaterial'].keys()):
|
|
name = material['relatingMaterial']['name']
|
|
g.add((resource[materialID], ontology.name, Literal(name)))
|
|
if "name" in list(material['relatingMaterial']['forProfileSet'].keys()):
|
|
profileType, profileName = material['relatingMaterial']['forProfileSet']['type'], material['relatingMaterial']['forProfileSet']['name']
|
|
g.add((resource[materialID], ontology.name, Literal(profileName)))
|
|
g.add((resource[materialID], ontology.type, Literal(profileType)))
|
|
for obj in material['relatingMaterial']['forProfileSet']['materialProfiles']:
|
|
profileType, profileName = obj['profile']['profileType'], obj['profile']['profileName']
|
|
g.add((resource[materialID], ontology.profileType, Literal(profileType)))
|
|
g.add((resource[materialID], ontology.profileName, Literal(profileName)))
|
|
g.add((resource[materialID], ontology.xcoordinate, Literal(obj['profile']['position']['location']['coordinates'][0])))
|
|
g.add((resource[materialID], ontology.ycoordinate, Literal(obj['profile']['position']['location']['coordinates'][1])))
|
|
g.add((resource[materialID], ontology.overallWidth, Literal(obj['profile']['overallWidth'])))
|
|
g.add((resource[materialID], ontology.overallDepth, Literal(obj['profile']['overallDepth'])))
|
|
g.add((resource[materialID], ontology.webThickness, Literal(obj['profile']['webThickness'])))
|
|
g.add((resource[materialID], ontology.flangeThickness, Literal(obj['profile']['flangeThickness'])))
|
|
g.add((resource[materialID], ontology.filletRadius, Literal(obj['profile']['filletRadius'])))
|
|
g.add((resource[materialID], ontology.priority, Literal(obj['priority'])))
|
|
except Exception:
|
|
pass
|
|
return 1
|
|
|
|
def ifcBuilingFunction(IfcBuilding):
|
|
for building in IfcBuilding:
|
|
buildingID = building['globalId']
|
|
#basic information
|
|
g.add((resource[buildingID], RDF.type, ontology.Structure))
|
|
try:
|
|
buildingHistory = building['ownerHistory']['ref']
|
|
g.add((resource[buildingHistory], RDF.type, ontology.History))
|
|
g.add((resource[buildingID], ontology.hasHistory, resource[buildingHistory]))
|
|
except Exception:
|
|
pass
|
|
try:
|
|
buildingObjectType = building['objectType']
|
|
g.add((resource[buildingID], ontology.objectType, Literal(buildingObjectType)))
|
|
except Exception:
|
|
pass
|
|
try:
|
|
buildingLongName = building['longName']
|
|
g.add((resource[buildingID], ontology.longName, Literal(buildingLongName)))
|
|
except Exception:
|
|
pass
|
|
try:#add history
|
|
buildingDescription = building['description']
|
|
g.add((resource[buildingID], ontology.height, Literal(buildingDescription)))
|
|
except Exception:
|
|
pass
|
|
try:#name is not always there
|
|
buildingName = building['name']
|
|
g.add((resource[buildingID], ontology.name, Literal(buildingName)))
|
|
except Exception:
|
|
pass
|
|
try:#name is not always there
|
|
addressType, addressRegion, addressCountry = building['buildingAddress']['type'], building['buildingAddress']['region'], building['buildingAddress']['country']
|
|
g.add((resource[buildingID], ontology.addressType, Literal(addressType)))
|
|
g.add((resource[buildingID], ontology.addressRegion, Literal(addressRegion)))
|
|
g.add((resource[buildingID], ontology.addressCountry, Literal(addressCountry)))
|
|
for line in building['buildingAddress']['addressLines']:
|
|
g.add((resource[buildingID], ontology.addressLine, Literal(line)))
|
|
except Exception:
|
|
pass
|
|
try:#composition is not always there
|
|
buildingComposition = building['compositionType']
|
|
g.add((resource[buildingID], ontology.composition, Literal(buildingComposition)))
|
|
except Exception:
|
|
pass
|
|
try:#decompose is not always there
|
|
for representation in building['isDecomposedBy']:
|
|
rep = representation['ref']
|
|
g.add((resource[rep], RDF.type, ontology.Object))
|
|
g.add((resource[rep], ontology.isDecomposedBy, resource[buildingID]))
|
|
except Exception:
|
|
pass
|
|
try:#decompose is not always there
|
|
for representation in building['decomposes']:
|
|
rep = representation['ref']
|
|
g.add((resource[rep], RDF.type, ontology.Object))
|
|
g.add((resource[buildingID], ontology.decomposes, resource[rep]))
|
|
except Exception:
|
|
pass
|
|
try:#definedby is not always there
|
|
for defined in building['isDefinedBy']:
|
|
issdefined= defined['ref']
|
|
g.add((resource[issdefined], RDF.type, ontology.PropertySet))
|
|
g.add((resource[buildingID], ontology.isDefinedBy, resource[issdefined]))
|
|
except Exception:
|
|
pass
|
|
try:#definedby is not always there
|
|
for defined in building['servicedBySystems']:
|
|
servicedsystem = defined['ref']
|
|
g.add((resource[servicedsystem], RDF.type, ontology.ServicedSystem))
|
|
g.add((resource[buildingID], ontology.hasServicedSystem, resource[servicedsystem]))
|
|
except Exception:
|
|
pass
|
|
try: # representationMaps data
|
|
g.add((resource[buildingID], ontology.hasPlacement, resource["plamenent_" + buildingID + "_1"]))
|
|
g.add((resource["plamenent_" + buildingID + "_1"], RDF.type, ontology.Placement))
|
|
g.add((resource["plamenent_" + buildingID + "_1"], ontology.xlocation,
|
|
Literal(building['objectPlacement']['relativePlacement']['location']['coordinates'][0],
|
|
datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + buildingID + "_1"], ontology.ylocation,
|
|
Literal(building['objectPlacement']['relativePlacement']['location']['coordinates'][1],
|
|
datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + buildingID + "_1"], ontology.zlocation,
|
|
Literal(building['objectPlacement']['relativePlacement']['location']['coordinates'][2],
|
|
datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + buildingID + "_1"], ontology.xaxis,
|
|
Literal(building['objectPlacement']['relativePlacement']['axis']['directionRatios'][0],
|
|
datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + buildingID + "_1"], ontology.yaxis,
|
|
Literal(building['objectPlacement']['relativePlacement']['axis']['directionRatios'][1],
|
|
datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + buildingID + "_1"], ontology.zaxis,
|
|
Literal(building['objectPlacement']['relativePlacement']['axis']['directionRatios'][2],
|
|
datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + buildingID + "_1"], ontology.xdirection,
|
|
Literal(building['objectPlacement']['relativePlacement']['refDirection']['directionRatios'][0],
|
|
datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + buildingID + "_1"], ontology.ydirection,
|
|
Literal(building['objectPlacement']['relativePlacement']['refDirection']['directionRatios'][1],
|
|
datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + buildingID + "_1"], ontology.zdirection,
|
|
Literal(building['objectPlacement']['relativePlacement']['refDirection']['directionRatios'][2],
|
|
datatype=XSD.decimal)))
|
|
except Exception:
|
|
pass
|
|
try:
|
|
g.add((resource[buildingID], ontology.hasPlacement, resource["plamenent_" + buildingID + "_2"]))
|
|
g.add((resource["plamenent_" + buildingID + "_2"], RDF.type, ontology.Placement))
|
|
g.add((resource["plamenent_" + buildingID + "_2"], ontology.xlocation, Literal(
|
|
building['objectPlacement']['placementRelTo']['relativePlacement']['location']['coordinates'][0],
|
|
datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + buildingID + "_2"], ontology.ylocation, Literal(
|
|
building['objectPlacement']['placementRelTo']['relativePlacement']['location']['coordinates'][1],
|
|
datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + buildingID + "_2"], ontology.zlocation, Literal(
|
|
building['objectPlacement']['placementRelTo']['relativePlacement']['location']['coordinates'][2],
|
|
datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + buildingID + "_2"], ontology.xaxis,
|
|
Literal(
|
|
building['objectPlacement']['placementRelTo']['relativePlacement']['axis']['directionRatios'][0],
|
|
datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + buildingID + "_2"], ontology.yaxis,
|
|
Literal(
|
|
building['objectPlacement']['placementRelTo']['relativePlacement']['axis']['directionRatios'][1],
|
|
datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + buildingID + "_2"], ontology.zaxis,
|
|
Literal(
|
|
building['objectPlacement']['placementRelTo']['relativePlacement']['axis']['directionRatios'][2],
|
|
datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + buildingID + "_2"], ontology.xdirection,
|
|
Literal(building['objectPlacement']['placementRelTo']['relativePlacement']['refDirection'][
|
|
'directionRatios'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + buildingID + "_2"], ontology.ydirection,
|
|
Literal(building['objectPlacement']['placementRelTo']['relativePlacement']['refDirection'][
|
|
'directionRatios'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + buildingID + "_2"], ontology.zdirection,
|
|
Literal(building['objectPlacement']['placementRelTo']['relativePlacement']['refDirection'][
|
|
'directionRatios'][2], datatype=XSD.decimal)))
|
|
except Exception:
|
|
pass
|
|
return 1
|
|
|
|
def ifcColumnTypeFunction(IfcColumnType):
|
|
|
|
for columnType in IfcColumnType:
|
|
columnTypeID = columnType['globalId']
|
|
g.add((resource[columnTypeID], RDF.type, ontology.ColumnType))
|
|
try: # add history
|
|
columnTypeHistory = columnType['ownerHistory']['ref']
|
|
g.add((resource[columnTypeHistory], RDF.type, ontology.History))
|
|
g.add((resource[columnTypeID], ontology.hasHistory, resource[columnTypeHistory]))
|
|
except Exception:
|
|
pass
|
|
try:
|
|
g.add((resource[columnTypeID], ontology.name, Literal(columnType['name'].replace("\"", ""))))
|
|
except Exception:
|
|
pass
|
|
try:
|
|
g.add((resource[columnTypeID], ontology.type, Literal(columnType['predefinedType'].replace("\"", ""))))
|
|
except Exception:
|
|
pass
|
|
try:
|
|
g.add((resource[columnTypeID], ontology.tag, Literal(columnType['tag'].replace("\"", ""))))
|
|
except Exception:
|
|
pass
|
|
try:#material is not always there
|
|
for material in columnType['hasAssociations']:
|
|
ismaterial = material['ref']
|
|
g.add((resource[ismaterial], RDF.type, ontology.Material))
|
|
g.add((resource[columnTypeID], ontology.associatesMaterial, resource[ismaterial]))
|
|
except Exception:
|
|
pass
|
|
try:#material is not always there
|
|
for typed in columnType['types']:
|
|
istyped = typed['ref']
|
|
g.add((resource[istyped], RDF.type, ontology.TypeCategory))
|
|
g.add((resource[columnTypeID], ontology.hasType, resource[istyped]))
|
|
except Exception:
|
|
pass
|
|
try:#object is not always there
|
|
count = 1
|
|
for prp in columnType['hasPropertySets']:
|
|
isprp = prp['ref']
|
|
g.add((resource["propertyset_" + isprp + "_" + str(count)], RDF.type, ontology.PropertySet))
|
|
g.add((resource[columnTypeID], ontology.hasProperty, resource["propertyset_" + isprp + "_" + str(count)]))
|
|
count += 1
|
|
except Exception:
|
|
pass
|
|
try: # representationMaps data
|
|
g.add((resource[columnTypeID], ontology.hasPlacement, resource["plamenent_" + columnTypeID + "_1"]))
|
|
g.add((resource["plamenent_" + columnTypeID + "_1"], RDF.type, ontology.Placement))
|
|
g.add((resource["plamenent_" + columnTypeID + "_1"], ontology.xlocation,
|
|
Literal(columnType['representationMaps'][0]['mappingOrigin']['location']['coordinates'][0],
|
|
datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + columnTypeID + "_1"], ontology.ylocation,
|
|
Literal(columnType['representationMaps'][0]['mappingOrigin']['location']['coordinates'][1],
|
|
datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + columnTypeID + "_1"], ontology.zlocation,
|
|
Literal(columnType['representationMaps'][0]['mappingOrigin']['location']['coordinates'][2],
|
|
datatype=XSD.decimal)))
|
|
except Exception:
|
|
pass
|
|
return 1
|
|
|
|
def ifcColumnFunction(IfcColumn):
|
|
for column in IfcColumn:
|
|
columnID = column['globalId']
|
|
g.add((resource[columnID], RDF.type, ontology.Column))
|
|
try:
|
|
g.add((resource[columnID], ontology.name, Literal(column['name'].replace("\"", ""))))
|
|
except Exception:
|
|
pass
|
|
try:#representation is not always there
|
|
for representation in column['representation']['representations']:
|
|
rep = representation['ref']
|
|
g.add((resource[rep], RDF.type, ontology.Representation))
|
|
g.add((resource[columnID], ontology.hasRepresentationType, resource[rep]))
|
|
except Exception:
|
|
pass
|
|
try:#material is not always there
|
|
for material in column['hasAssociations']:
|
|
ismaterial = material['ref']
|
|
g.add((resource[ismaterial], RDF.type, ontology.Material))
|
|
g.add((resource[columnID], ontology.associatesMaterial, resource[ismaterial]))
|
|
except Exception:
|
|
pass
|
|
try:#isTypedBy is not always there
|
|
for typed in column['isTypedBy']:
|
|
istyped = typed['ref']
|
|
g.add((resource[istyped], RDF.type, ontology.TypeCategory))
|
|
g.add((resource[columnID], ontology.hasType, resource[istyped]))
|
|
except Exception:
|
|
pass
|
|
try:#structure is not always there
|
|
for structure in column['containedInStructure']:
|
|
isstructure= structure['ref']
|
|
g.add((resource[isstructure], RDF.type, ontology.Structure))
|
|
g.add((resource[columnID], ontology.inStructure, resource[isstructure]))
|
|
except Exception:
|
|
pass
|
|
try:#definedby is not always there
|
|
for defined in column['isDefinedBy']:
|
|
issdefined= defined['ref']
|
|
g.add((resource[issdefined], RDF.type, ontology.PropertySet))
|
|
g.add((resource[columnID], ontology.isDefinedBy, resource[issdefined]))
|
|
except Exception:
|
|
pass
|
|
try:#hasAssociations is not always there
|
|
for typed in column['hasAssignments']:
|
|
iselement = typed['ref']
|
|
g.add((resource[iselement], RDF.type, ontology.Group))
|
|
g.add((resource[columnID], ontology.hasAssignments, resource[iselement]))
|
|
except Exception:
|
|
pass
|
|
try: # add history
|
|
columnHistory = column['ownerHistory']['ref']
|
|
g.add((resource[columnHistory], RDF.type, ontology.History))
|
|
g.add((resource[columnID], ontology.hasHistory, resource[columnHistory]))
|
|
except Exception:
|
|
pass
|
|
try:
|
|
g.add((resource[columnID], ontology.predefinedType, Literal(column['predefinedType'].replace("\"", ""))))
|
|
except Exception:
|
|
pass
|
|
try:
|
|
g.add((resource[columnID], ontology.name, Literal(column['name'].replace("\"", ""))))
|
|
except Exception:
|
|
pass
|
|
try:
|
|
g.add((resource[columnID], ontology.type, Literal(column['objectType'].replace("\"", ""))))
|
|
except Exception:
|
|
pass
|
|
try:
|
|
g.add((resource[columnID], ontology.tag, Literal(column['tag'].replace("\"", ""))))
|
|
except Exception:
|
|
pass
|
|
try:#representationMaps data
|
|
g.add((resource[columnID], ontology.hasPlacement, resource["plamenent_" + columnID + "_1"]))
|
|
g.add((resource["plamenent_" + columnID + "_1"], RDF.type, ontology.Placement))
|
|
g.add((resource["plamenent_" + columnID + "_1"], ontology.xlocation, Literal(column['objectPlacement']['relativePlacement']['location']['coordinates'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + columnID + "_1"], ontology.ylocation, Literal(column['objectPlacement']['relativePlacement']['location']['coordinates'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + columnID + "_1"], ontology.zlocation, Literal(column['objectPlacement']['relativePlacement']['location']['coordinates'][2], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + columnID + "_1"], ontology.xaxis,
|
|
Literal(column['objectPlacement']['relativePlacement']['axis']['directionRatios'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + columnID + "_1"], ontology.yaxis,
|
|
Literal(column['objectPlacement']['relativePlacement']['axis']['directionRatios'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + columnID + "_1"], ontology.zaxis,
|
|
Literal(column['objectPlacement']['relativePlacement']['axis']['directionRatios'][2], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + columnID + "_1"], ontology.xdirection,
|
|
Literal(column['objectPlacement']['relativePlacement']['refDirection']['directionRatios'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + columnID + "_1"], ontology.ydirection,
|
|
Literal(column['objectPlacement']['relativePlacement']['refDirection']['directionRatios'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + columnID + "_1"], ontology.zdirection,
|
|
Literal(column['objectPlacement']['relativePlacement']['refDirection']['directionRatios'][2], datatype=XSD.decimal)))
|
|
except Exception:
|
|
pass
|
|
try:
|
|
g.add((resource[columnID], ontology.hasPlacement, resource["plamenent_" + columnID + "_2"]))
|
|
g.add((resource["plamenent_" + columnID + "_2"], RDF.type, ontology.Placement))
|
|
g.add((resource["plamenent_" + columnID + "_2"], ontology.xlocation, Literal(column['objectPlacement']['placementRelTo']['relativePlacement']['location']['coordinates'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + columnID + "_2"], ontology.ylocation, Literal(column['objectPlacement']['placementRelTo']['relativePlacement']['location']['coordinates'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + columnID + "_2"], ontology.zlocation, Literal(column['objectPlacement']['placementRelTo']['relativePlacement']['location']['coordinates'][2], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + columnID + "_2"], ontology.xaxis,
|
|
Literal(column['objectPlacement']['placementRelTo']['relativePlacement']['axis']['directionRatios'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + columnID + "_2"], ontology.yaxis,
|
|
Literal(column['objectPlacement']['placementRelTo']['relativePlacement']['axis']['directionRatios'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + columnID + "_2"], ontology.zaxis,
|
|
Literal(column['objectPlacement']['placementRelTo']['relativePlacement']['axis']['directionRatios'][2], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + columnID + "_2"], ontology.xdirection,
|
|
Literal(column['objectPlacement']['placementRelTo']['relativePlacement']['refDirection']['directionRatios'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + columnID + "_2"], ontology.ydirection,
|
|
Literal(column['objectPlacement']['placementRelTo']['relativePlacement']['refDirection']['directionRatios'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + columnID + "_2"], ontology.zdirection,
|
|
Literal(column['objectPlacement']['placementRelTo']['relativePlacement']['refDirection']['directionRatios'][2], datatype=XSD.decimal)))
|
|
except Exception:
|
|
pass
|
|
try:
|
|
g.add((resource[columnID], ontology.hasPlacement, resource["plamenent_" + columnID + "_3"]))
|
|
g.add((resource["plamenent_" + columnID + "_3"], RDF.type, ontology.Placement))
|
|
g.add((resource["plamenent_" + columnID + "_3"], ontology.xlocation, Literal(column['objectPlacement']['placementRelTo']['placementRelTo']['relativePlacement']['location']['coordinates'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + columnID + "_3"], ontology.ylocation, Literal(column['objectPlacement']['placementRelTo']['placementRelTo']['relativePlacement']['location']['coordinates'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + columnID + "_3"], ontology.zlocation, Literal(column['objectPlacement']['placementRelTo']['placementRelTo']['relativePlacement']['location']['coordinates'][2], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + columnID + "_3"], ontology.xaxis,
|
|
Literal(column['objectPlacement']['placementRelTo']['placementRelTo']['relativePlacement']['axis']['directionRatios'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + columnID + "_3"], ontology.yaxis,
|
|
Literal(column['objectPlacement']['placementRelTo']['placementRelTo']['relativePlacement']['axis']['directionRatios'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + columnID + "_3"], ontology.zaxis,
|
|
Literal(column['objectPlacement']['placementRelTo']['placementRelTo']['relativePlacement']['axis']['directionRatios'][2], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + columnID + "_3"], ontology.xdirection,
|
|
Literal(column['objectPlacement']['placementRelTo']['placementRelTo']['relativePlacement']['refDirection']['directionRatios'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + columnID + "_3"], ontology.ydirection,
|
|
Literal(column['objectPlacement']['placementRelTo']['placementRelTo']['relativePlacement']['refDirection']['directionRatios'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + columnID + "_3"], ontology.zdirection,
|
|
Literal(column['objectPlacement']['placementRelTo']['placementRelTo']['relativePlacement']['refDirection']['directionRatios'][2], datatype=XSD.decimal)))
|
|
except Exception:
|
|
pass
|
|
try:
|
|
g.add((resource[columnID], ontology.hasPlacement, resource["plamenent_" + columnID + "_4"]))
|
|
g.add((resource["plamenent_" + columnID + "_4"], RDF.type, ontology.Placement))
|
|
g.add((resource["plamenent_" + columnID + "_4"], ontology.xlocation, Literal(column['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['location']['coordinates'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + columnID + "_4"], ontology.ylocation, Literal(column['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['location']['coordinates'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + columnID + "_4"], ontology.zlocation, Literal(column['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['location']['coordinates'][2], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + columnID + "_4"], ontology.xaxis,
|
|
Literal(column['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['axis']['directionRatios'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + columnID + "_4"], ontology.yaxis,
|
|
Literal(column['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['axis']['directionRatios'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + columnID + "_4"], ontology.zaxis,
|
|
Literal(column['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['axis']['directionRatios'][2], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + columnID + "_4"], ontology.xdirection,
|
|
Literal(column['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['refDirection']['directionRatios'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + columnID + "_4"], ontology.ydirection,
|
|
Literal(column['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['refDirection']['directionRatios'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + columnID + "_4"], ontology.zdirection,
|
|
Literal(column['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['refDirection']['directionRatios'][2], datatype=XSD.decimal)))
|
|
except Exception:
|
|
pass
|
|
return 1
|
|
|
|
def ifcMemberTypeFunction(IfcMemberType):
|
|
for membertype in IfcMemberType:
|
|
memberID = membertype['globalId']
|
|
#basic information
|
|
g.add((resource[memberID], RDF.type, ontology.MemberType))
|
|
try:#name is not always there
|
|
memberName = membertype['name']
|
|
g.add((resource[memberID], ontology.name, Literal(memberName)))
|
|
except Exception:
|
|
pass
|
|
try:#name is not always there
|
|
memberTag = membertype['tag']
|
|
g.add((resource[memberID], ontology.tag, Literal(memberTag)))
|
|
except Exception:
|
|
pass
|
|
try:#name is not always there
|
|
memberPredefinedType = membertype['predefinedType']
|
|
g.add((resource[memberID], ontology.predefinedType, Literal(memberPredefinedType)))
|
|
except Exception:
|
|
pass
|
|
try:#add history
|
|
memberOwnerHistory = membertype['ownerHistory']['ref']
|
|
g.add((resource[ memberOwnerHistory], RDF.type, ontology.History))
|
|
g.add((resource[memberID], ontology.hasHistory, resource[ memberOwnerHistory]))
|
|
except Exception:
|
|
pass
|
|
try:#material is not always there
|
|
for material in membertype['hasAssociations']:
|
|
ismaterial = material['ref']
|
|
g.add((resource[ismaterial], RDF.type, ontology.Material))
|
|
g.add((resource[memberID], ontology.associatesMaterial, resource[ismaterial]))
|
|
except Exception:
|
|
pass
|
|
try:#object is not always there
|
|
count = 1
|
|
for prp in membertype['hasPropertySets']:
|
|
isprp = prp['ref']
|
|
g.add((resource["propertyset_" + isprp + "_" + str(count)], RDF.type, ontology.PropertySet))
|
|
g.add((resource[memberID], ontology.hasProperty, resource["propertyset_" + isprp + "_" + str(count)]))
|
|
count += 1
|
|
except Exception:
|
|
pass
|
|
try:#material is not always there
|
|
for typed in membertype['types']:
|
|
istyped = typed['ref']
|
|
g.add((resource[istyped], RDF.type, ontology.TypeCategory))
|
|
g.add((resource[memberID], ontology.hasType, resource[istyped]))
|
|
except Exception:
|
|
pass
|
|
try:#representationMaps data
|
|
for maps in membertype['representationMaps']:
|
|
#print(maps['mappingOrigin'])
|
|
g.add((resource[memberID], ontology.hasRepresentationType, resource[ maps['mappedRepresentation']['ref']]))
|
|
g.add((resource[ maps['mappedRepresentation']['ref']], RDF.type, ontology.Representation))
|
|
g.add((resource[ maps['mappedRepresentation']['ref']], ontology.xlocation, Literal(maps['mappingOrigin']['location']['coordinates'][0], datatype=XSD.decimal)))
|
|
g.add((resource[ maps['mappedRepresentation']['ref']], ontology.ylocation, Literal(maps['mappingOrigin']['location']['coordinates'][1], datatype=XSD.decimal)))
|
|
g.add((resource[ maps['mappedRepresentation']['ref']], ontology.zlocation, Literal(maps['mappingOrigin']['location']['coordinates'][2], datatype=XSD.decimal)))
|
|
g.add((resource[ maps['mappedRepresentation']['ref']], ontology.xaxis,
|
|
Literal(maps['mappingOrigin']['axis']['directionRatios'][0], datatype=XSD.decimal)))
|
|
g.add((resource[ maps['mappedRepresentation']['ref']], ontology.yaxis,
|
|
Literal(maps['mappingOrigin']['axis']['directionRatios'][1], datatype=XSD.decimal)))
|
|
g.add((resource[ maps['mappedRepresentation']['ref']], ontology.zaxis,
|
|
Literal(maps['mappingOrigin']['axis']['directionRatios'][2], datatype=XSD.decimal)))
|
|
g.add((resource[ maps['mappedRepresentation']['ref']], ontology.xdirection,
|
|
Literal(maps['mappingOrigin']['refDirection']['directionRatios'][0], datatype=XSD.decimal)))
|
|
g.add((resource[ maps['mappedRepresentation']['ref']], ontology.ydirection,
|
|
Literal(maps['mappingOrigin']['refDirection']['directionRatios'][1], datatype=XSD.decimal)))
|
|
g.add((resource[ maps['mappedRepresentation']['ref']], ontology.zdirection,
|
|
Literal(maps['mappingOrigin']['refDirection']['directionRatios'][2], datatype=XSD.decimal)))
|
|
except Exception:
|
|
pass
|
|
return 1
|
|
|
|
def ifcSiteFunction(IfcSite):
|
|
for site in IfcSite:
|
|
siteID = site['globalId']
|
|
#basic information
|
|
g.add((resource[siteID], RDF.type, ontology.Site))
|
|
try:#tag is not always there
|
|
siteTag = site['objectType']
|
|
g.add((resource[siteID], ontology.type, Literal(siteTag)))
|
|
except Exception:
|
|
pass
|
|
try:#name is not always there
|
|
siteDescription = site['description']
|
|
g.add((resource[siteID], ontology.description, Literal(siteDescription)))
|
|
except Exception:
|
|
pass
|
|
try:#name is not always there
|
|
siteName = site['name']
|
|
g.add((resource[siteID], ontology.name, Literal(siteName)))
|
|
except Exception:
|
|
pass
|
|
try:#add history
|
|
siteHistory = site['ownerHistory']['ref']
|
|
g.add((resource[siteHistory], RDF.type, ontology.History))
|
|
g.add((resource[siteID], ontology.hasHistory, resource[siteHistory]))
|
|
except Exception:
|
|
pass
|
|
try:#add composition
|
|
siteType = site['compositionType']
|
|
g.add((resource[siteID], ontology.composition, Literal(siteType)))
|
|
except Exception:
|
|
pass
|
|
try:#add elevation
|
|
siteElevation = site['refElevation']
|
|
g.add((resource[siteID], ontology.elevation, Literal(siteElevation)))
|
|
except Exception:
|
|
pass
|
|
try:#definedby is not always there
|
|
for defined in site['isDefinedBy']:
|
|
issdefined= defined['ref']
|
|
g.add((resource[issdefined], RDF.type, ontology.PropertySet))
|
|
g.add((resource[siteID], ontology.isDefinedBy, resource[issdefined]))
|
|
except Exception:
|
|
pass
|
|
try:#representation is not always there
|
|
for representation in site['representation']['representations']:
|
|
rep = representation['ref']
|
|
g.add((resource[rep], RDF.type, ontology.Representation))
|
|
g.add((resource[siteID], ontology.hasRepresentationType, resource[rep]))
|
|
except Exception:
|
|
pass
|
|
try:#decompose is not always there
|
|
for representation in site['isDecomposedBy']:
|
|
rep = representation['ref']
|
|
g.add((resource[rep], RDF.type, ontology.Object))
|
|
g.add((resource[rep], ontology.isDecomposedBy, resource[siteID]))
|
|
except Exception:
|
|
pass
|
|
try:#decompose is not always there
|
|
for representation in site['decomposes']:
|
|
rep = representation['ref']
|
|
g.add((resource[rep], RDF.type, ontology.Object))
|
|
g.add((resource[siteID], ontology.decomposes, resource[rep]))
|
|
except Exception:
|
|
pass
|
|
try:#coordinates is not always there
|
|
count = 0
|
|
for representation in site['refLatitude']:
|
|
g.add((resource[siteID + "_" + str(count)], RDF.type, ontology.Coordinates))
|
|
g.add((resource[siteID], ontology.hasCoordinates, resource[siteID + "_" + str(count)]))
|
|
g.add((resource[siteID + "_" + str(count)], ontology.latitude, Literal(site['refLatitude'][count], datatype=XSD.decimal)))
|
|
g.add((resource[siteID + "_" + str(count)], ontology.longitude, Literal(site['refLongitude'][count], datatype=XSD.decimal)))
|
|
count += 1
|
|
except Exception:
|
|
pass
|
|
try:#representationMaps data
|
|
g.add((resource[siteID], ontology.hasPlacement, resource["plamenent_" + siteID]))
|
|
g.add((resource["plamenent_" + siteID], RDF.type, ontology.Placement))
|
|
g.add((resource["plamenent_" + siteID], ontology.xlocation, Literal(site['objectPlacement']['relativePlacement']['location']['coordinates'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + siteID], ontology.ylocation, Literal(site['objectPlacement']['relativePlacement']['location']['coordinates'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + siteID], ontology.zlocation, Literal(site['objectPlacement']['relativePlacement']['location']['coordinates'][2], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + siteID], ontology.xaxis,
|
|
Literal(site['objectPlacement']['relativePlacement']['axis']['directionRatios'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + siteID], ontology.yaxis,
|
|
Literal(site['objectPlacement']['relativePlacement']['axis']['directionRatios'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + siteID], ontology.zaxis,
|
|
Literal(site['objectPlacement']['relativePlacement']['axis']['directionRatios'][2], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + siteID], ontology.xdirection,
|
|
Literal(site['objectPlacement']['relativePlacement']['refDirection']['directionRatios'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + siteID], ontology.ydirection,
|
|
Literal(site['objectPlacement']['relativePlacement']['refDirection']['directionRatios'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + siteID], ontology.zdirection,
|
|
Literal(site['objectPlacement']['relativePlacement']['refDirection']['directionRatios'][2], datatype=XSD.decimal)))
|
|
except Exception:
|
|
pass
|
|
return 1
|
|
|
|
def ifcOpeningElementFunction(IfcOpeningElement):
|
|
for opening in IfcOpeningElement:
|
|
openingID = opening['globalId']
|
|
#basic information
|
|
g.add((resource[openingID], RDF.type, ontology.Opening))
|
|
try:#add history
|
|
openingHistory = opening['ownerHistory']['ref']
|
|
g.add((resource[openingHistory], RDF.type, ontology.History))
|
|
g.add((resource[openingID], ontology.hasHistory, resource[openingHistory]))
|
|
except Exception:
|
|
pass
|
|
try:#tag is not always there
|
|
openingTag = opening['tag']
|
|
g.add((resource[openingID], ontology.height, Literal(openingTag)))
|
|
except Exception:
|
|
pass
|
|
try:#name is not always there
|
|
openingName = opening['name']
|
|
g.add((resource[openingID], ontology.name, Literal(openingName)))
|
|
except Exception:
|
|
pass
|
|
try:#predefinedType is not always there
|
|
openingPredefinedType = opening['predefinedType']
|
|
g.add((resource[openingID], ontology.predefinedType, Literal(openingPredefinedType)))
|
|
except Exception:
|
|
pass
|
|
try:#definedby is not always there
|
|
for defined in opening['isDefinedBy']:
|
|
issdefined= defined['ref']
|
|
g.add((resource[issdefined], RDF.type, ontology.PropertySet))
|
|
g.add((resource[openingID], ontology.isDefinedBy, resource[issdefined]))
|
|
except Exception:
|
|
pass
|
|
try:#fillsVoidvoidsElements is not always there
|
|
for void in opening['voidsElements']:
|
|
isvoid = void['ref']
|
|
g.add((resource[isvoid], RDF.type, ontology.Object))
|
|
g.add((resource[openingID], ontology.voidsElements, resource[isvoid]))
|
|
except Exception:
|
|
pass
|
|
try:#representation is not always there
|
|
for representation in opening['representation']['representations']:
|
|
rep = representation['ref']
|
|
g.add((resource[rep], RDF.type, ontology.Representation))
|
|
g.add((resource[openingID], ontology.hasRepresentationType, resource[rep]))
|
|
except Exception:
|
|
pass
|
|
try:#hasAssociations is not always there
|
|
for typed in opening['hasAssignments']:
|
|
iselement = typed['ref']
|
|
g.add((resource[iselement], RDF.type, ontology.Group))
|
|
g.add((resource[openingID], ontology.hasAssignments, resource[iselement]))
|
|
except Exception:
|
|
pass
|
|
try:#fillsVoid is not always there
|
|
for void in opening['hasFillings']:
|
|
isvoid = void['ref']
|
|
g.add((resource[isvoid], RDF.type, ontology.Void))
|
|
g.add((resource[openingID], ontology.fillsVoid, resource[isvoid]))
|
|
except Exception:
|
|
pass
|
|
|
|
try:#representationMaps data
|
|
g.add((resource[openingID], ontology.hasPlacement, resource["plamenent_" + openingID + "_1"]))
|
|
g.add((resource["plamenent_" + openingID + "_1"], RDF.type, ontology.Placement))
|
|
g.add((resource["plamenent_" + openingID + "_1"], ontology.xlocation, Literal(opening['objectPlacement']['relativePlacement']['location']['coordinates'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + openingID + "_1"], ontology.ylocation, Literal(opening['objectPlacement']['relativePlacement']['location']['coordinates'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + openingID + "_1"], ontology.zlocation, Literal(opening['objectPlacement']['relativePlacement']['location']['coordinates'][2], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + openingID + "_1"], ontology.xaxis,
|
|
Literal(opening['objectPlacement']['relativePlacement']['axis']['directionRatios'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + openingID + "_1"], ontology.yaxis,
|
|
Literal(opening['objectPlacement']['relativePlacement']['axis']['directionRatios'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + openingID + "_1"], ontology.zaxis,
|
|
Literal(opening['objectPlacement']['relativePlacement']['axis']['directionRatios'][2], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + openingID + "_1"], ontology.xdirection,
|
|
Literal(opening['objectPlacement']['relativePlacement']['refDirection']['directionRatios'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + openingID + "_1"], ontology.ydirection,
|
|
Literal(opening['objectPlacement']['relativePlacement']['refDirection']['directionRatios'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + openingID + "_1"], ontology.zdirection,
|
|
Literal(opening['objectPlacement']['relativePlacement']['refDirection']['directionRatios'][2], datatype=XSD.decimal)))
|
|
except Exception:
|
|
pass
|
|
try:
|
|
g.add((resource[openingID], ontology.hasPlacement, resource["plamenent_" + openingID + "_2"]))
|
|
g.add((resource["plamenent_" + openingID + "_2"], RDF.type, ontology.Placement))
|
|
g.add((resource["plamenent_" + openingID + "_2"], ontology.xlocation, Literal(opening['objectPlacement']['placementRelTo']['relativePlacement']['location']['coordinates'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + openingID + "_2"], ontology.ylocation, Literal(opening['objectPlacement']['placementRelTo']['relativePlacement']['location']['coordinates'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + openingID + "_2"], ontology.zlocation, Literal(opening['objectPlacement']['placementRelTo']['relativePlacement']['location']['coordinates'][2], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + openingID + "_2"], ontology.xaxis,
|
|
Literal(opening['objectPlacement']['placementRelTo']['relativePlacement']['axis']['directionRatios'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + openingID + "_2"], ontology.yaxis,
|
|
Literal(opening['objectPlacement']['placementRelTo']['relativePlacement']['axis']['directionRatios'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + openingID + "_2"], ontology.zaxis,
|
|
Literal(opening['objectPlacement']['placementRelTo']['relativePlacement']['axis']['directionRatios'][2], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + openingID + "_2"], ontology.xdirection,
|
|
Literal(opening['objectPlacement']['placementRelTo']['relativePlacement']['refDirection']['directionRatios'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + openingID + "_2"], ontology.ydirection,
|
|
Literal(opening['objectPlacement']['placementRelTo']['relativePlacement']['refDirection']['directionRatios'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + openingID + "_2"], ontology.zdirection,
|
|
Literal(opening['objectPlacement']['placementRelTo']['relativePlacement']['refDirection']['directionRatios'][2], datatype=XSD.decimal)))
|
|
except Exception:
|
|
pass
|
|
try:
|
|
g.add((resource[openingID], ontology.hasPlacement, resource["plamenent_" + openingID + "_3"]))
|
|
g.add((resource["plamenent_" + openingID + "_3"], RDF.type, ontology.Placement))
|
|
g.add((resource["plamenent_" + openingID + "_3"], ontology.xlocation, Literal(opening['objectPlacement']['placementRelTo']['placementRelTo']['relativePlacement']['location']['coordinates'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + openingID + "_3"], ontology.ylocation, Literal(opening['objectPlacement']['placementRelTo']['placementRelTo']['relativePlacement']['location']['coordinates'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + openingID + "_3"], ontology.zlocation, Literal(opening['objectPlacement']['placementRelTo']['placementRelTo']['relativePlacement']['location']['coordinates'][2], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + openingID + "_3"], ontology.xaxis,
|
|
Literal(opening['objectPlacement']['placementRelTo']['placementRelTo']['relativePlacement']['axis']['directionRatios'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + openingID + "_3"], ontology.yaxis,
|
|
Literal(opening['objectPlacement']['placementRelTo']['placementRelTo']['relativePlacement']['axis']['directionRatios'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + openingID + "_3"], ontology.zaxis,
|
|
Literal(opening['objectPlacement']['placementRelTo']['placementRelTo']['relativePlacement']['axis']['directionRatios'][2], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + openingID + "_3"], ontology.xdirection,
|
|
Literal(opening['objectPlacement']['placementRelTo']['placementRelTo']['relativePlacement']['refDirection']['directionRatios'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + openingID + "_3"], ontology.ydirection,
|
|
Literal(opening['objectPlacement']['placementRelTo']['placementRelTo']['relativePlacement']['refDirection']['directionRatios'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + openingID + "_3"], ontology.zdirection,
|
|
Literal(opening['objectPlacement']['placementRelTo']['placementRelTo']['relativePlacement']['refDirection']['directionRatios'][2], datatype=XSD.decimal)))
|
|
except Exception:
|
|
pass
|
|
try:
|
|
g.add((resource[openingID], ontology.hasPlacement, resource["plamenent_" + openingID + "_4"]))
|
|
g.add((resource["plamenent_" + openingID + "_4"], RDF.type, ontology.Placement))
|
|
g.add((resource["plamenent_" + openingID + "_4"], ontology.xlocation, Literal(opening['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['location']['coordinates'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + openingID + "_4"], ontology.ylocation, Literal(opening['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['location']['coordinates'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + openingID + "_4"], ontology.zlocation, Literal(opening['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['location']['coordinates'][2], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + openingID + "_4"], ontology.xaxis,
|
|
Literal(opening['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['axis']['directionRatios'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + openingID + "_4"], ontology.yaxis,
|
|
Literal(opening['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['axis']['directionRatios'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + openingID + "_4"], ontology.zaxis,
|
|
Literal(opening['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['axis']['directionRatios'][2], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + openingID + "_4"], ontology.xdirection,
|
|
Literal(opening['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['refDirection']['directionRatios'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + openingID + "_4"], ontology.ydirection,
|
|
Literal(opening['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['refDirection']['directionRatios'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + openingID + "_4"], ontology.zdirection,
|
|
Literal(opening['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['refDirection']['directionRatios'][2], datatype=XSD.decimal)))
|
|
except Exception:
|
|
pass
|
|
try:#representationMaps data
|
|
g.add((resource[openingID], ontology.hasPlacement, resource["plamenent_" + openingID + "_5"]))
|
|
g.add((resource["plamenent_" + openingID + "_5"], RDF.type, ontology.Placement))
|
|
g.add((resource["plamenent_" + openingID + "_5"], ontology.xlocation, Literal(opening['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['location']['coordinates'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + openingID + "_5"], ontology.ylocation, Literal(opening['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['location']['coordinates'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + openingID + "_5"], ontology.zlocation, Literal(opening['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['location']['coordinates'][2], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + openingID + "_5"], ontology.xaxis,
|
|
Literal(opening['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['axis']['directionRatios'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + openingID + "_5"], ontology.yaxis,
|
|
Literal(opening['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['axis']['directionRatios'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + openingID + "_5"], ontology.zaxis,
|
|
Literal(opening['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['axis']['directionRatios'][2], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + openingID + "_5"], ontology.xdirection,
|
|
Literal(opening['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['refDirection']['directionRatios'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + openingID + "_5"], ontology.ydirection,
|
|
Literal(opening['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['refDirection']['directionRatios'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + openingID + "_5"], ontology.zdirection,
|
|
Literal(opening['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['refDirection']['directionRatios'][2], datatype=XSD.decimal)))
|
|
except Exception:
|
|
pass
|
|
return 1
|
|
|
|
def ifcRelAggregatesFunction(IfcRelAggregates):
|
|
for aggregates in IfcRelAggregates:
|
|
aggregatesID = aggregates['globalId']
|
|
#basic information
|
|
g.add((resource[aggregatesID], RDF.type, ontology.Object))
|
|
try:#add history
|
|
aggregatesHistory = aggregates['ownerHistory']['ref']
|
|
g.add((resource[aggregatesHistory], RDF.type, ontology.History))
|
|
g.add((resource[aggregatesID], ontology.hasHistory, resource[aggregatesHistory]))
|
|
except Exception:
|
|
pass
|
|
try:#name is not always there
|
|
aggregatesName = aggregates['name']
|
|
g.add((resource[aggregatesID], ontology.name, Literal(aggregatesName)))
|
|
except Exception:
|
|
pass
|
|
try:#name is not always there
|
|
aggregatesDescription = aggregates['description']
|
|
g.add((resource[aggregatesID], ontology.description, Literal(aggregatesDescription)))
|
|
except Exception:
|
|
pass
|
|
try:#relatingObject is not always there
|
|
relating = aggregates['relatingObject']['ref']
|
|
g.add((resource[relating], RDF.type, ontology.Object))
|
|
g.add((resource[aggregatesID], ontology.relatingElement, resource[relating]))
|
|
except Exception:
|
|
pass
|
|
try:
|
|
for related in aggregates['relatedObjects']:
|
|
g.add((resource[related['ref']], RDF.type, ontology.Object))
|
|
g.add((resource[aggregatesID], ontology.relatedObject, resource[related['ref']]))
|
|
except Exception:
|
|
pass
|
|
return 1
|
|
|
|
def ifcGeometricRepresentationContextFunction(IfcGeometricRepresentationContext):
|
|
for context in IfcGeometricRepresentationContext:
|
|
contextID = context['globalId']
|
|
#basic information
|
|
g.add((resource[contextID], RDF.type, ontology.Context))
|
|
try:#contextType is not always there
|
|
contextType = context['contextType']
|
|
g.add((resource[contextID], ontology.contextType, Literal(contextType)))
|
|
except Exception:
|
|
pass
|
|
try:#contextIdentifier is not always there
|
|
contextIdentifier = context['contextIdentifier']
|
|
g.add((resource[contextID], ontology.identifier, Literal(contextIdentifier)))
|
|
except Exception:
|
|
pass
|
|
try:#precision is not always there
|
|
precision = context['precision']
|
|
g.add((resource[contextID], ontology.contextPrecision, Literal(precision)))
|
|
except Exception:
|
|
pass
|
|
try:#coordinateSpaceDimension is not always there
|
|
space = context['coordinateSpaceDimension']
|
|
g.add((resource[contextID], ontology.coordinateSpaceDimension, Literal(space)))
|
|
except Exception:
|
|
pass
|
|
try:#hasSubContexts is not always there
|
|
for sub in context['hasSubContexts']:
|
|
subContext = sub['ref']
|
|
g.add((resource[subContext], RDF.type, ontology.Context))
|
|
g.add((resource[contextID], ontology.hasSubContexts, resource[subContext]))
|
|
except Exception:
|
|
pass
|
|
try:#trueNorth is not always there
|
|
trueNorthType, trueNorthdirectionRatios0, trueNorthdirectionRatios1 = context['trueNorth']['type'], context['trueNorth']['directionRatios'][0], context['trueNorth']['directionRatios'][1]
|
|
g.add((resource[contextID], ontology.northType, Literal(trueNorthType)))
|
|
g.add((resource[contextID], ontology.northdirectionRatios0, Literal(trueNorthdirectionRatios0)))
|
|
g.add((resource[contextID], ontology.northdirectionRatios1, Literal(trueNorthdirectionRatios1)))
|
|
except Exception:
|
|
pass
|
|
try:#representationMaps data
|
|
g.add((resource["placement_" + contextID], RDF.type, ontology.Representation))
|
|
g.add((resource[contextID], ontology.hasRepresentationType, resource["placement_" + contextID]))
|
|
g.add((resource["placement_" + contextID], ontology.xlocation, Literal(context['worldCoordinateSystem']['location']['coordinates'][0], datatype=XSD.decimal)))
|
|
g.add((resource["placement_" + contextID], ontology.ylocation, Literal(context['worldCoordinateSystem']['location']['coordinates'][1], datatype=XSD.decimal)))
|
|
g.add((resource["placement_" + contextID], ontology.zlocation, Literal(context['worldCoordinateSystem']['location']['coordinates'][2], datatype=XSD.decimal)))
|
|
except Exception:
|
|
pass
|
|
try:#representationMaps data
|
|
g.add((resource["placement_" + contextID], ontology.xaxis, Literal(context['worldCoordinateSystem']['axis']['directionRatios'][0], datatype=XSD.decimal)))
|
|
g.add((resource["placement_" + contextID], ontology.yaxis, Literal(context['worldCoordinateSystem']['axis']['directionRatios'][1], datatype=XSD.decimal)))
|
|
g.add((resource["placement_" + contextID], ontology.zaxis, Literal(context['worldCoordinateSystem']['axis']['directionRatios'][2], datatype=XSD.decimal)))
|
|
except Exception:
|
|
pass
|
|
try:#representationMaps data
|
|
g.add((resource["placement_" + contextID], ontology.xdirection, Literal(context['worldCoordinateSystem']['refDirection']['directionRatios'][0], datatype=XSD.decimal)))
|
|
g.add((resource["placement_" + contextID], ontology.ydirection, Literal(context['worldCoordinateSystem']['refDirection']['directionRatios'][1], datatype=XSD.decimal)))
|
|
g.add((resource["placement_" + contextID], ontology.zdirection, Literal(context['worldCoordinateSystem']['refDirection']['directionRatios'][2], datatype=XSD.decimal)))
|
|
except Exception:
|
|
pass
|
|
try:#representationsInContext is not always there
|
|
for sub in context['representationsInContext']:
|
|
g.add((resource["placement_" + contextID], ontology.hasContext,
|
|
resource[sub["ref"]]))
|
|
|
|
except Exception:
|
|
pass
|
|
return 1
|
|
|
|
def ifcWindowLiningPropertiesFunction(IfcWindowLiningProperties):
|
|
for window in IfcWindowLiningProperties:
|
|
windowID = window['globalId']
|
|
#basic information
|
|
g.add((resource[windowID], RDF.type, ontology.WindowLining))
|
|
try:#add history
|
|
windowHistory = window['ownerHistory']['ref']
|
|
g.add((resource[windowHistory], RDF.type, ontology.History))
|
|
g.add((resource[windowID], ontology.hasHistory, resource[windowHistory]))
|
|
except Exception:
|
|
pass
|
|
try:#name is not always there
|
|
windowName = window['name']
|
|
g.add((resource[windowID], ontology.name, Literal(windowName)))
|
|
except Exception:
|
|
pass
|
|
try:#definedby is not always there
|
|
for defined in window['definesType']:
|
|
issdefined = defined['ref']
|
|
g.add((resource[issdefined], RDF.type, ontology.Representation))
|
|
g.add((resource[windowID], ontology.hasRepresentationType, resource[issdefined]))
|
|
except Exception:
|
|
pass
|
|
try:#liningDepth is not always there
|
|
lining = window['liningDepth']
|
|
g.add((resource[windowID], ontology.liningDepth, Literal(lining)))
|
|
except Exception:
|
|
pass
|
|
try:#liningThickness is not always there
|
|
thickness = window['liningThickness']
|
|
g.add((resource[windowID], ontology.liningThickness, Literal(thickness)))
|
|
except Exception:
|
|
pass
|
|
return 1
|
|
|
|
def ifcRelVoidsElementFunction(IfcRelVoidsElement):
|
|
for void in IfcRelVoidsElement:
|
|
voidID = void['globalId']
|
|
#basic information
|
|
g.add((resource[voidID], RDF.type, ontology.Void))
|
|
try:#add history
|
|
voidHistory = void['ownerHistory']['ref']
|
|
g.add((resource[voidHistory], RDF.type, ontology.History))
|
|
g.add((resource[voidID], ontology.hasHistory, resource[voidHistory]))
|
|
except Exception:
|
|
pass
|
|
try:#relatingBuildingElement is not always there
|
|
building = void['relatingBuildingElement']['ref']
|
|
g.add((resource[building], RDF.type, ontology.Structure))
|
|
g.add((resource[voidID], ontology.relatingBuildingElement, resource[building]))
|
|
except Exception:
|
|
pass
|
|
try:#relatedOpeningElement is not always there
|
|
opening = void['relatedOpeningElement']['ref']
|
|
g.add((resource[opening], RDF.type, ontology.Opening))
|
|
g.add((resource[voidID], ontology.relatedOpeningElement, resource[opening]))
|
|
except Exception:
|
|
pass
|
|
return 1
|
|
|
|
def ifcDoorTypeFunction(IfcDoorType):
|
|
for doortype in IfcDoorType:
|
|
doorID = doortype['globalId']
|
|
#basic information
|
|
g.add((resource[doorID], RDF.type, ontology.DoorType))
|
|
try:#name is not always there
|
|
doorName = doortype['name']
|
|
g.add((resource[doorID], ontology.name, Literal(doorName)))
|
|
except Exception:
|
|
pass
|
|
try:#predefinedType is not always there
|
|
doorPredefinedType = doortype['predefinedType']
|
|
g.add((resource[doorID], ontology.predefinedType, Literal(doorPredefinedType)))
|
|
except Exception:
|
|
pass
|
|
try:#operationType is not always there
|
|
doorOperationType = doortype['operationType']
|
|
g.add((resource[doorID], ontology.operationType, Literal(doorOperationType)))
|
|
except Exception:
|
|
pass
|
|
try:#add history
|
|
doorOwnerHistory = doortype['ownerHistory']['ref']
|
|
g.add((resource[ doorOwnerHistory], RDF.type, ontology.History))
|
|
g.add((resource[doorID], ontology.hasHistory, resource[ doorOwnerHistory]))
|
|
except Exception:
|
|
pass
|
|
try:#tag is not always there
|
|
doorTag = doortype['tag']
|
|
g.add((resource[doorID], ontology.tag, Literal(doorTag)))
|
|
except Exception:
|
|
pass
|
|
try:#material is not always there
|
|
for material in doortype['hasAssociations']:
|
|
ismaterial = material['ref']
|
|
g.add((resource[ismaterial], RDF.type, ontology.Material))
|
|
g.add((resource[doorID], ontology.associatesMaterial, resource[ismaterial]))
|
|
except Exception:
|
|
pass
|
|
try:#object is not always there
|
|
count = 1
|
|
for prp in doortype['hasPropertySets']:
|
|
isprp = prp['ref']
|
|
g.add((resource["propertyset_" + isprp + "_" + str(count)], RDF.type, ontology.PropertySet))
|
|
g.add((resource[doorID], ontology.hasProperty, resource["propertyset_" + isprp + "_" + str(count)]))
|
|
count += 1
|
|
except Exception:
|
|
pass
|
|
try: # material is not always there
|
|
for typed in doortype['types']:
|
|
istyped = typed['ref']
|
|
g.add((resource[istyped], RDF.type, ontology.TypeCategory))
|
|
g.add((resource[doorID], ontology.hasType, resource[istyped]))
|
|
except Exception:
|
|
pass
|
|
try:#representationMaps data
|
|
for maps in doortype['representationMaps']:
|
|
#print(maps['mappingOrigin'])
|
|
g.add((resource[doorID], ontology.hasRepresentationType, resource[ maps['mappedRepresentation']['ref']]))
|
|
g.add((resource[ maps['mappedRepresentation']['ref']], RDF.type, ontology.Representation))
|
|
g.add((resource[ maps['mappedRepresentation']['ref']], ontology.xlocation, Literal(maps['mappingOrigin']['location']['coordinates'][0], datatype=XSD.decimal)))
|
|
g.add((resource[ maps['mappedRepresentation']['ref']], ontology.ylocation, Literal(maps['mappingOrigin']['location']['coordinates'][1], datatype=XSD.decimal)))
|
|
g.add((resource[ maps['mappedRepresentation']['ref']], ontology.zlocation, Literal(maps['mappingOrigin']['location']['coordinates'][2], datatype=XSD.decimal)))
|
|
except Exception:
|
|
pass
|
|
return 1
|
|
|
|
def ifcDoorLiningPropertiesFunction(IfcDoorLiningProperties):
|
|
for door in IfcDoorLiningProperties:
|
|
doorID = door['globalId']
|
|
#basic information
|
|
g.add((resource[doorID], RDF.type, ontology.DoorLining))
|
|
try:#add history
|
|
doorHistory = door['ownerHistory']['ref']
|
|
g.add((resource[doorHistory], RDF.type, ontology.History))
|
|
g.add((resource[doorID], ontology.hasHistory, resource[doorHistory]))
|
|
except Exception:
|
|
pass
|
|
try:#name is not always there
|
|
doorName = door['name']
|
|
g.add((resource[doorID], ontology.name, Literal(doorName)))
|
|
except Exception:
|
|
pass
|
|
try:#definedby is not always there
|
|
for defined in door['definesType']:
|
|
issdefined= defined['ref']
|
|
g.add((resource[issdefined], RDF.type, ontology.PropertySet))
|
|
g.add((resource[doorID], ontology.hasProperty, resource[issdefined]))
|
|
except Exception:
|
|
pass
|
|
try:#liningDepth is not always there
|
|
lining = door['liningDepth']
|
|
g.add((resource[doorID], ontology.liningDepth, Literal(lining)))
|
|
except Exception:
|
|
pass
|
|
try:#liningThickness is not always there
|
|
thickness = door['liningThickness']
|
|
g.add((resource[doorID], ontology.liningThickness, Literal(thickness)))
|
|
except Exception:
|
|
pass
|
|
return 1
|
|
|
|
def ifcRelDefinesByPropertiesFunction(IfcRelDefinesByProperties):
|
|
for property in IfcRelDefinesByProperties:
|
|
propertyID = property['globalId']
|
|
#basic information
|
|
g.add((resource[propertyID], RDF.type, ontology.PropertySet))
|
|
try:#add history
|
|
propertyHistory = property['ownerHistory']['ref']
|
|
g.add((resource[propertyHistory], RDF.type, ontology.History))
|
|
g.add((resource[propertyID], ontology.hasHistory, resource[propertyHistory]))
|
|
except Exception:
|
|
pass
|
|
try: # add history
|
|
propertyDefinition = property['relatingPropertyDefinition']['ref']
|
|
g.add((resource[propertyDefinition], RDF.type, ontology.PropertySet))
|
|
g.add((resource[propertyID], ontology.relatedProperty, resource[propertyDefinition]))
|
|
except Exception:
|
|
pass
|
|
try: # add history
|
|
for obj in property['relatedObjects']:
|
|
propertyObject = obj['ref']
|
|
g.add((resource[propertyObject], RDF.type, ontology.Object))
|
|
g.add((resource[propertyID], ontology.relatedObject, resource[propertyObject]))
|
|
except Exception:
|
|
pass
|
|
return 1
|
|
|
|
def ifcWallTypeFunction(IfcWallType):
|
|
for walltype in IfcWallType:
|
|
wallID = walltype['globalId']
|
|
#basic information
|
|
g.add((resource[wallID], RDF.type, ontology.WallType))
|
|
try:#name is not always there
|
|
wallName = walltype['name']
|
|
g.add((resource[wallID], ontology.name, Literal(wallName)))
|
|
except Exception:
|
|
pass
|
|
try:#predefinedType is not always there
|
|
wallPredefinedType = walltype['predefinedType']
|
|
g.add((resource[wallID], ontology.predefinedType, Literal(wallPredefinedType)))
|
|
except Exception:
|
|
pass
|
|
try:#add history
|
|
wallOwnerHistory = walltype['ownerHistory']['ref']
|
|
g.add((resource[ wallOwnerHistory], RDF.type, ontology.History))
|
|
g.add((resource[wallID], ontology.hasHistory, resource[ wallOwnerHistory]))
|
|
except Exception:
|
|
pass
|
|
try:#tag is not always there
|
|
wallTag = walltype['tag']
|
|
g.add((resource[wallID], ontology.tag, Literal(wallTag)))
|
|
except Exception:
|
|
pass
|
|
try:#material is not always there
|
|
for material in walltype['hasAssociations']:
|
|
ismaterial = material['ref']
|
|
g.add((resource[ismaterial], RDF.type, ontology.Material))
|
|
g.add((resource[wallID], ontology.associatesMaterial, resource[ismaterial]))
|
|
except Exception:
|
|
pass
|
|
try:#object is not always there
|
|
count = 1
|
|
for prp in walltype['hasPropertySets']:
|
|
isprp = prp['ref']
|
|
g.add((resource["propertyset_" + isprp + "_" + str(count)], RDF.type, ontology.PropertySet))
|
|
g.add((resource[wallID], ontology.hasProperty, resource["propertyset_" + isprp + "_" + str(count)]))
|
|
count += 1
|
|
except Exception:
|
|
pass
|
|
try: # material is not always there
|
|
for typed in walltype['types']:
|
|
istyped = typed['ref']
|
|
g.add((resource[istyped], RDF.type, ontology.TypeCategory))
|
|
g.add((resource[wallID], ontology.hasType, resource[istyped]))
|
|
except Exception:
|
|
pass
|
|
try:#representationMaps data
|
|
for maps in walltype['representationMaps']:
|
|
#print(maps['mappingOrigin'])
|
|
g.add((resource[wallID], ontology.hasRepresentationType, resource[ maps['mappedRepresentation']['ref']]))
|
|
g.add((resource[ maps['mappedRepresentation']['ref']], RDF.type, ontology.Representation))
|
|
g.add((resource[ maps['mappedRepresentation']['ref']], ontology.xlocation, Literal(maps['mappingOrigin']['location']['coordinates'][0], datatype=XSD.decimal)))
|
|
g.add((resource[ maps['mappedRepresentation']['ref']], ontology.ylocation, Literal(maps['mappingOrigin']['location']['coordinates'][1], datatype=XSD.decimal)))
|
|
g.add((resource[ maps['mappedRepresentation']['ref']], ontology.zlocation, Literal(maps['mappingOrigin']['location']['coordinates'][2], datatype=XSD.decimal)))
|
|
g.add((resource[ maps['mappedRepresentation']['ref']], ontology.xaxis,
|
|
Literal(maps['mappingOrigin']['axis']['directionRatios'][0], datatype=XSD.decimal)))
|
|
g.add((resource[ maps['mappedRepresentation']['ref']], ontology.yaxis,
|
|
Literal(maps['mappingOrigin']['axis']['directionRatios'][1], datatype=XSD.decimal)))
|
|
g.add((resource[ maps['mappedRepresentation']['ref']], ontology.zaxis,
|
|
Literal(maps['mappingOrigin']['axis']['directionRatios'][2], datatype=XSD.decimal)))
|
|
g.add((resource[ maps['mappedRepresentation']['ref']], ontology.xdirection,
|
|
Literal(maps['mappingOrigin']['refDirection']['directionRatios'][0], datatype=XSD.decimal)))
|
|
g.add((resource[ maps['mappedRepresentation']['ref']], ontology.ydirection,
|
|
Literal(maps['mappingOrigin']['refDirection']['directionRatios'][1], datatype=XSD.decimal)))
|
|
g.add((resource[ maps['mappedRepresentation']['ref']], ontology.zdirection,
|
|
Literal(maps['mappingOrigin']['refDirection']['directionRatios'][2], datatype=XSD.decimal)))
|
|
except Exception:
|
|
pass
|
|
return 1
|
|
|
|
def ifcWindowTypeFunction(IfcWindowType):
|
|
for windowtype in IfcWindowType:
|
|
windowID = windowtype['globalId']
|
|
#basic information
|
|
g.add((resource[windowID], RDF.type, ontology.WindowType))
|
|
try:#name is not always there
|
|
windowName = windowtype['name']
|
|
g.add((resource[windowID], ontology.name, Literal(windowName)))
|
|
except Exception:
|
|
pass
|
|
try:#predefinedType is not always there
|
|
windowPredefinedType = windowtype['predefinedType']
|
|
g.add((resource[windowID], ontology.predefinedType, Literal(windowPredefinedType)))
|
|
except Exception:
|
|
pass
|
|
try:#partitioningType is not always there
|
|
windowPartitioningType = windowtype['partitioningType']
|
|
g.add((resource[windowID], ontology.partitioningType, Literal(windowPartitioningType)))
|
|
except Exception:
|
|
pass
|
|
try:#add history
|
|
windowOwnerHistory = windowtype['ownerHistory']['ref']
|
|
g.add((resource[ windowOwnerHistory], RDF.type, ontology.History))
|
|
g.add((resource[windowID], ontology.hasHistory, resource[ windowOwnerHistory]))
|
|
except Exception:
|
|
pass
|
|
try:#add history
|
|
windowTag = windowtype['tag']
|
|
g.add((resource[windowID], ontology.tag, Literal(windowTag)))
|
|
except Exception:
|
|
pass
|
|
try:#material is not always there
|
|
for material in windowtype['hasAssociations']:
|
|
ismaterial = material['ref']
|
|
g.add((resource[ismaterial], RDF.type, ontology.Material))
|
|
g.add((resource[windowID], ontology.associatesMaterial, resource[ismaterial]))
|
|
except Exception:
|
|
pass
|
|
try:#object is not always there
|
|
count = 1
|
|
for prp in windowtype['hasPropertySets']:
|
|
isprp = prp['ref']
|
|
g.add((resource["propertyset_" + isprp + "_" + str(count)], RDF.type, ontology.PropertySet))
|
|
g.add((resource[windowID], ontology.hasProperty, resource["propertyset_" + isprp + "_" + str(count)]))
|
|
count += 1
|
|
except Exception:
|
|
pass
|
|
try: # material is not always there
|
|
for typed in windowtype['types']:
|
|
istyped = typed['ref']
|
|
g.add((resource[istyped], RDF.type, ontology.TypeCategory))
|
|
g.add((resource[windowID], ontology.hasType, resource[istyped]))
|
|
except Exception:
|
|
pass
|
|
try:#representationMaps data
|
|
for maps in windowtype['representationMaps']:
|
|
#print(maps['mappingOrigin'])
|
|
g.add((resource[windowID], ontology.hasRepresentationType, resource[ maps['mappedRepresentation']['ref']]))
|
|
g.add((resource[ maps['mappedRepresentation']['ref']], RDF.type, ontology.Representation))
|
|
g.add((resource[ maps['mappedRepresentation']['ref']], ontology.xlocation, Literal(maps['mappingOrigin']['location']['coordinates'][0], datatype=XSD.decimal)))
|
|
g.add((resource[ maps['mappedRepresentation']['ref']], ontology.ylocation, Literal(maps['mappingOrigin']['location']['coordinates'][1], datatype=XSD.decimal)))
|
|
g.add((resource[ maps['mappedRepresentation']['ref']], ontology.zlocation, Literal(maps['mappingOrigin']['location']['coordinates'][2], datatype=XSD.decimal)))
|
|
g.add((resource[ maps['mappedRepresentation']['ref']], ontology.xaxis,
|
|
Literal(maps['mappingOrigin']['axis']['directionRatios'][0], datatype=XSD.decimal)))
|
|
g.add((resource[ maps['mappedRepresentation']['ref']], ontology.yaxis,
|
|
Literal(maps['mappingOrigin']['axis']['directionRatios'][1], datatype=XSD.decimal)))
|
|
g.add((resource[ maps['mappedRepresentation']['ref']], ontology.zaxis,
|
|
Literal(maps['mappingOrigin']['axis']['directionRatios'][2], datatype=XSD.decimal)))
|
|
g.add((resource[ maps['mappedRepresentation']['ref']], ontology.xdirection,
|
|
Literal(maps['mappingOrigin']['refDirection']['directionRatios'][0], datatype=XSD.decimal)))
|
|
g.add((resource[ maps['mappedRepresentation']['ref']], ontology.ydirection,
|
|
Literal(maps['mappingOrigin']['refDirection']['directionRatios'][1], datatype=XSD.decimal)))
|
|
g.add((resource[ maps['mappedRepresentation']['ref']], ontology.zdirection,
|
|
Literal(maps['mappingOrigin']['refDirection']['directionRatios'][2], datatype=XSD.decimal)))
|
|
except Exception:
|
|
pass
|
|
return 1
|
|
|
|
def ifcWallFunction(IfcWall):
|
|
for wall in IfcWall:
|
|
wallID = wall['globalId']
|
|
#basic information
|
|
g.add((resource[wallID], RDF.type, ontology.Wall))
|
|
try:#predefinedType is not always there
|
|
wallPredefinedType = wall['predefinedType']
|
|
g.add((resource[wallID], ontology.predefinedType, Literal(wallPredefinedType)))
|
|
except Exception:
|
|
pass
|
|
try:#tag is not always there
|
|
wallTag = wall['tag']
|
|
g.add((resource[wallID], ontology.tag, Literal(wallTag)))
|
|
except Exception:
|
|
pass
|
|
try:#tag is not always there
|
|
wallName = wall['name']
|
|
g.add((resource[wallID], ontology.name, Literal(wallName)))
|
|
except Exception:
|
|
pass
|
|
try:#tag is not always there
|
|
wallObjectType = wall['objectType']
|
|
g.add((resource[wallID], ontology.type, Literal(wallObjectType)))
|
|
except Exception:
|
|
pass
|
|
try:#add history
|
|
wallHistory = wall['ownerHistory']['ref']
|
|
g.add((resource[wallHistory], RDF.type, ontology.History))
|
|
g.add((resource[wallID], ontology.hasHistory, resource[wallHistory]))
|
|
except Exception:
|
|
pass
|
|
try:#material is not always there
|
|
for material in wall['hasAssociations']:
|
|
ismaterial = material['ref']
|
|
g.add((resource[ismaterial], RDF.type, ontology.Material))
|
|
g.add((resource[wallID], ontology.associatesMaterial, resource[ismaterial]))
|
|
except Exception:
|
|
pass
|
|
try:#isTypedBy is not always there
|
|
for typed in wall['isTypedBy']:
|
|
istyped = typed['ref']
|
|
g.add((resource[istyped], RDF.type, ontology.TypeCategory))
|
|
g.add((resource[wallID], ontology.hasType, resource[istyped]))
|
|
except Exception:
|
|
pass
|
|
try:#hasAssociations is not always there
|
|
for typed in wall['hasAssignments']:
|
|
iselement = typed['ref']
|
|
g.add((resource[iselement], RDF.type, ontology.Group))
|
|
g.add((resource[wallID], ontology.hasAssignments, resource[iselement]))
|
|
except Exception:
|
|
pass
|
|
try:#definedby is not always there
|
|
for defined in wall['isDefinedBy']:
|
|
issdefined= defined['ref']
|
|
g.add((resource[issdefined], RDF.type, ontology.PropertySet))
|
|
g.add((resource[wallID], ontology.isDefinedBy, resource[issdefined]))
|
|
except Exception:
|
|
pass
|
|
try:#representation is not always there
|
|
for representation in wall['representation']['representations']:
|
|
rep = representation['ref']
|
|
g.add((resource[rep], RDF.type, ontology.Representation))
|
|
g.add((resource[wallID], ontology.hasRepresentationType, resource[rep]))
|
|
except Exception:
|
|
pass
|
|
try:#structure is not always there
|
|
for structure in wall['containedInStructure']:
|
|
isstructure= structure['ref']
|
|
g.add((resource[isstructure], RDF.type, ontology.Structure))
|
|
g.add((resource[wallID], ontology.inStructure, resource[isstructure]))
|
|
except Exception:
|
|
pass
|
|
try:#opening is not always there
|
|
for void in wall['hasOpenings']:
|
|
opening = void['ref']
|
|
g.add((resource[opening], RDF.type, ontology.Opening))
|
|
g.add((resource[wallID], ontology.hasOpening, resource[opening]))
|
|
except Exception:
|
|
pass
|
|
try:#representationMaps data
|
|
g.add((resource[wallID], ontology.hasPlacement, resource["plamenent_" + wallID + "_1"]))
|
|
g.add((resource["plamenent_" + wallID + "_1"], RDF.type, ontology.Placement))
|
|
g.add((resource["plamenent_" + wallID + "_1"], ontology.xlocation, Literal(wall['objectPlacement']['relativePlacement']['location']['coordinates'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + wallID + "_1"], ontology.ylocation, Literal(wall['objectPlacement']['relativePlacement']['location']['coordinates'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + wallID + "_1"], ontology.zlocation, Literal(wall['objectPlacement']['relativePlacement']['location']['coordinates'][2], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + wallID + "_1"], ontology.xaxis,
|
|
Literal(wall['objectPlacement']['relativePlacement']['axis']['directionRatios'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + wallID + "_1"], ontology.yaxis,
|
|
Literal(wall['objectPlacement']['relativePlacement']['axis']['directionRatios'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + wallID + "_1"], ontology.zaxis,
|
|
Literal(wall['objectPlacement']['relativePlacement']['axis']['directionRatios'][2], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + wallID + "_1"], ontology.xdirection,
|
|
Literal(wall['objectPlacement']['relativePlacement']['refDirection']['directionRatios'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + wallID + "_1"], ontology.ydirection,
|
|
Literal(wall['objectPlacement']['relativePlacement']['refDirection']['directionRatios'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + wallID + "_1"], ontology.zdirection,
|
|
Literal(wall['objectPlacement']['relativePlacement']['refDirection']['directionRatios'][2], datatype=XSD.decimal)))
|
|
except Exception:
|
|
pass
|
|
try:
|
|
g.add((resource[wallID], ontology.hasPlacement, resource["plamenent_" + wallID + "_2"]))
|
|
g.add((resource["plamenent_" + wallID + "_2"], RDF.type, ontology.Placement))
|
|
g.add((resource["plamenent_" + wallID + "_2"], ontology.xlocation, Literal(wall['objectPlacement']['placementRelTo']['relativePlacement']['location']['coordinates'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + wallID + "_2"], ontology.ylocation, Literal(wall['objectPlacement']['placementRelTo']['relativePlacement']['location']['coordinates'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + wallID + "_2"], ontology.zlocation, Literal(wall['objectPlacement']['placementRelTo']['relativePlacement']['location']['coordinates'][2], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + wallID + "_2"], ontology.xaxis,
|
|
Literal(wall['objectPlacement']['placementRelTo']['relativePlacement']['axis']['directionRatios'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + wallID + "_2"], ontology.yaxis,
|
|
Literal(wall['objectPlacement']['placementRelTo']['relativePlacement']['axis']['directionRatios'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + wallID + "_2"], ontology.zaxis,
|
|
Literal(wall['objectPlacement']['placementRelTo']['relativePlacement']['axis']['directionRatios'][2], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + wallID + "_2"], ontology.xdirection,
|
|
Literal(wall['objectPlacement']['placementRelTo']['relativePlacement']['refDirection']['directionRatios'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + wallID + "_2"], ontology.ydirection,
|
|
Literal(wall['objectPlacement']['placementRelTo']['relativePlacement']['refDirection']['directionRatios'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + wallID + "_2"], ontology.zdirection,
|
|
Literal(wall['objectPlacement']['placementRelTo']['relativePlacement']['refDirection']['directionRatios'][2], datatype=XSD.decimal)))
|
|
except Exception:
|
|
pass
|
|
try:
|
|
g.add((resource[wallID], ontology.hasPlacement, resource["plamenent_" + wallID + "_3"]))
|
|
g.add((resource["plamenent_" + wallID + "_3"], RDF.type, ontology.Placement))
|
|
g.add((resource["plamenent_" + wallID + "_3"], ontology.xlocation, Literal(wall['objectPlacement']['placementRelTo']['placementRelTo']['relativePlacement']['location']['coordinates'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + wallID + "_3"], ontology.ylocation, Literal(wall['objectPlacement']['placementRelTo']['placementRelTo']['relativePlacement']['location']['coordinates'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + wallID + "_3"], ontology.zlocation, Literal(wall['objectPlacement']['placementRelTo']['placementRelTo']['relativePlacement']['location']['coordinates'][2], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + wallID + "_3"], ontology.xaxis,
|
|
Literal(wall['objectPlacement']['placementRelTo']['placementRelTo']['relativePlacement']['axis']['directionRatios'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + wallID + "_3"], ontology.yaxis,
|
|
Literal(wall['objectPlacement']['placementRelTo']['placementRelTo']['relativePlacement']['axis']['directionRatios'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + wallID + "_3"], ontology.zaxis,
|
|
Literal(wall['objectPlacement']['placementRelTo']['placementRelTo']['relativePlacement']['axis']['directionRatios'][2], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + wallID + "_3"], ontology.xdirection,
|
|
Literal(wall['objectPlacement']['placementRelTo']['placementRelTo']['relativePlacement']['refDirection']['directionRatios'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + wallID + "_3"], ontology.ydirection,
|
|
Literal(wall['objectPlacement']['placementRelTo']['placementRelTo']['relativePlacement']['refDirection']['directionRatios'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + wallID + "_3"], ontology.zdirection,
|
|
Literal(wall['objectPlacement']['placementRelTo']['placementRelTo']['relativePlacement']['refDirection']['directionRatios'][2], datatype=XSD.decimal)))
|
|
except Exception:
|
|
pass
|
|
try:
|
|
g.add((resource[wallID], ontology.hasPlacement, resource["plamenent_" + wallID + "_4"]))
|
|
g.add((resource["plamenent_" + wallID + "_4"], RDF.type, ontology.Placement))
|
|
g.add((resource["plamenent_" + wallID + "_4"], ontology.xlocation, Literal(wall['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['location']['coordinates'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + wallID + "_4"], ontology.ylocation, Literal(wall['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['location']['coordinates'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + wallID + "_4"], ontology.zlocation, Literal(wall['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['location']['coordinates'][2], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + wallID + "_4"], ontology.xaxis,
|
|
Literal(wall['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['axis']['directionRatios'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + wallID + "_4"], ontology.yaxis,
|
|
Literal(wall['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['axis']['directionRatios'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + wallID + "_4"], ontology.zaxis,
|
|
Literal(wall['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['axis']['directionRatios'][2], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + wallID + "_4"], ontology.xdirection,
|
|
Literal(wall['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['refDirection']['directionRatios'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + wallID + "_4"], ontology.ydirection,
|
|
Literal(wall['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['refDirection']['directionRatios'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + wallID + "_4"], ontology.zdirection,
|
|
Literal(wall['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['refDirection']['directionRatios'][2], datatype=XSD.decimal)))
|
|
except Exception:
|
|
pass
|
|
return 1
|
|
|
|
def ifcWindowFunction(IfcWindow):
|
|
for window in IfcWindow:
|
|
windowID = window['globalId']
|
|
#basic information
|
|
g.add((resource[windowID], RDF.type, ontology.Window))
|
|
try:#name is not always there
|
|
windowName = window['name']
|
|
g.add((resource[windowID], ontology.name, Literal(windowName)))
|
|
except Exception:
|
|
pass
|
|
try:#tag is not always there
|
|
windowTag = window['tag']
|
|
g.add((resource[windowID], ontology.tag, Literal(windowTag)))
|
|
except Exception:
|
|
pass
|
|
try:#type is not always there
|
|
windowType = window['objectType']
|
|
g.add((resource[windowID], ontology.type, Literal(windowType)))
|
|
except Exception:
|
|
pass
|
|
try:#predefinedType is not always there
|
|
windowPredefined = window['predefinedType']
|
|
g.add((resource[windowID], ontology.predefinedType, Literal(windowPredefined)))
|
|
except Exception:
|
|
pass
|
|
try:#partitioningType is not always there
|
|
windowPartitiong = window['partitioningType']
|
|
g.add((resource[windowID], ontology.partitioningType, Literal(windowPartitiong)))
|
|
except Exception:
|
|
pass
|
|
try:#add history
|
|
windowHistory = window['ownerHistory']['ref']
|
|
g.add((resource[windowHistory], RDF.type, ontology.History))
|
|
g.add((resource[windowID], ontology.hasHistory, resource[windowHistory]))
|
|
except Exception:
|
|
pass
|
|
try:#Height/Width is not always there
|
|
windowHeight, windowWidth = window['overallHeight'], window['overallWidth']
|
|
g.add((resource[windowID], ontology.height, Literal(windowHeight)))
|
|
g.add((resource[windowID], ontology.width, Literal(windowWidth)))
|
|
except Exception:
|
|
pass
|
|
try:#isTypedBy is not always there
|
|
for typed in window['isTypedBy']:
|
|
istyped = typed['ref']
|
|
g.add((resource[istyped], RDF.type, ontology.TypeCategory))
|
|
g.add((resource[windowID], ontology.hasType, resource[istyped]))
|
|
except Exception:
|
|
pass
|
|
try:#material is not always there
|
|
for material in window['hasAssociations']:
|
|
ismaterial = material['ref']
|
|
g.add((resource[ismaterial], RDF.type, ontology.Material))
|
|
g.add((resource[windowID], ontology.associatesMaterial, resource[ismaterial]))
|
|
except Exception:
|
|
pass
|
|
try:#fillsVoid is not always there
|
|
for void in window['fillsVoids']:
|
|
isvoid = void['ref']
|
|
g.add((resource[isvoid], RDF.type, ontology.Void))
|
|
g.add((resource[windowID], ontology.fillsVoid, resource[isvoid]))
|
|
except Exception:
|
|
pass
|
|
try:#structure is not always there
|
|
for structure in window['containedInStructure']:
|
|
isstructure= structure['ref']
|
|
g.add((resource[isstructure], RDF.type, ontology.Structure))
|
|
g.add((resource[windowID], ontology.inStructure, resource[isstructure]))
|
|
except Exception:
|
|
pass
|
|
try:#definedby is not always there
|
|
for defined in window['isDefinedBy']:
|
|
issdefined= defined['ref']
|
|
g.add((resource[issdefined], RDF.type, ontology.PropertySet))
|
|
g.add((resource[windowID], ontology.isDefinedBy, resource[issdefined]))
|
|
except Exception:
|
|
pass
|
|
try:#representation is not always there
|
|
for representation in window['representation']['representations']:
|
|
rep = representation['ref']
|
|
g.add((resource[rep], RDF.type, ontology.Representation))
|
|
g.add((resource[windowID], ontology.hasRepresentationType, resource[rep]))
|
|
except Exception:
|
|
pass
|
|
try:#hasAssociations is not always there
|
|
for typed in window['hasAssignments']:
|
|
iselement = typed['ref']
|
|
g.add((resource[iselement], RDF.type, ontology.Group))
|
|
g.add((resource[windowID], ontology.hasAssignments, resource[iselement]))
|
|
except Exception:
|
|
pass
|
|
try:#representationMaps data
|
|
g.add((resource[windowID], ontology.hasPlacement, resource["plamenent_" + windowID + "_1"]))
|
|
g.add((resource["plamenent_" + windowID + "_1"], RDF.type, ontology.Placement))
|
|
g.add((resource["plamenent_" + windowID + "_1"], ontology.xlocation, Literal(window['objectPlacement']['relativePlacement']['location']['coordinates'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + windowID + "_1"], ontology.ylocation, Literal(window['objectPlacement']['relativePlacement']['location']['coordinates'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + windowID + "_1"], ontology.zlocation, Literal(window['objectPlacement']['relativePlacement']['location']['coordinates'][2], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + windowID + "_1"], ontology.xaxis,
|
|
Literal(window['objectPlacement']['relativePlacement']['axis']['directionRatios'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + windowID + "_1"], ontology.yaxis,
|
|
Literal(window['objectPlacement']['relativePlacement']['axis']['directionRatios'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + windowID + "_1"], ontology.zaxis,
|
|
Literal(window['objectPlacement']['relativePlacement']['axis']['directionRatios'][2], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + windowID + "_1"], ontology.xdirection,
|
|
Literal(window['objectPlacement']['relativePlacement']['refDirection']['directionRatios'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + windowID + "_1"], ontology.ydirection,
|
|
Literal(window['objectPlacement']['relativePlacement']['refDirection']['directionRatios'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + windowID + "_1"], ontology.zdirection,
|
|
Literal(window['objectPlacement']['relativePlacement']['refDirection']['directionRatios'][2], datatype=XSD.decimal)))
|
|
except Exception:
|
|
pass
|
|
try:
|
|
g.add((resource[windowID], ontology.hasPlacement, resource["plamenent_" + windowID + "_2"]))
|
|
g.add((resource["plamenent_" + windowID + "_2"], RDF.type, ontology.Placement))
|
|
g.add((resource["plamenent_" + windowID + "_2"], ontology.xlocation, Literal(window['objectPlacement']['placementRelTo']['relativePlacement']['location']['coordinates'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + windowID + "_2"], ontology.ylocation, Literal(window['objectPlacement']['placementRelTo']['relativePlacement']['location']['coordinates'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + windowID + "_2"], ontology.zlocation, Literal(window['objectPlacement']['placementRelTo']['relativePlacement']['location']['coordinates'][2], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + windowID + "_2"], ontology.xaxis,
|
|
Literal(window['objectPlacement']['placementRelTo']['relativePlacement']['axis']['directionRatios'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + windowID + "_2"], ontology.yaxis,
|
|
Literal(window['objectPlacement']['placementRelTo']['relativePlacement']['axis']['directionRatios'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + windowID + "_2"], ontology.zaxis,
|
|
Literal(window['objectPlacement']['placementRelTo']['relativePlacement']['axis']['directionRatios'][2], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + windowID + "_2"], ontology.xdirection,
|
|
Literal(window['objectPlacement']['placementRelTo']['relativePlacement']['refDirection']['directionRatios'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + windowID + "_2"], ontology.ydirection,
|
|
Literal(window['objectPlacement']['placementRelTo']['relativePlacement']['refDirection']['directionRatios'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + windowID + "_2"], ontology.zdirection,
|
|
Literal(window['objectPlacement']['placementRelTo']['relativePlacement']['refDirection']['directionRatios'][2], datatype=XSD.decimal)))
|
|
except Exception:
|
|
pass
|
|
try:
|
|
g.add((resource[windowID], ontology.hasPlacement, resource["plamenent_" + windowID + "_3"]))
|
|
g.add((resource["plamenent_" + windowID + "_3"], RDF.type, ontology.Placement))
|
|
g.add((resource["plamenent_" + windowID + "_3"], ontology.xlocation, Literal(window['objectPlacement']['placementRelTo']['placementRelTo']['relativePlacement']['location']['coordinates'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + windowID + "_3"], ontology.ylocation, Literal(window['objectPlacement']['placementRelTo']['placementRelTo']['relativePlacement']['location']['coordinates'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + windowID + "_3"], ontology.zlocation, Literal(window['objectPlacement']['placementRelTo']['placementRelTo']['relativePlacement']['location']['coordinates'][2], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + windowID + "_3"], ontology.xaxis,
|
|
Literal(window['objectPlacement']['placementRelTo']['placementRelTo']['relativePlacement']['axis']['directionRatios'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + windowID + "_3"], ontology.yaxis,
|
|
Literal(window['objectPlacement']['placementRelTo']['placementRelTo']['relativePlacement']['axis']['directionRatios'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + windowID + "_3"], ontology.zaxis,
|
|
Literal(window['objectPlacement']['placementRelTo']['placementRelTo']['relativePlacement']['axis']['directionRatios'][2], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + windowID + "_3"], ontology.xdirection,
|
|
Literal(window['objectPlacement']['placementRelTo']['placementRelTo']['relativePlacement']['refDirection']['directionRatios'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + windowID + "_3"], ontology.ydirection,
|
|
Literal(window['objectPlacement']['placementRelTo']['placementRelTo']['relativePlacement']['refDirection']['directionRatios'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + windowID + "_3"], ontology.zdirection,
|
|
Literal(window['objectPlacement']['placementRelTo']['placementRelTo']['relativePlacement']['refDirection']['directionRatios'][2], datatype=XSD.decimal)))
|
|
except Exception:
|
|
pass
|
|
try:
|
|
g.add((resource[windowID], ontology.hasPlacement, resource["plamenent_" + windowID + "_4"]))
|
|
g.add((resource["plamenent_" + windowID + "_4"], RDF.type, ontology.Placement))
|
|
g.add((resource["plamenent_" + windowID + "_4"], ontology.xlocation, Literal(window['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['location']['coordinates'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + windowID + "_4"], ontology.ylocation, Literal(window['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['location']['coordinates'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + windowID + "_4"], ontology.zlocation, Literal(window['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['location']['coordinates'][2], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + windowID + "_4"], ontology.xaxis,
|
|
Literal(window['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['axis']['directionRatios'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + windowID + "_4"], ontology.yaxis,
|
|
Literal(window['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['axis']['directionRatios'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + windowID + "_4"], ontology.zaxis,
|
|
Literal(window['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['axis']['directionRatios'][2], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + windowID + "_4"], ontology.xdirection,
|
|
Literal(window['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['refDirection']['directionRatios'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + windowID + "_4"], ontology.ydirection,
|
|
Literal(window['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['refDirection']['directionRatios'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + windowID + "_4"], ontology.zdirection,
|
|
Literal(window['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['refDirection']['directionRatios'][2], datatype=XSD.decimal)))
|
|
except Exception:
|
|
pass
|
|
try:#representationMaps data
|
|
g.add((resource[windowID], ontology.hasPlacement, resource["plamenent_" + windowID + "_5"]))
|
|
g.add((resource["plamenent_" + windowID + "_5"], RDF.type, ontology.Placement))
|
|
g.add((resource["plamenent_" + windowID + "_5"], ontology.xlocation, Literal(window['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['location']['coordinates'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + windowID + "_5"], ontology.ylocation, Literal(window['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['location']['coordinates'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + windowID + "_5"], ontology.zlocation, Literal(window['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['location']['coordinates'][2], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + windowID + "_5"], ontology.xaxis,
|
|
Literal(window['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['axis']['directionRatios'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + windowID + "_5"], ontology.yaxis,
|
|
Literal(window['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['axis']['directionRatios'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + windowID + "_5"], ontology.zaxis,
|
|
Literal(window['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['axis']['directionRatios'][2], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + windowID + "_5"], ontology.xdirection,
|
|
Literal(window['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['refDirection']['directionRatios'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + windowID + "_5"], ontology.ydirection,
|
|
Literal(window['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['refDirection']['directionRatios'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + windowID + "_5"], ontology.zdirection,
|
|
Literal(window['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['refDirection']['directionRatios'][2], datatype=XSD.decimal)))
|
|
except Exception:
|
|
pass
|
|
try:#representationMaps data
|
|
g.add((resource[windowID], ontology.hasPlacement, resource["plamenent_" + windowID + "_6"]))
|
|
g.add((resource["plamenent_" + windowID + "_6"], RDF.type, ontology.Placement))
|
|
g.add((resource["plamenent_" + windowID + "_6"], ontology.xlocation, Literal(window['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['location']['coordinates'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + windowID + "_6"], ontology.ylocation, Literal(window['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['location']['coordinates'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + windowID + "_6"], ontology.zlocation, Literal(window['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['location']['coordinates'][2], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + windowID + "_6"], ontology.xaxis,
|
|
Literal(window['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['axis']['directionRatios'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + windowID + "_6"], ontology.yaxis,
|
|
Literal(window['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['axis']['directionRatios'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + windowID + "_6"], ontology.zaxis,
|
|
Literal(window['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['axis']['directionRatios'][2], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + windowID + "_6"], ontology.xdirection,
|
|
Literal(window['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['refDirection']['directionRatios'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + windowID + "_6"], ontology.ydirection,
|
|
Literal(window['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['refDirection']['directionRatios'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + windowID + "_6"], ontology.zdirection,
|
|
Literal(window['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['refDirection']['directionRatios'][2], datatype=XSD.decimal)))
|
|
except Exception:
|
|
pass
|
|
return 1
|
|
|
|
def ifcGroupFunction(IfcGroup):
|
|
for group in IfcGroup:
|
|
groupID = group['globalId']
|
|
# basic information
|
|
g.add((resource[groupID], RDF.type, ontology.Group))
|
|
try: # predefinedType is not always there
|
|
groupPredefinedType = group['predefinedType']
|
|
g.add((resource[groupID], ontology.predefinedType, Literal(groupPredefinedType)))
|
|
except Exception:
|
|
pass
|
|
try: # predefinedType is not always there
|
|
groupObjectType = group['objectType']
|
|
g.add((resource[groupID], ontology.type, Literal(groupObjectType)))
|
|
except Exception:
|
|
pass
|
|
try: # name is not always there
|
|
groupName = group['name']
|
|
g.add((resource[groupID], ontology.name, Literal(groupName)))
|
|
except Exception:
|
|
pass
|
|
try: # add history
|
|
groupHistory = group['ownerHistory']['ref']
|
|
g.add((resource[groupHistory], RDF.type, ontology.History))
|
|
g.add((resource[groupID], ontology.hasHistory, resource[groupHistory]))
|
|
except Exception:
|
|
pass
|
|
try: # structure is not always there
|
|
for grouped in group['isGroupedBy']:
|
|
isgrouped = grouped['ref']
|
|
g.add((resource[isgrouped], RDF.type, ontology.Group))
|
|
g.add((resource[groupID], ontology.isGroupedBy, resource[isgrouped]))
|
|
except Exception:
|
|
pass
|
|
return 1
|
|
|
|
def ifcRelAssignsToGroupFunction(IfcRelAssignsToGroup):
|
|
for propertySet in IfcRelAssignsToGroup:
|
|
propertySetID = propertySet['globalId']
|
|
#basic information
|
|
g.add((resource[propertySetID], RDF.type, ontology.PropertySet))
|
|
try:#add history
|
|
propertySetHistory = propertySet['ownerHistory']['ref']
|
|
g.add((resource[propertySetHistory], RDF.type, ontology.History))
|
|
g.add((resource[propertySetID], ontology.hasHistory, resource[propertySetHistory]))
|
|
except Exception:
|
|
pass
|
|
try:
|
|
for obj in propertySet['relatedObjects']:
|
|
propertyObject = obj['ref']
|
|
g.add((resource[propertyObject], RDF.type, ontology.Object))
|
|
g.add((resource[propertySetID], ontology.relatedObject, resource[propertyObject]))
|
|
except Exception:
|
|
pass
|
|
try:
|
|
propertyGroup = propertySet['relatingGroup']['ref']
|
|
g.add((resource[propertyGroup], RDF.type, ontology.Group))
|
|
g.add((resource[propertySetID], ontology.relatedGroup, resource[propertyGroup]))
|
|
except Exception:
|
|
pass
|
|
return 1
|
|
|
|
def ifcPropertySetFunction(IfcPropertySet):
|
|
for propertySet in IfcPropertySet:
|
|
propertySetID = propertySet['globalId']
|
|
#basic information
|
|
g.add((resource[propertySetID], RDF.type, ontology.PropertySet))
|
|
try:#add history
|
|
propertySetHistory = propertySet['ownerHistory']['ref']
|
|
g.add((resource[propertySetHistory], RDF.type, ontology.History))
|
|
g.add((resource[propertySetID], ontology.hasHistory, resource[propertySetHistory]))
|
|
except Exception:
|
|
pass
|
|
try:#name is not always there
|
|
propertySetIDName = propertySet['name']
|
|
g.add((resource[propertySetID], ontology.name, Literal(propertySetIDName)))
|
|
except Exception:
|
|
pass
|
|
try:#name is not always there
|
|
propertySetIDDescription = propertySet['description']
|
|
g.add((resource[propertySetID], ontology.description, Literal(propertySetIDDescription)))
|
|
except Exception:
|
|
pass
|
|
count = 1
|
|
try:
|
|
for prp in propertySet['hasProperties']:
|
|
type, name, nominalType, nominalValue = prp['type'], prp['name'], prp['nominalValue']['type'], prp['nominalValue']['value']
|
|
g.add((resource["propertysetNominal_" + propertySetID + "_" + str(count)], RDF.type, ontology.PropertyDetail))
|
|
g.add((resource[propertySetID], ontology.hasProperty, resource["propertysetNominal_" + propertySetID + "_" + str(count)]))
|
|
g.add((resource["propertysetNominal_" + propertySetID + "_" + str(count)], ontology.type, Literal(type)))
|
|
g.add((resource["propertysetNominal_" + propertySetID + "_" + str(count)], ontology.name, Literal(name)))
|
|
g.add((resource["propertysetNominal_" + propertySetID + "_" + str(count)], ontology.nominalType, Literal(nominalType)))
|
|
g.add((resource["propertysetNominal_" + propertySetID + "_" + str(count)], ontology.nominalValue, Literal(nominalValue)))
|
|
count += 1
|
|
except Exception:
|
|
pass
|
|
try:
|
|
count = 1
|
|
for prp in propertySet['definesOccurrence']:
|
|
occurence = prp['ref']
|
|
g.add((resource["occurence_" + propertySetID + "_" + str(count)], RDF.type, ontology.Occurence))
|
|
g.add((resource[propertySetID], ontology.definesOccurence, resource["occurence_" + occurence + "_" + str(count)]))
|
|
count += 1
|
|
except Exception:
|
|
pass
|
|
|
|
return 1
|
|
|
|
def ifcDoorPanelPropertiesFunction(IfcDoorPanelProperties):
|
|
for door in IfcDoorPanelProperties:
|
|
doorID = door['globalId']
|
|
#basic information
|
|
g.add((resource[doorID], RDF.type, ontology.DoorPanel))
|
|
try:#add history
|
|
doorHistory = door['ownerHistory']['ref']
|
|
g.add((resource[doorHistory], RDF.type, ontology.History))
|
|
g.add((resource[doorID], ontology.hasHistory, resource[doorHistory]))
|
|
except Exception:
|
|
pass
|
|
try:#name is not always there
|
|
doorName = door['name']
|
|
g.add((resource[doorID], ontology.name, Literal(doorName)))
|
|
except Exception:
|
|
pass
|
|
try:#definedby is not always there
|
|
for defined in door['definesType']:
|
|
issdefined = defined['ref']
|
|
g.add((resource[issdefined], RDF.type, ontology.Representation))
|
|
g.add((resource[doorID], ontology.hasRepresentationType, resource[issdefined]))
|
|
except Exception:
|
|
pass
|
|
try:#panelDepth is not always there
|
|
depth = door['panelDepth']
|
|
g.add((resource[doorID], ontology.panelDepth, Literal(depth)))
|
|
except Exception:
|
|
pass
|
|
try:#liningThickness is not always there
|
|
operation = door['panelOperation']
|
|
g.add((resource[doorID], ontology.panelOperation, Literal(operation)))
|
|
except Exception:
|
|
pass
|
|
try:#panelWidth is not always there
|
|
width = door['panelWidth']
|
|
g.add((resource[doorID], ontology.panelWidth, Literal(width)))
|
|
except Exception:
|
|
pass
|
|
try:#panelPosition is not always there
|
|
position = door['panelPosition']
|
|
g.add((resource[doorID], ontology.panelPosition, Literal(position)))
|
|
except Exception:
|
|
pass
|
|
return 1
|
|
|
|
def ifcSlabFunction(IfcSlab):
|
|
for slab in IfcSlab:
|
|
slabID = slab['globalId']
|
|
#basic information
|
|
g.add((resource[slabID], RDF.type, ontology.Slab))
|
|
try:#add history
|
|
slabHistory = slab['ownerHistory']['ref']
|
|
g.add((resource[slabHistory], RDF.type, ontology.History))
|
|
g.add((resource[slabID], ontology.hasHistory, resource[slabHistory]))
|
|
except Exception:
|
|
pass
|
|
try:#tag is not always there
|
|
slabTag = slab['tag']
|
|
g.add((resource[slabID], ontology.tag, Literal(slabTag)))
|
|
except Exception:
|
|
pass
|
|
try:#add history
|
|
slabPredefinedType = slab['predefinedType']
|
|
g.add((resource[slabID], ontology.predefinedType, Literal(slabPredefinedType)))
|
|
except Exception:
|
|
pass
|
|
try:#add history
|
|
slabObjectType = slab['objectType']
|
|
g.add((resource[slabID], ontology.type, Literal(slabObjectType)))
|
|
except Exception:
|
|
pass
|
|
try:#name is not always there
|
|
slabName = slab['name']
|
|
g.add((resource[slabID], ontology.name, Literal(slabName)))
|
|
except Exception:
|
|
pass
|
|
|
|
try:#representation is not always there
|
|
for representation in slab['representation']['representations']:
|
|
rep = representation['ref']
|
|
g.add((resource[rep], RDF.type, ontology.Representation))
|
|
g.add((resource[slabID], ontology.hasRepresentationType, resource[rep]))
|
|
except Exception:
|
|
pass
|
|
try:#definedby is not always there
|
|
for defined in slab['isDefinedBy']:
|
|
issdefined= defined['ref']
|
|
g.add((resource[issdefined], RDF.type, ontology.PropertySet))
|
|
g.add((resource[slabID], ontology.isDefinedBy, resource[issdefined]))
|
|
except Exception:
|
|
pass
|
|
try:#material is not always there
|
|
for material in slab['hasAssociations']:
|
|
ismaterial = material['ref']
|
|
g.add((resource[ismaterial], RDF.type, ontology.Material))
|
|
g.add((resource[slabID], ontology.associatesMaterial, resource[ismaterial]))
|
|
except Exception:
|
|
pass
|
|
try:#hasAssociations is not always there
|
|
for typed in slab['hasAssignments']:
|
|
iselement = typed['ref']
|
|
g.add((resource[iselement], RDF.type, ontology.Group))
|
|
g.add((resource[slabID], ontology.hasAssignments, resource[iselement]))
|
|
except Exception:
|
|
pass
|
|
try:#structure is not always there
|
|
for structure in slab['containedInStructure']:
|
|
isstructure= structure['ref']
|
|
g.add((resource[isstructure], RDF.type, ontology.Structure))
|
|
g.add((resource[slabID], ontology.inStructure, resource[isstructure]))
|
|
except Exception:
|
|
pass
|
|
try:#isTypedBy is not always there
|
|
for typed in slab['isTypedBy']:
|
|
istyped = typed['ref']
|
|
g.add((resource[istyped], RDF.type, ontology.TypeCategory))
|
|
g.add((resource[slabID], ontology.hasType, resource[istyped]))
|
|
except Exception:
|
|
pass
|
|
try: # representationMaps data
|
|
g.add((resource[slabID], ontology.hasPlacement, resource["plamenent_" + slabID + "_1"]))
|
|
g.add((resource["plamenent_" + slabID + "_1"], RDF.type, ontology.Placement))
|
|
g.add((resource["plamenent_" + slabID + "_1"], ontology.xlocation,
|
|
Literal(slab['objectPlacement']['relativePlacement']['location']['coordinates'][0],
|
|
datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + slabID + "_1"], ontology.ylocation,
|
|
Literal(slab['objectPlacement']['relativePlacement']['location']['coordinates'][1],
|
|
datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + slabID + "_1"], ontology.zlocation,
|
|
Literal(slab['objectPlacement']['relativePlacement']['location']['coordinates'][2],
|
|
datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + slabID + "_1"], ontology.xaxis,
|
|
Literal(slab['objectPlacement']['relativePlacement']['axis']['directionRatios'][0],
|
|
datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + slabID + "_1"], ontology.yaxis,
|
|
Literal(slab['objectPlacement']['relativePlacement']['axis']['directionRatios'][1],
|
|
datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + slabID + "_1"], ontology.zaxis,
|
|
Literal(slab['objectPlacement']['relativePlacement']['axis']['directionRatios'][2],
|
|
datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + slabID + "_1"], ontology.xdirection,
|
|
Literal(slab['objectPlacement']['relativePlacement']['refDirection']['directionRatios'][0],
|
|
datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + slabID + "_1"], ontology.ydirection,
|
|
Literal(slab['objectPlacement']['relativePlacement']['refDirection']['directionRatios'][1],
|
|
datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + slabID + "_1"], ontology.zdirection,
|
|
Literal(slab['objectPlacement']['relativePlacement']['refDirection']['directionRatios'][2],
|
|
datatype=XSD.decimal)))
|
|
except Exception:
|
|
pass
|
|
try:
|
|
g.add((resource[slabID], ontology.hasPlacement, resource["plamenent_" + slabID + "_2"]))
|
|
g.add((resource["plamenent_" + slabID + "_2"], RDF.type, ontology.Placement))
|
|
g.add((resource["plamenent_" + slabID + "_2"], ontology.xlocation, Literal(
|
|
slab['objectPlacement']['placementRelTo']['relativePlacement']['location']['coordinates'][0],
|
|
datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + slabID + "_2"], ontology.ylocation, Literal(
|
|
slab['objectPlacement']['placementRelTo']['relativePlacement']['location']['coordinates'][1],
|
|
datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + slabID + "_2"], ontology.zlocation, Literal(
|
|
slab['objectPlacement']['placementRelTo']['relativePlacement']['location']['coordinates'][2],
|
|
datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + slabID + "_2"], ontology.xaxis,
|
|
Literal(
|
|
slab['objectPlacement']['placementRelTo']['relativePlacement']['axis']['directionRatios'][0],
|
|
datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + slabID + "_2"], ontology.yaxis,
|
|
Literal(
|
|
slab['objectPlacement']['placementRelTo']['relativePlacement']['axis']['directionRatios'][1],
|
|
datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + slabID + "_2"], ontology.zaxis,
|
|
Literal(
|
|
slab['objectPlacement']['placementRelTo']['relativePlacement']['axis']['directionRatios'][2],
|
|
datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + slabID + "_2"], ontology.xdirection,
|
|
Literal(slab['objectPlacement']['placementRelTo']['relativePlacement']['refDirection'][
|
|
'directionRatios'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + slabID + "_2"], ontology.ydirection,
|
|
Literal(slab['objectPlacement']['placementRelTo']['relativePlacement']['refDirection'][
|
|
'directionRatios'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + slabID + "_2"], ontology.zdirection,
|
|
Literal(slab['objectPlacement']['placementRelTo']['relativePlacement']['refDirection'][
|
|
'directionRatios'][2], datatype=XSD.decimal)))
|
|
except Exception:
|
|
pass
|
|
try:
|
|
g.add((resource[slabID], ontology.hasPlacement, resource["plamenent_" + slabID + "_3"]))
|
|
g.add((resource["plamenent_" + slabID + "_3"], RDF.type, ontology.Placement))
|
|
g.add((resource["plamenent_" + slabID + "_3"], ontology.xlocation, Literal(
|
|
slab['objectPlacement']['placementRelTo']['placementRelTo']['relativePlacement']['location'][
|
|
'coordinates'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + slabID + "_3"], ontology.ylocation, Literal(
|
|
slab['objectPlacement']['placementRelTo']['placementRelTo']['relativePlacement']['location'][
|
|
'coordinates'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + slabID + "_3"], ontology.zlocation, Literal(
|
|
slab['objectPlacement']['placementRelTo']['placementRelTo']['relativePlacement']['location'][
|
|
'coordinates'][2], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + slabID + "_3"], ontology.xaxis,
|
|
Literal(slab['objectPlacement']['placementRelTo']['placementRelTo']['relativePlacement']['axis'][
|
|
'directionRatios'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + slabID + "_3"], ontology.yaxis,
|
|
Literal(slab['objectPlacement']['placementRelTo']['placementRelTo']['relativePlacement']['axis'][
|
|
'directionRatios'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + slabID + "_3"], ontology.zaxis,
|
|
Literal(slab['objectPlacement']['placementRelTo']['placementRelTo']['relativePlacement']['axis'][
|
|
'directionRatios'][2], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + slabID + "_3"], ontology.xdirection,
|
|
Literal(slab['objectPlacement']['placementRelTo']['placementRelTo']['relativePlacement'][
|
|
'refDirection']['directionRatios'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + slabID + "_3"], ontology.ydirection,
|
|
Literal(slab['objectPlacement']['placementRelTo']['placementRelTo']['relativePlacement'][
|
|
'refDirection']['directionRatios'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + slabID + "_3"], ontology.zdirection,
|
|
Literal(slab['objectPlacement']['placementRelTo']['placementRelTo']['relativePlacement'][
|
|
'refDirection']['directionRatios'][2], datatype=XSD.decimal)))
|
|
except Exception:
|
|
pass
|
|
try:
|
|
g.add((resource[slabID], ontology.hasPlacement, resource["plamenent_" + slabID + "_4"]))
|
|
g.add((resource["plamenent_" + slabID + "_4"], RDF.type, ontology.Placement))
|
|
g.add((resource["plamenent_" + slabID + "_4"], ontology.xlocation, Literal(slab['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['location']['coordinates'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + slabID + "_4"], ontology.ylocation, Literal(slab['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['location']['coordinates'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + slabID + "_4"], ontology.zlocation, Literal(slab['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['location']['coordinates'][2], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + slabID + "_4"], ontology.xaxis,
|
|
Literal(slab['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['axis']['directionRatios'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + slabID + "_4"], ontology.yaxis,
|
|
Literal(slab['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['axis']['directionRatios'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + slabID + "_4"], ontology.zaxis,
|
|
Literal(slab['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['axis']['directionRatios'][2], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + slabID + "_4"], ontology.xdirection,
|
|
Literal(slab['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['refDirection']['directionRatios'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + slabID + "_4"], ontology.ydirection,
|
|
Literal(slab['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['refDirection']['directionRatios'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + slabID + "_4"], ontology.zdirection,
|
|
Literal(slab['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['refDirection']['directionRatios'][2], datatype=XSD.decimal)))
|
|
except Exception:
|
|
pass
|
|
return 1
|
|
|
|
def ifcMemberFunction(IfcMember):
|
|
|
|
for member in IfcMember:
|
|
memberID = member['globalId']
|
|
#basic information
|
|
g.add((resource[memberID], RDF.type, ontology.Member))
|
|
try:#add history
|
|
memberHistory = member['ownerHistory']['ref']
|
|
g.add((resource[memberHistory], RDF.type, ontology.History))
|
|
g.add((resource[memberID], ontology.hasHistory, resource[memberHistory]))
|
|
except Exception:
|
|
pass
|
|
try:#name is not always there
|
|
memberName = member['name']
|
|
g.add((resource[memberID], ontology.name, Literal(memberName)))
|
|
except Exception:
|
|
pass
|
|
try:#objectType is not always there
|
|
memberObjectType = member['objectType']
|
|
g.add((resource[memberID], ontology.Type, Literal(memberObjectType)))
|
|
except Exception:
|
|
pass
|
|
try:#description is not always there
|
|
memberDescription = member['description']
|
|
g.add((resource[memberID], ontology.description, Literal(memberDescription)))
|
|
except Exception:
|
|
pass
|
|
try:#name is not always there
|
|
memberTag = member['tag']
|
|
g.add((resource[memberID], ontology.tag, Literal(memberTag)))
|
|
except Exception:
|
|
pass
|
|
try:#isTypedBy is not always there
|
|
for typed in member['isTypedBy']:
|
|
istyped = typed['ref']
|
|
g.add((resource[istyped], RDF.type, ontology.TypeCategory))
|
|
g.add((resource[memberID], ontology.hasType, resource[istyped]))
|
|
except Exception:
|
|
pass
|
|
try:#representation is not always there
|
|
for representation in member['representation']['representations']:
|
|
rep = representation['ref']
|
|
g.add((resource[rep], RDF.type, ontology.Representation))
|
|
g.add((resource[memberID], ontology.hasRepresentationType, resource[rep]))
|
|
except Exception:
|
|
pass
|
|
try:#structure is not always there
|
|
for structure in member['containedInStructure']:
|
|
isstructure= structure['ref']
|
|
g.add((resource[isstructure], RDF.type, ontology.Structure))
|
|
g.add((resource[memberID], ontology.inStructure, resource[isstructure]))
|
|
except Exception:
|
|
pass
|
|
try:#definedby is not always there
|
|
for defined in member['isDefinedBy']:
|
|
issdefined= defined['ref']
|
|
g.add((resource[issdefined], RDF.type, ontology.PropertySet))
|
|
g.add((resource[memberID], ontology.isDefinedBy, resource[issdefined]))
|
|
except Exception:
|
|
pass
|
|
try:#material is not always there
|
|
for material in member['hasAssociations']:
|
|
ismaterial = material['ref']
|
|
g.add((resource[ismaterial], RDF.type, ontology.Material))
|
|
g.add((resource[memberID], ontology.associatesMaterial, resource[ismaterial]))
|
|
except Exception:
|
|
pass
|
|
|
|
try: # representationMaps data
|
|
g.add((resource[memberID], ontology.hasPlacement, resource["plamenent_" + memberID + "_1"]))
|
|
g.add((resource["plamenent_" + memberID + "_1"], RDF.type, ontology.Placement))
|
|
g.add((resource["plamenent_" + memberID + "_1"], ontology.xlocation,
|
|
Literal(member['objectPlacement']['relativePlacement']['location']['coordinates'][0],
|
|
datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + memberID + "_1"], ontology.ylocation,
|
|
Literal(member['objectPlacement']['relativePlacement']['location']['coordinates'][1],
|
|
datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + memberID + "_1"], ontology.zlocation,
|
|
Literal(member['objectPlacement']['relativePlacement']['location']['coordinates'][2],
|
|
datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + memberID + "_1"], ontology.xaxis,
|
|
Literal(member['objectPlacement']['relativePlacement']['axis']['directionRatios'][0],
|
|
datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + memberID + "_1"], ontology.yaxis,
|
|
Literal(member['objectPlacement']['relativePlacement']['axis']['directionRatios'][1],
|
|
datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + memberID + "_1"], ontology.zaxis,
|
|
Literal(member['objectPlacement']['relativePlacement']['axis']['directionRatios'][2],
|
|
datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + memberID + "_1"], ontology.xdirection,
|
|
Literal(member['objectPlacement']['relativePlacement']['refDirection']['directionRatios'][0],
|
|
datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + memberID + "_1"], ontology.ydirection,
|
|
Literal(member['objectPlacement']['relativePlacement']['refDirection']['directionRatios'][1],
|
|
datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + memberID + "_1"], ontology.zdirection,
|
|
Literal(member['objectPlacement']['relativePlacement']['refDirection']['directionRatios'][2],
|
|
datatype=XSD.decimal)))
|
|
except Exception:
|
|
pass
|
|
try:
|
|
g.add((resource[memberID], ontology.hasPlacement, resource["plamenent_" + memberID + "_2"]))
|
|
g.add((resource["plamenent_" + memberID + "_2"], RDF.type, ontology.Placement))
|
|
g.add((resource["plamenent_" + memberID + "_2"], ontology.xlocation, Literal(
|
|
member['objectPlacement']['placementRelTo']['relativePlacement']['location']['coordinates'][0],
|
|
datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + memberID + "_2"], ontology.ylocation, Literal(
|
|
member['objectPlacement']['placementRelTo']['relativePlacement']['location']['coordinates'][1],
|
|
datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + memberID + "_2"], ontology.zlocation, Literal(
|
|
member['objectPlacement']['placementRelTo']['relativePlacement']['location']['coordinates'][2],
|
|
datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + memberID + "_2"], ontology.xaxis,
|
|
Literal(
|
|
member['objectPlacement']['placementRelTo']['relativePlacement']['axis']['directionRatios'][0],
|
|
datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + memberID + "_2"], ontology.yaxis,
|
|
Literal(
|
|
member['objectPlacement']['placementRelTo']['relativePlacement']['axis']['directionRatios'][1],
|
|
datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + memberID + "_2"], ontology.zaxis,
|
|
Literal(
|
|
member['objectPlacement']['placementRelTo']['relativePlacement']['axis']['directionRatios'][2],
|
|
datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + memberID + "_2"], ontology.xdirection,
|
|
Literal(member['objectPlacement']['placementRelTo']['relativePlacement']['refDirection'][
|
|
'directionRatios'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + memberID + "_2"], ontology.ydirection,
|
|
Literal(member['objectPlacement']['placementRelTo']['relativePlacement']['refDirection'][
|
|
'directionRatios'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + memberID + "_2"], ontology.zdirection,
|
|
Literal(member['objectPlacement']['placementRelTo']['relativePlacement']['refDirection'][
|
|
'directionRatios'][2], datatype=XSD.decimal)))
|
|
except Exception:
|
|
pass
|
|
try:
|
|
g.add((resource[memberID], ontology.hasPlacement, resource["plamenent_" + memberID + "_3"]))
|
|
g.add((resource["plamenent_" + memberID + "_3"], RDF.type, ontology.Placement))
|
|
g.add((resource["plamenent_" + memberID + "_3"], ontology.xlocation, Literal(
|
|
member['objectPlacement']['placementRelTo']['placementRelTo']['relativePlacement']['location'][
|
|
'coordinates'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + memberID + "_3"], ontology.ylocation, Literal(
|
|
member['objectPlacement']['placementRelTo']['placementRelTo']['relativePlacement']['location'][
|
|
'coordinates'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + memberID + "_3"], ontology.zlocation, Literal(
|
|
member['objectPlacement']['placementRelTo']['placementRelTo']['relativePlacement']['location'][
|
|
'coordinates'][2], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + memberID + "_3"], ontology.xaxis,
|
|
Literal(member['objectPlacement']['placementRelTo']['placementRelTo']['relativePlacement']['axis'][
|
|
'directionRatios'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + memberID + "_3"], ontology.yaxis,
|
|
Literal(member['objectPlacement']['placementRelTo']['placementRelTo']['relativePlacement']['axis'][
|
|
'directionRatios'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + memberID + "_3"], ontology.zaxis,
|
|
Literal(member['objectPlacement']['placementRelTo']['placementRelTo']['relativePlacement']['axis'][
|
|
'directionRatios'][2], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + memberID + "_3"], ontology.xdirection,
|
|
Literal(member['objectPlacement']['placementRelTo']['placementRelTo']['relativePlacement'][
|
|
'refDirection']['directionRatios'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + memberID + "_3"], ontology.ydirection,
|
|
Literal(member['objectPlacement']['placementRelTo']['placementRelTo']['relativePlacement'][
|
|
'refDirection']['directionRatios'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + memberID + "_3"], ontology.zdirection,
|
|
Literal(member['objectPlacement']['placementRelTo']['placementRelTo']['relativePlacement'][
|
|
'refDirection']['directionRatios'][2], datatype=XSD.decimal)))
|
|
except Exception:
|
|
pass
|
|
try:
|
|
g.add((resource[memberID], ontology.hasPlacement, resource["plamenent_" + memberID + "_4"]))
|
|
g.add((resource["plamenent_" + memberID + "_4"], RDF.type, ontology.Placement))
|
|
g.add((resource["plamenent_" + memberID + "_4"], ontology.xlocation, Literal(member['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['location']['coordinates'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + memberID + "_4"], ontology.ylocation, Literal(member['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['location']['coordinates'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + memberID + "_4"], ontology.zlocation, Literal(member['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['location']['coordinates'][2], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + memberID + "_4"], ontology.xaxis,
|
|
Literal(member['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['axis']['directionRatios'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + memberID + "_4"], ontology.yaxis,
|
|
Literal(member['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['axis']['directionRatios'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + memberID + "_4"], ontology.zaxis,
|
|
Literal(member['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['axis']['directionRatios'][2], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + memberID + "_4"], ontology.xdirection,
|
|
Literal(member['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['refDirection']['directionRatios'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + memberID + "_4"], ontology.ydirection,
|
|
Literal(member['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['refDirection']['directionRatios'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + memberID + "_4"], ontology.zdirection,
|
|
Literal(member['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['refDirection']['directionRatios'][2], datatype=XSD.decimal)))
|
|
except Exception:
|
|
pass
|
|
return 1
|
|
|
|
def ifcElementQuantityFunction(IfcElementQuantity):
|
|
for quantity in IfcElementQuantity:
|
|
quantityID = quantity['globalId']
|
|
#basic information
|
|
g.add((resource[quantityID], RDF.type, ontology.Object))
|
|
try:#add history
|
|
quantityHistory = quantity['ownerHistory']['ref']
|
|
g.add((resource[quantityHistory], RDF.type, ontology.History))
|
|
g.add((resource[quantityID], ontology.hasHistory, resource[quantityHistory]))
|
|
except Exception:
|
|
pass
|
|
try:#name is not always there
|
|
quantityName = quantity['name']
|
|
g.add((resource[quantityID], ontology.name, Literal(quantityName)))
|
|
except Exception:
|
|
pass
|
|
try:#methodOfMeasurement is not always there
|
|
quantitymethodOfMeasurement = quantity['methodOfMeasurement']
|
|
g.add((resource[quantityID], ontology.methodMeasurement, Literal(quantitymethodOfMeasurement)))
|
|
except Exception:
|
|
pass
|
|
try:
|
|
count = 1
|
|
for prp in quantity['definesOccurrence']:
|
|
occurence = prp['ref']
|
|
g.add((resource["occurence_" + quantityID + "_" + str(count)], RDF.type, ontology.Occurence))
|
|
g.add((resource[quantityID], ontology.definesOccurence, resource["occurence_" + occurence + "_" + str(count)]))
|
|
count += 1
|
|
except Exception:
|
|
pass
|
|
try:
|
|
count = 1
|
|
for prp in quantity['quantities']:
|
|
g.add((resource["quantity_" + quantityID + "_" + str(count)], RDF.type, ontology.Quantity))
|
|
g.add((resource[quantityID], ontology.hasQuantity, resource["quantity_" + quantityID + "_" + str(count)]))
|
|
|
|
for k in list(prp.keys()):
|
|
if k == "hasQuantities":
|
|
for l in prp[k]:
|
|
for second in list(l.keys()):
|
|
second_key = "secondQuantity_" + second
|
|
g.add((resource["quantity_" + quantityID + "_" + str(count)], ontology[second_key], Literal(l[second])))
|
|
else:
|
|
g.add((resource["quantity_" + quantityID + "_" + str(count)], ontology[k], Literal(prp[k])))
|
|
|
|
count += 1
|
|
except Exception:
|
|
pass
|
|
return 1
|
|
|
|
def ifcBeamFunction(IfcBeam):
|
|
for beam in IfcBeam:
|
|
beamID = beam['globalId']
|
|
#basic information
|
|
g.add((resource[beamID], RDF.type, ontology.Beam))
|
|
try:#add history
|
|
beamHistory = beam['ownerHistory']['ref']
|
|
g.add((resource[beamHistory], RDF.type, ontology.History))
|
|
g.add((resource[beamID], ontology.hasHistory, resource[beamHistory]))
|
|
except Exception:
|
|
pass
|
|
try:#add history
|
|
beamTag = beam['tag']
|
|
g.add((resource[beamID], ontology.tag, Literal(beamTag)))
|
|
except Exception:
|
|
pass
|
|
try:#add history
|
|
beamObjectType = beam['objectType']
|
|
g.add((resource[beamID], ontology.type, Literal(beamObjectType)))
|
|
except Exception:
|
|
pass
|
|
try:#add history
|
|
beamPredefinedType = beam['predefinedType']
|
|
g.add((resource[beamID], ontology.predefinedType, Literal(beamPredefinedType)))
|
|
except Exception:
|
|
pass
|
|
try:#name is not always there
|
|
beamName = beam['name']
|
|
g.add((resource[beamID], ontology.name, Literal(beamName)))
|
|
except Exception:
|
|
pass
|
|
try:#name is not always there
|
|
beamDescription = beam['description']
|
|
g.add((resource[beamID], ontology.description, Literal(beamDescription)))
|
|
except Exception:
|
|
pass
|
|
try:#representation is not always there
|
|
for representation in beam['representation']['representations']:
|
|
rep = representation['ref']
|
|
g.add((resource[rep], RDF.type, ontology.Representation))
|
|
g.add((resource[beamID], ontology.hasRepresentationType, resource[rep]))
|
|
except Exception:
|
|
pass
|
|
try:#definedby is not always there
|
|
for defined in beam['isDefinedBy']:
|
|
issdefined= defined['ref']
|
|
g.add((resource[issdefined], RDF.type, ontology.PropertySet))
|
|
g.add((resource[beamID], ontology.isDefinedBy, resource[issdefined]))
|
|
except Exception:
|
|
pass
|
|
try:#material is not always there
|
|
for material in beam['hasAssociations']:
|
|
ismaterial = material['ref']
|
|
g.add((resource[ismaterial], RDF.type, ontology.Material))
|
|
g.add((resource[beamID], ontology.associatesMaterial, resource[ismaterial]))
|
|
except Exception:
|
|
pass
|
|
try:#structure is not always there
|
|
for structure in beam['containedInStructure']:
|
|
isstructure= structure['ref']
|
|
g.add((resource[isstructure], RDF.type, ontology.Structure))
|
|
g.add((resource[beamID], ontology.inStructure, resource[isstructure]))
|
|
except Exception:
|
|
pass
|
|
try:#isTypedBy is not always there
|
|
for typed in beam['isTypedBy']:
|
|
istyped = typed['ref']
|
|
g.add((resource[istyped], RDF.type, ontology.TypeCategory))
|
|
g.add((resource[beamID], ontology.hasType, resource[istyped]))
|
|
except Exception:
|
|
pass
|
|
try:#hasAssociations is not always there
|
|
for typed in beam['hasAssignments']:
|
|
iselement = typed['ref']
|
|
g.add((resource[iselement], RDF.type, ontology.Group))
|
|
g.add((resource[beamID], ontology.hasAssignments, resource[iselement]))
|
|
except Exception:
|
|
pass
|
|
try: # representationMaps data
|
|
g.add((resource[beamID], ontology.hasPlacement, resource["plamenent_" + beamID + "_1"]))
|
|
g.add((resource["plamenent_" + beamID + "_1"], RDF.type, ontology.Placement))
|
|
g.add((resource["plamenent_" + beamID + "_1"], ontology.xlocation,
|
|
Literal(beam['objectPlacement']['relativePlacement']['location']['coordinates'][0],
|
|
datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + beamID + "_1"], ontology.ylocation,
|
|
Literal(beam['objectPlacement']['relativePlacement']['location']['coordinates'][1],
|
|
datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + beamID + "_1"], ontology.zlocation,
|
|
Literal(beam['objectPlacement']['relativePlacement']['location']['coordinates'][2],
|
|
datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + beamID + "_1"], ontology.xaxis,
|
|
Literal(beam['objectPlacement']['relativePlacement']['axis']['directionRatios'][0],
|
|
datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + beamID + "_1"], ontology.yaxis,
|
|
Literal(beam['objectPlacement']['relativePlacement']['axis']['directionRatios'][1],
|
|
datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + beamID + "_1"], ontology.zaxis,
|
|
Literal(beam['objectPlacement']['relativePlacement']['axis']['directionRatios'][2],
|
|
datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + beamID + "_1"], ontology.xdirection,
|
|
Literal(beam['objectPlacement']['relativePlacement']['refDirection']['directionRatios'][0],
|
|
datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + beamID + "_1"], ontology.ydirection,
|
|
Literal(beam['objectPlacement']['relativePlacement']['refDirection']['directionRatios'][1],
|
|
datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + beamID + "_1"], ontology.zdirection,
|
|
Literal(beam['objectPlacement']['relativePlacement']['refDirection']['directionRatios'][2],
|
|
datatype=XSD.decimal)))
|
|
except Exception:
|
|
pass
|
|
try:
|
|
g.add((resource[beamID], ontology.hasPlacement, resource["plamenent_" + beamID + "_2"]))
|
|
g.add((resource["plamenent_" + beamID + "_2"], RDF.type, ontology.Placement))
|
|
g.add((resource["plamenent_" + beamID + "_2"], ontology.xlocation, Literal(
|
|
beam['objectPlacement']['placementRelTo']['relativePlacement']['location']['coordinates'][0],
|
|
datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + beamID + "_2"], ontology.ylocation, Literal(
|
|
beam['objectPlacement']['placementRelTo']['relativePlacement']['location']['coordinates'][1],
|
|
datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + beamID + "_2"], ontology.zlocation, Literal(
|
|
beam['objectPlacement']['placementRelTo']['relativePlacement']['location']['coordinates'][2],
|
|
datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + beamID + "_2"], ontology.xaxis,
|
|
Literal(
|
|
beam['objectPlacement']['placementRelTo']['relativePlacement']['axis']['directionRatios'][0],
|
|
datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + beamID + "_2"], ontology.yaxis,
|
|
Literal(
|
|
beam['objectPlacement']['placementRelTo']['relativePlacement']['axis']['directionRatios'][1],
|
|
datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + beamID + "_2"], ontology.zaxis,
|
|
Literal(
|
|
beam['objectPlacement']['placementRelTo']['relativePlacement']['axis']['directionRatios'][2],
|
|
datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + beamID + "_2"], ontology.xdirection,
|
|
Literal(beam['objectPlacement']['placementRelTo']['relativePlacement']['refDirection'][
|
|
'directionRatios'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + beamID + "_2"], ontology.ydirection,
|
|
Literal(beam['objectPlacement']['placementRelTo']['relativePlacement']['refDirection'][
|
|
'directionRatios'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + beamID + "_2"], ontology.zdirection,
|
|
Literal(beam['objectPlacement']['placementRelTo']['relativePlacement']['refDirection'][
|
|
'directionRatios'][2], datatype=XSD.decimal)))
|
|
except Exception:
|
|
pass
|
|
try:
|
|
g.add((resource[beamID], ontology.hasPlacement, resource["plamenent_" + beamID + "_3"]))
|
|
g.add((resource["plamenent_" + beamID + "_3"], RDF.type, ontology.Placement))
|
|
g.add((resource["plamenent_" + beamID + "_3"], ontology.xlocation, Literal(
|
|
beam['objectPlacement']['placementRelTo']['placementRelTo']['relativePlacement']['location'][
|
|
'coordinates'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + beamID + "_3"], ontology.ylocation, Literal(
|
|
beam['objectPlacement']['placementRelTo']['placementRelTo']['relativePlacement']['location'][
|
|
'coordinates'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + beamID + "_3"], ontology.zlocation, Literal(
|
|
beam['objectPlacement']['placementRelTo']['placementRelTo']['relativePlacement']['location'][
|
|
'coordinates'][2], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + beamID + "_3"], ontology.xaxis,
|
|
Literal(beam['objectPlacement']['placementRelTo']['placementRelTo']['relativePlacement']['axis'][
|
|
'directionRatios'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + beamID + "_3"], ontology.yaxis,
|
|
Literal(beam['objectPlacement']['placementRelTo']['placementRelTo']['relativePlacement']['axis'][
|
|
'directionRatios'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + beamID + "_3"], ontology.zaxis,
|
|
Literal(beam['objectPlacement']['placementRelTo']['placementRelTo']['relativePlacement']['axis'][
|
|
'directionRatios'][2], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + beamID + "_3"], ontology.xdirection,
|
|
Literal(beam['objectPlacement']['placementRelTo']['placementRelTo']['relativePlacement'][
|
|
'refDirection']['directionRatios'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + beamID + "_3"], ontology.ydirection,
|
|
Literal(beam['objectPlacement']['placementRelTo']['placementRelTo']['relativePlacement'][
|
|
'refDirection']['directionRatios'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + beamID + "_3"], ontology.zdirection,
|
|
Literal(beam['objectPlacement']['placementRelTo']['placementRelTo']['relativePlacement'][
|
|
'refDirection']['directionRatios'][2], datatype=XSD.decimal)))
|
|
except Exception:
|
|
pass
|
|
try:
|
|
g.add((resource[beamID], ontology.hasPlacement, resource["plamenent_" + beamID + "_4"]))
|
|
g.add((resource["plamenent_" + beamID + "_4"], RDF.type, ontology.Placement))
|
|
g.add((resource["plamenent_" + beamID + "_4"], ontology.xlocation, Literal(beam['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['location']['coordinates'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + beamID + "_4"], ontology.ylocation, Literal(beam['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['location']['coordinates'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + beamID + "_4"], ontology.zlocation, Literal(beam['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['location']['coordinates'][2], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + beamID + "_4"], ontology.xaxis,
|
|
Literal(beam['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['axis']['directionRatios'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + beamID + "_4"], ontology.yaxis,
|
|
Literal(beam['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['axis']['directionRatios'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + beamID + "_4"], ontology.zaxis,
|
|
Literal(beam['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['axis']['directionRatios'][2], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + beamID + "_4"], ontology.xdirection,
|
|
Literal(beam['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['refDirection']['directionRatios'][0], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + beamID + "_4"], ontology.ydirection,
|
|
Literal(beam['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['refDirection']['directionRatios'][1], datatype=XSD.decimal)))
|
|
g.add((resource["plamenent_" + beamID + "_4"], ontology.zdirection,
|
|
Literal(beam['objectPlacement']['placementRelTo']['placementRelTo']['placementRelTo']['relativePlacement']['refDirection']['directionRatios'][2], datatype=XSD.decimal)))
|
|
except Exception:
|
|
pass
|
|
return 1
|
|
|
|
def read_ttl_and_store_in_graphdb(ttl_file_path, graphdb_endpoint, graphdb_repository, username=None, password=None):
|
|
"""
|
|
Reads RDF data from a Turtle file and stores it in a GraphDB repository.
|
|
|
|
:param ttl_file_path: Path to the Turtle file.
|
|
:param graphdb_endpoint: URL of the GraphDB endpoint.
|
|
:param graphdb_repository: Name of the GraphDB repository.
|
|
:param username: (Optional) Username for GraphDB authentication.
|
|
:param password: (Optional) Password for GraphDB authentication.
|
|
"""
|
|
# Create a graph
|
|
graph = Graph()
|
|
|
|
# Parse the Turtle file
|
|
graph.parse(ttl_file_path, format="turtle")
|
|
|
|
# Serialize the graph to a string in N-Triples format
|
|
ntriples_data = graph.serialize(format='nt')
|
|
|
|
# If ntriples_data is bytes, decode it to string
|
|
if isinstance(ntriples_data, bytes):
|
|
ntriples_data = ntriples_data.decode('utf-8')
|
|
|
|
# Create a SPARQLWrapper instance for the GraphDB endpoint
|
|
sparql = SPARQLWrapper(f"{graphdb_endpoint}/repositories/{graphdb_repository}/statements")
|
|
sparql.setMethod(POST)
|
|
sparql.setRequestMethod(URLENCODED)
|
|
sparql.addParameter('update', f"""
|
|
INSERT DATA {{
|
|
{ntriples_data}
|
|
}}
|
|
""")
|
|
|
|
# Set credentials if provided
|
|
if username and password:
|
|
sparql.setHTTPAuth(BASIC)
|
|
sparql.setCredentials(username, password)
|
|
|
|
# Send the request to the GraphDB repository
|
|
sparql.query()
|
|
|
|
|
|
def receive_json(ifcJson):
|
|
# Your main logic using the JSON data
|
|
print("Received JSON:", type(ifcJson))
|
|
|
|
IfcBuildingStorey, IfcRelDefinesByType, IfcBeamType, IfcRelFillsElement, IfcDoor, IfcOwnerHistory, ifcSlabType, IfcRelContainedInSpatialStructure, IfcRelAssociatesMaterial, \
|
|
IfcBuilding, IfcColumnType, IfcColumn, IfcMemberType, IfcSite, IfcOpeningElement, IfcRelAggregates, IfcGeometricRepresentationContext, IfcWindowLiningProperties,\
|
|
IfcRelVoidsElement, IfcDoorType, IfcGeometricRepresentationSubContext, IfcDoorLiningProperties, IfcRelDefinesByProperties, IfcWallType, IfcWindowType, IfcWall, \
|
|
IfcWindow, IfcGroup, IfcRelAssignsToGroup, IfcProject, IfcPropertySet, IfcSlab, IfcDoorPanelProperties, IfcMember, IfcElementQuantity, IfcBeam, IfcShapeRepresentation = parser(ifcJson)
|
|
|
|
ifcRelDefinesByTypeFunction(IfcRelDefinesByType)
|
|
ifcBuildingStoreyFunction(IfcBuildingStorey)
|
|
ifcBeamTypeFunction(IfcBeamType)
|
|
ifcRelFillsElementFunction(IfcRelFillsElement)
|
|
ifcDoorFunction(IfcDoor)
|
|
ifcOwnerHistoryFunction(IfcOwnerHistory)
|
|
ifcSlabTypeFunction(ifcSlabType)
|
|
ifcRelContainedInSpatialStructureFunction(IfcRelContainedInSpatialStructure)
|
|
ifcRelAssociatesMaterialFunction(IfcRelAssociatesMaterial)
|
|
ifcBuilingFunction(IfcBuilding)
|
|
ifcColumnTypeFunction(IfcColumnType)
|
|
ifcColumnFunction(IfcColumn)
|
|
ifcMemberTypeFunction(IfcMemberType)
|
|
ifcSiteFunction(IfcSite)
|
|
ifcOpeningElementFunction(IfcOpeningElement)
|
|
ifcRelAggregatesFunction(IfcRelAggregates)
|
|
ifcGeometricRepresentationContextFunction(IfcGeometricRepresentationContext)
|
|
ifcWindowLiningPropertiesFunction(IfcWindowLiningProperties)
|
|
ifcRelVoidsElementFunction(IfcRelVoidsElement)
|
|
ifcDoorTypeFunction(IfcDoorType)
|
|
ifcDoorLiningPropertiesFunction(IfcDoorLiningProperties)
|
|
ifcRelDefinesByPropertiesFunction(IfcRelDefinesByProperties)
|
|
ifcWallTypeFunction(IfcWallType)
|
|
ifcWindowTypeFunction(IfcWindowType)
|
|
ifcWallFunction(IfcWall)
|
|
ifcWindowFunction(IfcWindow)
|
|
ifcGroupFunction(IfcGroup)
|
|
ifcRelAssignsToGroupFunction(IfcRelAssignsToGroup)
|
|
ifcPropertySetFunction(IfcPropertySet)
|
|
ifcSlabFunction(IfcSlab)
|
|
ifcDoorPanelPropertiesFunction(IfcDoorPanelProperties)
|
|
ifcMemberFunction(IfcMember)
|
|
ifcElementQuantityFunction(IfcElementQuantity)
|
|
ifcBeamFunction(IfcBeam)
|
|
|
|
|
|
#Class for IfcProject
|
|
projectClass = project(IfcProject, g, ontology, resource)
|
|
projectClass.ifcProjectFunction()
|
|
|
|
#Class for ifcGeometricRepresentationSubContextFunction
|
|
geometricClass = geometric(IfcGeometricRepresentationSubContext, g, ontology, resource)
|
|
geometricClass.ifcGeometricRepresentationSubContextFunction()
|
|
|
|
#Class for ifcShapeRepresentation
|
|
shapeClass = shape(IfcShapeRepresentation, g, ontology, resource)
|
|
shapeClass.ifcShapeRepresentationFunction()
|
|
|
|
# Create RDF triples
|
|
# Serialize and save the RDF graph to a TTL file
|
|
file_path = "output.ttl"
|
|
g.serialize(destination=file_path, format="turtle")
|
|
|
|
print(f"RDF triples dumped to '{file_path}' successfully.")
|
|
ttl_file_path = 'output.ttl' # Replace with the path to your Turtle file
|
|
graphdb_endpoint = 'http://localhost:7200' # Replace with the URL of your GraphDB endpoint
|
|
graphdb_repository = 'model_madrid' # Replace with the name of your GraphDB repository
|
|
username = 'admin' # Replace with your GraphDB username (if required)
|
|
password = 'root' # Replace with your GraphDB password (if required)
|
|
#test pc certh, this is new
|
|
# read_ttl_and_store_in_graphdb(ttl_file_path, graphdb_endpoint, graphdb_repository, username, password)
|
|
print("Data was mapped in GraphDB")
|
|
return 1 |