def step_impl(context, number):
number = assert_number(number)
if IfcFile.get().schema == 'IFC2X3':
for site in IfcFile.get().by_type('IfcSite'):
assert_pset(site, 'EPset_MapConversion', 'Scale', number)
return
check_ifc4_geolocation('IfcMapConversion', 'Scale', number)
def step_impl(context, number):
number = assert_number(number)
if IfcFile.get().schema == "IFC2X3":
for site in IfcFile.get().by_type("IfcSite"):
assert_pset(site, "EPset_MapConversion", "Scale", number)
return
check_ifc4_geolocation("IfcMapConversion", "Scale", number)
def step_impl(context, coordinate_reference_name):
if IfcFile.get().schema == 'IFC2X3':
for site in IfcFile.get().by_type('IfcSite'):
assert_pset(site, 'EPset_ProjectedCRS', 'VerticalDatum',
coordinate_reference_name)
return
check_ifc4_geolocation('IfcProjectedCRS', 'VerticalDatum',
coordinate_reference_name)
def step_impl(context, ifc_class, property_path, pattern):
import re
pset_name, property_name = property_path.split('.')
elements = IfcFile.get().by_type(ifc_class)
for element in elements:
prop = IfcFile.get_property(element, pset_name, property_name)
if not prop:
assert False
# For now, we only check single values
if prop.is_a('IfcPropertySingleValue'):
if not (prop.NominalValue \
and re.search(pattern, prop.NominalValue.wrappedValue)):
assert False
def step_impl(context, unit):
if IfcFile.get().schema == "IFC2X3":
for site in IfcFile.get().by_type("IfcSite"):
assert_pset(site, "EPset_ProjectedCRS", "MapUnit", unit)
return
actual_value = check_ifc4_geolocation("IfcProjectedCRS", "MapUnit", should_assert=False)
if not actual_value:
assert False, "A unit was not provided in the projected CRS"
if actual_value.is_a("IfcSIUnit"):
prefix = actual_value.Prefix if actual_value.Prefix else ""
actual_value = prefix + actual_value.Name
elif actual_value.is_a("IfcConversionBasedUnit"):
actual_value = actual_value.Name
assert actual_value == unit, 'We expected a value of "{}" but instead got "{}"'.format(unit, actual_value)
def step_impl(context, ifc_class, attribute_name, attribute_value):
elements = IfcFile.get().by_type(ifc_class)
for element in elements:
if hasattr(element, attribute_name) and getattr(
element, attribute_name) == attribute_value:
return
assert False
def step_impl(context, ifc_class, pattern):
import re
elements = IfcFile.get().by_type(ifc_class)
for element in elements:
if not re.search(pattern, element.Name):
assert False
def step_impl(context, ifc_class, attribute, pattern):
import re
elements = IfcFile.get().by_type(ifc_class)
for element in elements:
value = getattr(element, attribute)
print(f'Checking value "{value}" for {element}')
assert re.search(pattern, value)
def step_impl(context, ifc_class, representation_class):
def is_item_a_representation(item, representation):
if "/" in representation:
for cls in representation.split("/"):
if item.is_a(cls):
return True
elif item.is_a(representation):
return True
elements = IfcFile.get().by_type(ifc_class)
for element in elements:
if not element.Representation:
continue
has_representation = False
for representation in element.Representation.Representations:
for item in representation.Items:
if item.is_a("IfcMappedItem"):
# We only check one more level deep.
for item2 in item.MappingSource.MappedRepresentation.Items:
if is_item_a_representation(item2,
representation_class):
has_representation = True
else:
if is_item_a_representation(item, representation_class):
has_representation = True
if not has_representation:
assert False
def get_classification(name):
classifications = [
c for c in IfcFile.get().by_type('IfcClassification') if c.Name == name
]
if len(classifications) != 1:
assert False, f'The classification "{name}" was not found'
return classifications[0]
def check_ifc4_geolocation(entity_name,
prop_name=None,
value=None,
should_assert=True):
if entity_name not in IfcFile.bookmarks:
has_entity = False
project = IfcFile.get().by_type('IfcProject')[0]
for context in project.RepresentationContexts:
if entity_name == 'IfcMapConversion':
if context.is_a('IfcGeometricRepresentationContext') \
and context.ContextType == 'Model' \
and context.HasCoordinateOperation:
IfcFile.bookmarks[
entity_name] = context.HasCoordinateOperation[0]
has_entity = True
elif entity_name == 'IfcProjectedCRS':
if context.is_a('IfcGeometricRepresentationContext') \
and context.ContextType == 'Model' \
and context.HasCoordinateOperation \
and context.HasCoordinateOperation[0].TargetCRS:
IfcFile.bookmarks[
entity_name] = context.HasCoordinateOperation[
0].TargetCRS
has_entity = True
if not has_entity:
assert False, 'No model geometric representation contexts refer to an {}'.format(
entity_name)
if not prop_name:
return
actual_value = getattr(IfcFile.bookmarks[entity_name], prop_name)
if should_assert:
assert actual_value == value, 'We expected a value of "{}" but instead got "{}"'.format(
value, actual_value)
else:
return actual_value
def step_impl(context, guid, number):
number = assert_number(number)
site = IfcFile.by_guid(guid)
if not site.is_a("IfcSite"):
assert False, "The element {} is not an IfcSite".format(site)
ref = assert_attribute(site, "RefLatitude")
number = ifcopenshell.util.geolocation.dd2dms(number, use_ms=(len(ref) == 4))
assert_attribute(site, "RefLatitude", number)
def step_impl(context, guid, easting, northing, elevation):
if IfcFile.get().schema == 'IFC2X3':
if element.is_a('IfcSite'):
site = element
else:
potential_sites = [
s for s in get_containing_spatial_elements(element)
if s.is_a('IfcSite')
]
if potential_sites:
site = potential_sites[0]
else:
assert False, 'The datum element does not belong to a geolocated site'
map_conversion = assert_pset(site, 'EPset_MapConversion')
else:
map_conversion = IfcFile.get().by_type('IfcMapConversion')
if map_conversion:
map_conversion = map_conversion[0].get_info()
else:
assert False, 'No map conversion was found in the file'
element = IfcFile.by_guid(guid)
if not element.ObjectPlacement:
assert False, 'The element does not have an object placement: {}'.format(
element)
m = get_local_placement(element.ObjectPlacement)
e, n, h = ifcopenshell.util.geolocation.xyz2enh(
m[0][3],
m[1][3],
m[2][3],
float(map_conversion['Eastings']),
float(map_conversion['Northings']),
float(map_conversion['OrthogonalHeight']),
float(map_conversion['XAxisAbscissa']),
float(map_conversion['XAxisOrdinate']),
float(map_conversion['Scale']),
)
element_x = round(e, get_decimal_points(easting))
element_y = round(n, get_decimal_points(northing))
element_z = round(h, get_decimal_points(elevation))
expected_placement = (assert_number(easting), assert_number(northing),
assert_number(elevation))
if (element_x, element_y, element_z) != expected_placement:
assert False, 'The element {} is meant to have a location of {} but instead we found {}'.format(
element, expected_placement, (element_x, element_y, element_z))
def step_impl(context, number):
number = assert_number(number)
if IfcFile.get().schema == "IFC2X3":
return check_ifc2x3_geolocation("EPset_MapConversion", "Height", number)
abscissa = check_ifc4_geolocation("IfcMapConversion", "XAxisAbscissa", should_assert=False)
ordinate = check_ifc4_geolocation("IfcMapConversion", "XAxisOrdinate", should_assert=False)
actual_value = round(ifcopenshell.util.geolocation.xy2angle(abscissa, ordinate), 3)
value = round(number, 3)
assert actual_value == value, 'We expected a value of "{}" but instead got "{}"'.format(value, actual_value)
def check_geocode_address(guid, spatial_type, name, value):
element = IfcFile.by_guid(guid)
ifc_class = get_ifc_class_from_spatial_type(spatial_type)
assert_type(element, ifc_class)
if ifc_class == "IfcSite":
address_name = "SiteAddress"
elif ifc_class == "IfcBuilding":
address_name = "BuildingAddress"
assert_attribute(element, address_name)
assert_attribute(getattr(element, address_name), name, value)
def get_subcontext(identifier, type, target_view):
project = IfcFile.get().by_type("IfcProject")[0]
for rep_context in project.RepresentationContexts:
for subcontext in rep_context.HasSubContexts:
if (subcontext.ContextIdentifier == identifier
and subcontext.ContextType == type
and subcontext.TargetView == target_view):
return True
assert False, "The subcontext with identifier {}, type {}, and target view {} could not be found".format(
identifier, type, target_view)
def step_impl(context, guid, predefined_type):
element = IfcFile.by_guid(guid)
if (hasattr(element, "PredefinedType")
and element.PredefinedType == "USERDEFINED"
and hasattr(element, "ObjectType")):
assert_attribute(element, "ObjectType", predefined_type)
elif hasattr(element, "PredefinedType"):
assert_attribute(element, "PredefinedType", predefined_type)
else:
assert False, "The element {} does not have a PredefinedType or ObjectType attribute".format(
element)
def step_impl(context, guid, predefined_type):
element = IfcFile.by_guid(guid)
if hasattr(element, 'PredefinedType') \
and element.PredefinedType == 'USERDEFINED' \
and hasattr(element,'ObjectType'):
assert_attribute(element, 'ObjectType', predefined_type)
elif hasattr(element, 'PredefinedType'):
assert_attribute(element, 'PredefinedType', predefined_type)
else:
assert False, 'The element {} does not have a PredefinedType or ObjectType attribute'.format(
element)
def step_impl(context, ifc_class, qto_name, quantity_name):
elements = IfcFile.get().by_type(ifc_class)
for element in elements:
is_successful = False
if not element.IsDefinedBy:
assert False
for relationship in element.IsDefinedBy:
if relationship.RelatingPropertyDefinition.Name == qto_name:
for quantity in relationship.RelatingPropertyDefinition.Quantities:
if quantity.Name == quantity_name:
is_successful = True
if not is_successful:
assert False
def step_impl(context, guid, x, y, z):
element = IfcFile.by_guid(guid)
if not element.ObjectPlacement:
assert False, 'The element does not have an object placement: {}'.format(
element)
m = get_local_placement(element.ObjectPlacement)
element_x = round(m[0][3], get_decimal_points(x))
element_y = round(m[1][3], get_decimal_points(y))
element_z = round(m[2][3], get_decimal_points(z))
expected_placement = (assert_number(x), assert_number(y), assert_number(z))
if (element_x, element_y, element_z) != expected_placement:
assert False, 'The element {} is meant to have a location of {} but instead we found {}'.format(
element, expected_placement, (element_x, element_y, element_z))
def step_impl(context, number):
number = int(number)
errors = []
for element in IfcFile.get().by_type('IfcElement'):
if not element.Representation:
continue
total_polygons = 0
tree = IfcFile.get().traverse(element.Representation)
for e in tree:
if e.is_a('IfcFace'):
total_polygons += 1
elif e.is_a('IfcPolygonalFaceSet'):
total_polygons += len(e.Faces)
elif e.is_a('IfcTriangulatedFaceSet'):
total_polygons += len(e.CoordIndex)
if total_polygons > number:
errors.append((total_polygons, element))
if errors:
message = 'The following {} elements are over 500 polygons:\n'.format(len(errors))
for error in errors:
message += 'Polygons: {} - {}\n'.format(error[0], error[1])
assert False, message
def step_impl(context, ifc_class, attributes, list_file):
import csv
values = []
with open(list_file) as csvfile:
reader = csv.reader(csvfile)
for row in reader:
values.append(row)
elements = IfcFile.get().by_type(ifc_class)
for element in elements:
attribute_values = []
for attribute in attributes.split(','):
if not hasattr(element, attribute):
assert False, f'Failed at element {element.GlobalId}'
attribute_values.append(getattr(element, attribute))
if attribute_values not in values:
assert False, f'Failed at element {element.GlobalId}'
def step_impl(context, guid, identification, reference_name):
element = IfcFile.by_guid(guid)
if not hasattr(element, 'HasAssociations') or not element.HasAssociations:
assert False, f'The element {element} has no associations.'
references = [
a.RelatingClassification for a in element.HasAssociations
if a.is_a('IfcRelAssociatesClassification')
]
if not references:
assert False, f'The element {element} has no associated classification references.'
is_success = False
for reference in references:
try:
assert_attribute(reference, 'Identification', identification)
assert_attribute(reference, 'Name', reference_name)
is_success = True
except:
pass
if not is_success:
assert False, 'No classification references met the requirement for an identification {} and name {} for the element {}. The references we found were: {}'.format(
identification, reference_name, element, references)
def step_impl(context, ifc_class, attribute):
elements = IfcFile.get().by_type(ifc_class)
for element in elements:
if not getattr(element, attribute):
assert False
def step_impl(context, ifc_class):
assert len(IfcFile.get().by_type(ifc_class)
) >= 1, 'An element of {} could not be found'.format(ifc_class)
def step_impl(context, value):
if IfcFile.get().schema == 'IFC2X3':
for site in IfcFile.get().by_type('IfcSite'):
assert_pset(site, 'EPset_ProjectedCRS', 'Description', value)
return
check_ifc4_geolocation('IfcProjectedCRS', 'Description', value)
def step_impl(context, guid, number):
number = assert_number(number)
site = IfcFile.by_guid(guid)
if not site.is_a('IfcSite'):
assert False, 'The element {} is not an IfcSite'.format(site)
assert_attribute(site, 'RefElevation', number)
def step_impl(context):
if IfcFile.get().schema == 'IFC2X3':
for site in IfcFile.get().by_type('IfcSite'):
assert_pset(site, 'EPset_MapConversion')
check_ifc4_geolocation('IfcMapConversion')
def step_impl(context, ifc_class, reason):
assert len(IfcFile.get().by_type(ifc_class)) == 0
def step_impl(context, ifc_class, property_path):
pset_name, property_name = property_path.split(".")
elements = IfcFile.get().by_type(ifc_class)
for element in elements:
if not IfcFile.get_property(element, pset_name, property_name):
assert False
