public String verticesToString() { String result = "List of vertices\n"; Iterator it = this.vertices.iterator(); int cont = 0; while (it.hasNext()) { Vertex v = (Vertex) it.next(); result = result + "v" + cont + " " + v.getPoint().toString() + "\n"; cont++; } return result; }
/** * creates a new triangle facet within the hole incident to h by connecting the tip of h with two * new halfedges and a new vertex. Returns the halfedge of the new edge that is incident to the * new facet and the new vertex. */ public Halfedge<X> addTriangleToBorder(Halfedge h, X point) { if (h.face != null) throw new Error("no border edge"); System.out.println("adding triangle to " + h); Face<X> newFace = new Face<X>(); Vertex<X> newVertex = new Vertex<X>(point); Halfedge<X> hPrev = new Halfedge<X>(); Halfedge<X> hNext = new Halfedge<X>(); Halfedge<X> hPrevOpp = new Halfedge<X>(); Halfedge<X> hNextOpp = new Halfedge<X>(); // setting the new face newFace.setEdge(h); // setting hPrev (halfedge preceding h in the new face) hPrev.setFace(newFace); hPrev.setVertex(h.getOpposite().getVertex()); hPrev.setPrev(hNext); hPrev.setNext(h); hPrev.setOpposite(hPrevOpp); // setting hNext (halfedge following h in the new face) hNext.setFace(newFace); hNext.setVertex(newVertex); hNext.setPrev(h); hNext.setNext(hPrev); hNext.setOpposite(hNextOpp); // setting hPrevOpp (new boundary halfedge) hPrevOpp.setFace(null); hPrevOpp.setVertex(newVertex); hPrevOpp.setPrev(h.getPrev()); hPrevOpp.setNext(hNextOpp); hPrevOpp.setOpposite(hPrev); // setting hNextOpp (the other new boundary halfedge) hNextOpp.setFace(null); hNextOpp.setVertex(h.getVertex()); hNextOpp.setPrev(hPrevOpp); hNextOpp.setNext(h.getNext()); hNextOpp.setOpposite(hNext); // updating old boundary halfedge informations h.setFace(newFace); h.setPrev(hPrev); h.setNext(hNext); // setting newVertex newVertex.setEdge(hPrev); // LCA: a controler si c'est hPrev ou hNext // adding new facet, vertex and the four halfedges this.vertices.add(newVertex); this.facets.add(newFace); this.halfedges.add(hPrev); this.halfedges.add(hNext); this.halfedges.add(hPrevOpp); this.halfedges.add(hNextOpp); return hNext; }
public int vertexDegree(Vertex v) { int result = 0; Halfedge e = v.getHalfedge(); Halfedge pEdge = e.getNext().getOpposite(); while (pEdge != e) { pEdge = pEdge.getNext().getOpposite(); result++; } return result + 1; }
/** * a triangle with border edges is added to the polyhedral surface. Returns a non-border halfedge * of the triangle. */ public Halfedge<X> makeTriangle(X p1, X p2, X p3) { Face<X> newFace = new Face<X>(); Vertex<X> newVertex1 = new Vertex<X>(p1); Vertex<X> newVertex2 = new Vertex<X>(p2); Vertex<X> newVertex3 = new Vertex<X>(p3); Halfedge<X> e1 = new Halfedge<X>(); Halfedge<X> e2 = new Halfedge<X>(); Halfedge<X> e3 = new Halfedge<X>(); Halfedge<X> e1Opp = new Halfedge<X>(); Halfedge<X> e2Opp = new Halfedge<X>(); Halfedge<X> e3Opp = new Halfedge<X>(); // setting the new face newFace.setEdge(e1); // setting the new vertices (LCA: a' controler) newVertex1.setEdge(e2); newVertex2.setEdge(e3); newVertex3.setEdge(e1); // setting e1 e1.setFace(newFace); e1.setVertex(newVertex1); e1.setPrev(e3); e1.setNext(e2); e1.setOpposite(e1Opp); // setting e2 e2.setFace(newFace); e2.setVertex(newVertex2); e2.setPrev(e1); e2.setNext(e3); e2.setOpposite(e2Opp); // setting e3 e3.setFace(newFace); e3.setVertex(newVertex3); e3.setPrev(e2); e3.setNext(e1); e3.setOpposite(e3Opp); // setting e1Opp (boundary halfedge opposite to e1) e1Opp.setFace(null); e1Opp.setVertex(newVertex3); e1Opp.setPrev(e2Opp); e1Opp.setNext(e3Opp); e1Opp.setOpposite(e1); // setting e2Opp (boundary halfedge opposite to e2) e2Opp.setFace(null); e2Opp.setVertex(newVertex1); e2Opp.setPrev(e3Opp); e2Opp.setNext(e1Opp); e2Opp.setOpposite(e2); // setting e3Opp (boundary halfedge opposite to e3) e3Opp.setFace(null); e3Opp.setVertex(newVertex2); e3Opp.setPrev(e1Opp); e3Opp.setNext(e2Opp); e3Opp.setOpposite(e3); this.facets.add(newFace); this.vertices.add(newVertex1); this.vertices.add(newVertex2); this.vertices.add(newVertex3); this.halfedges.add(e1); this.halfedges.add(e1Opp); this.halfedges.add(e2); this.halfedges.add(e2Opp); this.halfedges.add(e3); this.halfedges.add(e3Opp); return e1; }
/** * returns true if the polyhedral surface is combinatorially consistent. If borders==true * normalization of the border edges is checked too. This method checks that each facet is at * least a triangle and that the two incident facets of a non-border edge are distinct. */ public boolean isValid(boolean borders) { boolean valid = true; System.out.print("Checking Polyhedron..."); int n = this.vertices.size(); int e = this.halfedges.size(); int f = this.facets.size(); for (int i = 0; i < this.halfedges.size(); i++) { Halfedge<X> pedge = this.halfedges.get(i); if (pedge.getOpposite() == null) { System.out.print("error opposite: " + i); valid = false; // Face face=pedge.getFace(); // int[] ind=face.getVertexIndices(this); // System.out.println(" "+ind[0]+" "+ind[1]+" "+ind[2]); } if (pedge.getNext() == null) { System.out.println("error next_edge: " + i); valid = false; } if (pedge.getPrev() == null) { System.out.println("error prev_edge: " + i); valid = false; } if (pedge.getVertex() == null) { System.out.println("error vertex: " + i); valid = false; } if (pedge.opposite != null && pedge.face == pedge.getOpposite().face) { System.out.println("error edge: " + i); valid = false; } } for (int i = 0; i < this.facets.size(); i++) { Face<X> pface = this.facets.get(i); if (pface == null) { System.out.println("error face pointer"); valid = false; } if (pface.halfedge == null) { System.out.println("error face.halfedge"); valid = false; } if (pface.degree() < 3) { System.out.println("error face degree"); return valid = false; } } for (int i = 0; i < this.vertices.size(); i++) { Vertex<X> pvertex = this.vertices.get(i); // System.out.println(""+pvertex.toString()); if (pvertex == null) { System.out.println("error vertex pointer:" + i); valid = false; } if (pvertex.halfedge == null) { System.out.println("error vertex.halfedge: " + i); valid = false; } if (pvertex.getPoint() == null) { System.out.println("error vertex.point: " + i); valid = false; } } if (valid == true) System.out.println("ok"); else System.out.println("not valid"); System.out.print("n: " + n + " e: " + e / 2 + " f: " + f + " - "); int g = -(n - e / 2 + f - 2) / 2; System.out.println("genus: " + g); return valid; }