Add semantic zooming based on phylogenetic

.gitattributes

@@ -0,0 +1 @@
+*.gfa filter=lfs diff=lfs merge=lfs -text

code.java

@@ -0,0 +1,8 @@
+
+    public static void main(String[] args) {
+        TokenIterator it = new TokenIterator("cbbaaacabaa", "bc");
+        while (it.hasNext()) {
+            System.out.println("next: " + it.next());
+        }
+    }
+

src/main/java/io/github/programminglife2016/pl1_2016/Launcher.java

@@ -1,7 +1,9 @@
 package io.github.programminglife2016.pl1_2016;
 
-import io.github.programminglife2016.pl1_2016.parser.JsonSerializable;
+import io.github.programminglife2016.pl1_2016.parser.phylotree.TreeNodeCollection;
+import io.github.programminglife2016.pl1_2016.parser.nodes.NodeCollection;
 import io.github.programminglife2016.pl1_2016.parser.nodes.SegmentParser;
+import io.github.programminglife2016.pl1_2016.parser.phylotree.PhyloGeneticTreeParser;
 import io.github.programminglife2016.pl1_2016.server.api.RestServer;
 import io.github.programminglife2016.pl1_2016.server.Server;
 
@@ -23,12 +25,14 @@ private Launcher() {
     public static void main(String[] args) throws IOException {
         System.out.println("Started loading.");
         long startTime = System.nanoTime();
-        InputStream is = Launcher.class.getResourceAsStream("/genomes/TB10_200.gfa");
-        JsonSerializable jsonSerializable = new SegmentParser().parse(is);
+        InputStream is = Launcher.class.getResourceAsStream("/genomes/TB10.gfa");
+        NodeCollection nodeCollection = new SegmentParser().parse(is);
         long endTime = System.nanoTime();
         System.out.println(String.format("Loading time: %f s.", (endTime - startTime)
                 / NANOSECONDS_PER_SECOND));
-        Server server = new RestServer(jsonSerializable);
+        InputStream nwk = Launcher.class.getResourceAsStream("/genomes/TB10.nwk");
+        TreeNodeCollection treeNodes = new PhyloGeneticTreeParser().parse(nwk);
+        Server server = new RestServer(nodeCollection, treeNodes.getRoot());
         server.startServer();
     }
 }

src/main/java/io/github/programminglife2016/pl1_2016/parser/ClosestGenomeSelectionStrategy.java

@@ -0,0 +1,23 @@
+package io.github.programminglife2016.pl1_2016.parser;
+
+import io.github.programminglife2016.pl1_2016.parser.phylotree.TreeNode;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class ClosestGenomeSelectionStrategy implements GenomeSelectionStrategy {
+    @Override
+    public Collection<String> genomes(TreeNode rootNode, int level) {
+        List<TreeNode> treeNodes = rootNode.flatten().stream().collect(Collectors.toList());
+        Collection<String> genomes = new ArrayList<>();
+        for (int i = 0; i < Math.min(Math.pow(2, level), treeNodes.size()); i++) {
+            genomes.add(treeNodes.get(i).getName());
+        }
+//        return genomes;
+        return Arrays.asList("TKK 02 0007", "TKK 02 0006");
+    }
+
+}

src/main/java/io/github/programminglife2016/pl1_2016/parser/FurthestGenomeSelectionStrategy.java

@@ -0,0 +1,29 @@
+package io.github.programminglife2016.pl1_2016.parser;
+
+import io.github.programminglife2016.pl1_2016.parser.phylotree.TreeNode;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Optional;
+
+public class FurthestGenomeSelectionStrategy implements GenomeSelectionStrategy {
+    @Override
+    public Collection<String> genomes(TreeNode rootNode, int level) {
+        if (level == 0) {
+            Optional<TreeNode> treeNode = rootNode.flatten().stream().findFirst();
+            return Collections.singletonList(treeNode.get().getName());
+        }
+        if (rootNode.getChildren().isEmpty()) {
+            return Collections.singletonList(rootNode.getName());
+        } else {
+            Collection<TreeNode> children = rootNode.getChildren();
+            Collection<String> allGenomes = new ArrayList<>();
+            for (TreeNode child : children) {
+                Collection<String> genomes = genomes(child, level - 1);
+                allGenomes.addAll(genomes);
+            }
+            return allGenomes;
+        }
+    }
+}

