[Bprocessor-commit] model/src/net/sourceforge/bprocessor/model Edge.java, 1.97, 1.98 Command.java, 1.16, 1.17 ParameterBlock.java, 1.13, 1.14

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

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

Modified Files:
	Edge.java Command.java ParameterBlock.java 
Log Message:
A smoothing operation is implemented on a collection of surfaces that are subdivided according to Catmull-clark rules

Index: Edge.java
===================================================================
RCS file: /cvsroot/bprocessor/model/src/net/sourceforge/bprocessor/model/Edge.java,v
retrieving revision 1.97
retrieving revision 1.98
diff -C2 -d -r1.97 -r1.98
*** Edge.java	5 Oct 2007 13:30:49 -0000	1.97
--- Edge.java	28 Oct 2007 22:45:37 -0000	1.98
***************
*** 45,48 ****
--- 45,51 ----
    private boolean strippled;
    
+   /** Is smooth */
+   private boolean smooth;
+   
    /**
     * Return the first vertex in a list of edges.
***************
*** 198,201 ****
--- 201,220 ----
      strippled = c;
    }
+   
+   /**
+    * Returns the smooth flag
+    * @return isSmooth
+    */
+   public boolean isSmooth() {
+     return smooth;
+   }
+   
+   /**
+    * Sets the smooth flag
+    * @param value new value of smooth
+    */
+   public void setSmooth(boolean value) {
+     smooth = value;
+   }
  
    /** {@inheritDoc} */
***************
*** 661,664 ****
--- 680,685 ----
        } else  if (a.getName().equals("Length")) {
          setLength(((Double)a.getValue()).doubleValue());
+       } else if (a.getName().equals("Smooth")) {
+         setSmooth(((Boolean)a.getValue()).booleanValue());
        }
      } 
***************
*** 673,676 ****
--- 694,698 ----
      res.add(new Attribute("Name", getName(), false));
      res.add(new Attribute("Owner", getOwner(), false));
+     res.add(new Attribute("Smooth", isSmooth(), true));
      res.add(new Attribute("Length", new Double(getLength())));
      return res;

Index: Command.java
===================================================================
RCS file: /cvsroot/bprocessor/model/src/net/sourceforge/bprocessor/model/Command.java,v
retrieving revision 1.16
retrieving revision 1.17
diff -C2 -d -r1.16 -r1.17
*** Command.java	26 Oct 2007 13:01:31 -0000	1.16
--- Command.java	28 Oct 2007 22:45:37 -0000	1.17
***************
*** 136,169 ****
    
    /**
!    * 
     */
