bprocessor-commit

[Michael L. <he...@us...>]

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

Modified Files:
	Command.java Space.java 
Log Message:
Surfaces with size 4 is drawn as quads
Grid generation

Index: Space.java
===================================================================
RCS file: /cvsroot/bprocessor/model/src/net/sourceforge/bprocessor/model/Space.java,v
retrieving revision 1.209
retrieving revision 1.210
diff -C2 -d -r1.209 -r1.210
*** Space.java	2 Dec 2007 12:02:14 -0000	1.209
--- Space.java	7 Dec 2007 11:00:22 -0000	1.210
***************
*** 1408,1412 ****
      }
      if (isInstance()) {
!       result.add(anchor.center());
      }
      if (container) {
--- 1408,1412 ----
      }
      if (isInstance()) {
!       result.addAll(anchor.collect());
      }
      if (container) {

Index: Command.java
===================================================================
RCS file: /cvsroot/bprocessor/model/src/net/sourceforge/bprocessor/model/Command.java,v
retrieving revision 1.47
retrieving revision 1.48
diff -C2 -d -r1.47 -r1.48
*** Command.java	3 Dec 2007 22:02:24 -0000	1.47
--- Command.java	7 Dec 2007 11:00:22 -0000	1.48
***************
*** 1640,1652 ****
        parameters.put("surface", surface);
        parameters.put("x distance", 0.5);
      }
!     /** {@inheritDoc} */
!     @Override
!     public void evaluate() { 
!       Surface surface = (Surface) parameters.get("surface");
!       double xdistance = parameters.getDouble("x distance");
!       Space owner = surface.getOwner();
!       
!       Space net = Space.createNet("");
        HashMap map = new HashMap();
        
--- 1640,1648 ----
        parameters.put("surface", surface);
        parameters.put("x distance", 0.5);
+       parameters.put("y distance", 0.5);
      }
!     
!     private Space createVerticalNet(Surface surface, double xdistance) {
!       Space net = Space.createNet("Vertical Net");
        HashMap map = new HashMap();
        
***************
*** 1656,1661 ****
        }
        
-       
-       
        Vertex vertex = surface.getFirstVertex();
        Vertex normal = surface.normal();
--- 1652,1655 ----
***************
*** 1682,1686 ****
        }
        Vertex min = system.unTranslate(new Vertex(xmin, ymin, 0));
-       Vertex max = system.unTranslate(new Vertex(xmax, xmax, 0));
        Vertex origin = min;
        
--- 1676,1679 ----
***************
*** 1716,1720 ****
            }
            if (intersections.size() > 0) {
!             for (int j = 0; j < (int) (intersections.size() / 2); j++) {
                Iterator<Vertex> iter = intersections.iterator();
                Vertex from = iter.next();
--- 1709,1713 ----
            }
            if (intersections.size() > 0) {
!             for (int j = 0; j < (intersections.size() / 2); j++) {
                Iterator<Vertex> iter = intersections.iterator();
                Vertex from = iter.next();
***************
*** 1728,1731 ****
--- 1721,1845 ----
        Geometry.insertEdges(net, contour);
        Geometry.insertEdges(net, verticals);
+       
+       return net;
+     }
+     
+     private static int round(double value) {
+       int n = (int) Math.floor(value);
+       double rest = value - n;
+       if (rest < 0.0000001) {
+         n--;
+       }
+       return n;
+     }
+     
+     private Space createGrid(Surface surface, double dx, double dy) {
+       Space net = Space.createNet("Grid Net");
+       HashMap map = new HashMap();
+       
+       List<Edge> contour = new LinkedList();
+       for (Edge current : surface.getEdges()) {
+         contour.add((Edge) current.copy(map));
+       }
+       
+       Vertex vertex = surface.getFirstVertex();
+       Vertex normal = surface.normal();
+       CoordinateSystem system = CoordinateSystem.systemFor(vertex, normal);
+       
+       List<Vertex> vertices = Offset.vertices(contour);
+       List<Vertex> locals = system.translate(vertices);
+       
+       double xmin = Double.MAX_VALUE;
+       double xmax = Double.MIN_VALUE;
+       double ymin = Double.MAX_VALUE;
+       double ymax = Double.MIN_VALUE;
+       for (Vertex current : locals) {
+         if (current.getX() < xmin) {
+           xmin = current.getX();
+         }
+         if (current.getX() > xmax) {
+           xmax = current.getX();
+         }
+         if (current.getY() < ymin) {
+           ymin = current.getY();
+         }
+         if (current.getY() > ymax) {
+           ymax = current.getY();
+         }
+       }
+       
+       double width = xmax - xmin;
+       double height = ymax - ymin;
+       
+       int n = round(width / dx);
+       int m = round(height / dy);
+       
+       Vertex[][] grid = new Vertex[n][m];
+       {
+         double x = xmin;
+         for (int i = 0; i < n; i++) {
+           x = x + dx;
+           double y = ymin;
+           for (int j = 0; j < m; j++) {
+             y = y + dy;
+             grid[i][j] = new Vertex(x, y, 0);
+           }
+         }
+       }
+       
+       List<Edge> verticals = new LinkedList();
+       {
+         for (int i = 0; i < n; i++) {
+           for (int j = 0; j < m - 1; j++) {
+             Vertex from = grid[i][j];
+             Vertex to = grid[i][j + 1];
+             verticals.add(new Edge(from, to));
+           }
+         }
+       }
+       
+       List<Edge> horizontals = new LinkedList();
+       {
+         for (int j = 0; j < m; j++) {
+           for (int i = 0; i < n - 1; i++) {
+             Vertex from = grid[i][j];
+             Vertex to = grid[i + 1][j];
+             horizontals.add(new Edge(from, to));
+           }
+         }
+       }
+       
+       List<Edge> all = new LinkedList();
+       all.addAll(verticals);
+       all.addAll(horizontals);
+       
+       {
+         for (int i = 0; i < n; i++) {
+           for (int j = 0; j < m; j++) {
+             Vertex current = grid[i][j];
+             Vertex global = system.unTranslate(current);
+             current.set(global);
+           }
+         }
+       }
+       Geometry.insertEdges(net, all);
+       
+       
+       return net;
+     }
+     
+     /** {@inheritDoc} */
+     @Override
+     public void evaluate() { 
+       Surface surface = (Surface) parameters.get("surface");
+       double xdistance = parameters.getDouble("x distance");
+       double ydistance = parameters.getDouble("y distance");
+       Space net;
+       if (xdistance > 0.0000001 && ydistance > 0.00001) {
+         net = createGrid(surface, xdistance, ydistance);
+       } else {
+         net = createVerticalNet(surface, xdistance);
+       }
+       Space owner = surface.getOwner();
        owner.add(net);
      }