fulddaekning/osrm/OSRMHelper.java

package dk.daoas.fulddaekning.osrm;

import java.io.IOException;
import java.util.Collection;
import java.util.Iterator;
import java.util.logging.Level;
import java.util.logging.Logger;


import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Future;

import org.apache.http.HttpHost;
import org.apache.http.HttpRequest;
import org.apache.http.HttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.nio.client.CloseableHttpPipeliningClient;
import org.apache.http.impl.nio.client.HttpAsyncClients;
import org.apache.http.util.EntityUtils;

import com.google.gson.Gson;

import dk.daoas.fulddaekning.Adresse;
import dk.daoas.fulddaekning.HttpUtil;
import dk.daoas.fulddaekning.LookupWorker;

public class OSRMHelper {
        
        final static Logger logger = Logger.getLogger( OSRMHelper.class.toString() );
        
        Gson gson = new Gson();
        

        final String host = "10.30.2.61";
        final int port = 5000;
        final String base_url = "http://" + host + ":" + port;

        public Adresse getNearestViaTable(Adresse a1, Collection<Adresse> haystack) {
                
                Adresse bedsteAdresse = null;
                
                Adresse hayArray[] = new Adresse[ haystack.size() ];
                haystack.toArray(hayArray);
                
                StringBuilder sb = new StringBuilder();
                sb.append(base_url);
                sb.append("/table?loc=").append(a1.latitude).append(",").append(a1.longitude);
                
                for(int i = 0; i<hayArray.length; i++) {
                        Adresse a = hayArray[i];
                        sb.append("&loc=").append( a.latitude ).append(",").append(a.longitude);
                }
                
                try {
                        String txtResponse = HttpUtil.getContentString(sb.toString(), 500, "UTF-8");
                        OSRMDistanceTable table = gson.fromJson(txtResponse, OSRMDistanceTable.class);
                        if (table.status != 0) {
                                logger.info("OSRM failed with message: " + table.status_message);
                                return null;
                        }
                        
                        int bedsteTid = Integer.MAX_VALUE;
                        
                        for (int i = 1; i<table.distance_table.length; i++) {
                                if (table.distance_table[0][i] < bedsteTid) {
                                        bedsteTid = table.distance_table[0][i];
                                        int idx = i-1;
                                        bedsteAdresse = hayArray[idx];
                                }
                        }

                } catch (Exception e) {
                        logger.log(Level.SEVERE, "Lookup failed", e);
                        System.exit(1);                 
                }
                
                //return gson.fromJson(txtResponse, OSRMResponse.class);
                
                
                return bedsteAdresse;
        }

        public Adresse getNearestPipeline(Adresse a1, Collection<Adresse> haystack) {
                
                int bedsteAfstand = Integer.MAX_VALUE;
                Adresse bedsteAdresse = null;

                Adresse hayArray[] = new Adresse[ haystack.size() ];
                haystack.toArray(hayArray);


        try (CloseableHttpPipeliningClient httpclient = HttpAsyncClients.createPipelining(); ) {
            httpclient.start();

            HttpHost targetHost = new HttpHost(host, port);

                System.out.println("1>" + targetHost.toString() );
                System.out.println("2>" + targetHost.toURI() );

                List<HttpRequest> requests = new ArrayList<HttpRequest>();

                      String loc1 = a1.latitude + "," + a1.longitude;

                //for (int i=0; i<hayArray.length; i++) {
                for (int i=0; i<2; i++) {
                        Adresse a2 = hayArray[i];
                          String loc2 = a2.latitude + "," + a2.longitude;

                          String uri = "/viaroute?loc=" + loc1 + "&loc=" + loc2 + "&geometry=false&instructions=false&alt=false";
                        System.out.println( uri );

                        requests.add( new HttpGet(uri) );

                }


            Future<List<HttpResponse>> future = httpclient.execute(targetHost, requests, null);
            List<HttpResponse> responses = future.get();

                HttpResponse respArr[] = new HttpResponse[ responses.size() ];
                responses.toArray( respArr );

                for (int i=0; i<respArr.length; i++) {
                        String jsonBody = EntityUtils.toString( respArr[i].getEntity() );
                        OSRMResponse res = gson.fromJson(jsonBody, OSRMResponse.class);

                            if (res.route_summary.total_distance < bedsteAfstand) {
                                        bedsteAfstand = res.route_summary.total_distance;
                                        bedsteAdresse = hayArray[i];
                              }

                }


            System.out.println(responses);

        } catch(Exception e) {
                        logger.log(Level.SEVERE, "Lookup failed", e);

        } 


                return bedsteAdresse;
        }

        
        /*
         * Denne virker men table opslaget er 10 gange hurtigere
         * 
         */
        @Deprecated
        public Adresse getNearest(Adresse a1, Collection<Adresse> haystack) {
                int bedsteAfstand = Integer.MAX_VALUE;
                Adresse bedsteAdresse = null;
                
                Iterator<Adresse> it = haystack.iterator();
                while (it.hasNext()) {
                        Adresse a2 = it.next();
                        
                        try {
                                OSRMResponse res = getRoute(a1, a2);

                                if (res.status != 0) {
                                        System.out.println("OSRM Returned " + res.status + "/" + res.status_message );
                                        continue;
                                }
                                
                                
                                if (res.route_summary.total_distance < bedsteAfstand) {
                                        bedsteAfstand = res.route_summary.total_distance;
                                        bedsteAdresse = a2;
                                }
                        } catch (IOException e) {
                                System.out.println( e.getMessage() );
                                System.exit(1);
                        }
        
                }
                
                return bedsteAdresse;
        }
        
