diff --git a/src/main/java/de/hhu/ba/yoshikoWrapper/tasks/AlgorithmTask.java b/src/main/java/de/hhu/ba/yoshikoWrapper/tasks/AlgorithmTask.java index 65c4a5e0a3f019cff91d7e1f2c8a63569fbe0f3a..daedf67b38cc1f8c3411ac3a37eee812ff0d17d4 100644 --- a/src/main/java/de/hhu/ba/yoshikoWrapper/tasks/AlgorithmTask.java +++ b/src/main/java/de/hhu/ba/yoshikoWrapper/tasks/AlgorithmTask.java @@ -25,6 +25,7 @@ import java.awt.Window; import de.hhu.ba.yoshikoWrapper.yoshikoAlgorithm.YoshikoAlgoritmController; import org.cytoscape.model.CyNetwork; +import org.cytoscape.model.CyNode; import org.cytoscape.model.CyTable; import org.cytoscape.work.AbstractTask; import org.cytoscape.work.ContainsTunables; @@ -135,9 +136,9 @@ public class AlgorithmTask extends AbstractTask implements ObservableTask, Tunab taskMonitor.setProgress(0.99); - //Generate solutionsPanel - resultPanel = new ResultPanel(result); - + //Generate solutionsPanel*/ + //resultPanel = new ResultPanel(result); +/* //Show solution panel CyCore.registrar.registerService(resultPanel,CytoPanelComponent.class, new Properties()); //Focus solution panel diff --git a/src/main/java/de/hhu/ba/yoshikoWrapper/yoshikoAlgorithm/BinaryHeap.java b/src/main/java/de/hhu/ba/yoshikoWrapper/yoshikoAlgorithm/BinaryHeap.java index a9156e409187bf8fb31c8585aa5dc1f281c5f3e1..cba75fb0352814b5a736c8117b6498e0bfeedbdf 100644 --- a/src/main/java/de/hhu/ba/yoshikoWrapper/yoshikoAlgorithm/BinaryHeap.java +++ b/src/main/java/de/hhu/ba/yoshikoWrapper/yoshikoAlgorithm/BinaryHeap.java @@ -28,6 +28,10 @@ public class BinaryHeap { public void remove(YoshikoEdge edge){ int index = getIndexFromValue(edge); + if (edge.weight != Double.NEGATIVE_INFINITY){ + //System.out.println("MELDUNG 5"); + } + if (index < 0){ //Die Kante wurde bereits auf "forbidden" gesetzt return; @@ -40,6 +44,12 @@ public class BinaryHeap { list.remove(list.size()-1); } + + public void removeIncidentEdges(int n1, int n2){ + + } + + public void remove(Set<YoshikoEdge> edgeSet){ for (YoshikoEdge edge : edgeSet){ remove(edge); @@ -121,7 +131,7 @@ public class BinaryHeap { if (entry.getKey() == 0){ //Der erste DummyEintrag im Heap soll ignoriert werden } - else if (entry.getValue().equals(edge)) { + else if (entry.getValue().edgeId == edge.edgeId) { return entry.getKey(); } } diff --git a/src/main/java/de/hhu/ba/yoshikoWrapper/yoshikoAlgorithm/ClusteringAlgorithm.java b/src/main/java/de/hhu/ba/yoshikoWrapper/yoshikoAlgorithm/ClusteringAlgorithm.java index 2b3dc00f7ba47e60d1eb139703ad9fde4bc948da..c82f42afdf75f71122f742bffcae32fd5efb84f2 100644 --- a/src/main/java/de/hhu/ba/yoshikoWrapper/yoshikoAlgorithm/ClusteringAlgorithm.java +++ b/src/main/java/de/hhu/ba/yoshikoWrapper/yoshikoAlgorithm/ClusteringAlgorithm.java @@ -1,19 +1,26 @@ package de.hhu.ba.yoshikoWrapper.yoshikoAlgorithm; +import java.util.ArrayList; +import java.util.List; + public class ClusteringAlgorithm { private BinaryHeap bHeap; private double clusteringCost; private YoshikoEdge[][] edgeArray; private int numberOfNodes; + List<Integer> nodeList; + List<List<Integer>> clusters; + public ClusteringAlgorithm(YoshikoEdge[][] edgeArray){ this.edgeArray = edgeArray; numberOfNodes = edgeArray.length; + clusters = new ArrayList<>(); } - public void runAlgorithm(){ + public List<List<Integer>> runAlgorithm(){ clusteringCost = 0; bHeap = new BinaryHeap(); @@ -21,7 +28,15 @@ public class ClusteringAlgorithm { initializeQueue(); workHeap(); + addSingleNodesToClusters(); + int counter = 0; + List<Integer> list = new ArrayList<>(); + for (List<Integer> cluster : clusters){ + counter += cluster.size(); + } + System.out.println(clusteringCost); + return clusters; } private void initializeQueue(){ @@ -29,28 +44,35 @@ public class ClusteringAlgorithm { for (int i=1; i<numberOfNodes; i++){ 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"); + initializeNodeList(); } -/* - private void addAllNotForbidden(Set<MyDefaultWeightedEdge> edgeSet){ - 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 icp = 0; 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){ icf = edge.weight; } @@ -84,11 +106,7 @@ public class ClusteringAlgorithm { edge.icp = icp; edge.maxIcfIcp = Math.max(icf, icp); - if (edge.maxIcfIcp > 25){ - System.out.println("asd"); - } - - bHeap.add(edge); + return edge; } private int makeEdgeId(int u, int v){ @@ -98,42 +116,19 @@ public class ClusteringAlgorithm { 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(){ + int minH = 99999999; 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()); - YoshikoEdge e= bHeap.popMax(); + YoshikoEdge e=bHeap.popMax(); if (e.icf >= e.icp){ @@ -146,7 +141,10 @@ public class ClusteringAlgorithm { if(e.weight > 0){ clusteringCost +=e.weight; } - //makeEdgeForbidden(e); + makeEdgeForbidden(e); + } + if (clusteringCost == Double.POSITIVE_INFINITY){ + System.out.println("MELDUNG 7"); } } } @@ -168,10 +166,13 @@ public class ClusteringAlgorithm { private void makeEdgePermanent(YoshikoEdge e){ substactInfluenceOfVerticesOnIcfIcp(e); - MyVertex mergedVertex = mergeVertexes(e); - calculateNewEdgesIcfIcp(mergedVertex); + mergeVertexes(e); - addInfluenceOfVertexOnIcfIcp(mergedVertex); + calculateNewEdgesIcfIcp(e.source); + + addInfluenceOfVertexOnIcfIcp(e.source); + + putInCluster(e); System.out.println("perm"); } @@ -179,66 +180,62 @@ public class ClusteringAlgorithm { private void mergeVertexes(YoshikoEdge e){ e.weight = Double.POSITIVE_INFINITY; - - } + int n1 = e.source; + int n2 = e.target; - - /* - 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))){ + for (int v: nodeList){ + if (v == n1|| v== n2){ continue; } + YoshikoEdge e1 = edgeArray[n1][v]; + if (e1 == null){ + e1 = edgeArray[v][n1]; + } + double e1Val = e1.weight; - MyDefaultWeightedEdge p1Edge = g.getEdge(p1, v); - double p1EdgeWeight = g.getEdgeWeight(p1Edge); - - MyDefaultWeightedEdge p2Edge = g.getEdge(p2, v); - double p2EdgeWeight = g.getEdgeWeight(p2Edge); + YoshikoEdge e2 = edgeArray[n2][v]; + if (e2 == null){ + e2 = edgeArray[v][n2]; + } + double e2Val = e2.weight; + bHeap.remove(e2); - MyDefaultWeightedEdge newEdge = g.addEdge(mergedVertex, v); - g.setEdgeWeight(newEdge, p1EdgeWeight+p2EdgeWeight); + double val = e1Val + e2Val; + e1.weight = val; + if (val == Double.NEGATIVE_INFINITY){ + bHeap.remove(e1); + } } - - bHeap.remove(g.outgoingEdgesOf(p1)); - g.removeVertex(p1); - - bHeap.remove(g.outgoingEdgesOf(p2)); - g.removeVertex(p2); - - return mergedVertex; + Integer k = n2; + nodeList.remove(k); } - private void calculateNewEdgesIcfIcp(MyVertex mergedVertex){ - Set<Long> vertexSet = g.vertexSet(); - Set<YoshikoEdge> newEdgesSet = g.outgoingEdgesOf(mergedVertex); - - calculateIcf(vertexSet, newEdgesSet); - calculateIcp(vertexSet, newEdgesSet); - calculateMaxIcpIcf(newEdgesSet); - - for(YoshikoEdge edge : newEdgesSet){ - if (g.getEdgeWeight(edge) == Double.NEGATIVE_INFINITY){ + private void calculateNewEdgesIcfIcp(int node1){ + for (int node2 : nodeList){ + if (node1 == node2){ 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){ int p1 = e.source; int p2 = e.target; for (YoshikoEdge edge : bHeap.map.values()){ + if (edge == null){ + continue; + } int v1 = edge.source; int v2 = edge.target; @@ -281,105 +278,148 @@ public class ClusteringAlgorithm { edge.maxIcfIcp = Math.max(edge.icf, edge.icp); } } -/* - private void addInfluenceOfVertexOnIcfIcp(MyVertex mergedVertex) { - Set<MyDefaultWeightedEdge> edgeSet = g.edgeSet(); - for (MyDefaultWeightedEdge edge : edgeSet){ - MyVertex v1 = g.getEdgeSource(edge); - MyVertex v2 = g.getEdgeTarget(edge); + private void addInfluenceOfVertexOnIcfIcp(int mergedVertex) { + for (YoshikoEdge edge : bHeap.map.values()){ + 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; } //Addiere Einfluss des Dreiecks v1-MergedVertex-v2 auf icf - MyDefaultWeightedEdge ux = g.getEdge(v1, mergedVertex); - MyDefaultWeightedEdge vx = g.getEdge(v2, mergedVertex); + YoshikoEdge ux = getEdge(v1, mergedVertex); + YoshikoEdge vx = getEdge(v2, mergedVertex); - if (g.getEdgeWeight(ux) > 0 && g.getEdgeWeight(vx) > 0){ - edge.icf += Math.min(g.getEdgeWeight(ux), g.getEdgeWeight(vx)); + if (ux.weight > 0 && vx.weight > 0){ + edge.icf += Math.min(ux.weight, vx.weight); } //Addiere Einfluss des Dreiecks v1-MergedVertex-v2 auf icp - ux = g.getEdge(v1, mergedVertex); - vx = g.getEdge(v2, mergedVertex); - - if (g.getEdgeWeight(ux) > 0 && g.getEdgeWeight(vx) < 0){ - 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)); + if (ux.weight > 0 && vx.weight < 0){ + edge.icp += Math.min(ux.weight, -vx.weight); + }else if (ux.weight < 0 && vx.weight > 0){ + edge.icp += Math.min(-ux.weight, vx.weight); } } - }*/ - /* + } + - private void makeEdgeForbidden(MyDefaultWeightedEdge e){ + private void makeEdgeForbidden(YoshikoEdge e) { editInfluenzeOfForbiddenEdge(e); - g.setEdgeWeight(e, Double.NEGATIVE_INFINITY); + e.weight=Double.NEGATIVE_INFINITY; bHeap.remove(e); System.out.println("rm"); - }*/ -/* - private void editInfluenzeOfForbiddenEdge(MyDefaultWeightedEdge forbiddenEdge){ - MyVertex x1 = g.getEdgeSource(forbiddenEdge); - MyVertex x2 = g.getEdgeTarget(forbiddenEdge); - - Set<MyDefaultWeightedEdge> v1EdgeSet = g.outgoingEdgesOf(x1); - for (MyDefaultWeightedEdge edge : v1EdgeSet){ - MyVertex v1 = x1; - MyVertex v2 = g.getEdgeTarget(edge); - if (v2.equals(v1)){ - v2 = g.getEdgeSource(edge); - } - if (v1.equals(x2)||v2.equals(x2)){ + } + + private void editInfluenzeOfForbiddenEdge(YoshikoEdge forbiddenEdge){ + int x1 = forbiddenEdge.source; + int x2 = forbiddenEdge.target; + + for (int v : nodeList){ + if (x1==v||x2==v){ 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){ - edge.icf -= Math.min(g.getEdgeWeight(forbiddenEdge), g.getEdgeWeight(edge2)); - edge.icp += g.getEdgeWeight(edge2); + if (forbiddenEdge.weight>0 && edge2.weight > 0){ + edge1.icf -= Math.min(forbiddenEdge.weight, edge2.weight); + edge1.icp += edge2.weight; } - if (g.getEdgeWeight(forbiddenEdge) > 0 && g.getEdgeWeight(edge2) < 0){ - edge.icp -= Math.min(g.getEdgeWeight(forbiddenEdge), -g.getEdgeWeight(edge2)); - } else if (g.getEdgeWeight(forbiddenEdge) < 0 && g.getEdgeWeight(edge2) > 0){ - if (g.getEdgeWeight(forbiddenEdge)*(-1) < g.getEdgeWeight(edge2)){ - edge.icp += g.getEdgeWeight(edge2)+g.getEdgeWeight(forbiddenEdge); + if (forbiddenEdge.weight > 0 && edge2.weight < 0){ + edge1.icp -= Math.min(forbiddenEdge.weight, -edge2.weight); + } else if (forbiddenEdge.weight < 0 && edge2.weight > 0){ + if (forbiddenEdge.weight*(-1) < edge2.weight){ + edge1.icp += edge2.weight+forbiddenEdge.weight; } } - } - Set<MyDefaultWeightedEdge> v2EdgeSet = g.outgoingEdgesOf(x2); - for (MyDefaultWeightedEdge edge : v2EdgeSet){ - MyVertex v1 = x2; - MyVertex v2 = g.getEdgeTarget(edge); - if (v2.equals(v1)){ - v2 = g.getEdgeSource(edge); + if (forbiddenEdge.weight>0 && edge1.weight > 0){ + edge2.icf -= Math.min(forbiddenEdge.weight, edge1.weight); + edge2.icp += edge1.weight; } - if (v1.equals(x1)||v2.equals(x1)){ - continue; + + if (forbiddenEdge.weight > 0 && edge1.weight < 0){ + edge2.icp -= Math.min(forbiddenEdge.weight, -edge1.weight); + } else if (forbiddenEdge.weight < 0 && edge1.weight > 0){ + if (forbiddenEdge.weight*(-1) < edge1.weight){ + edge2.icp += edge1.weight+forbiddenEdge.weight; + } } + } + } - MyDefaultWeightedEdge edge2 = g.getEdge(v2, x1); + private void putInCluster(YoshikoEdge edge){ + Integer x1 = edge.source; + Integer x2 = edge.target; - if (g.getEdgeWeight(forbiddenEdge)>0 && g.getEdgeWeight(edge2) > 0){ - edge.icf -= Math.min(g.getEdgeWeight(forbiddenEdge), g.getEdgeWeight(edge2)); - edge.icp += g.getEdgeWeight(edge2); + 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 (g.getEdgeWeight(forbiddenEdge) > 0 && g.getEdgeWeight(edge2) < 0){ - edge.icp -= Math.min(g.getEdgeWeight(forbiddenEdge), -g.getEdgeWeight(edge2)); - } else if (g.getEdgeWeight(forbiddenEdge) < 0 && g.getEdgeWeight(edge2) > 0){ - if (g.getEdgeWeight(forbiddenEdge)*(-1) < g.getEdgeWeight(edge2)){ - edge.icp += g.getEdgeWeight(edge2)+g.getEdgeWeight(forbiddenEdge); - } + if (indexOfx1 >= 0){ + if (indexOfx2 >= 0){ + List<Integer> cluster1 = clusters.get(indexOfx1); + List<Integer> cluster2 = clusters.get(indexOfx2); + + 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); + + clusters.add(newCluster); + } + + } + + private void addSingleNodesToClusters(){ + for (int i = 0; i < numberOfNodes; i++){ + nodeIsInCluster(i); + } + } + + private void nodeIsInCluster(int i){ + for (List<Integer> cluster : clusters){ + if (cluster.contains(i)){ + return; } } - }*/ + List<Integer> newCluster = new ArrayList<>(); + newCluster.add(i); + clusters.add(newCluster); + } } \ No newline at end of file diff --git a/src/main/java/de/hhu/ba/yoshikoWrapper/yoshikoAlgorithm/GraphTranslator.java b/src/main/java/de/hhu/ba/yoshikoWrapper/yoshikoAlgorithm/GraphTranslator.java index 44677f8b7c01beb18b417f6542837a7dbd1dc0f1..0a7aa5cb92b2190e6e22633ddb736fe0259827fb 100644 --- a/src/main/java/de/hhu/ba/yoshikoWrapper/yoshikoAlgorithm/GraphTranslator.java +++ b/src/main/java/de/hhu/ba/yoshikoWrapper/yoshikoAlgorithm/GraphTranslator.java @@ -1,11 +1,15 @@ 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.cytoUtil.NodeMap; import org.cytoscape.model.*; +import org.cytoscape.model.subnetwork.CyRootNetwork; +import org.cytoscape.model.subnetwork.CySubNetwork; import java.util.*; -public class GraphTranslator { +public final class GraphTranslator { private CyNetwork network; private ParameterSet parameterSet; @@ -94,4 +98,51 @@ public class GraphTranslator { 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)); + } + } } diff --git a/src/main/java/de/hhu/ba/yoshikoWrapper/yoshikoAlgorithm/YoshikoAlgoritmController.java b/src/main/java/de/hhu/ba/yoshikoWrapper/yoshikoAlgorithm/YoshikoAlgoritmController.java index 7ea06f0ac0f3ab3d74584838603a16183cb82ff5..4c74d695e74b29e11a0f8642a88d0b6e40180431 100644 --- a/src/main/java/de/hhu/ba/yoshikoWrapper/yoshikoAlgorithm/YoshikoAlgoritmController.java +++ b/src/main/java/de/hhu/ba/yoshikoWrapper/yoshikoAlgorithm/YoshikoAlgoritmController.java @@ -28,7 +28,8 @@ public class YoshikoAlgoritmController { YoshikoEdge[][] edgeArray = translator.translateGraph(); ClusteringAlgorithm clusteringAlgorithm = new ClusteringAlgorithm(edgeArray); - clusteringAlgorithm.runAlgorithm(); + List<List<Integer>> clusters = clusteringAlgorithm.runAlgorithm(); + translator.makeCytoscapeGraph(clusters); }