390 lines
14 KiB
Python
390 lines
14 KiB
Python
# SPDX-License-Identifier: LGPL-2.1-or-later
|
|
|
|
# ***************************************************************************
|
|
# * *
|
|
# * Copyright (c) 2023 Yorik van Havre <yorik@uncreated.net> *
|
|
# * *
|
|
# * This program is free software; you can redistribute it and/or modify *
|
|
# * it under the terms of the GNU Lesser General Public License (LGPL) *
|
|
# * as published by the Free Software Foundation; either version 2 of *
|
|
# * the License, or (at your option) any later version. *
|
|
# * for detail see the LICENCE text file. *
|
|
# * *
|
|
# * This program is distributed in the hope that it will be useful, *
|
|
# * but WITHOUT ANY WARRANTY; without even the implied warranty of *
|
|
# * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
|
|
# * GNU Library General Public License for more details. *
|
|
# * *
|
|
# * You should have received a copy of the GNU Library General Public *
|
|
# * License along with this program; if not, write to the Free Software *
|
|
# * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 *
|
|
# * USA *
|
|
# * *
|
|
# ***************************************************************************
|
|
|
|
"""This NativeIFC module deals with properties and property sets"""
|
|
|
|
|
|
import os
|
|
import re
|
|
|
|
import FreeCAD
|
|
|
|
from . import ifc_tools
|
|
|
|
translate = FreeCAD.Qt.translate
|
|
|
|
|
|
def has_psets(obj):
|
|
"""Returns True if an object has attached psets"""
|
|
|
|
element = ifc_tools.get_ifc_element(obj)
|
|
psets = getattr(element, "IsDefinedBy", [])
|
|
if psets and [p for p in psets if p.is_a("IfcRelDefinesByProperties")]:
|
|
# TODO verify too if these psets are not already there
|
|
return True
|
|
psets = getattr(element, "HasProperties", [])
|
|
if psets:
|
|
return True
|
|
return False
|
|
|
|
|
|
def get_psets(element):
|
|
"""Returns a dictionary of dictionaries representing the
|
|
properties of an element in the form:
|
|
{ pset_name : { property_name : IfcType(value), ... }, ... }"""
|
|
|
|
result = {}
|
|
psets = getattr(element, "IsDefinedBy", [])
|
|
psets = [p for p in psets if p.is_a("IfcRelDefinesByProperties")]
|
|
psets = [p.RelatingPropertyDefinition for p in psets]
|
|
if not psets:
|
|
psets = getattr(element, "HasProperties", [])
|
|
if not psets:
|
|
return result
|
|
for pset in psets:
|
|
pset_dict = {}
|
|
if pset.is_a("IfcPropertySet") and pset.HasProperties:
|
|
for prop in pset.HasProperties:
|
|
pset_dict[prop.Name] = str(prop.NominalValue)
|
|
if pset.is_a("IfcMaterialProperties") and pset.Properties:
|
|
for prop in pset.Properties:
|
|
pset_dict[prop.Name] = str(prop.NominalValue)
|
|
elif pset.is_a("IfcElementQuantity"):
|
|
# TODO implement quantities
|
|
pass
|
|
if pset_dict:
|
|
result[pset.Name] = pset_dict
|
|
return result
|
|
|
|
|
|
def get_pset(psetname, element):
|
|
"""Returns an IfcPropertySet with the given name"""
|
|
|
|
psets = getattr(element, "IsDefinedBy", [])
|
|
psets = [p for p in psets if p.is_a("IfcRelDefinesByProperties")]
|
|
for p in psets:
|
|
pset = p.RelatingPropertyDefinition
|
|
if pset.Name == psetname:
|
|
return pset
|
|
return None
|
|
|
|
|
|
def show_psets(obj):
|
|
"""Shows the psets attached to the given object as properties"""
|
|
|
|
element = ifc_tools.get_ifc_element(obj)
|
|
if not element:
|
|
return
|
|
psets = get_psets(element)
|
|
for gname, pset in psets.items():
|
|
for pname, pvalue in pset.items():
|
|
oname = pname
|
|
ptype, value = pvalue.split("(", 1)
|
|
value = value.strip(")")
|
|
value = value.strip("'")
|
|
pname = re.sub(r"[^0-9a-zA-Z]+", "", pname)
|
|
if pname[0].isdigit():
|
|
pname = "_" + pname
|
|
ttip = (
|
|
ptype + ":" + oname
|
|
) # setting IfcType:PropName as a tooltip to desambiguate
|
|
#while pname in obj.PropertiesList:
|
|
# print("DEBUG: property", pname, "(", value, ") already exists in", obj.Label)
|
|
# pname += "_"
|
|
ftype = None
|
|
if ptype in [
|
|
"IfcPositiveLengthMeasure",
|
|
"IfcLengthMeasure",
|
|
"IfcNonNegativeLengthMeasure",
|
|
]:
|
|
ftype = "App::PropertyDistance"
|
|
elif ptype in ["IfcVolumeMeasure"]:
|
|
ftype = "App::PropertyVolume"
|
|
elif ptype in ["IfcPositivePlaneAngleMeasure", "IfcPlaneAngleMeasure"]:
|
|
ftype = "App::PropertyAngle"
|
|
value = float(value)
|
|
while value > 360:
|
|
value = value - 360
|
|
elif ptype in ["IfcMassMeasure"]:
|
|
ftype = "App::PropertyMass"
|
|
elif ptype in ["IfcAreaMeasure"]:
|
|
ftype = "App::PropertyArea"
|
|
elif ptype in ["IfcCountMeasure", "IfcInteger"]:
|
|
ftype = "App::PropertyInteger"
|
|
value = int(value.strip("."))
|
|
elif ptype in ["IfcReal"]:
|
|
ftype = "App::PropertyFloat"
|
|
value = float(value)
|
|
elif ptype in ["IfcBoolean", "IfcLogical"]:
|
|
ftype = "App::PropertyBool"
|
|
if value in [".T."]:
|
|
value = True
|
|
else:
|
|
value = False
|
|
elif ptype in [
|
|
"IfcDateTime",
|
|
"IfcDate",
|
|
"IfcTime",
|
|
"IfcDuration",
|
|
"IfcTimeStamp",
|
|
]:
|
|
ftype = "App::PropertyTime"
|
|
elif isinstance(value, str) and "::" in value:
|
|
# FreeCAD-specific: split strings by :: delimiter
|
|
ftype = "App::PropertyStringList"
|
|
value = value.split("::")
|
|
else:
|
|
ftype = "App::PropertyString"
|
|
# print("DEBUG: setting",pname, ptype, value)
|
|
if ftype:
|
|
if pname in obj.PropertiesList \
|
|
and obj.getGroupOfProperty(pname) == gname:
|
|
if obj.getTypeOfProperty(pname) == ftype:
|
|
pass
|
|
if ftype == "App::PropertyString" \
|
|
and obj.getTypeOfProperty(pname) == "App::PropertyStringList":
|
|
value = [value]
|
|
else:
|
|
print(pname, gname, obj.PropertiesList)
|
|
obj.addProperty(ftype, pname, gname, ttip)
|
|
if pname in obj.PropertiesList:
|
|
setattr(obj, pname, value)
|
|
|
|
|
|
def edit_pset(obj, prop, value=None, force=False, ifcfile=None, element=None):
|
|
"""Edits the corresponding property. If force is True,
|
|
the property is created even if it has no value"""
|
|
|
|
pset = obj.getGroupOfProperty(prop)
|
|
ptype = obj.getDocumentationOfProperty(prop)
|
|
if value is None:
|
|
value = getattr(obj, prop)
|
|
if not ifcfile:
|
|
ifcfile = ifc_tools.get_ifcfile(obj)
|
|
if not ifcfile:
|
|
return
|
|
if not element:
|
|
element = ifc_tools.get_ifc_element(obj)
|
|
if not element:
|
|
return
|
|
pset_exist = get_psets(element)
|
|
target_prop = None
|
|
value_exist = None
|
|
|
|
# build prop name and type
|
|
if ptype.startswith("Ifc"):
|
|
if ":" in ptype:
|
|
target_prop = ptype.split(":", 1)[-1]
|
|
ptype = ptype.split(":", 1)[0]
|
|
else:
|
|
ptype = obj.getTypeIdOfProperty(prop)
|
|
if ptype == "App::PropertyDistance":
|
|
ptype = "IfcLengthMeasure"
|
|
elif ptype == "App::PropertyLength":
|
|
ptype = "IfcPositiveLengthMeasure"
|
|
elif ptype == "App::PropertyBool":
|
|
ptype = "IfcBoolean"
|
|
elif ptype == "App::PropertyInteger":
|
|
ptype = "IfcInteger"
|
|
elif ptype == "App::PropertyFloat":
|
|
ptype = "IfcReal"
|
|
elif ptype == "App::PropertyArea":
|
|
ptype = "IfcAreaMeasure"
|
|
else:
|
|
# default
|
|
ptype = "IfcLabel"
|
|
if not target_prop:
|
|
# test if the prop exists under different forms (uncameled, unslashed...)
|
|
prop = prop.rstrip("_")
|
|
prop_uncamel = re.sub(r"(\w)([A-Z])", r"\1 \2", prop)
|
|
prop_unslash = re.sub(r"(\w)([A-Z])", r"\1\/\2", prop)
|
|
if pset in pset_exist:
|
|
if prop in pset_exist[pset]:
|
|
target_prop = prop
|
|
elif prop_uncamel in pset_exist[pset]:
|
|
target_prop = prop_uncamel
|
|
elif prop_unslash in pset_exist[pset]:
|
|
target_prop = prop_unslash
|
|
if not target_prop:
|
|
target_prop = prop
|
|
|
|
# create pset if needed
|
|
if pset in pset_exist:
|
|
ifcpset = get_pset(pset, element)
|
|
if target_prop in pset_exist[pset]:
|
|
value_exist = pset_exist[pset][target_prop].split("(", 1)[1][:-1].strip("'")
|
|
else:
|
|
ifcpset = ifc_tools.api_run("pset.add_pset", ifcfile, product=element, name=pset)
|
|
|
|
# value conversions
|
|
if value_exist in [".F.", ".U."]:
|
|
value_exist = False
|
|
elif value_exist in [".T."]:
|
|
value_exist = True
|
|
elif isinstance(value, int):
|
|
if value_exist:
|
|
value_exist = int(value_exist.strip("."))
|
|
elif isinstance(value, float):
|
|
if value_exist:
|
|
value_exist = float(value_exist)
|
|
elif isinstance(value, FreeCAD.Units.Quantity):
|
|
if value_exist:
|
|
value_exist = float(value_exist)
|
|
if value.Unit.Type == "Angle":
|
|
if value_exist:
|
|
while value_exist > 360:
|
|
value_exist = value_exist - 360
|
|
value = value.getValueAs("deg")
|
|
elif value.Unit.Type == "Length":
|
|
value = value.getValueAs("mm").Value * ifc_tools.get_scale(ifcfile)
|
|
else:
|
|
print("DEBUG: unhandled quantity type:",value, value.Unit.Type)
|
|
return False
|
|
if value == value_exist:
|
|
return False
|
|
if not force and not value and not value_exist:
|
|
return False
|
|
FreeCAD.Console.PrintLog(
|
|
"IFC: property changed for "
|
|
+ obj.Label
|
|
+ " ("
|
|
+ str(element.id())
|
|
+ "): "
|
|
+ str(target_prop)
|
|
+ ": "
|
|
+ str(value_exist)
|
|
+ " ("
|
|
+ type(value_exist).__name__
|
|
+ ") -> "
|
|
+ str(value)
|
|
+ " ("
|
|
+ type(value).__name__
|
|
+ ")\n"
|
|
)
|
|
|
|
# run the change
|
|
# TODO the property type is automatically determined by ifcopenhell
|
|
# https://docs.ifcopenshell.org/autoapi/ifcopenshell/api/pset/edit_pset/index.html
|
|
# and is therefore wrong for Quantity types. Research a way to overcome that
|
|
ifc_tools.api_run(
|
|
"pset.edit_pset", ifcfile, pset=ifcpset, properties={target_prop: value}
|
|
)
|
|
# TODO manage quantities
|
|
return True
|
|
|
|
|
|
def load_psets(obj):
|
|
"""Recursively loads psets of child objects"""
|
|
|
|
show_psets(obj)
|
|
if isinstance(obj, FreeCAD.DocumentObject):
|
|
group = obj.Group
|
|
else:
|
|
group = obj.Objects
|
|
for child in group:
|
|
load_psets(child)
|
|
|
|
|
|
def add_pset(obj, psetname):
|
|
"""Adds a pset with the given name to the given object"""
|
|
|
|
ifcfile = ifc_tools.get_ifcfile(obj)
|
|
element = ifc_tools.get_ifc_element(obj)
|
|
if ifcfile and element:
|
|
pset = ifc_tools.api_run(
|
|
"pset.add_pset", ifcfile, product=element, name=psetname
|
|
)
|
|
return pset
|
|
|
|
|
|
def add_property(ifcfile, pset, name, value=""):
|
|
"""Adds a property with the given name to the given pset. The type is deduced from
|
|
the value: string is IfcLabel, True/False is IfcBoolean, number is IfcLengthMeasure.
|
|
To force a certain type, value can also be an IFC element such as IfcLabel"""
|
|
|
|
ifc_tools.api_run("pset.edit_pset", ifcfile, pset=pset, properties={name: value})
|
|
|
|
|
|
def get_freecad_type(ptype):
|
|
"""Returns a FreeCAD property type corresponding to an IFC property type"""
|
|
|
|
conv = read_properties_conversion()
|
|
for key, values in conv.items():
|
|
if ptype.lower() in [v.lower() for v in values.split(":")]:
|
|
return key
|
|
return "App::PropertyString"
|
|
|
|
|
|
def get_ifc_type(fctype):
|
|
"""Returns an IFC property type corresponding to a FreeCAD property type"""
|
|
|
|
conv = read_properties_conversion()
|
|
for key, values in conv.items():
|
|
if fctype.lower() == key.lower():
|
|
return values.split(":")[0]
|
|
return "IfcLabel"
|
|
|
|
|
|
def read_properties_conversion():
|
|
"""Reads the properties conversion table"""
|
|
|
|
import csv
|
|
csvfile = os.path.join(
|
|
FreeCAD.getResourceDir(), "Mod", "BIM", "Presets", "properties_conversion.csv"
|
|
)
|
|
result = {}
|
|
if os.path.exists(csvfile):
|
|
with open(csvfile, "r") as f:
|
|
reader = csv.reader(f, delimiter=",")
|
|
for row in reader:
|
|
result[row[0]] = row[1]
|
|
return result
|
|
|
|
|
|
def remove_property(obj, prop):
|
|
"""Removes a custom property"""
|
|
|
|
from . import ifc_tools
|
|
ifcfile = ifc_tools.get_ifcfile(obj)
|
|
if not ifcfile:
|
|
return
|
|
element = ifc_tools.get_ifc_element(obj, ifcfile)
|
|
if not element:
|
|
return
|
|
psets = get_psets(element)
|
|
for psetname, props in psets.items():
|
|
if prop in props:
|
|
pset = get_pset(psetname, element)
|
|
if pset:
|
|
FreeCAD.Console.PrintMessage(translate("BIM","Removing property")+": "+prop)
|
|
ifc_tools.api_run("pset.edit_pset", ifcfile, pset=pset, properties={prop: None})
|
|
if len(props) == 1:
|
|
# delete the pset too
|
|
FreeCAD.Console.PrintMessage(translate("BIM","Removing property set")+": "+psetname)
|
|
ifc_tools.api_run("pset.remove_pset", ifcfile, product=element, pset=pset)
|
|
|
|
|
|
# Quantity types
|
|
# https://ifc43-docs.standards.buildingsmart.org/IFC/RELEASE/IFC4x3/HTML/ifcsharedbldgelements/content.html#6.1.5-Quantity-Sets
|