|
public class cVector implements java.io.Serializable
|
{
|
static final long serialVersionUID = 218039003662855348L;
|
|
public cVector()
|
{
|
}
|
|
public cVector(double ix, double iy, double iz)
|
{
|
x = ix;
|
y = iy;
|
z = iz;
|
}
|
|
public cVector(cVector v)
|
{
|
set(v);
|
}
|
|
static final public cVector X = new cVector(1, 0, 0);
|
static final public cVector Y = new cVector(0, 1, 0);
|
static final public cVector Z = new cVector(0, 0, 1);
|
|
double x, y, z;
|
|
double get(int i)
|
{
|
switch (i)
|
{
|
case 0:
|
return x;
|
case 1:
|
return y;
|
case 2:
|
return z;
|
}
|
|
System.err.println("ARRAY OUT OF BOUND");
|
new Exception().printStackTrace();
|
return 0;
|
}
|
|
void set(int i, double value)
|
{
|
switch (i)
|
{
|
case 0:
|
x = value;
|
break;
|
case 1:
|
y = value;
|
break;
|
case 2:
|
z = value;
|
break;
|
default:
|
{
|
System.err.println("ARRAY OUT OF BOUND");
|
new Exception().printStackTrace();
|
}
|
}
|
}
|
|
cVector ToFloat()
|
{
|
x = (float)x;
|
y = (float)y;
|
z = (float)z;
|
|
return this;
|
}
|
|
void set(cVector v)
|
{
|
x = v.x;
|
y = v.y;
|
z = v.z;
|
}
|
|
void set(cVector v, double scale)
|
{
|
x = v.x * scale;
|
y = v.y * scale;
|
z = v.z * scale;
|
}
|
|
void set(double ix, double iy, double iz)
|
{
|
x = ix;
|
y = iy;
|
z = iz;
|
}
|
|
void mul(double f)
|
{
|
x *= f;
|
y *= f;
|
z *= f;
|
}
|
|
void mulEq(int i, double value)
|
{
|
switch (i)
|
{
|
case 0:
|
x *= value;
|
break;
|
case 1:
|
y *= value;
|
break;
|
case 2:
|
z *= value;
|
break;
|
default:
|
{
|
System.err.println("ARRAY OUT OF BOUND");
|
new Exception().printStackTrace();
|
}
|
}
|
}
|
|
void mulEq(double value)
|
{
|
x *= value;
|
y *= value;
|
z *= value;
|
}
|
|
void addEq(int i, double value)
|
{
|
switch (i)
|
{
|
case 0:
|
x += value;
|
break;
|
case 1:
|
y += value;
|
break;
|
case 2:
|
z += value;
|
break;
|
default:
|
{
|
System.err.println("ARRAY OUT OF BOUND");
|
new Exception().printStackTrace();
|
}
|
}
|
|
}
|
|
void addEq(double value)
|
{
|
x += value;
|
y += value;
|
z += value;
|
}
|
|
double distance(cVector v)
|
{
|
double dx = x - v.x;
|
double dy = y - v.y;
|
double dz = z - v.z;
|
|
return Math.sqrt(dx*dx + dy*dy + dz*dz);
|
}
|
|
double length()
|
{
|
double l2 = x * x + y * y + z * z;
|
|
if (l2 == 1)
|
{
|
return 1;
|
}
|
|
return Math.sqrt(l2);
|
}
|
|
double length2()
|
{
|
return x * x + y * y + z * z;
|
}
|
|
boolean normalize()
|
{
|
double l = length();
|
|
if (l == 0)
|
{
|
return false;
|
}
|
|
if (l == 1) // maybe rare...
|
return true;
|
|
x /= l;
|
y /= l;
|
z /= l;
|
|
return true;
|
}
|
|
boolean normalized()
|
{
|
if (true)
|
return true;
|
|
double l = length2();
|
|
return Math.abs(l - 1) < 1E-6;
|
}
|
|
double dot(cVector v)
|
{
|
return (double) x * v.x + y * v.y + z * v.z;
|
}
|
|
void sub(cVector v)
|
{
|
x -= v.x;
|
y -= v.y;
|
z -= v.z;
|
}
|
|
void add(cVector v)
|
{
|
x += v.x;
|
y += v.y;
|
z += v.z;
|
}
|
|
void add(cVector v, double scale)
|
{
|
x += v.x * scale;
|
y += v.y * scale;
|
z += v.z * scale;
|
}
|
|
void cross(cVector u, cVector v)
|
{
|
double tx = u.y * v.z - u.z * v.y;
|
double ty = u.z * v.x - u.x * v.z;
|
double tz = u.x * v.y - u.y * v.x;
|
|
x = tx; y = ty; z = tz;
|
}
|
|
public String toString()
|
{
|
double x0 = (int)(x*1000000) / 1000000.0;
|
double y0 = (int)(y*1000000) / 1000000.0;
|
double z0 = (int)(z*1000000) / 1000000.0;
|
|
return "[" + x0 + ", " + y0 + ", " + z0 + "]";
|
}
|
|
public boolean equals(Object o)
|
{
|
//if (true) return false;
|
|
cVector vert = (cVector) o;
|
|
double tolerance = 0.00001;
|
|
if (!Grafreed.epsequal)
|
tolerance = 0;
|
|
return Math.abs(x - vert.x) +
|
Math.abs(y - vert.y) +
|
Math.abs(z - vert.z) <= tolerance;
|
}
|
|
public int hashCode()
|
{
|
long lx = Double.doubleToRawLongBits(x);
|
long ly = Double.doubleToRawLongBits(y);
|
long lz = Double.doubleToRawLongBits(z);
|
|
if (Grafreed.epsequal)
|
{
|
return 0;
|
} else
|
{
|
return (int) (lx + (lx >> 32) + ly + (ly >> 32) + lz + (lz >> 32));
|
}
|
}
|
}
|
