regional algebra 'ra' new QSR

Author: Yiannis Gatsoulis

qsr_lib/scripts/example_extended.py

@@ -27,7 +27,7 @@ def pretty_print_world_qsr_trace(which_qsr, qsrlib_response_message):
 
 
 if __name__ == "__main__":
-    options = ["rcc2", "rcc3", "rcc8", "cardir", "qtcbs", "qtccs", "qtcbcs", "argd", "argprobd", "mos", "multiple"]
+    options = sorted(QSRlib().qsrs_registry.keys()) + ["multiple"]
     multiple = options[:]; multiple.remove("multiple"); multiple.remove("argd"); multiple.remove("argprobd")
 
     parser = argparse.ArgumentParser()
@@ -50,7 +50,7 @@ def pretty_print_world_qsr_trace(which_qsr, qsrlib_response_message):
 
     dynamic_args = {}
 
-    if which_qsr == "rcc3" or which_qsr == "rcc2":
+    if which_qsr in ["rcc2", "rcc3", "ra"]:
         dynamic_args = {which_qsr: {"quantisation_factor": args.quantisation_factor}}
         o1 = [Object_State(name="o1", timestamp=0, x=1., y=1., xsize=5., ysize=8.),
               Object_State(name="o1", timestamp=1, x=1., y=2., xsize=5., ysize=8.),

qsr_lib/src/qsrlib_io/world_trace.py

@@ -128,7 +128,7 @@ def return_bounding_box_2d(self, xsize_minimal=0, ysize_minimal=0):
         :param xsize_minimal: If object has no x-size (i.e. simply a point) then compute bounding box based on this minimal x-size.
         :type xsize_minimal: int or float
         :param ysize_minimal: If object has no y-size (i.e. simply a point) then compute bounding box based on this minimal y-size.
-        :return: The coordinates of the upper-left and bottom-right corners of the bounding box.
+        :return: The coordinates of the first and third corner of the bounding box.
         :rtype: list
         """
         xsize = xsize_minimal if isnan(self.xsize) else self.xsize

qsr_lib/src/qsrlib_qsrs/__init__.py

@@ -9,6 +9,7 @@
 from qsr_arg_prob_relations_distance import QSR_Arg_Prob_Relations_Distance
 from qsr_moving_or_stationary import QSR_Moving_or_Stationary
 from qsr_new_mwe import QSR_MWE
+from qsr_ra import QSR_RA
 
 # register new qsrs by class name below
 qsrs_registry = (QSR_RCC2_Rectangle_Bounding_Boxes_2D,
@@ -21,4 +22,5 @@
                  QSR_Arg_Relations_Distance,
                  QSR_Arg_Prob_Relations_Distance,
                  QSR_Moving_or_Stationary,
-                 QSR_MWE)
+                 QSR_MWE,
+                 QSR_RA)

qsr_lib/src/qsrlib_qsrs/qsr_abstractclass.py

@@ -15,6 +15,7 @@ class QSR_Abstractclass(object):
     def __init__(self):
         """Constructor."""
         self._dtype_map = {"points": self._return_points,
+                           "bounding_boxes": self._return_bounding_boxes_2d,  # todo this is to handle 2D/3D and needs its own function
                            "bounding_boxes_2d": self._return_bounding_boxes_2d}
         """dict: Mapping of _dtype to methods."""
 

qsr_lib/src/qsrlib_qsrs/qsr_ra.py

@@ -0,0 +1,79 @@
+# -*- coding: utf-8 -*-
+from __future__ import print_function, division
+from numpy import isnan
+from qsrlib_qsrs.qsr_dyadic_abstractclass import QSR_Dyadic_1t_Abstractclass
+
+
+class QSR_RA(QSR_Dyadic_1t_Abstractclass):
+    """Regional Algebra.
+
+    Members:
+        * _unique_id: "ra"
+        * _all_possible_relations: ("<", ">", "m", "mi", "o", "oi", "s", "si", "d", "di", "f", "fi", "=")
+        * _dtype: "bounding_boxes"
+
+    Some explanation about the QSR. Maybe a reference if it exists.
+    """
+
+    _unique_id = "ra"
+    """str: Unique identifier name of the QSR."""
+
+    _all_possible_relations = ("<", ">", "m", "mi", "o", "oi", "s", "si", "d", "di", "f", "fi", "=")
+    """tuple: All possible relations of the QSR."""
+
+    _dtype = "bounding_boxes"
+    """str: On what kind of data the QSR works with."""
+
+    _inverse_map = {"<": ">", "m": "mi", "o": "oi", "s": "si", "d": "di", "f": "fi",
+                    ">": "<", "mi": "m", "o1": "o", "si": "s", "di": "d", "fi": "f"}
+    """dict: Inverse relations"""
+
+    def __init__(self):
+        """Constructor.
+
+        :return:
+        """
+        super(QSR_RA, self).__init__()
+
+    def _compute_qsr(self, bb1, bb2, qsr_params, **kwargs):
+        """Compute QSR value.
+
+        :param bb1: First object's bounding box.
+        :type bb2: tuple or list
+        :param bb2: Second object's bounding box.
+        :type bb2: tuple or list
+        :param qsr_params: QSR specific parameters passed in `dynamic_args`.
+        :type qsr_params: dict
+        :param kwargs: Optional further arguments.
+        :return: The computed QSR value: two/three comma separated Allen relations for 2D/3D.
+        :rtype: str
+        """
+        if len(bb1) == 4 and len(bb2) == 4:  # 2D version
+            return ",".join([self.__allen((bb1[0], bb1[2]), (bb2[0], bb2[2])),
+                             self.__allen((bb1[1], bb1[3]), (bb2[1], bb2[3]))])
+        elif len(bb1) == 6 and len(bb2) == 6:  # 3D version
+            return ",".join([self.__allen((bb1[0], bb1[3]), (bb2[0], bb2[3])),
+                             self.__allen((bb1[1], bb1[4]), (bb2[1], bb2[4])),
+                             self.__allen((bb1[2], bb1[5]), (bb2[2], bb2[5]))])
+        else:
+            raise ValueError("bb1 and bb2 must have length of 4 (2D) or 6 (3D)")
+
+    def __allen(self, i1, i2):
+        if isnan(i1).any() or isnan(i2).any():  # nan values cause dragons
+            raise ValueError("illegal 'nan' values found")
+
+        if i1[1] < i2[0]:
+            return "<"
+        if i1[1] == i2[0]:
+            return "m"
+        if i1[0] < i2[0] < i1[1] and i2[0] < i1[1] < i2[1]:
+            return "o"
+        if i1[0] == i2[0] and i1[1] < i2[1]:
+            return "s"
+        if i2[0] < i1[0] < i2[1] and i2[0] < i1[1] < i2[1]:
+            return "d"
+        if i2[0] < i1[0] < i2[1] and i1[1] == i2[1]:
+            return "f"
+        if i1[0] == i2[0] and i1[1] == i2[1]:
+            return "="
+        return self._inverse_map[self.__allen(i2, i1)]