[Bprocessor-commit] bprocessor/src/net/sourceforge/bprocessor/packages/physics PhysicsSurface.java, 1.3, 1.4 PhysicsSection.java, 1.1, 1.2

[Sebastian G. <sg...@us...>]

Update of /cvsroot/bprocessor/bprocessor/src/net/sourceforge/bprocessor/packages/physics
In directory vz-cvs-4.sog:/tmp/cvs-serv13676/src/net/sourceforge/bprocessor/packages/physics

Modified Files:
	PhysicsSurface.java PhysicsSection.java 
Log Message:
physics horizontal section

Index: PhysicsSurface.java
===================================================================
RCS file: /cvsroot/bprocessor/bprocessor/src/net/sourceforge/bprocessor/packages/physics/PhysicsSurface.java,v
retrieving revision 1.3
retrieving revision 1.4
diff -C2 -d -r1.3 -r1.4
*** PhysicsSurface.java	6 May 2012 15:14:59 -0000	1.3
--- PhysicsSurface.java	7 May 2012 16:00:24 -0000	1.4
***************
*** 20,24 ****
    boolean displayDiagonals = false;
    boolean displayCircularMesh = false;
!   boolean displayMovementGuides = true;
    
    //properties
--- 20,24 ----
    boolean displayDiagonals = false;
    boolean displayCircularMesh = false;
!   boolean displayMovementGuides = false;
    
    //properties

Index: PhysicsSection.java
===================================================================
RCS file: /cvsroot/bprocessor/bprocessor/src/net/sourceforge/bprocessor/packages/physics/PhysicsSection.java,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -d -r1.1 -r1.2
*** PhysicsSection.java	6 May 2012 15:15:00 -0000	1.1
--- PhysicsSection.java	7 May 2012 16:00:24 -0000	1.2
***************
*** 3,9 ****
--- 3,11 ----
  import java.util.ArrayList;
  import java.util.Collection;
+ import java.util.HashMap;
  import java.util.List;
  
  import net.sourceforge.bprocessor.model.Edge;
+ import net.sourceforge.bprocessor.model.Item;
  import net.sourceforge.bprocessor.model.ParameterBlock;
  import net.sourceforge.bprocessor.model.Selection;
***************
*** 18,22 ****
--- 20,27 ----
    Collection<Surface> surfaces  = new ArrayList<Surface>();
    PhysicsPlane sectionPlane;
+   List<Edge> intersectionEdges = new ArrayList<Edge>();
+   List<Surface> intersectionSurfaces = new ArrayList<Surface>();
    Vertex intersection = new Vertex();
+   double area = 0;
    
    //constructors
***************
*** 28,106 ****
    
    public void computeSection () {
!     List<Edge> intersectionEdges = new ArrayList<Edge>();
      for (Surface s : surfaces) {
!     //sort edges
!       Collection<Edge> sEdges = s.getEdges();
!       /*
!       System.out.println("0");
        Collection<Edge> tEdges = s.getEdges();
!       if (tEdges.size()>0) {
!         System.out.println("1");
!         Edge current = (Edge)tEdges.toArray()[0];
!         System.out.println("2");
!         Collection<Edge> sEdges = new ArrayList<Edge>();
!         System.out.println("3");
!         sEdges.add(current);
!         tEdges.remove(current);
!         boolean res = true;
!         while (res == true) {
!           res = false;
!           for (Edge e : tEdges) {
!             System.out.println("4");
!             if (e.getFrom().equals(current.getTo())) {
!               System.out.println("next edge");
!               current = e;
!               sEdges.add(current.copy());
!               tEdges.remove(current);
!               res = true;
!               if (tEdges.size() == 0) {
!                 res = false;
!               }
!               //end for loop
                break;
!             }
!             if (e.getTo().equals(current.getTo())) {
!               System.out.println("next edge inverse");
!               Edge eRev = new Edge(e.getTo(),e.getFrom());
!               current = eRev;
!               sEdges.add(current.copy());
!               tEdges.remove(e);
!               res = true;
!               if (tEdges.size() == 0) {
!                 res = false;
!               }
!               //end for loop
                break;
              }
            }
          }
!         */
        
!         List<Vertex> intersections = new ArrayList<Vertex>();
!         for (Edge e : sEdges) {
!           System.out.println("intersecting...");
!           String result;
            System.out.println(e.getFrom().toString());
            System.out.println(e.getTo().toString());
!           result = intersectLinePlaneBetweenPoints(e.getFrom(),e.getTo());
!           if (result == "intersect") {  
!             intersections.add(intersection);
!           }
!           if (result == "both") {
!             intersections.add(e.getFrom());
!             intersections.add(e.getTo());
            }
          }
!         //irregular polygons can have more than 2 intersections! CHECK!
!         if (intersections.size()==2) {
!           System.out.println(intersections.get(0).toString());
!           System.out.println(intersections.get(1).toString());
!           Edge intersectionEdge = new Edge(intersections.get(0).copy(), intersections.get(1).copy());
!           intersectionEdges.add(intersectionEdge);
!           sectionsSpace.add(intersectionEdge);
!           sectionsSpace.update();
          }
        }
!     //}
    }
    
