@Override
public Vector getMaximumPoint() {
return new Vector(
Math.max(pos1.getX(), pos2.getX()),
Math.max(pos1.getY(), pos2.getY()),
Math.max(pos1.getZ(), pos2.getZ()));
}
public void update() {
vel.increaseX(accel.getX());
vel.increaseY(accel.getY());
if (isWalking && Math.abs(vel.getX()) < maxSpeed) vel.increaseX((2 * currentDirection - 1));
x += vel.getX();
y -= vel.getY();
if (vel.getY() < 0) jumped = true;
}
// Returns the orientation of the palm given a frame of data
// The double returned is a real number between 0 and 1 indicating
// the component of the normal to the palm on the plane of the
// computer screen
private Double getPalmOrientation(Frame frame) {
Double armOrt = -1.0;
if (frame.isValid()) {
if (!frame.hands().isEmpty()) {
Vector normal = frame.hands().rightmost().palmNormal();
armOrt = Math.sqrt(normal.getX() * normal.getX() + normal.getY() * normal.getY());
}
}
return armOrt;
}
public static Transform rotate(final double angle, final Vector vector) {
vector.normalize();
final double sin = Math.sin(Math.toRadians(angle));
final double cos = Math.cos(Math.toRadians(angle));
final double[][] m = new double[4][4];
m[0][0] = vector.getX() * vector.getX() + (1.0D - vector.getX() * vector.getX()) * cos;
m[0][1] = vector.getX() * vector.getY() * (1.0D - cos) - vector.getZ() * sin;
m[0][2] = vector.getX() * vector.getZ() * (1.0D - cos) + vector.getY() * sin;
m[0][3] = 0.0D;
m[1][0] = vector.getX() * vector.getY() * (1.0D - cos) + vector.getZ() * sin;
m[1][1] = vector.getY() * vector.getY() + (1.0D - vector.getY() * vector.getY()) * cos;
m[1][2] = vector.getY() * vector.getZ() * (1.0D - cos) - vector.getX() * sin;
m[1][3] = 0.0D;
m[2][0] = vector.getX() * vector.getZ() * (1.0D - cos) - vector.getY() * sin;
m[2][1] = vector.getY() * vector.getZ() * (1.0D - cos) + vector.getX() * sin;
m[2][2] = vector.getZ() * vector.getZ() + (1.0D - vector.getZ() * vector.getZ()) * cos;
m[2][3] = 0.0D;
m[3][0] = 0.0D;
m[3][1] = 0.0D;
m[3][2] = 0.0D;
m[3][3] = 1.0D;
final Matrix matrix = Matrix.newInstance(m);
final Matrix matrixInversed = matrix.transpose();
return newInstance(matrix, matrixInversed);
}
/**
* constructed an orthogonal whose normal vector aligns with a v1, v2 and v3 are the two tangents
*
* @param v1
* @param v2
* @param v3
* @return
*/
public static Vector[] coordinateSystem(Vector v1, Vector v2, Vector v3) {
if (Math.abs(v1.getX()) > Math.abs(v1.getY())) {
float invLen = (float) (1.f / Math.sqrt(v1.getX() * v1.getX() + v1.getZ() * v1.getZ()));
v2 = new Vector(-v1.getZ() * invLen, 0.f, v1.getX() * invLen);
} else {
float invLen = (float) (1.f / Math.sqrt(v1.getY() * v1.getY() + v1.getZ() * v1.getZ()));
v2 = new Vector(0.f, v1.getZ() * invLen, -v1.getY() * invLen);
}
v3 = cross(v1, v2);
Vector vect[] = {v1, v2, v3};
return vect;
}
public float getDistance(Vector vector) {
return (float)
Math.sqrt(
Math.pow(vector.getX() - x, 2)
+ Math.pow(vector.getY() - y, 2)
+ Math.pow(vector.getZ() - z, 2));
}
private String transformationStr(Transformation trf) {
NumberFormat fmt = FloatFormat.getInstance();
Matrix matrix = trf.matrix();
Vector vector = trf.vector();
return "matrix <"
+ fmt.format(matrix.get(Transformation.X, Transformation.X))
+ ","
+ fmt.format(matrix.get(Transformation.Z, Transformation.X))
+ ","
+ fmt.format(matrix.get(Transformation.Y, Transformation.X))
+ ","
+ fmt.format(matrix.get(Transformation.X, Transformation.Z))
+ ","
+ fmt.format(matrix.get(Transformation.Z, Transformation.Z))
+ ","
+ fmt.format(matrix.get(Transformation.Y, Transformation.Z))
+ ","
+ fmt.format(matrix.get(Transformation.X, Transformation.Y))
+ ","
+ fmt.format(matrix.get(Transformation.Z, Transformation.Y))
+ ","
+ fmt.format(matrix.get(Transformation.Y, Transformation.Y))
+ ","
+ fmt.format(vector.getX())
+ ","
+ fmt.format(vector.getZ())
+ ","
+ fmt.format(vector.getY())
+ ">";
}
@Override
public final void clip(double z) {
boolean isCompletelyHidden = true;
int vectorCount = vectors.size();
for (int i = 0; i < vectorCount; i++) {
int next = (i + 1) % vectorCount;
Vector vector1 = vectors.get(i);
Vector vector2 = vectors.get(next);
Vector vector3 = null;
if (vector1.getZ() < z) {
isCompletelyHidden = false;
}
if (vector1.getZ() > vector2.getZ()) {
vector3 = vector1;
vector1 = vector2;
vector2 = vector3;
}
if (vector1.getZ() < z && vector2.getZ() > z) {
double scale = (z - vector1.getZ()) / (vector2.getZ() - vector1.getZ());
vectors.add(
next,
Vector.newInstance(
vector1.getX() + scale * (vector2.getX() - vector1.getX()),
vector1.getY() + scale * (vector2.getY() - vector1.getY()),
z));
vectorCount++;
}
}
if (isCompletelyHidden) {
return;
}
for (int i = vectorCount - 1; i >= 0; i--) {
if (vectors.get(i).getZ() > z) {
vectors.remove(i);
}
}
}
/**
* Get a region that contains the faces of this cuboid.
*
* @return a new complex region
*/
public Region getFaces() {
Vector min = getMinimumPoint();
Vector max = getMaximumPoint();
return new RegionIntersection(
// Project to Z-Y plane
new CuboidRegion(pos1.setX(min.getX()), pos2.setX(min.getX())),
new CuboidRegion(pos1.setX(max.getX()), pos2.setX(max.getX())),
// Project to X-Y plane
new CuboidRegion(pos1.setZ(min.getZ()), pos2.setZ(min.getZ())),
new CuboidRegion(pos1.setZ(max.getZ()), pos2.setZ(max.getZ())),
// Project to the X-Z plane
new CuboidRegion(pos1.setY(min.getY()), pos2.setY(min.getY())),
new CuboidRegion(pos1.setY(max.getY()), pos2.setY(max.getY())));
}
/**
* Returns the y-component for the vector.
*
* @return The y-component.
*/
public double getVectorY() {
Vector vi = (Vector) getObject();
if (vi != null) {
return vi.getY();
} else {
return Double.NaN;
}
}
public static Quaternion makeRotation(Quaternion result, float theta, Vector axis) {
float halfTheta = theta / 2;
float sinHalfTheta = GMath.sin(halfTheta);
result.w = GMath.cos(halfTheta);
result.x = axis.getX() * sinHalfTheta;
result.y = axis.getY() * sinHalfTheta;
result.z = axis.getZ() * sinHalfTheta;
return result;
}
private String vectorStr(Vector v) {
NumberFormat fmt = FloatFormat.getInstance();
return "<"
+ fmt.format(v.getX())
+ ","
+ fmt.format(v.getZ())
+ ","
+ fmt.format(v.getY())
+ ">";
}
public static TexturedPolygon newTexturedPolygon(Texture texture, Vector... vectors) {
TexturedPolygon texturedPolygon = TexturedPolygonImpl.newInstance(texture, vectors);
if (vectors.length >= 2) {
if (texture instanceof ShadedTexture) {
ShadedTexture shadedTexture = ShadedTexture.class.cast(texture);
List<PointLight> pointLights = new ArrayList<>();
Vector normal = texturedPolygon.getNormal();
Vector location = null;
double x = normal.getX();
double y = normal.getY() + 500.0D;
double z = normal.getZ();
double distanceFalloff = 2500.0D;
Color intensity = Color.white();
location = Vector.newInstance(x, y, z);
PointLight pointLight = PointLight.newInstance();
pointLight.setLocation(location);
pointLight.setIntensity(intensity);
pointLight.setDistanceFalloff(distanceFalloff);
pointLights.add(pointLight);
Color ambientLightIntensity = Color.valueOf(0xFF333333);
ShadedSurfaceTexture.createShadedSurfaceTexture(
texturedPolygon,
shadedTexture,
pointLights,
new ArrayList<Polygon>(),
ambientLightIntensity);
} else {
Vector origin = vectors[0];
Vector v = vectors[1].copy();
Vector normal = texturedPolygon.getNormal();
v.subtract(origin);
Vector u = Vector.toCrossProduct(normal, v);
BoundingBox boundingBox = texturedPolygon.getTextureBounds();
boundingBox.setOrigin(origin);
boundingBox.setU(u);
boundingBox.setV(v);
}
}
return texturedPolygon;
}
public boolean isOnLink(Link l) {
Vector AM =
new Vector(
this.getX() - l.getvA().getX(),
this.getY() - l.getvA().getY(),
this.getZ() - l.getvA().getZ());
System.out.println("AM : " + AM);
System.out.println("AB : " + l.getU());
if (l.getU().getX() == 0)
if (AM.getX() != 0) return false;
else return AM.getZ() / l.getU().getZ() == AM.getY() / l.getU().getY();
else if (l.getU().getY() == 0)
if (AM.getY() != 0) return false;
else return AM.getX() / l.getU().getX() == AM.getZ() / l.getU().getZ();
else if (l.getU().getZ() == 0)
if (AM.getZ() != 0) return false;
else return AM.getX() / l.getU().getX() == AM.getY() / l.getU().getY();
else
return AM.getX() / l.getU().getX() == AM.getY() / l.getU().getY()
&& AM.getX() / l.getU().getX() == AM.getZ() / l.getU().getZ();
}
public Vector transform(final Vector vector) {
final double[][] matrix = this.matrix.getMatrix();
final double x = vector.getX();
final double y = vector.getY();
final double z = vector.getZ();
vector.setX(matrix[0][0] * x + matrix[0][1] * y + matrix[0][2] * z);
vector.setY(matrix[1][0] * x + matrix[1][1] * y + matrix[1][2] * z);
vector.setZ(matrix[2][0] * x + matrix[2][1] * y + matrix[2][2] * z);
return vector;
}
@Override
public boolean equals(Object object) {
if (object == null) {
return false;
}
if (object instanceof Vector) {
Vector vector = (Vector) object;
if (vector.getX() == x && vector.getY() == y && vector.getZ() == z) {
return true;
}
}
return false;
}
public Transform transform(final Vector vector0, final Vector vector1) {
final double[][] matrix = this.matrix.getMatrix();
final double x = vector0.getX();
final double y = vector0.getY();
final double z = vector0.getZ();
vector1.setX(matrix[0][0] * x + matrix[0][1] * y + matrix[0][2] * z);
vector1.setY(matrix[1][0] * x + matrix[1][1] * y + matrix[1][2] * z);
vector1.setZ(matrix[2][0] * x + matrix[2][1] * y + matrix[2][2] * z);
return this;
}
@Override
public String toString() {
Vector d = this.getVector();
String str = "BBox{";
str += "[" + this.min.getX() + ";" + this.min.getY() + ";" + this.min.getZ() + "]";
str += " x ";
str += "[" + this.max.getX() + ";" + this.max.getY() + ";" + this.max.getZ() + "]";
str += " extends ";
str += "[" + d.getX() + ";" + d.getY() + ";" + d.getZ() + "]";
str += "}";
return str;
}
public static Transform lookAt(final Point source, final Point target, final Vector up) {
final double[][] m = new double[4][4];
m[0][3] = source.getX();
m[1][3] = source.getY();
m[2][3] = source.getZ();
m[3][3] = 1.0D;
final Vector direction = Vector.copyAndSubtract(target, source).normalize();
final Vector vector0 = Vector.copyAndNormalize(up);
final Vector vector1 = Vector.toCrossProduct(vector0, direction);
if (vector1.length() == 0.0D) {
return newInstance();
}
final Vector vector2 = vector1.normalize();
final Vector vector3 = Vector.toCrossProduct(direction, vector2);
m[0][0] = vector2.getX();
m[1][0] = vector2.getY();
m[2][0] = vector2.getZ();
m[3][0] = 0.0D;
m[0][1] = vector3.getX();
m[1][1] = vector3.getY();
m[2][1] = vector3.getZ();
m[3][1] = 0.0D;
m[0][2] = direction.getX();
m[1][2] = direction.getY();
m[2][2] = direction.getZ();
m[3][2] = 0.0D;
final Matrix matrix = Matrix.newInstance(m);
return newInstance(matrix.inverse(), matrix);
}
@Override
public boolean contains(Vector position) {
double x = position.getX();
double y = position.getY();
double z = position.getZ();
Vector min = getMinimumPoint();
Vector max = getMaximumPoint();
return x >= min.getBlockX()
&& x <= max.getBlockX()
&& y >= min.getBlockY()
&& y <= max.getBlockY()
&& z >= min.getBlockZ()
&& z <= max.getBlockZ();
}
@Override
public void contract(Vector... changes) {
checkNotNull(changes);
for (Vector change : changes) {
if (change.getX() < 0) {
if (Math.max(pos1.getX(), pos2.getX()) == pos1.getX()) {
pos1 = pos1.add(new Vector(change.getX(), 0, 0));
} else {
pos2 = pos2.add(new Vector(change.getX(), 0, 0));
}
} else {
if (Math.min(pos1.getX(), pos2.getX()) == pos1.getX()) {
pos1 = pos1.add(new Vector(change.getX(), 0, 0));
} else {
pos2 = pos2.add(new Vector(change.getX(), 0, 0));
}
}
if (change.getY() < 0) {
if (Math.max(pos1.getY(), pos2.getY()) == pos1.getY()) {
pos1 = pos1.add(new Vector(0, change.getY(), 0));
} else {
pos2 = pos2.add(new Vector(0, change.getY(), 0));
}
} else {
if (Math.min(pos1.getY(), pos2.getY()) == pos1.getY()) {
pos1 = pos1.add(new Vector(0, change.getY(), 0));
} else {
pos2 = pos2.add(new Vector(0, change.getY(), 0));
}
}
if (change.getZ() < 0) {
if (Math.max(pos1.getZ(), pos2.getZ()) == pos1.getZ()) {
pos1 = pos1.add(new Vector(0, 0, change.getZ()));
} else {
pos2 = pos2.add(new Vector(0, 0, change.getZ()));
}
} else {
if (Math.min(pos1.getZ(), pos2.getZ()) == pos1.getZ()) {
pos1 = pos1.add(new Vector(0, 0, change.getZ()));
} else {
pos2 = pos2.add(new Vector(0, 0, change.getZ()));
}
}
}
recalculate();
}
private void initTransform(Graphics g) throws Exception {
// Perform transformation
transform = new AffineTransform();
double dw = 1;
double minw = 0;
double dh = 0;
double minh = 0;
double scale;
double x;
double y;
// double abs;
final int margin = 5;
int showLevel = previewTree.getShowLevel();
class FindAStem extends DefaultTreeTraversal {
Stem found = null;
int level;
public FindAStem(int level) {
this.level = level;
}
public Stem getFound() {
return found;
}
public boolean enterStem(Stem stem) {
if (found == null && stem.stemlevel < level) return true; // look further
else if (found != null || stem.stemlevel > level) return false; // found a stem or too deep
else if (stem.stemlevel == level) found = stem;
return true;
}
public boolean leaveTree(Tree tree) {
return (found != null);
}
}
if (showLevel < 1) {
setOrigin(new Vector());
//////////// FRONT view
if (perspective == PERSPECTIVE_FRONT) {
// get width and height of the tree
dw = previewTree.getWidth() * 2;
dh = previewTree.getHeight();
minh = 0;
minw = -dw / 2;
///////////////// TOP view
} else {
// get width of the tree
dw = previewTree.getWidth() * 2;
minw = -dw / 2;
}
} else {
// find stem which to show
/* Enumeration e = previewTree.allStems(showLevel-1);
if (! e.hasMoreElements()) throw new Exception("Stem not found");
Stem stem = (Stem)e.nextElement();
*/
Stem aStem = null;
FindAStem stemFinder = new FindAStem(showLevel - 1);
if (previewTree.traverseTree(stemFinder)) {
aStem = stemFinder.getFound();
}
if (aStem != null) {
Vector diag = aStem.getMaxPoint().sub(aStem.getMinPoint());
Vector orig = aStem.getTransformation().getT();
setOrigin(new Vector(orig.getX(), orig.getY(), 0));
Vector max = aStem.getMaxPoint();
Vector min = aStem.getMinPoint();
// get greatest distance from orig
x = Math.max(Math.abs(min.getX() - orig.getX()), Math.abs(max.getX() - orig.getX()));
y = Math.max(Math.abs(min.getY() - orig.getY()), Math.abs(max.getY() - orig.getY()));
dw = Math.sqrt(x * x + y * y) * 2;
minw = -dw / 2;
dh = diag.getZ();
minh = min.getZ();
}
// DEBUG
// System.err.println("O: "+ orig +" min: "+min+" max: "+max);
// System.err.println("maxX: "+x+" maxY: "+y);
// System.err.println("dg: "+diag+" dw: "+dw+" minw: "+minw+" dh: "+dh+" minh: "+minh);
}
//////////// FRONT view
if (perspective == PERSPECTIVE_FRONT) {
// how much to scale for fitting into view?
scale = Math.min((getHeight() - 2 * margin) / dh, (getWidth() - 2 * margin) / dw);
if (previewTree.params.debug) System.err.println("scale: " + scale);
// shift to mid point of the view
transform.translate(getWidth() / 2, getHeight() / 2);
// scale to image height
transform.scale(scale, -scale);
// shift mid of the tree to the origin of the image
transform.translate(-minw - dw / 2, -minh - dh / 2);
///////////////// TOP view
} else {
// how much to scale for fitting into view?
scale = Math.min((getHeight() - 2 * margin) / dw, (getWidth() - 2 * margin) / dw);
// shift to mid point of the view
transform.translate(getWidth() / 2, getHeight() / 2);
// scale to image height
transform.scale(scale, -scale);
// shift mid of the stem to the origin of the image
transform.translate(-minw - dw / 2, -minw - dw / 2);
}
// DEBUG
Point p = new Point();
transform.transform(new Point2D.Double(0.0, 0.0), p);
if (previewTree.params.debug) {
System.err.println("width: " + minw + "+" + dw);
System.err.println("height: " + minh + "+" + dh);
System.err.println("Origin at: " + p);
System.err.println("view: " + getWidth() + "x" + getHeight());
}
}
/**
* Constructeur par recopie
*
* @param vect le vecteur a copier
*/
public Vector(Vector vect) {
this.x = vect.getX();
this.y = vect.getY();
}
/**
* return the index of the longest axis
*
* @return 0 for x, 1 for y, 2 for z
*/
public int maxExtent() {
Vector v = this.getVector();
if (v.getX() > v.getY() && v.getX() > v.getZ()) return 0;
else if (v.getY() > v.getZ()) return 1;
else return 2;
}
/** @return area of the aabox */
public float surfaceArea() {
Vector v = this.getVector();
return 2.f * v.getX() * v.getY() + 2.f * v.getX() * v.getZ() + 2.f * v.getY() * v.getZ();
}
/** @return the volume of aabox */
public float volume() {
Vector v = this.getVector();
return v.getX() * v.getY() * v.getZ();
}
/**
* methode pemertant de copier une coordonne dans une autre
*
* @param coord la coordonne a copier
*/
public void copie(Vector vect) {
this.setX(vect.getX());
this.setY(vect.getY());
}
public static Transform translate(final Vector vector) {
return translate(vector.getX(), vector.getY(), vector.getZ());
}
public static Transform scale(final Vector vector) {
return scale(vector.getX(), vector.getY(), vector.getZ());
}
/**
* Flip the clipboard.
*
* @param dir direction to flip
* @param aroundPlayer flip the offset around the player
*/
public void flip(FlipDirection dir, boolean aroundPlayer) {
final int width = getWidth();
final int length = getLength();
final int height = getHeight();
switch (dir) {
case WEST_EAST:
final int wid = (int) Math.ceil(width / 2.0f);
for (int xs = 0; xs < wid; ++xs) {
for (int z = 0; z < length; ++z) {
for (int y = 0; y < height; ++y) {
BaseBlock old = data[xs][y][z].flip(dir);
if (xs == width - xs - 1) continue;
data[xs][y][z] = data[width - xs - 1][y][z].flip(dir);
data[width - xs - 1][y][z] = old;
}
}
}
if (aroundPlayer) {
offset = offset.setX(1 - offset.getX() - width);
}
break;
case NORTH_SOUTH:
final int len = (int) Math.ceil(length / 2.0f);
for (int zs = 0; zs < len; ++zs) {
for (int x = 0; x < width; ++x) {
for (int y = 0; y < height; ++y) {
BaseBlock old = data[x][y][zs].flip(dir);
if (zs == length - zs - 1) continue;
data[x][y][zs] = data[x][y][length - zs - 1].flip(dir);
data[x][y][length - zs - 1] = old;
}
}
}
if (aroundPlayer) {
offset = offset.setZ(1 - offset.getZ() - length);
}
break;
case UP_DOWN:
final int hei = (int) Math.ceil(height / 2.0f);
for (int ys = 0; ys < hei; ++ys) {
for (int x = 0; x < width; ++x) {
for (int z = 0; z < length; ++z) {
BaseBlock old = data[x][ys][z].flip(dir);
if (ys == height - ys - 1) continue;
data[x][ys][z] = data[x][height - ys - 1][z].flip(dir);
data[x][height - ys - 1][z] = old;
}
}
}
if (aroundPlayer) {
offset = offset.setY(1 - offset.getY() - height);
}
break;
}
}
