Moving dependence from custom branch's tour_model to master's trip_model

emission/analysis/modelling/similarity/od_similarity.py

@@ -16,6 +16,23 @@ def extract_features(self, trip: ecwc.Confirmedtrip) -> List[float]:
         return ctfe.od_features(trip)
 
     def similarity(self, a: List[float], b: List[float]) -> List[float]:
-        o_dist = ecc.calDistance([a[0], a[1]], [b[0], b[1]])
-        d_dist = ecc.calDistance([a[2], a[3]], [b[2], b[3]])
-        return [o_dist, d_dist]
+        """
+        a : a list of point features that can take either of two forms
+                    1. [point1_latitude,point1_longitude]  
+                    2. [point1_latitude,point1_longitude,point2_latitude,point2_longitude] 
+
+        b : a list of point features that can take either of two forms
+                    1. [point3_latitude,point3_longitude]  
+                    2. [point3_latitude,point3_longitude,point4_latitude,point4_longitude] 
+
+            It'll always take the same form as parameter a.
+
+        return: a list of size 1 ([distance between point1-point3]) if a and b take form 1
+                or of size 2 ([distance between point1-point3, distance between point2-point4])
+                if a and b take form 2.
+        """
+
+        point_dist = [ecc.calDistance(a[i:i+2], b[i:i+2]) 
+                      for i in range (0,len(a),2)] 
+
+        return point_dist

emission/analysis/modelling/similarity/similarity_metric.py

@@ -31,11 +31,12 @@ def similar(self, a: List[float], b: List[float], thresh: float) -> bool:
         """compares the features, returning true if they are similar
         within some threshold
 
-        :param a: features for a trip
+        :param a: features for a trip 
         :param b: features for another trip
         :param thresh: threshold for similarity
         :return: true if the feature similarity is within some threshold
         """
         similarity_values = self.similarity(a, b)
-        is_similar = all(map(lambda sim: sim <= thresh, similarity_values))
+        is_similar = all(sim <= thresh for sim in similarity_values)
+
         return is_similar

emission/analysis/modelling/trip_model/greedy_similarity_binning.py

@@ -119,6 +119,11 @@ class label to apply:
         self.sim_thresh = config['similarity_threshold_meters']
         self.apply_cutoff = config['apply_cutoff']
         self.is_incremental = config['incremental_evaluation']
+        if config.get('clustering_way') is None:
+            self.clusteringWay='origin-destination'   # previous default
+        else:
+            self.clusteringWay= config['clustering_way'] 
+        self.tripLabels=[]
 
         self.bins: Dict[str, Dict] = {}
 
@@ -184,9 +189,11 @@ def _assign_bins(self, trips: List[ecwc.Confirmedtrip]):
                 logging.debug(f"adding trip to bin {bin_id} with features {trip_features}")
                 self.bins[bin_id]['feature_rows'].append(trip_features)
                 self.bins[bin_id]['labels'].append(trip_labels)
+                self.tripLabels.append(bin_id)
             else:
                 # create new bin
                 new_bin_id = str(len(self.bins))
+                self.tripLabels.append(new_bin_id)
                 new_bin_record = {
                     'feature_rows': [trip_features],
                     'labels': [trip_labels],
@@ -200,14 +207,22 @@ def _find_matching_bin_id(self, trip_features: List[float]) -> Optional[str]:
         finds an existing bin where all bin features are "similar" to the incoming
         trip features.
 
-        :param trip_features: feature row for the incoming trip
+        :param trip_features: feature row for the incoming trip. 
+                            takes the form [orig_lat, orig_lon, dest_lat, dest_lon]
         :return: the id of a bin if a match was found, otherwise None
         """
         for bin_id, bin_record in self.bins.items():
-                matches_bin = all([self.metric.similar(trip_features, bin_sample, self.sim_thresh)
-                    for bin_sample in bin_record['feature_rows']])
-                if matches_bin:
-                    return bin_id
+            if self.clusteringWay == 'origin':
+                start,end=0,2  #since first two features in trip_features are for origin
+            elif self.clusteringWay == 'destination':
+                start,end=2,4  #third and fourth values intrip_features are for destination
+            elif self.clusteringWay == 'origin-destination':
+                start,end=0,4  #when clusteromgWay is 'origin-destination',we pass all four features
+
+            matches_bin = all([self.metric.similar(trip_features[start:end], bin_sample[start:end], self.sim_thresh)
+                for bin_sample in bin_record['feature_rows']])
+            if matches_bin:
+                return bin_id
         return None
 
     def _nearest_bin(self, trip: ecwc.Confirmedtrip) -> Tuple[Optional[int], Optional[Dict]]: