|
class Vertex extends cVector implements java.io.Serializable, java.lang.Comparable
|
{
|
static int sortaxis = 0;
|
|
public int compareTo(Object o)
|
{
|
Vertex b = (Vertex) o;
|
|
switch (sortaxis)
|
{
|
case 0: return x < b.x?-1:1;
|
case 1: return y < b.y?-1:1;
|
case 2: return z < b.z?-1:1;
|
}
|
|
return 0;
|
}
|
|
static final long serialVersionUID = -367349739426346764L;
|
|
Vertex()
|
{
|
this(false);
|
}
|
|
Vertex(boolean withnorm)
|
{
|
//pos = new cVector();
|
if (withnorm)
|
{
|
norm = new cVector();
|
}
|
}
|
|
Vertex(cVector v)
|
{
|
//pos = new cVector(v);
|
super(v);
|
}
|
|
Vertex(Vertex v)
|
{
|
//pos = new cVector(v/*.pos*/);
|
super(v);
|
if (v.norm != null)
|
{
|
norm = new cVector(v.norm);
|
assert(norm.normalized());
|
}
|
index = v.index;
|
s = v.s;
|
t = v.t;
|
}
|
|
Vertex(double x, double y, double z)
|
{
|
//pos = new cVector(x,y,z);
|
super(x, y, z);
|
}
|
|
void set(Vertex v)
|
{
|
super.set(v);
|
|
if (norm != null && v.norm != null)
|
{
|
assert(norm.normalized());
|
|
norm.set(v.norm);
|
|
assert(norm.normalized());
|
}
|
}
|
|
boolean ContainsFace(int index)
|
{
|
assert(norm.normalized());
|
for (int i=0; i<faceindices.length; i++)
|
{
|
if (faceindices[i] == -1)
|
return false;
|
|
if (faceindices[i] == index)
|
return true;
|
}
|
|
// assert(false);
|
|
return false;
|
}
|
|
void AddFace(int index)
|
{
|
assert(norm.normalized());
|
for (int i=0; i<faceindices.length; i++)
|
{
|
if (faceindices[i] == -1)
|
{
|
faceindices[i] = index;
|
return;
|
}
|
}
|
|
// assert(false);
|
}
|
|
// Don't consider normal into hashcode for uniqueness
|
static boolean normalmode = false;
|
|
public int hashCode()
|
{
|
//if (normalmode) // pos == null)
|
// return 0;
|
if (norm == null || !normalmode)
|
{
|
return /*pos.*/ super.hashCode();
|
}
|
|
return /*pos.*/ super.hashCode() + norm.hashCode();
|
}
|
|
public boolean equals(Object o)
|
{
|
// JUNE 2019. norm can be null (e.g. Box) Grafreed.Assert(norm.normalized());
|
//if (true) return false;
|
|
Vertex vert = (Vertex) o;
|
|
//System.out.println("pos = " + pos + "; vert.pos = " + vert/*.pos*/);
|
|
double tolerance = 0.00001;
|
|
if (!Grafreed.epsequal)
|
tolerance = 0;
|
|
boolean samepos = Math.abs(/*pos.*/x - vert./*pos.*/x) +
|
Math.abs(/*pos.*/y - vert./*pos.*/y) +
|
Math.abs(/*pos.*/z - vert./*pos.*/z) <= tolerance && // GrafreeD.epsvertex2 && // WARNING: USE 0.0001 for serial issues
|
(Grafreed.linkUV || Math.abs(s - vert.s) + Math.abs(t - vert.t) <= tolerance)
|
; // GrafreeD.epsvertex2;
|
|
if (samepos && Grafreed.smoothmode)
|
{
|
norm.add(vert.norm);
|
norm.normalize();
|
vert.norm.set(norm);
|
}
|
|
return samepos;
|
}
|
/*
|
public boolean isSame(Object o)
|
{
|
Vertex vert = (Vertex) o;
|
return x == vert.x && y == vert.y && z == vert.z;
|
}
|
*/
|
//cVector pos; // Base class
|
cVector norm;
|
cVector speed;
|
int index = -1;
|
double s, t;
|
int vertexlink = -1;
|
int vertexlink2 = -1; // second point to block the rotation
|
float tx; // coordinates in tangent plane (closest point)
|
float ty;
|
float tz;
|
float nx; // normals in tangent plane (closest point)
|
float ny;
|
float nz;
|
|
int[] vertexlinks = null; // multiple support points (N)
|
int[] vertexlinks2 = null; // second point to block the rotation
|
float[] weights;
|
float totalweight;
|
float[] tplane; // coordinates in tangent plane (xyz*N)
|
float[] nplane; // normals
|
int closestsupport;
|
|
// june 2013
|
transient int[] faceindices;
|
|
int supportindex; // actually subgeometry
|
|
//short flags;
|
//boolean touched;
|
transient int /*byte*/ valid = -1;
|
transient int boundary = -1;
|
transient int valence = 0;
|
//transient
|
float AO = 1;
|
}
|
