| """Routines for calculating bounding boxes, point in rectangle calculations and | |
| so on. | |
| """ | |
| from fontTools.misc.roundTools import otRound | |
| from fontTools.misc.vector import Vector as _Vector | |
| import math | |
| import warnings | |
| def calcBounds(array): | |
| """Calculate the bounding rectangle of a 2D points array. | |
| Args: | |
| array: A sequence of 2D tuples. | |
| Returns: | |
| A four-item tuple representing the bounding rectangle ``(xMin, yMin, xMax, yMax)``. | |
| """ | |
| if not array: | |
| return 0, 0, 0, 0 | |
| xs = [x for x, y in array] | |
| ys = [y for x, y in array] | |
| return min(xs), min(ys), max(xs), max(ys) | |
| def calcIntBounds(array, round=otRound): | |
| """Calculate the integer bounding rectangle of a 2D points array. | |
| Values are rounded to closest integer towards ``+Infinity`` using the | |
| :func:`fontTools.misc.fixedTools.otRound` function by default, unless | |
| an optional ``round`` function is passed. | |
| Args: | |
| array: A sequence of 2D tuples. | |
| round: A rounding function of type ``f(x: float) -> int``. | |
| Returns: | |
| A four-item tuple of integers representing the bounding rectangle: | |
| ``(xMin, yMin, xMax, yMax)``. | |
| """ | |
| return tuple(round(v) for v in calcBounds(array)) | |
| def updateBounds(bounds, p, min=min, max=max): | |
| """Add a point to a bounding rectangle. | |
| Args: | |
| bounds: A bounding rectangle expressed as a tuple | |
| ``(xMin, yMin, xMax, yMax), or None``. | |
| p: A 2D tuple representing a point. | |
| min,max: functions to compute the minimum and maximum. | |
| Returns: | |
| The updated bounding rectangle ``(xMin, yMin, xMax, yMax)``. | |
| """ | |
| (x, y) = p | |
| if bounds is None: | |
| return x, y, x, y | |
| xMin, yMin, xMax, yMax = bounds | |
| return min(xMin, x), min(yMin, y), max(xMax, x), max(yMax, y) | |
| def pointInRect(p, rect): | |
| """Test if a point is inside a bounding rectangle. | |
| Args: | |
| p: A 2D tuple representing a point. | |
| rect: A bounding rectangle expressed as a tuple | |
| ``(xMin, yMin, xMax, yMax)``. | |
| Returns: | |
| ``True`` if the point is inside the rectangle, ``False`` otherwise. | |
| """ | |
| (x, y) = p | |
| xMin, yMin, xMax, yMax = rect | |
| return (xMin <= x <= xMax) and (yMin <= y <= yMax) | |
| def pointsInRect(array, rect): | |
| """Determine which points are inside a bounding rectangle. | |
| Args: | |
| array: A sequence of 2D tuples. | |
| rect: A bounding rectangle expressed as a tuple | |
| ``(xMin, yMin, xMax, yMax)``. | |
| Returns: | |
| A list containing the points inside the rectangle. | |
| """ | |
| if len(array) < 1: | |
| return [] | |
| xMin, yMin, xMax, yMax = rect | |
| return [(xMin <= x <= xMax) and (yMin <= y <= yMax) for x, y in array] | |
| def vectorLength(vector): | |
| """Calculate the length of the given vector. | |
| Args: | |
| vector: A 2D tuple. | |
| Returns: | |
| The Euclidean length of the vector. | |
| """ | |
| x, y = vector | |
| return math.sqrt(x**2 + y**2) | |
| def asInt16(array): | |
| """Round a list of floats to 16-bit signed integers. | |
| Args: | |
| array: List of float values. | |
| Returns: | |
| A list of rounded integers. | |
| """ | |
| return [int(math.floor(i + 0.5)) for i in array] | |
| def normRect(rect): | |
| """Normalize a bounding box rectangle. | |
| This function "turns the rectangle the right way up", so that the following | |
| holds:: | |
| xMin <= xMax and yMin <= yMax | |
| Args: | |
| rect: A bounding rectangle expressed as a tuple | |
| ``(xMin, yMin, xMax, yMax)``. | |
| Returns: | |
| A normalized bounding rectangle. | |
| """ | |
| (xMin, yMin, xMax, yMax) = rect | |
| return min(xMin, xMax), min(yMin, yMax), max(xMin, xMax), max(yMin, yMax) | |
| def scaleRect(rect, x, y): | |
| """Scale a bounding box rectangle. | |
| Args: | |
| rect: A bounding rectangle expressed as a tuple | |
| ``(xMin, yMin, xMax, yMax)``. | |
| x: Factor to scale the rectangle along the X axis. | |
| Y: Factor to scale the rectangle along the Y axis. | |
| Returns: | |
| A scaled bounding rectangle. | |
| """ | |
| (xMin, yMin, xMax, yMax) = rect | |
| return xMin * x, yMin * y, xMax * x, yMax * y | |
| def offsetRect(rect, dx, dy): | |
| """Offset a bounding box rectangle. | |
| Args: | |
| rect: A bounding rectangle expressed as a tuple | |
| ``(xMin, yMin, xMax, yMax)``. | |
| dx: Amount to offset the rectangle along the X axis. | |
| dY: Amount to offset the rectangle along the Y axis. | |
| Returns: | |
| An offset bounding rectangle. | |
| """ | |
| (xMin, yMin, xMax, yMax) = rect | |
| return xMin + dx, yMin + dy, xMax + dx, yMax + dy | |
| def insetRect(rect, dx, dy): | |
| """Inset a bounding box rectangle on all sides. | |
| Args: | |
| rect: A bounding rectangle expressed as a tuple | |
| ``(xMin, yMin, xMax, yMax)``. | |
| dx: Amount to inset the rectangle along the X axis. | |
| dY: Amount to inset the rectangle along the Y axis. | |
| Returns: | |
| An inset bounding rectangle. | |
| """ | |
| (xMin, yMin, xMax, yMax) = rect | |
| return xMin + dx, yMin + dy, xMax - dx, yMax - dy | |
| def sectRect(rect1, rect2): | |
| """Test for rectangle-rectangle intersection. | |
| Args: | |
| rect1: First bounding rectangle, expressed as tuples | |
| ``(xMin, yMin, xMax, yMax)``. | |
| rect2: Second bounding rectangle. | |
| Returns: | |
| A boolean and a rectangle. | |
| If the input rectangles intersect, returns ``True`` and the intersecting | |
| rectangle. Returns ``False`` and ``(0, 0, 0, 0)`` if the input | |
| rectangles don't intersect. | |
| """ | |
| (xMin1, yMin1, xMax1, yMax1) = rect1 | |
| (xMin2, yMin2, xMax2, yMax2) = rect2 | |
| xMin, yMin, xMax, yMax = ( | |
| max(xMin1, xMin2), | |
| max(yMin1, yMin2), | |
| min(xMax1, xMax2), | |
| min(yMax1, yMax2), | |
| ) | |
| if xMin >= xMax or yMin >= yMax: | |
| return False, (0, 0, 0, 0) | |
| return True, (xMin, yMin, xMax, yMax) | |
| def unionRect(rect1, rect2): | |
| """Determine union of bounding rectangles. | |
| Args: | |
| rect1: First bounding rectangle, expressed as tuples | |
| ``(xMin, yMin, xMax, yMax)``. | |
| rect2: Second bounding rectangle. | |
| Returns: | |
| The smallest rectangle in which both input rectangles are fully | |
| enclosed. | |
| """ | |
| (xMin1, yMin1, xMax1, yMax1) = rect1 | |
| (xMin2, yMin2, xMax2, yMax2) = rect2 | |
| xMin, yMin, xMax, yMax = ( | |
| min(xMin1, xMin2), | |
| min(yMin1, yMin2), | |
| max(xMax1, xMax2), | |
| max(yMax1, yMax2), | |
| ) | |
| return (xMin, yMin, xMax, yMax) | |
| def rectCenter(rect): | |
| """Determine rectangle center. | |
| Args: | |
| rect: Bounding rectangle, expressed as tuples | |
| ``(xMin, yMin, xMax, yMax)``. | |
| Returns: | |
| A 2D tuple representing the point at the center of the rectangle. | |
| """ | |
| (xMin, yMin, xMax, yMax) = rect | |
| return (xMin + xMax) / 2, (yMin + yMax) / 2 | |
| def rectArea(rect): | |
| """Determine rectangle area. | |
| Args: | |
| rect: Bounding rectangle, expressed as tuples | |
| ``(xMin, yMin, xMax, yMax)``. | |
| Returns: | |
| The area of the rectangle. | |
| """ | |
| (xMin, yMin, xMax, yMax) = rect | |
| return (yMax - yMin) * (xMax - xMin) | |
| def intRect(rect): | |
| """Round a rectangle to integer values. | |
| Guarantees that the resulting rectangle is NOT smaller than the original. | |
| Args: | |
| rect: Bounding rectangle, expressed as tuples | |
| ``(xMin, yMin, xMax, yMax)``. | |
| Returns: | |
| A rounded bounding rectangle. | |
| """ | |
| (xMin, yMin, xMax, yMax) = rect | |
| xMin = int(math.floor(xMin)) | |
| yMin = int(math.floor(yMin)) | |
| xMax = int(math.ceil(xMax)) | |
| yMax = int(math.ceil(yMax)) | |
| return (xMin, yMin, xMax, yMax) | |
| def quantizeRect(rect, factor=1): | |
| """ | |
| >>> bounds = (72.3, -218.4, 1201.3, 919.1) | |
| >>> quantizeRect(bounds) | |
| (72, -219, 1202, 920) | |
| >>> quantizeRect(bounds, factor=10) | |
| (70, -220, 1210, 920) | |
| >>> quantizeRect(bounds, factor=100) | |
| (0, -300, 1300, 1000) | |
| """ | |
| if factor < 1: | |
| raise ValueError(f"Expected quantization factor >= 1, found: {factor!r}") | |
| xMin, yMin, xMax, yMax = normRect(rect) | |
| return ( | |
| int(math.floor(xMin / factor) * factor), | |
| int(math.floor(yMin / factor) * factor), | |
| int(math.ceil(xMax / factor) * factor), | |
| int(math.ceil(yMax / factor) * factor), | |
| ) | |
| class Vector(_Vector): | |
| def __init__(self, *args, **kwargs): | |
| warnings.warn( | |
| "fontTools.misc.arrayTools.Vector has been deprecated, please use " | |
| "fontTools.misc.vector.Vector instead.", | |
| DeprecationWarning, | |
| ) | |
| def pairwise(iterable, reverse=False): | |
| """Iterate over current and next items in iterable. | |
| Args: | |
| iterable: An iterable | |
| reverse: If true, iterate in reverse order. | |
| Returns: | |
| A iterable yielding two elements per iteration. | |
| Example: | |
| >>> tuple(pairwise([])) | |
| () | |
| >>> tuple(pairwise([], reverse=True)) | |
| () | |
| >>> tuple(pairwise([0])) | |
| ((0, 0),) | |
| >>> tuple(pairwise([0], reverse=True)) | |
| ((0, 0),) | |
| >>> tuple(pairwise([0, 1])) | |
| ((0, 1), (1, 0)) | |
| >>> tuple(pairwise([0, 1], reverse=True)) | |
| ((1, 0), (0, 1)) | |
| >>> tuple(pairwise([0, 1, 2])) | |
| ((0, 1), (1, 2), (2, 0)) | |
| >>> tuple(pairwise([0, 1, 2], reverse=True)) | |
| ((2, 1), (1, 0), (0, 2)) | |
| >>> tuple(pairwise(['a', 'b', 'c', 'd'])) | |
| (('a', 'b'), ('b', 'c'), ('c', 'd'), ('d', 'a')) | |
| >>> tuple(pairwise(['a', 'b', 'c', 'd'], reverse=True)) | |
| (('d', 'c'), ('c', 'b'), ('b', 'a'), ('a', 'd')) | |
| """ | |
| if not iterable: | |
| return | |
| if reverse: | |
| it = reversed(iterable) | |
| else: | |
| it = iter(iterable) | |
| first = next(it, None) | |
| a = first | |
| for b in it: | |
| yield (a, b) | |
| a = b | |
| yield (a, first) | |
| def _test(): | |
| """ | |
| >>> import math | |
| >>> calcBounds([]) | |
| (0, 0, 0, 0) | |
| >>> calcBounds([(0, 40), (0, 100), (50, 50), (80, 10)]) | |
| (0, 10, 80, 100) | |
| >>> updateBounds((0, 0, 0, 0), (100, 100)) | |
| (0, 0, 100, 100) | |
| >>> pointInRect((50, 50), (0, 0, 100, 100)) | |
| True | |
| >>> pointInRect((0, 0), (0, 0, 100, 100)) | |
| True | |
| >>> pointInRect((100, 100), (0, 0, 100, 100)) | |
| True | |
| >>> not pointInRect((101, 100), (0, 0, 100, 100)) | |
| True | |
| >>> list(pointsInRect([(50, 50), (0, 0), (100, 100), (101, 100)], (0, 0, 100, 100))) | |
| [True, True, True, False] | |
| >>> vectorLength((3, 4)) | |
| 5.0 | |
| >>> vectorLength((1, 1)) == math.sqrt(2) | |
| True | |
| >>> list(asInt16([0, 0.1, 0.5, 0.9])) | |
| [0, 0, 1, 1] | |
| >>> normRect((0, 10, 100, 200)) | |
| (0, 10, 100, 200) | |
| >>> normRect((100, 200, 0, 10)) | |
| (0, 10, 100, 200) | |
| >>> scaleRect((10, 20, 50, 150), 1.5, 2) | |
| (15.0, 40, 75.0, 300) | |
| >>> offsetRect((10, 20, 30, 40), 5, 6) | |
| (15, 26, 35, 46) | |
| >>> insetRect((10, 20, 50, 60), 5, 10) | |
| (15, 30, 45, 50) | |
| >>> insetRect((10, 20, 50, 60), -5, -10) | |
| (5, 10, 55, 70) | |
| >>> intersects, rect = sectRect((0, 10, 20, 30), (0, 40, 20, 50)) | |
| >>> not intersects | |
| True | |
| >>> intersects, rect = sectRect((0, 10, 20, 30), (5, 20, 35, 50)) | |
| >>> intersects | |
| 1 | |
| >>> rect | |
| (5, 20, 20, 30) | |
| >>> unionRect((0, 10, 20, 30), (0, 40, 20, 50)) | |
| (0, 10, 20, 50) | |
| >>> rectCenter((0, 0, 100, 200)) | |
| (50.0, 100.0) | |
| >>> rectCenter((0, 0, 100, 199.0)) | |
| (50.0, 99.5) | |
| >>> intRect((0.9, 2.9, 3.1, 4.1)) | |
| (0, 2, 4, 5) | |
| """ | |
| if __name__ == "__main__": | |
| import sys | |
| import doctest | |
| sys.exit(doctest.testmod().failed) | |