[Bprocessor-commit] gl/src/net/sourceforge/bprocessor/gl/tool CatmullClarkActionListener.java,NONE,1

SourceForge Headquarters 225 Broadway Suite 1600 San Diego, CA 92101 +1 (858) 422-6466

Update of /cvsroot/bprocessor/gl/src/net/sourceforge/bprocessor/gl/tool
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv1777/src/net/sourceforge/bprocessor/gl/tool

Modified Files:
	ExtrusionTool.java SelectTool.java 
Added Files:
	CatmullClarkActionListener.java CatmullClark.java 
Log Message:
Catmull Clark subdivision

--- NEW FILE: CatmullClark.java ---
//---------------------------------------------------------------------------------
// $Id: CatmullClark.java,v 1.1 2005/11/28 22:24:51 henryml Exp $
//
// Copyright (c) 2005      The BProcessor Team (http://bprocessor.sourceforge.net) 
// Released under the Lesser GNU Public License v2.1
//---------------------------------------------------------------------------------

package net.sourceforge.bprocessor.gl.tool;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Set;

import net.sourceforge.bprocessor.model.Edge;
import net.sourceforge.bprocessor.model.Space;
import net.sourceforge.bprocessor.model.Modellor;
import net.sourceforge.bprocessor.model.Surface;
import net.sourceforge.bprocessor.model.Vertex;

/**
 * CatmullClark subdivision
 */
public class CatmullClark implements Modellor {

  /** The space */
  private Space space;

  /** The edge list */
  private HashMap edgelist;

  /** The face list */
  private HashMap facelist;

  /**
   * Construct!
   * @param space The Space
   */
  public CatmullClark(Space space) {
    super();
    this.space = space;
  }

  /**
   * Make a copy of the originals
   * @param originals The originals
   * @return The copy
   */
  private List copy(Set originals) {
    List surfaces = new ArrayList();
    HashMap edgemap = new HashMap();
    HashMap vertexmap = new HashMap();
    {
      Iterator oit = originals.iterator();
      while (oit.hasNext()) {
        Surface surface = (Surface) oit.next();
        Iterator vit = surface.getVertices().iterator();
        while (vit.hasNext()) {
          Vertex current = (Vertex) vit.next();
          Vertex vertex = current.copy();
          vertexmap.put(current, vertex);
        }
      }
    }
    {
      Iterator oit = originals.iterator();
      while (oit.hasNext()) {
        Surface surface = (Surface) oit.next();
        Iterator vit = surface.getEdges().iterator();
        while (vit.hasNext()) {
          Edge current = (Edge) vit.next();
          Vertex from = (Vertex) vertexmap.get(current.getFrom());
          Vertex to = (Vertex) vertexmap.get(current.getTo());
          Edge edge = new Edge("", from, to);
          edgemap.put(current, edge);
        }
      }
    }
    {
      Iterator oit = originals.iterator();
      while (oit.hasNext()) {
        Surface surface = (Surface) oit.next();
        List edges = new ArrayList();
        Iterator vit = surface.getEdges().iterator();
        while (vit.hasNext()) {
          Edge current = (Edge) vit.next();
          Edge edge = (Edge) edgemap.get(current);
          edges.add(edge);
        }
        surfaces.add(new Surface("", edges));
      }
    }
    return surfaces;
  }

  /**
   * Find a common vertex
   * @param e1 Edge 1
   * @param e2 Edge 2
   * @return A common vertex
   */
  public Vertex common(Edge e1, Edge e2) {
    if (e2.contains(e1.getFrom())) {
      return e1.getFrom();
    } else {
      return e1.getTo();
    }
  }

