IVS-137 ALB012 Vertical Segment Radius of Curvature

features/ALB012_Alignment-vertical-segment-radius-of-curvature.feature

@@ -0,0 +1,21 @@
+@implementer-agreement
+@ALB
+@version1
+@E00020
+Feature: ALB012 - Alignment vertical segment radius of curvature
+  The rule verifies the 'RadiusOfCurvature' design parameter for vertical alignment segments.
+
+  Background:
+    Given A model with Schema "IFC4.3"
+    Given An IfcAlignmentVertical
+    Given A relationship IfcRelNests from IfcAlignmentVertical to IfcAlignmentSegment and following that
+    Given Its attribute DesignParameters
+    Given Its entity type is 'IfcAlignmentVerticalSegment'
+
+  Scenario: Validating the absence of curvature radius for specific predefined types of vertical segment
+    Given PredefinedType != 'ARC' or 'PARABOLICARC'
+    Then The value of attribute RadiusOfCurvature must be empty
+
+  Scenario: Validating the radius of curvature for parabolic segments
+    Given PredefinedType = 'PARABOLICARC'
+    Then The value of attribute RadiusOfCurvature must be equal to the expression: HorizontalLength / ( EndGradient - StartGradient )

features/steps/givens/attributes.py

@@ -229,3 +229,10 @@ def step_impl(context, inst, ff : FirstOrFinal):
 @gherkin_ifc.step("An IFC model")
 def step_impl(context):
     yield ValidationOutcome(instance_id = context.model, severity=OutcomeSeverity.PASSED)
+
+@gherkin_ifc.step('Each instance pair at depth 1')
+def step_impl(context, inst):
+    pairs = list()
+    for i in range(0, len(inst) - 1):
+        pairs.append([inst[i], inst[i+1]])
+    yield ValidationOutcome(instance_id = [pairs], severity=OutcomeSeverity.PASSED)

features/steps/thens/attributes.py

@@ -1,5 +1,5 @@
 import operator
-
+import ifcopenshell
 
 from utils import misc, system, geometry
 from validation_handling import gherkin_ifc
@@ -60,37 +60,124 @@ def accumulate_errors(i):
         yield from errors
 
 
