[Bprocessor-commit] model/src/net/sourceforge/bprocessor/model Geometry.java, 1.52, 1.53

[Nordholt <nor...@us...>]

Update of /cvsroot/bprocessor/model/src/net/sourceforge/bprocessor/model
In directory sc8-pr-cvs3.sourceforge.net:/tmp/cvs-serv1139/src/net/sourceforge/bprocessor/model

Modified Files:
	Geometry.java 
Log Message:
optimizing the simplify methods a bit

Index: Geometry.java
===================================================================
RCS file: /cvsroot/bprocessor/model/src/net/sourceforge/bprocessor/model/Geometry.java,v
retrieving revision 1.52
retrieving revision 1.53
diff -C2 -d -r1.52 -r1.53
*** Geometry.java	15 Apr 2007 11:10:40 -0000	1.52
--- Geometry.java	23 Apr 2007 14:57:26 -0000	1.53
***************
*** 528,533 ****
      i.normalize();
      CoordinateSystem cs = new CoordinateSystem(i, j , n, sharedVertex);
-     log.info(cs);
-     //Project.getInstance().getActiveSpace().add(cs);
      List<Surface> neighbours = new LinkedList<Surface>(edge.getSurfaces());
      if (surToAngle == null) {
--- 528,531 ----
***************
*** 624,633 ****
      for (Surface s : surfaces) {
        edges.addAll(s.getEdges());
!     }
      vertices.addAll(Geometry.collect(edges));
      allPossibleCollapses(vertices);
      allEdgeCollapses(edges);
!     surfaces.removeAll(deleteRedundantSurfaces(surfaces));
!     mergeAllPossibleSurfaces(surfaces);
      extendAllPossibleEdges(edges);
    }
--- 622,631 ----
      for (Surface s : surfaces) {
        edges.addAll(s.getEdges());
!     }    
      vertices.addAll(Geometry.collect(edges));
      allPossibleCollapses(vertices);
      allEdgeCollapses(edges);
!     deleteRedundantSurfaces(surfaces);
!     mergeAllPossibleSurfaces2(edges);
      extendAllPossibleEdges(edges);
    }
***************
*** 641,648 ****
      Set<Surface> redundant = new HashSet<Surface>();
      for (Surface s : surfaces) {
!       if (s.getFrontDomain() == s.getBackDomain()) {
!         redundant.add(s);
!         s.getFrontDomain().removeSurface(s);
!         s.delete();
        }
      }
--- 639,652 ----
      Set<Surface> redundant = new HashSet<Surface>();
      for (Surface s : surfaces) {
!       Space front = s.getFrontDomain();
!       if (front != null && 
!           front == s.getBackDomain()) {
!         Space owner = front.getOwner();
!         if (owner != null && 
!             front != owner.empty) {
!           redundant.add(s);
!           front.removeSurface(s);
!           s.delete();
!         }
        }
      }
***************
*** 656,676 ****
     */
    public static void mergeAllPossibleSurfaces(Set<Surface> surfaces) {
!     Set<Edge> mergeEdges = new HashSet<Edge>();
      for (Surface s : surfaces) {
!       for (Edge e : s.getEdges()) {
!         Set<Surface> surfs = e.getSurfaces();
!         if (surfs.size() == 2) {
!           surfs.remove(s);
!           Surface otherSurface = surfs.iterator().next();
!           if (mergeTest(s, otherSurface)) {
!             mergeEdges.add(e);
!           }
          }
        }
      }
!     for (Edge e : mergeEdges) {
        e.delete();
      }
!   }   
  
    /**
--- 660,691 ----
     */
    public static void mergeAllPossibleSurfaces(Set<Surface> surfaces) {
!     Set<Edge> edges = new HashSet<Edge>();
      for (Surface s : surfaces) {
!       edges.addAll(s.getEdges());
!     }
!     mergeAllPossibleSurfaces2(edges);
!   }
!   
!   /**
!    * Deletes all edges that lie between two surfaces that could be merged.
!    * @param edges a set of edges 
!    */
!   public static void mergeAllPossibleSurfaces2(Set<Edge> edges) {
!     Set<Edge> deleteEdge = new HashSet<Edge>();
!     for (Edge e : edges) {
!       Set<Surface> surfaces = e.getSurfaces();
!       if (surfaces.size() == 2) {
!         Iterator<Surface> it = surfaces.iterator();
!         Surface s1 = it.next();
!         Surface s2 = it.next();
!         if (mergeTest(s1, s2)) {
!           deleteEdge.add(e);
          }
        }
      }
!     for (Edge e : deleteEdge) {
        e.delete();
      }
!   }
  
    /**
***************
*** 703,706 ****
--- 718,722 ----
    }
    
+   
    /**
     * Finds sets of edges that have the same endpoints (in both ends) 
***************
*** 709,739 ****
     */
    public static void allEdgeCollapses(Set<Edge> edges) {
!     Set<Edge> collapsed = firstEdgeCollaps(edges);
!     while (!collapsed.isEmpty()) {
!       edges.removeAll(collapsed);
!       collapsEdges(collapsed);
!       collapsed = firstEdgeCollaps(edges);
!     }    
!   }
!   
!   private static Set<Edge> firstEdgeCollaps(Set<Edge> edges) {
!     Set<Edge> collaps = new HashSet<Edge>();
!     Set<Edge> unChecked = new HashSet<Edge>(edges); 
      for (Edge e : edges) {
!       unChecked.remove(e);
!       for (Edge ue : unChecked) {
!         if (e.equalsEps(ue)) {
!           collaps.add(ue);
!         }
        }
!       if (!collaps.isEmpty()) {
!         collaps.add(e);
!         break;
        }
      }
!     return collaps;
!   }
    
