Upload files to "ifcParser"

This commit is contained in:
2024-10-10 22:59:05 +00:00
parent df81ec84c4
commit 4d355aa1b3
5 changed files with 3943 additions and 0 deletions

View File

@@ -0,0 +1,50 @@
from rdflib import Graph, Namespace, URIRef, Literal, RDF, RDFS, XSD
class geometric():
def __init__(self, IfcGeometricRepresentationSubContext, g, ontology, resource):
self.IfcGeometricRepresentationSubContext = IfcGeometricRepresentationSubContext
self.g = g
self.ontology = ontology
self.resource = resource
def ifcGeometricRepresentationSubContextFunction(self):
for context in self.IfcGeometricRepresentationSubContext:
contextID = context['globalId']
#basic information
self.g.add((self.resource[contextID], RDF.type, self.ontology.Context))
try: # contextIdentifier is not always there
contextIdentifier = context['contextIdentifier']
self.g.add((self.resource[contextID], self.ontology.identifier, Literal(contextIdentifier)))
except Exception:
pass
try: # contextType is not always there
contextType = context['contextType']
self.g.add((self.resource[contextID], self.ontology.contextType, Literal(contextType)))
except Exception:
pass
try: # targetView is not always there
contextTargetView = context['targetView']
self.g.add((self.resource[contextID], self.ontology.targetView, Literal(contextTargetView)))
except Exception:
pass
try: # contextType is not always there
parentContext = context['parentContext']['ref']
self.g.add((self.resource[parentContext], RDF.type, self.ontology.Context))
self.g.add((self.resource[contextID], self.ontology.hasParentContext, self.resource[parentContext]))
except Exception:
pass
try: # contextType is not always there
for element in context['representationsInContext']:
if "ref" in list(element.keys()):
self.g.add((self.resource[element['ref']], RDF.type, self.ontology.Context))
self.g.add((self.resource[contextID], self.ontology.hasRelatedContext, self.resource[element['ref']]))
except Exception:
pass
# Create RDF triples
# Serialize and save the RDF graph to a TTL file
file_path = "output.ttl"
self.g.serialize(destination=file_path, format="turtle")

3395
ifcParser/ifcJsonParser.py Normal file

File diff suppressed because it is too large Load Diff

146
ifcParser/ifcProject.py Normal file
View File

