QSRs abstractproperties

Author: Yiannis Gatsoulis

qsr_lib/src/qsrlib_qsrs/qsr_abstractclass.py

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 from __future__ import print_function, division
-from abc import ABCMeta, abstractmethod
+from abc import ABCMeta, abstractmethod, abstractproperty
 
 
 class QSR_Abstractclass(object):
@@ -9,26 +9,29 @@ class QSR_Abstractclass(object):
     """
     __metaclass__ = ABCMeta
 
+    _common_dynamic_args = ["qsrs_for"]
+    """tuple: Common across all QSRs arguments of `dynamic_args`."""
+
     def __init__(self):
-        """Constructor.
+        """Constructor."""
+        self._dtype_map = {"points": self._return_points,
+                           "bounding_boxes_2d": self._return_bounding_boxes_2d}
+        """dict: Mapping of _dtype to methods."""
 
-        :return:
-        """
-        self._unique_id = ""
+    @abstractproperty
+    def _unique_id(self):
         """str: The unique identifier of each QSR."""
+        pass
 
-        self._all_possible_relations = ()
+    @abstractproperty
+    def _all_possible_relations(self):
         """tuple: All possible relations of a QSR."""
+        pass
 
-        self._dtype = ""
-        """str: On what kind of data the QSR operates with, e.g. 'points' or 'bboxes'"""
-
-        self._common_dynamic_args = ["qsrs_for"]
-        """tuple: Common across all QSRs arguments of `dynamic_args`."""
-
-        self._dtype_map = {"points": self._return_points,
-                           "bounding_boxes_2d": self._return_bounding_boxes_2d}
-        """dict: Mapping of _dtype to methods."""
+    @abstractproperty
+    def _dtype(self):
+        """str: On what kind of data the QSR operates with, see self._dtype_map for possible values"""
+        pass
 
     @abstractmethod
     def make_world_qsr_trace(self, world_trace, timestamps, qsr_params, req_params, **kwargs):

qsr_lib/src/qsrlib_qsrs/qsr_arg_prob_relations_distance.py

@@ -12,7 +12,7 @@
 
 
 class QSR_Arg_Prob_Relations_Distance(QSR_Arg_Relations_Distance):
-    def __init__(self, config=None):
+    def __init__(self):
         super(QSR_Arg_Prob_Relations_Distance, self).__init__()
         self._unique_id = "argprobd"
         self.allowed_value_types = (tuple, list)

qsr_lib/src/qsrlib_qsrs/qsr_arg_relations_distance.py

@@ -7,12 +7,15 @@
 
 
 class QSR_Arg_Relations_Distance(QSR_Arg_Relations_Abstractclass):
+
+    _unique_id = "argd"
+    _dtype = "points"
+    _all_possible_relations = ()
+
     def __init__(self):
         super(QSR_Arg_Relations_Distance, self).__init__()
-        self._unique_id = "argd"
         self.allowed_value_types = (int, float)
         self.value_sort_key = operator.itemgetter(1)  # Sort by threshold
-        self._dtype = "points"
 
     def _process_qsr_parameters_from_request_parameters(self, req_params, **kwargs):
         try:

qsr_lib/src/qsrlib_qsrs/qsr_cardinal_direction_bounding_boxes_centroid_2d.py

@@ -16,11 +16,13 @@ class QSR_Cardinal_Direction_Bounding_Boxes_Centroid_2D(QSR_Dyadic_1t_Abstractcl
 
         where,\nx1, y2: the xy-coords of the top-left corner of the rectangle\nx2, y2: the xy-coords of the bottom-right corner of the rectangle
     """
+
+    _unique_id = "cardir"
+    _all_possible_relations = ("n", "ne", "e", "se", "s", "sw", "w", "nw", "eq")
+    _dtype = "bounding_boxes_2d"
+
     def __init__(self):
         super(QSR_Cardinal_Direction_Bounding_Boxes_Centroid_2D, self).__init__()
