def only_eleclasses(context, ifc_classes): context.falseelems = [] context.falseguids = [] # get the list of ifc_classes target_ifc_classes = ifc_classes.replace(" ", "").split(",") # ToDo test if they exist in ifc standard, should be possible with ifcos all_elements = IfcStore.file.by_type("IfcBuildingElement") context.elemcount = len(all_elements) false_elements = [] for elem in all_elements: if elem.is_a() not in target_ifc_classes: context.falseelems.append(str(elem)) context.falseguids.append(elem.GlobalId) context.falsecount = len(context.falseelems) # use ifc_classes in method parameter but ifc_class in string parameter # be careful somehow the opposite of most other tests is tested util.assert_elements( ifc_classes, context.elemcount, context.falsecount, context.falseelems, message_all_falseelems=_("All {elemcount} elements in the file are not {ifc_class} elements."), message_some_falseelems=_( "{falsecount} of {elemcount} false_elements are not {ifc_class} elements: {falseelems}" ), )
def eleclass_has_description_with_a_value(context, ifc_class): context.falseelems = [] context.falseguids = [] elements = IfcStore.file.by_type(ifc_class) for elem in elements: # print(elem.Description) if not elem.Description: context.falseelems.append(str(elem)) context.falseguids.append(elem.GlobalId) context.elemcount = len(elements) context.falsecount = len(context.falseelems) util.assert_elements( ifc_class, context.elemcount, context.falsecount, context.falseelems, message_all_falseelems=_("The description of all {elemcount} elements is not set."), message_some_falseelems=_( "The description of {falsecount} out of {elemcount} {ifc_class} elements is not set: {falseelems}" ), message_no_elems=_("There are no {ifc_class} elements in the IFC file."), )
def eleclass_has_property_in_pset(context, ifc_class, aproperty, pset): context.falseelems = [] context.falseguids = [] context.falseprops = {} from ifcopenshell.util.element import get_psets elements = IfcStore.file.by_type(ifc_class) for elem in elements: psets = get_psets(elem) if not (pset in psets and aproperty in psets[pset]): context.falseelems.append(str(elem)) context.falseguids.append(elem.GlobalId) context.falseprops[elem.id()] = str(psets) context.elemcount = len(elements) context.falsecount = len(context.falseelems) util.assert_elements( ifc_class, context.elemcount, context.falsecount, context.falseelems, # TODO: Translate these messages into other languages message_all_falseelems= _("All {elemcount} {ifc_class} elements are missing the property {parameter} in the pset." ), message_some_falseelems= _("The following {falsecount} of {elemcount} {ifc_class} elements are missing the property {parameter} in the pset: {falseelems}" ), message_no_elems=_( "There are no {ifc_class} elements in the IFC file."), parameter=aproperty, )
def assert_type(element, ifc_class, is_exact=False): if is_exact: assert element.is_a() == ifc_class, _( "The element {} is an {} instead of {}.").format( element, element.is_a(), ifc_class) else: assert element.is_a(ifc_class), _( "The element {} is an {} instead of {}.").format( element, element.is_a(), ifc_class)
def eleclass_has_geometric_representation_of_specific_class( 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 context.falseelems = [] context.falseguids = [] context.falseprops = {} rep = None elements = IfcStore.file.by_type(ifc_class) for elem in elements: if not elem.Representation: continue has_representation = False for representation in elem.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 rep = item2 else: if is_item_a_representation(item, representation_class): has_representation = True rep = item if not has_representation: context.falseelems.append(str(elem)) context.falseguids.append(elem.GlobalId) context.falseprops[elem.id()] = str(rep) context.elemcount = len(elements) context.falsecount = len(context.falseelems) util.assert_elements( ifc_class, context.elemcount, context.falsecount, context.falseelems, message_all_falseelems= _("All {elemcount} {ifc_class} elements are not a {parameter} representation." ), message_some_falseelems= _("The following {falsecount} of {elemcount} {ifc_class} elements are not a {parameter} representation: {falseelems}" ), message_no_elems=_( "There are no {ifc_class} elements in the IFC file."), parameter=representation_class, )
def step_impl(context, guid): site = util.assert_guid(IfcStore.file, guid) util.assert_type(site, "IfcSite") if not site.ObjectPlacement: assert False, _("The site has no object placement") site_placement = ifcopenshell.util.placement.get_local_placement( site.ObjectPlacement)[:, 3][0:3] origin = np.array([0, 0, 0]) assert np.allclose( origin, site_placement), _('The site location is at "{}" instead of "{}"')
def step_impl(context, guid, easting, northing, elevation): if IfcStore.file.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 = util.assert_pset(site, "EPset_MapConversion") else: map_conversion = IfcStore.file.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 = util.assert_guid(IfcStore.file, guid) if not element.ObjectPlacement: assert False, _("The element does not have an object placement: {}" ).format(element) m = ifcopenshell.util.placement.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 = (util.assert_number(easting), util.assert_number(northing), util.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 eleclass_have_class_attributes_with_a_value(context, ifc_class): from ifcopenshell.ifcopenshell_wrapper import schema_by_name # schema = schema_by_name("IFC2X3") schema = schema_by_name(IfcStore.file.schema) class_attributes = [] for cl_attrib in schema.declaration_by_name(ifc_class).all_attributes(): class_attributes.append(cl_attrib.name()) # print(class_attributes) context.falseelems = [] context.falseguids = [] context.falseprops = {} elements = IfcStore.file.by_type(ifc_class) failed_attribs = [] for elem in elements: elem_failed = False for cl_attrib in class_attributes: attrib_value = getattr(elem, cl_attrib) if not attrib_value: elem_failed = True failed_attribs.append(cl_attrib) # print(attrib_value) if elem_failed is True: context.falseelems.append(str(elem)) context.falseguids.append(elem.GlobalId) context.falseprops[elem.id()] = failed_attribs context.elemcount = len(elements) context.falsecount = len(context.falseelems) util.assert_elements( ifc_class, context.elemcount, context.falsecount, context.falseelems, message_all_falseelems=_( "For all {elemcount} {ifc_class} elements at least one of these class attributes {parameter} has no value." ), message_some_falseelems=_( "For the following {falsecount} out of {elemcount} {ifc_class} elements at least one of these class attributes {parameter} has no value: {falseelems}" ), message_no_elems=_("There are no {ifc_class} elements in the IFC file."), parameter=failed_attribs, )
def step_impl(context, number): number = util.assert_number(number) project = IfcStore.file.by_type("IfcProject")[0] for c in project.RepresentationContexts: if c.TrueNorth: actual_value = round( ifcopenshell.util.geolocation.yaxis2angle( c.TrueNorth.DirectionRatios[0], c.TrueNorth.DirectionRatios[1]), 3, ) value = round(number, 3) assert actual_value == value, _( 'We expected a value of "{}" but instead got "{}"').format( value, actual_value) return assert False, _("True north is not defined in the file")
def step_impl(context, guid, x, y, z): element = util.assert_guid(IfcStore.file, guid) if not element.ObjectPlacement: assert False, _("The element does not have an object placement: {}" ).format(element) m = ifcopenshell.util.placement.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 = (util.assert_number(x), util.assert_number(y), util.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, unit): if IfcStore.file.schema == "IFC2X3": for site in IfcStore.file.by_type("IfcSite"): util.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, guid, identification, reference_name): element = util.assert_guid(IfcStore.file, guid) if not hasattr(element, "HasAssociations") or not element.HasAssociations: assert False, _("The element {} has no associations.").format(element) references = [a.RelatingClassification for a in element.HasAssociations if a.is_a("IfcRelAssociatesClassification")] if not references: assert False, _("The element {element} has no associated classification references.").format(element) is_success = False for reference in references: try: util.assert_attribute(reference, "Identification", identification) util.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 assert_attribute(element, name, value=None): if not hasattr(element, name): assert False, _( "The element {} does not have the attribute {}").format( element, name) if not value: if getattr(element, name) is None: assert False, _( "The element {} does not have a value for the attribute {}" ).format(element, name) return getattr(element, name) if value == "NULL": value = None actual_value = getattr(element, name) if isinstance(value, list) and actual_value: actual_value = list(actual_value) assert actual_value == value, _( 'We expected a value of "{}" but instead got "{}" for the element {}' ).format(value, actual_value, element)
def assert_pset(element, pset_name, prop_name=None, value=None): if value == "NULL": value = None psets = ifcopenshell.util.element.get_psets(site) if pset_name not in psets: assert False, _( "The element {} does not have a property set named {}").format( element, pset_name) if prop_name is None: return psets[pset_name] if prop_name not in psets[pset_name]: assert False, _( 'The element {} does not have a property named "{}" in the pset "{}"' ).format(element, prop_name, pset_name) if value is None: return psets[pset_name][prop_name] actual_value = psets[pset_name][prop_name] assert actual_value == value, _( 'We expected a value of "{}" but instead got "{}" for the element {}' ).format(value, actual_value, element)
def step_impl(context, guid, predefined_type): element = util.assert_guid(IfcStore.file, guid) if ( hasattr(element, "PredefinedType") and element.PredefinedType == "USERDEFINED" and hasattr(element, "ObjectType") ): util.assert_attribute(element, "ObjectType", predefined_type) elif hasattr(element, "PredefinedType"): util.assert_attribute(element, "PredefinedType", predefined_type) else: assert False, _("The element {} does not have a PredefinedType or ObjectType attribute").format(element)
def no_eleclass(context, ifc_class): context.falseelems = [] context.falseguids = [] elements = IfcStore.file.by_type(ifc_class) context.elemcount = len(IfcStore.file.by_type("IfcBuildingElement")) for elem in elements: context.falseelems.append(str(elem)) context.falseguids.append(elem.GlobalId) context.falsecount = len(context.falseelems) # be careful somehow the opposite of most other tests is tested util.assert_elements( ifc_class, context.elemcount, context.falsecount, context.falseelems, message_all_falseelems=_("All {elemcount} elements in the file are {ifc_class} elements."), message_some_falseelems=_("{falsecount} of {elemcount} false_elements are {ifc_class} elements: {falseelems}"), )
def assert_elements( ifc_class, elemcount, falsecount, falseelems, message_all_falseelems, message_some_falseelems, message_no_elems="", parameter=None, ): out_falseelems = "\n" for e in falseelems: out_falseelems += e + "\n" # old, elemcount == 0 creates a failed test, but should not # no elements of a ifc_class should not be a fail # if a ifc_class has to be exist, it should be in a own test # if elemcount > 0 and falsecount == 0: # return # Test OK # elif elemcount == 0: # assert False, ( # message_no_elems.format( # ifc_class=ifc_class # ) # ) if falsecount == 0: return # test ok for elemcount == 0 and elemcount > 0 elif falsecount == elemcount: if parameter is None: assert False, message_all_falseelems.format(elemcount=elemcount, ifc_class=ifc_class) else: assert False, message_all_falseelems.format(elemcount=elemcount, ifc_class=ifc_class, parameter=parameter) elif falsecount > 0 and falsecount < elemcount: if parameter is None: assert False, message_some_falseelems.format( falsecount=falsecount, elemcount=elemcount, ifc_class=ifc_class, falseelems=out_falseelems, ) else: assert False, message_some_falseelems.format( falsecount=falsecount, elemcount=elemcount, ifc_class=ifc_class, falseelems=out_falseelems, parameter=parameter, ) else: assert False, _( "Error in falsecount calculation, something went wrong.")
def check_ifc4_geolocation(entity_name, prop_name=None, value=None, should_assert=True): if entity_name not in IfcStore.bookmarks: has_entity = False project = IfcStore.file.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): IfcStore.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): IfcStore.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(IfcStore.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 get_template_strings(self): return { # "_lang": _("en"), "_success": _("Success"), "_failure": _("Failure"), "_tests_passed": _("Tests passed"), "_duration": _("Duration"), "_auditing": _("OpenBIM auditing is a feature of"), "_and": _("and"), }
def step_impl(context, number): number = util.assert_number(number) if IfcStore.file.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.xaxis2angle(abscissa, ordinate), 3) value = round(number, 3) assert actual_value == value, _( 'We expected a value of "{}" but instead got "{}"').format( value, actual_value)
def step_impl(context, ifc_class): assert len(IfcStore.file.by_type(ifc_class)) >= 1, _( "An element of {} could not be found").format(ifc_class)
def step_impl(context, guid, reason): try: element = IfcStore.file.by_id(guid) except: return assert False, _("This element {} should be reevaluated.").format(element)
def assert_number(number): try: return float(number) except ValueError: assert False, _("A number should be specified, not {}").format(number)
def assert_guid(ifc, guid): try: return ifc.by_guid(guid) except: assert False, _( "An element with the ID {} could not be found.").format(guid)
def step_impl(context, schema): real_schema = IfcStore.file.schema assert real_schema == schema, _( "We expected a schema of {} but instead got {}").format( schema, real_schema)
def step_impl(context, name, tokens): try: tokens = json.loads(tokens) except: assert False, _("Tokens {} are not specified as a JSON list").format(tokens) util.assert_attribute(get_classification(name), "ReferenceTokens", tokens)