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;

/*
import dk.thoerup.osrmbinding.OSRMBinding;
import dk.thoerup.osrmbinding.ViarouteResult;
*/

public class OSRMHelper {
        
        private static final boolean ENABLE_OSRM = false;


        final static Logger logger = Logger.getLogger( OSRMHelper.class.toString() );

        Gson gson = new Gson();

        //static OSRMBinding binding = null;

        //final String host = "127.0.0.1";
        final String host = "10.30.2.103";
        final int port = 5000;
        final String base_url = "http://" + host + ":" + port;
/*
        private static synchronized void initOsrm() {
                if (binding == null) {
                        binding = new OSRMBinding("/home/openstreetmap/denmark-latest.osrm");
                }
        }
*/

        public Adresse getNearestTableHttp(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 getNearestTableJni(Adresse a1, Collection<Adresse> haystack) {
                if (binding == null) {
                        initOsrm();
                }

                Adresse bedsteAdresse = null;

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

                dk.thoerup.osrmbinding.Geopoint points[] = new dk.thoerup.osrmbinding.Geopoint[ hayArray.length + 1 ];
                points[0] = new dk.thoerup.osrmbinding.Geopoint( a1.latitude, a1.longitude);


                for(int i = 0; i<hayArray.length; i++) {
                        Adresse a = hayArray[i];
                        int idx = i+1;
                        points[idx] = new dk.thoerup.osrmbinding.Geopoint(a.latitude, a.longitude);
                }

                try {
                        float distance_table[][] = binding.table( points );

                        int bedsteTid = Integer.MAX_VALUE;

                        for (int i = 1; i<distance_table.length; i++) {
                                if (distance_table[0][i] < bedsteTid) {
                                        bedsteTid = (int) 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 bedsteAdresse;
        }*/
        

        public Adresse getNearestMultitargetHttp(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("/multitarget?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");
                        OSRMMultiTarget table = gson.fromJson(txtResponse, OSRMMultiTarget.class);


                        double bedsteAfstand = Double.MAX_VALUE;

                        for (int i = 1; i<table.distances.length; i++) {
                                if (table.distances[i].distance < bedsteAfstand) {
                                        bedsteAfstand = table.distances[i].distance;
                                        bedsteAdresse = hayArray[i];
                                }
                        }

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


                return bedsteAdresse;
        }
        
        public Adresse getNearestViarouteHttp(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 == 0) {
                                        continue;
                                }


                                if (res.route_summary.total_distance < bedsteAfstand) {
                                        bedsteAfstand = res.route_summary.total_distance;
                                        bedsteAdresse = a2;
                                }

                                if (bedsteAfstand < 200) { //vejdistance er tæt nok på
                                        return bedsteAdresse;
                                }
                    
                        }
                        
                } catch (Exception e) {
                        logger.log(Level.SEVERE, "Lookup failed", e);
                }

                return bedsteAdresse;
        }

/*      
        public Adresse getNearestViarouteJni(Adresse a1, Collection<Adresse> haystack) {

                if (binding == null) {
                        initOsrm();
                }


                int bedsteAfstand = Integer.MAX_VALUE;
                Adresse bedsteAdresse = null;
                
                        
                        for(Adresse a2: haystack) {

                    ViarouteResult res = binding.viaRoute(a1.latitude, a1.longitude, a2.latitude, a2.longitude);

                    
                    if (res.status != 0) {
                                        System.out.println("OSRM Returned " + res.status  );
                                        continue;
                                }

                                if (res.totalDistance == 0) {
                                        continue;
                                }


                                if (res.totalDistance < bedsteAfstand) {
                                        bedsteAfstand = res.totalDistance;
                                        bedsteAdresse = a2;
                                }

                                if (bedsteAfstand < 200) { //vejdistance er tæt nok på
                                        return bedsteAdresse;
                                }
                    
                        }                       

                return bedsteAdresse;
        }*/
}


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	2744	/*
31	torben	2741	import dk.thoerup.osrmbinding.OSRMBinding;
32			import dk.thoerup.osrmbinding.ViarouteResult;
33	torben	2744	*/
34	torben	2741
35	torben	2708	public class OSRMHelper {
36	torben	2744
37			private static final boolean ENABLE_OSRM = false;
38	torben	2733
39	torben	2744
40	torben	2720	final static Logger logger = Logger.getLogger( OSRMHelper.class.toString() );
41	torben	2733
42	torben	2708	Gson gson = new Gson();
43
44	torben	2744	//static OSRMBinding binding = null;
45	torben	2733
46	torben	2749	//final String host = "127.0.0.1";
47			final String host = "10.30.2.103";
48	torben	2730	final int port = 5000;
49			final String base_url = "http://" + host + ":" + port;
50	torben	2744	/*
51	torben	2741	private static synchronized void initOsrm() {
52			if (binding == null) {
53			binding = new OSRMBinding("/home/openstreetmap/denmark-latest.osrm");
54			}
55			}
56	torben	2744	*/
57	torben	2733
58	torben	2741	public Adresse getNearestTableHttp(Adresse a1, Collection<Adresse> haystack) {
59
60	torben	2708	Adresse bedsteAdresse = null;
61	torben	2733
62	torben	2708	Adresse hayArray[] = new Adresse[ haystack.size() ];
63			haystack.toArray(hayArray);
64	torben	2733
65	torben	2708	StringBuilder sb = new StringBuilder();
66			sb.append(base_url);
67			sb.append("/table?loc=").append(a1.latitude).append(",").append(a1.longitude);
68	torben	2733
69	torben	2708	for(int i = 0; i<hayArray.length; i++) {
70			Adresse a = hayArray[i];
71			sb.append("&loc=").append( a.latitude ).append(",").append(a.longitude);
72			}
73	torben	2733
74	torben	2708	try {
75			String txtResponse = HttpUtil.getContentString(sb.toString(), 500, "UTF-8");
76			OSRMDistanceTable table = gson.fromJson(txtResponse, OSRMDistanceTable.class);
77	torben	2723	if (table.status != 0) {
78			logger.info("OSRM failed with message: " + table.status_message);
79			return null;
80			}
81	torben	2733
82	torben	2708	int bedsteTid = Integer.MAX_VALUE;
83	torben	2733
84	torben	2708	for (int i = 1; i<table.distance_table.length; i++) {
85			if (table.distance_table[0][i] < bedsteTid) {
86			bedsteTid = table.distance_table[0][i];
87			int idx = i-1;
88			bedsteAdresse = hayArray[idx];
89			}
90			}
91
92			} catch (Exception e) {
93	torben	2720	logger.log(Level.SEVERE, "Lookup failed", e);
94	torben	2708	System.exit(1);
95			}
96	torben	2733
97	torben	2708	//return gson.fromJson(txtResponse, OSRMResponse.class);
98	torben	2733
99
100	torben	2708	return bedsteAdresse;
101			}
102	torben	2749
103
104
105	torben	2744	/*
106	torben	2741	public Adresse getNearestTableJni(Adresse a1, Collection<Adresse> haystack) {
107			if (binding == null) {
108			initOsrm();
109			}
110
111			Adresse bedsteAdresse = null;
112
113			Adresse hayArray[] = new Adresse[ haystack.size() ];
114			haystack.toArray(hayArray);
115
116			dk.thoerup.osrmbinding.Geopoint points[] = new dk.thoerup.osrmbinding.Geopoint[ hayArray.length + 1 ];
117			points[0] = new dk.thoerup.osrmbinding.Geopoint( a1.latitude, a1.longitude);
118
119
120			for(int i = 0; i<hayArray.length; i++) {
121			Adresse a = hayArray[i];
122			int idx = i+1;
123			points[idx] = new dk.thoerup.osrmbinding.Geopoint(a.latitude, a.longitude);
124			}
125
126			try {
127			float distance_table[][] = binding.table( points );
128
129			int bedsteTid = Integer.MAX_VALUE;
130
131			for (int i = 1; i<distance_table.length; i++) {
132			if (distance_table[0][i] < bedsteTid) {
133			bedsteTid = (int) distance_table[0][i];
134			int idx = i-1;
135			bedsteAdresse = hayArray[idx];
136			}
137			}
138
139			} catch (Exception e) {
140			logger.log(Level.SEVERE, "Lookup failed", e);
141			System.exit(1);
142			}
143
144			return bedsteAdresse;
145	torben	2744	}*/
146	torben	2735
147	torben	2749
148			public Adresse getNearestMultitargetHttp(Adresse a1, Collection<Adresse> haystack) {
149
150			Adresse bedsteAdresse = null;
151
152			Adresse hayArray[] = new Adresse[ haystack.size() ];
153			haystack.toArray(hayArray);
154
155			StringBuilder sb = new StringBuilder();
156			sb.append(base_url);
157			sb.append("/multitarget?loc=").append(a1.latitude).append(",").append(a1.longitude);
158
159			for(int i = 0; i<hayArray.length; i++) {
160			Adresse a = hayArray[i];
161			sb.append("&loc=").append( a.latitude ).append(",").append(a.longitude);
162			}
163
164			try {
165			String txtResponse = HttpUtil.getContentString(sb.toString(), 500, "UTF-8");
166			OSRMMultiTarget table = gson.fromJson(txtResponse, OSRMMultiTarget.class);
167
168
169			double bedsteAfstand = Double.MAX_VALUE;
170
171			for (int i = 1; i<table.distances.length; i++) {
172			if (table.distances[i].distance < bedsteAfstand) {
173			bedsteAfstand = table.distances[i].distance;
174			bedsteAdresse = hayArray[i];
175			}
176			}
177
178			} catch (Exception e) {
179			logger.log(Level.SEVERE, "Lookup failed", e);
180			System.exit(1);
181			}
182
183
184			return bedsteAdresse;
185			}
186
187	torben	2741	public Adresse getNearestViarouteHttp(Adresse a1, Collection<Adresse> haystack) {
188	torben	2735	int bedsteAfstand = Integer.MAX_VALUE;
189			Adresse bedsteAdresse = null;
190
191			try (CloseableHttpClient httpclient = HttpClients.createDefault()) {
192
193			String loc1 = a1.latitude + "," + a1.longitude;
194	torben	2730
195	torben	2735
196			for(Adresse a2: haystack) {
197			String loc2 = a2.latitude + "," + a2.longitude;
198
199			String uri = base_url + "/viaroute?loc=" + loc1 + "&loc=" + loc2 + "&geometry=false&instructions=false&alt=false";
200
201			HttpGet httpget = new HttpGet(uri);
202
203			ResponseHandler<String> responseHandler = new ResponseHandler<String>() {
204
205			@Override
206			public String handleResponse(final HttpResponse response) throws ClientProtocolException, IOException {
207			int status = response.getStatusLine().getStatusCode();
208
209			if (status >= 200 && status < 300) {
210			HttpEntity entity = response.getEntity();
211			return entity != null ? EntityUtils.toString(entity) : null;
212			} else {
213			throw new ClientProtocolException("Unexpected response status: " + status);
214			}
215			}
216
217			};
218			String responseBody = httpclient.execute(httpget, responseHandler);
219
220			OSRMResponse res = gson.fromJson(responseBody, OSRMResponse.class);
221
222
223
224			if (res.status != 0) {
225			System.out.println("OSRM Returned " + res.status + "/" + res.status_message );
226			continue;
227			}
228
229	torben	2741	if (res.route_summary.total_distance == 0) {
230			continue;
231			}
232	torben	2735
233	torben	2741
234	torben	2735	if (res.route_summary.total_distance < bedsteAfstand) {
235			bedsteAfstand = res.route_summary.total_distance;
236			bedsteAdresse = a2;
237			}
238	torben	2741
239			if (bedsteAfstand < 200) { //vejdistance er tæt nok på
240			return bedsteAdresse;
241			}
242	torben	2735
243			}
244
245			} catch (Exception e) {
246			logger.log(Level.SEVERE, "Lookup failed", e);
247			}
248
249			return bedsteAdresse;
250			}
251
252	torben	2744	/*
253	torben	2741	public Adresse getNearestViarouteJni(Adresse a1, Collection<Adresse> haystack) {
254	torben	2735
255	torben	2741	if (binding == null) {
256			initOsrm();
257			}
258	torben	2733
259	torben	2741
260	torben	2730	int bedsteAfstand = Integer.MAX_VALUE;
261			Adresse bedsteAdresse = null;
262	torben	2741
263
264			for(Adresse a2: haystack) {
265	torben	2730
266	torben	2741	ViarouteResult res = binding.viaRoute(a1.latitude, a1.longitude, a2.latitude, a2.longitude);
267	torben	2730
268	torben	2741
269			if (res.status != 0) {
270			System.out.println("OSRM Returned " + res.status );
271			continue;
272	torben	2733	}
273	torben	2730
274	torben	2741	if (res.totalDistance == 0) {
275	torben	2731	continue;
276			}
277	torben	2733
278
279	torben	2741	if (res.totalDistance < bedsteAfstand) {
280			bedsteAfstand = res.totalDistance;
281	torben	2708	bedsteAdresse = a2;
282			}
283	torben	2733
284	torben	2741	if (bedsteAfstand < 200) { //vejdistance er tæt nok på
285			return bedsteAdresse;
286			}
287
288			}
289	torben	2733
290	torben	2708	return bedsteAdresse;
291	torben	2744	}*/
292	torben	2741	}
293	torben	2733
294