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);
     }