  /**
   * Init edgelist
   * @param v The vertex
   * @return The new edgelist
   */
  public List edgelistInit(Vertex v) {
    List edges = new LinkedList();
    edgelist.put(v, edges);
    return edges;
  }
  /**
   * Get edgelist
   * @param v The vertex
   * @return The edgelist
   */
  public List edgelistGet(Vertex v) {
    List edges = (List) edgelist.get(v);
    if (edges == null) {
      edges = edgelistInit(v);
    }
    return edges;
  }
  /**
   * Insert edge in edgelist
   * @param v The Vertex
   * @param e The edge
   */
  public void edgelistInsert(Vertex v, Edge e) {
    List edges = edgelistGet(v);
    edges.add(e);
  }

  /**
   * Init facelist
   * @param v The Vertex
   * @return The new facelist
   */
  public List facelistInit(Vertex v) {
    List faces = new LinkedList();
    facelist.put(v, faces);
    return faces;
  }
  /**
   * Get facelist
   * @param v The vertex
   * @return The facelist
   */
  public List facelistGet(Vertex v) {
    List faces = (List) facelist.get(v);
    if (faces == null) {
      faces = facelistInit(v);
    }
    return faces;
  }
  /**
   * Insert in facelist
   * @param v The vertex
   * @param e The face
   */
  public void facelistInsert(Vertex v, Surface e) {
    List faces = facelistGet(v);
    faces.add(e);
  }

  /**
   * Create edge
   * @param from From
   * @param to To
   * @return Edge
   */
  public Edge edge(Vertex from, Vertex to) {
    List fl = edgelistGet(from);
    List tl = edgelistGet(to);
    Iterator iter = fl.iterator();
    Edge edge = null;
    while (iter.hasNext()) {
      Edge current = (Edge) iter.next();
      if (current.otherVertex(from) == to) {
        edge = current;
        break;
      }
    }
    if (edge == null) {
      edge = new Edge("", from, to);
      fl.add(edge);
      tl.add(edge);
    }
    return edge;
  }