-        self._unique_id = "cardir"
-        self._all_possible_relations = ("n", "ne", "e", "se", "s", "sw", "w", "nw", "eq")
-        self._dtype = "bounding_boxes_2d"
 
     def _compute_qsr(self, data1, data2, qsr_params, **kwargs):
         """Cardinal direction relation

qsr_lib/src/qsrlib_qsrs/qsr_moving_or_stationary.py

@@ -8,12 +8,13 @@ class QSR_Moving_or_Stationary(QSR_Monadic_2t_Abstractclass):
     """Computes moving or stationary relations: 'm': moving, 's': stationary
 
     """
+
+    _unique_id = "mos"
+    _all_possible_relations = ("m", "s")
+    _dtype = "points"
+
     def __init__(self):
         super(QSR_Moving_or_Stationary, self).__init__()
-        self._unique_id = "mos"
-        self._all_possible_relations = ("m", "s")
-        self._dtype = "points"
-
         self.__qsr_params_defaults = {"quantisation_factor": 0.0}
 
     def _process_qsr_parameters_from_request_parameters(self, req_params, **kwargs):

qsr_lib/src/qsrlib_qsrs/qsr_new_mwe.py

@@ -13,22 +13,23 @@ class QSR_MWE(QSR_Dyadic_1t_Abstractclass):
 
     Some explanation about the QSR. Maybe a reference if it exists.
     """
+
+    _unique_id = "mwe"
+    """str: Unique identifier name of the QSR."""
+
+    _all_possible_relations = ("left", "together", "right")
+    """tuple: All possible relations of the QSR."""
+
+    _dtype = "points"
+    """str: On what kind of data the QSR works with."""
+
     def __init__(self):
         """Constructor.
 
         :return:
         """
         super(QSR_MWE, self).__init__()
 
-        self._unique_id = "mwe"
-        """str: Unique identifier name of the QSR."""
-
-        self._all_possible_relations = ("left", "together", "right")
-        """tuple: All possible relations of the QSR."""
-
-        self._dtype = "points"
-        """str: On what kind of data the QSR works with."""
-
     def _compute_qsr(self, data1, data2, qsr_params, **kwargs):
         """Compute QSR value.
 

qsr_lib/src/qsrlib_qsrs/qsr_qtc_simplified_abstractclass.py

@@ -30,9 +30,12 @@ class QSR_QTC_Simplified_Abstractclass(QSR_Dyadic_Abstractclass):
     __global_unique_id = "qtcs"
     __no_state__ = 9.
 
+    _unique_id = ""
+    _all_possible_relations = ()
+    _dtype = "points"
+
     def __init__(self):
         super(QSR_QTC_Simplified_Abstractclass, self).__init__()
-        self._unique_id = ""
         self.qtc_type = ""
 
         self.__qsr_params_defaults= {
@@ -116,9 +119,9 @@ def _validate_qtc_sequence(self, qtc):
             for j1 in xrange(0, len(qtc[i,:])-1):
                 for j2 in xrange(j1+1, len(insert)):
                     if np.sum(np.abs(qtc[i-1,[j1,j2]])) == 1 \
-                    and np.sum(np.abs(insert[[j1,j2]])) == 1:
+                            and np.sum(np.abs(insert[[j1,j2]])) == 1:
                         if np.nanmax(np.abs(qtc[i-1,[j1,j2]] - insert[[j1,j2]])) > 0 \
-                        and np.sum(qtc[i-1,[j1,j2]] - insert[[j1,j2]]) != 1:
+                                and np.sum(qtc[i-1,[j1,j2]] - insert[[j1,j2]]) != 1:
                             insert[[j1,j2]] = 0
 
             #print insert
@@ -222,16 +225,16 @@ def _create_qtc_representation(self, pos_k, pos_l, quantisation_factor=0):
             self._test_constraint(
                 pos_l,
                 np.array([ # Needs to be turned around to determine correct side
-                    [trans_RL_l[1,0],trans_RL_l[1,1]],
-                    [trans_RL_l[0,0],trans_RL_l[0,1]]
-                ]),
+                           [trans_RL_l[1,0],trans_RL_l[1,1]],
+                           [trans_RL_l[0,0],trans_RL_l[0,1]]
+                           ]),
                 quantisation_factor=quantisation_factor),
             self._test_constraint(
                 pos_l,
                 np.array([ # Needs to be turned around to determine correct side
-                    [RL_ext[1,0],RL_ext[1,1]],
-                    [RL_ext[0,0],RL_ext[0,1]]
-                ]),
+                           [RL_ext[1,0],RL_ext[1,1]],
+                           [RL_ext[0,0],RL_ext[0,1]]
+                           ]),
                 quantisation_factor=quantisation_factor,
                 constraint="side")
         )
@@ -426,11 +429,11 @@ def _postprocess_world_qsr_trace(self, world_qsr_trace, world_trace, world_trace
             return World_QSR_Trace(
                 qsr_type=world_qsr_trace.qsr_type,
                 trace={t: world_qsr_trace.trace[tqtc]
-                    for t, tqtc in zip(
-                        world_trace.get_sorted_timestamps()[1:],
-                        world_qsr_trace.get_sorted_timestamps()
-                    )
-                }
+                       for t, tqtc in zip(
+                    world_trace.get_sorted_timestamps()[1:],
+                    world_qsr_trace.get_sorted_timestamps()
+                )
+                       }
             )
         else:
             return world_qsr_trace

qsr_lib/src/qsrlib_qsrs/qsr_rcc2_rectangle_bounding_boxes_2d.py

@@ -9,10 +9,15 @@ class QSR_RCC2_Rectangle_Bounding_Boxes_2D(QSR_RCC_Abstractclass):
     	# 'dc'     bb1 is disconnected from bb2
 		# 'c'      bb1 is connected to bb2
     """