src/main/java/io/github/programminglife2016/pl1_2016/parser/GenomeSelectionStrategy.java

@@ -0,0 +1,9 @@
+package io.github.programminglife2016.pl1_2016.parser;
+
+import io.github.programminglife2016.pl1_2016.parser.phylotree.TreeNode;
+
+import java.util.Collection;
+
+public interface GenomeSelectionStrategy {
+    Collection<String> genomes(TreeNode rootNode, int level);
+}

src/main/java/io/github/programminglife2016/pl1_2016/parser/JsonSerializable.java

@@ -1,25 +1,9 @@
 package io.github.programminglife2016.pl1_2016.parser;
 
-import com.google.gson.Gson;
-import com.google.gson.GsonBuilder;
-import io.github.programminglife2016.pl1_2016.parser.nodes.NodeCollectionSerializer;
-import io.github.programminglife2016.pl1_2016.parser.nodes.NodeList;
-import io.github.programminglife2016.pl1_2016.parser.nodes.NodeMap;
-
 /**
  * Data is sent by the server in JSON format. Classes extending this method can convert their
  * representation to JSON.
  */
 public interface JsonSerializable {
-    /**
-     * Convert the representation to JSON.
-     *
-     * @return JSON representation of this object.
-     */
-    default String toJson() {
-        Gson gson = new GsonBuilder()
-                .registerTypeAdapter(NodeList.class, new NodeCollectionSerializer())
-                .registerTypeAdapter(NodeMap.class, new NodeCollectionSerializer()).create();
-        return gson.toJson(this);
-    }
+    String toJson();
 }

src/main/java/io/github/programminglife2016/pl1_2016/parser/NodeReductionStrategy.java

@@ -0,0 +1,7 @@
+package io.github.programminglife2016.pl1_2016.parser;
+
+import io.github.programminglife2016.pl1_2016.parser.nodes.NodeCollection;
+
+public interface NodeReductionStrategy {
+    NodeCollection reduce(NodeCollection original);
+}

src/main/java/io/github/programminglife2016/pl1_2016/parser/PreserveGenomesNodeReductionStrategy.java