!   private static void collapsEdges(Set<Edge> edges) {
      if (!edges.isEmpty()) {
        Edge collapsEdge = edges.iterator().next();
--- 725,768 ----
     */
    public static void allEdgeCollapses(Set<Edge> edges) {
!     Map<Vertex, Set<Edge>> v2e = new HashMap<Vertex, Set<Edge>>(edges.size());
      for (Edge e : edges) {
!       Vertex to = e.to;
!       Vertex from = e.from;
!       Set<Edge> toSet = v2e.get(to);
!       Set<Edge> fromSet = v2e.get(from);
!       if (fromSet == null) {
!         fromSet = new HashSet<Edge>();
        }
!       if (toSet == null) {
!         toSet = new HashSet<Edge>();
        }
+       fromSet.add(e);
+       toSet.add(e);      
+       v2e.put(e.getFrom(), fromSet);
+       v2e.put(e.getTo(), toSet);
      }
!     Set<Edge> allCollapsed = new HashSet<Edge>();
!     for (Vertex v : v2e.keySet()) {
!       Set<Edge> vEdges = new HashSet<Edge>(v2e.get(v));
!       for (Edge e : vEdges) {
!         if (!allCollapsed.contains(e)) {
!           Vertex other = e.otherVertex(v);
!           Set<Edge> otherEdges = v2e.get(other);
!           Set<Edge> collaps = new HashSet<Edge>();
!           for (Edge otherE : otherEdges) {
!             if (vEdges.contains(otherE)) {
!               collaps.add(otherE);
!             }
!           }
!           if (collaps.size() > 1) {
!             allCollapsed.addAll(collaps);
!             collapsEdges(collaps);
!           }
!         }
!       }
!     }
!   }  
    
!   private static Edge collapsEdges(Set<Edge> edges) {
      if (!edges.isEmpty()) {
        Edge collapsEdge = edges.iterator().next();
***************
*** 748,752 ****
--- 777,783 ----
          e.delete();
        }
+       return collapsEdge;
      }
+     return null;
    }
    
***************
*** 811,815 ****
        }
      }
!   }
    
    /**
--- 842,847 ----
        }
      }
!   }  
!   
    
    /**
***************
*** 823,827 ****
      List<Edge> extendable = firstExtendList(edges);
      while (!extendable.isEmpty()) {
!       extendEdges(extendable);
        for (Edge e : extendable) {
          e.delete();
--- 855,859 ----
      List<Edge> extendable = firstExtendList(edges);
      while (!extendable.isEmpty()) {
!       extendEdges(extendable);    
        for (Edge e : extendable) {
          e.delete();
***************
*** 829,833 ****
        edges.removeAll(extendable);
        extendable = firstExtendList(edges);
!     }    
    }
    
--- 861,865 ----
        edges.removeAll(extendable);
        extendable = firstExtendList(edges);
!     }
    }
    
***************
*** 851,854 ****
--- 883,887 ----
        Set<Surface> surfaces = first.getSurfaces();
        for (Surface s : surfaces) {
+         int size = s.getEdges().size();
          s.replace(extendable, extendedEdge);
          Space owner  = s.getOwner();
***************
*** 871,875 ****
        List<Edge> fromList = extendList(e, e.getFrom());
        if (!toList.isEmpty() || !fromList.isEmpty()) {
!         extendable.addAll(toList);
          extendable.add(e);
          extendable.addAll(fromList);
--- 904,909 ----
        List<Edge> fromList = extendList(e, e.getFrom());
        if (!toList.isEmpty() || !fromList.isEmpty()) {
!         Collections.reverse(toList);
!         extendable.addAll(toList);     
          extendable.add(e);
          extendable.addAll(fromList);
***************
*** 890,901 ****
    private static List<Edge> extendList(Edge e, Vertex v) {
      List<Edge> extendList = new LinkedList<Edge>();
!     if (e.contains(v) && v.getEdges().size() == 2) {
!       Set<Edge> edges = v.getEdges();
!       edges.remove(e);
!       Edge otherEdge = edges.iterator().next();
!       if (e.parrallel(otherEdge) && 
!           e.getSurfaces().equals(otherEdge.getSurfaces())) {
!         extendList.add(otherEdge);
!         extendList.addAll(extendList(otherEdge, otherEdge.otherVertex(v)));
        }
      }
--- 924,942 ----
    private static List<Edge> extendList(Edge e, Vertex v) {
      List<Edge> extendList = new LinkedList<Edge>();
!     Edge currentEdge = e;
!     Vertex currentVertex = v;
!     Set<Edge> currentEdges = v.getEdges();
!     while (currentEdge.contains(currentVertex) && 
!            currentVertex.getEdges().size() == 2) {
!       currentEdges.remove(currentEdge);
!       Edge otherEdge = currentEdges.iterator().next();
!       if (currentEdge.parrallel(otherEdge) && 
!           currentEdge.getSurfaces().equals(otherEdge.getSurfaces())) {
!         currentVertex = otherEdge.otherVertex(currentVertex);
!         currentEdges = currentVertex.getEdges();
!         currentEdge = otherEdge;
!         extendList.add(currentEdge);
!       } else {
!         break;
        }
      }