bprocessor-commit

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

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

Modified Files:
	Space.java 
Log Message:
simplyfied and try to fix the delete method, still has errors though.

Index: Space.java
===================================================================
RCS file: /cvsroot/bprocessor/model/src/net/sourceforge/bprocessor/model/Space.java,v
retrieving revision 1.133
retrieving revision 1.134
diff -C2 -d -r1.133 -r1.134
*** Space.java	14 Apr 2007 14:59:34 -0000	1.133
--- Space.java	15 Apr 2007 11:12:04 -0000	1.134
***************
*** 749,857 ****
    public void delete(Edge edge) {
      if (edge.getId() != null) {
!       Set<Surface> surfaces = edge.getSurfaces();
!       
        Vertex to = edge.getTo();
!       Vertex from = edge.getFrom();
!       
        remove(edge);
!       
!       {
!         // Find adjacent surfaces that must be combined to one surface.
!         //
!         // First the adjacent surfaces are partioned into groups of 
!         // coplanar surfaces.
!         // If there is only one group consisting of two coplanar surfaces
!         // these two surfaces are combined.
!         
!         List<List<Surface>> partions = new LinkedList<List<Surface>>();
!         List<Surface> work = new LinkedList<Surface>(surfaces);
!         while (!work.isEmpty()) {
!           Iterator iter = work.iterator();
!           Surface first = (Surface) iter.next();
!           iter.remove();
!           Plane plane = first.plane();
!           List<Surface> partion = new LinkedList<Surface>();
!           partion.add(first);
!           while (iter.hasNext()) {
!             Surface current = (Surface) iter.next();
!             if (plane.contains(current)) {
!               partion.add(current);
!               iter.remove();
              }
!           }
!           partions.add(partion);
!         }
!         int count = 0;
!         List partion = null;
!         {
!           Iterator<List<Surface>> iter = partions.iterator();
!           while (iter.hasNext()) {
!             List current = iter.next();
!             if (current.size() == 2) {
!               count++;
!               partion = current;
              }
            }
          }
!         if (count == 1) {
!           Surface s1 = (Surface) partion.get(0);
!           Surface s2 = (Surface) partion.get(1);
!           List<Edge> edges1 = new LinkedList<Edge>();
!           List<Edge> edges2 = new LinkedList<Edge>();
!           {
!             boolean gab = false;
!             List<Edge> prefix = new LinkedList<Edge>();
!             Iterator iter = s1.getEdges().iterator();
!             while (iter.hasNext()) {
!               Edge current = (Edge) iter.next();
!               if (!s2.contains(current)) {
!                 if (!gab) {
!                   prefix.add(current);
!                 } else {
!                   edges1.add(current);
!                 }
!               } else {
!                 gab = true;
!               }
!             }
!             edges1.addAll(prefix);
!           }
!           {
!             boolean gab = false;
!             List<Edge> prefix = new LinkedList<Edge>();
!             Iterator iter = s2.getEdges().iterator();
!             while (iter.hasNext()) {
!               Edge current = (Edge) iter.next();
!               if (!s1.contains(current)) {
!                 if (!gab) {
!                   prefix.add(current);
!                 } else {
!                   edges2.add(current);
!                 }
!               } else {
!                 gab = true;
!               }
!             }
!             edges2.addAll(prefix);
!           }
!           if (Edge.first(edges1) == Edge.first(edges2)) {
!             Collections.reverse(edges2);
!           }
!           edges1.addAll(edges2);
!           Surface surface = new Surface(edges1);
!           add(surface);
!           if (s1.getExterior() != null) {
!             s1.getExterior().addHole(surface);
            }
-           Surface.mergeSpaceAssign(s1, s2, surface);
          }
        }
-       
-       
-       Iterator it = surfaces.iterator();
-       while (it.hasNext()) {
-         Surface surface = (Surface)it.next();
-         remove(surface);
-       }
        if (to.getOwner() != null) {
          if (to.getEdges().size() == 0) {
--- 749,820 ----
    public void delete(Edge edge) {
      if (edge.getId() != null) {
!       Set<Surface> surfaces = edge.getSurfaces();      
        Vertex to = edge.getTo();
!       Vertex from = edge.getFrom();      
        remove(edge);
!       {        
!         if (surfaces.size() == 2) {
!           Iterator<Surface> it = surfaces.iterator();
!           Surface s1 = it.next();
!           Surface s2 = it.next();
!           if (s1.plane().contains(s2)) {
!             List<Edge> edges1 = edgeFirst(s1, edge);
!             List<Edge> edges2 = edgeFirst(s2, edge);
!             edges1.remove(edge);
!             edges2.remove(edge);
!             if (Edge.first(edges1) == Edge.first(edges2)) {
!               Collections.reverse(edges2);
              }
!             edges1.addAll(edges2);
!             Surface surface = new Surface(edges1);
!             add(surface);            
!             if (s1.getExterior() != null) {
!               s1.getExterior().addHole(surface);
!             } else if (s2.getExterior() != null) {
!               s2.getExterior().addHole(surface);
              }
+             Set<Surface> holes = new HashSet<Surface>();
+             holes.addAll(s1.getHoles());
+             holes.addAll(s2.getHoles());
+             for (Surface hole : holes) {
+               surface.addHole(hole);
+             }            
+             Surface.mergeSpaceAssign(s1, s2, surface);
            }
          }
!       }
!       for (Surface surface : surfaces) {
!         List<Edge> edges = surface.getEdges();
!         int firstIndex = edges.indexOf(edge);
!         int lastIndex = edges.lastIndexOf(edge);
!         if (firstIndex == lastIndex) {
!           remove(surface);
!         } else {
!           int size = edges.size();
!           int gapSize = lastIndex - firstIndex;
!           if ((gapSize == 1) || gapSize == size - 1) {
!             edges.remove(lastIndex);
!             edges.remove(firstIndex);
!             surface.setEdges(edges);
!           } else {
!             List<Edge> head = new LinkedList<Edge>(edges.subList(0, firstIndex));
!             List<Edge> middel = new LinkedList<Edge>(edges.subList(firstIndex + 1, lastIndex));
!             List<Edge> tail = new LinkedList<Edge>(edges.subList(lastIndex, size));
!             tail.remove(edge);
!             head.addAll(tail);
!             Surface s1 = new Surface(head);
!             Surface s2 = new Surface(middel);
!             if (s1.surrounds(s2, true)) {
!               surface.setEdges(head);
!               add(s2);
!               surface.addHole(s2);
!             } else {
!               surface.setEdges(middel);
!               add(s1);
!               surface.addHole(s1);
!             }            
            }
          }
        }
        if (to.getOwner() != null) {
          if (to.getEdges().size() == 0) {
***************
*** 868,871 ****
--- 831,855 ----
    
    /**
+    * Takes a surface and arranges its edgelist so that
+    * the a specified edge in the list is the first edge in the list
+    * @param surface the surface
+    * @param first the edge the should be first in the edgelist
+    * @return a list of the surfaces edges arranged correctly, returns 
+    * unaltered edgelist if the edge is not in the surface.
+    */
+   private static List<Edge> edgeFirst(Surface s, Edge first) {
+     List<Edge> edges = new LinkedList<Edge>(s.getEdges());
+     int index = edges.indexOf(first);
+     int size = edges.size();
+     if (index > 0) {
+       List<Edge> prefix = edges.subList(0, index);
+       List<Edge> suffix = edges.subList(index, size);
+       edges = suffix;
+       edges.addAll(prefix);
+     }
+     return edges;
+   }
+   
+   /**
     * Return the edges
     * @return The edges
***************
*** 927,933 ****
    public void remove(Surface surface) {
      if (surface.getHoles() != null) {
!       Iterator iter = surface.getHoles().iterator();
!       while (iter.hasNext()) {
!         Surface curHole = (Surface)iter.next();
          if (surface.getExterior() != null) {
            surface.getExterior().addHole(curHole);
--- 911,915 ----
    public void remove(Surface surface) {
      if (surface.getHoles() != null) {
!       for (Surface curHole : surface.getHoles()) {
          if (surface.getExterior() != null) {
            surface.getExterior().addHole(curHole);