Skip to content
Snippets Groups Projects
Commit 3bddc1c9 authored by unknown's avatar unknown
Browse files

clustering without a given k works now

parent 6f420b13
Branches
No related tags found
No related merge requests found
Show whitespace changes
Inline Side-by-side
Showing
with 269 additions and 166 deletions
src/main/java/de/hhu/ba/yoshikoWrapper/tasks/AlgorithmTask.java
+ 4
− 3
View file @ 3bddc1c9
...@@ -25,6 +25,7 @@ import java.awt.Window; ...@@ -25,6 +25,7 @@ import java.awt.Window;
import de.hhu.ba.yoshikoWrapper.yoshikoAlgorithm.YoshikoAlgoritmController; import de.hhu.ba.yoshikoWrapper.yoshikoAlgorithm.YoshikoAlgoritmController;
import org.cytoscape.model.CyNetwork; import org.cytoscape.model.CyNetwork;
import org.cytoscape.model.CyNode;
import org.cytoscape.model.CyTable; import org.cytoscape.model.CyTable;
import org.cytoscape.work.AbstractTask; import org.cytoscape.work.AbstractTask;
import org.cytoscape.work.ContainsTunables; import org.cytoscape.work.ContainsTunables;
...@@ -135,9 +136,9 @@ public class AlgorithmTask extends AbstractTask implements ObservableTask, Tunab ...@@ -135,9 +136,9 @@ public class AlgorithmTask extends AbstractTask implements ObservableTask, Tunab
taskMonitor.setProgress(0.99); taskMonitor.setProgress(0.99);
//Generate solutionsPanel //Generate solutionsPanel*/
resultPanel = new ResultPanel(result); //resultPanel = new ResultPanel(result);
/*
//Show solution panel //Show solution panel
CyCore.registrar.registerService(resultPanel,CytoPanelComponent.class, new Properties()); CyCore.registrar.registerService(resultPanel,CytoPanelComponent.class, new Properties());
//Focus solution panel //Focus solution panel
......
src/main/java/de/hhu/ba/yoshikoWrapper/yoshikoAlgorithm/BinaryHeap.java
+ 11
− 1
View file @ 3bddc1c9
...@@ -28,6 +28,10 @@ public class BinaryHeap { ...@@ -28,6 +28,10 @@ public class BinaryHeap {
public void remove(YoshikoEdge edge){ public void remove(YoshikoEdge edge){
int index = getIndexFromValue(edge); int index = getIndexFromValue(edge);
if (edge.weight != Double.NEGATIVE_INFINITY){
//System.out.println("MELDUNG 5");
}
if (index < 0){ if (index < 0){
//Die Kante wurde bereits auf "forbidden" gesetzt //Die Kante wurde bereits auf "forbidden" gesetzt
return; return;
...@@ -40,6 +44,12 @@ public class BinaryHeap { ...@@ -40,6 +44,12 @@ public class BinaryHeap {
list.remove(list.size()-1); list.remove(list.size()-1);
} }
public void removeIncidentEdges(int n1, int n2){
}
public void remove(Set<YoshikoEdge> edgeSet){ public void remove(Set<YoshikoEdge> edgeSet){
for (YoshikoEdge edge : edgeSet){ for (YoshikoEdge edge : edgeSet){
remove(edge); remove(edge);
...@@ -121,7 +131,7 @@ public class BinaryHeap { ...@@ -121,7 +131,7 @@ public class BinaryHeap {
if (entry.getKey() == 0){ if (entry.getKey() == 0){
//Der erste DummyEintrag im Heap soll ignoriert werden //Der erste DummyEintrag im Heap soll ignoriert werden
} }
else if (entry.getValue().equals(edge)) { else if (entry.getValue().edgeId == edge.edgeId) {
return entry.getKey(); return entry.getKey();
} }
} }
......
src/main/java/de/hhu/ba/yoshikoWrapper/yoshikoAlgorithm/ClusteringAlgorithm.java
+ 200
− 160
View file @ 3bddc1c9
package de.hhu.ba.yoshikoWrapper.yoshikoAlgorithm; package de.hhu.ba.yoshikoWrapper.yoshikoAlgorithm;
import java.util.ArrayList;
import java.util.List;
public class ClusteringAlgorithm { public class ClusteringAlgorithm {
private BinaryHeap bHeap; private BinaryHeap bHeap;
private double clusteringCost; private double clusteringCost;
private YoshikoEdge[][] edgeArray; private YoshikoEdge[][] edgeArray;
private int numberOfNodes; private int numberOfNodes;
List<Integer> nodeList;
List<List<Integer>> clusters;
public ClusteringAlgorithm(YoshikoEdge[][] edgeArray){ public ClusteringAlgorithm(YoshikoEdge[][] edgeArray){
this.edgeArray = edgeArray; this.edgeArray = edgeArray;
numberOfNodes = edgeArray.length; numberOfNodes = edgeArray.length;
clusters = new ArrayList<>();
} }
public void runAlgorithm(){ public List<List<Integer>> runAlgorithm(){
clusteringCost = 0; clusteringCost = 0;
bHeap = new BinaryHeap(); bHeap = new BinaryHeap();
...@@ -21,7 +28,15 @@ public class ClusteringAlgorithm { ...@@ -21,7 +28,15 @@ public class ClusteringAlgorithm {
initializeQueue(); initializeQueue();
workHeap(); workHeap();
addSingleNodesToClusters();
int counter = 0;
List<Integer> list = new ArrayList<>();
for (List<Integer> cluster : clusters){
counter += cluster.size();
}
System.out.println(clusteringCost); System.out.println(clusteringCost);
return clusters;
} }
private void initializeQueue(){ private void initializeQueue(){
...@@ -29,28 +44,35 @@ public class ClusteringAlgorithm { ...@@ -29,28 +44,35 @@ public class ClusteringAlgorithm {
for (int i=1; i<numberOfNodes; i++){ for (int i=1; i<numberOfNodes; i++){
for (int j=0; j<i; j++){ for (int j=0; j<i; j++){
initIcfIcp(i,j); YoshikoEdge edge = initIcfIcp(i,j);
} bHeap.add(edge);
} }
System.out.println("asd");
} }
/* System.out.println("MELDUNG 2");
private void addAllNotForbidden(Set<MyDefaultWeightedEdge> edgeSet){ initializeNodeList();
for (MyDefaultWeightedEdge e : edgeSet){
if(g.getEdgeWeight(e) != Double.NEGATIVE_INFINITY){
bHeap.add(e);
} }
private void initializeNodeList(){
this.nodeList = new ArrayList<>();
for(int i = 0; i < numberOfNodes; i++){
nodeList.add(i);
} }
} }
*/
private void initIcfIcp(int u, int v){ private YoshikoEdge initIcfIcp(int u, int v){
double icf = 0; double icf = 0;
double icp = 0; double icp = 0;
YoshikoEdge edge = edgeArray[u][v]; YoshikoEdge edge = edgeArray[u][v];
if (edge == null){
System.out.println("MELDUNG 1");
}
if (edge.weight == Double.NEGATIVE_INFINITY){
return null;
}
if (edge.weight > 0){ if (edge.weight > 0){
icf = edge.weight; icf = edge.weight;
} }
...@@ -84,11 +106,7 @@ public class ClusteringAlgorithm { ...@@ -84,11 +106,7 @@ public class ClusteringAlgorithm {
edge.icp = icp; edge.icp = icp;
edge.maxIcfIcp = Math.max(icf, icp); edge.maxIcfIcp = Math.max(icf, icp);
if (edge.maxIcfIcp > 25){ return edge;
System.out.println("asd");
}
bHeap.add(edge);
} }
private int makeEdgeId(int u, int v){ private int makeEdgeId(int u, int v){
...@@ -98,40 +116,17 @@ public class ClusteringAlgorithm { ...@@ -98,40 +116,17 @@ public class ClusteringAlgorithm {
return u*(u-1)+v; return u*(u-1)+v;
} }
/*
private void calculateIcp(Set<Long> vertexSet, Set<YoshikoEdge> edgeSet){
for (YoshikoEdge edge : edgeSet){
double icp = 0;
if (g.getEdgeWeight(edge) < 0){
icp = -(g.getEdgeWeight(edge));
}
for (Long v : vertexSet){
MyVertex v1 = g.getEdgeSource(edge);
MyVertex v2 = g.getEdgeTarget(edge);
if (v.equals(v1)||v.equals(v2)){
continue;
}
if (g.getEdgeWeight(g.getEdge(v, v1)) > 0 && g.getEdgeWeight(g.getEdge(v, v2)) < 0) {
icp = icp + Math.min(g.getEdgeWeight(g.getEdge(v, v1)), -g.getEdgeWeight(g.getEdge(v, v2)));
}else if (g.getEdgeWeight(g.getEdge(v, v1)) < 0 && g.getEdgeWeight(g.getEdge(v, v2)) > 0) {
icp = icp + Math.min(-g.getEdgeWeight(g.getEdge(v, v1)), g.getEdgeWeight(g.getEdge(v, v2)));
}
edge.icp = icp;
}
}
}
private void calculateMaxIcpIcf(Set<YoshikoEdge> edgeSet){
for (YoshikoEdge edge : edgeSet){
edge.calculateMaxIcfIcp();
}
}*/
private void workHeap(){ private void workHeap(){
int minH = 99999999;
while (bHeap.size() > 0){ while (bHeap.size() > 0){
if (minH < bHeap.size()){
System.out.println("MELDUNG 4");
}
if (bHeap.size()==21649){
System.out.println("MELDUNG 6");
}
minH=bHeap.size();
System.out.println(bHeap.size()); System.out.println(bHeap.size());
YoshikoEdge e=bHeap.popMax(); YoshikoEdge e=bHeap.popMax();
...@@ -146,7 +141,10 @@ public class ClusteringAlgorithm { ...@@ -146,7 +141,10 @@ public class ClusteringAlgorithm {
if(e.weight > 0){ if(e.weight > 0){
clusteringCost +=e.weight; clusteringCost +=e.weight;
} }
//makeEdgeForbidden(e); makeEdgeForbidden(e);
}
if (clusteringCost == Double.POSITIVE_INFINITY){
System.out.println("MELDUNG 7");
} }
} }
} }
...@@ -168,10 +166,13 @@ public class ClusteringAlgorithm { ...@@ -168,10 +166,13 @@ public class ClusteringAlgorithm {
private void makeEdgePermanent(YoshikoEdge e){ private void makeEdgePermanent(YoshikoEdge e){
substactInfluenceOfVerticesOnIcfIcp(e); substactInfluenceOfVerticesOnIcfIcp(e);
MyVertex mergedVertex = mergeVertexes(e); mergeVertexes(e);
calculateNewEdgesIcfIcp(mergedVertex);
calculateNewEdgesIcfIcp(e.source);
addInfluenceOfVertexOnIcfIcp(e.source);
addInfluenceOfVertexOnIcfIcp(mergedVertex); putInCluster(e);
System.out.println("perm"); System.out.println("perm");
} }
...@@ -179,66 +180,62 @@ public class ClusteringAlgorithm { ...@@ -179,66 +180,62 @@ public class ClusteringAlgorithm {
private void mergeVertexes(YoshikoEdge e){ private void mergeVertexes(YoshikoEdge e){
e.weight = Double.POSITIVE_INFINITY; e.weight = Double.POSITIVE_INFINITY;
int n1 = e.source;
int n2 = e.target;
} for (int v: nodeList){
if (v == n1|| v== n2){
/*
private MyVertex mergeVertexes(MyDefaultWeightedEdge e){
MyVertex p1 = g.getEdgeSource(e);
MyVertex p2 = g.getEdgeTarget(e);
MyVertex mergedVertex = new MyVertex(p1, p2);
g.addVertex(mergedVertex);
Set<MyVertex> vSet = g.vertexSet();
for (MyVertex v : vSet) {
if ((v.equals(p1))||(v.equals(p2))||(v.equals(mergedVertex))){
continue; continue;
} }
YoshikoEdge e1 = edgeArray[n1][v];
MyDefaultWeightedEdge p1Edge = g.getEdge(p1, v); if (e1 == null){
double p1EdgeWeight = g.getEdgeWeight(p1Edge); e1 = edgeArray[v][n1];
MyDefaultWeightedEdge p2Edge = g.getEdge(p2, v);
double p2EdgeWeight = g.getEdgeWeight(p2Edge);
MyDefaultWeightedEdge newEdge = g.addEdge(mergedVertex, v);
g.setEdgeWeight(newEdge, p1EdgeWeight+p2EdgeWeight);
} }
double e1Val = e1.weight;
bHeap.remove(g.outgoingEdgesOf(p1)); YoshikoEdge e2 = edgeArray[n2][v];
g.removeVertex(p1); if (e2 == null){
e2 = edgeArray[v][n2];
bHeap.remove(g.outgoingEdgesOf(p2));
g.removeVertex(p2);
return mergedVertex;
} }
double e2Val = e2.weight;
bHeap.remove(e2);
private void calculateNewEdgesIcfIcp(MyVertex mergedVertex){ double val = e1Val + e2Val;
Set<Long> vertexSet = g.vertexSet(); e1.weight = val;
Set<YoshikoEdge> newEdgesSet = g.outgoingEdgesOf(mergedVertex); if (val == Double.NEGATIVE_INFINITY){
bHeap.remove(e1);
calculateIcf(vertexSet, newEdgesSet); }
calculateIcp(vertexSet, newEdgesSet); }
calculateMaxIcpIcf(newEdgesSet); Integer k = n2;
nodeList.remove(k);
}
for(YoshikoEdge edge : newEdgesSet){ private void calculateNewEdgesIcfIcp(int node1){
if (g.getEdgeWeight(edge) == Double.NEGATIVE_INFINITY){ for (int node2 : nodeList){
if (node1 == node2){
continue; continue;
} }
bHeap.add(edge); if (node2 > node1){
int tmp = node1;
node1 = node2;
node2 = tmp;
}
YoshikoEdge e = edgeArray[node1][node2];
if (e.weight == Double.NEGATIVE_INFINITY){
continue;
}
initIcfIcp(node1, node2);
}
} }
}*/
private void substactInfluenceOfVerticesOnIcfIcp(YoshikoEdge e){ private void substactInfluenceOfVerticesOnIcfIcp(YoshikoEdge e){
int p1 = e.source; int p1 = e.source;
int p2 = e.target; int p2 = e.target;
for (YoshikoEdge edge : bHeap.map.values()){ for (YoshikoEdge edge : bHeap.map.values()){
if (edge == null){
continue;
}
int v1 = edge.source; int v1 = edge.source;
int v2 = edge.target; int v2 = edge.target;
...@@ -281,105 +278,148 @@ public class ClusteringAlgorithm { ...@@ -281,105 +278,148 @@ public class ClusteringAlgorithm {
edge.maxIcfIcp = Math.max(edge.icf, edge.icp); edge.maxIcfIcp = Math.max(edge.icf, edge.icp);
} }
} }
/*
private void addInfluenceOfVertexOnIcfIcp(MyVertex mergedVertex) {
Set<MyDefaultWeightedEdge> edgeSet = g.edgeSet();
for (MyDefaultWeightedEdge edge : edgeSet){ private void addInfluenceOfVertexOnIcfIcp(int mergedVertex) {
MyVertex v1 = g.getEdgeSource(edge); for (YoshikoEdge edge : bHeap.map.values()){
MyVertex v2 = g.getEdgeTarget(edge); if(edge == null){
continue;
}
int v1 = edge.source;
int v2 = edge.target;
if (v1.equals(mergedVertex)||v1.equals(mergedVertex)){ if (v1==mergedVertex||v2==mergedVertex){
continue; continue;
} }
//Addiere Einfluss des Dreiecks v1-MergedVertex-v2 auf icf //Addiere Einfluss des Dreiecks v1-MergedVertex-v2 auf icf
MyDefaultWeightedEdge ux = g.getEdge(v1, mergedVertex); YoshikoEdge ux = getEdge(v1, mergedVertex);
MyDefaultWeightedEdge vx = g.getEdge(v2, mergedVertex); YoshikoEdge vx = getEdge(v2, mergedVertex);
if (g.getEdgeWeight(ux) > 0 && g.getEdgeWeight(vx) > 0){ if (ux.weight > 0 && vx.weight > 0){
edge.icf += Math.min(g.getEdgeWeight(ux), g.getEdgeWeight(vx)); edge.icf += Math.min(ux.weight, vx.weight);
} }
//Addiere Einfluss des Dreiecks v1-MergedVertex-v2 auf icp //Addiere Einfluss des Dreiecks v1-MergedVertex-v2 auf icp
ux = g.getEdge(v1, mergedVertex); if (ux.weight > 0 && vx.weight < 0){
vx = g.getEdge(v2, mergedVertex); edge.icp += Math.min(ux.weight, -vx.weight);
}else if (ux.weight < 0 && vx.weight > 0){
if (g.getEdgeWeight(ux) > 0 && g.getEdgeWeight(vx) < 0){ edge.icp += Math.min(-ux.weight, vx.weight);
edge.icp += Math.min(g.getEdgeWeight(ux), -g.getEdgeWeight(vx));
}else if (g.getEdgeWeight(ux) < 0 && g.getEdgeWeight(vx) > 0){
edge.icp += Math.min(-g.getEdgeWeight(ux), g.getEdgeWeight(vx));
} }
} }
}*/ }
/*
private void makeEdgeForbidden(MyDefaultWeightedEdge e){
private void makeEdgeForbidden(YoshikoEdge e) {
editInfluenzeOfForbiddenEdge(e); editInfluenzeOfForbiddenEdge(e);
g.setEdgeWeight(e, Double.NEGATIVE_INFINITY); e.weight=Double.NEGATIVE_INFINITY;
bHeap.remove(e); bHeap.remove(e);
System.out.println("rm"); System.out.println("rm");
}*/ }
/*
private void editInfluenzeOfForbiddenEdge(MyDefaultWeightedEdge forbiddenEdge){ private void editInfluenzeOfForbiddenEdge(YoshikoEdge forbiddenEdge){
MyVertex x1 = g.getEdgeSource(forbiddenEdge); int x1 = forbiddenEdge.source;
MyVertex x2 = g.getEdgeTarget(forbiddenEdge); int x2 = forbiddenEdge.target;
Set<MyDefaultWeightedEdge> v1EdgeSet = g.outgoingEdgesOf(x1); for (int v : nodeList){
for (MyDefaultWeightedEdge edge : v1EdgeSet){ if (x1==v||x2==v){
MyVertex v1 = x1;
MyVertex v2 = g.getEdgeTarget(edge);
if (v2.equals(v1)){
v2 = g.getEdgeSource(edge);
}
if (v1.equals(x2)||v2.equals(x2)){
continue; continue;
} }
MyDefaultWeightedEdge edge2 = g.getEdge(v2, x2); YoshikoEdge edge1 = edgeArray[x1][v];
if (edge1 == null){
edge1 = edgeArray[v][x1];
}
YoshikoEdge edge2 = edgeArray[x2][v];
if (edge2 == null){
edge2 = edgeArray[v][x2];
}
if (g.getEdgeWeight(forbiddenEdge)>0 && g.getEdgeWeight(edge2) > 0){ if (forbiddenEdge.weight>0 && edge2.weight > 0){
edge.icf -= Math.min(g.getEdgeWeight(forbiddenEdge), g.getEdgeWeight(edge2)); edge1.icf -= Math.min(forbiddenEdge.weight, edge2.weight);
edge.icp += g.getEdgeWeight(edge2); edge1.icp += edge2.weight;
} }
if (g.getEdgeWeight(forbiddenEdge) > 0 && g.getEdgeWeight(edge2) < 0){ if (forbiddenEdge.weight > 0 && edge2.weight < 0){
edge.icp -= Math.min(g.getEdgeWeight(forbiddenEdge), -g.getEdgeWeight(edge2)); edge1.icp -= Math.min(forbiddenEdge.weight, -edge2.weight);
} else if (g.getEdgeWeight(forbiddenEdge) < 0 && g.getEdgeWeight(edge2) > 0){ } else if (forbiddenEdge.weight < 0 && edge2.weight > 0){
if (g.getEdgeWeight(forbiddenEdge)*(-1) < g.getEdgeWeight(edge2)){ if (forbiddenEdge.weight*(-1) < edge2.weight){
edge.icp += g.getEdgeWeight(edge2)+g.getEdgeWeight(forbiddenEdge); edge1.icp += edge2.weight+forbiddenEdge.weight;
} }
} }
if (forbiddenEdge.weight>0 && edge1.weight > 0){
edge2.icf -= Math.min(forbiddenEdge.weight, edge1.weight);
edge2.icp += edge1.weight;
} }
Set<MyDefaultWeightedEdge> v2EdgeSet = g.outgoingEdgesOf(x2); if (forbiddenEdge.weight > 0 && edge1.weight < 0){
for (MyDefaultWeightedEdge edge : v2EdgeSet){ edge2.icp -= Math.min(forbiddenEdge.weight, -edge1.weight);
MyVertex v1 = x2; } else if (forbiddenEdge.weight < 0 && edge1.weight > 0){
MyVertex v2 = g.getEdgeTarget(edge); if (forbiddenEdge.weight*(-1) < edge1.weight){
if (v2.equals(v1)){ edge2.icp += edge1.weight+forbiddenEdge.weight;
v2 = g.getEdgeSource(edge);
} }
if (v1.equals(x1)||v2.equals(x1)){
continue;
} }
}
}
private void putInCluster(YoshikoEdge edge){
Integer x1 = edge.source;
Integer x2 = edge.target;
int indexOfx1 = -1;
int indexOfx2 = -1;
if (edge.source == 242|| edge.target == 242){
System.out.println("asdasda");
}
for (List<Integer> cluster : clusters){
if (cluster.contains(x1)){
indexOfx1 = clusters.indexOf(cluster);
}else if (cluster.contains(x2)){
indexOfx2 = clusters.indexOf(cluster);
}
}
if (indexOfx1 >= 0){
if (indexOfx2 >= 0){
List<Integer> cluster1 = clusters.get(indexOfx1);
List<Integer> cluster2 = clusters.get(indexOfx2);
MyDefaultWeightedEdge edge2 = g.getEdge(v2, x1); cluster1.addAll(cluster2);
clusters.remove(cluster2);
}else {
List<Integer> cluster1 = clusters.get(indexOfx1);
cluster1.add(x2);
}
}else if (indexOfx2 >= 0){
List<Integer> cluster2 = clusters.get(indexOfx2);
cluster2.add(x1);
}else{
List<Integer> newCluster = new ArrayList<>();
newCluster.add(x1);
newCluster.add(x2);
if (g.getEdgeWeight(forbiddenEdge)>0 && g.getEdgeWeight(edge2) > 0){ clusters.add(newCluster);
edge.icf -= Math.min(g.getEdgeWeight(forbiddenEdge), g.getEdgeWeight(edge2)); }
edge.icp += g.getEdgeWeight(edge2);
}
private void addSingleNodesToClusters(){
for (int i = 0; i < numberOfNodes; i++){
nodeIsInCluster(i);
}
} }
if (g.getEdgeWeight(forbiddenEdge) > 0 && g.getEdgeWeight(edge2) < 0){ private void nodeIsInCluster(int i){
edge.icp -= Math.min(g.getEdgeWeight(forbiddenEdge), -g.getEdgeWeight(edge2)); for (List<Integer> cluster : clusters){
} else if (g.getEdgeWeight(forbiddenEdge) < 0 && g.getEdgeWeight(edge2) > 0){ if (cluster.contains(i)){
if (g.getEdgeWeight(forbiddenEdge)*(-1) < g.getEdgeWeight(edge2)){ return;
edge.icp += g.getEdgeWeight(edge2)+g.getEdgeWeight(forbiddenEdge);
} }
} }
List<Integer> newCluster = new ArrayList<>();
newCluster.add(i);
clusters.add(newCluster);
} }
}*/
} }
\ No newline at end of file
src/main/java/de/hhu/ba/yoshikoWrapper/yoshikoAlgorithm/GraphTranslator.java
+ 52
− 1
View file @ 3bddc1c9
package de.hhu.ba.yoshikoWrapper.yoshikoAlgorithm; package de.hhu.ba.yoshikoWrapper.yoshikoAlgorithm;
import de.hhu.ba.yoshikoWrapper.core.CyCore;
import de.hhu.ba.yoshikoWrapper.core.ParameterSet; import de.hhu.ba.yoshikoWrapper.core.ParameterSet;
import de.hhu.ba.yoshikoWrapper.cytoUtil.NodeMap;
import org.cytoscape.model.*; import org.cytoscape.model.*;
import org.cytoscape.model.subnetwork.CyRootNetwork;
import org.cytoscape.model.subnetwork.CySubNetwork;
import java.util.*; import java.util.*;
public class GraphTranslator { public final class GraphTranslator {
private CyNetwork network; private CyNetwork network;
private ParameterSet parameterSet; private ParameterSet parameterSet;
...@@ -94,4 +98,51 @@ public class GraphTranslator { ...@@ -94,4 +98,51 @@ public class GraphTranslator {
return weight; return weight;
} }
public void makeCytoscapeGraph(List<List<Integer>> clusters){
CySubNetwork resultNetwork = createNewGaph();
addNodesToResultNetwork(resultNetwork);
addEdgesToResultNetwork(clusters, resultNetwork);
}
private CySubNetwork createNewGaph(){
CyRootNetwork rootNetwork = CyCore.rootNetworkManager.getRootNetwork(network);
CySubNetwork resultNetwork = rootNetwork.addSubNetwork();
CyCore.networkManager.addNetwork(resultNetwork, false);
resultNetwork.getRow(resultNetwork).set(CyNetwork.NAME, "Result-Graph");
return resultNetwork;
}
private void addNodesToResultNetwork(CySubNetwork resultNetwork){
for (CyNode node : nodeMap.values()){
resultNetwork.addNode(node);
}
}
private void addEdgesToResultNetwork(List<List<Integer>> clusters, CySubNetwork resultNetwork){
for (List<Integer> cluster : clusters){
for (Integer i : cluster){
for (Integer j : cluster){
if (j<i){
addEdgeToResultNetwork(edgeArray[i][j],resultNetwork);
}
}
}
}
}
private void addEdgeToResultNetwork(YoshikoEdge yoshikoEdge, CySubNetwork resultNetwork) {
if (yoshikoEdge.suid < 0) {
CyNode node1 = nodeMap.get(yoshikoEdge.source);
CyNode node2 = nodeMap.get(yoshikoEdge.target);
CyEdge edge = resultNetwork.addEdge(node1, node2, false);
} else {
resultNetwork.addEdge(network.getEdge(yoshikoEdge.suid));
}
}
} }
src/main/java/de/hhu/ba/yoshikoWrapper/yoshikoAlgorithm/YoshikoAlgoritmController.java
+ 2
− 1
View file @ 3bddc1c9
...@@ -28,7 +28,8 @@ public class YoshikoAlgoritmController { ...@@ -28,7 +28,8 @@ public class YoshikoAlgoritmController {
YoshikoEdge[][] edgeArray = translator.translateGraph(); YoshikoEdge[][] edgeArray = translator.translateGraph();
ClusteringAlgorithm clusteringAlgorithm = new ClusteringAlgorithm(edgeArray); ClusteringAlgorithm clusteringAlgorithm = new ClusteringAlgorithm(edgeArray);
clusteringAlgorithm.runAlgorithm(); List<List<Integer>> clusters = clusteringAlgorithm.runAlgorithm();
translator.makeCytoscapeGraph(clusters);
} }
......
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment