public void computeIntersection(Coordinate p, Coordinate p1, Coordinate p2) {
isProper = false;
// do between check first, since it is faster than the orientation test
if (Envelope.intersects(p1, p2, p)) {
if ((CGAlgorithms.orientationIndex(p1, p2, p) == 0)
&& (CGAlgorithms.orientationIndex(p2, p1, p) == 0)) {
isProper = true;
if (p.equals(p1) || p.equals(p2)) {
isProper = false;
}
result = POINT_INTERSECTION;
return;
}
}
result = NO_INTERSECTION;
}
protected int computeIntersect(Coordinate p1, Coordinate p2, Coordinate q1, Coordinate q2) {
isProper = false;
// first try a fast test to see if the envelopes of the lines intersect
if (!Envelope.intersects(p1, p2, q1, q2)) return NO_INTERSECTION;
// for each endpoint, compute which side of the other segment it lies
// if both endpoints lie on the same side of the other segment,
// the segments do not intersect
int Pq1 = CGAlgorithms.orientationIndex(p1, p2, q1);
int Pq2 = CGAlgorithms.orientationIndex(p1, p2, q2);
if ((Pq1 > 0 && Pq2 > 0) || (Pq1 < 0 && Pq2 < 0)) {
return NO_INTERSECTION;
}
int Qp1 = CGAlgorithms.orientationIndex(q1, q2, p1);
int Qp2 = CGAlgorithms.orientationIndex(q1, q2, p2);
if ((Qp1 > 0 && Qp2 > 0) || (Qp1 < 0 && Qp2 < 0)) {
return NO_INTERSECTION;
}
boolean collinear = Pq1 == 0 && Pq2 == 0 && Qp1 == 0 && Qp2 == 0;
if (collinear) {
return computeCollinearIntersection(p1, p2, q1, q2);
}
/**
* At this point we know that there is a single intersection point (since the lines are not
* collinear).
*/
/**
* Check if the intersection is an endpoint. If it is, copy the endpoint as the intersection
* point. Copying the point rather than computing it ensures the point has the exact value,
* which is important for robustness. It is sufficient to simply check for an endpoint which is
* on the other line, since at this point we know that the inputLines must intersect.
*/
if (Pq1 == 0 || Pq2 == 0 || Qp1 == 0 || Qp2 == 0) {
isProper = false;
/**
* Check for two equal endpoints. This is done explicitly rather than by the orientation tests
* below in order to improve robustness.
*
* <p>[An example where the orientation tests fail to be consistent is the following (where
* the true intersection is at the shared endpoint POINT (19.850257749638203
* 46.29709338043669)
*
* <p>LINESTRING ( 19.850257749638203 46.29709338043669, 20.31970698357233 46.76654261437082 )
* and LINESTRING ( -48.51001596420236 -22.063180333403878, 19.850257749638203
* 46.29709338043669 )
*
* <p>which used to produce the INCORRECT result: (20.31970698357233, 46.76654261437082, NaN)
*/
if (p1.equals2D(q1) || p1.equals2D(q2)) {
intPt[0] = p1;
} else if (p2.equals2D(q1) || p2.equals2D(q2)) {
intPt[0] = p2;
}
/** Now check to see if any endpoint lies on the interior of the other segment. */
else if (Pq1 == 0) {
intPt[0] = new Coordinate(q1);
} else if (Pq2 == 0) {
intPt[0] = new Coordinate(q2);
} else if (Qp1 == 0) {
intPt[0] = new Coordinate(p1);
} else if (Qp2 == 0) {
intPt[0] = new Coordinate(p2);
}
} else {
isProper = true;
intPt[0] = intersection(p1, p2, q1, q2);
}
return POINT_INTERSECTION;
}
