// Return number of occupied DPoints Modified
public int getOccupiedDPoints() {
int occupiedNumber = 0;
for (DPoint p : dockingPoints) {
if (p.isOccupied()) occupiedNumber++;
}
return occupiedNumber;
}
void setDistributor(EventDistributor d) {
touchScreen.addDistributorLinks(d);
cardReader.addDistributorLinks(d);
keyReader.addDistributorLinks(d);
for (DPoint dp : dockingPoints) {
dp.setDistributor(d);
}
}
void setCollector(EventCollector c) {
touchScreen.setCollector(c);
cardReader.setCollector(c);
keyIssuer.setCollector(c);
for (DPoint dp : dockingPoints) {
dp.setCollector(c);
}
}
/**
* Display the triangle in a JPanel Must be used only when using package drawing
*
* @param g
* @param decalageX
* @param decalageY
* @param minX
* @param minY
* @param scaleX
* @param scaleY
*/
public final void displayObject(
Graphics g,
int decalageX,
int decalageY,
double minX,
double minY,
double scaleX,
double scaleY) {
int[] xPoints, yPoints;
xPoints = new int[PT_NB];
yPoints = new int[PT_NB];
DPoint p1, p2, pptNb;
p1 = getPoint(0);
p2 = getPoint(1);
pptNb = getPoint(2);
xPoints[0] = (int) ((p1.getX() - minX) * scaleX + decalageX);
xPoints[1] = (int) ((p2.getX() - minX) * scaleX + decalageX);
xPoints[2] = (int) ((pptNb.getX() - minX) * scaleX + decalageX);
yPoints[0] = (int) ((p1.getY() - minY) * scaleY + decalageY);
yPoints[1] = (int) ((p2.getY() - minY) * scaleY + decalageY);
yPoints[2] = (int) ((pptNb.getY() - minY) * scaleY + decalageY);
setColor(g);
g.fillPolygon(xPoints, yPoints, PT_NB);
for (int i = 0; i < PT_NB; i++) {
edges[i].displayObject(g, decalageX, decalageY, minX, minY, scaleX, scaleY);
}
}
/**
* Get the point of the triangle that is not one of the 2 points given in argument. If one of
* these argument is not part of this triangle, this method will return null.
*
* @param p1
* @param p2
* @return alterPoint
*/
public final DPoint getAlterPoint(DPoint p1, DPoint p2) {
DPoint t1 = getPoint(0);
DPoint t2 = getPoint(1);
DPoint t3 = getPoint(2);
if (p1.equals(t1)) {
if (p2.equals(t2)) {
return t3;
} else if (p2.equals(t3)) {
return t2;
}
} else if (p1.equals(t2)) {
if (p2.equals(t1)) {
return t3;
} else if (p2.equals(t3)) {
return t1;
}
} else if (p1.equals(t3)) {
if (p2.equals(t1)) {
return t2;
} else if (p2.equals(t2)) {
return t1;
}
}
return null;
}
/**
* Get the ith point. i must be equal to 0, 1 or 2.
*
* <p>This method is consistent with getPoints, ie getPoints().get(i)==getPoint(i).
*
* @param i
* @return aPoint On of the apex if i = 0, 1 or 2, null otherwise.
*/
public final DPoint getPoint(int i) {
DPoint p = null;
if (i == 0) {
p = edges[0].getStartPoint();
} else if (i == 1) {
p = edges[0].getEndPoint();
} else if (i == 2) {
p = edges[1].getStartPoint();
if ((p.equals(edges[0].getStartPoint())) || (p.equals(edges[0].getEndPoint()))) {
p = edges[1].getEndPoint();
}
}
return p;
}
/**
* Check if the aPoint is in or on the circumcircle of this triangle.
*
* @param aPoint
* @return position : <br>
* * 0 = outside <br>
* * 1 = inside <br>
* * 2 = on the circle
*/
public final int inCircle(DPoint aPoint) {
// default is outside the circle
int returnedValue = 0;
double ux = aPoint.getX() - xCenter;
double uy = aPoint.getY() - yCenter;
double distance = ux * ux + uy * uy;
if (distance < radius - Tools.EPSILON2) {
returnedValue = 1;
} else if (distance < radius + Tools.EPSILON2) {
returnedValue = 2;
}
return returnedValue;
}
/**
* Get the barycenter of the triangle as a DPoint
*
* @return isFlat
* @throws DelaunayError
*/
public final DPoint getBarycenter() throws DelaunayError {
double x = 0, y = 0, z = 0;
DPoint aPoint;
for (int i = 0; i < PT_NB; i++) {
aPoint = getPoint(i);
x += aPoint.getX();
y += aPoint.getY();
z += aPoint.getZ();
}
x /= (double) PT_NB;
y /= (double) PT_NB;
z /= (double) PT_NB;
return new DPoint(x, y, z);
}
@Override
public final BoundaryBox getBoundingBox() throws DelaunayError {
BoundaryBox aBox = new BoundaryBox();
DPoint p1, p2, pptNb;
p1 = edges[0].getStartPoint();
p2 = edges[0].getEndPoint();
pptNb = edges[1].getStartPoint();
if ((pptNb.equals(p1)) || (pptNb.equals(p2))) {
pptNb = edges[1].getEndPoint();
}
aBox.alterBox(p1);
aBox.alterBox(p2);
aBox.alterBox(pptNb);
return aBox;
}
/**
* Return the square of the minimal distance between pt and the apex of this triangle.
*
* @param pt
* @return the square of the minimal distance between pt and the apex of this triangle.
*/
public final double getMinSquareDistance(DPoint pt) {
double min = Double.POSITIVE_INFINITY;
for (int i = 0; i < PT_NB; i++) {
double dist = pt.squareDistance(getPoint(i));
min = dist < min ? dist : min;
}
return min;
}
/**
* Implements the Comparable interface. The triangles will be sorted according the middle of their
* bounding box. As we work on a triangulation where triangles' intersection can only be an edge,
* a point or void, the Bounding boxes are unique.
*
* <p>BE CAREFUL : this method is not consistent with equals ! We are making a comparison on the
* bounding box of two triangles, they could be equal even if the triangle are different !!!
*
* @param t
* @return -1, 0 or 1, using the point comparison on the center of the bounding boxes
*/
@Override
public final int compareTo(DTriangle t) {
try {
DPoint midT = getBoundingBox().getMiddle();
DPoint midO = t.getBoundingBox().getMiddle();
int c = midT.compareTo(midO);
if (c == 0) {
try {
c = getBarycenter().compareTo(t.getBarycenter());
} catch (DelaunayError ex) {
Logger.getLogger(DTriangle.class.getName()).log(Level.WARNING, null, ex);
}
}
return c;
} catch (DelaunayError e) {
throw new IllegalArgumentException(e.getLocalizedMessage(), e);
}
}
/**
* Get the normal vector to this triangle, of length 1.
*
* @return Get the vector normal to the triangle.
* @throws DelaunayError
*/
public final DPoint getNormalVector() throws DelaunayError {
// We first perform a vectorial product between two of the edges
double dx1 = edges[0].getStartPoint().getX() - edges[0].getEndPoint().getX();
double dy1 = edges[0].getStartPoint().getY() - edges[0].getEndPoint().getY();
double dz1 = edges[0].getStartPoint().getZ() - edges[0].getEndPoint().getZ();
double dx2 = edges[1].getStartPoint().getX() - edges[1].getEndPoint().getX();
double dy2 = edges[1].getStartPoint().getY() - edges[1].getEndPoint().getY();
double dz2 = edges[1].getStartPoint().getZ() - edges[1].getEndPoint().getZ();
DPoint vec = new DPoint(dy1 * dz2 - dz1 * dy2, dz1 * dx2 - dx1 * dz2, dx1 * dy2 - dy1 * dx2);
double length = Math.sqrt(vec.squareDistance(new DPoint(0, 0, 0)));
vec.setX(vec.getX() / length);
vec.setY(vec.getY() / length);
vec.setZ(vec.getZ() / length);
return vec;
}
/**
* Compute the azimut of the triangle in degrees between north and steeepest vector. Aspect is
* measured clockwise in degrees from 0, due north, to 360, again due north, coming full circle.
*
* @return the aspect of the slope of this triangle.
* @throws DelaunayError
*/
public final double getSlopeAspect() throws DelaunayError {
double orientationPente;
DPoint c1 = new DPoint(0.0, 0.0, 0.0);
DPoint c2 = getSteepestVector();
if (c2.getZ() > 0.0) {
c2.setX(-c2.getX());
c2.setY(-c2.getY());
c2.setZ(-c2.getZ());
}
// l'ordre des coordonnees correspond a l'orientation de l'arc
// "sommet haut vers sommet bas"
double angleAxeXrad = Tools.angle(c1, c2);
// on considere que l'axe nord correspond a l'axe Y positif
double angleAxeNordrad = Tools.PI_OVER_2 - angleAxeXrad;
double angleAxeNorddeg = Math.toDegrees(angleAxeNordrad);
// on renvoie toujours une valeur d'angle >= 0
orientationPente = angleAxeNorddeg < 0.0 ? 360.0 + angleAxeNorddeg : angleAxeNorddeg;
return orientationPente;
}
/**
* Compute the intersection point according to the vector opposite to the steepest vector. If dp
* is outside the triangle, we return null.
*
* @param dp
* @return The point pt of the triangle's boundary for which (dp pt) is colinear to the steepest
* vector.
* @throws DelaunayError
*/
public final DPoint getCounterSteepestIntersection(DPoint dp) throws DelaunayError {
if (isInside(dp) || isOnAnEdge(dp)) {
for (DEdge ed : edges) {
if (!isTopoOrientedToEdge(ed)) {
DPoint counterSteep = getSteepestVector();
counterSteep.setX(-counterSteep.getX());
counterSteep.setY(-counterSteep.getY());
counterSteep.setZ(-counterSteep.getZ());
DPoint pt =
Tools.computeIntersection(
ed.getStartPoint(), ed.getDirectionVector(), dp, counterSteep);
if (ed.contains(pt)) {
return pt;
}
}
}
}
return null;
}
/**
* Get the edge of the triangle that includes the two point
*
* @param p1
* @param p2
* @return alterEdge
*/
protected final DEdge getEdgeFromPoints(DPoint p1, DPoint p2) {
DEdge alterEdge = null;
DPoint test1, test2;
int i = 0;
while (i < PT_NB && alterEdge == null) {
DEdge testEdge = edges[i];
test1 = testEdge.getStartPoint();
test2 = testEdge.getEndPoint();
if ((test1.equals(p1)) && (test2.equals(p2))) {
alterEdge = testEdge;
} else if ((test1.equals(p2)) && (test2.equals(p1))) {
alterEdge = testEdge;
} else {
i++;
}
}
return alterEdge;
}
/**
* Compute triangle area
*
* @return area
*/
public final double getArea() {
DPoint p1, p2, pptNb;
p1 = edges[0].getStartPoint();
p2 = edges[0].getEndPoint();
pptNb = edges[1].getStartPoint();
if ((pptNb.equals(p1)) || (pptNb.equals(p2))) {
pptNb = edges[1].getEndPoint();
}
double area =
((pptNb.getX() - p1.getX()) * (p2.getY() - p1.getY())
- (p2.getX() - p1.getX()) * (pptNb.getY() - p1.getY()))
/ 2;
return area < 0 ? -area : area;
}
public void setHub(HubInterface h) {
this.hub = h;
for (DPoint dp : dockingPoints) {
dp.setInterface(this, hub);
}
}
/**
* Get the leftmost point of this triangle.
*
* @return the leftmost point of this triangle.
*/
public final DPoint getLeftMost() {
DPoint p1 = edges[0].getPointLeft();
DPoint p2 = edges[1].getPointLeft();
return p1.compareTo(p2) < 1 ? p1 : p2;
}
/**
* Recompute the center of the circle that joins the ptNb points : the CircumCenter
*
* @throws DelaunayError
*/
public final void computeCenter() throws DelaunayError {
DPoint p1, p2, pptNb;
p1 = edges[0].getStartPoint();
p2 = edges[0].getEndPoint();
pptNb = edges[1].getStartPoint();
if ((pptNb.equals(p1)) || (pptNb.equals(p2))) {
pptNb = edges[1].getEndPoint();
}
double p1Sq = p1.getX() * p1.getX() + p1.getY() * p1.getY();
double p2Sq = p2.getX() * p2.getX() + p2.getY() * p2.getY();
double pptNbSq = pptNb.getX() * pptNb.getX() + pptNb.getY() * pptNb.getY();
double ux = p2.getX() - p1.getX();
double uy = p2.getY() - p1.getY();
double vx = pptNb.getX() - p1.getX();
double vy = pptNb.getY() - p1.getY();
double cp = ux * vy - uy * vx;
double cx, cy;
if (cp != 0) {
cx =
(p1Sq * (p2.getY() - pptNb.getY())
+ p2Sq * (pptNb.getY() - p1.getY())
+ pptNbSq * (p1.getY() - p2.getY()))
/ (2.0 * cp);
cy =
(p1Sq * (pptNb.getX() - p2.getX())
+ p2Sq * (p1.getX() - pptNb.getX())
+ pptNbSq * (p2.getX() - p1.getX()))
/ (2.0 * cp);
xCenter = cx;
yCenter = cy;
zCenter = interpolateZ(new DPoint(cx, cy, 0));
radius = p1.squareDistance2D(xCenter, yCenter);
} else {
xCenter = 0.0;
yCenter = 0.0;
radius = -1;
}
}
/**
* Get the vector with the highest down slope in the plan associated to this triangle.
*
* @return return the steepest vector.
* @throws DelaunayError
*/
public final DPoint getSteepestVector() throws DelaunayError {
DPoint normal = getNormalVector();
if (Math.abs(normal.getX()) < Tools.EPSILON && Math.abs(normal.getY()) < Tools.EPSILON) {
return new DPoint(0, 0, 0);
}
DPoint pente;
if (Math.abs(normal.getX()) < Tools.EPSILON) {
pente = new DPoint(0, 1, -normal.getY() / normal.getZ());
} else if (Math.abs(normal.getY()) < Tools.EPSILON) {
pente = new DPoint(1, 0, -normal.getX() / normal.getZ());
} else {
pente =
new DPoint(
normal.getX() / normal.getY(),
1,
-1 / normal.getZ() * (normal.getX() * normal.getX() / normal.getY() + normal.getY()));
}
// We want the vector to be low-oriented.
if (pente.getZ() > Tools.EPSILON) {
pente.setX(-pente.getX());
pente.setY(-pente.getY());
pente.setZ(-pente.getZ());
}
// We normalize it
double length = Math.sqrt(pente.squareDistance(new DPoint(0, 0, 0)));
if (length > Tools.EPSILON) {
pente.setX(pente.getX() / length);
pente.setY(pente.getY() / length);
pente.setZ(pente.getZ() / length);
}
return pente;
}
/**
* Retrieve the angle, in degrees, at vertex number k.
*
* @param k
* @return The angle at the ith point.
*/
public final double getAngle(int k) {
int k1 = (k + 1) % PT_NB;
int k2 = (k1 + 1) % PT_NB;
final double degreesPI = 180d;
DPoint p1 = this.getPoint(k);
DPoint p2 = this.getPoint(k1);
DPoint pptNb = this.getPoint(k2);
double ux = p2.getX() - p1.getX();
double uy = p2.getY() - p1.getY();
double vx = pptNb.getX() - p1.getX();
double vy = pptNb.getY() - p1.getY();
double dp = ux * vx + uy * vy;
return Math.acos(Math.sqrt(((dp * dp)) / ((ux * ux + uy * uy) * (vx * vx + vy * vy))))
* (degreesPI / Math.PI);
}
/**
* Get Z value of a specific point in the triangle
*
* @param aPoint
* @return ZValue
*/
public final double interpolateZ(DPoint aPoint) {
double zValue = 0;
DPoint p1, p2, p3;
p1 = edges[0].getStartPoint();
p2 = edges[0].getEndPoint();
p3 = edges[1].getStartPoint();
if ((p3.equals(p1)) || (p3.equals(p2))) {
p3 = edges[1].getEndPoint();
}
double ux = p2.getX() - p1.getX();
double uy = p2.getY() - p1.getY();
double uz = p2.getZ() - p1.getZ();
double vx = p3.getX() - p1.getX();
double vy = p3.getY() - p1.getY();
double vz = p3.getZ() - p1.getZ();
double a = uy * vz - uz * vy;
double b = uz * vx - ux * vz;
double c = ux * vy - uy * vx;
double d = -a * p1.getX() - b * p1.getY() - c * p1.getZ();
if (Math.abs(c) > Tools.EPSILON) {
// Non vertical triangle
zValue = (-a * aPoint.getX() - b * aPoint.getY() - d) / c;
}
return zValue;
}
/**
* Computes the 3D area of a triangle based on the same approach of JTS
*
* @return
*/
public final double getArea3D() {
DPoint p1, p2, pptNb;
p1 = edges[0].getStartPoint();
p2 = edges[0].getEndPoint();
pptNb = edges[1].getStartPoint();
if ((pptNb.equals(p1)) || (pptNb.equals(p2))) {
pptNb = edges[1].getEndPoint();
}
/**
* Uses the formula 1/2 * | u x v | where u,v are the side vectors of the triangle x is the
* vector cross-product
*/
// side vectors u and v
double ux = p2.getX() - p1.getX();
double uy = p2.getY() - p1.getY();
double uz = p2.getZ() - p1.getZ();
double vx = pptNb.getX() - p1.getX();
double vy = pptNb.getY() - p1.getY();
double vz = pptNb.getZ() - p1.getZ();
// cross-product = u x v
double crossx = uy * vz - uz * vy;
double crossy = uz * vx - ux * vz;
double crossz = ux * vy - uy * vx;
// tri area = 1/2 * | u x v |
double absSq = crossx * crossx + crossy * crossy + crossz * crossz;
return Math.sqrt(absSq) / 2;
}