  /**
   * Create quad
   * @param e1 E1
   * @param e2 E2
   * @param e3 E3
   * @param e4 E4
   * @return Quad
   */
  public 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);
  }

  /**
   * Create a quad
   * @param v1 V1
   * @param v2 V2
   * @param v3 V3
   * @param v4 V4
   * @return Quad
   */
  public 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);
  }

  /**
   * Calculate the average of points
   * @param pts The points
   * @return The average
   */
  public double[] average(List pts) {
    double[] values = new double[]{0, 0, 0};
    Iterator iter = pts.iterator();
    while (iter.hasNext()) {
      Vertex current = (Vertex) iter.next();
      values[0] += current.getX();
      values[1] += current.getY();
      values[2] += current.getZ();
    }
    values[0] /= (double) pts.size();
    values[1] /= (double) pts.size();
    values[2] /= (double) pts.size();
    return values;
  }

  /**
   * Generate the faces
   * @return the faces
   */
  public List generate() {
    List faces = copy(space.getSurfaces());
    return catmullclark(catmullclark(catmullclark(faces)));
  }

  /**
   * Run catmullclark subdivsion on faces
   * @param faces The faces to subdivide
   * @return The subdivided mesh
   */
  public List catmullclark(List faces) {
    edgelist = new HashMap();
    facelist = new HashMap();
    List surfaces = new ArrayList();
    HashSet edges = new HashSet();
    HashSet vertices = new HashSet();
    List edgepoints = new LinkedList();
    HashMap facemap = new HashMap();
    HashMap edgemap = new HashMap();
    {
      Iterator iter = faces.iterator();
      while (iter.hasNext()) {
        Surface current = (Surface) iter.next();
        facemap.put(current, current.center());
        edges.addAll(current.getEdges());
        Iterator vit = current.getVertices().iterator();
        vit.next();
        while (vit.hasNext()) {
          Vertex v = (Vertex) vit.next();
          facelistInsert(v, current);
          vertices.add(v);
        }
      }
    }
    {
      Iterator iter = edges.iterator();
      while (iter.hasNext()) {
        Edge current = (Edge) iter.next();
        double[] values = current.center();
        Vertex center = new Vertex("", values[0], values[1], values[2]);
        edgepoints.add(center);
        edgemap.put(current, center);
      }
    }
    {
      Iterator iter = faces.iterator();
      while (iter.hasNext()) {
        Surface current = (Surface) iter.next();
        Iterator eit = current.getEdges().iterator();
        Edge top = (Edge) eit.next();
        Edge right = (Edge) eit.next();
        Edge bottom = (Edge) eit.next();
        Edge left = (Edge) eit.next();
        Vertex topm = (Vertex) edgemap.get(top);
        Vertex rightm = (Vertex) edgemap.get(right);
        Vertex bottomm = (Vertex) edgemap.get(bottom);
        Vertex leftm = (Vertex) edgemap.get(left);
        Vertex topleft = common(top, left);
        Vertex topright = common(top, right);
        Vertex bottomleft = common(bottom, left);
        Vertex bottomright = common(bottom, right);
        Vertex m = (Vertex) facemap.get(current);
        Surface q1 = quad(topleft, topm, m, leftm);
        Surface q2 = quad(topm, topright, rightm, m);
        Surface q3 = quad(rightm, bottomright, bottomm, m);
        Surface q4 = quad(bottomm, bottomleft, leftm, m);
        surfaces.add(q1);
        surfaces.add(q2);
        surfaces.add(q3);
        surfaces.add(q4);
      }
    }
    {
      Iterator iter = edgepoints.iterator();
      while (iter.hasNext()) {
        Vertex v = (Vertex) iter.next();
        List adjacent = edgelistGet(v);
        List pts = new LinkedList();
        Iterator eit = adjacent.iterator();
        while (eit.hasNext()) {
          Edge edge = (Edge) eit.next();
          pts.add(edge.otherVertex(v));
        }
        double[] values = average(pts);
        v.setX(values[0]);
        v.setY(values[1]);
        v.setZ(values[2]);
      }
    }
    {
      Iterator iter = vertices.iterator();
      while (iter.hasNext()) {
        Vertex v = (Vertex) iter.next();
        List es = edgelistGet(v);
        double n = es.size();
        List adjacent = facelistGet(v);
        List pts = new LinkedList();
        Iterator sit = adjacent.iterator();
        while (sit.hasNext()) {
          pts.add(facemap.get(sit.next()));
        }
        double[] q = average(pts);

        double[] r = new double[]{0, 0, 0};
        Iterator eit = es.iterator();
        while (eit.hasNext()) {
          Edge edge = (Edge) eit.next();
          double[] c = edge.center();
          r[0] += c[0];
          r[1] += c[1];
          r[2] += c[2];
        }

        r[0] /= n;
        r[1] /= n;
        r[2] /= n;

        double[] p = new double[3];
        p[0] = v.getX();
        p[1] = v.getY();
        p[2] = v.getZ();

        double[] values = new double[3];
        values[0] = q[0] / n + 2 * r[0] / n + (n - 3) * p[0] / n;
        values[1] = q[1] / n + 2 * r[1] / n + (n - 3) * p[1] / n;
        values[2] = q[2] / n + 2 * r[2] / n + (n - 3) * p[2] / n;

        v.setX(values[0]);
        v.setY(values[1]);
        v.setZ(values[2]);

      }
    }
    return surfaces;
  }

}

Index: SelectTool.java
===================================================================
RCS file: /cvsroot/bprocessor/gl/src/net/sourceforge/bprocessor/gl/tool/SelectTool.java,v
retrieving revision 1.43
retrieving revision 1.44
diff -C2 -d -r1.43 -r1.44
*** SelectTool.java	20 Nov 2005 19:33:52 -0000	1.43
--- SelectTool.java	28 Nov 2005 22:24:50 -0000	1.44
***************
*** 80,84 ****
     * @param e The MouseEvent object
     */
