144 lines
3.6 KiB
JavaScript
144 lines
3.6 KiB
JavaScript
|
|
// Returns sign of number
|
|
sign = function(x) {
|
|
return typeof x === 'number' ? x ? x < 0 ? -1 : 1 : x === x ? 0 : NaN : NaN;
|
|
};
|
|
|
|
|
|
// Returns intersection points of lines and whether lines are intersected
|
|
getLineIntersection = function (point1, point2, point3, point4) {
|
|
|
|
var intersectionPoint = {};
|
|
|
|
var x1 = point1.x, y1 = point1.y, x2 = point2.x, y2 = point2.y,
|
|
x3 = point3.x, y3 = point3.y, x4 = point4.x, y4 = point4.y;
|
|
|
|
var a1, a2, b1, b2, c1, c2; // Coefficients of line equations
|
|
var r1, r2, r3, r4; // Sign values
|
|
|
|
var denom, offset, num; //Intermediate values
|
|
|
|
// Compute a1, b1, c1, where line joining points 1 and 2 is "a1 x + b1 y + c1 = 0"
|
|
a1 = y2 - y1;
|
|
b1 = x1 - x2;
|
|
c1 = x2 * y1 - x1 * y2;
|
|
|
|
// Compute r3 and r4
|
|
r3 = a1 * x3 + b1 * y3 + c1;
|
|
r4 = a1 * x4 + b1 * y4 + c1;
|
|
|
|
/* Check signs of r3 and r4. If both point 3 and point 4 lie on
|
|
* same side of line 1, the line segments do not intersect.
|
|
*/
|
|
|
|
if (r3 != 0 &&
|
|
r4 != 0 &&
|
|
sign(r3) == sign(r4))
|
|
{
|
|
intersectionPoint.x = 0;
|
|
intersectionPoint.y = 0;
|
|
intersectionPoint.intersected = false;
|
|
return intersectionPoint;
|
|
}
|
|
|
|
/* Compute a2, b2, c2 */
|
|
|
|
a2 = y4 - y3;
|
|
b2 = x3 - x4;
|
|
c2 = x4 * y3 - x3 * y4;
|
|
|
|
/* Compute r1 and r2 */
|
|
|
|
r1 = a2 * x1 + b2 * y1 + c2;
|
|
r2 = a2 * x2 + b2 * y2 + c2;
|
|
|
|
/* Check signs of r1 and r2. If both point 1 and point 2 lie
|
|
* on same side of second line segment, the line segments do
|
|
* not intersect.
|
|
*/
|
|
|
|
if (r1 != 0 &&
|
|
r2 != 0 &&
|
|
sign(r1) == sign(r2))
|
|
{
|
|
intersectionPoint.x = 0;
|
|
intersectionPoint.y = 0;
|
|
intersectionPoint.intersected = false;
|
|
return intersectionPoint;
|
|
}
|
|
|
|
/* Line segments intersect: compute intersection point.
|
|
*/
|
|
|
|
denom = (a1 * b2) - (a2 * b1);
|
|
|
|
offset = denom < 0 ? -denom / 2 : denom / 2;
|
|
|
|
/* The denom/2 is to get rounding instead of truncating. It
|
|
* is added or subtracted to the numerator, depending upon the
|
|
* sign of the numerator.
|
|
*/
|
|
|
|
num = (b1 * c2) - (b2 * c1);
|
|
var x = parseFloat(num / denom);
|
|
|
|
num = (a2 * c1) - (a1 * c2);
|
|
var y = parseFloat(num / denom);
|
|
|
|
intersectionPoint.x = x;
|
|
intersectionPoint.y = y;
|
|
intersectionPoint.intersected = true;
|
|
|
|
return intersectionPoint;
|
|
};
|
|
|
|
// Returns distance between two points
|
|
getDistance = function(point1, point2) {
|
|
return Math.sqrt((point1.x - point2.x) * (point1.x - point2.x) + (point1.y - point2.y) * (point1.y - point2.y));
|
|
};
|
|
|
|
// Returns distance from point to a line
|
|
getDistanceFromPointToLine = function (ptTest, pt1, pt2) {
|
|
var ptNearest = {};
|
|
|
|
// Point on line segment nearest to pt0
|
|
var dx = pt2.x - pt1.x;
|
|
var dy = pt2.y - pt1.y;
|
|
|
|
// It's a point, not a line
|
|
if (dx == 0 && dy == 0)
|
|
{
|
|
ptNearest.x = pt1.x;
|
|
ptNearest.y = pt1.y;
|
|
}
|
|
else
|
|
{
|
|
// Parameter
|
|
var t = ((ptTest.x - pt1.x) * dx + (ptTest.y - pt1.y) * dy) / (dx * dx + dy * dy);
|
|
|
|
// Nearest point is pt1
|
|
if (t < 0)
|
|
{
|
|
ptNearest = pt1;
|
|
}
|
|
// Nearest point is pt2
|
|
else if (t > 1)
|
|
{
|
|
ptNearest = pt2;
|
|
}
|
|
// Nearest point is on the line segment
|
|
else
|
|
{
|
|
// Parametric equation
|
|
ptNearest.x = (pt1.x + t * dx);
|
|
ptNearest.y = (pt1.y + t * dy);
|
|
}
|
|
}
|
|
|
|
var distanceX = ptTest.x - ptNearest.x;
|
|
var distanceY = ptTest.y - ptNearest.y;
|
|
ptNearest.distance = Math.sqrt(distanceX * distanceX + distanceY * distanceY);
|
|
|
|
return ptNearest;
|
|
};
|