[Bprocessor-commit] gl/src/net/sourceforge/bprocessor/gl/view PopupMenu.java, 1.53, 1.54
Status: Pre-Alpha
Brought to you by:
henryml
Menu
▾
▴
[Bprocessor-commit] gl/src/net/sourceforge/bprocessor/gl/view PopupMenu.java, 1.53, 1.54
|
From: Sebastian G. <sg...@us...> - 2011-09-18 16:37:10
|
Update of /cvsroot/bprocessor/gl/src/net/sourceforge/bprocessor/gl/view
In directory vz-cvs-4.sog:/tmp/cvs-serv23979/src/net/sourceforge/bprocessor/gl/view
Modified Files:
PopupMenu.java
Log Message:
subdivion algorithms added to context menus
Index: PopupMenu.java
===================================================================
RCS file: /cvsroot/bprocessor/gl/src/net/sourceforge/bprocessor/gl/view/PopupMenu.java,v
retrieving revision 1.53
retrieving revision 1.54
diff -C2 -d -r1.53 -r1.54
*** PopupMenu.java 27 Jul 2011 07:19:32 -0000 1.53
--- PopupMenu.java 18 Sep 2011 16:37:08 -0000 1.54
***************
*** 61,64 ****
--- 61,66 ----
import org.apache.log4j.Logger;
+ import com.sun.xml.internal.bind.v2.runtime.unmarshaller.XsiNilLoader.Array;
+
/**
* The static popup menu generator
***************
*** 104,107 ****
--- 106,110 ----
};
menu.add(holeanalysis);
+ /*
AbstractAction flip = new EntityMenuAction(s, "Flip") {
public void actionPerformed(ActionEvent arg0) {
***************
*** 111,115 ****
};
menu.add(flip);
!
{
AbstractAction action = new EntityMenuAction(s, "Assign from Neighbours") {
--- 114,118 ----
};
menu.add(flip);
! */
{
AbstractAction action = new EntityMenuAction(s, "Assign from Neighbours") {
***************
*** 526,529 ****
--- 529,977 ----
menu.add(delete);
{
+ AbstractAction flip = new GeometricMenuAction(arguments, "flip normals") {
+ public void actionPerformed(ActionEvent arg0) {
+ //Selection.primary().clear();
+ for (Geometric current : entities) {
+ if (current instanceof Surface) {
+ Surface surface = (Surface) current;
+ surface.flip();
+ }
+ }
+ }
+ };
+ menu.add(flip);
+ }
+
+ {
+ AbstractAction makeCorner = new GeometricMenuAction(arguments, "create corner points") {
+ public void actionPerformed(ActionEvent arg0) {
+ //Selection.primary().clear();
+ for (Geometric current : entities) {
+ if (current instanceof Vertex) {
+ Vertex v = (Vertex) current;
+ v.setCorner(true);
+ }
+ if (current instanceof Edge) {
+ Edge e = (Edge) current;
+ e.getFrom().setCorner(true);
+ e.getTo().setCorner(true);
+ }
+ if (current instanceof Surface) {
+ Surface s = (Surface) current;
+ Collection<Edge> edges = s.getEdges();
+ for (Edge e : edges) {
+ e.getFrom().setCorner(true);
+ e.getTo().setCorner(true);
+ }
+ }
+ }
+ }
+ };
+ menu.add(makeCorner);
+ }
+
+ {
+ AbstractAction deleteCorner = new GeometricMenuAction(arguments, "remove corner points") {
+ public void actionPerformed(ActionEvent arg0) {
+ //Selection.primary().clear();
+ for (Geometric current : entities) {
+ if (current instanceof Vertex) {
+ Vertex v = (Vertex) current;
+ v.setCorner(false);
+ }
+ if (current instanceof Edge) {
+ Edge e = (Edge) current;
+ e.getFrom().setCorner(false);
+ e.getTo().setCorner(false);
+ }
+ if (current instanceof Surface) {
+ Surface s = (Surface) current;
+ Collection<Edge> edges = s.getEdges();
+ for (Edge e : edges) {
+ e.getFrom().setCorner(false);
+ e.getTo().setCorner(false);
+ }
+ }
+ }
+ }
+ };
+ menu.add(deleteCorner);
+ }
+
+ {
+ AbstractAction quadDivide = new GeometricMenuAction(arguments, "Subdivision Constant Quads") {
+ Space owner;
+ public void actionPerformed(ActionEvent arg0) {
+
+ Selection.primary().clear();
+ ArrayList<Surface> newSurfaces = new ArrayList();
+
+ ArrayList<Edge> newEdges = new ArrayList();
+
+ for (Geometric current : entities) {
+ if (current instanceof Surface) {
+ Surface surface = (Surface) current;
+ owner = surface.getOwner();
+ Vertex sNormal = surface.normal();
+ Collection<Edge> sEdges = surface.getEdges();
+ //save surface center
+ Vertex sCenter = surface.center();
+
+ //convert Collection into List for easier looping and reference
+ List<Edge> lEdges = new ArrayList<Edge>();
+ for (Iterator edgeIt = sEdges.iterator(); edgeIt.hasNext();) {
+ Edge lE = (Edge) edgeIt.next();
+ lEdges.add(lE);
+ }
+ Edge previous = (Edge) lEdges.get(lEdges.size()-1);
+
+ for (Edge sE : lEdges) {
+ List <Edge> nEdges = new ArrayList<Edge>();
+ Vertex eCenter = sE.center();
+ Vertex pCenter = previous.center();
+
+ Vertex corner;
+ //find relevant corner point sharing current and previous edge
+ if (sE.getFrom().coincides(previous.getFrom())) {
+ corner = sE.getFrom();
+ } else if (sE.getFrom().coincides(previous.getTo())) {
+ corner = sE.getFrom();
+ } else if (sE.getTo().coincides(previous.getFrom())) {
+ corner = sE.getTo();
+ } else {
+ corner = sE.getTo();
+ }
+
+ //add new Edges
+ Edge nE = new Edge(eCenter,sCenter);
+ nEdges.add(nE.copy());
+
+ nE = new Edge(sCenter,pCenter);
+ nEdges.add(nE.copy());
+
+ nE = new Edge(pCenter,corner);
+ nEdges.add(nE.copy());
+
+ nE = new Edge(corner, eCenter);
+ nEdges.add(nE.copy());
+
+ //if current corner point is a corner (fix point) then make sure this property is kept in new surface
+ if (corner.isCorner()) {
+ for (Edge e : nEdges) {
+ if (e.getFrom().coincides(corner)) {
+ e.getFrom().setCorner(true);
+ }
+ if (e.getTo().coincides(corner)) {
+ e.getTo().setCorner(true);
+ }
+ }
+ }
+
+ //create new surface
+ Surface nS = new Surface(nEdges);
+ newSurfaces.add(nS);
+
+ //save current edge as the previous one for next iteration
+ previous = sE;
+ }
+ current.erase();
+ //Project.getInstance().changed();
+ }
+
+ }
+ //Project.getInstance().changed(Geometric.collect(entities));
+ Project.getInstance().checkpoint();
+ //now add all the new surfaces to the original geometry
+
+ for (Surface s : newSurfaces) {
+ owner.insertAll(s);
+ //owner.addAll(s);
+ owner.update();
+ Project.getInstance().changed();
+ }
+ }
+ };
+ menu.add(quadDivide);
+ }
+
+ {
+ AbstractAction SiepinskiDivide = new GeometricMenuAction(arguments, "Subdivision Sierpinski") {
+ Space owner;
+ public void actionPerformed(ActionEvent arg0) {
+
+ Selection.primary().clear();
+ ArrayList<Surface> newSurfaces = new ArrayList();
+
+ ArrayList<Edge> newEdges = new ArrayList();
+
+ for (Geometric current : entities) {
+ if (current instanceof Surface) {
+ Surface surface = (Surface) current;
+ owner = surface.getOwner();
+ Vertex sNormal = surface.normal();
+ Collection<Edge> sEdges = surface.getEdges();
+
+ //convert Collection into List for easier looping and reference
+ List<Edge> lEdges = new ArrayList<Edge>();
+ for (Iterator edgeIt = sEdges.iterator(); edgeIt.hasNext();) {
+ Edge lE = (Edge) edgeIt.next();
+ lEdges.add(lE);
+ }
+ Edge previous = (Edge) lEdges.get(lEdges.size()-1);
+
+ ArrayList<Vertex> centerPoints = new ArrayList();
+
+ for (Edge sE : lEdges) {
+ List <Edge> nEdges = new ArrayList<Edge>();
+ Vertex eCenter = sE.center();
+ Vertex pCenter = previous.center();
+
+ //save centerPoint of current Edge
+ centerPoints.add(eCenter.copy());
+
+ Vertex corner;
+ //find relevant corner point sharing current and previous edge
+ if (sE.getFrom().coincides(previous.getFrom())) {
+ corner = sE.getFrom();
+ } else if (sE.getFrom().coincides(previous.getTo())) {
+ corner = sE.getFrom();
+ } else if (sE.getTo().coincides(previous.getFrom())) {
+ corner = sE.getTo();
+ } else {
+ corner = sE.getTo();
+ }
+
+ //add new Edges
+ Edge nE = new Edge(eCenter,pCenter);
+ nEdges.add(nE.copy());
+
+ nE = new Edge(pCenter,corner);
+ nEdges.add(nE.copy());
+
+ nE = new Edge(corner, eCenter);
+ nEdges.add(nE.copy());
+
+ //if current corner point is a corner (fix point) then make sure this property is kept in new surface
+ if (corner.isCorner()) {
+ for (Edge e : nEdges) {
+ if (e.getFrom().coincides(corner)) {
+ e.getFrom().setCorner(true);
+ }
+ if (e.getTo().coincides(corner)) {
+ e.getTo().setCorner(true);
+ }
+ }
+ }
+
+ //create new surface
+ Surface nS = new Surface(nEdges);
+ newSurfaces.add(nS);
+
+ //save current edge as the previous one for next iteration
+ previous = sE;
+ }
+ current.erase();
+ //Project.getInstance().changed();
+
+ //create center polygon
+ Vertex pVertex = centerPoints.get(centerPoints.size()-1).copy();
+ List <Edge> nEdges = new ArrayList<Edge>();
+ for (Vertex v : centerPoints) {
+ Edge nE = new Edge(pVertex,v);
+ nEdges.add(nE.copy());
+ pVertex = v.copy();
+ }
+ Surface nS = new Surface(nEdges);
+ newSurfaces.add(nS);
+ }
+
+ }
+ //Project.getInstance().changed(Geometric.collect(entities));
+ Project.getInstance().checkpoint();
+ //now add all the new surfaces to the original geometry
+
+ for (Surface s : newSurfaces) {
+ owner.insertAll(s);
+ //owner.addAll(s);
+ owner.update();
+ Project.getInstance().changed();
+ }
+ }
+ };
+ menu.add(SiepinskiDivide);
+ }
+
+
+
+ //NOT YET WORKING, WHY???
+ /*
+
+ {
+ AbstractAction catmullClark = new GeometricMenuAction(arguments, "Subdivision CatmullClark") {
+ //http://en.wikipedia.org/wiki/Catmull%E2%80%93Clark_subdivision_surface
+ Space owner;
+
+ public Vertex CatmullClarkEdgeAverage(Edge e) {
+ Collection<Surface> cSurfaces = e.getSurfaces();
+ List<Vertex> cVertices = new ArrayList<Vertex>();
+ cVertices.add(e.getTo().copy());
+ cVertices.add(e.getFrom().copy());
+ for (Surface s : cSurfaces) {
+ cVertices.add(s.center().copy());
+ }
+ Vertex eCenter = new Vertex(0,0,0);
+ for (Vertex v : cVertices) {
+ eCenter=eCenter.add(v);
+ }
+ eCenter=eCenter.scale(1/cVertices.size());
+ return eCenter;
+ }
+
+ public Vertex CatMullClarkAverageFacePoints(Vertex p) {
+ Vertex f = new Vertex(0,0,0);
+ Collection<Surface> fSurfaces= p.getSurfaces();
+ if (fSurfaces.size()>0) {
+ for (Surface s : fSurfaces) {
+ f=f.add(s.center());
+ }
+ f=f.scale(1/fSurfaces.size());
+ } else {
+ f = p.copy();
+ }
+ return f;
+ }
+
+ public Vertex CatMullClarkAverageEdgePoints(Vertex p) {
+ Vertex r = new Vertex(0,0,0);
+ Collection<Edge> pEdges= p.getEdges();
+ if (pEdges.size()>0) {
+ for (Edge e : pEdges) {
+ r.add(e.center());
+ }
+ r.scale(1/pEdges.size());
+ } else {
+ r = p.copy();
+ }
+ return r;
+ }
+
+ public void actionPerformed(ActionEvent arg0) {
+
+ Selection.primary().clear();
+ ArrayList<Surface> newSurfaces = new ArrayList();
+ ArrayList<Surface> oldSurfaces = new ArrayList();
+ ArrayList<Edge> newEdges = new ArrayList();
+
+ for (Geometric current : entities) {
+ if (current instanceof Surface) {
+ Surface surface = (Surface) current;
+ owner = surface.getOwner();
+ Vertex sNormal = surface.normal();
+ Collection<Edge> sEdges = surface.getEdges();
+ //save surface center
+ Vertex sCenter = surface.center().copy();
+
+ //convert Collection into List for easier looping and reference
+ List<Edge> lEdges = new ArrayList<Edge>();
+ for (Iterator edgeIt = sEdges.iterator(); edgeIt.hasNext();) {
+ Edge lE = (Edge) edgeIt.next();
+ lEdges.add(lE);
+ }
+ Edge previous = (Edge) lEdges.get(lEdges.size()-1);
+
+ for (Edge sE : lEdges) {
+ List <Edge> nEdges = new ArrayList<Edge>();
+
+ //Edge Points = average of edges endpoints and facing surface centroids
+
+ Vertex eCenter = CatmullClarkEdgeAverage(sE);
+ Vertex pCenter = CatmullClarkEdgeAverage(previous);
+
+ //find relevant corner point sharing current and previous edge
+ Vertex corner;
+
+ if (sE.getFrom().coincides(previous.getFrom())) {
+ corner = sE.getFrom();
+ } else if (sE.getFrom().coincides(previous.getTo())) {
+ corner = sE.getFrom();
+ } else if (sE.getTo().coincides(previous.getFrom())) {
+ corner = sE.getTo();
+ } else {
+ corner = sE.getTo();
+ }
+
+ //move corner point
+ Vertex f = CatMullClarkAverageFacePoints(corner);
+ Vertex r = CatMullClarkAverageEdgePoints(corner);
+
+ double n = corner.getSurfaces().size();
+ Vertex p = corner.copy();
+ r=r.scale(2);
+ p=p.scale(n-3);
+ corner = f.copy();
+ corner=corner.add(r);
+ corner=corner.add(p);
+ corner=corner.scale(1/n);
+
+ //add new Edges
+ Edge nE = new Edge(eCenter,sCenter);
+ nEdges.add(nE.copy());
+
+ nE = new Edge(sCenter,pCenter);
+ nEdges.add(nE.copy());
+
+ nE = new Edge(pCenter,corner);
+ nEdges.add(nE.copy());
+
+ nE = new Edge(corner, eCenter);
+ nEdges.add(nE.copy());
+
+ //if current corner point is a corner (fix point) then make sure this property is kept in new surface
+ if (corner.isCorner()) {
+ for (Edge e : nEdges) {
+ if (e.getFrom().coincides(corner)) {
+ e.getFrom().setCorner(true);
+ }
+ if (e.getTo().coincides(corner)) {
+ e.getTo().setCorner(true);
+ }
+ }
+ }
+
+ //create new surface
+ Surface nS = new Surface(nEdges);
+ newSurfaces.add(nS);
+
+ //save current edge as the previous one for next iteration
+ previous = sE;
+ }
+ oldSurfaces.add((Surface)current);
+ //current.erase();
+ //Project.getInstance().changed();
+ }
+
+ }
+
+ for (Surface s : oldSurfaces) {
+ s.erase();
+ Project.getInstance().changed();
+ }
+ //Project.getInstance().changed(Geometric.collect(entities));
+ Project.getInstance().checkpoint();
+ //now add all the new surfaces to the original geometry
+
+ for (Surface s : newSurfaces) {
+ owner.insertAll(s);
+ //owner.addAll(s);
+ owner.update();
+ Project.getInstance().changed();
+ }
+ }
+ };
+ menu.add(catmullClark);
+ }
+ */
+
+ {
AbstractAction action = new GeometricMenuAction(arguments, "Make Union") {
public void actionPerformed(ActionEvent event) {
|
