public void onDestroy() { running = false; if (scanThread != null) scanThread.interrupt(); if (myWLocate != null) myWLocate.doPause(); sensorManager.unregisterListener( this, sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER)); if (scanData.getmView() != null) { ((WindowManager) getSystemService(WINDOW_SERVICE)).removeView(scanData.getmView()); scanData.setmView(null); } try { if (wl != null) wl.release(); } catch (RuntimeException re) { } wl = null; try { scanThread.join(1000); } catch (InterruptedException ie) { } System.exit(0); }
public static void main(String[] args) { Thread thread = new Thread(new Download(args)); thread.setDaemon(true); thread.start(); try { thread.join(); } catch (Exception e) { e.printStackTrace(); } }
// TODO : if start or end is already in the highway, will occur the problem, need to fix public static double routingHierarchy( long startNode, long endNode, int startTime, int dayIndex, ArrayList<Long> pathNodeList) { // System.out.println("start finding the path..."); int debug = 0; try { if (!OSMData.nodeHashMap.containsKey(startNode) || !OSMData.nodeHashMap.containsKey(endNode)) { System.err.println("cannot find start or end node!"); return -1; } if (startNode == endNode) { System.out.println("start node is the same as end node."); return 0; } NodeInfo start = OSMData.nodeHashMap.get(startNode); NodeInfo end = OSMData.nodeHashMap.get(endNode); double minDistance = Geometry.calculateDistance(start.getLocation(), end.getLocation()); if (minDistance < 5) { // use normal A* algorithm to calculate small distance return routingAStar( start.getNodeId(), end.getNodeId(), OSMRouteParam.START_TIME, OSMRouteParam.DAY_INDEX, pathNodeList); } SearchingSharing sharingData = new SearchingSharing(); HashMap<Long, NodeInfoHelper> nodeForwardCache = new HashMap<Long, NodeInfoHelper>(); HashMap<Long, NodeInfoHelper> nodeReverseCache = new HashMap<Long, NodeInfoHelper>(); ForwardSearching forwardSearching = new ForwardSearching( startNode, endNode, startTime, dayIndex, sharingData, nodeForwardCache); ReverseSearching reverseSearching = new ReverseSearching(endNode, startNode, sharingData, nodeReverseCache); // two thread run simultaneously Thread forwardThread = new Thread(forwardSearching); Thread reverseThread = new Thread(reverseSearching); // search forward forwardThread.start(); // let forward searching for a while // Thread.sleep(100); // search reverse reverseThread.start(); // waiting for thread finish forwardThread.join(); reverseThread.join(); // get the searching intersects ArrayList<Long> intersectList = sharingData.getIntersectList(); // pick the least cost one according to time-dependent double minCost = Double.MAX_VALUE; ArrayList<Long> minCostPath = new ArrayList<Long>(); for (long intersect : intersectList) { NodeInfoHelper current = nodeForwardCache.get(intersect); // cost from source to intersect double cost = current.getCost(); current = nodeReverseCache.get(intersect); // update the reverse cost as forward cost current.setCost(cost); ArrayList<Long> reversePath = new ArrayList<Long>(); double totalCost = Double.MAX_VALUE; // recalculate from intersect to destination while (true) { long nodeId = current.getNodeId(); int timeIndex = startTime + (int) (current.getCost() / OSMParam.SECOND_PER_MINUTE / OSMRouteParam.TIME_INTERVAL); if (timeIndex > OSMRouteParam.TIME_RANGE - 1) // time [6am - 9 pm], we regard times after 9pm as constant edge weights timeIndex = OSMRouteParam.TIME_RANGE - 1; long nextNodeId = current.getParentId(); double arriveTime = current.getCost(); // arrive end if (nextNodeId == 0) { totalCost = arriveTime; break; } // add node reversePath.add(nextNodeId); // calculate cost according adjlist LinkedList<ToNodeInfo> adjNodeList = OSMData.adjListHashMap.get(nodeId); double costTime = 0; for (ToNodeInfo toNode : adjNodeList) { if (toNode.getNodeId() == nextNodeId) { int travelTime; // forward searching is time dependent if (toNode.isFix()) // fix time travelTime = toNode.getTravelTime(); else // fetch from time array travelTime = toNode.getSpecificTravelTime(dayIndex, timeIndex); costTime = arriveTime + (double) travelTime / OSMParam.MILLI_PER_SECOND; break; } } current = nodeReverseCache.get(nextNodeId); if (costTime == 0) System.err.println("cost time cannot be zero!"); else current.setCost(costTime); } // process the left nodes to real destination long lastNode = reversePath.get(reversePath.size() - 1); if (lastNode != endNode) { NodeInfo last = OSMData.nodeHashMap.get(lastNode); NodeInfo dest = OSMData.nodeHashMap.get(endNode); EdgeInfo onEdge = last.getEdgeFromNodes(dest); current = nodeReverseCache.get(lastNode); int totalDistance = onEdge.getDistance(); int distance; long toNodeId; if (onEdge.getStartNode() == lastNode) { // from start to middle distance = onEdge.getStartDistance(endNode); toNodeId = onEdge.getEndNode(); } else { // from end to middle distance = onEdge.getEndDistance(endNode); toNodeId = onEdge.getStartNode(); } LinkedList<ToNodeInfo> adjNodeList = OSMData.adjListHashMap.get(lastNode); double costTime = 0; int timeIndex = startTime + (int) (totalCost / OSMParam.SECOND_PER_MINUTE / OSMRouteParam.TIME_INTERVAL); if (timeIndex > OSMRouteParam.TIME_RANGE - 1) // time [6am - 9 pm], we regard times after 9pm as constant edge weights timeIndex = OSMRouteParam.TIME_RANGE - 1; for (ToNodeInfo toNode : adjNodeList) { if (toNode.getNodeId() == toNodeId) { int travelTime; // forward searching is time dependent if (toNode.isFix()) // fix time travelTime = toNode.getTravelTime(); else // fetch from time array travelTime = toNode.getSpecificTravelTime(dayIndex, timeIndex); costTime = (double) travelTime / OSMParam.MILLI_PER_SECOND; break; } } if (costTime != 0) { costTime *= (double) distance / totalDistance; } totalCost += costTime; // add cost reversePath.add(endNode); // add dest } // if found less cost path, build forward path if (totalCost < minCost) { ArrayList<Long> forwardPath = new ArrayList<Long>(); minCost = totalCost; current = nodeForwardCache.get(intersect); long traceNodeId = current.getParentId(); while (traceNodeId != 0) { forwardPath.add(traceNodeId); // add node current = nodeForwardCache.get(traceNodeId); traceNodeId = current.getParentId(); } Collections.reverse(forwardPath); // reverse the path list // record min-cost path, combine forward path and reverse path minCostPath = new ArrayList<Long>(); minCostPath.addAll(forwardPath); minCostPath.add(intersect); minCostPath.addAll(reversePath); // output kml // OSMOutput.generatePathKML(nodeHashMap, pathNodeList, "path_" + intersect); // ArrayList<Long> intersectNode = new ArrayList<Long>(); // intersectNode.add(intersect); // OSMOutput.generatePathNodeKML(nodeHashMap, intersectNode, "intersect_" + intersect); } } pathNodeList.addAll(minCostPath); return minCost; } catch (Exception e) { e.printStackTrace(); System.err.println("routingHierarchy: debug code " + debug); } return 0; }