
    h,                     B   S r SSKJr  SSKJr  SSKrSSKrS r\4S jr	\
\4S jrS rS	 rS
 rS rS rS rS rS rS rS rS rS rS rSS jr " S S\5      rSS jrS r\S:X  a4  SSKrSSKr\R@                  " \RB                  " 5       RD                  5        gg)zTRoutines for calculating bounding boxes, point in rectangle calculations and
so on.
    )otRound)VectorNc                     U (       d  gU  VVs/ s H  u  pUPM	     nnnU  VVs/ s H  u  pUPM	     nnn[        U5      [        U5      [        U5      [        U5      4$ s  snnf s  snnf )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   minmax)arrayxyxsyss        K/var/www/html/env/lib/python3.13/site-packages/fontTools/misc/arrayTools.py
calcBoundsr      s]     	!B		!B	r7CGSWc"g-- 
	s
   AA%c                 @   ^ [        U4S j[        U 5       5       5      $ )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   4   >#    U  H  nT" U5      v   M     g 7f)N ).0vrounds     r   	<genexpr> calcIntBounds.<locals>.<genexpr>*   s     5#4aq#4s   )tupler   )r
   r   s    `r   calcIntBoundsr      s     5:e#4555    c                 ^    Uu  pEU c  XEXE4$ U u  pgpU" Xd5      U" Xu5      U" X5      U" X5      4$ )a?  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)``.
r   )
boundspr   r	   r   r   xMinyMinxMaxyMaxs
             r   updateBoundsr#   -   sC     FQ~Qz#Dt<Ts4|S\AAr   c                 r    U u  p#Uu  pEpgXBs=:*  =(       a    U:*  Os  =(       a    XSs=:*  =(       a    U:*  $ 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"   s           r   pointInRectr&   @   s<     FQ!D6D$5$5$56$56r   c                     [        U 5      S:  a  / $ Uu  p#pEU  VVs/ s H4  u  pgX&s=:*  =(       a    U:*  Os  =(       a    X7s=:*  =(       a    U:*  Os  PM6     snn$ s  snnf )zDetermine 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.
   )len)r
   r%   r   r    r!   r"   r   r   s           r   pointsInRectr*   P   sV     5zA~	!DDIJEDAT$7T%6%6$%67EJJJs   ;Ac                 H    U u  p[         R                  " US-  US-  -   5      $ )z{Calculate the length of the given vector.

Args:
    vector: A 2D tuple.

Returns:
    The Euclidean length of the vector.
   )mathsqrt)vectorr   r   s      r   vectorLengthr0   a   s&     DA99QTAqD[!!r   c           	      r    U  Vs/ s H%  n[        [        R                  " US-   5      5      PM'     sn$ s  snf )zRound a list of floats to 16-bit signed integers.

Args:
    array: List of float values.

Returns:
    A list of rounded integers.
g      ?)intr-   floor)r
   is     r   asInt16r5   n   s.     /44eC

1s7#$e444s   ,4c                 `    U u  pp4[        X5      [        X$5      [        X5      [        X$5      4$ )a,  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"   s        r   normRectr8   z   s-      $Tt?COS_c$oMMr   c                 (    U u  p4pVX1-  XB-  XQ-  Xb-  4$ )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"   s          r   	scaleRectr:      s%      $T8TXtx11r   c                 (    U u  p4pVX1-   XB-   XQ-   Xb-   4$ )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"   s          r   
offsetRectr?      %      $T9diDI55r   c                 (    U u  p4pVX1-   XB-   XQ-
  Xb-
  4$ )a)  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<   s          r   	insetRectrB      r@   r   c                     U u  p#pEUu  pgp[        X&5      [        X75      [        XH5      [        XY5      4u  ppX:  d  X:  a  gSXX44$ )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.
)Fr   T)r	   r   rect1rect2xMin1yMin1xMax1yMax1xMin2yMin2xMax2yMax2r   r    r!   r"   s                 r   sectRectrO      sb     $) U5#( U5EEEE	D |t|"$d)))r   c                 x    U u  p#pEUu  pgp[        X&5      [        X75      [        XH5      [        XY5      4u  ppXX4$ )a  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   rD   s                 r   	unionRectrQ      sQ     $) U5#( U5EEEE	D ##r   c                 (    U u  pp4X-   S-  X$-   S-  4$ )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   r7   s        r   
rectCenterrS      s'      $TK1t{a///r   c                     U u  pp4XB-
  X1-
  -  $ )zDetermine rectangle area.

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

Returns:
    The area of the rectangle.
r   r7   s        r   rectArearU      s      $TKDK((r   c                    U u  pp4[        [        R                  " U5      5      n[        [        R                  " U5      5      n[        [        R                  " U5      5      n[        [        R                  " U5      5      nXX44$ )zRound 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.
)r2   r-   r3   ceilr7   s        r   intRectrX     sc      $Ttzz$ Dtzz$ DtyyDtyyD##r   c           	      d   US:  a  [        SU< 35      e[        U 5      u  p#pE[        [        R                  " X!-  5      U-  5      [        [        R                  " X1-  5      U-  5      [        [        R
                  " XA-  5      U-  5      [        [        R
                  " XQ-  5      U-  5      4$ )z
>>> 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)
r(   z*Expected quantization factor >= 1, found: )
ValueErrorr8   r2   r-   r3   rW   )r%   factorr   r    r!   r"   s         r   quantizeRectr\     s     zEfZPQQ%d^DDJJt}%./DJJt}%./DIIdm$v-.DIIdm$v-.	 r   c                       \ rS rSrS rSrg)r   i4  c                 :    [         R                  " S[        5        g )NzffontTools.misc.arrayTools.Vector has been deprecated, please use fontTools.misc.vector.Vector instead.)warningswarnDeprecationWarning)selfargskwargss      r   __init__Vector.__init__5  s    4	
r   r   N)__name__
__module____qualname____firstlineno__re   __static_attributes__r   r   r   r   r   4  s    
r   r   c              #      #    U (       d  gU(       a  [        U 5      nO[        U 5      n[        US5      nUnU H
  nXE4v   UnM     XC4v   g7f)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bs         r   pairwiserv   =  sT     B h(^TNEAf  *s   AAc                      g)aM  
>>> 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   _testrx   l  s    r   __main__)r(   )F)#__doc__fontTools.misc.roundToolsr   fontTools.misc.vectorr   _Vectorr-   r_   r   r   r   r	   r#   r&   r*   r0   r5   r8   r:   r?   rB   rO   rQ   rS   rU   rX   r\   rv   rx   rg   sysdoctestexittestmodfailedr   r   r   <module>r      s    . 3  .   ' 6$ !$ B&7 K"
"	5N&2 6 6 *6$.0)$(*
W 
,^5p zHHW__%%&	 r   