@@ -0,0 +1,146 @@
from rdflib import Graph, Namespace, URIRef, Literal, RDF, RDFS, XSD
class project():
def __init__(self, IfcProject, g, ontology, resource):
self.IfcProject = IfcProject
self.g = g
self.ontology = ontology
self.resource = resource
def ifcProjectFunction(self):
for proj in self.IfcProject:
projectID = proj['globalId']
#basic information
self.g.add((self.resource[projectID], RDF.type, self.ontology.Project))
try:#add history
projectHistory = proj['ownerHistory']['ref']
self.g.add((self.resource[projectHistory], RDF.type, self.ontology.History))
self.g.add((self.resource[projectID], self.ontology.hasHistory, self.resource[projectHistory]))
except Exception:
pass
try: # name is not always there
projName = proj['name']
self.g.add((self.resource[projectID], self.ontology.name, Literal(projName)))
except Exception:
pass
try: # description is not always there
projDescription = proj['description']
self.g.add((self.resource[projectID], self.ontology.description, Literal(projDescription)))
except Exception:
pass
try: # description is not always there
projLongName = proj['longName']
self.g.add((self.resource[projectID], self.ontology.longName, Literal(projLongName)))
except Exception:
pass
try: # description is not always there
projPhase = proj['phase']
self.g.add((self.resource[projectID], self.ontology.phase, Literal(projPhase)))
except Exception:
pass
try: # representationContexts is not always there
for representationContexts in proj['representationContexts']:
context = representationContexts['ref']
self.g.add((self.resource[context], RDF.type, self.ontology.Context))
self.g.add((self.resource[projectID], self.ontology.hasRepresentationContext, self.resource[context]))
except Exception:
pass
try: # definedby is not always there
for defined in proj['isDefinedBy']:
issdefined = defined['ref']
self.g.add((self.resource[issdefined], RDF.type, self.ontology.PropertySet))
self.g.add((self.resource[projectID], self.ontology.isDefinedBy, self.resource[issdefined]))
except Exception:
pass
try: # decompose is not always there
for representation in proj['isDecomposedBy']:
rep = representation['ref']
self.g.add((self.resource["building_" + projectID], RDF.type, self.ontology.Object))
self.g.add((self.resource[rep], self.ontology.isDecomposedBy, self.resource["building_" + projectID]))
except Exception:
pass
try: # decompose is not always there
for representation in proj['declares']:
rep = representation['ref']
self.g.add((self.resource["declaration_" + projectID], RDF.type, self.ontology.RelationDeclaration))
self.g.add((self.resource[rep], self.ontology.declares, self.resource["declaration_" + projectID]))
except Exception:
pass
try:
count, countElement = 1, 1
for unit in proj['unitsInContext']['units']:
unitType = unit['type']
print(unitType)
if unitType == "IfcSIUnit":
self.g.add((self.resource["ifcUnit_" + projectID + "_" + str(count)], RDF.type, self.ontology.IfcSIUnit))
self.g.add((self.resource[projectID], self.ontology.hasUnit, self.resource["ifcUnit_" + projectID + "_" + str(count)]))
self.g.add((self.resource["ifcUnit_" + projectID + "_" + str(count)], self.ontology.unitType, Literal(unit['unitType'])))
self.g.add((self.resource["ifcUnit_" + projectID + "_" + str(count)], self.ontology.name, Literal(unit['name'])))
self.g.add((self.resource["ifcUnit_" + projectID + "_" + str(count)], self.ontology.dimensionType, Literal(unit['dimensions']['type'])))
if 'prefix' in list(unit.keys()):
self.g.add((self.resource["ifcUnit_" + projectID + "_" + str(count)], self.ontology.prefix, Literal(unit['prefix'])))
if 'LengthExponent' in list(unit['dimensions'].keys()):
self.g.add((self.resource["ifcUnit_" + projectID + "_" + str(count)], self.ontology.LengthExponent, Literal(unit['dimensions']['LengthExponent'])))
if 'TimeExponent' in list(unit['dimensions'].keys()):
self.g.add((self.resource["ifcUnit_" + projectID + "_" + str(count)], self.ontology.TimeExponent, Literal(unit['dimensions']['TimeExponent'])))
if 'ThermodynamicTemperatureExponent' in list(unit['dimensions'].keys()):
self.g.add((self.resource["ifcUnit_" + projectID + "_" + str(count)], self.ontology.ThermodynamicTemperatureExponent, Literal(unit['dimensions']['ThermodynamicTemperatureExponent'])))
if 'MassExponent' in list(unit['dimensions'].keys()):
self.g.add((self.resource["ifcUnit_" + projectID + "_" + str(count)], self.ontology.MassExponent, Literal(unit['dimensions']['MassExponent'])))
if 'ElectricCurrentExponent' in list(unit['dimensions'].keys()):
self.g.add((self.resource["ifcUnit_" + projectID + "_" + str(count)], self.ontology.ElectricCurrentExponent, Literal(unit['dimensions']['ElectricCurrentExponent'])))
if 'LuminousIntensityExponent' in list(unit['dimensions'].keys()):
self.g.add((self.resource["ifcUnit_" + projectID + "_" + str(count)], self.ontology.LuminousIntensityExponent, Literal(unit['dimensions']['LuminousIntensityExponent'])))
elif unitType == "IfcConversionBasedUnit":
self.g.add((self.resource["conversionBasedUnit_" + projectID + "_" + str(count)], RDF.type, self.ontology.ConversionBasedUnit))
self.g.add((self.resource[projectID], self.ontology.hasUnit, self.resource["conversionBasedUnit_" + projectID + "_" + str(count)]))
self.g.add((self.resource["conversionBasedUnit_" + projectID + "_" + str(count)], self.ontology.unitType, Literal(unit['unitType'])))
self.g.add((self.resource["conversionBasedUnit_" + projectID + "_" + str(count)], self.ontology.name, Literal(unit['name'])))
self.g.add((self.resource["conversionBasedUnit_" + projectID + "_" + str(count)], self.ontology.coversionType, Literal(unit['conversionFactor']['valueComponent']['type'])))
self.g.add((self.resource["conversionBasedUnit_" + projectID + "_" + str(count)], self.ontology.coversionValue, Literal(unit['conversionFactor']['valueComponent']['value'])))
self.g.add((self.resource["conversionBasedUnit_" + projectID + "_" + str(count)], self.ontology.componentType, Literal(unit['conversionFactor']['unitComponent']['unitType'])))
self.g.add((self.resource["conversionBasedUnit_" + projectID + "_" + str(count)], self.ontology.componentName, Literal(unit['conversionFactor']['unitComponent']['name'])))
self.g.add((self.resource["conversionBasedUnit_" + projectID + "_" + str(count)], self.ontology.dimensionType, Literal(unit['conversionFactor']['unitComponent']['dimensions']['type'])))
self.g.add((self.resource["conversionBasedUnit_" + projectID + "_" + str(count)], self.ontology.LengthExponent, Literal(unit['dimensions']['lengthExponent'])))
self.g.add((self.resource["conversionBasedUnit_" + projectID + "_" + str(count)], self.ontology.MassExponent, Literal(unit['dimensions']['massExponent'])))
self.g.add((self.resource["conversionBasedUnit_" + projectID + "_" + str(count)], self.ontology.TimeExponent, Literal(unit['dimensions']['timeExponent'])))
self.g.add((self.resource["conversionBasedUnit_" + projectID + "_" + str(count)], self.ontology.ElectricCurrentExponent, Literal(unit['dimensions']['electricCurrentExponent'])))
self.g.add((self.resource["conversionBasedUnit_" + projectID + "_" + str(count)], self.ontology.ThermodynamicTemperatureExponent, Literal(unit['dimensions']['thermodynamicTemperatureExponent'])))
self.g.add((self.resource["conversionBasedUnit_" + projectID + "_" + str(count)], self.ontology.AmountOfSubstanceExponent, Literal(unit['dimensions']['amountOfSubstanceExponent'])))
self.g.add((self.resource["conversionBasedUnit_" + projectID + "_" + str(count)], self.ontology.LuminousIntensityExponent, Literal(unit['dimensions']['luminousIntensityExponent'])))
elif unitType == "IfcDerivedUnit":
self.g.add((self.resource["derivedUnit_" + projectID + "_" + str(count)], RDF.type, self.ontology.DerivedUnit))
self.g.add((self.resource[projectID], self.ontology.hasUnit, self.resource["derivedUnit_" + projectID + "_" + str(count)]))
self.g.add((self.resource["derivedUnit_" + projectID + "_" + str(count)], self.ontology.unitType, Literal(unit['unitType'])))
for element in unit['elements']:
self.g.add((self.resource["derivedUnitElement_" + projectID + "_" + str(countElement)], RDF.type, self.ontology.DerivedUnit))
self.g.add((self.resource["derivedUnit_" + projectID + "_" + str(count)], self.ontology.hasElement, self.resource["derivedUnitElement_" + projectID + "_" + str(countElement)]))
self.g.add((self.resource["derivedUnitElement_" + projectID + "_" + str(countElement)], self.ontology.type, Literal(element['unit']['unitType'])))
try:
self.g.add((self.resource["derivedUnitElement_" + projectID + "_" + str(countElement)],
self.ontology.prefix, Literal(element['prefix'])))
except Exception:
pass
try:
self.g.add((self.resource["derivedUnitElement_" + projectID + "_" + str(countElement)], self.ontology.name, Literal(element['unit']['name'])))
except Exception:
pass
self.g.add((self.resource["derivedUnitElement_" + projectID + "_" + str(countElement)], self.ontology.exponent, Literal(element['exponent'])))
self.g.add((self.resource["derivedUnitElement_" + projectID + "_" + str(countElement)], self.ontology.dimensionType, Literal(element['unit']['dimensions']['type'])))
for k in list(element['unit']['dimensions'].keys()):
if str(k) != "type":
self.g.add((self.resource["derivedUnitElement_" + projectID + "_" + str(countElement)], self.ontology[k], Literal(element['unit']['dimensions'][k])))
countElement += 1
else:
pass
count += 1
except Exception:
pass
# Create RDF triples
# Serialize and save the RDF graph to a TTL file
file_path = "output.ttl"
self.g.serialize(destination=file_path, format="turtle")

