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

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

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

Modified Files:
	Geometry.java 
Log Message:
added the simplify geometry method. It can still cause errors, these has to do with how we delete edges.

Index: Geometry.java
===================================================================
RCS file: /cvsroot/bprocessor/model/src/net/sourceforge/bprocessor/model/Geometry.java,v
retrieving revision 1.51
retrieving revision 1.52
diff -C2 -d -r1.51 -r1.52
*** Geometry.java	30 Mar 2007 11:11:43 -0000	1.51
--- Geometry.java	15 Apr 2007 11:10:40 -0000	1.52
***************
*** 606,609 ****
--- 606,637 ----
    
    /**
+    * Simplifies geometry
+    * @param entities a set of entities
+    */
+   public static void simplifyGeometry(Collection<? extends Entity> entities) {
+     Set<Surface> surfaces = new HashSet<Surface>();
+     Set<Edge> edges = new HashSet<Edge>();
+     Set<Vertex> vertices = new HashSet<Vertex>();
+     for (Entity ent : entities) {
+       if (ent instanceof Surface) {
+         surfaces.add((Surface)ent);
+       } else if (ent instanceof Edge) {
+         edges.add((Edge)ent);
+       } else if (ent instanceof Vertex) {
+         vertices.add((Vertex)ent);
+       }      
+     }
+     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);
+   }
+   
+   /**
     * Deletes all surfaces that have the same space assignment on each side
     * @param surfaces a set of surfaces to delete from
***************
*** 639,643 ****
            }
          }
!       }      
      }
      for (Edge e : mergeEdges) {
--- 667,671 ----
            }
          }
!       }
      }
      for (Edge e : mergeEdges) {
***************
*** 676,679 ****
--- 704,755 ----
    
    /**
+    * Finds sets of edges that have the same endpoints (in both ends) 
+    * and replaces each set with a single edge. 
+    * @param edges the edges to search 
+    */
+   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();
+       edges.remove(collapsEdge);
+       for (Edge e : edges) {
+         Set<Surface> surfaces = e.getSurfaces();
+         for (Surface s : surfaces) {
+           List<Edge> edge = new LinkedList<Edge>();
+           edge.add(e);
+           s.replace(edge, collapsEdge);
+         }
+         e.delete();
+       }
+     }
+   }
+   
+   /**
     * Collapses a set of vertices, so that all vertices that 
     * lies in the same coordinates are replaced with one new vertex  
***************
*** 729,733 ****
              e.setFrom(collaps);
            }
-           e.changed();
          }
        }
--- 805,808 ----
***************
*** 748,752 ****
      List<Edge> extendable = firstExtendList(edges);
      while (!extendable.isEmpty()) {
-       log.info("extended");
        extendEdges(extendable);
        for (Edge e : extendable) {
--- 823,826 ----
***************
*** 792,796 ****
     */
    private static List<Edge>  firstExtendList(Set<Edge> edges) {
-     log.info("extend set size: " + edges.size());
      List<Edge> extendable = new LinkedList<Edge>();
      for (Edge e : edges) {
--- 866,869 ----
***************
*** 798,802 ****
        List<Edge> fromList = extendList(e, e.getFrom());
        if (!toList.isEmpty() || !fromList.isEmpty()) {
-         log.info("break");
          extendable.addAll(toList);
          extendable.add(e);
--- 871,874 ----
***************
*** 805,809 ****
        }
      }
-     log.info("extendable size: " + extendable.size());
      return extendable;
    }
--- 877,880 ----