Skip to content

Commit

Permalink
Merge pull request #19 from ProgrammingLife2016/TempGraphVisualizer
Browse files Browse the repository at this point in the history
Temp graph visualizer
  • Loading branch information
Pathemeous committed Apr 29, 2016
2 parents 73debd1 + c8287e0 commit 07f6461
Show file tree
Hide file tree
Showing 13 changed files with 534 additions and 280 deletions.
1 change: 1 addition & 0 deletions .gitignore
Original file line number Diff line number Diff line change
Expand Up @@ -253,3 +253,4 @@ nbproject/
build/
manifest.mf
build.xml
nbactions.xml
Original file line number Diff line number Diff line change
Expand Up @@ -29,11 +29,12 @@ public static void main(String[] args) {
//MutationAlgorithm m = new MutationAlgorithm();
//m.calc(g);
FindBubbles findBubbles = new FindBubbles(g);
findBubbles.calculateFlows();
FilterInDels filter = new FilterInDels(g);
Graph filteredGraph = filter.filterGraph();
filteredGraph.print();
g.print();
findBubbles.calculateBubbles();
// findBubbles.calculateFlows();
// FilterInDels filter = new FilterInDels(g);
// Graph filteredGraph = filter.filterGraph();
// filteredGraph.print();
//g.print();
//System.out.println(g.getNodes().get(8).getIn().get(0).getParent().getFlow());
long f = System.currentTimeMillis();
System.out.println("The algorithm took " + (f - e) + " milliseconds to run");
Expand Down
Original file line number Diff line number Diff line change
@@ -1,84 +1,84 @@
package nl.tudelft.pl2016gr2.core.algorithms;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.Set;

import nl.tudelft.pl2016gr2.model.Edge;
import nl.tudelft.pl2016gr2.model.Graph;
import nl.tudelft.pl2016gr2.model.Node;

public class FilterInDels {

private Graph graph;
/**
* Contains all nodes that are part of an indel
*/
private Set<Integer> usedNodes = new HashSet<>();

public FilterInDels(Graph graph) {
this.graph = graph;
}

public Graph filterGraph() {
ArrayList<Node> root = new ArrayList<>();
ArrayList<Node> nodes = graph.getNodes();
root.add(nodes.get(0));
root.add(nodes.get(1));
Graph filteredGraph = new Graph(root);

for (int i = 0; i < nodes.size(); i++) {
Node source = nodes.get(i);

if (!usedNodes.contains(source.getId())) {
Node[] res = getInsertion(source);
if (res != null) {
Node insertion = res[0];
Node end = res[1];

usedNodes.add(insertion.getId());
Node inDel = new Node(source.getId());
inDel.setInDel(true);
inDel.setBubbleStart(source.getId());
inDel.setBubbleEnd(end.getId());

for (Edge edge : source.getIn()) {
inDel.addIn(edge);
}

for (Edge edge : end.getOut()) {
inDel.addOut(edge);
}

filteredGraph.addNode(inDel);
} else {
filteredGraph.addNode(source);
}
}
}

return filteredGraph;
}

private Node[] getInsertion(Node source) {
ArrayList<Edge> outEdges = source.getOut();

if (outEdges.size() != 2) {
return null;
}

Node target1 = outEdges.get(0).getTarget();
Node target2 = outEdges.get(1).getTarget();

// First one is the insertion, second one is the initial endpoint
if (target1.getOut().size() != 0 && target1.getOut().get(0).getTarget().equals(target2) && target1.getIn().size() == 1 && target2.getIn().size() == 2) {
Node[] res = {target1, target2};
return res;
} else if(target2.getOut().size() != 0 && target2.getOut().get(0).getTarget().equals(target1) && target2.getIn().size() == 1 && target1.getIn().size() == 2) {
Node[] res = {target2, target1};
return res;
}

return null;
}
}
//package nl.tudelft.pl2016gr2.core.algorithms;
//
//import java.util.ArrayList;
//import java.util.HashSet;
//import java.util.Set;
//
//import nl.tudelft.pl2016gr2.model.Edge;
//import nl.tudelft.pl2016gr2.model.Graph;
//import nl.tudelft.pl2016gr2.model.Node;
//
//public class FilterInDels {
//
// private Graph graph;
// /**
// * Contains all nodes that are part of an indel
// */
// private Set<Integer> usedNodes = new HashSet<>();
//
// public FilterInDels(Graph graph) {
// this.graph = graph;
// }
//
// public Graph filterGraph() {
// ArrayList<Node> root = new ArrayList<>();
// ArrayList<Node> nodes = graph.getNodes();
// root.add(nodes.get(0));
// root.add(nodes.get(1));
// Graph filteredGraph = new Graph(root);
//
// for (int i = 0; i < nodes.size(); i++) {
// Node source = nodes.get(i);
//
// if (!usedNodes.contains(source.getId())) {
// Node[] res = getInsertion(source);
// if (res != null) {
// Node insertion = res[0];
// Node end = res[1];
//
// usedNodes.add(insertion.getId());
// Node inDel = new Node(source.getId());
// inDel.setInDel(true);
// inDel.setBubbleStart(source.getId());
// inDel.setBubbleEnd(end.getId());
//
// for (Edge edge : source.getIn()) {
// inDel.addIn(edge);
// }
//
// for (Edge edge : end.getOut()) {
// inDel.addOut(edge);
// }
//
// filteredGraph.addNode(inDel);
// } else {
// filteredGraph.addNode(source);
// }
// }
// }
//
// return filteredGraph;
// }
//
// private Node[] getInsertion(Node source) {
// ArrayList<Edge> outEdges = source.getOut();
//
// if (outEdges.size() != 2) {
// return null;
// }
//
// Node target1 = outEdges.get(0).getTarget();
// Node target2 = outEdges.get(1).getTarget();
//
// // First one is the insertion, second one is the initial endpoint
// if (target1.getOut().size() != 0 && target1.getOut().get(0).getTarget().equals(target2) && target1.getIn().size() == 1 && target2.getIn().size() == 2) {
// Node[] res = {target1, target2};
// return res;
// } else if(target2.getOut().size() != 0 && target2.getOut().get(0).getTarget().equals(target1) && target2.getIn().size() == 1 && target1.getIn().size() == 2) {
// Node[] res = {target2, target1};
// return res;
// }
//
// return null;
// }
//}
Original file line number Diff line number Diff line change
@@ -1,39 +1,142 @@
package nl.tudelft.pl2016gr2.core.algorithms;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Set;

import nl.tudelft.pl2016gr2.model.Edge;
import nl.tudelft.pl2016gr2.model.Bubble;
import nl.tudelft.pl2016gr2.model.Graph;
import nl.tudelft.pl2016gr2.model.Node;

public class FindBubbles {

private Graph graph;
private HashMap<Integer, PriorityQueue<Bubble>> bubbles = new HashMap<>();;
private Set<Bubble> collapsedBubbles = new HashSet<>();
private PriorityQueue<Node> flows;

public FindBubbles(Graph graph) {
this.graph = graph;

flows = new PriorityQueue<>((Node node1, Node node2) -> {
int comparison = Double.compare(node1.getFlow(), node2.getFlow());

if (comparison == 0) {
return Integer.compare(node1.getId(), node2.getId());
}

return comparison;
});
}

public void calculateFlows() {
public Graph calculateBubbles() {
Graph overview = new Graph(new ArrayList<Bubble>());

init();
sendFlow();

while(!flows.isEmpty()) {
Node curNode = flows.poll();
//System.out.println(curNode);

Node nextNode = flows.peek();

if (curNode.getFlow() == nextNode.getFlow()) {
// is bubble
Bubble bubble = new Bubble(curNode.getId());
bubble.setInLinks(curNode.getInLinks());
bubble.setOutLinks(nextNode.getOutLinks());
bubble.setStartBubble(curNode);
bubble.setEndBubble(nextNode);
findNestedBubbles(curNode, nextNode, bubble);
bubbles.get(bubble.getId()).offer(bubble);
}
}

for (PriorityQueue<Bubble> bubbleLevels : bubbles.values()) {
overview.addNode(bubbleLevels.peek());
}

return overview;
}

private void findNestedBubbles(Bubble startBubble, Bubble endBubble, Bubble newBubble) {
if (startBubble.getOutLinks().size() == 1 && startBubble.getOutLinks().get(0).equals(endBubble)) {
return;
}

Set<Integer> visited = new HashSet<>();
visited.add(endBubble.getId());

Queue<Integer> toVisit = new LinkedList<>();
toVisit.addAll(startBubble.getOutLinks());

int highestLevel = 0;

while (!toVisit.isEmpty()) {
Bubble bubble = bubbles.get(toVisit.poll()).peek();

if (!bubble.equals(endBubble)) {
newBubble.addNestedBubble(bubble.getId());
visited.add(bubble.getId());

highestLevel = bubble.getLevel() > highestLevel ? bubble.getLevel() : highestLevel;

for (Integer target : bubble.getOutLinks()) {
if (!visited.contains(target)) {
toVisit.add(target);
}
}
}
}

newBubble.setLevel(highestLevel);
}

private void init() {
// Puts the bubble with the highest level first
Comparator<Bubble> compareLevels = (Bubble bubble1, Bubble bubble2) -> {
return Integer.compare(bubble2.getLevel(), bubble1.getLevel());
};

for (Bubble node : graph.getNodes()) {
PriorityQueue<Bubble> levels = new PriorityQueue<>(compareLevels);
levels.add(node);
bubbles.put(node.getId(), levels);
}
}

private void sendFlow() {
double flowStart = (double)graph.getSize();
graph.getRoot().setFlow(flowStart);
//graph.getRoot().setFlow(flowStart);
Node root = (Node) graph.getRoot();
root.setFlow(flowStart);

for (Node node : graph.getNodes()) {
System.out.println(node);
ArrayList<Edge> outEdges = node.getOut();
for (Bubble bubble : graph.getNodes()) {
Node node = (Node) bubble;
flows.offer(node);

// System.out.println(node);
ArrayList<Integer> outLinks = node.getOutLinks();
double remainingFlow = node.getFlow();

for (int i = 0; i < outEdges.size(); i++) {
Node target = outEdges.get(i).getTarget();
for (int i = 0; i < outLinks.size(); i++) {
Node target = (Node) bubbles.get(outLinks.get(i)).peek();

if (i == node.getOut().size() - 1) {
if (i == outLinks.size() - 1) {
target.addFlow(remainingFlow);
} else {
double random = Math.random();
if (random == 0) {
random += 0.1;
} else if (random == 1) {
random -= 0.1;
}
double flowToAdd = random * remainingFlow;
remainingFlow -= flowToAdd;
target.addFlow(flowToAdd);
Expand Down
Original file line number Diff line number Diff line change
@@ -1,12 +1,5 @@
package nl.tudelft.pl2016gr2.core.algorithms;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Queue;

import nl.tudelft.pl2016gr2.model.Edge;
import nl.tudelft.pl2016gr2.model.Graph;
import nl.tudelft.pl2016gr2.model.Node;


public class MutationAlgorithm {
Expand Down
Loading

0 comments on commit 07f6461

Please sign in to comment.