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;
}
}
