blob: e80d790f7e58fd98b6af15685ab0b13005259f9f [file] [log] [blame]
// Copyright (c) 2013, the Dart project authors. Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.
part of dart.math;
/// A base class for representing two-dimensional axis-aligned rectangles.
///
/// This rectangle uses a left-handed Cartesian coordinate system, with x
/// directed to the right and y directed down, as per the convention in 2D
/// computer graphics.
///
/// See also:
/// [W3C Coordinate Systems Specification](http://www.w3.org/TR/SVG/coords.html#InitialCoordinateSystem).
///
/// The rectangle is the set of points with representable coordinates greater
/// than or equal to left/top, and with distance to left/top no greater than
/// width/height (to the limit of the precision of the coordinates).
abstract class _RectangleBase<T extends num> {
const _RectangleBase();
/// The x-coordinate of the left edge.
T get left;
/// The y-coordinate of the top edge.
T get top;
/// The width of the rectangle.
T get width;
/// The height of the rectangle.
T get height;
/// The x-coordinate of the right edge.
T get right => (left + width) as T;
/// The y-coordinate of the bottom edge.
T get bottom => (top + height) as T;
String toString() {
return 'Rectangle ($left, $top) $width x $height';
}
bool operator ==(Object other) =>
other is Rectangle &&
left == other.left &&
top == other.top &&
right == other.right &&
bottom == other.bottom;
int get hashCode => SystemHash.hash4(
left.hashCode, top.hashCode, right.hashCode, bottom.hashCode);
/// Computes the intersection of `this` and [other].
///
/// The intersection of two axis-aligned rectangles, if any, is always another
/// axis-aligned rectangle.
///
/// Returns the intersection of this and `other`, or `null` if they don't
/// intersect.
Rectangle<T>? intersection(Rectangle<T> other) {
var x0 = max(left, other.left);
var x1 = min(left + width, other.left + other.width);
if (x0 <= x1) {
var y0 = max(top, other.top);
var y1 = min(top + height, other.top + other.height);
if (y0 <= y1) {
return Rectangle<T>(x0, y0, (x1 - x0) as T, (y1 - y0) as T);
}
}
return null;
}
/// Returns true if `this` intersects [other].
bool intersects(Rectangle<num> other) {
return (left <= other.left + other.width &&
other.left <= left + width &&
top <= other.top + other.height &&
other.top <= top + height);
}
/// Returns a new rectangle which completely contains `this` and [other].
Rectangle<T> boundingBox(Rectangle<T> other) {
var right = max(this.left + this.width, other.left + other.width);
var bottom = max(this.top + this.height, other.top + other.height);
var left = min(this.left, other.left);
var top = min(this.top, other.top);
return Rectangle<T>(left, top, (right - left) as T, (bottom - top) as T);
}
/// Tests whether `this` entirely contains [another].
bool containsRectangle(Rectangle<num> another) {
return left <= another.left &&
left + width >= another.left + another.width &&
top <= another.top &&
top + height >= another.top + another.height;
}
/// Tests whether [another] is inside or along the edges of `this`.
bool containsPoint(Point<num> another) {
return another.x >= left &&
another.x <= left + width &&
another.y >= top &&
another.y <= top + height;
}
Point<T> get topLeft => Point<T>(this.left, this.top);
Point<T> get topRight => Point<T>((this.left + this.width) as T, this.top);
Point<T> get bottomRight =>
Point<T>((this.left + this.width) as T, (this.top + this.height) as T);
Point<T> get bottomLeft => Point<T>(this.left, (this.top + this.height) as T);
}
/// A class for representing two-dimensional rectangles whose properties are
/// immutable.
class Rectangle<T extends num> extends _RectangleBase<T> {
final T left;
final T top;
final T width;
final T height;
/// Create a rectangle spanned by `(left, top)` and
/// `(left+width, top+height)`.
///
/// The rectangle contains the points
/// with x-coordinate between `left` and `left + width`, and
/// with y-coordinate between `top` and `top + height`, both inclusive.
///
/// The `width` and `height` should be non-negative.
/// If `width` or `height` are negative, they are clamped to zero.
///
/// If `width` and `height` are zero, the "rectangle" comprises only the
/// single point `(left, top)`.
const Rectangle(this.left, this.top, T width, T height)
: width = (width < 0)
? (-width * 0) as dynamic
: width, // Inline _clampToZero<num>.
height = (height < 0) ? (-height * 0) as dynamic : height;
/// Create a rectangle spanned by the points [a] and [b];
///
/// The rectangle contains the points
/// with x-coordinate between `a.x` and `b.x`, and
/// with y-coordinate between `a.y` and `b.y`, both inclusive.
///
/// If the distance between `a.x` and `b.x` is not representable
/// (which can happen if one or both is a double),
/// the actual right edge might be slightly off from `max(a.x, b.x)`.
/// Similar for the y-coordinates and the bottom edge.
factory Rectangle.fromPoints(Point<T> a, Point<T> b) {
T left = min(a.x, b.x);
T width = (max(a.x, b.x) - left) as T;
T top = min(a.y, b.y);
T height = (max(a.y, b.y) - top) as T;
return Rectangle<T>(left, top, width, height);
}
}
/// A class for representing two-dimensional axis-aligned rectangles with
/// mutable properties.
class MutableRectangle<T extends num> extends _RectangleBase<T>
implements Rectangle<T> {
/// The x-coordinate of the left edge.
///
/// Setting the value will move the rectangle without changing its width.
T left;
/// The y-coordinate of the left edge.
///
/// Setting the value will move the rectangle without changing its height.
T top;
T _width;
T _height;
/// Create a mutable rectangle spanned by `(left, top)` and
/// `(left+width, top+height)`.
///
/// The rectangle contains the points
/// with x-coordinate between `left` and `left + width`, and
/// with y-coordinate between `top` and `top + height`, both inclusive.
///
/// The `width` and `height` should be non-negative.
/// If `width` or `height` are negative, they are clamped to zero.
///
/// If `width` and `height` are zero, the "rectangle" comprises only the
/// single point `(left, top)`.
MutableRectangle(this.left, this.top, T width, T height)
: this._width = (width < 0) ? _clampToZero<T>(width) : width,
this._height = (height < 0) ? _clampToZero<T>(height) : height;
/// Create a mutable rectangle spanned by the points [a] and [b];
///
/// The rectangle contains the points
/// with x-coordinate between `a.x` and `b.x`, and
/// with y-coordinate between `a.y` and `b.y`, both inclusive.
///
/// If the distance between `a.x` and `b.x` is not representable
/// (which can happen if one or both is a double),
/// the actual right edge might be slightly off from `max(a.x, b.x)`.
/// Similar for the y-coordinates and the bottom edge.
factory MutableRectangle.fromPoints(Point<T> a, Point<T> b) {
T left = min(a.x, b.x);
T width = (max(a.x, b.x) - left) as T;
T top = min(a.y, b.y);
T height = (max(a.y, b.y) - top) as T;
return MutableRectangle<T>(left, top, width, height);
}
T get width => _width;
/// Sets the width of the rectangle.
///
/// The width must be non-negative.
/// If a negative width is supplied, it is clamped to zero.
///
/// Setting the value will change the right edge of the rectangle,
/// but will not change [left].
set width(T width) {
if (width < 0) width = _clampToZero<T>(width);
_width = width;
}
T get height => _height;
/// Sets the height of the rectangle.
///
/// The height must be non-negative.
/// If a negative height is supplied, it is clamped to zero.
///
/// Setting the value will change the bottom edge of the rectangle,
/// but will not change [top].
set height(T height) {
if (height < 0) height = _clampToZero<T>(height);
_height = height;
}
}
/// Converts a negative [int] or [double] to a zero-value of the same type.
///
/// Returns `0` if value is int, `0.0` if value is double.
T _clampToZero<T extends num>(T value) {
assert(value < 0);
return (-value * 0) as T;
}