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);
+ }
+ }
}
|