        public OSRMResponse getRoute(Adresse a1, Adresse a2) throws IOException {
                
                String loc1 = a1.latitude + "," + a1.longitude;
                String loc2 = a2.latitude + "," + a2.longitude;
                
                String params = "loc=" + loc1 + "&loc=" + loc2 + "&geometry=false&instructions=false&alt=false";
                
                String url = base_url + "/viaroute?" + params;
                
                String txtResponse = HttpUtil.getContentString(url, 500, "UTF-8");
                
                return gson.fromJson(txtResponse, OSRMResponse.class);
        }
}
1	torben	2708	package dk.daoas.fulddaekning.osrm;
2
3			import java.io.IOException;
4			import java.util.Collection;
5			import java.util.Iterator;
6	torben	2720	import java.util.logging.Level;
7			import java.util.logging.Logger;
8	torben	2708
9	torben	2730
10			import java.util.ArrayList;
11			import java.util.List;
12			import java.util.concurrent.Future;
13
14			import org.apache.http.HttpHost;
15			import org.apache.http.HttpRequest;
16			import org.apache.http.HttpResponse;
17			import org.apache.http.client.methods.HttpGet;
18			import org.apache.http.impl.nio.client.CloseableHttpPipeliningClient;
19			import org.apache.http.impl.nio.client.HttpAsyncClients;
20			import org.apache.http.util.EntityUtils;
21
22	torben	2708	import com.google.gson.Gson;
23
24			import dk.daoas.fulddaekning.Adresse;
25			import dk.daoas.fulddaekning.HttpUtil;
26	torben	2720	import dk.daoas.fulddaekning.LookupWorker;
27	torben	2708
28			public class OSRMHelper {
29
30	torben	2720	final static Logger logger = Logger.getLogger( OSRMHelper.class.toString() );
31
32	torben	2708	Gson gson = new Gson();
33
34
35	torben	2730	final String host = "10.30.2.61";
36			final int port = 5000;
37			final String base_url = "http://" + host + ":" + port;
38
39	torben	2708	public Adresse getNearestViaTable(Adresse a1, Collection<Adresse> haystack) {
40
41			Adresse bedsteAdresse = null;
42
43			Adresse hayArray[] = new Adresse[ haystack.size() ];
44			haystack.toArray(hayArray);
45
46			StringBuilder sb = new StringBuilder();
47			sb.append(base_url);
48			sb.append("/table?loc=").append(a1.latitude).append(",").append(a1.longitude);
49
50			for(int i = 0; i<hayArray.length; i++) {
51			Adresse a = hayArray[i];
52			sb.append("&loc=").append( a.latitude ).append(",").append(a.longitude);
53			}
54
55			try {
56			String txtResponse = HttpUtil.getContentString(sb.toString(), 500, "UTF-8");
57			OSRMDistanceTable table = gson.fromJson(txtResponse, OSRMDistanceTable.class);
58	torben	2723	if (table.status != 0) {
59			logger.info("OSRM failed with message: " + table.status_message);
60			return null;
61			}
62
63	torben	2708	int bedsteTid = Integer.MAX_VALUE;
64
65			for (int i = 1; i<table.distance_table.length; i++) {
66			if (table.distance_table[0][i] < bedsteTid) {
67			bedsteTid = table.distance_table[0][i];
68			int idx = i-1;
69			bedsteAdresse = hayArray[idx];
70			}
71			}
72
73			} catch (Exception e) {
74	torben	2720	logger.log(Level.SEVERE, "Lookup failed", e);
75	torben	2708	System.exit(1);
76			}
77
78			//return gson.fromJson(txtResponse, OSRMResponse.class);
79
80
81			return bedsteAdresse;
82			}
83	torben	2730
84			public Adresse getNearestPipeline(Adresse a1, Collection<Adresse> haystack) {
85
86			int bedsteAfstand = Integer.MAX_VALUE;
87			Adresse bedsteAdresse = null;
88
89			Adresse hayArray[] = new Adresse[ haystack.size() ];
90			haystack.toArray(hayArray);
91
92
93			try (CloseableHttpPipeliningClient httpclient = HttpAsyncClients.createPipelining(); ) {
94			httpclient.start();
95
96			HttpHost targetHost = new HttpHost(host, port);
97
98			System.out.println("1>" + targetHost.toString() );
99			System.out.println("2>" + targetHost.toURI() );
100
101			List<HttpRequest> requests = new ArrayList<HttpRequest>();
102
103			String loc1 = a1.latitude + "," + a1.longitude;
104
105			//for (int i=0; i<hayArray.length; i++) {
106			for (int i=0; i<2; i++) {
107			Adresse a2 = hayArray[i];
108			String loc2 = a2.latitude + "," + a2.longitude;
109
110			String uri = "/viaroute?loc=" + loc1 + "&loc=" + loc2 + "&geometry=false&instructions=false&alt=false";
111			System.out.println( uri );
112
113			requests.add( new HttpGet(uri) );
114
115			}
116
117
118			Future<List<HttpResponse>> future = httpclient.execute(targetHost, requests, null);
119			List<HttpResponse> responses = future.get();
120
121			HttpResponse respArr[] = new HttpResponse[ responses.size() ];
122			responses.toArray( respArr );
123
124			for (int i=0; i<respArr.length; i++) {
125			String jsonBody = EntityUtils.toString( respArr[i].getEntity() );
126			OSRMResponse res = gson.fromJson(jsonBody, OSRMResponse.class);
127
128			if (res.route_summary.total_distance < bedsteAfstand) {
129			bedsteAfstand = res.route_summary.total_distance;
130			bedsteAdresse = hayArray[i];
131			}
132
133			}
134
135
136			System.out.println(responses);
137
138			} catch(Exception e) {
139			logger.log(Level.SEVERE, "Lookup failed", e);
140
141			}
142
143
144			return bedsteAdresse;
145			}
146
147	torben	2708
148			/*
149			* Denne virker men table opslaget er 10 gange hurtigere
150			*
151			*/
152			@Deprecated
153			public Adresse getNearest(Adresse a1, Collection<Adresse> haystack) {
154	torben	2724	int bedsteAfstand = Integer.MAX_VALUE;
155	torben	2708	Adresse bedsteAdresse = null;
156
157			Iterator<Adresse> it = haystack.iterator();
158			while (it.hasNext()) {
159			Adresse a2 = it.next();
160
161			try {
162			OSRMResponse res = getRoute(a1, a2);
163	torben	2731
164			if (res.status != 0) {
165			System.out.println("OSRM Returned " + res.status + "/" + res.status_message );
166			continue;
167			}
168	torben	2708
169
170			if (res.route_summary.total_distance < bedsteAfstand) {
171			bedsteAfstand = res.route_summary.total_distance;
172			bedsteAdresse = a2;
173			}
174			} catch (IOException e) {
175			System.out.println( e.getMessage() );
176			System.exit(1);
177			}
178
179			}
180
181			return bedsteAdresse;
182			}
183
184			public OSRMResponse getRoute(Adresse a1, Adresse a2) throws IOException {
185
186			String loc1 = a1.latitude + "," + a1.longitude;
187			String loc2 = a2.latitude + "," + a2.longitude;
188
189			String params = "loc=" + loc1 + "&loc=" + loc2 + "&geometry=false&instructions=false&alt=false";
190
191			String url = base_url + "/viaroute?" + params;
192
193			String txtResponse = HttpUtil.getContentString(url, 500, "UTF-8");
194
195			return gson.fromJson(txtResponse, OSRMResponse.class);
196			}
197			}