implemented k-Clustering with icf-icp

src/main/java/de/hhu/ba/yoshikoWrapper/core/ParameterSet.java

@@ -108,7 +108,7 @@ public class ParameterSet implements TunableValidator
 		permanentColumn = new ListSingleSelection<CyColumn>(booleanColumns);
 		
 		//Don't select any columns by default
-		weightColumn.setSelectedValue(numericColumns.get(1));
+		weightColumn.setSelectedValue(null);
 		forbiddenColumn.setSelectedValue(null);
 		permanentColumn.setSelectedValue(null);
 

src/main/java/de/hhu/ba/yoshikoWrapper/yoshikoAlgorithm/BinaryHeap.java

@@ -5,28 +5,42 @@ import java.util.*;
 public class BinaryHeap {
     ArrayList<Double> list = new ArrayList();
     HashMap<Integer, YoshikoEdge> map = new HashMap<>();
+    HashMap<YoshikoEdge, Integer> reverseMap = new HashMap<>();
+    int k = -1;
 
     public BinaryHeap(){
         list.add(Double.NEGATIVE_INFINITY);
         map.put(0, null);
+        reverseMap.put(null, 0);
     }
 
-    public void add(YoshikoEdge edge){
+    public void addMaxIcfIcp(YoshikoEdge edge){
 
         list.add(edge.maxIcfIcp);
         map.put(list.size()-1, edge);
+        reverseMap.put(edge, list.size()-1);
 
         checkParent(list.size()-1);
-    }
 
-    public void add(Set<YoshikoEdge> edgeSet){
-        for(YoshikoEdge edge : edgeSet){
-            add(edge);
+        if (list.size()-1 == 30864){
+            System.out.println("asd");
+        }
     }
+
+    public void addIcfMinusIcp(YoshikoEdge edge){
+        list.add(edge.icfMinusIcp);
+        map.put(list.size()-1, edge);
+
+        reverseMap.put(edge, list.size()-1);
+
+        checkParent(list.size()-1);
     }
 
     public void remove(YoshikoEdge edge){
-        int index = getIndexFromValue(edge);
+        if (!reverseMap.containsKey(edge)){
+            return;
+        }
+        int index = reverseMap.get(edge);
 
         if (edge.weight != Double.NEGATIVE_INFINITY){
             //System.out.println("MELDUNG 5");
@@ -37,23 +51,7 @@ public class BinaryHeap {
             return;
         }
 
-        map.replace(index, map.get(map.size()-1));
-        map.remove(map.size()-1);
-
-        list.set(index, list.get(list.size()-1));
-        list.remove(list.size()-1);
-    }
-
-
-    public void  removeIncidentEdges(int n1, int n2){
-
-    }
-
-
-    public void remove(Set<YoshikoEdge> edgeSet){
-        for (YoshikoEdge edge : edgeSet){
-            remove(edge);
-        }
+        saveRemove(index, edge);
     }
 
     public YoshikoEdge popMax(){
@@ -68,24 +66,46 @@ public class BinaryHeap {
 
         YoshikoEdge e = map.get(index);
 
+        saveRemove(index, e);
+
+        return e;
+    }
+
+    private void saveRemove(int index, YoshikoEdge e) {
         map.replace(index, map.get(map.size()-1));
         map.remove(map.size()-1);
 
+        YoshikoEdge movedEdge = map.get(index);
+
+        reverseMap.replace(movedEdge, index);
+        reverseMap.remove(e);
+
         list.set(index, list.get(list.size()-1));
         list.remove(list.size()-1);
-
-        return e;
     }
 
 
+    public void updateEdge(YoshikoEdge edge){
+        if (!reverseMap.containsKey(edge)){
+            return;
+        }
+        int index = reverseMap.get(edge);
+
+        if (index < 0){
+            return;
+        }
 
-    public void checkUptatedNode(YoshikoEdge edge){
-        int index = getIndexFromValue(edge);
+        if (k<0){
+            list.set(index, edge.maxIcfIcp);
+        }else {
+            list.set(index, edge.icfMinusIcp);
+        }
 
         checkParent(index);
         checkChild(index);
     }
 
+
     public int size(){
         return list.size()-1;
     }
@@ -121,20 +141,17 @@ public class BinaryHeap {
         list.set(index, list.get(parentIndex));
         list.set(parentIndex, tmpVal);
 
-        YoshikoEdge tmpEdge = map.get(index);
-        map.replace(index, map.get(parentIndex));
-        map.replace(parentIndex, tmpEdge);
-    }
 
-    private int getIndexFromValue(YoshikoEdge edge){
-        for (Map.Entry<Integer, YoshikoEdge> entry : map.entrySet()) {
-            if (entry.getKey() == 0){
-                //Der erste DummyEintrag im Heap soll ignoriert werden
-            }
-            else if (entry.getValue().edgeId == edge.edgeId) {
-                return entry.getKey();
-            }
-        }
-        return -1;
+        YoshikoEdge edge1 = map.get(index);
+        YoshikoEdge edge2 = map.get(parentIndex);
+
+        Integer index1 = reverseMap.get(edge1);
+        Integer index2 = reverseMap.get(edge2);
+
+        map.replace(index, edge2);
+        map.replace(parentIndex, edge1);
+
+        reverseMap.replace(edge1, index2);
+        reverseMap.replace(edge2, index1);
     }
 }
\ No newline at end of file

src/main/java/de/hhu/ba/yoshikoWrapper/yoshikoAlgorithm/ClusteringAlgorithm.java

@@ -12,28 +12,32 @@ public class ClusteringAlgorithm {
     private int numberOfNodes;
     List<Integer> nodeList;
     List<List<Integer>> clusters;
+    int k=-1;
+    int nodeInClusters;
 
 
     public ClusteringAlgorithm(YoshikoEdge[][] edgeArray){
         this.edgeArray = edgeArray;
         numberOfNodes = edgeArray.length;
         clusters = new ArrayList<>();
-    }
-
-    public List<List<Integer>> runAlgorithm(){
         clusteringCost = 0;
+    }
 
-        bHeap = new BinaryHeap();
-
+    public List<List<Integer>> runClusteringAlgorithm(){
         initializeQueue();
 
+        if (k < 0) {
+            while (bHeap.size() > 0) {
                 workHeap();
-        addSingleNodesToClusters();
-        int counter = 0;
-        List<Integer> list = new ArrayList<>();
-        for (List<Integer> cluster : clusters){
-            counter += cluster.size();
             }
+        }else {
+            while (numberOfNodes-nodeInClusters > k) {
+                workHeap();
+            }
+        }
+
+
+        addSingleNodesToClusters();
 
         System.out.println(clusteringCost);
         return clusters;
@@ -41,14 +45,19 @@ public class ClusteringAlgorithm {
 
     private void initializeQueue(){
         bHeap = new BinaryHeap();
+        bHeap.k = k;
 
         for (int i=1; i<numberOfNodes; i++){
             for (int j=0; j<i; j++){
-                YoshikoEdge edge = initIcfIcp(i,j);
-                bHeap.add(edge);
+                YoshikoEdge edge = calculateIcfIcp(i,j);
+                if (k<1){
+                    bHeap.addMaxIcfIcp(edge);
+                } else {
+                    bHeap.addIcfMinusIcp(edge);
+                }
+
             }
         }
-        System.out.println("MELDUNG 2");
         initializeNodeList();
     }
 
@@ -59,11 +68,10 @@ public class ClusteringAlgorithm {
         }
     }
 
-    private YoshikoEdge initIcfIcp(int u, int v){
+    private YoshikoEdge calculateIcfIcp(int u, int v){
         double icf = 0;
         double icp = 0;
 
-
         YoshikoEdge edge = edgeArray[u][v];
 
         if (edge == null){
@@ -105,6 +113,9 @@ public class ClusteringAlgorithm {
         edge.icf = icf;
         edge.icp = icp;
         edge.maxIcfIcp = Math.max(icf, icp);
+        edge.icfMinusIcp = icf-icp;
+
+        bHeap.updateEdge(edge);
 
         return edge;
     }
@@ -118,36 +129,20 @@ public class ClusteringAlgorithm {
 
 
     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();
 
 
-            if (e.icf >= e.icp){
-                if(e.weight < 0){
-                    clusteringCost -= e.weight;
-                }
+        if (e.icf >= e.icp|| k > -1){
             makeEdgePermanent(e);
         }
         else{
-                if(e.weight > 0){
-                    clusteringCost +=e.weight;
-                }
             makeEdgeForbidden(e);
         }
         if (clusteringCost == Double.POSITIVE_INFINITY){
             System.out.println("MELDUNG 7");
         }
     }
-    }
 
     private YoshikoEdge getEdge(int edgeId){
         int u = (int) Math.ceil(Math.sqrt(2*(edgeId-1)+0.25)-0.5);
@@ -164,6 +159,10 @@ public class ClusteringAlgorithm {
     }
 
     private void makeEdgePermanent(YoshikoEdge e){
+        if(e.weight < 0){
+            clusteringCost -= e.weight;
+        }
+
         substactInfluenceOfVerticesOnIcfIcp(e);
 
         mergeVertexes(e);
@@ -206,8 +205,8 @@ public class ClusteringAlgorithm {
                 bHeap.remove(e1);
             }
         }
-        Integer k = n2;
-        nodeList.remove(k);
+        Integer o = n2;
+        nodeList.remove(o);
     }
 
     private void calculateNewEdgesIcfIcp(int node1){
@@ -224,7 +223,7 @@ public class ClusteringAlgorithm {
             if (e.weight == Double.NEGATIVE_INFINITY){
                 continue;
             }
-            initIcfIcp(node1, node2);
+            calculateIcfIcp(node1, node2);
         }
     }
 
@@ -276,6 +275,8 @@ public class ClusteringAlgorithm {
             }
 
             edge.maxIcfIcp = Math.max(edge.icf, edge.icp);
+            edge.icfMinusIcp = edge.icf-edge.icp;
+            bHeap.updateEdge(edge);
         }
     }
 
@@ -307,11 +308,17 @@ public class ClusteringAlgorithm {
                 edge.icp += Math.min(-ux.weight, vx.weight);
             }
 
+            edge.maxIcfIcp = Math.max(edge.icf, edge.icp);
+            edge.icfMinusIcp = edge.icf-edge.icp;
+            bHeap.updateEdge(edge);
         }
     }
 
 
     private void makeEdgeForbidden(YoshikoEdge e) {
+        if(e.weight > 0){
+            clusteringCost +=e.weight;
+        }
         editInfluenzeOfForbiddenEdge(e);
 
         e.weight=Double.NEGATIVE_INFINITY;
@@ -349,6 +356,7 @@ public class ClusteringAlgorithm {
                     edge1.icp += edge2.weight+forbiddenEdge.weight;
                 }
             }
+            bHeap.updateEdge(edge1);
 
             if (forbiddenEdge.weight>0 && edge1.weight > 0){
                 edge2.icf -= Math.min(forbiddenEdge.weight, edge1.weight);
@@ -362,18 +370,17 @@ public class ClusteringAlgorithm {
                     edge2.icp += edge1.weight+forbiddenEdge.weight;
                 }
             }
+            bHeap.updateEdge(edge2);
         }
     }
 
     private void putInCluster(YoshikoEdge edge){
+        nodeInClusters++;
         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);

src/main/java/de/hhu/ba/yoshikoWrapper/yoshikoAlgorithm/YoshikoAlgoritmController.java

 package de.hhu.ba.yoshikoWrapper.yoshikoAlgorithm;
 
-import de.hhu.ba.yoshikoWrapper.core.CyCore;
 import de.hhu.ba.yoshikoWrapper.core.ParameterSet;
-import org.cytoscape.model.CyEdge;
 import org.cytoscape.model.CyNetwork;
-import org.cytoscape.model.CyNode;
-import org.cytoscape.model.CyTable;
-import org.jgrapht.Graph;
-import org.jgrapht.graph.SimpleWeightedGraph;
 
-import java.util.Collection;
 import java.util.List;
-import java.util.Set;
 
 public class YoshikoAlgoritmController {
 
+    private int k = 19;
     private CyNetwork network;
     private ParameterSet parameterSet;
 
@@ -28,8 +21,15 @@ public class YoshikoAlgoritmController {
         YoshikoEdge[][] edgeArray = translator.translateGraph();
 
         ClusteringAlgorithm clusteringAlgorithm = new ClusteringAlgorithm(edgeArray);
-        List<List<Integer>> clusters = clusteringAlgorithm.runAlgorithm();
+        clusteringAlgorithm.k = k;
+
+        List<List<Integer>> clusters;
+
+        clusters = clusteringAlgorithm.runClusteringAlgorithm();
+
         translator.makeCytoscapeGraph(clusters);
+
+        System.out.println("asdadasd");
     }
 
 

src/main/java/de/hhu/ba/yoshikoWrapper/yoshikoAlgorithm/YoshikoEdge.java

@@ -11,6 +11,7 @@ public class YoshikoEdge {
     double icf;
     double icp;
     double maxIcfIcp;
+    double icfMinusIcp;
 
     public YoshikoEdge(long suid, double weight, int edgeId){
         this.suid = suid;