fix routing matrix bug

minor fix

source/jormungandr/jormungandr/street_network/andyamo.py

@@ -28,14 +28,13 @@
 # www.navitia.io
 from __future__ import absolute_import, print_function, unicode_literals, division
 import logging
-from enum import Enum
 import pybreaker
 import six
 import requests as requests
 import ujson
 import json
 from shapely.geometry import Point, Polygon
-
+from itertools import product
 
 from jormungandr import utils
 from jormungandr import app
@@ -121,18 +120,14 @@ def are_both_points_inside_zone(self, from_point, to_point):
     def not_in_andyamo_zone(self, from_point, to_point):
         return not self.are_both_points_inside_zone(from_point, to_point)
 
-    def mapping_inside_outside(self, from_point, to_point):
+    def mapping_inside(self, from_points, to_points):
         inside_zone_combinations = []
-        outside_zone_combinations = []
 
-        for f_point in from_point:
-            for t_point in to_point:
-                if self.are_both_points_inside_zone(f_point, t_point):
-                    inside_zone_combinations.append((f_point, t_point))
-                else:
-                    outside_zone_combinations.append((f_point, t_point))
+        for (f_point, t_point) in product(from_points, to_points):
+            if self.are_both_points_inside_zone(f_point, t_point):
+                inside_zone_combinations.append((f_point, t_point))
 
-        return inside_zone_combinations, outside_zone_combinations
+        return inside_zone_combinations
 
     def get_unic_objects(self, list_object):
         used = set()
@@ -144,21 +139,14 @@ def get_unic_objects(self, list_object):
             used.add(obj.uri)
         return result
 
-    def dispatch(self, origins, destinations):
-        inside_zone_combinations, outside_zone_combinations = self.mapping_inside_outside(origins, destinations)
-
-        andyamo = {
-            'origins': self.get_unic_objects([pair[0] for pair in inside_zone_combinations]),
-            'destinations': self.get_unic_objects([pair[1] for pair in inside_zone_combinations]),
-        }
+    def compute_andyamo_origins_destinations(self, origins, destinations):
+        inside_zone_combinations = self.mapping_inside(origins, destinations)
 
-        asgard = {
-            'origins': self.get_unic_objects([pair[0] for pair in outside_zone_combinations]),
-            'destinations': self.get_unic_objects([pair[1] for pair in outside_zone_combinations]),
+        return {
+            'origins': self.get_unic_objects((pair[0] for pair in inside_zone_combinations)),
+            'destinations': self.get_unic_objects((pair[1] for pair in inside_zone_combinations)),
         }
 
-        return {'andyamo': andyamo, 'asgard': asgard}
-
     def check_andyamo_modes(self, modes):
         if len(modes) != 1 or "walking" not in modes:
             self.log.error('Andyamo, mode(s) {} not implemented'.format(modes))
@@ -217,20 +205,18 @@ def post_matrix_request(self, origins, destinations, request):
     def make_path_key(self, mode, orig_uri, dest_uri, streetnetwork_path_type, period_extremity):
         return StreetNetworkPathKey(mode, orig_uri, dest_uri, streetnetwork_path_type, None)
 
-    def _create_matrix_response(self, json_response, origins, destinations, max_duration):
+    def _insert_andyamo_matrix_response(self, json_response, andyamo_isocrhone_places_idx, max_duration, output):
         sources_to_targets = json_response.get('sources_to_targets', [])
-        sn_routing_matrix = response_pb2.StreetNetworkRoutingMatrix()
-        row = sn_routing_matrix.rows.add()
-        for st in sources_to_targets:
+
+        for st, idx in zip(sources_to_targets, andyamo_isocrhone_places_idx):
             duration = int(round(st["time"]))
-            routing = row.routing_response.add()
+            routing = output.rows[0].routing_response[idx]
             if duration <= max_duration:
                 routing.duration = duration
                 routing.routing_status = response_pb2.reached
             else:
                 routing.duration = -1
                 routing.routing_status = response_pb2.unreached
-        return sn_routing_matrix
 
     def check_content_response(self, json_respons, origins, destinations):
         len_origins = len(origins)
@@ -250,35 +236,42 @@ def _get_street_network_routing_matrix(
         self, instance, origins, destinations, street_network_mode, max_duration, request, request_id, **kwargs
     ):
         wheelchair = self.get_wheelchair_parameter(request)
-        result = self.dispatch(origins, destinations)
-        andyamo = result['andyamo']
-        asgard = result['asgard']
-
-        asgard_output = self.service_backup._get_street_network_routing_matrix(
-            instance,
-            asgard['origins'],
-            asgard['destinations'],
-            street_network_mode,
-            max_duration,
-            request,
-            request_id,
-            **kwargs
+        andyamo_orig_dest = self.compute_andyamo_origins_destinations(origins, destinations)
+
+        # we pass origins and destinations at any rate
+        # if no wheelchair is activated OR no coordinates fall into the shape, we just return asgard's output
+        # Note that the output of asgard is 1 * N or N * 1
+        output = self.service_backup._get_street_network_routing_matrix(
+            instance, origins, destinations, street_network_mode, max_duration, request, request_id, **kwargs
         )
 
-        if not wheelchair or len(andyamo['origins']) == 0 or len(andyamo['destinations']) == 0:
-            return asgard_output
+        if (
+            not wheelchair
+            or len(andyamo_orig_dest['origins']) == 0
+            or len(andyamo_orig_dest['destinations']) == 0
+        ):
+            return output
+
+        resp_json = self.post_matrix_request(
+            andyamo_orig_dest['origins'], andyamo_orig_dest['destinations'], request
+        )
+        self.check_content_response(resp_json, andyamo_orig_dest['origins'], destinations)
 
-        resp_json = self.post_matrix_request(andyamo['origins'], andyamo['destinations'], request)
-        self.check_content_response(resp_json, andyamo['origins'], destinations)
+        origins_idx = {obj.uri: idx for idx, obj in enumerate(origins)}
+        destinations_idx = {obj.uri: idx for idx, obj in enumerate(destinations)}
 
-        andyamo_output = self._create_matrix_response(
-            resp_json, andyamo['origins'], andyamo['destinations'], max_duration
+        andyamo_isocrhone_places, isochrone_places_idx = (
+            (andyamo_orig_dest['destinations'], destinations_idx)
+            if len(andyamo_orig_dest['origins']) == 1
+            else (andyamo_orig_dest['origins'], origins_idx)
         )
 
-        for row in asgard_output.rows:
-            andyamo_output.rows.add().CopyFrom(row)
+        andyamo_isocrhone_places_idx = [isochrone_places_idx[p.uri] for p in andyamo_isocrhone_places]
+        logging.getLogger(__name__).error("{}".format(andyamo_isocrhone_places_idx))
+
+        self._insert_andyamo_matrix_response(resp_json, andyamo_isocrhone_places_idx, max_duration, output)
 
-        return andyamo_output
+        return output
 
     def _direct_path(
         self,