/** * 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); } }
/** * 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; }
/** * 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; }
/** * 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; }
/** * 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; }
/** * 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; }
/** * 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); }
/** * 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; }
/** * 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; }
/** * 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; } }