--- 33,239 ----
    
    public void computeSection () {
!     area = 0;
!     intersectionEdges = new ArrayList<Edge>();
      for (Surface s : surfaces) {
!       
        Collection<Edge> tEdges = s.getEdges();
!       //sort edges
!       List<Edge> sEdges = new ArrayList<Edge>();
!       List<Edge> cEdges = new ArrayList<Edge>();
!       Edge current = (Edge)tEdges.toArray()[0];
!       
!       //copy original Edge list
!       for (Edge e: tEdges) {
!         if (!e.equals(current)) {
!           cEdges.add(e.copy());
!         }
!       }
! 
!       //sort edges
!       sEdges.add(current);
!       boolean check = true;
!       while (check) {
!         if (cEdges.size()>0) {
!           Edge eAdd = new Edge();
!           Edge eRem = new Edge();
!           check = false;
!           for (Edge e : cEdges) {
!             if (current.getTo().equalEps(e.getFrom())) {
!               eAdd = new Edge(e.getFrom(), e.getTo());
!               eRem = e;
!               check = true;
                break;
!             } else if (current.getTo().equalEps(e.getTo())) {
!               eAdd = new Edge(e.getTo(), e.getFrom());
!               eRem = e;
!               check = true;
                break;
+             } 
+           } 
+           sEdges.add(eAdd);
+           if (check) {
+             cEdges.remove(eRem);
+           }
+           current = eAdd;
+         } else {
+           check = false;
+         }
+       }      
+       
+       List<Vertex> intersections = new ArrayList<Vertex>();
+       HashMap<Vertex, Edge> iEdges = new HashMap();  
+       
+       for (Edge e : sEdges) {
+         String result;
+         result = intersectLinePlaneBetweenPoints(e.getFrom(),e.getTo());
+         if (result == "intersect") {  
+           Vertex v = intersection.copy();
+           intersections.add(v);
+           iEdges.put(v, e);
+         }
+         if (result == "both") {
+           //check if edge is already in collection
+           if (!edgeExists(e)) {
+             intersectionEdges.add(e);
+           }
+         }
+       }
+       if (intersections.size()>=2) {
+         //add first elements add end of lists for looping
+         Vertex first = intersections.get(0).copy();
+         Edge fEdge = iEdges.get(intersections.get(0)).copy();
+         intersections.add(first);
+         iEdges.put(first, fEdge);
+         
+         //irregular polygons can have more than 2 intersections! CHECK!
+         for (int i = 0; i <intersections.size()-1; i ++) {
+           Vertex a = intersections.get(i);
+           Vertex b = intersections.get(i+1);
+           Edge aE = iEdges.get(a);
+           Edge bE = iEdges.get(b);
+           if ((aE.getFrom().getZ()<sectionPlane.origin.getZ()) && (bE.getTo().getZ()<sectionPlane.origin.getZ())) {
+             Edge intersectionEdge = new Edge(a, b);
+             if (!edgeExists(intersectionEdge)) {
+               intersectionEdges.add(intersectionEdge);
              }
            }
          }
!       }
        
!       //for (Edge e : intersectionEdges) {
!       //  sectionsSpace.add(e);
!       //}
!     }
!     
!     boolean search = true;
!     while (search) {
!       search = false;
!       if (intersectionEdges.size()>0) {
!         Edge current = intersectionEdges.get(0).copy();
!         intersectionEdges.remove(0);
!         boolean chain = true;
!         List<Edge> surfaceEdges = new ArrayList<Edge>();
!         surfaceEdges.add(current);
!         while (chain) {
!         
!           if (intersectionEdges.size()>0) {
!             Edge eAdd = new Edge();
!             Edge eRem = new Edge();
!             chain = false;
!             for (Edge e : intersectionEdges) {
!               if (current.getTo().equalEps(e.getFrom())) {
!                 eAdd = new Edge(current.getTo(), e.getTo());
!                 eRem = e;
!                 chain = true;
!                 break;
!               } else if (current.getTo().equalEps(e.getTo())) {
!                 eAdd = new Edge(current.getTo(), e.getFrom());
!                 eRem = e;
!                 chain = true;
!                 break;
!               } 
!             } 
!             
!             if (chain) {
!               surfaceEdges.add(eAdd);
!               intersectionEdges.remove(eRem);
!               current = eAdd;
!             }
!             
!           } else {
!             chain = false;
!           }
!         
!         } //while chain
!         //check if chain is a closed surface
!         /*
!         for (Edge e : surfaceEdges) {
!           System.out.println(e.toString());
            System.out.println(e.getFrom().toString());
            System.out.println(e.getTo().toString());
!           System.out.println("---");
!         }
!         */
!         if (surfaceEdges.size()>2) {
!           Edge firstEdge = surfaceEdges.get(0);
!           Edge lastEdge = surfaceEdges.get(surfaceEdges.size()-1);
!           //System.out.println(firstEdge.getFrom().toString());
!           //System.out.println(lastEdge.getTo().toString());
!           if (firstEdge.getFrom().equalEps(lastEdge.getTo())) {
!             //surface is closed
!             Surface s = new Surface(surfaceEdges);
!             intersectionSurfaces.add(s);
            }
          }
!         if (intersectionEdges.size()>2) {
!           search = true;
          }
        }
!     } //while search
!     //check for holes in surfaces
!     area = 0;
!     for (Surface s : intersectionSurfaces) {
!       area = area + s.getArea();
!       PhysicsCollisionSurface pcs = new PhysicsCollisionSurface(s);
!       for (Surface cs : intersectionSurfaces) {
!         if (!s.equals(cs)) {
!           Collection<Vertex> csVertices = cs.getVertices();
!           boolean inside = true;
!           for (Vertex v : csVertices) {
!             Space guides = Item.createUnion("Guidelines");
!             if (!pcs.pointInsidePolygon(v, guides)) {
!               inside = false;
!               break;
!             }
!           }
!           if (inside) {
!             //cs is a hole of s
!             s.addHole(cs);
!             area = area - (2 * cs.getArea());
!           }
!         }
!       }
!     }
!     
!     for (Surface s : intersectionSurfaces) {
!       sectionsSpace.addAll(s);
!     }
!     sectionsSpace.update();
!     System.out.println("Total Section Area = " + area);
!   }
!   
!   public boolean edgeExists(Edge a) {
!     boolean result = false;
!     for (Edge b : intersectionEdges) {
!       if ((a.getFrom().equalEps(b.getFrom())) && (a.getTo().equalEps(b.getTo()))) {
!         result = true;
!         break;
!       }
!       if ((a.getTo().equalEps(b.getFrom())) && (a.getFrom().equalEps(b.getTo()))) {
!         result = true;
!         break;
!       }
!     }
!     return result;
    }