!   protected void pressed(MouseEvent e) {    
      if (e.getButton() == MouseEvent.BUTTON1) {
        if (e.getClickCount() >= 2 && target instanceof Surface) {
--- 80,94 ----
     * @param e The MouseEvent object
     */
!   protected void pressed(MouseEvent e) {   
!     
!     if (e.getButton() == MouseEvent.BUTTON3) {
!       findTarget(e);
!       if (target != null) {
!         if (target instanceof String) {
!           JPopupMenu toolsmenu = toolsmenu((String) target);
!           glv.popup(toolsmenu, e.getX(), e.getY());
!         }
!       }
!     }
      if (e.getButton() == MouseEvent.BUTTON1) {
        if (e.getClickCount() >= 2 && target instanceof Surface) {
***************
*** 260,263 ****
--- 270,307 ----

    /**
+    * Create the toolsmenu
+    * @param name Space name
+    * @return The toolsmenu
+    */
+   private JPopupMenu toolsmenu(String name) {
+     JPopupMenu menu = new JPopupMenu("Tools");
+     Space space = null;
+     Surface surface = null;
+     Iterator iter = selection.iterator();
+     while (iter.hasNext()) {
+       Object current = iter.next();
+       if (current instanceof Surface) {
+         surface = (Surface) current;
+         break;
+       }
+     }
+     if (surface != null) {
+       if (name.equals("back")) {
+         space = (Space) surface.getBackDomain(); 
+       }
+       if (name.equals("front")) {
+         space = (Space) surface.getFrontDomain();
+       }
+     }
+     if (space != null) {
+       ActionListener listener = new CatmullClarkActionListener(space);
+       JMenuItem catmullClarkItem = new JMenuItem("Catmull-Clark");
+       catmullClarkItem.addActionListener(listener);
+       menu.add(catmullClarkItem);
+     }
+     return menu;
+   }
+   
+   /**
     * Sends the notification for select
     * @param obj The selected object

--- NEW FILE: CatmullClarkActionListener.java ---
//---------------------------------------------------------------------------------
// $Id: CatmullClarkActionListener.java,v 1.1 2005/11/28 22:24:50 henryml Exp $
//
// Copyright (c) 2005      The BProcessor Team (http://bprocessor.sourceforge.net) 
// Released under the Lesser GNU Public License v2.1
//---------------------------------------------------------------------------------

package net.sourceforge.bprocessor.gl.tool;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import net.sourceforge.bprocessor.model.Space;

/**
 * First version of implementation of Catmull-Clark scheme.
 * Does not handle boundary cases.
 */
public class CatmullClarkActionListener implements ActionListener {  
  /** The space */
  private Space space;

  /**
   * Construct
   * @param space The space
   */
  public CatmullClarkActionListener(Space space) {
    super();
    this.space = space;
  }

  /**
   * Perform action
   * @param event The ActionEvent
   */
  public void actionPerformed(ActionEvent event) {
    space.setModellor(new CatmullClark(space));
  }

}

Index: ExtrusionTool.java
===================================================================
RCS file: /cvsroot/bprocessor/gl/src/net/sourceforge/bprocessor/gl/tool/ExtrusionTool.java,v
retrieving revision 1.31
retrieving revision 1.32
diff -C2 -d -r1.31 -r1.32
*** ExtrusionTool.java	23 Nov 2005 16:51:56 -0000	1.31
--- ExtrusionTool.java	28 Nov 2005 22:24:50 -0000	1.32
***************
*** 153,157 ****
          while (vertIt.hasNext() && inSide) {
            Vertex vert = (Vertex)vertIt.next();
!           inSide = surface.surrounds(vert, 1);
          }
        }
--- 153,157 ----
          while (vertIt.hasNext() && inSide) {
            Vertex vert = (Vertex)vertIt.next();
!           inSide = surface.surrounds(vert, 1.0);
          }
        }

[Bprocessor-commit] gl/src/net/sourceforge/bprocessor/gl/tool CatmullClarkActionListener.java,NONE,1

[Bprocessor-commit] gl/src/net/sourceforge/bprocessor/gl/tool CatmullClarkActionListener.java,NONE,1.1 CatmullClark.java,NONE,1.1 ExtrusionTool.java,1.31,1.32 SelectTool.java,1.43,1.44