fulddaekning/osrm/OSRMHelper.java

package dk.daoas.fulddaekning.osrm;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.concurrent.Future;
import java.util.logging.Level;
import java.util.logging.Logger;

import org.apache.http.HttpEntity;
import org.apache.http.HttpHost;
import org.apache.http.HttpRequest;
import org.apache.http.HttpResponse;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.ResponseHandler;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
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;


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 getNearestApacheClient(Adresse a1, Collection<Adresse> haystack) {
                int bedsteAfstand = Integer.MAX_VALUE;
                Adresse bedsteAdresse = null;
                
                try (CloseableHttpClient httpclient = HttpClients.createDefault()) {
                        
                        String loc1 = a1.latitude + "," + a1.longitude;

                        
                        for(Adresse a2: haystack) {
                                String loc2 = a2.latitude + "," + a2.longitude;

                                String uri = base_url + "/viaroute?loc=" + loc1 + "&loc=" + loc2 + "&geometry=false&instructions=false&alt=false";
                                
                                HttpGet httpget = new HttpGet(uri);
                                
                                ResponseHandler<String> responseHandler = new ResponseHandler<String>() {

                        @Override
                        public String handleResponse(final HttpResponse response) throws ClientProtocolException, IOException {
                            int status = response.getStatusLine().getStatusCode();
                            
                            if (status >= 200 && status < 300) {
                                HttpEntity entity = response.getEntity();
                                return entity != null ? EntityUtils.toString(entity) : null;
                            } else {
                                throw new ClientProtocolException("Unexpected response status: " + status);
                            }
                        }

                    };
                    String responseBody = httpclient.execute(httpget, responseHandler);
                    
                                OSRMResponse res = gson.fromJson(responseBody, OSRMResponse.class);

                                
                    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 (Exception e) {
                        logger.log(Level.SEVERE, "Lookup failed", e);
                }

                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];
                                }

                        }

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