tree construction improvement

diylc/diylc-core/src/org/diylc/netlist/Tree.java

@@ -30,6 +30,11 @@ public class Tree {
   private TreeConnectionType connectionType;  
   private TreeLeaf leaf;
   
+  public Tree(TreeConnectionType connectionType) {
+    this.children = new ArrayList<Tree>();
+    this.connectionType = connectionType;
+  }
+  
   public Tree(TreeLeaf leaf) {
     this.leaf = leaf;
   }
@@ -43,9 +48,13 @@ public class Tree {
     return children;
   }
   
-  public void trimChildren(int count) {
+  public void trimChildrenLeft(int count) {
     children = children.subList(count, children.size());
   }
+  
+  public void trimChildrenRight(int count) {
+    children = children.subList(0, children.size() - count);
+  }
 
   public TreeConnectionType getConnectionType() { 
     return connectionType;

diylc/diylc-core/src/org/diylc/netlist/TreeLeaf.java

@@ -92,7 +92,10 @@ public class TreeLeaf implements ITree {
 
   @Override
   public String toString() {   
-    return component.getName() + "." + component.getInternalLinkName(pointIndex1, pointIndex2);
+    String linkName = component.getInternalLinkName(pointIndex1, pointIndex2);
+    if (component.getName().equals(linkName))
+      return linkName;
+    return component.getName() + "." + linkName;
   }
   
   public String toHTML() {

diylc/diylc-library/src/org/diylc/components/AbstractLeadedComponent.java

@@ -130,6 +130,7 @@ public abstract class AbstractLeadedComponent<T> extends AbstractTransparentComp
                 : borderColor;
       }
 
+      g2d.setStroke(ObjectCache.getInstance().fetchBasicStroke(1f));
       g2d.setColor(finalBorderColor);
       g2d.draw(body);
       if (!outlineMode) {

diylc/diylc-library/src/org/diylc/netlist/AbstractNetlistAnalyzer.java

@@ -1,143 +1,224 @@
 /*
-
+ * 
-    DIY Layout Creator (DIYLC).
+ * DIY Layout Creator (DIYLC). Copyright (c) 2009-2018 held jointly by the individual authors.
-    Copyright (c) 2009-2018 held jointly by the individual authors.
+ * 
-
+ * This file is part of DIYLC.
-    This file is part of DIYLC.
+ * 
-
+ * DIYLC is free software: you can redistribute it and/or modify it under the terms of the GNU
-    DIYLC is free software: you can redistribute it and/or modify
+ * General Public License as published by the Free Software Foundation, either version 3 of the
-    it under the terms of the GNU General Public License as published by
+ * License, or (at your option) any later version.
-    the Free Software Foundation, either version 3 of the License, or
+ * 
-    (at your option) any later version.
+ * DIYLC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even
-
+ * the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
-    DIYLC is distributed in the hope that it will be useful,
+ * Public License for more details.
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * 
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * You should have received a copy of the GNU General Public License along with DIYLC. If not, see
-    GNU General Public License for more details.
+ * <http://www.gnu.org/licenses/>.
-
+ */
-    You should have received a copy of the GNU General Public License
-    along with DIYLC.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
 package org.diylc.netlist;
 
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
+import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
+import java.util.Map;
 import java.util.Set;
 
 import org.diylc.core.IDIYComponent;
 
 public abstract class AbstractNetlistAnalyzer {
 
-  public AbstractNetlistAnalyzer() {
+  public AbstractNetlistAnalyzer() {}
-  }
+
-  
+  protected Tree constructTreeBetween(Netlist netlist, Node nodeA, Node nodeB) {
-  protected Tree constructTree(Netlist netlist, Node nodeA, Node nodeB) {    
+    Tree tree = new Tree(TreeConnectionType.Parallel);
-    Tree tree = new Tree(new ArrayList<Tree>(), TreeConnectionType.Parallel);
+    connectNodes(netlist, nodeA, nodeB, tree.getChildren(), new Tree(TreeConnectionType.Series), new HashSet<Node>());
-    connectNodes(netlist, nodeA, nodeB, tree.getChildren(), null, new HashSet<Node>());
+
-//    System.out.println(netlist.getSwitchSetup());
+    // System.out.println(netlist.getSwitchSetup());
-//    System.out.println(tree);
+    // System.out.println(tree);
+    //
+    // System.out.println("opposite:");
+    // Tree tree1 = new Tree(TreeConnectionType.Parallel);
+    // connectNodes(netlist, nodeB, nodeA, tree1.getChildren(), new Tree(TreeConnectionType.Series),
+    // new HashSet<Node>());
+    // System.out.println(tree1);
+
     return tree;
   }
-  
+
-  protected void connectNodes(Netlist netlist, Node nodeA, Node nodeB, List<Tree> concurrentPaths, Tree currentPath, Set<Node> visited) {
+  protected void connectNodes(Netlist netlist, Node nodeA, Node nodeB, List<Tree> concurrentPaths, Tree currentPath,
+      Set<Node> visited) {
     if (nodeA == nodeB) {
       concurrentPaths.add(currentPath);
       return;
-    }   
+    }
-    
+
     Group groupA = findGroup(netlist, nodeA);
-    
+
     if (groupA == null)
       return;
-    
+
     if (groupA.getNodes().contains(nodeB)) {
       concurrentPaths.add(currentPath);
       return;
     }
-    
+
-    visited.add(nodeA);
+    visited.addAll(groupA.getNodes());
-    
+
+    List<Tree> newConcurrentPaths = new ArrayList<Tree>();
+
     for (Node n : groupA.getNodes()) {
       IDIYComponent<?> c = n.getComponent();
       for (int i = 0; i < c.getControlPointCount(); i++) {
         if (i != n.getPointIndex() && c.getInternalLinkName(i, n.getPointIndex()) != null) {
           TreeLeaf l = new TreeLeaf(c, i, n.getPointIndex());
           Node newNodeA = new Node(c, i);
-          if (!visited.contains(newNodeA)) {            
+          if (!visited.contains(newNodeA)) {
-            visited.add(n);
+            // visited.add(n);
             Tree newCurrentPath = null;
             try {
-              if (currentPath == null)
+              newCurrentPath = (Tree) currentPath.clone();
-                newCurrentPath = new Tree(new ArrayList<Tree>(), TreeConnectionType.Series);
-              else
-                newCurrentPath = (Tree) currentPath.clone();
             } catch (CloneNotSupportedException e) {
             }
             Tree newItem = new Tree(l);
             if (!newCurrentPath.getChildren().contains(newItem))
               newCurrentPath.getChildren().add(newItem);
-//            if (!currentPath.contains(l))
+            // if (!currentPath.contains(l))
-//              newCurrentPath.add(l);
+            // newCurrentPath.add(l);
             Set<Node> newVisited = new HashSet<Node>(visited);
-            connectNodes(netlist, newNodeA, nodeB, concurrentPaths, newCurrentPath, newVisited);
+            connectNodes(netlist, newNodeA, nodeB, newConcurrentPaths, newCurrentPath, newVisited);
           }
         }
       }
     }
-    
+
-    if (concurrentPaths.size() < 2)
+    if (newConcurrentPaths.size() == 0)
       return;
+
+
+    if (newConcurrentPaths.size() == 1) {
+      if (newConcurrentPaths.get(0).getConnectionType() == TreeConnectionType.Series) {
+        currentPath.getChildren().clear();
+        currentPath.getChildren().addAll(newConcurrentPaths.get(0).getChildren());
+      } else {
+        currentPath.getChildren().add(newConcurrentPaths.get(0));
+      }
+      concurrentPaths.add(currentPath);
+      return;
+    }
+
+    mergePaths(newConcurrentPaths, false);
+    concurrentPaths.addAll(newConcurrentPaths);
+  }
+
+  protected void mergePaths(List<Tree> paths, boolean backward) {
+    Map<Tree, Integer> uniques = new HashMap<Tree, Integer>();
+    for (Tree t : paths) {
+      if (t.getConnectionType() != TreeConnectionType.Series)
+        continue;
+      Tree key = t.getChildren().get(backward ? t.getChildren().size() - 1 : 0);
+      Integer count = uniques.get(key);
+      uniques.put(key, count == null ? 1 : count + 1);
+    }
     
-    Tree jointSection = new Tree(new ArrayList<Tree>(), TreeConnectionType.Series);
+    List<Tree> unmerged = new ArrayList<Tree>(paths);
-    for (int i = 0; i < concurrentPaths.get(0).getChildren().size(); i++) {
+
-      Tree unique = concurrentPaths.get(0).getChildren().get(i);
+    for (Map.Entry<Tree, Integer> e : uniques.entrySet()) {
-      boolean canMerge = true;
+      if (e.getValue() > 1) {
-      for (Tree t : concurrentPaths) {
+        List<Tree> pathsToMerge = new ArrayList<Tree>();
-        if (t.getConnectionType() != TreeConnectionType.Series || t.getChildren().size() <= i || !t.getChildren().get(i).equals(unique)) {
+        for (Tree t : paths) {
-          canMerge = false;
+          Tree key = t.getChildren().get(backward ? t.getChildren().size() - 1 : 0);
-          break;
+          if (key.equals(e.getKey()))
+            pathsToMerge.add(t);
+        }
+        unmerged.removeAll(pathsToMerge);
+
+        Tree jointStart = new Tree(new ArrayList<Tree>(), TreeConnectionType.Series);
+        Tree jointFinish = new Tree(new ArrayList<Tree>(), TreeConnectionType.Series);
+        
+        Tree unique = e.getKey();
+
+        for (int i = 0; i < pathsToMerge.get(0).getChildren().size(); i++) {
+          boolean canMerge = true;
+          unique = pathsToMerge.get(0).getChildren().get(backward ? pathsToMerge.get(0).getChildren().size() - i - 1 : i);
+          for (Tree t : pathsToMerge) {            
+            if (t.getChildren().size() <= i || !t.getChildren().get(backward ? t.getChildren().size() - i - 1 : i).equals(unique)) {
+              canMerge = false;
+              break;
+            }
+          }
+          if (canMerge)
+            (backward ? jointFinish : jointStart).getChildren().add(unique);
+          else
+            break;
+        }        
+        
+        for (int i = 0; i < pathsToMerge.get(0).getChildren().size(); i++) {
+          boolean canMerge = true;
+          unique = pathsToMerge.get(0).getChildren().get(backward ? i : pathsToMerge.get(0).getChildren().size() - i - 1);
+          for (Tree t : pathsToMerge) {            
+            if (t.getChildren().size() <= i || !t.getChildren().get(backward ? 0 : pathsToMerge.get(0).getChildren().size() - 1).equals(unique)) {
+              canMerge = false;
+              break;
+            }
+          }
+          if (canMerge)
+            (backward ? jointStart : jointFinish).getChildren().add(unique);
+          else
+            break;
+        }
+
+        if (!jointStart.getChildren().isEmpty() || !jointFinish.getChildren().isEmpty()) {
+          Tree mergedTree = new Tree(new ArrayList<Tree>(), TreeConnectionType.Series);
+          Tree parallelSection = new Tree(new ArrayList<Tree>(pathsToMerge), TreeConnectionType.Parallel);
+          if (!jointStart.getChildren().isEmpty()) {
+            mergedTree.getChildren().add(jointStart);
+            for (Tree t : parallelSection.getChildren()) {
+              t.trimChildrenLeft(jointStart.getChildren().size());
+            }
+          }
+          mergedTree.getChildren().add(parallelSection);
+          if (!jointFinish.getChildren().isEmpty()) {
+            mergedTree.getChildren().add(jointFinish);
+            for (Tree t : parallelSection.getChildren()) {
+              t.trimChildrenRight(jointFinish.getChildren().size());
+            }
+          }
+          paths.removeAll(pathsToMerge);
+          paths.add(mergedTree);          
         }
       }
-      if (canMerge)
-        jointSection.getChildren().add(unique);
-      else
-        break;
     }
-    if (!jointSection.getChildren().isEmpty()) {
+    
-      Tree mergedTree = new Tree(new ArrayList<Tree>(), TreeConnectionType.Series);
+    // try in the opposite direction for paths we haven't merged
-      mergedTree.getChildren().add(jointSection);
+    if (!backward && !unmerged.isEmpty()) {
-      Tree parallelSection = new Tree(new ArrayList<Tree>(concurrentPaths), TreeConnectionType.Parallel);
+      paths.removeAll(unmerged);
-      for (Tree t : parallelSection.getChildren()) {
+      mergePaths(unmerged, true);
-        t.trimChildren(jointSection.getChildren().size());
+      paths.addAll(unmerged);
-      }
-      mergedTree.getChildren().add(parallelSection);
-      concurrentPaths.clear();
-      concurrentPaths.add(mergedTree);
     }
   }
-  
+
-  protected void findAllPaths(Netlist netlist, Node nodeA, Node nodeB, List<TreeLeaf> currentPath, List<List<TreeLeaf>> allPaths, Set<Node> visited) {
+  protected void findAllPaths(Netlist netlist, Node nodeA, Node nodeB, List<TreeLeaf> currentPath,
+      List<List<TreeLeaf>> allPaths, Set<Node> visited) {
     if (nodeA == nodeB) {
       allPaths.add(currentPath);
       return;
     }
-    
+
-//    System.out.println("Finding path between " + nodeA + " and " + nodeB);
+    // System.out.println("Finding path between " + nodeA + " and " + nodeB);
-    
+
     Group groupA = findGroup(netlist, nodeA);
-    
+
     if (groupA == null)
       return;
-    
+
     if (groupA.getNodes().contains(nodeB)) {
       allPaths.add(currentPath);
       return;
     }
-    
+
     for (Node n : groupA.getNodes()) {
       IDIYComponent<?> c = n.getComponent();
       for (int i = 0; i < c.getControlPointCount(); i++) {
@@ -157,7 +238,7 @@ public abstract class AbstractNetlistAnalyzer {
       }
     }
   }
-  
+
   protected Group findGroup(Netlist netlist, Node node) {
     for (Group g : netlist.getGroups())
       if (g.getNodes().contains(node))
@@ -169,75 +250,76 @@ public abstract class AbstractNetlistAnalyzer {
     List<Group> res = new ArrayList<Group>();
     for (Group g : netlist.getGroups()) {
       for (Node n : g.getNodes()) {
-        if (typeNames.contains(n.getComponent().getClass().getCanonicalName()) && 
+        if (typeNames.contains(n.getComponent().getClass().getCanonicalName())
-            (nodeName == null || n.getDisplayName().equalsIgnoreCase(nodeName))) {
+            && (nodeName == null || n.getDisplayName().equalsIgnoreCase(nodeName))) {
           res.add(g);
           break;
         }
-      }      
+      }
     }
     return res;
   }
-  
+
   protected List<Node> find(Set<String> typeNames, String nodeName, Group group) {
     List<Node> res = new ArrayList<Node>();
 
-    for (Node n : group.getNodes()) {              
+    for (Node n : group.getNodes()) {
-      if (typeNames.contains(n.getComponent().getClass().getCanonicalName()) && 
+      if (typeNames.contains(n.getComponent().getClass().getCanonicalName())
-          (nodeName == null || n.getDisplayName().equalsIgnoreCase(nodeName))) {
+          && (nodeName == null || n.getDisplayName().equalsIgnoreCase(nodeName))) {
         res.add(n);
       }
-    }      
+    }
-    
+
     return res;
   }
-  
+
   protected List<Group> findGroups(Set<String> typeNames, String nodeName, Netlist netlist) {
     List<Group> res = new ArrayList<Group>();
     for (Group g : netlist.getGroups()) {
-      for (Node n : g.getNodes()) {              
+      for (Node n : g.getNodes()) {
-        if (typeNames.contains(n.getComponent().getClass().getCanonicalName()) && 
+        if (typeNames.contains(n.getComponent().getClass().getCanonicalName())
-            (nodeName == null || n.getDisplayName().equalsIgnoreCase(nodeName))) {
+            && (nodeName == null || n.getDisplayName().equalsIgnoreCase(nodeName))) {
           res.add(g);
           break;
         }
-      }      
+      }
     }
     return res;
   }
-  
+
-  protected List<Group> findGroups(Set<String> typeNames, String nodeName, Netlist netlist, Collection<IDIYComponent<?>> belongTo) {
+  protected List<Group> findGroups(Set<String> typeNames, String nodeName, Netlist netlist,
+      Collection<IDIYComponent<?>> belongTo) {
     List<Group> res = new ArrayList<Group>();
     for (Group g : netlist.getGroups()) {
-      for (Node n : g.getNodes()) {              
+      for (Node n : g.getNodes()) {
-        if ((belongTo == null || belongTo.contains(n.getComponent())) && 
+        if ((belongTo == null || belongTo.contains(n.getComponent()))
-            (typeNames.contains(n.getComponent().getClass().getCanonicalName())) && 
+            && (typeNames.contains(n.getComponent().getClass().getCanonicalName()))
-            (nodeName == null || n.getDisplayName().equalsIgnoreCase(nodeName))) {
+            && (nodeName == null || n.getDisplayName().equalsIgnoreCase(nodeName))) {
           res.add(g);
           break;
         }
-      }      
+      }
     }
     return res;
   }
-  
+
   protected List<Node> find(Set<String> typeNames, String nodeName, Netlist netlist) {
     List<Node> res = new ArrayList<Node>();
     for (Group g : netlist.getGroups()) {
-      for (Node n : g.getNodes()) {              
+      for (Node n : g.getNodes()) {
-        if (typeNames.contains(n.getComponent().getClass().getCanonicalName()) && 
+        if (typeNames.contains(n.getComponent().getClass().getCanonicalName())
-            (nodeName == null || n.getDisplayName().equalsIgnoreCase(nodeName))) {
+            && (nodeName == null || n.getDisplayName().equalsIgnoreCase(nodeName))) {
           res.add(n);
         }
-      }      
+      }
     }
     return res;
   }
-  
+
   protected List<Node> find(Set<String> typeNames, String nodeName, Netlist netlist, List<Node> inGroupWith) {
     List<Node> res = new ArrayList<Node>();
     for (Group g : netlist.getGroups()) {
-      
+
       boolean inGroup;
       if (inGroupWith == null) {
         inGroup = true;
@@ -249,55 +331,57 @@ public abstract class AbstractNetlistAnalyzer {
             break;
           }
       }
-      
+
-      for (Node n : g.getNodes()) {              
+      for (Node n : g.getNodes()) {
-        if (inGroup && typeNames.contains(n.getComponent().getClass().getCanonicalName()) && 
+        if (inGroup && typeNames.contains(n.getComponent().getClass().getCanonicalName())
-            (nodeName == null || n.getDisplayName().equalsIgnoreCase(nodeName))) {
+            && (nodeName == null || n.getDisplayName().equalsIgnoreCase(nodeName))) {
           res.add(n);
         }
-      }      
+      }
     }
     return res;
   }
-  
+
-  protected List<Node> find(Set<String> typeNames, String nodeName, Netlist netlist, Collection<IDIYComponent<?>> belongTo) {
+  protected List<Node> find(Set<String> typeNames, String nodeName, Netlist netlist,
+      Collection<IDIYComponent<?>> belongTo) {
     List<Node> res = new ArrayList<Node>();
-    for (Group g : netlist.getGroups()) {     
+    for (Group g : netlist.getGroups()) {
-      
+
-      for (Node n : g.getNodes()) {              
+      for (Node n : g.getNodes()) {
-        if ((belongTo == null || belongTo.contains(n.getComponent())) && typeNames.contains(n.getComponent().getClass().getCanonicalName()) && 
+        if ((belongTo == null || belongTo.contains(n.getComponent()))
-            (nodeName == null || n.getDisplayName().equalsIgnoreCase(nodeName))) {
+            && typeNames.contains(n.getComponent().getClass().getCanonicalName())
+            && (nodeName == null || n.getDisplayName().equalsIgnoreCase(nodeName))) {
           res.add(n);
         }
-      }      
+      }
     }
     return res;
   }
-  
+
   protected boolean allMatch(Collection<Node> nodes, String name) {
     for (Node n : nodes)
       if (!n.getDisplayName().equalsIgnoreCase(name))
         return false;
-    
+
     return true;
   }
-  
+
   protected boolean allComponentsMatch(Collection<Node> nodes, Set<IDIYComponent<?>> components) {
     Set<IDIYComponent<?>> extracted = extractComponents(nodes);
     return extracted.containsAll(components);
   }
-  
+
   protected Set<IDIYComponent<?>> extractComponents(Collection<Node> nodes) {
     Set<IDIYComponent<?>> components = new HashSet<IDIYComponent<?>>();
     for (Node n : nodes)
       components.add(n.getComponent());
     return components;
   }
-  
+
   protected String extractName(IDIYComponent<?> c) {
     return c.getName() + " " + c.getValueForDisplay();
   }
-  
+
   protected List<String> extractNames(Collection<IDIYComponent<?>> components) {
     List<String> names = new ArrayList<String>();
     for (IDIYComponent<?> c : components)
@@ -305,13 +389,13 @@ public abstract class AbstractNetlistAnalyzer {
     Collections.sort(names);
     return names;
   }
-  
+
   protected Netlist simplify(Netlist netlist, Set<Node> nodesToMerge, Collection<Node> nodesToPurge) {
     Netlist res = new Netlist();
     res.getSwitchSetup().addAll(netlist.getSwitchSetup());
 
     Group merged = new Group();
-    
+
     // merge
     for (Group g : netlist.getGroups()) {
       boolean needsMerging = false;
@@ -330,28 +414,28 @@ public abstract class AbstractNetlistAnalyzer {
         res.getGroups().add(g.clone());
       }
     }
-    
+
     if (!merged.getNodes().isEmpty())
       res.getGroups().add(merged);
-    
+
     // purge
     for (Group g : res.getGroups()) {
       g.getNodes().removeAll(nodesToPurge);
     }
-    
+
     System.out.println("Before:\n" + netlist);
     System.out.println("After:\n" + res);
-    
+
     return res;
   }
-  
+
   protected boolean intersect(List<Group> groups, Node node) {
     for (Group g : groups)
       if (g.getNodes().contains(node))
         return true;
     return false;
   }
-  
+
   protected Node intersect(List<Group> groups, Group group) {
     for (Group g : groups)
       for (Node node : group.getNodes())

diylc/diylc-library/src/org/diylc/netlist/GuitarDiagramAnalyzer.java

@@ -164,7 +164,7 @@ public class GuitarDiagramAnalyzer extends AbstractNetlistAnalyzer implements IN
     } else {      
       Node jackTip = jackTipNodes.get(0);
       Node jackSleeve = jackSleeveNodes.get(0);      
-      return constructTree(netlist, jackTip, jackSleeve);
+      return constructTreeBetween(netlist, jackTip, jackSleeve);
     }
   }
 }