+
+    _unique_id = "rcc2"
+    """str: Unique identifier name of the QSR."""
+
+    _all_possible_relations = ("dc", "c")
+    """tuple: All possible relations of the QSR."""
+
     def __init__(self):
         super(QSR_RCC2_Rectangle_Bounding_Boxes_2D, self).__init__()
-        self._unique_id = "rcc2"
-        self._all_possible_relations = ("dc", "c")
 
     def _convert_to_requested_rcc_type(self, qsr):
         return qsr if qsr == "dc" else "c"

qsr_lib/src/qsrlib_qsrs/qsr_rcc3_rectangle_bounding_boxes_2d.py

@@ -10,10 +10,12 @@ class QSR_RCC3_Rectangle_Bounding_Boxes_2D(QSR_RCC_Abstractclass):
         # 'po'     bb1 partially overlaps bb2
         # 'o'      bb1 is occluded or part of bb2
     """
+
+    _unique_id = "rcc3"
+    _all_possible_relations = ("dc", "po", "o")
+
     def __init__(self):
         super(QSR_RCC3_Rectangle_Bounding_Boxes_2D, self).__init__()
-        self._unique_id = "rcc3"
-        self._all_possible_relations = ("dc", "po", "o")
 
     def _convert_to_requested_rcc_type(self, qsr):
         qsr = qsr.replace("ec", "po")

qsr_lib/src/qsrlib_qsrs/qsr_rcc8_rectangle_bounding_boxes_2d.py

@@ -15,10 +15,12 @@ class QSR_RCC8_Rectangle_Bounding_Boxes_2D(QSR_RCC_Abstractclass):
         # 'tppi'   bb2 is a tangential proper part of bb1
         # 'ntppi'  bb2 is a non-tangential proper part of bb1
     """
+
+    _unique_id = "rcc8"
+    _all_possible_relations = ("dc", "ec", "po", "eq", "tpp", "ntpp", "tppi", "ntppi")
+
     def __init__(self):
         super(QSR_RCC8_Rectangle_Bounding_Boxes_2D, self).__init__()
-        self._unique_id = "rcc8"
-        self._all_possible_relations = ("dc", "ec", "po", "eq", "tpp", "ntpp", "tppi", "ntppi")
 
     def _convert_to_requested_rcc_type(self, qsr):
         return qsr