@@ -0,0 +1,142 @@
+package io.github.programminglife2016.pl1_2016.parser;
+
+import io.github.programminglife2016.pl1_2016.parser.nodes.Node;
+import io.github.programminglife2016.pl1_2016.parser.nodes.NodeCollection;
+import io.github.programminglife2016.pl1_2016.parser.nodes.NodeMap;
+
+import java.util.*;
+
+public class PreserveGenomesNodeReductionStrategy implements NodeReductionStrategy {
+    private Collection<String> genomes;
+    private int currnode = 0;
+    private int totalSize = 0;
+
+    public PreserveGenomesNodeReductionStrategy(Collection<String> genomes) {
+        this.genomes = genomes;
+    }
+
+    @Override
+    public NodeCollection reduce(NodeCollection original) {
+        System.out.println(genomes);
+        this.totalSize = original.getNodes().size();
+        NodeCollection filter = filter(original);
+        NodeCollection aggregate = filter;
+        for (int i = 0; i < 8; i++) {
+            this.totalSize = aggregate.getNodes().size();
+            this.currnode = 0;
+            aggregate = aggregate(aggregate);
+        }
+        return aggregate;
+    }
+
+    private NodeCollection filter(NodeCollection original) {
+        NodeCollection filtered = new NodeMap(original.getNodes().size());
+        for (Node node : original) {
+            printPercentage("Filtering");
+            if (Collections.disjoint(genomes, node.getGenomes())) {
+                continue;
+            }
+            Node clonedNode;
+            if (filtered.containsKey(node.getId())) {
+                clonedNode = filtered.get(node.getId());
+            } else {
+                filtered.put(node.getId(), node.clone());
+                clonedNode = filtered.get(node.getId());
+            }
+            Collection<Node> newLinks = new ArrayList<>();
+            Collection<Node> newBackLinks = new ArrayList<>();
+            for (Node nodeFront : clonedNode.getLinks()) {
+                if (Collections.disjoint(genomes, nodeFront.getGenomes())) {
+                    continue;
+                }
+                Node clonedNodeFront;
+                if (filtered.containsKey(nodeFront.getId())) {
+                    clonedNodeFront = filtered.get(nodeFront.getId());
+                } else {
+                    filtered.put(nodeFront.getId(), nodeFront.clone());
+                    clonedNodeFront = filtered.get(nodeFront.getId());
+                }
+                newLinks.add(clonedNodeFront);
+            }
+            for (Node nodeBack : clonedNode.getBackLinks()) {
+                if (Collections.disjoint(genomes, nodeBack.getGenomes())) {
+                    continue;
+                }
+                Node clonedNodeBack;
+                if (filtered.containsKey(nodeBack.getId())) {
+                    clonedNodeBack = filtered.get(nodeBack.getId());
+                } else {
+                    filtered.put(nodeBack.getId(), nodeBack.clone());
+                    clonedNodeBack = filtered.get(nodeBack.getId());
+                }
+                newBackLinks.add(clonedNodeBack);
+            }
+            clonedNode.getLinks().clear();
+            clonedNode.getBackLinks().clear();
+            newLinks.stream().forEach(clonedNode::addLink);
+            newBackLinks.stream().forEach(clonedNode::addBackLink);
+        }
+        System.out.println("\rFiltering... 100%");
+        return filtered;
+    }
+
+    private NodeCollection aggregate(NodeCollection nodeCollection) {
+        NodeCollection aggregated = new NodeMap(nodeCollection.getNodes().size());
+        nodeCollection.getNodes().stream().forEach(x -> aggregated.put(x.getId(), x));
+        Collection<Node> toRemove = new HashSet<>();
+        for (Node node : aggregated) {
+            printPercentage("Aggregating");
+            while (node.getLinks().size() == 1 && node.getLinks().iterator().next().getBackLinks().size() == 1) {
+                Node next = node.getLinks().iterator().next();
+                toRemove.add(next);
+                node.getLinks().clear();
+                node.setData(node.getData() + next.getData());
+                next.getLinks().stream().forEach(node::addLink);
+                next.getLinks().clear();
+                next.getBackLinks().clear();
+                boolean azi = true;
+                while (node.getLinks().size() >= 2 && azi) {
+                    azi = false;
+                    Collection<Node> linksToRemove = new ArrayList<>();
+                    Collection<Node> linksToAdd = new ArrayList<>();
+                    for (Node nodeFront : node.getLinks()) {
+                        List<Node> intersection = new ArrayList<>(node.getLinks());
+                        intersection.retainAll(nodeFront.getLinks());
+                        if (!intersection.isEmpty()) {
+                            toRemove.add(nodeFront);
+                            linksToRemove.add(nodeFront);
+                            linksToAdd.addAll(nodeFront.getLinks());
+                            node.setData(node.getData() + nodeFront.getData());
+                            nodeFront.getLinks().clear();
+                            nodeFront.getLinks().clear();
+                            azi = true;
+                            break;
+                        }
+                    }
+                    linksToRemove.stream().forEach(x -> node.getLinks().remove(x));
+                    linksToAdd.stream().forEach(node::addLink);
+                }
+            }
+        }
+        System.out.println("\rAggregating... 100%");
+        toRemove.stream().forEach(aggregated::removeNode);
+        for (Node aggregatedNode : aggregated) {
+            aggregatedNode.getBackLinks().clear();
+        }
+        for (Node aggregatedNode : aggregated) {
+            aggregatedNode.getLinks().stream().forEach(x -> x.addBackLink(aggregatedNode));
+        }
+        return aggregated;
+    }
+
+        /**
+          * Every 500 nodes, print the current percentage.
+          */
+    @SuppressWarnings("checkstyle:magicnumber")
+    private void printPercentage(String action) {
+//        if (currnode++ % (totalSize / 1000) == 0) {
+            System.out.print(String.format("\r%s... %.1f%%.", action, (double) currnode
+                    / totalSize * 100));
+//        }
+    }
+}

