/** Start the background thread. */
public void start() {
// create a random list of cities
cities = new City[TravelingSalesman.CITY_COUNT];
for (int i = 0; i < TravelingSalesman.CITY_COUNT; i++) {
cities[i] =
new City(
(int) (Math.random() * (getBounds().width - 10)),
(int) (Math.random() * (getBounds().height - 60)));
}
// create the initial chromosomes
chromosomes = new Chromosome[TravelingSalesman.POPULATION_SIZE];
for (int i = 0; i < TravelingSalesman.POPULATION_SIZE; i++) {
chromosomes[i] = new Chromosome(cities);
chromosomes[i].setCut(cutLength);
chromosomes[i].setMutation(TravelingSalesman.MUTATION_PERCENT);
}
Chromosome.sortChromosomes(chromosomes, TravelingSalesman.POPULATION_SIZE);
// start up the background thread
started = true;
map.update(map.getGraphics());
generation = 0;
if (worker != null) worker = null;
worker = new Thread(this);
// worker.setPriority(Thread.MIN_PRIORITY);
worker.start();
}
public SetIfModifiedSince() throws Exception {
serverSock = new ServerSocket(0);
int port = serverSock.getLocalPort();
Thread thr = new Thread(this);
thr.start();
Date date = new Date(new Date().getTime() - 1440000); // this time yesterday
URL url;
HttpURLConnection con;
// url = new URL(args[0]);
url = new URL("http://localhost:" + String.valueOf(port) + "/anything");
con = (HttpURLConnection) url.openConnection();
con.setIfModifiedSince(date.getTime());
con.connect();
int ret = con.getResponseCode();
if (ret == 304) {
System.out.println("Success!");
} else {
throw new RuntimeException(
"Test failed! Http return code using setIfModified method is:"
+ ret
+ "\nNOTE:some web servers are not implemented according to RFC, thus a failed test does not necessarily indicate a bug in setIfModifiedSince method");
}
}
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();
}
}
/**
* Creates an instance.
*
* @param pout Source of inputs
* @param jTextArea Where the inputs are written.
*/
public JConsoleOutLinker(PipedOutputStream pout, JTextArea jTextArea) {
try {
this.pin = new PipedInputStream(pout);
} catch (IOException ioe) {
throw new UIError("Unable to create input stream!");
}
this.jTextArea = jTextArea;
thisThread = new Thread(this);
thisThread.setDaemon(true);
thisThread.start();
}
public void start() {
if (t == null) {
t = new Thread(this);
t.start();
}
}
// 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;
}
// Overriding "start()"
public void start() {
running = true;
super.start();
}
/**
* the constructor of the class
*
* @param editor the editor
*/
public ResourceImageManager(Editor editor) {
this.editor = editor;
// the listener to the svg handle changes
editor
.getHandlesManager()
.addHandlesListener(
new HandlesListener() {
@Override
public void handleChanged(SVGHandle currentHandle, Set<SVGHandle> handles) {
// removes the frames that have been closed from the map
for (SVGHandle handle : new LinkedList<SVGHandle>(handleToIdToImages.keySet())) {
if (handle != null && !handles.contains(handle)) {
handleToIdToImages.remove(handle);
}
}
// removes the image representations that belongs to disposed
// svg handles
for (ResourceRepresentation rep :
new HashSet<ResourceRepresentation>(resourceRepresentationList)) {
if (rep != null && !handles.contains(rep.getSVGHandle())) {
rep.dispose();
resourceRepresentationList.remove(rep);
}
}
}
});
// sets the format used to convert numbers into a string
DecimalFormatSymbols symbols = new DecimalFormatSymbols();
symbols.setDecimalSeparator('.');
format = new DecimalFormat("######.#", symbols);
// the queue manager
queueManager =
new Thread() {
@Override
public void run() {
Runnable runnable = null;
while (true) {
while (queue.size() > 0) {
// getting the runnable
runnable = queue.get(0);
// removing it from the queue
queue.remove(runnable);
// running the runnable
runnable.run();
runnable = null;
}
try {
sleep(100);
} catch (InterruptedException ex) {
Thread.currentThread().interrupt();
}
}
}
};
queueManager.start();
}
public int onStartCommand(Intent intent, int flags, int startId) {
scanThread = new Thread(this);
scanThread.start();
return START_STICKY;
}
