[Bprocessor-commit] model/src/net/sourceforge/bprocessor/model Command.java, 1.28, 1.29

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

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

Modified Files:
	Command.java 
Log Message:
offset command

Index: Command.java
===================================================================
RCS file: /cvsroot/bprocessor/model/src/net/sourceforge/bprocessor/model/Command.java,v
retrieving revision 1.28
retrieving revision 1.29
diff -C2 -d -r1.28 -r1.29
*** Command.java	13 Nov 2007 12:19:29 -0000	1.28
--- Command.java	16 Nov 2007 13:15:08 -0000	1.29
***************
*** 331,335 ****
      }
      
!     private Vertex average(Collection<Vertex> vertices) {
        double x = 0;
        double y = 0;
--- 331,340 ----
      }
      
!     /**
!      * Compute the average of a collection of vertices
!      * @param vertices collection of vertices
!      * @return average
!      */
!     public static Vertex average(Collection<Vertex> vertices) {
        double x = 0;
        double y = 0;
***************
*** 803,805 ****
--- 808,919 ----
      }
    }
+   
+   /**
+    * Offset command
+    */
+   public static class Offset extends Command {
+     private List<Edge> edges;
+     
+     /**
+      * Constructs an Offset command
+      * @param edges list of edges
+      */
+     public Offset(List<Edge> edges) {
+       this.edges = edges;
+       parameters.put("distance", 1.0);
+     }
+     
+     
+     private List<Vertex> offset(List<Vertex> vertices, Vertex normal, double distance) {
+       List<Vertex> result = new LinkedList();
+       int n = vertices.size();
+       for (int i = 0; i < n; i++) {
+         Vertex current = vertices.get(i);
+         Vertex p;
+         Vertex q;
+         if (i == 0) {
+           p = vertices.get(n - 1);
+         } else {
+           p = vertices.get(i - 1);
+         }
+         if (i == n - 1) {
+           q = vertices.get(0);
+         } else {
+           q = vertices.get(i + 1);
+         }
+         
+         Vertex u = p.minus(current);
+         u.normalize();
+         Vertex v = q.minus(current);
+         v.normalize();
+         
+         Vertex direction = u.add(v);
+         if (direction.isZero()) {
+           direction = normal.cross(u);
+         } else {
+           Vertex cross = u.cross(direction);
+           double sign = normal.dot(cross);
+           if (sign < 0) {
+             sign = -1;
+           } else {
+             sign = 1;
+           }
+           direction = direction.scale(sign / cross.length());
+         }
+         
+         result.add(current.add(direction.scale(distance)));
+       }
+       return result;
+     }
+     
+     private List<Vertex> vertices(List<Edge> edges) {
+       List<Vertex> vertices = new ArrayList();
+       if (edges.size() > 1) {
+         Edge e0 = edges.get(0);
+         Edge e1 = edges.get(1);
+         Vertex v1 = Edge.commonVertex(e0, e1);
+         Vertex v0 = e0.otherVertex(v1);
+         Vertex vertex = v0;
+         vertices.add(vertex);
+         for (Edge current : edges) {
+           vertex = current.otherVertex(vertex);
+           if (vertex != v0) {
+             vertices.add(vertex);
+           }
+         }
+       }
+       return vertices;
+     }
+     
+     private List<Edge> offset(List<Edge> edges, double distance) {
+       List<Edge> contour = new LinkedList();
+       { 
+         List<Vertex> vertices = vertices(edges);
+         Vertex normal = Surface.normalOf(edges);
+         if (vertices.size() > 2) {
+           List<Vertex> result = offset(vertices, normal, distance);
+           Map<Vertex, Vertex> vmap = new HashMap();
+           for (int i = 0; i < vertices.size(); i++) {
+             Vertex original = vertices.get(i);
+             Vertex offset = result.get(i);
+             vmap.put(original, offset);
+           }
+           for (Edge current : edges) {
+             Vertex from = vmap.get(current.from);
+             Vertex to = vmap.get(current.to);
+             contour.add(new Edge(from, to));
+           }
+         }
+       }
+       return contour;
+     }
+     
+     /** {@inheritDoc} */
+     @Override
+     public void evaluate() {
+       double distance = parameters.getDouble("distance");
+       List<Edge> contour = offset(edges, distance);
+       Geometry.insertEdges(contour);
+     }
+   }
  }