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

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

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

Modified Files:
	Geometry.java 
Log Message:
simpler and better implementation for merging surfaces

Index: Geometry.java
===================================================================
RCS file: /cvsroot/bprocessor/model/src/net/sourceforge/bprocessor/model/Geometry.java,v
retrieving revision 1.50
retrieving revision 1.51
diff -C2 -d -r1.50 -r1.51
*** Geometry.java	29 Mar 2007 13:59:21 -0000	1.50
--- Geometry.java	30 Mar 2007 11:11:43 -0000	1.51
***************
*** 626,703 ****
     * new surfaces corresponding to the merge of those surfaces.
     * @param surfaces a set of surfaces 
-    * @return the surfaces created by merging
     */
!   public static Set<Surface> mergeAllPossibleSurfaces(Set<Surface> surfaces) {
!     Set<Surface> mergedSurfaces = new HashSet<Surface>();
!     Set<Surface> newSurfaces = new HashSet<Surface>();
      for (Surface s : surfaces) {
!       Space front = s.getFrontDomain();
!       Space back = s.getBackDomain();
!       if (!mergedSurfaces.contains(s)) {
!         Set<Surface> merged = new HashSet<Surface>();
!         List<Edge> edgeList = mergeSurface(s, merged);
!         if (merged.size() > 1) {
!           mergedSurfaces.addAll(merged);
!           Surface newSurface = new Surface(edgeList);
!           for (Surface merge : merged) {
!             Collection<Surface> holes = merge.getHoles();
!             for (Surface hole : holes) {
!               newSurface.addHole(hole);
!             }
            }
-           assignSame(s, newSurface, front, front);
-           assignSame(s, newSurface, back, back);
-           newSurfaces.add(newSurface);          
          }
!       }
      }
!     for (Surface s : mergedSurfaces) {
!       s.delete();
      }
!     return newSurfaces;
!   }
!    
!   /**
!    * Merges a surface with all possible surrounding surfaces.
!    * @param surface the surface
!    * @param mergedSurfaces the surfaces that were allready merged, (for
!    * recursive calls.)
!    * @return a list of edges defining the contour of the merged surface
!    */
!   private static List<Edge> mergeSurface(Surface surface, Set<Surface> mergedSurfaces) {
!     List<Edge> edgeList = new LinkedList<Edge>(surface.getEdges());
!     mergedSurfaces.add(surface);
!     for (Edge e : surface.getEdges()) {
!       Set<Surface> surfaces = e.getSurfaces();
!       if (surfaces.size() == 2) {
!         surfaces.remove(surface);
!         Surface nextSurface = surfaces.iterator().next();
!         if (mergedSurfaces.contains(nextSurface)) {
!           edgeList.remove(e);
!         } else if (mergeTest(surface, nextSurface)) {
!           int index = edgeList.indexOf(e);
!           int listSize = edgeList.size();
!           Edge beforeIndex = edgeList.get((index - 1 + listSize) % listSize);
!           Edge afterIndex = edgeList.get((index + 1) % listSize);
!           
!           List<Edge> nextList = mergeSurface(nextSurface, mergedSurfaces);
!           if (!nextList.isEmpty()) {
!             Edge first = nextList.get(0);
!             Edge last = nextList.get(nextList.size() - 1);
!             if (Edge.commonVertex(first, beforeIndex) != null &&
!                 Edge.commonVertex(last, afterIndex) != null) {
!               edgeList.addAll(index, nextList);
!             } else if (Edge.commonVertex(last, beforeIndex) != null &&
!                        Edge.commonVertex(first, afterIndex) != null) {
!               Collections.reverse(nextList);
!               edgeList.addAll(index, nextList);
!             }
!           }
!           edgeList.remove(e);
!         }
!       }
!     }    
!     return edgeList; 
!   }
  
    /**
--- 626,648 ----
     * new surfaces corresponding to the merge of those surfaces.
     * @param surfaces a set of surfaces 
     */
!   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();
      }
!   }   
  
    /**