mirror of
https://github.com/scratchfoundation/paper.js.git
synced 2025-01-10 06:41:59 -05:00
645 lines
17 KiB
JavaScript
645 lines
17 KiB
JavaScript
/*
|
|
* Paper.js
|
|
*
|
|
* This file is part of Paper.js, a JavaScript Vector Graphics Library,
|
|
* based on Scriptographer.org and designed to be largely API compatible.
|
|
* http://paperjs.org/
|
|
* http://scriptographer.org/
|
|
*
|
|
* Copyright (c) 2011, Juerg Lehni & Jonathan Puckey
|
|
* http://lehni.org/ & http://jonathanpuckey.com/
|
|
*
|
|
* Distributed under the MIT license. See LICENSE file for details.
|
|
*
|
|
* All rights reserved.
|
|
*/
|
|
|
|
/**
|
|
* @name Curve
|
|
*
|
|
* @class The Curve object represents the parts of a path that are connected by
|
|
* two following {@link Segment} objects. The curves of a path can be accessed
|
|
* through its {@link Path#curves} array.
|
|
*
|
|
* While a segment describe the anchor point and its incoming and outgoing
|
|
* handles, a Curve object describes the curve passing between two such
|
|
* segments. Curves and segments represent two different ways of looking at the
|
|
* same thing, but focusing on different aspects. Curves for example offer many
|
|
* convenient ways to work with parts of the path, finding lengths, positions or
|
|
* tangents at given offsets.
|
|
*/
|
|
var Curve = this.Curve = Base.extend(/** @lends Curve# */{
|
|
/**
|
|
* Creates a new curve object.
|
|
*
|
|
* @param {Segment} segment1
|
|
* @param {Segment} segment2
|
|
*/
|
|
initialize: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
|
|
var count = arguments.length;
|
|
if (count == 0) {
|
|
this._segment1 = new Segment();
|
|
this._segment2 = new Segment();
|
|
} else if (count == 1) {
|
|
// TODO: If beans are not activated, this won't copy from
|
|
// an existing segment. OK?
|
|
this._segment1 = new Segment(arg0.segment1);
|
|
this._segment2 = new Segment(arg0.segment2);
|
|
} else if (count == 2) {
|
|
this._segment1 = new Segment(arg0);
|
|
this._segment2 = new Segment(arg1);
|
|
} else if (count == 4) {
|
|
this._segment1 = new Segment(arg0, null, arg1);
|
|
this._segment2 = new Segment(arg3, arg2, null);
|
|
} else if (count == 8) {
|
|
// An array as returned by getValues
|
|
var p1 = Point.create(arg0, arg1),
|
|
p2 = Point.create(arg6, arg7);
|
|
this._segment1 = new Segment(p1, null,
|
|
Point.create(arg2, arg3).subtract(p1));
|
|
this._segment2 = new Segment(p2,
|
|
Point.create(arg4, arg5).subtract(p2), null);
|
|
}
|
|
},
|
|
|
|
_changed: function() {
|
|
// Clear cached values.
|
|
delete this._length;
|
|
},
|
|
|
|
/**
|
|
* The first anchor point of the curve.
|
|
*
|
|
* @type Point
|
|
* @bean
|
|
*/
|
|
getPoint1: function() {
|
|
return this._segment1._point;
|
|
},
|
|
|
|
setPoint1: function(point) {
|
|
point = Point.read(arguments);
|
|
this._segment1._point.set(point.x, point.y);
|
|
},
|
|
|
|
/**
|
|
* The second anchor point of the curve.
|
|
*
|
|
* @type Point
|
|
* @bean
|
|
*/
|
|
getPoint2: function() {
|
|
return this._segment2._point;
|
|
},
|
|
|
|
setPoint2: function(point) {
|
|
point = Point.read(arguments);
|
|
this._segment2._point.set(point.x, point.y);
|
|
},
|
|
|
|
/**
|
|
* The handle point that describes the tangent in the first anchor point.
|
|
*
|
|
* @type Point
|
|
* @bean
|
|
*/
|
|
getHandle1: function() {
|
|
return this._segment1._handleOut;
|
|
},
|
|
|
|
setHandle1: function(point) {
|
|
point = Point.read(arguments);
|
|
this._segment1._handleOut.set(point.x, point.y);
|
|
},
|
|
|
|
/**
|
|
* The handle point that describes the tangent in the second anchor point.
|
|
*
|
|
* @type Point
|
|
* @bean
|
|
*/
|
|
getHandle2: function() {
|
|
return this._segment2._handleIn;
|
|
},
|
|
|
|
setHandle2: function(point) {
|
|
point = Point.read(arguments);
|
|
this._segment2._handleIn.set(point.x, point.y);
|
|
},
|
|
|
|
/**
|
|
* The first segment of the curve.
|
|
*
|
|
* @type Segment
|
|
* @bean
|
|
*/
|
|
getSegment1: function() {
|
|
return this._segment1;
|
|
},
|
|
|
|
/**
|
|
* The second segment of the curve.
|
|
*
|
|
* @type Segment
|
|
* @bean
|
|
*/
|
|
getSegment2: function() {
|
|
return this._segment2;
|
|
},
|
|
|
|
/**
|
|
* The path that the curve belongs to.
|
|
*
|
|
* @type Path
|
|
* @bean
|
|
*/
|
|
getPath: function() {
|
|
return this._path;
|
|
},
|
|
|
|
/**
|
|
* The index of the curve in the {@link Path#curves} array.
|
|
*
|
|
* @type Number
|
|
* @bean
|
|
*/
|
|
getIndex: function() {
|
|
return this._segment1._index;
|
|
},
|
|
|
|
/**
|
|
* The next curve in the {@link Path#curves} array that the curve
|
|
* belongs to.
|
|
*
|
|
* @type Curve
|
|
* @bean
|
|
*/
|
|
getNext: function() {
|
|
var curves = this._path && this._path._curves;
|
|
return curves && (curves[this._segment1._index + 1]
|
|
|| this._path._closed && curves[0]) || null;
|
|
},
|
|
|
|
/**
|
|
* The previous curve in the {@link Path#curves} array that the curve
|
|
* belongs to.
|
|
*
|
|
* @type Curve
|
|
* @bean
|
|
*/
|
|
getPrevious: function() {
|
|
var curves = this._path && this._path._curves;
|
|
return curves && (curves[this._segment1._index - 1]
|
|
|| this._path._closed && curves[curves.length - 1]) || null;
|
|
},
|
|
|
|
/**
|
|
* Specifies whether the handles of the curve are selected.
|
|
*
|
|
* @type Boolean
|
|
* @bean
|
|
*/
|
|
isSelected: function() {
|
|
return this.getHandle1().isSelected() && this.getHandle2().isSelected();
|
|
},
|
|
|
|
setSelected: function(selected) {
|
|
this.getHandle1().setSelected(selected);
|
|
this.getHandle2().setSelected(selected);
|
|
},
|
|
|
|
getValues: function() {
|
|
return Curve.getValues(this._segment1, this._segment2);
|
|
},
|
|
|
|
// DOCS: document Curve#getLength(from, to)
|
|
/**
|
|
* The approximated length of the curve in points.
|
|
*
|
|
* @type Number
|
|
* @bean
|
|
*/
|
|
getLength: function(/* from, to */) {
|
|
var from = arguments[0],
|
|
to = arguments[1];
|
|
fullLength = arguments.length == 0 || from == 0 && to == 1;
|
|
if (fullLength && this._length != null)
|
|
return this._length;
|
|
// Hide parameters from Bootstrap so it injects bean too
|
|
var args = this.getValues();
|
|
if (!fullLength)
|
|
args.push(from, to);
|
|
var length = Curve.getLength.apply(Curve, args);
|
|
if (fullLength)
|
|
this._length = length;
|
|
return length;
|
|
},
|
|
|
|
getPart: function(from, to) {
|
|
var args = this.getValues();
|
|
args.push(from, to);
|
|
return new Curve(Curve.getPart.apply(Curve, args));
|
|
},
|
|
|
|
/**
|
|
* Checks if this curve is linear, meaning it does not define any curve
|
|
* handle.
|
|
|
|
* @return {Boolean} {@true the curve is linear}
|
|
*/
|
|
isLinear: function() {
|
|
return this._segment1._handleOut.isZero()
|
|
&& this._segment2._handleIn.isZero();
|
|
},
|
|
|
|
// PORT: Add support for start parameter to Sg
|
|
// DOCS: document Curve#getParameter(length, start)
|
|
/**
|
|
* @param {Number} length
|
|
* @param {Number} [start]
|
|
* @return {Number}
|
|
*/
|
|
getParameter: function(length, start) {
|
|
var args = this.getValues();
|
|
args.push(length, start !== undefined ? start : length < 0 ? 1 : 0);
|
|
return Curve.getParameter.apply(Curve, args);
|
|
},
|
|
|
|
/**
|
|
* Private method used in getPoint, getTangent, getNormal.
|
|
*/
|
|
_evaluate: function(parameter, type) {
|
|
var args = this.getValues();
|
|
args.push(parameter, type);
|
|
return Curve.evaluate.apply(Curve, args);
|
|
},
|
|
|
|
/**
|
|
* Returns the point on the curve at the specified position.
|
|
*
|
|
* @param {Number} parameter the position at which to find the point as
|
|
* a value between {@code 0} and {@code 1}.
|
|
* @return {Point}
|
|
*/
|
|
getPoint: function(parameter) {
|
|
return this._evaluate(parameter, 0);
|
|
},
|
|
|
|
/**
|
|
* Returns the tangent point on the curve at the specified position.
|
|
*
|
|
* @param {Number} parameter the position at which to find the tangent
|
|
* point as a value between {@code 0} and {@code 1}.
|
|
*/
|
|
getTangent: function(parameter) {
|
|
return this._evaluate(parameter, 1);
|
|
},
|
|
|
|
/**
|
|
* Returns the normal point on the curve at the specified position.
|
|
*
|
|
* @param {Number} parameter the position at which to find the normal
|
|
* point as a value between {@code 0} and {@code 1}.
|
|
*/
|
|
getNormal: function(parameter) {
|
|
return this._evaluate(parameter, 2);
|
|
},
|
|
|
|
getCrossingsFor: function(point) {
|
|
// Implement a simple crossing number algorithm:
|
|
// http://en.wikipedia.org/wiki/Point_in_polygon
|
|
// Solve the y-axis cubic polynominal for point.y and count all
|
|
// solutions to the right of point.x as crossings.
|
|
var vals = this.getValues(),
|
|
roots = Curve.solve(vals[1], vals[3], vals[5], vals[7], point.y),
|
|
crossings = 0,
|
|
maxT = 1 - Numerical.TOLERANCE;
|
|
for (var i = 0, l = roots != Infinity && roots.length; i < l; i++) {
|
|
var t = roots[i];
|
|
if (t >= 0 && t < maxT && this.getPoint(t).x > point.x)
|
|
crossings++;
|
|
}
|
|
return crossings;
|
|
},
|
|
|
|
// TODO: getParameter(point, precision)
|
|
// TODO: getLocation
|
|
// TODO: getIntersections
|
|
// TODO: adjustThroughPoint
|
|
|
|
/**
|
|
* Returns a reversed version of the curve, without modifying the curve
|
|
* itself.
|
|
*
|
|
* @return {Curve} a reversed version of the curve
|
|
*/
|
|
reverse: function() {
|
|
return new Curve(this._segment2.reverse(), this._segment1.reverse());
|
|
},
|
|
|
|
// TODO: divide
|
|
// TODO: split
|
|
|
|
/**
|
|
* Returns a copy of the curve.
|
|
*
|
|
* @return {Curve}
|
|
*/
|
|
clone: function() {
|
|
return new Curve(this._segment1, this._segment2);
|
|
},
|
|
|
|
/**
|
|
* @return {String} A string representation of the curve.
|
|
*/
|
|
toString: function() {
|
|
var parts = [ 'point1: ' + this._segment1._point ];
|
|
if (!this._segment1._handleOut.isZero())
|
|
parts.push('handle1: ' + this._segment1._handleOut);
|
|
if (!this._segment2._handleIn.isZero())
|
|
parts.push('handle2: ' + this._segment2._handleIn);
|
|
parts.push('point2: ' + this._segment2._point);
|
|
return '{ ' + parts.join(', ') + ' }';
|
|
},
|
|
|
|
statics: {
|
|
create: function(path, segment1, segment2) {
|
|
var curve = new Curve(Curve.dont);
|
|
curve._path = path;
|
|
curve._segment1 = segment1;
|
|
curve._segment2 = segment2;
|
|
return curve;
|
|
},
|
|
|
|
getValues: function(segment1, segment2) {
|
|
var p1 = segment1._point,
|
|
h1 = segment1._handleOut,
|
|
h2 = segment2._handleIn,
|
|
p2 = segment2._point;
|
|
return [
|
|
p1._x, p1._y,
|
|
p1._x + h1._x, p1._y + h1._y,
|
|
p2._x + h2._x, p2._y + h2._y,
|
|
p2._x, p2._y
|
|
];
|
|
},
|
|
|
|
evaluate: function(p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y, t, type) {
|
|
var x, y;
|
|
|
|
// Handle special case at beginning / end of curve
|
|
// PORT: Change in Sg too, so 0.000000000001 won't be
|
|
// required anymore
|
|
if (t == 0 || t == 1) {
|
|
var point;
|
|
switch (type) {
|
|
case 0: // point
|
|
x = t == 0 ? p1x : p2x;
|
|
y = t == 0 ? p1y : p2y;
|
|
break;
|
|
case 1: // tangent
|
|
case 2: // normal
|
|
var px, py;
|
|
if (t == 0) {
|
|
if (c1x == p1x && c1y == p1y) { // handle1 = 0
|
|
if (c2x == p2x && c2y == p2y) { // handle2 = 0
|
|
px = p2x; py = p2y; // p2
|
|
} else {
|
|
px = c2x; py = c2y; // c2
|
|
}
|
|
} else {
|
|
px = c1x; py = c1y; // handle1
|
|
}
|
|
x = px - p1x;
|
|
y = py - p1y;
|
|
} else {
|
|
if (c2x == p2x && c2y == p2y) { // handle2 = 0
|
|
if (c1x == p1x && c1y == p1y) { // handle1 = 0
|
|
px = p1x; py = p1y; // p1
|
|
} else {
|
|
px = c1x; py = c1y; // c1
|
|
}
|
|
} else { // handle2
|
|
px = c2x; py = c2y;
|
|
}
|
|
x = p2x - px;
|
|
y = p2y - py;
|
|
}
|
|
break;
|
|
}
|
|
} else {
|
|
// Calculate the polynomial coefficients.
|
|
var cx = 3 * (c1x - p1x),
|
|
bx = 3 * (c2x - c1x) - cx,
|
|
ax = p2x - p1x - cx - bx,
|
|
|
|
cy = 3 * (c1y - p1y),
|
|
by = 3 * (c2y - c1y) - cy,
|
|
ay = p2y - p1y - cy - by;
|
|
|
|
switch (type) {
|
|
case 0: // point
|
|
// Calculate the curve point at parameter value t
|
|
x = ((ax * t + bx) * t + cx) * t + p1x;
|
|
y = ((ay * t + by) * t + cy) * t + p1y;
|
|
break;
|
|
case 1: // tangent
|
|
case 2: // normal
|
|
// Simply use the derivation of the bezier function for both
|
|
// the x and y coordinates:
|
|
x = (3 * ax * t + 2 * bx) * t + cx;
|
|
y = (3 * ay * t + 2 * by) * t + cy;
|
|
break;
|
|
}
|
|
}
|
|
// The normal is simply the rotated tangent:
|
|
// TODO: Rotate normals the other way in Scriptographer too?
|
|
// (Depending on orientation, I guess?)
|
|
return type == 2 ? new Point(y, -x) : new Point(x, y);
|
|
},
|
|
|
|
subdivide: function(p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y, t) {
|
|
if (t === undefined)
|
|
t = 0.5;
|
|
var u = 1 - t,
|
|
// Interpolate from 4 to 3 points
|
|
p3x = u * p1x + t * c1x,
|
|
p3y = u * p1y + t * c1y,
|
|
p4x = u * c1x + t * c2x,
|
|
p4y = u * c1y + t * c2y,
|
|
p5x = u * c2x + t * p2x,
|
|
p5y = u * c2y + t * p2y,
|
|
// Interpolate from 3 to 2 points
|
|
p6x = u * p3x + t * p4x,
|
|
p6y = u * p3y + t * p4y,
|
|
p7x = u * p4x + t * p5x,
|
|
p7y = u * p4y + t * p5y,
|
|
// Interpolate from 2 points to 1 point
|
|
p8x = u * p6x + t * p7x,
|
|
p8y = u * p6y + t * p7y;
|
|
// We now have all the values we need to build the subcurves:
|
|
return [
|
|
[p1x, p1y, p3x, p3y, p6x, p6y, p8x, p8y], // left
|
|
[p8x, p8y, p7x, p7y, p5x, p5y, p2x, p2y] // right
|
|
];
|
|
},
|
|
|
|
// Converts from the point coordinates (p1, c1, c2, p2) to the
|
|
// polynomial coefficients and solve the polynomial for val
|
|
solve: function (p1, c1, c2, p2, val) {
|
|
var p1m3 = 3 * p1,
|
|
c1m3 = 3 * c1,
|
|
c2m3 = 3 * c2,
|
|
a = p2 - c2m3 + c1m3 - p1,
|
|
b = c2m3 - c1m3 - c1m3 + p1m3,
|
|
c = c1m3 - p1m3,
|
|
d = p1 - val;
|
|
return Numerical.solveCubic(a, b, c, d, Numerical.TOLERANCE);
|
|
},
|
|
|
|
// TODO: Find better name
|
|
getPart: function(p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y, from, to) {
|
|
var curve = [p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y];
|
|
if (from > 0) {
|
|
// 8th argument of Curve.subdivide() == t, and values can be
|
|
// directly used as arguments list for apply().
|
|
curve[8] = from;
|
|
curve = Curve.subdivide.apply(Curve, curve)[1]; // right
|
|
}
|
|
if (to < 1) {
|
|
// Se above about curve[8].
|
|
// Interpolate the parameter at 'to' in the new curve and
|
|
// cut there
|
|
curve[8] = (to - from) / (1 - from);
|
|
curve = Curve.subdivide.apply(Curve, curve)[0]; // left
|
|
}
|
|
return curve;
|
|
},
|
|
|
|
isSufficientlyFlat: function(p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y) {
|
|
// Inspired by Skia, but to be tested:
|
|
// Calculate 1/3 (m1) and 2/3 (m2) along the line between start (p1)
|
|
// and end (p2), measure distance from there the control points and
|
|
// see if they are further away than 1/2.
|
|
// Seems all very inaccurate, especially since the distance
|
|
// measurement is just the bigger one of x / y...
|
|
// TODO: Find a more accurate and still fast way to determine this.
|
|
var vx = (p2x - p1x) / 3,
|
|
vy = (p2y - p1y) / 3,
|
|
m1x = p1x + vx,
|
|
m1y = p1y + vy,
|
|
m2x = p2x - vx,
|
|
m2y = p2y - vy;
|
|
return Math.max(
|
|
Math.abs(m1x - c1x), Math.abs(m1y - c1y),
|
|
Math.abs(m2x - c1x), Math.abs(m1y - c1y)) < 1 / 2;
|
|
/*
|
|
// Thanks to Kaspar Fischer for the following:
|
|
// http://www.inf.ethz.ch/personal/fischerk/pubs/bez.pdf
|
|
var ux = 3 * c1x - 2 * p1x - p2x;
|
|
ux *= ux;
|
|
var uy = 3 * c1y - 2 * p1y - p2y;
|
|
uy *= uy;
|
|
var vx = 3 * c2x - 2 * p2x - p1x;
|
|
vx *= vx;
|
|
var vy = 3 * c2y - 2 * p2y - p1y;
|
|
vy *= vy;
|
|
if (ux < vx)
|
|
ux = vx;
|
|
if (uy < vy)
|
|
uy = vy;
|
|
// Tolerance is 16 * tol ^ 2
|
|
return ux + uy <= 16 * Numerical.TOLERNACE * Numerical.TOLERNACE;
|
|
*/
|
|
}
|
|
}
|
|
}, new function() { // Scope for methods that require numerical integration
|
|
|
|
function getLengthIntegrand(p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y) {
|
|
// Calculate the coefficients of a Bezier derivative.
|
|
var ax = 9 * (c1x - c2x) + 3 * (p2x - p1x),
|
|
bx = 6 * (p1x + c2x) - 12 * c1x,
|
|
cx = 3 * (c1x - p1x),
|
|
|
|
ay = 9 * (c1y - c2y) + 3 * (p2y - p1y),
|
|
by = 6 * (p1y + c2y) - 12 * c1y,
|
|
cy = 3 * (c1y - p1y);
|
|
|
|
return function(t) {
|
|
// Calculate quadratic equations of derivatives for x and y
|
|
var dx = (ax * t + bx) * t + cx,
|
|
dy = (ay * t + by) * t + cy;
|
|
return Math.sqrt(dx * dx + dy * dy);
|
|
};
|
|
}
|
|
|
|
// Amount of integral evaluations for the interval 0 <= a < b <= 1
|
|
function getIterations(a, b) {
|
|
// Guess required precision based and size of range...
|
|
// TODO: There should be much better educated guesses for
|
|
// this. Also, what does this depend on? Required precision?
|
|
return Math.max(2, Math.min(16, Math.ceil(Math.abs(b - a) * 32)));
|
|
}
|
|
|
|
return {
|
|
statics: true,
|
|
|
|
getLength: function(p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y, a, b) {
|
|
if (a === undefined)
|
|
a = 0;
|
|
if (b === undefined)
|
|
b = 1;
|
|
if (p1x == c1x && p1y == c1y && p2x == c2x && p2y == c2y) {
|
|
// Straight line
|
|
var dx = p2x - p1x,
|
|
dy = p2y - p1y;
|
|
return (b - a) * Math.sqrt(dx * dx + dy * dy);
|
|
}
|
|
var ds = getLengthIntegrand(
|
|
p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y);
|
|
return Numerical.integrate(ds, a, b, getIterations(a, b));
|
|
},
|
|
|
|
getParameter: function(p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y,
|
|
length, start) {
|
|
if (length == 0)
|
|
return start;
|
|
// See if we're going forward or backward, and handle cases
|
|
// differently
|
|
var forward = length > 0,
|
|
a = forward ? start : 0,
|
|
b = forward ? 1 : start,
|
|
length = Math.abs(length),
|
|
// Use integrand to calculate both range length and part
|
|
// lengths in f(t) below.
|
|
ds = getLengthIntegrand(
|
|
p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y),
|
|
// Get length of total range
|
|
rangeLength = Numerical.integrate(ds, a, b,
|
|
getIterations(a, b));
|
|
if (length >= rangeLength)
|
|
return forward ? b : a;
|
|
// Use length / rangeLength for an initial guess for t, to
|
|
// bring us closer:
|
|
var guess = length / rangeLength,
|
|
len = 0;
|
|
// Iteratively calculate curve range lengths, and add them up,
|
|
// using integration precision depending on the size of the
|
|
// range. This is much faster and also more precise than not
|
|
// modifing start and calculating total length each time.
|
|
function f(t) {
|
|
var count = getIterations(start, t);
|
|
if (start < t) {
|
|
len += Numerical.integrate(ds, start, t, count);
|
|
} else {
|
|
len -= Numerical.integrate(ds, t, start, count);
|
|
}
|
|
start = t;
|
|
return len - length;
|
|
}
|
|
return Numerical.findRoot(f, ds,
|
|
forward ? a + guess : b - guess, // Initial guess for x
|
|
a, b, 16, Numerical.TOLERANCE);
|
|
}
|
|
};
|
|
});
|