mirror of
https://github.com/IfcOpenShell/IfcOpenShell.git
synced 2026-08-12 02:23:34 +00:00
htlcnn
548 lines
24 KiB
Python
548 lines
24 KiB
Python
from __future__ import division
|
|
from __future__ import print_function
|
|
import json
|
|
import ifcopenshell
|
|
import numpy as np
|
|
|
|
|
|
class IFC2CA:
|
|
def __init__(self, filename):
|
|
self.filename = filename
|
|
self.file = None
|
|
self.result = {}
|
|
self.warnings = []
|
|
self.tol = 1e-06
|
|
|
|
def convert(self):
|
|
self.file = ifcopenshell.open(self.filename)
|
|
for model in self.file.by_type("IfcStructuralAnalysisModel"):
|
|
elements = self.get_structural_items(model, item_type="IfcStructuralMember")
|
|
connections = self.get_structural_items(model, item_type="IfcStructuralConnection")
|
|
|
|
materialdb = []
|
|
materials = list(dict.fromkeys([e["material"] for e in elements]))
|
|
for mat in [mat for mat in materials if mat]:
|
|
id = int(mat.split("|")[1])
|
|
material = self.get_material_properties(self.file.by_id(id))
|
|
material["relatedElements"] = [
|
|
e["ifcName"] for e in elements if "material" in e and e["material"] == mat
|
|
]
|
|
materialdb.append(material)
|
|
|
|
profiledb = []
|
|
profiles = list(dict.fromkeys([e["profile"] for e in elements if "profile" in e]))
|
|
for prof in [prof for prof in profiles if prof]:
|
|
id = int(prof.split("|")[1])
|
|
profile = self.get_profile_properties(self.file.by_id(id))
|
|
profile["relatedElements"] = [e["ifcName"] for e in elements if "profile" in e and e["profile"] == prof]
|
|
profiledb.append(profile)
|
|
|
|
self.result = {
|
|
"ifcName": model.is_a() + "|" + str(model.id()),
|
|
"name": model.Name,
|
|
"id": model.GlobalId,
|
|
"elements": elements,
|
|
"connections": connections,
|
|
"db": {"materials": materialdb, "profiles": profiledb},
|
|
"warnings": self.warnings,
|
|
}
|
|
|
|
print('Model "%s" converted' % model.Name)
|
|
print("Number of elements: ", len(elements))
|
|
print("Number of connections: ", len(connections))
|
|
print("Number of materials: ", len(materialdb))
|
|
print("Number of profiles: ", len(profiledb))
|
|
print("")
|
|
|
|
break
|
|
|
|
def get_structural_items(self, model, item_type="IfcStructuralItem"):
|
|
items = []
|
|
for group in model.IsGroupedBy:
|
|
for item in group.RelatedObjects:
|
|
if not item.is_a(item_type):
|
|
continue
|
|
data = self.get_item_data(item)
|
|
if data:
|
|
items.append(data)
|
|
return items
|
|
|
|
def get_item_data(self, item):
|
|
transformation = self.get_transformation(item.ObjectPlacement)
|
|
|
|
if item.is_a("IfcStructuralCurveMember"):
|
|
representation = self.get_representation(item, "Edge")
|
|
material_profile = self.get_material_profile(item)
|
|
if not representation:
|
|
self.warnings.append(
|
|
"No representation defined for %s. Member excluded" % (item.is_a() + "|" + str(item.id()))
|
|
)
|
|
return
|
|
if not material_profile:
|
|
self.warnings.append("No material defined for in %s" % (item.is_a() + "|" + str(item.id())))
|
|
self.warnings.append("No profile defined for in %s" % (item.is_a() + "|" + str(item.id())))
|
|
materialId = None
|
|
profileId = None
|
|
else:
|
|
material = material_profile.Material
|
|
materialId = material.is_a() + "|" + str(material.id())
|
|
profile = material_profile.Profile
|
|
profileId = profile.is_a() + "|" + str(profile.id())
|
|
|
|
geometry = self.get_geometry(representation)
|
|
orientation = self.get_1D_orientation(geometry, item.Axis)
|
|
connections = self.get_connection_data(item.ConnectedBy)
|
|
for conn in connections:
|
|
if not conn["orientation"]:
|
|
conn["orientation"] = orientation
|
|
# --> Correct pointOnElement for eccentricity connection for ETABS files
|
|
length = np.linalg.norm(np.array(geometry[1]) - np.array(geometry[0]))
|
|
for c in connections:
|
|
if c["eccentricity"]:
|
|
if np.linalg.norm(np.array(c["eccentricity"]["pointOnElement"])) > length + self.tol:
|
|
print(np.linalg.norm(np.array(c["eccentricity"]["pointOnElement"])), ">", length)
|
|
self.warnings.append("Eccentricity in %s corrected" % (item.is_a() + "|" + str(item.id())))
|
|
c["eccentricity"]["pointOnElement"][0] = length
|
|
# End <--
|
|
if transformation:
|
|
geometry = self.transform_vectors(geometry, transformation)
|
|
orientation = self.transform_vectors(orientation, transformation, include_translation=False)
|
|
for c in connections:
|
|
c["orientation"] = self.transform_vectors(
|
|
c["orientation"], transformation, include_translation=False
|
|
)
|
|
if c["eccentricity"]:
|
|
c["eccentricity"]["vector"] = self.transform_vectors(
|
|
c["eccentricity"]["vector"], transformation, include_translation=False
|
|
)
|
|
|
|
return {
|
|
"ifcName": item.is_a() + "|" + str(item.id()),
|
|
"name": item.Name,
|
|
"id": item.GlobalId,
|
|
"geometryType": "line",
|
|
"predefinedType": item.PredefinedType,
|
|
"geometry": geometry,
|
|
"orientation": orientation,
|
|
"material": materialId,
|
|
"profile": profileId,
|
|
"connections": connections,
|
|
}
|
|
|
|
elif item.is_a("IfcStructuralSurfaceMember"):
|
|
representation = self.get_representation(item, "Face")
|
|
material = self.get_material_profile(item)
|
|
if not representation:
|
|
self.warnings.append(
|
|
"No representation defined for %s. Member excluded" % (item.is_a() + "|" + str(item.id()))
|
|
)
|
|
return
|
|
if not material:
|
|
self.warnings.append("No material defined for in %s" % (item.is_a() + "|" + str(item.id())))
|
|
materialId = None
|
|
else:
|
|
materialId = material.is_a() + "|" + str(material.id())
|
|
|
|
geometry = self.get_geometry(representation)
|
|
orientation = self.get_2D_orientation(representation)
|
|
connections = self.get_connection_data(item.ConnectedBy)
|
|
for conn in connections:
|
|
if not conn["orientation"]:
|
|
conn["orientation"] = orientation
|
|
if transformation:
|
|
geometry = self.transform_vectors(geometry, transformation)
|
|
orientation = self.transform_vectors(orientation, transformation, include_translation=False)
|
|
for c in connections:
|
|
c["orientation"] = self.transform_vectors(
|
|
c["orientation"], transformation, include_translation=False
|
|
)
|
|
|
|
return {
|
|
"ifcName": item.is_a() + "|" + str(item.id()),
|
|
"name": item.Name,
|
|
"id": item.GlobalId,
|
|
"geometryType": "surface",
|
|
"predefinedType": item.PredefinedType,
|
|
"thickness": item.Thickness,
|
|
"geometry": geometry,
|
|
"orientation": orientation,
|
|
"material": materialId,
|
|
"connections": connections,
|
|
}
|
|
|
|
elif item.is_a("IfcStructuralPointConnection"):
|
|
representation = self.get_representation(item, "Vertex")
|
|
if not representation:
|
|
self.warnings.append(
|
|
"No representation defined for %s. Connection excluded" % (item.is_a() + "|" + str(item.id()))
|
|
)
|
|
return
|
|
|
|
geometry = self.get_geometry(representation)
|
|
orientation = self.get_0D_orientation(item.ConditionCoordinateSystem)
|
|
if not orientation:
|
|
orientation = np.eye(3).tolist()
|
|
if transformation:
|
|
geometry = self.transform_vectors(geometry, transformation)
|
|
orientation = self.transform_vectors(orientation, transformation, include_translation=False)
|
|
|
|
return {
|
|
"ifcName": item.is_a() + "|" + str(item.id()),
|
|
"name": item.Name,
|
|
"id": item.GlobalId,
|
|
"geometryType": "point",
|
|
"geometry": geometry,
|
|
"orientation": orientation,
|
|
"appliedCondition": self.get_connection_input(item, "point"),
|
|
"relatedElements": [con.is_a() + "|" + str(con.id()) for con in item.ConnectsStructuralMembers],
|
|
}
|
|
|
|
elif item.is_a("IfcStructuralCurveConnection"):
|
|
representation = self.get_representation(item, "Edge")
|
|
if not representation:
|
|
self.warnings.append(
|
|
"No representation defined for %s. Connection excluded" % (item.is_a() + "|" + str(item.id()))
|
|
)
|
|
return
|
|
|
|
geometry = self.get_geometry(representation)
|
|
orientation = self.get_1D_orientation(geometry, item.Axis)
|
|
if not orientation:
|
|
orientation = np.eye(3).tolist()
|
|
if transformation:
|
|
geometry = self.transform_vectors(geometry, transformation)
|
|
orientation = self.transform_vectors(orientation, transformation, include_translation=False)
|
|
|
|
return {
|
|
"ifcName": item.is_a() + "|" + str(item.id()),
|
|
"name": item.Name,
|
|
"id": item.GlobalId,
|
|
"geometryType": "line",
|
|
"geometry": geometry,
|
|
"orientation": orientation,
|
|
"appliedCondition": self.get_connection_input(item, "line"),
|
|
"relatedElements": [con.is_a() + "|" + str(con.id()) for con in item.ConnectsStructuralMembers],
|
|
}
|
|
|
|
def get_transformation(self, placement):
|
|
if not placement:
|
|
return None
|
|
if placement.is_a("IfcLocalPlacement"):
|
|
if placement.PlacementRelTo:
|
|
print("Warning! Object Placement with PlacementRelTo attribute is not supported and will be neglected")
|
|
axes = placement.RelativePlacement
|
|
location = np.array(self.get_coordinate(axes.Location))
|
|
if axes.Axis and axes.RefDirection:
|
|
xAxis = np.array(axes.RefDirection.DirectionRatios) # this can be not accurate (in the xz plane)
|
|
zAxis = np.array(axes.Axis.DirectionRatios)
|
|
zAxis /= np.linalg.norm(zAxis)
|
|
yAxis = np.cross(zAxis, xAxis)
|
|
yAxis /= np.linalg.norm(yAxis)
|
|
xAxis = np.cross(yAxis, zAxis)
|
|
xAxis /= np.linalg.norm(xAxis)
|
|
else:
|
|
if np.allclose(location, np.array([0.0, 0.0, 0.0])):
|
|
return None
|
|
xAxis = np.array([1.0, 0.0, 0.0])
|
|
yAxis = np.array([0.0, 1.0, 0.0])
|
|
zAxis = np.array([0.0, 0.0, 1.0])
|
|
if (
|
|
np.allclose(location, np.array([0.0, 0.0, 0.0]))
|
|
and np.allclose(xAxis, np.array([1.0, 0.0, 0.0]))
|
|
and np.allclose(yAxis, np.array([0.0, 1.0, 0.0]))
|
|
and np.allclose(zAxis, np.array([0.0, 0.0, 1.0]))
|
|
):
|
|
return None
|
|
return {"location": location, "rotationMatrix": np.array([xAxis, yAxis, zAxis]).transpose()}
|
|
else:
|
|
print(
|
|
"Warning! Object Placement is of type %s, which is not supported. Default considered" % placement.is_a()
|
|
)
|
|
return None
|
|
|
|
def get_representation(self, element, rep_type):
|
|
if not element.Representation:
|
|
return None
|
|
for representation in element.Representation.Representations:
|
|
rep = self.get_specific_representation(representation, "Reference", rep_type)
|
|
if rep:
|
|
return rep
|
|
else:
|
|
# print('Trying without rep identifier')
|
|
for representation in element.Representation.Representations:
|
|
rep = self.get_specific_representation(representation, None, rep_type)
|
|
if rep:
|
|
return rep
|
|
|
|
def get_specific_representation(self, representation, rep_id, rep_type):
|
|
if (
|
|
representation.RepresentationIdentifier == rep_id or rep_id is None
|
|
) and representation.RepresentationType == rep_type:
|
|
return representation
|
|
if representation.RepresentationType == "MappedRepresentation":
|
|
return self.get_specific_representation(
|
|
representation.Items[0].MappingSource.MappedRepresentation, rep_id, rep_type
|
|
)
|
|
|
|
def get_geometry(self, representation):
|
|
# Maybe IfcOpenShell can use create_shape here to simplify this, but
|
|
# supposedly structural models are very simple anyway, so perhaps we
|
|
# can do without it.
|
|
item = representation.Items[0]
|
|
if item.is_a("IfcEdge"):
|
|
return [
|
|
self.get_coordinate(item.EdgeStart.VertexGeometry),
|
|
self.get_coordinate(item.EdgeEnd.VertexGeometry),
|
|
]
|
|
|
|
elif item.is_a("IfcFaceSurface"):
|
|
edges = item.Bounds[0].Bound.EdgeList
|
|
coords = []
|
|
for edge in edges:
|
|
coords.append(self.get_coordinate(edge.EdgeElement.EdgeStart.VertexGeometry))
|
|
return coords
|
|
|
|
elif item.is_a("IfcVertexPoint"):
|
|
return self.get_coordinate(item.VertexGeometry)
|
|
|
|
def get_coordinate(self, point):
|
|
if point.is_a("IfcCartesianPoint"):
|
|
return list(point.Coordinates)
|
|
|
|
def get_0D_orientation(self, axes):
|
|
if axes and axes.Axis and axes.RefDirection:
|
|
xAxis = np.array(
|
|
axes.RefDirection.DirectionRatios
|
|
) # this can be not strictly perpendicular (in the xz plane)
|
|
zAxis = np.array(axes.Axis.DirectionRatios)
|
|
zAxis /= np.linalg.norm(zAxis)
|
|
yAxis = np.cross(zAxis, xAxis)
|
|
yAxis /= np.linalg.norm(yAxis)
|
|
xAxis = np.cross(yAxis, zAxis)
|
|
xAxis /= np.linalg.norm(xAxis)
|
|
|
|
return [xAxis.tolist(), yAxis.tolist(), zAxis.tolist()]
|
|
else: # return None and copy the elements orientation
|
|
return None
|
|
|
|
def get_1D_orientation(self, geometry, zAxis):
|
|
xAxis = np.array(geometry[1]) - np.array(geometry[0])
|
|
xAxis /= np.linalg.norm(xAxis)
|
|
zAxis = np.array(zAxis.DirectionRatios) # this can be not strictly perpendicular (in the xz plane)
|
|
yAxis = np.cross(zAxis, xAxis)
|
|
yAxis /= np.linalg.norm(yAxis)
|
|
zAxis = np.cross(xAxis, yAxis)
|
|
zAxis /= np.linalg.norm(zAxis)
|
|
|
|
return [xAxis.tolist(), yAxis.tolist(), zAxis.tolist()]
|
|
|
|
def get_2D_orientation(self, representation):
|
|
item = representation.Items[0]
|
|
if item.is_a("IfcFaceSurface"):
|
|
item.SameSense
|
|
axes = item.FaceSurface.Position
|
|
orientation = self.get_0D_orientation(axes)
|
|
if not item.SameSense:
|
|
orientation = [[-v for v in vec] for vec in orientation]
|
|
return orientation
|
|
|
|
def transform_vectors(self, geometry, trsf, include_translation=True):
|
|
if not any(isinstance(el, list) for el in geometry): # single point which contains no list
|
|
geometry = [geometry]
|
|
globalGeometry = []
|
|
|
|
for p in geometry:
|
|
gp = trsf["rotationMatrix"].dot(np.array(p))
|
|
if include_translation:
|
|
gp += trsf["location"]
|
|
globalGeometry.append(gp.tolist())
|
|
|
|
if len(globalGeometry) == 1: # single point
|
|
globalGeometry = globalGeometry[0]
|
|
|
|
return globalGeometry
|
|
|
|
def get_material_profile(self, element):
|
|
if not element.HasAssociations:
|
|
return None
|
|
for association in element.HasAssociations:
|
|
if not association.is_a("IfcRelAssociatesMaterial"):
|
|
continue
|
|
material = association.RelatingMaterial
|
|
if material.is_a("IfcMaterialProfileSet"):
|
|
# For now, we only deal with a single profile
|
|
return material.MaterialProfiles[0]
|
|
if material.is_a("IfcMaterialProfileSetUsage"):
|
|
return material.ForProfileSet.MaterialProfiles[0]
|
|
if material.is_a("IfcMaterial"):
|
|
return material
|
|
|
|
def get_material_properties(self, material):
|
|
psets = material.HasProperties
|
|
|
|
if self.get_pset_properties(psets, "Pset_MaterialMechanical"):
|
|
mechProps = self.get_pset_properties(psets, "Pset_MaterialMechanical")
|
|
else:
|
|
mechProps = self.get_pset_properties(psets, None)
|
|
|
|
if self.get_pset_properties(psets, "Pset_MaterialCommon"):
|
|
commonProps = self.get_pset_properties(psets, "Pset_MaterialCommon")
|
|
else:
|
|
commonProps = self.get_pset_properties(psets, None)
|
|
|
|
return {
|
|
"ifcName": material.is_a() + "|" + str(material.id()),
|
|
"name": material.Name,
|
|
"category": material.Category,
|
|
"mechProps": mechProps,
|
|
"commonProps": commonProps,
|
|
}
|
|
|
|
def get_pset_property(self, psets, pset_name, prop_name):
|
|
for pset in psets:
|
|
if pset.Name == pset_name or pset_name is None:
|
|
for prop in pset.Properties:
|
|
if prop.Name == prop_name:
|
|
return prop.NominalValue.wrappedValue
|
|
|
|
def get_pset_properties(self, psets, pset_name):
|
|
for pset in psets:
|
|
if pset.Name == pset_name or pset_name is None:
|
|
d = {}
|
|
for prop in pset.Properties:
|
|
propName = prop.Name[0].lower() + prop.Name[1:]
|
|
d[propName] = prop.NominalValue.wrappedValue
|
|
return d
|
|
|
|
def get_profile_properties(self, profile):
|
|
if profile.is_a("IfcRectangleProfileDef"):
|
|
return {
|
|
"ifcName": profile.is_a() + "|" + str(profile.id()),
|
|
"profileName": profile.ProfileName,
|
|
"profileType": profile.ProfileType,
|
|
"profileShape": "rectangular",
|
|
"xDim": profile.XDim,
|
|
"yDim": profile.YDim,
|
|
}
|
|
|
|
if profile.is_a("IfcIShapeProfileDef"):
|
|
psets = profile.HasProperties
|
|
|
|
if self.get_pset_properties(psets, "Pset_ProfileMechanical"):
|
|
mechProps = self.get_pset_properties(psets, "Pset_ProfileMechanical")
|
|
else:
|
|
mechProps = self.get_i_section_properties(profile, "iSymmetrical")
|
|
|
|
return {
|
|
"ifcName": profile.is_a() + "|" + str(profile.id()),
|
|
"profileName": profile.ProfileName,
|
|
"profileType": profile.ProfileType,
|
|
"profileShape": "iSymmetrical",
|
|
"mechProps": mechProps,
|
|
"commonProps": {
|
|
"flangeThickness": profile.FlangeThickness,
|
|
"webThickness": profile.WebThickness,
|
|
"overallDepth": profile.OverallDepth,
|
|
"overallWidth": profile.OverallWidth,
|
|
"filletRadius": profile.FilletRadius,
|
|
},
|
|
}
|
|
|
|
def get_connection_data(self, itemList):
|
|
return [
|
|
{
|
|
"ifcName": rel.is_a() + "|" + str(rel.id()),
|
|
"id": rel.GlobalId,
|
|
"relatingElement": rel.RelatingStructuralMember.is_a() + "|" + str(rel.RelatingStructuralMember.id()),
|
|
"relatedConnection": rel.RelatedStructuralConnection.is_a()
|
|
+ "|"
|
|
+ str(rel.RelatedStructuralConnection.id()),
|
|
"orientation": self.get_0D_orientation(rel.ConditionCoordinateSystem),
|
|
"appliedCondition": self.get_connection_input(
|
|
rel, self.get_geometry_type_from_connection(rel.RelatedStructuralConnection)
|
|
),
|
|
"eccentricity": None
|
|
if not rel.is_a("IfcRelConnectsWithEccentricity")
|
|
else {
|
|
"vector": [
|
|
0.0
|
|
if not rel.ConnectionConstraint.EccentricityInX
|
|
else rel.ConnectionConstraint.EccentricityInX,
|
|
0.0
|
|
if not rel.ConnectionConstraint.EccentricityInY
|
|
else rel.ConnectionConstraint.EccentricityInY,
|
|
0.0
|
|
if not rel.ConnectionConstraint.EccentricityInZ
|
|
else rel.ConnectionConstraint.EccentricityInZ,
|
|
],
|
|
"pointOnElement": self.get_coordinate(rel.ConnectionConstraint.PointOnRelatingElement),
|
|
},
|
|
}
|
|
for rel in itemList
|
|
]
|
|
|
|
def get_geometry_type_from_connection(self, connection):
|
|
if connection.is_a("IfcStructuralPointConnection"):
|
|
return "point"
|
|
if connection.is_a("IfcStructuralCurveConnection"):
|
|
return "line"
|
|
if connection.is_a("IfcStructuralSurfaceConnection"):
|
|
return "surface"
|
|
|
|
def get_connection_input(self, connection, geometryType):
|
|
if connection.AppliedCondition:
|
|
if geometryType == "point":
|
|
return {
|
|
"dx": connection.AppliedCondition.TranslationalStiffnessX.wrappedValue,
|
|
"dy": connection.AppliedCondition.TranslationalStiffnessY.wrappedValue,
|
|
"dz": connection.AppliedCondition.TranslationalStiffnessZ.wrappedValue,
|
|
"drx": connection.AppliedCondition.RotationalStiffnessX.wrappedValue,
|
|
"dry": connection.AppliedCondition.RotationalStiffnessY.wrappedValue,
|
|
"drz": connection.AppliedCondition.RotationalStiffnessZ.wrappedValue,
|
|
}
|
|
|
|
if geometryType == "line":
|
|
return {
|
|
"dx": connection.AppliedCondition.TranslationalStiffnessByLengthX.wrappedValue,
|
|
"dy": connection.AppliedCondition.TranslationalStiffnessByLengthY.wrappedValue,
|
|
"dz": connection.AppliedCondition.TranslationalStiffnessByLengthZ.wrappedValue,
|
|
"drx": connection.AppliedCondition.RotationalStiffnessByLengthX.wrappedValue,
|
|
"dry": connection.AppliedCondition.RotationalStiffnessByLengthY.wrappedValue,
|
|
"drz": connection.AppliedCondition.RotationalStiffnessByLengthZ.wrappedValue,
|
|
}
|
|
|
|
if geometryType == "surface":
|
|
return {
|
|
"dx": connection.AppliedCondition.TranslationalStiffnessByAreaX.wrappedValue,
|
|
"dy": connection.AppliedCondition.TranslationalStiffnessByAreaY.wrappedValue,
|
|
"dz": connection.AppliedCondition.TranslationalStiffnessByAreaZ.wrappedValue,
|
|
}
|
|
|
|
return connection.AppliedCondition
|
|
|
|
def get_i_section_properties(self, profile, profileShape):
|
|
if profileShape == "iSymmetrical":
|
|
tf = profile.FlangeThickness
|
|
tw = profile.WebThickness
|
|
h = profile.OverallDepth
|
|
b = profile.OverallWidth
|
|
|
|
A = b * h - (b - tw) * (h - 2 * tf)
|
|
Iy = b * (h ** 3) / 12 - (b - tw) * ((h - 2 * tf) ** 3) / 12
|
|
Iz = (2 * tf) * (b ** 3) / 12 + (h - 2 * tf) * (tw ** 3) / 12
|
|
Jx = 1 / 3 * ((h - tf) * (tw ** 3) + 2 * b * (tf ** 3))
|
|
|
|
return {"crossSectionArea": A, "momentOfInertiaY": Iy, "momentOfInertiaZ": Iz, "torsionalConstantX": Jx}
|
|
|
|
|
|
if __name__ == "__main__":
|
|
fileNames = ["cantilever_01", "portal_01", "grid_of_beams", "slab_01", "structure_01"]
|
|
files = fileNames
|
|
|
|
for fileName in files:
|
|
BASE_PATH = "/home/jesusbill/Dev-Projects/github.com/IfcOpenShell/analysis-models/ifcFiles/"
|
|
ifc2ca = IFC2CA(BASE_PATH + fileName + ".ifc")
|
|
ifc2ca.convert()
|
|
with open(BASE_PATH + fileName + ".json", "w") as f:
|
|
f.write(json.dumps(ifc2ca.result, indent=4))
|