B
    Sc)                 @   s  d Z ddlmZ ddlmZ ddlZddlZdd ZefddZ	e
efd	d
Zdd Zdd Zdd Zdd Zdd Zdd Zdd Zdd Zdd Zdd Zdd  Zd!d" Zd#d$ ZG d%d& d&eZd-d(d)Zd*d+ Zed,krddlZddlZee  j! dS ).zTRoutines for calculating bounding boxes, point in rectangle calculations and
so on.
    )otRound)VectorNc             C   s@   | sdS dd | D }dd | D }t |t |t|t|fS )zCalculate 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)``.
    )r   r   r   r   c             S   s   g | ]\}}|qS  r   ).0xyr   r   8lib/python3.7/site-packages/fontTools/misc/arrayTools.py
<listcomp>   s    zcalcBounds.<locals>.<listcomp>c             S   s   g | ]\}}|qS r   r   )r   r   r   r   r   r   r	      s    )minmax)arrayZxsZysr   r   r   
calcBounds   s
    	r   c                s   t  fddt| D S )a  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)``.
    c             3   s   | ]} |V  qd S )Nr   )r   v)roundr   r   	<genexpr>)   s    z calcIntBounds.<locals>.<genexpr>)tupler   )r   r   r   )r   r   calcIntBounds   s    r   c       
      C   s8   |\}}| \}}}}	|||||||||||	|fS )aV  Add a point to a bounding rectangle.

    Args:
        bounds: A bounding rectangle expressed as a tuple
            ``(xMin, yMin, xMax, yMax)``.
        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)``.
    r   )
Zboundspr
   r   r   r   xMinyMinxMaxyMaxr   r   r   updateBounds,   s    r   c             C   sD   | \}}|\}}}}||  ko&|kn  oB||  ko>|kS   S )a'  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.
    r   )r   rectr   r   r   r   r   r   r   r   r   pointInRect<   s    r   c                s4   t | dk rg S |\  fdd| D S )a  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.
       c                s@   g | ]8\}}|  ko kn  o:|  ko6kn  qS r   r   )r   r   r   )r   r   r   r   r   r   r	   Y   s    z pointsInRect.<locals>.<listcomp>)len)r   r   r   )r   r   r   r   r   pointsInRectK   s    r   c             C   s   | \}}t |d |d  S )zCalculate the length of the given vector.

    Args:
        vector: A 2D tuple.

    Returns:
        The Euclidean length of the vector.
       )mathZsqrt)Zvectorr   r   r   r   r   vectorLength[   s    	r    c             C   s   dd | D S )zRound a list of floats to 16-bit signed integers.

    Args:
        array: List of float values.

    Returns:
        A list of rounded integers.
    c             S   s   g | ]}t t|d  qS )g      ?)intr   floor)r   ir   r   r   r	   p   s    zasInt16.<locals>.<listcomp>r   )r   r   r   r   asInt16g   s    	r$   c             C   s0   | \}}}}t ||t ||t||t||fS )aP  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.
    )r
   r   )r   r   r   r   r   r   r   r   normRects   s    r%   c             C   s(   | \}}}}|| || || || fS )a:  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.
    r   )r   r   r   r   r   r   r   r   r   r   	scaleRect   s    r&   c             C   s(   | \}}}}|| || || || fS )a@  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.
    r   )r   dxdyr   r   r   r   r   r   r   
offsetRect   s    r)   c             C   s(   | \}}}}|| || || || fS )aI  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.
    r   )r   r'   r(   r   r   r   r   r   r   r   	insetRect   s    r*   c             C   sh   | \}}}}|\}}}}	t ||t ||t||t||	f\}
}}}|
|ksT||krXdS d|
|||ffS )a  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.
    )F)r   r   r   r   T)r   r
   )rect1rect2xMin1yMin1xMax1yMax1xMin2yMin2xMax2yMax2r   r   r   r   r   r   r   sectRect   s    r5   c             C   sP   | \}}}}|\}}}}	t ||t ||t||t||	f\}
}}}|
|||fS )a0  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.
    )r
   r   )r+   r,   r-   r.   r/   r0   r1   r2   r3   r4   r   r   r   r   r   r   r   	unionRect   s
    r6   c             C   s$   | \}}}}|| d || d fS )zDetermine 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.
    r   r   )r   r   r   r   r   r   r   r   
rectCenter   s    
r7   c             C   s   | \}}}}|| ||  S )zDetermine rectangle area.

    Args:
        rect: Bounding rectangle, expressed as tuples
            ``(xMin, yMin, xMax, yMax)``.

    Returns:
        The area of the rectangle.
    r   )r   r   r   r   r   r   r   r   rectArea   s    
r8   c             C   sP   | \}}}}t t|}t t|}t t|}t t|}||||fS )a  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.
    )r!   r   r"   Zceil)r   r   r   r   r   r   r   r   intRect   s    r9   c               @   s   e Zd Zdd ZdS )r   c             O   s   t dt d S )NzffontTools.misc.arrayTools.Vector has been deprecated, please use fontTools.misc.vector.Vector instead.)warningswarnDeprecationWarning)selfargskwargsr   r   r   __init__
  s    zVector.__init__N)__name__
__module____qualname__r@   r   r   r   r   r     s   r   Fc             c   sV   | sdS |rt | }nt| }t|d}|}x|D ]}||fV  |}q2W ||fV  dS )a  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'))
    N)reversediternext)iterablereverseitfirstabr   r   r   pairwise  s    !



rM   c               C   s   dS )a  
    >>> 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)
    Nr   r   r   r   r   _testA  s    5rN   __main__)F)"__doc__ZfontTools.misc.roundToolsr   ZfontTools.misc.vectorr   Z_Vectorr   r:   r   r   r
   r   r   r   r   r    r$   r%   r&   r)   r*   r5   r6   r7   r8   r9   rM   rN   rA   sysZdoctestexitZtestmodZfailedr   r   r   r   <module>   s6   

/7
