/**
* Returns a List containing the nodes of the shortest path between v1 and v2, not including v1.
* The size of this List will be the length of the path.
*
* @param v1 The node to start at.
* @param v2 The node to end with.
* @return A List containing the shortest path, or null if no such path exists.
*/
public List<E> getShortestPath(V v1, V v2) {
if (dijkstra == null) {
// create a new DijkstraShortestPath
dijkstra = new DijkstraShortestPath<V, E>(this);
// listen for edge changes and reset DijkstraShortestPath
this.addEdgeChangeListener(
new GraphItemChangeListener<E>() {
public void stateChanged(GraphItemChangeEvent e) {
dijkstra.reset();
}
});
}
try {
return dijkstra.getPath(v1, v2);
} catch (NullPointerException e) {
return null;
}
}
@Override
public void solve() {
while (true) {
Mine mine = null;
mine = initialMine.clone();
Game game = new Game(mine);
while (game.getState() == GameState.Game) {
Cell robotCell = mine.getRobotCell();
String map = mine.toText();
String mapWithoutRobot = mine.toTextWithoutRobot();
if (!loseMovs.containsKey(map)) {
loseMovs.put(map, new HashSet<Movement>());
}
if (!loseLinks.containsKey(map)) {
loseLinks.put(map, new HashSet<CellsLink>());
}
if (!noWay.containsKey(map)) {
noWay.put(map, new HashSet<Coordinate>());
}
if (!attendedWalkingAroundCoordinates.containsKey(mapWithoutRobot)) {
attendedWalkingAroundCoordinates.put(mapWithoutRobot, new HashSet<Coordinate>());
}
attendedWalkingAroundCoordinates.get(mapWithoutRobot).add(robotCell.getCoordinate());
Set<Cell> targets = new HashSet<Cell>();
boolean isFreeWay = false;
for (Cell cell : mine.getAdjacentCells(robotCell)) {
Movement mov = robotCell.getCoordinate().getNecessaryMovement(cell.getCoordinate());
isFreeWay |=
!attendedWalkingAroundCoordinates.get(mapWithoutRobot).contains(cell.getCoordinate())
&& !loseMovs.get(map).contains(mov);
}
if (isFreeWay) {
targets.addAll(mine.findCells(CellContent.Lambda));
targets.addAll(mine.findCells(CellContent.HighOrderRock));
if (targets.size() == 0) targets.addAll(mine.findCells(CellContent.OpenLambdaLift));
targets.removeAll(mine.getCells(noWay.get(map)));
} else {
targets.addAll(mine.findCells(CellContent.Empty));
targets.addAll(mine.findCells(CellContent.Earth));
targets.addAll(mine.findCells(CellContent.HuttonsRazor));
for (CellContent content : CellContent.getTrampolines()) {
targets.addAll(mine.findCells(content));
}
targets.removeAll(mine.getCells(attendedWalkingAroundCoordinates.get(mapWithoutRobot)));
targets.removeAll(mine.getCells(noWay.get(map)));
if (targets.size() == 0) {
game.move(Movement.ABORT);
continue;
}
}
Graph<Cell, CellsLink> graph = getDirectedGraph(mine);
DijkstraShortestPath<Cell, CellsLink> alg =
new DijkstraShortestPath<Cell, CellsLink>(
graph, new CellsLinkTransformer<CellsLink, Double>());
Cell nextTarget = null;
List<CellsLink> routeToNextTarget = null;
double shortestDist = Double.MAX_VALUE;
for (Cell target : targets) {
List<CellsLink> route = null;
Number dist = null;
try {
route = alg.getPath(mine.getRobotCell(), target);
dist = alg.getDistance(mine.getRobotCell(), target);
} catch (IllegalArgumentException e) {
noWay.get(map).add(target.getCoordinate());
continue;
}
if (dist != null
&& route != null
&& route.size() > 0
&& dist.doubleValue() < shortestDist) {
CellsLink firstLink = route.get(0);
Movement mov =
firstLink
.getSource()
.getCoordinate()
.getNecessaryMovement(firstLink.getTarget().getCoordinate());
if (!loseMovs.get(map).contains(mov)
&& !attendedWalkingAroundCoordinates
.get(mapWithoutRobot)
.contains(target.getCoordinate())) {
shortestDist = dist.doubleValue();
nextTarget = target;
routeToNextTarget = route;
}
}
}
if (nextTarget != null) {
for (CellsLink link : routeToNextTarget) {
Cell source = link.getSource();
Cell target = link.getTarget();
if (isSafeMovement(mine, source, target)) {
Movement mov = source.getCoordinate().getNecessaryMovement(target.getCoordinate());
GameState state = game.move(mov);
if (state == GameState.Lose || state == GameState.Abort) {
loseMovs.get(map).add(mov);
loseLinks.get(map).add(link);
}
}
break;
}
} else {
// Walking around
for (Movement mov : Movement.values()) {
if (!loseMovs.get(map).contains(mov)) {
if (mov == Movement.RAZOR && mine.getRazorsCount() > 0) {
boolean isRazorApplied = false;
for (Cell cell : mine.getNeighboringCells(robotCell)) {
isRazorApplied |= cell.getContent() == CellContent.WadlersBeard;
}
if (!isRazorApplied) continue;
}
Cell movCell = null;
for (Cell cell : mine.getAdjacentCells(robotCell)) {
if (robotCell.getCoordinate().getNecessaryMovement(cell.getCoordinate()) == mov) {
if (!attendedWalkingAroundCoordinates
.get(mapWithoutRobot)
.contains(cell.getCoordinate())) {
movCell = cell;
break;
}
}
}
if (mov == Movement.WAIT
|| mov == Movement.RAZOR
|| movCell != null
&& !attendedWalkingAroundCoordinates
.get(mapWithoutRobot)
.contains(movCell.getCoordinate())) {
GameState state = game.move(mov);
if (movCell != null && mapWithoutRobot.equals(mine.toTextWithoutRobot()))
attendedWalkingAroundCoordinates
.get(mapWithoutRobot)
.add(movCell.getCoordinate());
if (state == GameState.Game && map.equals(mine.toText())) {
loseMovs.get(map).add(mov);
}
break;
}
}
}
}
}
addNewRoute(game);
attemptsCount++;
}
}
public static int[][] layerMalik(
String path,
DirectedGraph<NmvNode, NmvLink> myGraphMalik,
DirectedGraph<NmvNode, NmvLink> myGraphGrid) {
ArrayList<NmvNode> nodeListGrid =
new ArrayList<NmvNode>(TriGraphConstructor.myGraphGrid.getVertices());
ArrayList<NmvNode> nodeListMalik =
new ArrayList<NmvNode>(TriGraphConstructor.myGraphMalik.getVertices());
int[][] assocList = new int[nodeListMalik.size()][4];
boolean flag = false;
boolean use = true;
boolean repeat = true;
Random randomGen = new Random();
int[] taken = new int[nodeListMalik.size()];
int hub = 2;
int spokes = 5;
int gen = 0;
DijkstraShortestPath<NmvNode, NmvLink> sPath =
new DijkstraShortestPath<NmvNode, NmvLink>(myGraphGrid);
// place the hub nodes
for (int i = 1; i <= hub; i++) {
assocList[i - 1][0] = i; // Malik hub #
flag = true;
for (int u = 0; u < nodeListMalik.size(); u++) {
if ((nodeListMalik.get(u).getId().equals(String.valueOf(assocList[i - 1][0]))) && (flag)) {
flag = false;
assocList[i - 1][1] = u; // Malik hub index
}
}
// generate grid number and test for use
repeat = true;
while (repeat) {
use = true;
gen = randomGen.nextInt(101);
// test if it's been used
for (int t = 0; t < taken.length; t++) {
if (taken[t] == gen) use = false;
}
// don't use 0
if (gen == 0) use = false;
if (use) repeat = false;
}
assocList[i - 1][2] = gen; // Grid number
taken[i - 1] = gen;
flag = true;
for (int u = 0; u < nodeListGrid.size(); u++) {
if ((nodeListGrid.get(u).getId().equals(String.valueOf(assocList[i - 1][2]))) && (flag)) {
flag = false;
assocList[i - 1][3] = u; // Grid index
}
}
}
// place spoke nodes
int count = hub;
int[][] hubDist =
new int[hub][5]; // hub-grid #, hub-grid index, spoke-grid #, spoke-grid index, distance
int incumbent = 400;
boolean beaten = false;
// assign the grid numbers and indices to the hubDist array for the HUB nodes
for (int y = 0; y < hub; y++) {
hubDist[y][0] = assocList[y][2];
hubDist[y][1] = assocList[y][3];
}
for (int i = 0; i < hub; i++) {
for (int k = hub + spokes * i; k <= hub + spokes * (i + 1) - 1; k++) {
// assign spoke number and spoke list index to assocList
assocList[count][0] = k + 1; // Malik hub #
flag = true;
for (int u = 0; u < nodeListMalik.size(); u++) {
if ((nodeListMalik.get(u).getId().equals(String.valueOf(assocList[count][0])))
&& (flag)) {
flag = false;
assocList[count][1] = u; // Malik hub index
}
}
// generate grid number for spoke node and test for use
repeat = true;
while (repeat) {
use = true;
gen = randomGen.nextInt(101);
// test if taken
for (int t = 0; t < taken.length; t++) {
if (taken[t] == gen) use = false;
}
// test if 0
if (gen == 0) use = false;
// calculate the distance from the generated node to each of the hubs
for (int y = 0; y < hub; y++) {
hubDist[y][2] = gen;
flag = true;
for (int u = 0; u < nodeListGrid.size(); u++) {
if ((nodeListGrid.get(u).getId().equals(String.valueOf(gen))) && (flag)) {
flag = false;
hubDist[y][3] = u; // List index
}
}
List<NmvLink> shortestPath =
sPath.getPath(nodeListGrid.get(hubDist[y][1]), nodeListGrid.get(hubDist[y][3]));
hubDist[y][4] = shortestPath.size();
}
// test whether the distance to the current hub i is not longer than shortest (can be
// equal)
incumbent = hubDist[i][4];
beaten = false;
for (int y = 0; y < hub; y++) {
if (hubDist[y][4] < incumbent) beaten = true;
}
if (beaten) use = false;
if (use) repeat = false;
}
// insert the tested gen into the assocList
assocList[count][2] = gen; // Grid number
taken[count] = gen;
flag = true;
for (int u = 0; u < nodeListGrid.size(); u++) {
if ((nodeListGrid.get(u).getId().equals(String.valueOf(assocList[count][2]))) && (flag)) {
flag = false;
assocList[count][3] = u; // Grid index
}
}
count++;
}
}
String assocFile = path + "assocList.csv";
BufferedWriter bw = IOUtils.getBufferedWriter(assocFile);
try {
bw.write("Malik id, Malik index,Grid id, Grid index");
bw.newLine();
for (int j = 0; j < assocList.length; j++) {
bw.write(
String.format(
"%d,%d,%d,%d\n",
assocList[j][0], assocList[j][1], assocList[j][2], assocList[j][3]));
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
bw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
System.out.println("Association list written to file " + assocFile);
return assocList;
}
public static int[][] pathBuilder(
DirectedGraph<NmvNode, NmvLink> myGraphGrid, ArrayList<NmvNode> gridNodes, int s, int t) {
// System.out.println("Source "+gridNodes.get(s).getId());
// System.out.println("Target "+gridNodes.get(t).getId());
DijkstraShortestPath<NmvNode, NmvLink> gPath =
new DijkstraShortestPath<NmvNode, NmvLink>(myGraphGrid);
List<NmvLink> shortestPathGrid = gPath.getPath(gridNodes.get(s), gridNodes.get(t));
// System.out.println("Path length"+shortestPathGrid.size());
int numSteps = shortestPathGrid.size();
int count = 0;
int nonzeroSize = 0;
int[][] pathCollectInt = new int[500000][numSteps + 1];
for (int[] row : pathCollectInt) {
Arrays.fill(row, 999);
}
pathCollectInt[0][0] = s;
while (count <= numSteps) {
int[][] NEWpathCollect = new int[50000][numSteps + 1];
for (int[] row : NEWpathCollect) {
Arrays.fill(row, 999);
}
int countRows = 0;
int cycle = 0;
while (pathCollectInt[cycle][0]
== s) { // while there is still a row in pathCollect with entries
int currentNode = pathCollectInt[cycle][count];
Collection<NmvNode> success =
new LinkedList<NmvNode>(myGraphGrid.getSuccessors(gridNodes.get(currentNode)));
// need to prevent from going back
for (NmvNode sucNode : success) {
boolean contin = false;
List<NmvLink> path1 = gPath.getPath(gridNodes.get(s), sucNode);
List<NmvLink> path2 = gPath.getPath(sucNode, gridNodes.get(t));
// make sure it doesn't move further away
// path2 must now be shorter than it was in the previous iteration
List<NmvLink> path2Prev = gPath.getPath(gridNodes.get(currentNode), gridNodes.get(t));
if (numSteps == (path1.size() + path2.size()) && (path2.size() < path2Prev.size())) {
contin = true;
}
if (contin) {
for (int k = 0; k <= count; k++) {
NEWpathCollect[countRows][k] =
pathCollectInt[cycle][k]; // populate row in NEW matrix with existing values
}
NEWpathCollect[countRows][count + 1] =
gridNodes.indexOf(sucNode); // add the successor node
countRows++;
nonzeroSize = countRows;
}
}
// System.out.println("NEWpathCollect");
// int check2 = 0;
// while (NEWpathCollect[check2][0]==s){
// for (int r = 0; r<=count+1;r++){
// System.out.print(gridNodes.get(NEWpathCollect[check2][r]).getId()+" ");
// }
// check2++;
// System.out.println();
// }
// System.out.println();
cycle++;
// System.out.println("CountRows "+countRows);
}
// write out both matrices to check before overwriting
// System.out.println("pathCollect");
// int check1 = 0;
// while (pathCollectInt[check1][0]==s){
// for (int r = 0; r<=count;r++){
// System.out.print(gridNodes.get(pathCollectInt[check1][r]).getId()+" ");
// }
// check1++;
// System.out.println();
// }
//
if (NEWpathCollect[0][0] != 999) {
pathCollectInt = NEWpathCollect;
}
count++;
// System.out.println("count "+cycle);
// System.out.println("countRows "+ countRows);
// System.out.println("cycle "+cycle);
}
// System.out.println("pathCollectINT");
// for (int t1 =0;t1<100;t1++){
// for (int t2=0; t2<numSteps+1;t2++){
// System.out.print(pathCollectInt[t1][t2]+" ");
//// System.out.print(gridNodes.get(pathCollectFin[t1][t2]).getId()+" ");
// }
// System.out.println();
// }
// System.out.println("NonZeroSize "+nonzeroSize);
int[][] pathCollectFin = new int[nonzeroSize][numSteps + 1];
for (int t1 = 0; t1 < nonzeroSize; t1++) {
for (int t2 = 0; t2 < numSteps + 1; t2++) {
pathCollectFin[t1][t2] = pathCollectInt[t1][t2];
}
}
// System.out.println("pathCollectFIN");
// for (int t1 =0;t1<nonzeroSize;t1++){
// for (int t2=0; t2<numSteps+1;t2++){
//// System.out.print(pathCollectFin[t1][t2]+" ");
// System.out.print(gridNodes.get(pathCollectFin[t1][t2]).getId()+" ");
// }
// System.out.println();
// }
return pathCollectFin;
}
public static DirectedGraph<NmvNode, NmvLink> constructGhostGraph(
String path, int[][] assocList, int fullPathSize, int segSize) {
ArrayList<NmvNode> nodeListGrid =
new ArrayList<NmvNode>(TriGraphConstructor.myGraphGrid.getVertices());
ArrayList<NmvLink> linkListMalik =
new ArrayList<NmvLink>(TriGraphConstructor.myGraphMalik.getEdges());
ArrayList<NmvNode> nodeListMalik =
new ArrayList<NmvNode>(TriGraphConstructor.myGraphMalik.getVertices());
// Create the shortest path sets for each link in the Malik Graph
// The 0= FROM(MalikId), 1 = TO(MalikId), 2 = FROM(GridId), 3 = TO(GridId), 4 = # of shortest
// paths between the two, the rest is the shortest path Grid ids
int[][] logicalPathCollect = new int[50000][10 + 10 + 1 + 5];
for (int[] row : logicalPathCollect) {
Arrays.fill(row, 999);
}
int rowMarker = 0;
Collection<NmvLink> linkTrack = null;
Iterator<NmvLink> LinkIterator = linkListMalik.iterator();
Collection<NmvNode> nodeTrack = null;
while (LinkIterator.hasNext()) {
nodeTrack =
myGraphMalik.getIncidentVertices(LinkIterator.next()); // gets incident vertices to a link
if (nodeTrack.size() != 2) {
System.out.println("Incident vertices !=2: " + nodeTrack.size());
}
Iterator<NmvNode> NodeIterator = nodeTrack.iterator();
logicalPathCollect[rowMarker][0] =
Integer.parseInt(
NodeIterator.next().getId()); // place Malik id of incident vertices in array
// System.out.println("FROM= "+logicalPathCollect[rowMarker][0]);
logicalPathCollect[rowMarker][1] =
Integer.parseInt(
NodeIterator.next().getId()); // place Malik id of incident vertices in array
// System.out.println("TO= "+logicalPathCollect[rowMarker][1]);
int source = 0;
int target = 0;
for (int s = 0;
s < assocList.length;
s++) { // find the matching grid ids and put it in the array
if (logicalPathCollect[rowMarker][0] == assocList[s][0]) {
logicalPathCollect[rowMarker][2] = assocList[s][2];
source = s; // position in the assocList for the source node
break;
}
}
for (int t = 0; t < assocList.length; t++) {
if (logicalPathCollect[rowMarker][1] == assocList[t][0]) {
logicalPathCollect[rowMarker][3] = assocList[t][2];
target = t; // position in the assocList for the target node
break;
}
}
// System.out.println(String.format("%d,%d,%d,%d\n",
// logicalPathCollect[rowMarker][0],logicalPathCollect[rowMarker][1],logicalPathCollect[rowMarker][2],logicalPathCollect[rowMarker][3]));
// this call gives you all the shortest paths between two connected malik nodes
// System.out.println("Source Grid ID: "+assocList[source][3]+" Target Grid ID:
// "+assocList[target][3]);
int[][] interimPathCollect =
pathBuilder(myGraphGrid, nodeListGrid, assocList[source][3], assocList[target][3]);
// System.out.println(interimPathCollect.length);
// now add it to the logicalPathCollect
int mFId = logicalPathCollect[rowMarker][0];
int mTId = logicalPathCollect[rowMarker][1];
int gFId = logicalPathCollect[rowMarker][2];
int gTId = logicalPathCollect[rowMarker][3];
// System.out.println(String.format("%d,%d,%d,%d\n", mFId,mTId,gFId,gTId));
for (int i1 = 0; i1 < interimPathCollect.length; i1++) {
logicalPathCollect[rowMarker][0] = mFId;
logicalPathCollect[rowMarker][1] = mTId;
logicalPathCollect[rowMarker][2] = gFId;
logicalPathCollect[rowMarker][3] = gTId;
logicalPathCollect[rowMarker][4] = interimPathCollect[0].length;
for (int r = 1; r <= interimPathCollect[0].length; r++) {
logicalPathCollect[rowMarker][4 + r] = interimPathCollect[i1][r - 1];
} // add nodes to path
//
// System.out.println(String.format("%d,%d,%d,%d,%d,%d,%d\n",logicalPathCollect[rowMarker][0],logicalPathCollect[rowMarker][1],logicalPathCollect[rowMarker][2],logicalPathCollect[rowMarker][3],logicalPathCollect[rowMarker][4],logicalPathCollect[rowMarker][5],logicalPathCollect[rowMarker][4+interimPathCollect[0].length]));
rowMarker++;
} // while there are still paths in interimPathCollect
} // linklist iterator loop end
// write to file
String filenameL = path + "segmentPaths.csv";
BufferedWriter bl = IOUtils.getBufferedWriter(filenameL);
try {
for (int j = 0; j < rowMarker; j++) {
for (int r = 0; r < logicalPathCollect[0].length; r++) {
if (logicalPathCollect[j][r] != 999) {
if (r <= 4) {
bl.write(logicalPathCollect[j][r] + " ");
} else bl.write(nodeListGrid.get(logicalPathCollect[j][r]).getId() + " ");
}
}
bl.newLine();
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
bl.close();
} catch (IOException e) {
e.printStackTrace();
}
}
System.out.println("Segment paths written to " + filenameL);
// Now you have all the shortest paths for all the directly connected Malik links. Put them
// together to build the whole set.
// Create set of all shortest paths for Ghost Network
int[][] fullPathCollect = new int[fullPathSize][55];
for (int[] row : fullPathCollect) {
Arrays.fill(row, 999);
}
DijkstraShortestPath<NmvNode, NmvLink> mPath =
new DijkstraShortestPath<NmvNode, NmvLink>(myGraphMalik);
// int marker =0;
// int test =0;
// for each node pair in the assocList - remember that shortest path sets may eventually not be
// symmetric and therefore you have to do all
int rows = 0;
for (int y = 0; y < assocList.length; y++) {
for (int x = 0; x < assocList.length; x++) {
// for (int y = 0; y<3;y++){ //test
// for (int x = 1; x<8;x++){ //test
if (x != y) {
int[][] segment1 = new int[segSize][19];
for (int[] row : segment1) {
Arrays.fill(row, 999);
}
int seg1C = 0;
int[][] segment2 = new int[segSize][19];
for (int[] row : segment2) {
Arrays.fill(row, 999);
}
int seg2C = 0;
int[][] segment3 = new int[segSize][19];
for (int[] row : segment3) {
Arrays.fill(row, 999);
}
int seg3C = 0;
// get the logical shortest path first
List<NmvLink> shortestPathMalik =
mPath.getPath(nodeListMalik.get(assocList[y][1]), nodeListMalik.get(assocList[x][1]));
NmvNode FROM = null;
NmvNode TO = null;
// decide which loop depending on the logical path length
if (shortestPathMalik.size() == 1) {
Iterator<NmvLink> PathIterator = shortestPathMalik.iterator();
nodeTrack =
myGraphMalik.getIncidentVertices(
PathIterator.next()); // gets incident vertices to a link
Iterator<NmvNode> NodeIterator = nodeTrack.iterator();
// if only one leg
// populate the segment from the LogicalPathCollect
FROM = NodeIterator.next();
TO = NodeIterator.next();
// first find the paths and populate segment1
int w = 0;
for (int q = 0; q < rowMarker; q++) {
if ((logicalPathCollect[q][0] == Integer.parseInt(FROM.getId()))
&& (logicalPathCollect[q][1] == Integer.parseInt(TO.getId()))) {
// System.out.println("In here 1");
w = 0;
while (logicalPathCollect[q][5 + w] != 999) {
segment1[seg1C][w] = logicalPathCollect[q][5 + w];
w++;
}
seg1C++;
}
} // now all the paths are transferred to segment 1
// for(int q=0;q<seg1C;q++){
//
// System.out.println(String.format("%s,%s,%s\n",nodeListGrid.get(segment1[q][0]).getId(),nodeListGrid.get(segment1[q][1]).getId(),nodeListGrid.get(segment1[q][2]).getId()));
// }
// transfer to fullPathCollect
int v = 0;
for (int u = 0; u < seg1C; u++) {
v = 0;
while (segment1[u][v] != 999) {
fullPathCollect[rows + u][v] = segment1[u][v];
v++;
}
}
rows = rows + seg1C;
// System.out.println("Fullpath rows: "+rows);
// for (int q=0;q<seg1C;q++){
//
// System.out.print(String.format("%s,%s,%s\n",nodeListGrid.get(fullPathCollect[q][0]).getId(),nodeListGrid.get(fullPathCollect[q][1]).getId(),nodeListGrid.get(fullPathCollect[q][2]).getId()));
// }
} else if (shortestPathMalik.size() == 2) {
// if two legs
Iterator<NmvLink> PathIterator = shortestPathMalik.iterator();
// FIRST SEGMENT
nodeTrack = myGraphMalik.getIncidentVertices(PathIterator.next());
Iterator<NmvNode> NodeIterator = nodeTrack.iterator();
// populate the segment from the LogicalPathCollect
FROM = NodeIterator.next();
TO = NodeIterator.next();
// first find the paths and populate segment1
int w = 0;
for (int q = 0; q < rowMarker; q++) {
if ((logicalPathCollect[q][0] == Integer.parseInt(FROM.getId()))
&& (logicalPathCollect[q][1] == Integer.parseInt(TO.getId()))) {
w = 0;
while (logicalPathCollect[q][5 + w] != 999) {
segment1[seg1C][w] = logicalPathCollect[q][5 + w];
w++;
}
seg1C++;
}
} // now all the paths are transferred to segment 1
// System.out.println("Segment 1");
// for(int q=0;q<seg1C;q++){
//
// System.out.print(String.format("%s,%s,%s\n",nodeListGrid.get(segment1[q][0]).getId(),nodeListGrid.get(segment1[q][1]).getId(),nodeListGrid.get(segment1[q][2]).getId()));
// }
// SECOND SEGMENT
nodeTrack = myGraphMalik.getIncidentVertices(PathIterator.next());
NodeIterator = nodeTrack.iterator();
// populate the segment from the LogicalPathCollect
FROM = NodeIterator.next();
TO = NodeIterator.next();
// first find the paths and populate segment2
w = 0;
for (int q = 0; q < rowMarker; q++) {
if ((logicalPathCollect[q][0] == Integer.parseInt(FROM.getId()))
&& (logicalPathCollect[q][1] == Integer.parseInt(TO.getId()))) {
w = 0;
while (logicalPathCollect[q][5 + w] != 999) {
segment2[seg2C][w] = logicalPathCollect[q][5 + w];
w++;
}
seg2C++;
}
} // now all the paths are transferred to segment 2
// System.out.println("Segment 2");
// for(int q=0;q<seg2C;q++){
//
// System.out.print(String.format("%s,%s,%s\n",nodeListGrid.get(segment2[q][0]).getId(),nodeListGrid.get(segment2[q][1]).getId(),nodeListGrid.get(segment2[q][2]).getId()));
// }
// transfer to fullPathCollect
int v = 0;
int v1 = 1;
for (int u = 0; u < seg1C; u++) {
for (int r = 0; r < seg2C; r++) {
v = 0;
v1 = 1;
while (segment1[u][v] != 999) { // add first segment
fullPathCollect[rows][v] = segment1[u][v];
v++;
}
while (segment2[r][v1] != 999) { // add second segment
fullPathCollect[rows][v] = segment2[r][v1];
v++;
v1++;
}
rows++;
}
}
// System.out.println("Fullpath rows: "+rows);
} else if (shortestPathMalik.size() == 3) {
Iterator<NmvLink> PathIterator = shortestPathMalik.iterator();
// FIRST SEGMENT
nodeTrack = myGraphMalik.getIncidentVertices(PathIterator.next());
Iterator<NmvNode> NodeIterator = nodeTrack.iterator();
// populate the segment from the LogicalPathCollect
FROM = NodeIterator.next();
TO = NodeIterator.next();
// first find the paths and populate segment1
int w = 0;
for (int q = 0; q < rowMarker; q++) {
if ((logicalPathCollect[q][0] == Integer.parseInt(FROM.getId()))
&& (logicalPathCollect[q][1] == Integer.parseInt(TO.getId()))) {
w = 0;
while (logicalPathCollect[q][5 + w] != 999) {
segment1[seg1C][w] = logicalPathCollect[q][5 + w];
w++;
}
seg1C++;
}
} // now all the paths are transferred to segment 1
// SECOND SEGMENT
nodeTrack = myGraphMalik.getIncidentVertices(PathIterator.next());
NodeIterator = nodeTrack.iterator();
// populate the segment from the LogicalPathCollect
FROM = NodeIterator.next();
TO = NodeIterator.next();
// first find the paths and populate segment2
w = 0;
for (int q = 0; q < rowMarker; q++) {
if ((logicalPathCollect[q][0] == Integer.parseInt(FROM.getId()))
&& (logicalPathCollect[q][1] == Integer.parseInt(TO.getId()))) {
w = 0;
while (logicalPathCollect[q][5 + w] != 999) {
segment2[seg2C][w] = logicalPathCollect[q][5 + w];
w++;
}
seg2C++;
}
} // now all the paths are transferred to segment 2
// THIRD SEGMENT
nodeTrack = myGraphMalik.getIncidentVertices(PathIterator.next());
NodeIterator = nodeTrack.iterator();
// populate the segment from the LogicalPathCollect
FROM = NodeIterator.next();
TO = NodeIterator.next();
// first find the paths and populate segment3
w = 0;
for (int q = 0; q < rowMarker; q++) {
if ((logicalPathCollect[q][0] == Integer.parseInt(FROM.getId()))
&& (logicalPathCollect[q][1] == Integer.parseInt(TO.getId()))) {
w = 0;
while (logicalPathCollect[q][5 + w] != 999) {
segment3[seg3C][w] = logicalPathCollect[q][5 + w];
w++;
}
seg3C++;
}
} // now all the paths are transferred to segment 3
// transfer to fullPathCollect
int v = 0;
int v1 = 1;
int v2 = 1;
for (int u = 0; u < seg1C; u++) {
for (int r = 0; r < seg2C; r++) {
for (int p = 0; p < seg3C; p++) {
v = 0;
v1 = 1;
v2 = 1;
while (segment1[u][v] != 999) { // add first segment
fullPathCollect[rows][v] = segment1[u][v];
v++;
}
while (segment2[r][v1] != 999) { // add second segment
fullPathCollect[rows][v] = segment2[r][v1];
v++;
v1++;
}
while (segment3[p][v2] != 999) { // add third segment
fullPathCollect[rows][v] = segment3[p][v2];
v++;
v2++;
}
rows++;
}
}
}
} else System.out.println("YOUR LOGICAL PATH HAS MORE THAN THREE SEGMENTS");
// int [][] interimPathCollect = pathBuilder(myGraphGrid, nodeListGrid,assocList[y][3],
// assocList[x][3]);
// // int [][] interimPathCollect = pathBuilder(myGraphGrid,
// nodeListGrid,assocList[1][3], assocList[2][3]);
// //insert into fullPathCollect
// for (int u = 0; u<interimPathCollect.length;u++){
// for (int g=0;g<interimPathCollect[0].length;g++){
// fullPathCollect[marker][g]=interimPathCollect[u][g];
// }
// marker++;
//
// }
// test=test+interimPathCollect.length;
}
}
}
// write out full path set (on screen)
// write fullPathCollect out
String filename = path + "shortestPathSet.csv";
BufferedWriter bf = IOUtils.getBufferedWriter(filename);
try {
for (int j = 0; j < rows; j++) {
for (int r = 0; r < fullPathCollect[0].length; r++) {
if (fullPathCollect[j][r] != 999) {
bf.write(nodeListGrid.get(fullPathCollect[j][r]).getId() + " ");
}
}
bf.newLine();
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
bf.close();
} catch (IOException e) {
e.printStackTrace();
}
}
System.out.println("Full path set written to file " + filename);
// trim fullpathset
int[][] fullPathTrim = new int[rows][55];
for (int[] row : fullPathTrim) {
Arrays.fill(row, 999);
}
for (int j = 0; j < rows; j++) {
for (int t = 0; t < 55; t++) {
if (fullPathCollect[j][t] != 999) {
fullPathTrim[j][t] = Integer.parseInt(nodeListGrid.get(fullPathCollect[j][t]).getId());
}
}
}
// System.out.println("fullPathTrim.length = "+fullPathTrim.length);
// System.out.println();
// for (int y = 0;y<5;y++){
// System.out.println("# of entries"+fullPathTrim[y].length);
// for (int r=0;r<21;r++){
// System.out.print(fullPathTrim[y][r]+" ");
// }
// System.out.println();
//
// }
String filename2 = path + "shortestPathSetTRIM.csv";
BufferedWriter bt = IOUtils.getBufferedWriter(filename2);
try {
for (int j = 0; j < rows; j++) {
for (int r = 0; r < fullPathTrim[0].length; r++) {
if (fullPathTrim[j][r] != 999) {
bt.write(fullPathTrim[j][r] + " ");
}
}
bt.newLine();
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
bt.close();
} catch (IOException e) {
e.printStackTrace();
}
}
System.out.println("Full path set TRIM written to file " + filename2);
// get the linklist
// int[][] linkList= GhostLinkList.linkList(path, fullPathTrim);
int[][] linkList = GhostLinkList.linkList(path, rows);
double defaultTransProb = 1;
myGraphGhost = new DirectedSparseMultigraph<NmvNode, NmvLink>();
// create the node list
int[] uniqueNodesTemp = new int[linkList.length * 2];
int count = 0;
boolean flag = true;
int cur1 = 0;
int cur2 = 0;
int r = 0;
uniqueNodesTemp[0] = linkList[0][0];
for (int y = 0; y < linkList.length; y++) {
cur1 = linkList[y][0];
cur2 = linkList[y][1];
r = 0;
flag = true;
while ((flag) && (r <= count)) {
if (uniqueNodesTemp[r] == cur1) {
flag = false;
} else r++;
}
if (flag) {
count++;
uniqueNodesTemp[count] = cur1;
}
r = 0;
flag = true;
while ((flag) && (r <= count)) {
if (uniqueNodesTemp[r] == cur2) {
flag = false;
} else r++;
}
if (flag) {
count++;
uniqueNodesTemp[count] = cur2;
}
}
int[] uniqueNodes = new int[count + 1];
for (int w = 0; w <= count; w++) {
uniqueNodes[w] = uniqueNodesTemp[w];
}
ArrayList<NmvNode> nodeList = new ArrayList<NmvNode>();
// what you have in linkList is the grid graph ID not the index
for (int m = 0; m < uniqueNodes.length; m++) {
NmvNode currentNode = new NmvNode("", "", 0, 0);
currentNode = new NmvNode(Integer.toString(m), Integer.toString(uniqueNodes[m]), 0, 0);
nodeList.add(m, currentNode);
}
int indexTo = 0;
int indexFrom = 0;
for (int w = 0; w < linkList.length; w++) {
for (int q = 0; q < uniqueNodes.length; q++) {
if (uniqueNodes[q] == linkList[w][0]) {
indexFrom = q;
break;
}
}
for (int p = 0; p < uniqueNodes.length; p++) {
if (uniqueNodes[p] == linkList[w][1]) {
indexTo = p;
break;
}
}
myGraphGhost.addEdge(
new NmvLink(Integer.toString(w), linkList[w][2], defaultTransProb),
nodeList.get(indexFrom),
nodeList.get(indexTo),
EdgeType.DIRECTED);
}
return myGraphGhost;
}
