|
|
import 'dart:math' as math;
|
|
|
|
|
|
import 'package:vector_math/vector_math_64.dart';
|
|
|
|
|
|
/// Calculates all [Vector2]s of a circumference.
|
|
|
///
|
|
|
/// A circumference can be achieved by specifying a [center] and a [radius].
|
|
|
/// In addition, a semi-circle can be achieved by specifying its [angle] and an
|
|
|
/// [offsetAngle] (both in radians).
|
|
|
///
|
|
|
/// The higher the [precision], the more [Vector2]s will be calculated;
|
|
|
/// achieving a more rounded arc.
|
|
|
///
|
|
|
/// For more information read: https://en.wikipedia.org/wiki/Trigonometric_functions.
|
|
|
List<Vector2> calculateArc({
|
|
|
required Vector2 center,
|
|
|
required double radius,
|
|
|
required double angle,
|
|
|
double offsetAngle = 0,
|
|
|
int precision = 100,
|
|
|
}) {
|
|
|
final stepAngle = angle / (precision - 1);
|
|
|
|
|
|
final points = <Vector2>[];
|
|
|
for (var i = 0; i < precision; i++) {
|
|
|
final x = center.x + radius * math.cos((stepAngle * i) + offsetAngle);
|
|
|
final y = center.y - radius * math.sin((stepAngle * i) + offsetAngle);
|
|
|
|
|
|
final point = Vector2(x, y);
|
|
|
points.add(point);
|
|
|
}
|
|
|
|
|
|
return points;
|
|
|
}
|
|
|
|
|
|
/// Calculates all [Vector2]s of an ellipse.
|
|
|
///
|
|
|
/// An ellipse can be achieved by specifying a [center], a [majorRadius] and a
|
|
|
/// [minorRadius].
|
|
|
///
|
|
|
/// The higher the [precision], the more [Vector2]s will be calculated;
|
|
|
/// achieving a more rounded ellipse.
|
|
|
///
|
|
|
/// For more information read: https://en.wikipedia.org/wiki/Ellipse.
|
|
|
List<Vector2> calculateEllipse({
|
|
|
required Vector2 center,
|
|
|
required double majorRadius,
|
|
|
required double minorRadius,
|
|
|
int precision = 100,
|
|
|
}) {
|
|
|
assert(
|
|
|
0 < minorRadius && minorRadius <= majorRadius,
|
|
|
'smallRadius ($minorRadius) and bigRadius ($majorRadius) must be in '
|
|
|
'range 0 < smallRadius <= bigRadius',
|
|
|
);
|
|
|
|
|
|
final stepAngle = 2 * math.pi / (precision - 1);
|
|
|
|
|
|
final points = <Vector2>[];
|
|
|
for (var i = 0; i < precision; i++) {
|
|
|
final x = center.x + minorRadius * math.cos(stepAngle * i);
|
|
|
final y = center.y - majorRadius * math.sin(stepAngle * i);
|
|
|
|
|
|
final point = Vector2(x, y);
|
|
|
points.add(point);
|
|
|
}
|
|
|
|
|
|
return points;
|
|
|
}
|
|
|
|
|
|
/// Calculates all [Vector2]s of a bezier curve.
|
|
|
///
|
|
|
/// A bezier curve of [controlPoints] that say how to create this curve.
|
|
|
///
|
|
|
/// First and last points specify the beginning and the end respectively
|
|
|
/// of the curve. The inner points specify the shape of the curve and
|
|
|
/// its turning points.
|
|
|
///
|
|
|
/// The [step] must be between zero and one (inclusive), indicating the
|
|
|
/// precision to calculate the curve.
|
|
|
///
|
|
|
/// For more information read: https://en.wikipedia.org/wiki/B%C3%A9zier_curve
|
|
|
List<Vector2> calculateBezierCurve({
|
|
|
required List<Vector2> controlPoints,
|
|
|
double step = 0.01,
|
|
|
}) {
|
|
|
assert(
|
|
|
0 <= step && step <= 1,
|
|
|
'Step ($step) must be in range 0 <= step <= 1',
|
|
|
);
|
|
|
assert(
|
|
|
controlPoints.length >= 2,
|
|
|
'At least 2 control points needed to create a bezier curve',
|
|
|
);
|
|
|
|
|
|
var t = 0.0;
|
|
|
final n = controlPoints.length - 1;
|
|
|
final points = <Vector2>[];
|
|
|
|
|
|
do {
|
|
|
var x = 0.0;
|
|
|
var y = 0.0;
|
|
|
for (var i = 0; i <= n; i++) {
|
|
|
final point = controlPoints[i];
|
|
|
|
|
|
x += binomial(n, i) * math.pow(1 - t, n - i) * math.pow(t, i) * point.x;
|
|
|
y += binomial(n, i) * math.pow(1 - t, n - i) * math.pow(t, i) * point.y;
|
|
|
}
|
|
|
points.add(Vector2(x, y));
|
|
|
|
|
|
t = t + step;
|
|
|
} while (t <= 1);
|
|
|
|
|
|
return points;
|
|
|
}
|
|
|
|
|
|
/// Calculates the binomial coefficient of 'n' and 'k'.
|
|
|
///
|
|
|
/// For more information read: https://en.wikipedia.org/wiki/Binomial_coefficient
|
|
|
num binomial(num n, num k) {
|
|
|
assert(0 <= k && k <= n, 'k ($k) and n ($n) must be in range 0 <= k <= n');
|
|
|
|
|
|
if (k == 0 || n == k) {
|
|
|
return 1;
|
|
|
} else {
|
|
|
return factorial(n) / (factorial(k) * factorial(n - k));
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/// Calculate the factorial of 'n'.
|
|
|
///
|
|
|
/// For more information read: https://en.wikipedia.org/wiki/Factorial
|
|
|
num factorial(num n) {
|
|
|
assert(n >= 0, 'Factorial is not defined for negative number n ($n)');
|
|
|
|
|
|
if (n == 0 || n == 1) {
|
|
|
return 1;
|
|
|
} else {
|
|
|
return n * factorial(n - 1);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/// Arithmetic mean position of all the [Vector2]s in a polygon.
|
|
|
///
|
|
|
/// For more information read: https://en.wikipedia.org/wiki/Centroid
|
|
|
Vector2 centroid(List<Vector2> vertices) {
|
|
|
assert(vertices.isNotEmpty, 'Vertices must not be empty');
|
|
|
final sum = vertices.reduce((a, b) => a + b);
|
|
|
return sum / vertices.length.toDouble();
|
|
|
}
|
