public point3d[] getVertices() { point3d[] vtxs = new point3d[numVertices]; for (int i = 0; i < numVertices; i++) { vtxs[i] = pointBuffer[vertexPointIndices[i]].pnt; } return(vtxs); }
public int getVertices(double[] coords) { for (int i = 0; i < numVertices; i++) { point3d pnt = pointBuffer[vertexPointIndices[i]].pnt; coords[i * 3 + 0] = pnt.x; coords[i * 3 + 1] = pnt.y; coords[i * 3 + 2] = pnt.z; } return(numVertices); }
public void computeCentroid(point3d centroid) { centroid.setZero(); HalfEdge he = he0; do { centroid.add(he.head().pnt); he = he.next; }while (he != he0); centroid.scale(1 / (double)numVerts); }
private void calculateHorizon(point3d eyePnt, HalfEdge edge0, Face face, List <HalfEdge> horizon) { // oldFaces.add (face); deleteFacePoints(face, null); face.mark = Face.DELETED; if (debug) { Print(" visiting face " + face.getVertexString()); } HalfEdge edge; if (edge0 == null) { edge0 = face.getEdge(0); edge = edge0; } else { edge = edge0.getNext(); } do { Face oppFace = edge.oppositeFace(); if (oppFace.mark == Face.VISIBLE) { if (oppFace.distanceToPlane(eyePnt) > tolerance) { calculateHorizon(eyePnt, edge.getOpposite(), oppFace, horizon); } else { horizon.Add(edge); if (debug) { Print(" adding horizon edge " + edge.getVertexString()); } } } edge = edge.getNext(); }while (edge != edge0); }
private double areaSquared(HalfEdge hedge0, HalfEdge hedge1) { point3d p0 = hedge0.tail().pnt; point3d p1 = hedge0.head().pnt; point3d p2 = hedge1.head().pnt; double dx1 = p1.x - p0.x; double dy1 = p1.y - p0.y; double dz1 = p1.z - p0.z; double dx2 = p2.x - p0.x; double dy2 = p2.y - p0.y; double dz2 = p2.z - p0.z; double x = dy1 * dz2 - dz1 * dy2; double y = dz1 * dx2 - dx1 * dz2; double z = dx1 * dy2 - dy1 * dx2; return(x * x + y * y + z * z); }
public void computeNormal(vector3d normal) { HalfEdge he1 = he0.next; HalfEdge he2 = he1.next; point3d p0 = he0.head().pnt; point3d p2 = he1.head().pnt; double d2x = p2.x - p0.x; double d2y = p2.y - p0.y; double d2z = p2.z - p0.z; normal.setZero(); numVerts = 2; while (he2 != he0) { double d1x = d2x; double d1y = d2y; double d1z = d2z; p2 = he2.head().pnt; d2x = p2.x - p0.x; d2y = p2.y - p0.y; d2z = p2.z - p0.z; normal.x += d1y * d2z - d1z * d2y; normal.y += d1z * d2x - d1x * d2z; normal.z += d1x * d2y - d1y * d2x; he1 = he2; he2 = he2.next; numVerts++; } area = normal.norm(); normal.scale(1 / area); }
public void computeNormal(vector3d normal, double minArea) { computeNormal(normal); if (area < minArea) { // make the normal more robust by removing // components parallel to the longest edge HalfEdge hedgeMax = null; double lenSqrMax = 0; HalfEdge hedge = he0; do { double lenSqr = hedge.lengthSquared(); if (lenSqr > lenSqrMax) { hedgeMax = hedge; lenSqrMax = lenSqr; } hedge = hedge.next; }while (hedge != he0); point3d p2 = hedgeMax.head().pnt; point3d p1 = hedgeMax.tail().pnt; double lenMax = Math.Sqrt(lenSqrMax); double ux = (p2.x - p1.x) / lenMax; double uy = (p2.y - p1.y) / lenMax; double uz = (p2.z - p1.z) / lenMax; double dot = normal.x * ux + normal.y * uy + normal.z * uz; normal.x -= dot * ux; normal.y -= dot * uy; normal.z -= dot * uz; normal.normalize(); } }
public Vertex(double x, double y, double z, int idx) { pnt = new point3d(x, y, z); index = idx; }
public Vertex() { pnt = new point3d(); }
public double distanceToPlane(point3d p) { return(normal.x * p.x + normal.y * p.y + normal.z * p.z - planeOffset); }
public Face() { normal = new vector3d(); centroid = new point3d(); mark = VISIBLE; }
private void computeMaxAndMin() { vector3d max = new vector3d(); vector3d min = new vector3d(); for (int i = 0; i < 3; i++) { maxVtxs[i] = minVtxs[i] = pointBuffer[0]; } max.set(pointBuffer[0].pnt); min.set(pointBuffer[0].pnt); for (int i = 1; i < numPoints; i++) { point3d pnt = pointBuffer[i].pnt; if (pnt.x > max.x) { max.x = pnt.x; maxVtxs[0] = pointBuffer[i]; } else if (pnt.x < min.x) { min.x = pnt.x; minVtxs[0] = pointBuffer[i]; } if (pnt.y > max.y) { max.y = pnt.y; maxVtxs[1] = pointBuffer[i]; } else if (pnt.y < min.y) { min.y = pnt.y; minVtxs[1] = pointBuffer[i]; } if (pnt.z > max.z) { max.z = pnt.z; maxVtxs[2] = pointBuffer[i]; } else if (pnt.z < min.z) { min.z = pnt.z; minVtxs[2] = pointBuffer[i]; } } // this epsilon formula comes from QuickHull, and I'm // not about to quibble. charLength = Math.Max(max.x - min.x, max.y - min.y); charLength = Math.Max(max.z - min.z, charLength); if (explicitTolerance == AUTOMATIC_TOLERANCE) { tolerance = 3 * DOUBLE_PREC * (Math.Max(Math.Abs(max.x), Math.Abs(min.x)) + Math.Max(Math.Abs(max.y), Math.Abs(min.y)) + Math.Max(Math.Abs(max.z), Math.Abs(min.z))); } else { tolerance = explicitTolerance; } }