327
ifcParser/ifcShape.py Normal file
View File

@@ -0,0 +1,327 @@
from rdflib import Graph, Namespace, URIRef, Literal, RDF, RDFS, XSD
class shape():
def __init__(self, IfcShapeRepresentation, g, ontology, resource):
self.IfcShapeRepresentation = IfcShapeRepresentation
self.g = g
self.ontology = ontology
self.resource = resource
def ifcShapeRepresentationFunction(self):
for shape in self.IfcShapeRepresentation:
shapeID = shape['globalId']
# basic information
self.g.add((self.resource[shapeID], RDF.type, self.ontology.Shape))
try: # name is not always there
shapeIdentifier = shape['representationIdentifier']
self.g.add((self.resource[shapeID], self.ontology.identifier, Literal(shapeIdentifier)))
except Exception:
pass
try: # description is not always there
shapeType = shape['representationType']
self.g.add((self.resource[shapeID], self.ontology.type, Literal(shapeType)))
except Exception:
pass
try:
iscontext = shape['contextOfItems']['ref']
self.g.add((self.resource[iscontext], RDF.type, self.ontology.Context))
self.g.add((self.resource[shapeID], self.ontology.hasContext, self.resource[iscontext]))
except Exception:
pass
try: # material is not always there
count = 1
for layer in shape['layerAssignments']:
layerType = layer['type']
layerName = layer['name']
self.g.add((self.resource["layer_" + shapeID + "_" + str(count)], RDF.type, self.ontology.Layer))
self.g.add((self.resource[shapeID], self.ontology.hasLayer, self.resource["layer_" + shapeID + "_" + str(count)]))
self.g.add((self.resource["layer_" + shapeID + "_" + str(count)], self.ontology.name, Literal(layerName)))
self.g.add((self.resource["layer_" + shapeID + "_" + str(count)], self.ontology.type, Literal(layerType)))
for item in layer['assignedItems']:
itemID = item['ref']
self.g.add(
(self.resource[itemID], RDF.type, self.ontology.Shape))
self.g.add((self.resource["layer_" + shapeID + "_" + str(count)], self.ontology.hasShape,
self.resource[itemID]))
count += 1
except Exception:
pass
try: # material is not always there
for representationMap in shape['representationMap']:
repID = representationMap['mappedRepresentation']['ref']
self.g.add((self.resource["mapped_representation_" + repID], RDF.type, self.ontology.MappedRepresentation))
self.g.add((self.resource[shapeID], self.ontology.hasMappedRepresentation, self.resource["mapped_representation_" + repID]))
self.g.add((self.resource["mapped_representation_" + repID], self.ontology.xlocation,
Literal(representationMap['mappingOrigin']['location'][
'coordinates'][0])))
self.g.add((self.resource["mapped_representation_" + repID], self.ontology.ylocation,
Literal(representationMap['mappingOrigin']['location'][
'coordinates'][1])))
self.g.add((self.resource["mapped_representation_" + repID], self.ontology.zlocation,
Literal(representationMap['mappingOrigin']['location'][
'coordinates'][2])))
except Exception:
pass
try: # material is not always there
for representationType in shape['ofProductRepresentation']:
for rep in representationType['representations']:
repID = rep['ref']
self.g.add((self.resource["representation_" + repID], RDF.type, self.ontology.Representation))
self.g.add((self.resource[shapeID], self.ontology.hasRepresentation, self.resource["representation_" + repID]))
except Exception:
pass
try: # material is not always there
for shapeAspect in shape['ofShapeAspect']:
self.g.add((self.resource[shapeID], self.ontology.name,
Literal(shapeAspect["name"])))
self.g.add((self.resource[shapeID], self.ontology.definition,
Literal(shapeAspect["productDefinitional"])))
for rep in shapeAspect['shapeRepresentations']:
repID = rep['ref']
self.g.add((self.resource["shape_representation_" + repID], RDF.type, self.ontology.ShapeRepresentation))
self.g.add((self.resource[shapeID], self.ontology.hasShapeRepresentation, self.resource["shape_representation_" + repID]))
if 'representations' in list(shapeAspect['partOfProductDefinitionShape'].keys()):
for rep in shapeAspect['partOfProductDefinitionShape']['representations']:
repID = rep['ref']
self.g.add((self.resource["mapped_representation_" + repID], RDF.type, self.ontology.MappedRepresentation))
self.g.add((self.resource[shapeID], self.ontology.hasMappedRepresentation, self.resource["mapped_representation_" + repID]))
elif 'mappingOrigin' in list(shapeAspect['partOfProductDefinitionShape'].keys()):
self.g.add((self.resource["mapped_representation_" + shapeAspect['partOfProductDefinitionShape']['mappedRepresentation']['ref']], RDF.type,
self.ontology.MappedRepresentation))
self.g.add((self.resource[shapeID], self.ontology.hasMappedRepresentation,
self.resource["mapped_representation_" + shapeAspect['partOfProductDefinitionShape']['mappedRepresentation']['ref']]))
self.g.add((self.resource["mapped_representation_" + shapeAspect['partOfProductDefinitionShape']['mappedRepresentation']['ref']], self.ontology.hasxlocation,
Literal(shapeAspect['partOfProductDefinitionShape']['mappingOrigin']['location']['coordinates'][0])))
self.g.add((self.resource["mapped_representation_" + shapeAspect['partOfProductDefinitionShape']['mappedRepresentation']['ref']], self.ontology.hasylocation,
Literal(shapeAspect['partOfProductDefinitionShape']['mappingOrigin']['location']['coordinates'][1])))
self.g.add((self.resource["mapped_representation_" + shapeAspect['partOfProductDefinitionShape']['mappedRepresentation']['ref']], self.ontology.haszlocation,
Literal(shapeAspect['partOfProductDefinitionShape']['mappingOrigin']['location']['coordinates'][2])))
except Exception:
pass
try: # material is not always there
countpolygonalFace, countPolygonalCoord = 1, 1
for item in shape['items']:
if item['type'] == "IfcExtrudedAreaSolid":
if 'depth' in list(item.keys()):
depth = item['depth']
self.g.add((self.resource[shapeID], self.ontology.depth, Literal(depth)))
if 'extrudedDirection' in list(item.keys()):
self.g.add((self.resource[shapeID], self.ontology.xextrudedDirection, Literal(item['extrudedDirection']['directionRatios'][0])))
self.g.add((self.resource[shapeID], self.ontology.yextrudedDirection, Literal(item['extrudedDirection']['directionRatios'][1])))
self.g.add((self.resource[shapeID], self.ontology.zextrudedDirection, Literal(item['extrudedDirection']['directionRatios'][2])))
if 'position' in list(item.keys()):
if 'location' in list(item['position'].keys()):
self.g.add((self.resource[shapeID], self.ontology.xlocation, Literal(item['position']['location']['coordinates'][0])))
self.g.add((self.resource[shapeID], self.ontology.ylocation, Literal(item['position']['location']['coordinates'][1])))
self.g.add((self.resource[shapeID], self.ontology.zlocation, Literal(item['position']['location']['coordinates'][2])))
if 'position' in list(item.keys()):
if 'axis' in list(item['position'].keys()):
self.g.add((self.resource[shapeID], self.ontology.xaxis, Literal(item['position']['axis']['directionRatios'][0])))
self.g.add((self.resource[shapeID], self.ontology.yaxis, Literal(item['position']['axis']['directionRatios'][1])))
self.g.add((self.resource[shapeID], self.ontology.zaxis, Literal(item['position']['axis']['directionRatios'][2])))
if 'position' in list(item.keys()):
if 'refDirection' in list(item['position'].keys()):
self.g.add((self.resource[shapeID], self.ontology.xrefDirection, Literal(item['position']['refDirection']['directionRatios'][0])))
self.g.add((self.resource[shapeID], self.ontology.yrefDirection, Literal(item['position']['refDirection']['directionRatios'][1])))
self.g.add((self.resource[shapeID], self.ontology.zrefDirection, Literal(item['position']['refDirection']['directionRatios'][2])))
if 'profileType' in list(item['sweptArea'].keys()):
self.g.add((self.resource[shapeID], self.ontology.sweptAreaType, Literal(item['sweptArea']['profileType'])))
if 'profileName' in list(item['sweptArea'].keys()):
self.g.add((self.resource[shapeID], self.ontology.sweptAreaName, Literal(item['sweptArea']['profileName'])))
if 'sweptArea' in list(item.keys()):
count = 1
for coord in item['sweptArea']['outerCurve']['points']['coordList']:
self.g.add(
(self.resource["coord_" + shapeID + "_" + str(count)], RDF.type, self.ontology.Coord))
self.g.add((self.resource[shapeID], self.ontology.hasCoord,
self.resource["coord_" + shapeID + "_" + str(count)]))
for constant in coord:
self.g.add(
(self.resource["coord_" + shapeID + "_" + str(count)], self.ontology.coord,
Literal(constant)))
count += 1
countInner = 1
if "innerCurves" in list(item['sweptArea'].keys()):
for inner in item['sweptArea']['innerCurves']:
for coord in inner['points']['coordList']:
self.g.add(
(self.resource["coordInner_" + shapeID + "_" + str(countInner)], RDF.type,
self.ontology.InnerCoord))
self.g.add((self.resource[shapeID], self.ontology.hasInnerCoord,
self.resource["coordInner_" + shapeID + "_" + str(countInner)]))
for constant in coord:
self.g.add(
(self.resource["coordInner_" + shapeID + "_" + str(countInner)], self.ontology.innercoord,
Literal(constant)))
countInner += 1
if item['type'] == "IfcMappedItem":
if "mappingTarget" in list(item.keys()):
if len(item['mappingTarget']['localOrigin']['coordinates']) == 3:
self.g.add((self.resource[shapeID], self.ontology.xlocation, Literal(item['mappingTarget']['localOrigin']['coordinates'][0])))
self.g.add((self.resource[shapeID], self.ontology.ylocation, Literal(item['mappingTarget']['localOrigin']['coordinates'][1])))
self.g.add((self.resource[shapeID], self.ontology.zlocation, Literal(item['mappingTarget']['localOrigin']['coordinates'][2])))
elif len(item['mappingTarget']['localOrigin']['coordinates']) == 2:
self.g.add((self.resource[shapeID], self.ontology.xlocation, Literal(item['mappingTarget']['localOrigin']['coordinates'][0])))
self.g.add((self.resource[shapeID], self.ontology.ylocation, Literal(item['mappingTarget']['localOrigin']['coordinates'][1])))
elif len(item['mappingTarget']['localOrigin']['coordinates']) == 1:
self.g.add((self.resource[shapeID], self.ontology.xlocation, Literal(item['mappingTarget']['localOrigin']['coordinates'][0])))
else:
pass
if "scale" in list(item['mappingTarget'].keys()):
self.g.add((self.resource[shapeID], self.ontology.scale,
Literal(item['mappingTarget']['scale'])))
if "mappingSource" in list(item.keys()):
if len(item['mappingSource']['mappingOrigin']['location']['coordinates']) == 3:
self.g.add((self.resource[shapeID], self.ontology.location2X, Literal(item['mappingSource']['mappingOrigin']['location']['coordinates'][0])))
self.g.add((self.resource[shapeID], self.ontology.location2Y, Literal(item['mappingSource']['mappingOrigin']['location']['coordinates'][1])))
self.g.add((self.resource[shapeID], self.ontology.location2Z, Literal(item['mappingSource']['mappingOrigin']['location']['coordinates'][2])))
elif len(item['mappingSource']['mappingOrigin']['location']['coordinates']) == 2:
self.g.add((self.resource[shapeID], self.ontology.location2X, Literal(item['mappingSource']['mappingOrigin']['location']['coordinates'][0])))
self.g.add((self.resource[shapeID], self.ontology.location2Y, Literal(item['mappingSource']['mappingOrigin']['location']['coordinates'][1])))
elif len(item['mappingSource']['mappingOrigin']['location']['coordinates']) == 1:
self.g.add((self.resource[shapeID], self.ontology.location2X, Literal(item['mappingSource']['mappingOrigin']['location']['coordinates'][0])))
else:
pass
if item['type'] == "IfcIndexedPolyCurve":
if "points" in list(item.keys()):
self.g.add(
(self.resource["placement_" + shapeID], RDF.type, self.ontology.Placement))
self.g.add((self.resource[shapeID], self.ontology.hasPlacement,
self.resource["placement_" + shapeID]))
count = 1
for coord in item['points']['coordList']:
self.g.add(
(self.resource["coord_" + shapeID + "_" + str(count)], RDF.type, self.ontology.Coord))
self.g.add((self.resource["placement_" + shapeID], self.ontology.hasCoord,
self.resource["coord_" + shapeID + "_" + str(count)]))
for constant in coord:
self.g.add(
(self.resource["coord_" + shapeID + "_" + str(count)], self.ontology.coord,
Literal(constant)))
count += 1
if item['type'] == "IfcPolygonalFaceSet":
if "coordinates" in list(item.keys()):
self.g.add(
(self.resource["placement_" + shapeID], RDF.type, self.ontology.Placement))
self.g.add((self.resource[shapeID], self.ontology.hasPlacement,
self.resource["placement_" + shapeID]))
for coord in item['coordinates']['coordList']:
self.g.add(
(self.resource["coord_" + shapeID + "_" + str(countPolygonalCoord)], RDF.type,
self.ontology.Coord))
self.g.add((self.resource["placement_" + shapeID], self.ontology.hasCoord,
self.resource["coord_" + shapeID + "_" + str(countPolygonalCoord)]))
for constant in coord:
self.g.add(
(self.resource["coord_" + shapeID + "_" + str(countPolygonalCoord)], self.ontology.coord,
Literal(constant)))
countPolygonalCoord += 1
if "closed" in list(item.keys()):
self.g.add(
(self.resource[shapeID], self.ontology.closed,
Literal(item['closed'])))
if "faces" in list(item.keys()):
self.g.add(
(self.resource["placementFacet_" + shapeID], RDF.type, self.ontology.Placement))
self.g.add((self.resource[shapeID], self.ontology.hasFacetPlacement,
self.resource["placementFacet_" + shapeID]))
for face in item['faces']:
self.g.add(
(self.resource["faces_" + shapeID + "_" + str(countpolygonalFace)], RDF.type,
self.ontology.Face))
self.g.add((self.resource["placementFacet_" + shapeID], self.ontology.hasFace,
self.resource["faces_" + shapeID + "_" + str(countpolygonalFace)]))
if face["type"] == "IfcIndexedPolygonalFace":
for constant in face['coordIndex']:
self.g.add(
(self.resource["faces_" + shapeID + "_" + str(countpolygonalFace)], self.ontology.faceValue,
Literal(constant)))
countpolygonalFace += 1
if face["type"] == "IfcIndexedPolygonalFaceWithVoids":
for constant in face['coordIndex']:
self.g.add(
(self.resource["faces_" + shapeID + "_" + str(countpolygonalFace)],
self.ontology.faceValue,
Literal(constant)))
for constant in face['innerCoordIndices']:
for innerconstant in constant:
self.g.add(
(self.resource["faces_" + shapeID + "_" + str(countpolygonalFace)], self.ontology.faceValueInner,
Literal(innerconstant)))
countpolygonalFace += 1
if item['type'] == "IfcBooleanClippingResult":
if "operator" in list(item.keys()):
self.g.add((self.resource[shapeID], self.ontology.operator, Literal(item["operator"])))
if "firstOperand" in list(item.keys()):
self.g.add(
(self.resource["firstplacement_" + shapeID], RDF.type, self.ontology.Placement))
self.g.add((self.resource[shapeID], self.ontology.hasFirstPlacement,
self.resource["firstplacement_" + shapeID]))
if "sweptArea" in list(item["firstOperand"].keys()):
self.g.add((self.resource["firstplacement_" + shapeID], self.ontology.type,
Literal(item["firstOperand"]["sweptArea"]["profileType"])))
self.g.add((self.resource["firstplacement_" + shapeID], self.ontology.name,
Literal(item["firstOperand"]["sweptArea"]["profileName"])))
self.g.add((self.resource["firstplacement_" + shapeID], self.ontology.xcoordinate,
Literal(item["firstOperand"]["sweptArea"]["position"]["location"]["coordinates"][0])))
self.g.add((self.resource["firstplacement_" + shapeID], self.ontology.ycoordinate,
Literal(item["firstOperand"]["sweptArea"]["position"]["location"]["coordinates"][1])))
self.g.add((self.resource["firstplacement_" + shapeID], self.ontology.xDim,
Literal(item["firstOperand"]["sweptArea"]["xDim"])))
self.g.add((self.resource["firstplacement_" + shapeID], self.ontology.yDim,
Literal(item["firstOperand"]["sweptArea"]["yDim"])))
if "position" in list(item["firstOperand"].keys()):
self.g.add((self.resource["firstplacement_" + shapeID], self.ontology.xlocation,
Literal(item["firstOperand"]["position"]["location"]["coordinates"][0])))
self.g.add((self.resource["firstplacement_" + shapeID], self.ontology.ylocation,
Literal(item["firstOperand"]["position"]["location"]["coordinates"][1])))
self.g.add((self.resource["firstplacement_" + shapeID], self.ontology.zlocation,
Literal(item["firstOperand"]["position"]["location"]["coordinates"][2])))
if "extrudedDirection" in list(item["firstOperand"].keys()):
self.g.add((self.resource["firstplacement_" + shapeID], self.ontology.xextrudedDirection,
Literal(item["firstOperand"]["extrudedDirection"]["directionRatios"][0])))
self.g.add((self.resource["firstplacement_" + shapeID], self.ontology.yextrudedDirection,
Literal(item["firstOperand"]["extrudedDirection"]["directionRatios"][1])))
self.g.add((self.resource["firstplacement_" + shapeID], self.ontology.zextrudedDirection,
Literal(item["firstOperand"]["extrudedDirection"]["directionRatios"][2])))
if "depth" in list(item["firstOperand"].keys()):
self.g.add((self.resource["firstplacement_" + shapeID], self.ontology.depth,
Literal(item["firstOperand"]["depth"])))
if "secondOperand" in list(item.keys()):
self.g.add(
(self.resource["secondplacement_" + shapeID], RDF.type, self.ontology.Placement))
self.g.add((self.resource[shapeID], self.ontology.hasSecondPlacement,
self.resource["secondplacement_" + shapeID]))
if "baseSurface" in list(item["secondOperand"].keys()):
if "position" in list(item["secondOperand"]["baseSurface"].keys()):
if "location" in list(item["secondOperand"]["baseSurface"]["position"].keys()):
self.g.add((self.resource["secondplacement_" + shapeID], self.ontology.xlocation,
Literal(item["secondOperand"]["baseSurface"]["position"]["location"]["coordinates"][0])))
self.g.add((self.resource["secondplacement_" + shapeID], self.ontology.ylocation,
Literal(item["secondOperand"]["baseSurface"]["position"]["location"]["coordinates"][1])))
self.g.add((self.resource["secondplacement_" + shapeID], self.ontology.zlocation,
Literal(item["secondOperand"]["baseSurface"]["position"]["location"]["coordinates"][2])))
if "axis" in list(item["secondOperand"]["baseSurface"]["position"].keys()):
self.g.add((self.resource["secondplacement_" + shapeID], self.ontology.xaxis,
Literal(item["secondOperand"]["baseSurface"]["position"]["axis"]["directionRatios"][0])))
self.g.add((self.resource["secondplacement_" + shapeID], self.ontology.yaxis,
Literal(item["secondOperand"]["baseSurface"]["position"]["axis"]["directionRatios"][1])))
self.g.add((self.resource["secondplacement_" + shapeID], self.ontology.zaxis,
Literal(item["secondOperand"]["baseSurface"]["position"]["axis"]["directionRatios"][2])))
if "refDirection" in list(item["secondOperand"]["baseSurface"]["position"].keys()):
self.g.add((self.resource["secondplacement_" + shapeID], self.ontology.xrefDirection,
Literal(item["secondOperand"]["baseSurface"]["position"]["refDirection"]["directionRatios"][0])))
self.g.add((self.resource["secondplacement_" + shapeID], self.ontology.yrefDirection,
Literal(item["secondOperand"]["baseSurface"]["position"]["refDirection"]["directionRatios"][1])))
self.g.add((self.resource["secondplacement_" + shapeID], self.ontology.zrefDirection,
Literal(item["secondOperand"]["baseSurface"]["position"]["refDirection"]["directionRatios"][2])))
except Exception:
pass
# Create RDF triples
# Serialize and save the RDF graph to a TTL file
file_path = "output.ttl"
self.g.serialize(destination=file_path, format="turtle")

25
ifcParser/main-mapping.py Normal file
View File

@@ -0,0 +1,25 @@
from flask import Flask, request, jsonify
import json, ifcJsonParser
app = Flask(__name__)
# First route
@app.route('/ifc-mapping', methods=['POST'])
def handle_request1():
data = request.get_json(force=True)
json_data = json.dumps(data)
print(type(data), type(json_data))
ifcJsonParser.receive_json(data)
return jsonify({"message": "Response from ifc-mapping"})
# Second route
@app.route('/endpoint2', methods=['POST'])
def handle_request2():
data = request.get_json()
# Process data
# ...
print(data)
return jsonify({"message": "Response from endpoint2"})
if __name__ == '__main__':
app.run(debug=True)