@antv/x6
Version:
JavaScript diagramming library that uses SVG and HTML for rendering
425 lines • 13.8 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.Point = void 0;
const tslib_1 = require("tslib");
const util_1 = require("./util");
const Angle = tslib_1.__importStar(require("./angle"));
const geometry_1 = require("./geometry");
class Point extends geometry_1.Geometry {
static create(x, y) {
if (x == null || typeof x === 'number') {
// @ts-ignore
return new Point(x, y);
}
return Point.clone(x);
}
static clone(p) {
if (Point.isPoint(p)) {
return new Point(p.x, p.y);
}
if (Array.isArray(p)) {
return new Point(p[0], p[1]);
}
return new Point(p.x, p.y);
}
static equals(p1, p2) {
if (p1 === p2) {
return true;
}
if (p1 != null && p2 != null) {
return p1.x === p2.x && p1.y === p2.y;
}
return false;
}
static rotateEx(point, cos, sin, center = new Point()) {
const source = Point.clone(point);
const origin = Point.clone(center);
const dx = source.x - origin.x;
const dy = source.y - origin.y;
const x1 = dx * cos - dy * sin;
const y1 = dy * cos + dx * sin;
return new Point(x1 + origin.x, y1 + origin.y);
}
static toJSON(p) {
if (Point.isPoint(p)) {
return { x: p.x, y: p.y };
}
if (Array.isArray(p)) {
return { x: p[0], y: p[1] };
}
return { x: p.x, y: p.y };
}
/**
* Returns a new Point object from the given polar coordinates.
* @see http://en.wikipedia.org/wiki/Polar_coordinate_system
*/
static fromPolar(r, rad, origin = new Point()) {
let x = Math.abs(r * Math.cos(rad));
let y = Math.abs(r * Math.sin(rad));
const org = Point.clone(origin);
const deg = Angle.normalize(Angle.toDeg(rad));
if (deg < 90) {
y = -y;
}
else if (deg < 180) {
x = -x;
y = -y;
}
else if (deg < 270) {
x = -x;
}
return new Point(org.x + x, org.y + y);
}
/**
* Converts rectangular to polar coordinates.
*/
static toPolar(point, origin = new Point()) {
const p = Point.clone(point);
const o = Point.clone(origin);
const dx = p.x - o.x;
const dy = p.y - o.y;
return new Point(Math.sqrt(dx * dx + dy * dy), // r
Angle.toRad(o.theta(p)));
}
static equalPoints(p1, p2) {
if ((p1 == null && p2 != null) ||
(p1 != null && p2 == null) ||
(p1 != null && p2 != null && p1.length !== p2.length)) {
return false;
}
if (p1 != null && p2 != null) {
for (let i = 0, ii = p1.length; i < ii; i += 1) {
if (!Point.equals(p1[i], p2[i])) {
return false;
}
}
}
return true;
}
/**
* Returns a point with random coordinates that fall within the range
* `[x1, x2]` and `[y1, y2]`.
*/
static random(x1, x2, y1, y2) {
return new Point((0, util_1.random)(x1, x2), (0, util_1.random)(y1, y2));
}
static rotate(point, angle, center) {
const rad = Angle.toRad(Angle.normalize(-angle));
const sin = Math.sin(rad);
const cos = Math.cos(rad);
return Point.rotateEx(point, cos, sin, center);
}
static isPoint(instance) {
return instance != null && instance instanceof Point;
}
static isPointLike(p) {
return (p != null &&
typeof p === 'object' &&
typeof p.x === 'number' &&
typeof p.y === 'number');
}
static isPointData(p) {
return (p != null &&
Array.isArray(p) &&
p.length === 2 &&
typeof p[0] === 'number' &&
typeof p[1] === 'number');
}
constructor(x, y) {
super();
this.x = x == null ? 0 : x;
this.y = y == null ? 0 : y;
}
/**
* Rounds the point to the given precision.
*/
round(precision = 0) {
this.x = (0, util_1.round)(this.x, precision);
this.y = (0, util_1.round)(this.y, precision);
return this;
}
add(x, y) {
const p = Point.create(x, y);
this.x += p.x;
this.y += p.y;
return this;
}
update(x, y) {
const p = Point.create(x, y);
this.x = p.x;
this.y = p.y;
return this;
}
translate(dx, dy) {
const t = Point.create(dx, dy);
this.x += t.x;
this.y += t.y;
return this;
}
/**
* Rotate the point by `degree` around `center`.
*/
rotate(degree, center) {
const p = Point.rotate(this, degree, center);
this.x = p.x;
this.y = p.y;
return this;
}
/**
* Scale point by `sx` and `sy` around the given `origin`. If origin is
* not specified, the point is scaled around `0, 0`.
*/
scale(sx, sy, origin = new Point()) {
const ref = Point.create(origin);
this.x = ref.x + sx * (this.x - ref.x);
this.y = ref.y + sy * (this.y - ref.y);
return this;
}
/**
* Chooses the point closest to this point from among `points`. If `points`
* is an empty array, `null` is returned.
*/
closest(points) {
if (points.length === 1) {
return Point.create(points[0]);
}
let ret = null;
let min = Infinity;
points.forEach((p) => {
const dist = this.squaredDistance(p);
if (dist < min) {
ret = p;
min = dist;
}
});
return ret ? Point.create(ret) : null;
}
/**
* Returns the distance between the point and another point `p`.
*/
distance(p) {
return Math.sqrt(this.squaredDistance(p));
}
/**
* Returns the squared distance between the point and another point `p`.
*
* Useful for distance comparisons in which real distance is not necessary
* (saves one `Math.sqrt()` operation).
*/
squaredDistance(p) {
const ref = Point.create(p);
const dx = this.x - ref.x;
const dy = this.y - ref.y;
return dx * dx + dy * dy;
}
manhattanDistance(p) {
const ref = Point.create(p);
return Math.abs(ref.x - this.x) + Math.abs(ref.y - this.y);
}
/**
* Returns the magnitude of the point vector.
*
* @see http://en.wikipedia.org/wiki/Magnitude_(mathematics)
*/
magnitude() {
return Math.sqrt(this.x * this.x + this.y * this.y) || 0.01;
}
/**
* Returns the angle(in degrees) between vector from this point to `p` and
* the x-axis.
*/
theta(p = new Point()) {
const ref = Point.create(p);
const y = -(ref.y - this.y); // invert the y-axis.
const x = ref.x - this.x;
let rad = Math.atan2(y, x);
// Correction for III. and IV. quadrant.
if (rad < 0) {
rad = 2 * Math.PI + rad;
}
return (180 * rad) / Math.PI;
}
/**
* Returns the angle(in degrees) between vector from this point to `p1` and
* the vector from this point to `p2`.
*
* The ordering of points `p1` and `p2` is important.
*
* The function returns a value between `0` and `180` when the angle (in the
* direction from `p1` to `p2`) is clockwise, and a value between `180` and
* `360` when the angle is counterclockwise.
*
* Returns `NaN` if either of the points `p1` and `p2` is equal with this point.
*/
angleBetween(p1, p2) {
if (this.equals(p1) || this.equals(p2)) {
return NaN;
}
let angle = this.theta(p2) - this.theta(p1);
if (angle < 0) {
angle += 360;
}
return angle;
}
/**
* Returns the angle(in degrees) between the line from `(0,0)` and this point
* and the line from `(0,0)` to `p`.
*
* The function returns a value between `0` and `180` when the angle (in the
* direction from this point to `p`) is clockwise, and a value between `180`
* and `360` when the angle is counterclockwise. Returns `NaN` if called from
* point `(0,0)` or if `p` is `(0,0)`.
*/
vectorAngle(p) {
const zero = new Point(0, 0);
return zero.angleBetween(this, p);
}
/**
* Converts rectangular to polar coordinates.
*/
toPolar(origin) {
this.update(Point.toPolar(this, origin));
return this;
}
/**
* Returns the change in angle(in degrees) that is the result of moving the
* point from its previous position to its current position.
*
* More specifically, this function computes the angle between the line from
* the ref point to the previous position of this point(i.e. current position
* `-dx`, `-dy`) and the line from the `ref` point to the current position of
* this point.
*
* The function returns a positive value between `0` and `180` when the angle
* (in the direction from previous position of this point to its current
* position) is clockwise, and a negative value between `0` and `-180` when
* the angle is counterclockwise.
*
* The function returns `0` if the previous and current positions of this
* point are the same (i.e. both `dx` and `dy` are `0`).
*/
changeInAngle(dx, dy, ref = new Point()) {
// Revert the translation and measure the change in angle around x-axis.
return this.clone().translate(-dx, -dy).theta(ref) - this.theta(ref);
}
/**
* If the point lies outside the rectangle `rect`, adjust the point so that
* it becomes the nearest point on the boundary of `rect`.
*/
adhereToRect(rect) {
if (!(0, util_1.containsPoint)(rect, this)) {
this.x = Math.min(Math.max(this.x, rect.x), rect.x + rect.width);
this.y = Math.min(Math.max(this.y, rect.y), rect.y + rect.height);
}
return this;
}
/**
* Returns the bearing(cardinal direction) between me and the given point.
*
* @see https://en.wikipedia.org/wiki/Cardinal_direction
*/
bearing(p) {
const ref = Point.create(p);
const lat1 = Angle.toRad(this.y);
const lat2 = Angle.toRad(ref.y);
const lon1 = this.x;
const lon2 = ref.x;
const dLon = Angle.toRad(lon2 - lon1);
const y = Math.sin(dLon) * Math.cos(lat2);
const x = Math.cos(lat1) * Math.sin(lat2) -
Math.sin(lat1) * Math.cos(lat2) * Math.cos(dLon);
const brng = Angle.toDeg(Math.atan2(y, x));
const bearings = ['NE', 'E', 'SE', 'S', 'SW', 'W', 'NW', 'N'];
let index = brng - 22.5;
if (index < 0) {
index += 360;
}
index = parseInt((index / 45), 10);
return bearings[index];
}
/**
* Returns the cross product of the vector from me to `p1` and the vector
* from me to `p2`.
*
* The left-hand rule is used because the coordinate system is left-handed.
*/
cross(p1, p2) {
if (p1 != null && p2 != null) {
const a = Point.create(p1);
const b = Point.create(p2);
return (b.x - this.x) * (a.y - this.y) - (b.y - this.y) * (a.x - this.x);
}
return NaN;
}
/**
* Returns the dot product of this point with given other point.
*/
dot(p) {
const ref = Point.create(p);
return this.x * ref.x + this.y * ref.y;
}
diff(dx, dy) {
if (typeof dx === 'number') {
return new Point(this.x - dx, this.y - dy);
}
const p = Point.create(dx);
return new Point(this.x - p.x, this.y - p.y);
}
/**
* Returns an interpolation between me and point `p` for a parametert in
* the closed interval `[0, 1]`.
*/
lerp(p, t) {
const ref = Point.create(p);
return new Point((1 - t) * this.x + t * ref.x, (1 - t) * this.y + t * ref.y);
}
/**
* Normalize the point vector, scale the line segment between `(0, 0)`
* and the point in order for it to have the given length. If length is
* not specified, it is considered to be `1`; in that case, a unit vector
* is computed.
*/
normalize(length = 1) {
const scale = length / this.magnitude();
return this.scale(scale, scale);
}
/**
* Moves this point along the line starting from `ref` to this point by a
* certain `distance`.
*/
move(ref, distance) {
const p = Point.create(ref);
const rad = Angle.toRad(p.theta(this));
return this.translate(Math.cos(rad) * distance, -Math.sin(rad) * distance);
}
/**
* Returns a point that is the reflection of me with the center of inversion
* in `ref` point.
*/
reflection(ref) {
return Point.create(ref).move(this, this.distance(ref));
}
snapToGrid(gx, gy) {
this.x = (0, util_1.snapToGrid)(this.x, gx);
this.y = (0, util_1.snapToGrid)(this.y, gy == null ? gx : gy);
return this;
}
equals(p) {
const ref = Point.create(p);
return ref != null && ref.x === this.x && ref.y === this.y;
}
clone() {
return Point.clone(this);
}
/**
* Returns the point as a simple JSON object. For example: `{ x: 0, y: 0 }`.
*/
toJSON() {
return Point.toJSON(this);
}
serialize() {
return `${this.x} ${this.y}`;
}
}
exports.Point = Point;
//# sourceMappingURL=point.js.map