src/main/java/io/github/programminglife2016/pl1_2016/parser/metadata/SpecimenMap.java

@@ -21,4 +21,6 @@ public SpecimenMap() {
     public Collection<Subject> getSpecimen() {
         return values();
     }
+
+    public String toJson() { return ""; }
 }

src/main/java/io/github/programminglife2016/pl1_2016/parser/nodes/Node.java

@@ -1,11 +1,12 @@
 package io.github.programminglife2016.pl1_2016.parser.nodes;
 
 import java.util.Collection;
+import java.util.Set;
 
 /**
  * An object that represents a displayable bubble/segment.
  */
-public interface Node {
+public interface Node extends Cloneable {
     /**
      * Set the x and y coordinates of the node.
      *
@@ -92,6 +93,21 @@ public interface Node {
     int getColumn();
 
     /**
+     * Add the genomes this segment belongs to.
+     *
+     * @param genomes the genomes this segment belongs to
+     */
+    void addGenomes(Collection<String> genomes);
+
+    /**
+     * Get the genomes this segment belongs to.
+     *
+     * @return the genomes this segment belongs to
+     */
+    Set<String> getGenomes();
+
+    Node clone();
+    /*
      * Calculate the position of this node, and the sibling nodes (in the case of a snip). Indels
      * are not yet accounted for.
      *

src/main/java/io/github/programminglife2016/pl1_2016/parser/nodes/NodeCollection.java

@@ -40,6 +40,8 @@ public interface NodeCollection extends JsonSerializable, Iterable<Node> {
      */
     Collection<Node> getNodes();
 
+    void removeNode(Node node);
+
     /**
      * Iterator for the collection.
      * @return iterator

src/main/java/io/github/programminglife2016/pl1_2016/parser/nodes/NodeList.java

@@ -1,5 +1,8 @@
 package io.github.programminglife2016.pl1_2016.parser.nodes;
 
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.stream.Collectors;
@@ -62,4 +65,15 @@ public boolean containsKey(Object id) {
     public Collection<Node> getNodes() {
         return Arrays.asList(array).stream().filter(x -> x != null).collect(Collectors.toList());
     }
+
+    @Override
+    public void removeNode(Node node) {
+        array[node.getId() - 1] = null;
+    }
+
+    @Override
+    public String toJson() {
+        Gson gson = new GsonBuilder().registerTypeAdapter(NodeList.class, new NodeCollectionSerializer()).create();
+        return gson.toJson(this);
+    }
 }

src/main/java/io/github/programminglife2016/pl1_2016/parser/nodes/NodeMap.java

@@ -1,5 +1,8 @@
 package io.github.programminglife2016.pl1_2016.parser.nodes;
 
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+
 import java.util.Collection;
 import java.util.HashMap;
 
@@ -24,4 +27,15 @@ public NodeMap(int initialCapacity) {
     public Collection<Node> getNodes() {
         return values();
     }
+
+    @Override
+    public void removeNode(Node node) {
+        remove(node.getId());
+    }
+
+    @Override
+    public String toJson() {
+        Gson gson = new GsonBuilder().registerTypeAdapter(NodeMap.class, new NodeCollectionSerializer()).create();
+        return gson.toJson(this);
+    }
 }