!   public static class SmoothSpace extends Command {
!     private Map<Vertex, List<Edge>> vmap;
      
      /**
       * 
!      * @param space Space
       */
!     public SmoothSpace(Space space) {
!       parameters.put("space", space);
      }
      
!     /** {@inheritDoc} */
!     public String getGeneralName() {
!       return "Smooth";
      }
      
!     private Vertex common(Edge e1, Edge e2) {
!       if (e2.contains(e1.from)) {
!         return e1.from;
!       } else {
!         return e1.to;
!       }
      }
      
      
!     private Edge edge(Vertex v1, Vertex v2) {
!       List<Edge> l1 = vmap.get(v1);
!       List<Edge> l2 = vmap.get(v2);
        for (Edge current : l1) {
          if (current.otherVertex(v1) == v2) {
--- 136,283 ----
    
    /**
!    * Inverse makes it possible to navigate the
!    * Vertex-Edge-Surface relations in the
!    * reverse direction.
!    *
     */
!   public static class Inverse {
!     private Collection<Vertex> vertices;
!     private Collection<Edge> edges;
!     private Collection<Surface> surfaces;
!     private Map<Vertex, List<Edge>> v2e;
!     private Map<Edge, List<Surface>> e2s;
!     private Map<Vertex, List<Surface>> v2s;
      
      /**
+      * Constructs an Inverse object, which makes
+      * it possible to navigate geometry in reverse.
       * 
!      * @param surfaces Collection of surfaces
       */
!     public Inverse(List<Surface> surfaces) {
!       this.surfaces = surfaces;
!       edges = Surface.edges(surfaces);
!       vertices = Edge.vertices(edges);
!       
!       v2e = new HashMap();
!       e2s = new HashMap();
!       v2s = new HashMap();
!       
!       for (Vertex current : vertices) {
!         v2e.put(current, new LinkedList());
!       }
!       for (Edge current : edges) {
!         List<Edge> fl = v2e.get(current.from);
!         fl.add(current);
!         List<Edge> tl = v2e.get(current.to);
!         tl.add(current);
!         e2s.put(current, new LinkedList());
!       }
!       for (Surface current : surfaces) {
!         for (Edge edge : current.getEdges()) {
!           List<Surface> l = e2s.get(edge);
!           l.add(current);
!         }
!       }
!       for (Vertex current : vertices) {
!         Set<Surface> set = new HashSet();
!         List<Edge> l = v2e.get(current);
!         for (Edge edge : l) {
!           set.addAll(e2s.get(edge));
!         }
!         v2s.put(current, new LinkedList(set));
!       }
      }
      
!     /**
!      * Returns the vertices
!      * @return the vertices
!      */
!     public Collection<Vertex> vertices() {
!       return vertices;
      }
      
!     /**
!      * Returns the edges
!      * @return the edges
!      */
!     public Collection<Edge> edges() {
!       return edges;
      }
      
+     /**
+      * Returns the surfaces
+      * @return the surfaces
+      */
+     public Collection<Surface> surfaces() {
+       return surfaces;
+     }
      
!     /**
!      * Returns the edges connected to specified vertex
!      * @param vertex the vertex
!      * @return the edges
!      */
!     public List<Edge> edges(Vertex vertex) {
!       return v2e.get(vertex);
!     }
!     
!     /**
!      * Returns the surfaces connected to specified edge
!      * @param edge the edge
!      * @return the surfaces
!      */
!     public List<Surface> surfaces(Edge edge) {
!       return e2s.get(edge);
!     }
!     
!     /**
!      * Returns the surfaces connected to the specified
!      * vertex
!      * @param vertex the vertex
!      * @return the surfaces
!      */
!     public List<Surface> surfaces(Vertex vertex) {
!       return v2s.get(vertex);
!     }
!   }
!   
!   /**
!    * Builder for building geometry
!    *
!    */
!   public static class Builder {
!     private Map<Vertex, List<Edge>> v2e;
!    
!     /**
!      * Constructs the builder
!      * @param vertices collection of vertices
!      */
!     public Builder(List<Vertex> vertices) {
!       v2e = new HashMap();
!       for (Vertex current : vertices) {
!         v2e.put(current, new LinkedList());
!       }
!     }
! 
!     /**
!      * Returns the edges connected to specified vertex
!      * @param vertex the vertex
!      * @return the edges
!      */
!     public List<Edge> edges(Vertex vertex) {
!       return v2e.get(vertex);
!     }
!     
!     /**
!      * Creates a new edge or returns an existing edge
!      * between specified vertices
!      * @param v1 Vertex 1
!      * @param v2 Vertex 2
!      * @return An edge between two vertices
!      */
!     public Edge edge(Vertex v1, Vertex v2) {
!       List<Edge> l1 = v2e.get(v1);
!       List<Edge> l2 = v2e.get(v2);
        for (Edge current : l1) {
          if (current.otherVertex(v1) == v2) {
***************
*** 177,195 ****
      }
      
!     private Surface quad(Edge e1, Edge e2, Edge e3, Edge e4) {
!       List edges = new ArrayList();
!       edges.add(e1);
!       edges.add(e2);
!       edges.add(e3);
!       edges.add(e4);
!       return new Surface(edges);
      }
      
!     private Surface quad(Vertex v1, Vertex v2, Vertex v3, Vertex v4) {
!       Edge e1 = edge(v1, v2);
!       Edge e2 = edge(v2, v3);
!       Edge e3 = edge(v3, v4);
!       Edge e4 = edge(v4, v1);
!       return quad(e1, e2, e3, e4);
      }
      
--- 291,334 ----
      }
      
!     /**
!      * Creates a surface with the specified array of edges
!      * @param objects edges as arguments
!      * @return new surface
!      */
!     public Surface surface(Edge ...objects) {
!       List<Edge> lst = new LinkedList();
!       for (Edge object : objects) {
!         lst.add(object);
!       }
!       return new Surface(lst);
      }
+   }
+   
+   /**
+    * 
+    */
+   public static class SmoothSpace extends Command {
      
!     /**
!      * 
!      * @param space Space
!      */
!     public SmoothSpace(Space space) {
!       parameters.put("space", space);
!       parameters.putDouble("n", 2);
!       parameters.putBoolean("envelope", true);
!     }
!     
!     /** {@inheritDoc} */
!     public String getGeneralName() {
!       return "Subdivide";
!     }
!     
!     private Vertex common(Edge e1, Edge e2) {
!       if (e2.contains(e1.from)) {
!         return e1.from;
!       } else {
!         return e1.to;
!       }
      }
      
***************
*** 207,219 ****
      }
      
!     /** {@inheritDoc} */
!     @Override
!     public void evaluate() {
!       Space space = (Space) parameters.get("space");
!       System.out.println("smooth " + space);
        
!       List<Surface> faces = new ArrayList(space.getEnvelope());
!       List<Edge> edges = new ArrayList(Surface.edges(faces));
!       List<Vertex> vertices = new ArrayList(Edge.vertices(edges));
        
        Map<Surface, Vertex> facemap = new HashMap();
--- 346,356 ----
      }
      
!     
!     private List<Surface> subdivide(List<Surface> faces) {
        
!       Inverse inv = new Inverse(faces);
!       
!       List<Edge> edges = new ArrayList(inv.edges());
!       List<Vertex> vertices = new ArrayList(inv.vertices());
        
        Map<Surface, Vertex> facemap = new HashMap();
***************
*** 225,229 ****
        
        {
-         // Subdivision step
          
          for (Surface current : faces) {
--- 362,365 ----
***************
*** 242,258 ****
          }
  
-         
          points.addAll(facemap.values());
          points.addAll(edgemap.values());
          points.addAll(vertexmap.values());
  
!         // Initialize vmap for speeding
!         // up quad generation
!         
!         vmap = new HashMap();
!         for (Vertex current : points) {
!           vmap.put(current, new LinkedList());
!         }
!         
          for (Surface face : faces) {
            LinkedList<Edge> contour = new LinkedList(face.getEdges());
--- 378,389 ----
          }
  
          points.addAll(facemap.values());
          points.addAll(edgemap.values());
          points.addAll(vertexmap.values());
+       }
  
!       Builder builder = new Builder(points);
!       
!       {  
          for (Surface face : faces) {
            LinkedList<Edge> contour = new LinkedList(face.getEdges());
***************
*** 263,267 ****
              Vertex p1 = edgemap.get(previous);
              Vertex p2 = edgemap.get(current);
!             quads.add(quad(f, p1, v, p2));
              previous = current;
            }
--- 394,406 ----
              Vertex p1 = edgemap.get(previous);
              Vertex p2 = edgemap.get(current);
!             Edge e1 = builder.edge(f, p1);
!             e1.setSmooth(true);
!             Edge e2 = builder.edge(p1, v);
!             e2.setSmooth(previous.isSmooth());
!             Edge e3 = builder.edge(v, p2);
!             e3.setSmooth(current.isSmooth());
!             Edge e4 = builder.edge(p2, f);
!             e4.setSmooth(true);
!             quads.add(builder.surface(e1, e2, e3, e4));
              previous = current;
            }
***************
*** 270,349 ****
        
        {
-         // Averaging step
-         
-         Map<Vertex, List<Edge>> v2e = new HashMap();
-         Map<Edge, List<Surface>> e2s = new HashMap();
-         Map<Vertex, List<Surface>> v2s = new HashMap();
-         
-         for (Vertex current : vertices) {
-           v2e.put(current, new LinkedList());
-         }
          for (Edge current : edges) {
!           List<Edge> fl = v2e.get(current.from);
!           fl.add(current);
!           List<Edge> tl = v2e.get(current.to);
!           tl.add(current);
!           e2s.put(current, new LinkedList());
!         }
!         for (Surface current : faces) {
!           for (Edge edge : current.getEdges()) {
!             List<Surface> l = e2s.get(edge);
!             l.add(current);
!           }
!         }
!         for (Vertex current : vertices) {
!           Set<Surface> set = new HashSet();
!           List<Edge> l = v2e.get(current);
!           for (Edge edge : l) {
!             set.addAll(e2s.get(edge));
!           }
!           v2s.put(current, new LinkedList(set));
!         }
!         
!         
!         for (Edge current : edges) {
!           Vertex edgepoint = edgemap.get(current);
!           List<Edge> es = vmap.get(edgepoint);
!           List<Vertex> vs = new LinkedList();
!           for (Edge edge : es) {
!             vs.add(edge.otherVertex(edgepoint));
            }
-           edgepoint.set(average(vs));
          }
          
          for (Vertex current : vertices) {
!           List<Edge> es = v2e.get(current);
!           List<Surface> ss = v2s.get(current);
            int n = es.size();
!           List<Vertex> vs = new LinkedList();
            for (Edge edge : es) {
!             vs.add(edge.otherVertex(current));
!           }
!           List<Vertex> fs = new LinkedList();
!           for (Surface surface : ss) {
!             fs.add(facemap.get(surface));
            }
            
-           Vertex a1 = average(vs);
-           Vertex a2 = average(fs);
-           double x = ((n - 2) * current.x) / n + a1.x / n + a2.x / n;
-           double y = ((n - 2) * current.y) / n + a1.y / n + a2.y / n;
-           double z = ((n - 2) * current.z) / n + a1.z / n + a2.z / n;
-           
            Vertex vertexpoint = vertexmap.get(current);
!           vertexpoint.setX(x);
!           vertexpoint.setY(y);
!           vertexpoint.setZ(z);
          }
        }
        
        
!       for (Vertex current : points) {
!         space.add(current);
        }
        
!       for (Surface quad : quads) {
          for (Edge current : quad.getEdges()) {
!           space.add(current);
          }
          space.add(quad);
--- 409,508 ----
        
        {
          for (Edge current : edges) {
!           if (current.isSmooth()) {
!             Vertex edgepoint = edgemap.get(current);
!             List<Edge> es = builder.edges(edgepoint);
!             List<Vertex> vs = new LinkedList();
!             for (Edge edge : es) {
!               vs.add(edge.otherVertex(edgepoint));
!             }
!             edgepoint.set(average(vs));
            }
          }
          
          for (Vertex current : vertices) {
!           
!           List<Edge> es = inv.edges(current);
!           List<Surface> ss = inv.surfaces(current);
            int n = es.size();
!           
!           List<Edge> crease = new LinkedList();
!           
            for (Edge edge : es) {
!             if (!edge.isSmooth()) {
!               crease.add(edge);
!             }
            }
            
            Vertex vertexpoint = vertexmap.get(current);
!           
!           if (crease.size() < 2) {
!             List<Vertex> vs = new LinkedList();
!             for (Edge edge : es) {
!               vs.add(edge.otherVertex(current));
!             }
!             List<Vertex> fs = new LinkedList();
!             for (Surface surface : ss) {
!               fs.add(facemap.get(surface));
!             }
! 
!             Vertex a1 = average(vs);
!             Vertex a2 = average(fs);
!             double x = ((n - 2) * current.x) / n + a1.x / n + a2.x / n;
!             double y = ((n - 2) * current.y) / n + a1.y / n + a2.y / n;
!             double z = ((n - 2) * current.z) / n + a1.z / n + a2.z / n;
!             vertexpoint.setX(x);
!             vertexpoint.setY(y);
!             vertexpoint.setZ(z);
!           } else if (crease.size() == 2) {
!             double x = 6 * current.x;
!             double y = 6 * current.y;
!             double z = 6 * current.z;
!             for (Edge edge : crease) {
!               Vertex v = edge.otherVertex(current);
!               x += v.x;
!               y += v.y;
!               z += v.z;
!             }
!             vertexpoint.setX(x / 8);
!             vertexpoint.setY(y / 8);
!             vertexpoint.setZ(z / 8);
!           }
          }
        }
        
+       return quads;
+     }
+     
+     /** {@inheritDoc} */
+     @Override
+     public void evaluate() {
+       Space space = (Space) parameters.get("space");
+       int n = (int) parameters.getDouble("n");
+       boolean envelope = parameters.getBoolean("envelope");
        
!       List<Surface> faces;
!       if (envelope) {
!         faces = new ArrayList(space.getEnvelope());
!       } else {
!         faces = new ArrayList(space.getSurfaces());
!       }
!       for (int i = 0; i < n; i++) {
!         faces = subdivide(faces);
        }
        
!       space.clear();
!       
!       for (Surface quad : faces) {
          for (Edge current : quad.getEdges()) {
!           if (current.from.getOwner() == null) {
!             space.add(current.from);
!           }
!           if (current.to.getOwner() == null) {
!             space.add(current.to);
!           }
!           if (current.getOwner() == null) {
!             space.add(current);
!           }
          }
          space.add(quad);
***************
*** 380,384 ****
      public void evaluate() {
        Edge edge = (Edge) parameters.get("edge");
!       int n = parameters.getDouble("n").intValue();
        Vertex from = edge.from;
        Vertex to = edge.to;
--- 539,543 ----
      public void evaluate() {
        Edge edge = (Edge) parameters.get("edge");
!       int n = (int) parameters.getDouble("n");
        Vertex from = edge.from;
        Vertex to = edge.to;
***************
*** 422,426 ****
        double r = parameters.getDouble("radius");
        double h = parameters.getDouble("height");
!       int s = parameters.getDouble("slices").intValue();
        
        List<Edge> edges = new LinkedList<Edge>();
--- 581,585 ----
        double r = parameters.getDouble("radius");
        double h = parameters.getDouble("height");
!       int s = (int) parameters.getDouble("slices");
        
        List<Edge> edges = new LinkedList<Edge>();

Index: ParameterBlock.java
===================================================================
RCS file: /cvsroot/bprocessor/model/src/net/sourceforge/bprocessor/model/ParameterBlock.java,v
retrieving revision 1.13
retrieving revision 1.14
diff -C2 -d -r1.13 -r1.14
*** ParameterBlock.java	22 Oct 2007 15:21:18 -0000	1.13
--- ParameterBlock.java	28 Oct 2007 22:45:37 -0000	1.14
***************
*** 80,84 ****
     * @return double value
     */
!   public Double getDouble(String key) {
      for (Attribute current : parameters) {
        if (current.getName().equals(key)) {
--- 80,84 ----
     * @return double value
     */
!   public double getDouble(String key) {
      for (Attribute current : parameters) {
        if (current.getName().equals(key)) {
***************
*** 92,95 ****
--- 92,109 ----
     * 
     * @param key String
+    * @return boolean value
+    */
+   public boolean getBoolean(String key) {
+     for (Attribute current : parameters) {
+       if (current.getName().equals(key)) {
+         return ((Boolean)(current.getValue())).booleanValue();
+       }
+     }
+     return false;
+   }
+   
+   /**
+    * 
+    * @param key String
     * @param value Object
     */