-@gherkin_ifc.step('The value of attribute {attribute} must be {value}')
-@gherkin_ifc.step('The value of attribute {attribute} must be {value} {display_entity:display_entity}')
-def step_impl(context, inst, attribute, value, display_entity=0):
-    # @todo the horror and inconsistency.. should we use
-    # ast here as well to differentiate between types?
-    pred = operator.eq
-    if value == 'empty':
-        value = ()
-    elif value == 'not empty':
-        value = ()
-        pred = operator.ne
-    elif 'or' in value:
-        opts = value.split(' or ')
-        value = tuple(opts)
-        pred = misc.reverse_operands(operator.contains)
-
-    if isinstance(inst, (tuple, list)):
-        inst = inst[0]
-    attribute_value = getattr(inst, attribute, 'Attribute not found')
-    if attribute_value is None:
-        attribute_value = ()
-    if inst is None:
-        # nothing was activated by the Given criteria
-        yield ValidationOutcome(inst=inst, severity=OutcomeSeverity.EXECUTED)
-    elif not pred(attribute_value, value):
-        yield ValidationOutcome(
-            inst=inst,
-            expected=None if not value else value,
-            observed=misc.recursive_unpack_value(attribute_value),
-            severity=OutcomeSeverity.ERROR
-        )
+@gherkin_ifc.step('The value of attribute {attribute} must be {value_or_comparison_op}')
+@gherkin_ifc.step('The value of attribute {attribute} must be {value_or_comparison_op} {display_entity:display_entity}')
+@gherkin_ifc.step('The value of attribute {attribute} must be {value_or_comparison_op} the expression: {expression}')
+def step_impl(context, inst, attribute:str, value_or_comparison_op:str, expression:str=None, display_entity=0):
+    """
+    Compare an attribute to an expression based on attributes.
+
+    The {comparison_op} operator can be 'equal to', 'not equal to', 'greater than', 'less than', 'greater than or equal to', and 'less than or equal to'.
+
+    The {expression} should be composed by attribute values, and use the following operators:
+    + : addition;
+    - : subtraction;
+    * : multiplication;
+    / : division;
+    % : modulus;
+    ** : exponentiation.
+    """
+
+    operators = {
+        '+' : operator.add,
+        '-' : operator.sub,
+        '*' : operator.mul,
+        '/' : operator.truediv,
+        '%' : operator.mod,
+        '**' : operator.pow,
+        'equal to' : operator.eq,
+        'not equal to' : operator.ne,
+        'greater than' : operator.gt,
+        'less than' : operator.gt,
+        'greater than or equal to' : operator.ge,
+        'less than or equal to' : operator.le,
+    }
+
+    if expression is not None:
+        # Get compared attribute value
+
+        attr_compared_value = getattr(inst, attribute, 'Compared attribute not found')
+        if isinstance(attr_compared_value, ifcopenshell.entity_instance):
+            raise Exception('Compared attribute value is an IFC entity')
+
+        # Replace attribute names with attribute values in the expression
+        for string_content in expression.split():
+            # Checks if the string is not a operator neither parenthesis
+            if string_content not in [*operators, '(', ')']:
+                if hasattr(inst, string_content):
+                    if not isinstance(getattr(inst, string_content), ifcopenshell.entity_instance):
+                        expression = expression.replace(string_content, str(getattr(inst, string_content)))
+                    else:
+                        raise Exception('Expression attribute value is an IFC entity')
+                else:
+                    raise Exception('Expression attribute not found')
+
+        # Evaluate the string expression using eval
+        try:
+            expression_value = eval(expression)
+        except Exception as e:
+            raise ValueError(f"Error evaluating expression: {e}")
+
+        # Compare the attribute with the expression value, considering the precision
+        entity_contexts = geometry.recurrently_get_entity_attr(context, inst, 'IfcRepresentation', 'ContextOfItems')
+        precision = geometry.get_precision_from_contexts(entity_contexts)
+
+        try:
+            result = geometry.compare_with_precision(
+                attr_compared_value, expression_value, precision, value_or_comparison_op
+            )
+            if result:
+                yield ValidationOutcome(
+                    inst=inst,
+                    expected=f"A value {value_or_comparison_op} {expression_value} with precision {precision}",
+                    observed={attr_compared_value},
+                    severity=OutcomeSeverity.PASSED,
+                )
+            else:
+                yield ValidationOutcome(
+                    inst=inst,
+                    expected=f"A value {value_or_comparison_op} {expression_value}",
+                    observed={attr_compared_value},
+                    severity=OutcomeSeverity.ERROR,
+                )
+        except ValueError as e:
+            yield ValidationOutcome(
+                inst=inst,
+                expected=f"A value {value_or_comparison_op} {expression_value}",
+                observed=f"Error during comparison: {e}",
+                severity=OutcomeSeverity.ERROR,
+            )
+
+
+    else:
+        # @todo the horror and inconsistency.. should we use
+        # ast here as well to differentiate between types?
+        pred = operator.eq
+        if value_or_comparison_op == 'empty':
+            value_or_comparison_op = ()
+        elif value_or_comparison_op == 'not empty':
+            value_or_comparison_op = ()
+            pred = operator.ne
+        elif 'or' in value_or_comparison_op:
+            opts = value_or_comparison_op.split(' or ')
+            value_or_comparison_op = tuple(opts)
+            pred = misc.reverse_operands(operator.contains)
+
+        if isinstance(inst, (tuple, list)):
+            inst = inst[0]
+        attribute_value = getattr(inst, attribute, 'Attribute not found')
+        if attribute_value is None:
+            attribute_value = ()
+        if inst is None:
+            # nothing was activated by the Given criteria
+            yield ValidationOutcome(inst=inst, severity=OutcomeSeverity.EXECUTED)
+        elif not pred(attribute_value, value_or_comparison_op):
+            yield ValidationOutcome(
+                inst=inst,
+                expected=None if not value_or_comparison_op else value_or_comparison_op,
+                observed=misc.recursive_unpack_value(attribute_value),
+                severity=OutcomeSeverity.ERROR
+            )
 
 @gherkin_ifc.step('The {field} of the {file_or_model} must be "{values}"')
 def step_impl(context, inst, field, file_or_model, values):
@@ -134,7 +221,7 @@ def step_impl(context, inst, constraint, num):
     inst = str(inst)
     op = misc.stmt_to_op(constraint)
     if not op(len(inst), num):
-        yield ValidationOutcome(inst=inst, expected=num, observed=len(inst), severity=OutcomeSeverity.ERROR) 
+        yield ValidationOutcome(inst=inst, expected=num, observed=len(inst), severity=OutcomeSeverity.ERROR)
 
 
 @gherkin_ifc.step('The characters must be within the official encoding character set')

features/steps/utils/geometry.py

@@ -222,3 +222,31 @@ def alignment_segment_angular_difference(
     delta = abs(current_start_direction - preceding_end_direction)
 
     return delta
+
+
+def compare_with_precision(value_1: float, value_2: float, precision: float, comparison_operator: str) -> bool:
+    """
+    Compare the value_1 with value_2 according to a comparison operator, considering a precision tolerance.
+
+    The valid comparison operators are:
+        'equal to';
+        'not equal to';
+        'greater than';
+        'less than';
+        'greater than or equal to';
+        'less than or equal to'. 
+    """
+    if comparison_operator == 'equal to':
+        return math.isclose(value_1, value_2, rel_tol=0., abs_tol=precision)
+    elif comparison_operator == 'not equal to':
+        return not math.isclose(value_1, value_2, rel_tol=0., abs_tol=precision)
+    elif comparison_operator == 'greater than':
+        return value_1 > value_2 and not math.isclose(value_1, value_2, rel_tol=0., abs_tol=precision)
+    elif comparison_operator == 'less than':
+        return value_1 < value_2 and not math.isclose(value_1, value_2, rel_tol=0., abs_tol=precision)
+    elif comparison_operator == 'greater than or equal to':
+        return value_1 > value_2 or math.isclose(value_1, value_2, rel_tol=0., abs_tol=precision)
+    elif comparison_operator == 'less than or equal to':
+        return value_1 < value_2 or math.isclose(value_1, value_2, rel_tol=0., abs_tol=precision)
+    else:
+        raise ValueError(f"Invalid comparison operator: {comparison_operator}")