h{XSrSSKrSSKrSSKrSSKrSSKrSSKrSSKrSSK J r SSK J r SSK JrJrJr SSKJr SrS r"S S 5r"S S \5r\R."\R0\R0/5r"SS\5r"SS\5r"SS\5r"SS\5r"SS\5r"SS\5r"SS\5r "SS\ 5r!"SS\ 5r""S S!5r#"S"S#\#\5r$"S$S%\#\ 5r%S&r&"S'S(\5r'"S)S*\ 5r(S+r)"S,S-\ 5r*"S.S/\ 5r+\ RX"S05"S1S2\+55r-"S3S4\ 5r."S5S6\ 5r/"S7S8\ 5r0"S9S:\ 5r1"S;S<\5r2"S=S>\25r3SDS?jr4S@r5SESAjr6SBr7SFSCjr8g)GaT Matplotlib includes a framework for arbitrary geometric transformations that is used to determine the final position of all elements drawn on the canvas. Transforms are composed into trees of `TransformNode` objects whose actual value depends on their children. When the contents of children change, their parents are automatically invalidated. The next time an invalidated transform is accessed, it is recomputed to reflect those changes. This invalidation/caching approach prevents unnecessary recomputations of transforms, and contributes to better interactive performance. For example, here is a graph of the transform tree used to plot data to the figure: .. graphviz:: /api/transforms.dot :alt: Diagram of transform tree from data to figure coordinates. The framework can be used for both affine and non-affine transformations. However, for speed, we want to use the backend renderers to perform affine transformations whenever possible. Therefore, it is possible to perform just the affine or non-affine part of a transformation on a set of data. The affine is always assumed to occur after the non-affine. For any transform:: full transform == non-affine part + affine part The backends are not expected to handle non-affine transformations themselves. See the tutorial :ref:`transforms_tutorial` for examples of how to use transforms. N)inv)_api)affine_transformcount_bboxes_overlapping_bboxupdate_path_extents)PathFch^^^^[R"[RSS9mSmUUUU4Sj$)a Generate a ``__str__`` method for a `.Transform` subclass. After :: class T: __str__ = _make_str_method("attr", key="other") ``str(T(...))`` will be .. code-block:: text {type(T).__name__}( {self.attr}, key={self.other}) z )prefixcX[U[5(a [U5$[U5$N) isinstancestrrepr)xs G/var/www/html/env/lib/python3.13/site-packages/matplotlib/transforms.pystrrepr!_make_str_method..strreprJs jC&8&847Dc!fDc>^[T5RS-SR/UUU4SjT5QUUU4SjTR55Q5-S-$)N(,c 3Z># UH nT"ST"[TU55-5v M" g7f) Ngetattr).0argindentselfrs r 5_make_str_method....Ms1'!%#TGGD#,>$??@@!%s(+c 3j># UH(upT"SU-S-T"[TU55-5v M* g7f)r=Nr)rkrrr rs rr!r"Os;4$2&!TAX^ggdC6H.IIJJ$2s03))type__name__joinitems)r argsrkwargsrs`r"_make_str_method..Ks_ T c! ((5'!%'54$*LLN45 6 6   r) functoolspartialtextwrapr)r+r,rrs``@@r_make_str_methodr28s("  xw ?FD rc^\rSrSrSr\"S5urrrSr \ R"S5"\ R"S55r SrSSjr\(aSrS rS rU4S jrS rS rSrSrSrU=r$) TransformNodeTa The base class for anything that participates in the transform tree and needs to invalidate its parents or be invalidated. This includes classes that are not really transforms, such as bounding boxes, since some transforms depend on bounding boxes to compute their values. F3.9cgNFclss rr-TransformNode.fsErcT0UlURUlU=(d SUlg)z Parameters ---------- shorthand_name : str A string representing the "name" of the transform. The name carries no significance other than to improve the readability of ``str(transform)`` when DEBUG=True. N)_parents _INVALID_FULL_invalid_shorthand_name)r shorthand_names r__init__TransformNode.__init__ns% ** -3rc>UR=(d [U5$r )rCrr s r__str__TransformNode.__str__}s''54: 5rc 0URESURR5VVs0sH upX"5_M snn0E$s snnf)Nr@)__dict__r@r*)r r%vs r __getstate__TransformNode.__getstate__sNH$--H 0C0C0EF0EQV0EFH HFsA c XlURR5VVs0sH:up#UcM U[R"X0RR U4Sj5_M< snnUlgs snnf)NcU"U5$r r:_popr%s rr-,TransformNode.__setstate__..sCFr)rLr@r*weakrefrefrT)r data_dictr%rMs r __setstate__TransformNode.__setstate__sa!  ++-@- LAw{{1MM,=,=JK K-@ @s A/4A/c>[R"[55n0Ul[U5R 5HHup#[ U[ 5(dM[U5UR;dM7URU5 MJ U$r ) copysuperr@varsr*rr4id set_children)r otherkeyval __class__s r__copy__TransformNode.__copy__sh %'"T ((*HC#}--"T(cll2J""3'+ rcvURUR(aURUS9$URUS9$)z Invalidate this `TransformNode` and triggers an invalidation of its ancestors. Should be called any time the transform changes. levelinvalidating_node)_invalidate_internal is_affine_INVALID_AFFINE_ONLYrArHs r invalidateTransformNode.invalidatesI ((/3~~$++")$ $CGCUCU")$ $rcXR::aUR(dgXl[URR 55HnU"5nUcMUR XS9 M g)z Called by :meth:`invalidate` and subsequently ascends the transform stack calling each TransformNode's _invalidate_internal method. Nrh)rB pass_throughlistr@valuesrk)r rirjparents rrk"TransformNode._invalidate_internalsX MM !$*;*;  4==//12FXF!++%+P3rc[U5nUH@n[R"XRRU4Sj5nXCRU'MB g)z Set the children of the transform, to let the invalidation system know which transforms can invalidate this transform. Should be called from the constructor of any transforms that depend on other transforms. cU"U5$r r:rRs rr-,TransformNode.set_children..s3q6rN)r_rVrWr@rT)r childrenid_selfchildrWs rr`TransformNode.set_childrensFT(E++NN$6$6'IKC&)NN7 # rcU$)z Return a frozen copy of this transform node. The frozen copy will not be updated when its children change. Useful for storing a previously known state of a transform where ``copy.deepcopy()`` might normally be used. r:rHs rfrozenTransformNode.frozens  r)rLrBr@rCr )r( __module__ __qualname____firstlineno____doc__range_VALIDrmrArlr deprecated classpropertyis_bboxrqrEDEBUGrIrNrYrernrkr`r~__static_attributes__ __classcell__rds@rr4r4Ts38(/F -Iooe$T%7%78I%JKGL 4  6H @ $ Q*&rr4c \rSrSrSr\R "S5"\R"S55rSr \ (a\ S5r Sr \R\ lSr\S 5r\S 5r\S 5r\S 5r\S 5r\S5r\S5r\S5r\S5r\S5r\S5r\S5r\S5r\S5r\S5r\S5r \S5r!\S5r"\S5r#Sr$Sr%Sr&Sr'S r(S!r)S"r*S#r+S$r,S%r-S&S'S(S)S*S+S,S-S.S/. r.S0r/S1r0S@S3jr1S4r2S5r3S6r4S7r5S8r6SAS9jr7S:r8S;r9S<r:\ S=5r;\ S>5rsDrTc$[U[RR5(a[R "S5 [R "U5n[USSS24USSS24- S:H5(a[R "S5 gg)NzBbox bounds are a masked array.rrzSingular Bbox.)rnpma MaskedArrayr warn_externalasarrayany)pointss r_checkBboxBase._checkso&"%%"3"344""#DEZZ'FF1a4L6!Q$</A566""#347rcP[UR5R55$r )Bbox get_pointsr\rHs rr~BboxBase.frozensDOO%**,--rc"UR5$r rr r+r,s r __array__BboxBase.__array__s  rc(UR5S$)z The first of the pair of *x* coordinates that define the bounding box. This is not guaranteed to be less than :attr:`x1` (for that, use :attr:`xmin`). rrrrHs rx0 BboxBase.x0 &&rc(UR5S$)z The first of the pair of *y* coordinates that define the bounding box. This is not guaranteed to be less than :attr:`y1` (for that, use :attr:`ymin`). rrrrHs ry0 BboxBase.y0rrc(UR5S$)z The second of the pair of *x* coordinates that define the bounding box. This is not guaranteed to be greater than :attr:`x0` (for that, use :attr:`xmax`). rrrrHs rx1 BboxBase.x1rrc(UR5S$)z The second of the pair of *y* coordinates that define the bounding box. This is not guaranteed to be greater than :attr:`y0` (for that, use :attr:`ymax`). rrrrHs ry1 BboxBase.y1 rrc(UR5S$)z The first pair of (*x*, *y*) coordinates that define the bounding box. This is not guaranteed to be the bottom-left corner (for that, use :attr:`min`). rrrHs rp0 BboxBase.p0 ##rc(UR5S$)z The second pair of (*x*, *y*) coordinates that define the bounding box. This is not guaranteed to be the top-right corner (for that, use :attr:`max`). rrrHs rp1 BboxBase.p1!rrcX[R"UR5SS2S45$)z"The left edge of the bounding box.NrrminrrHs rxmin BboxBase.xmin+#vvdoo'1-..rcX[R"UR5SS2S45$)z$The bottom edge of the bounding box.NrrrHs rymin BboxBase.ymin0rrcX[R"UR5SS2S45$)z#The right edge of the bounding box.NrrmaxrrHs rxmax BboxBase.xmax5rrcX[R"UR5SS2S45$)z!The top edge of the bounding box.NrrrHs rymax BboxBase.ymax:rrcH[R"UR5SS9$)z+The bottom-left corner of the bounding box.raxisrrHs rr BboxBase.min?vvdoo'a00rcH[R"UR5SS9$)z)The top-right corner of the bounding box.rrrrHs rr BboxBase.maxDrrc0UR5SS2S4$)zt The pair of *x* coordinates that define the bounding box. This is not guaranteed to be sorted from left to right. NrrrHs r intervalxBboxBase.intervalxI A&&rc0UR5SS2S4$)zt The pair of *y* coordinates that define the bounding box. This is not guaranteed to be sorted from bottom to top. NrrrHs r intervalyBboxBase.intervalyRrrc8UR5nUSUS- $)z'The (signed) width of the bounding box.rrrr rs rwidthBboxBase.width[#"d|fTl**rc8UR5nUSUS- $)z(The (signed) height of the bounding box.rrrrs rheightBboxBase.heightarrc8UR5nUSUS- $)z2The (signed) width and height of the bounding box.rrrrs rsize BboxBase.sizegs#"ay6!9$$rcBUR5uupup4XX1- XB- 4$)z?Return (:attr:`x0`, :attr:`y0`, :attr:`width`, :attr:`height`).rr rrrrs rboundsBboxBase.boundsms*"__.(2))rc>UR5R5$)z8Return (:attr:`x0`, :attr:`y0`, :attr:`x1`, :attr:`y1`).)rflattenrHs rextentsBboxBase.extentsss ((**rc[er NotImplementedErrorrHs rrBboxBase.get_pointsxs!!rc|URup#X!s=:*=(a U:*Os =(d X!s=:=(a U:$s $)zH Return whether *x* is in the closed (:attr:`x0`, :attr:`x1`) interval. rr rrrs r containsxBboxBase.containsx{/}}"}- 2 - -rc|URup#X!s=:*=(a U:*Os =(d X!s=:=(a U:$s $)zH Return whether *y* is in the closed (:attr:`y0`, :attr:`y1`) interval. rr yrrs r containsyBboxBase.containsyrrcTURU5=(a URU5$)zB Return whether ``(x, y)`` is in the bounding box or on its edge. )rrr rrs rcontainsBboxBase.containss!~~a 6T^^A%66rcURup#pEURupgpXB:aX$p$XS:aX5p5X:aXhphX:aXypyX(:*=(a Xd:*=(a X9:*=(a Xu:*$)zs Return whether this bounding box overlaps with the other bounding box. Parameters ---------- other : `.BboxBase` r r raax1ay1ax2ay2bx1by1bx2by2s roverlapsBboxBase.overlapsse"\\#"]]# 9 9 9 9zFcjFSZFCJFrc|URup#X!s=:=(a U:Os =(d X!s=:=(a U:$s $)zF Return whether *x* is in the open (:attr:`x0`, :attr:`x1`) interval. rrs rfully_containsxBboxBase.fully_containsx/{{{)bkkrk)k)rc|URup#X!s=:=(a U:Os =(d X!s=:=(a U:$s $)zF Return whether *y* is in the open (:attr:`y0`, :attr:`y1`) interval. rrs rfully_containsyBboxBase.fully_containsyrrcTURU5=(a URU5$)zF Return whether ``x, y`` is in the bounding box, but not on its edge. )rrrs rfully_containsBboxBase.fully_containss%##A&B4+?+?+BBrcURup#pEURupgpXB:aX$p$XS:aX5p5X:aXhphX:aXypyX(:=(a Xd:=(a X9:=(a Xu:$)z Return whether this bounding box overlaps with the other bounding box, not including the edges. Parameters ---------- other : `.BboxBase` rrs rfully_overlapsBboxBase.fully_overlapsse"\\#"]]# 9 9 9 9yBSYB39BBrc UR5nUR[R"USUSUS/USUS//55up4n[ X5SUS//5$)zH Construct a `Bbox` by statically transforming this one by *transform*. rrrrrr)r transformrarrayr)r rptsllullrs r transformedBboxBase.transformedssoo(( Vc$iT+c$iT-C D*FG RQ%A())r)?r&r)r&r)?r)r'r&)r'r')r&r')rr')rr&) CSWSSEENENNWWcURup4pVURupxp[U[5(aURUOUup[ UR X;XY- --U- XLXj- --U- /-5$)a Return a copy of the `Bbox` anchored to *c* within *container*. Parameters ---------- c : (float, float) or {'C', 'SW', 'S', 'SE', 'E', 'NE', ...} Either an (*x*, *y*) pair of relative coordinates (0 is left or bottom, 1 is right or top), 'C' (center), or a cardinal direction ('SW', southwest, is bottom left, etc.). container : `Bbox` The box within which the `Bbox` is positioned. See Also -------- .Axes.set_anchor )rrrcoefsr_points) r c containerlbwhLBr0Hcxcys ranchoredBboxBase.anchoreds|"%% a[[ a",Q"4"4A!DLL,&!+,&!+--. .rc~URup4[URSURSX-X$-/-/5$)z Return a copy of the `Bbox`, shrunk by the factor *mx* in the *x* direction and the factor *my* in the *y* direction. The lower left corner of the box remains unchanged. Normally *mx* and *my* will be less than 1, but this is not enforced. r)rrr3)r mxmyr8r9s rshrunkBboxBase.shrunksDyyT\\!_\\!_'779: :rNcUS::dUS::a [S5eUcUnURupEXA-U- nXe::aUnO XS-U- nUn[URSURSXv4-/5$)a Return a copy of the `Bbox`, shrunk so that it is as large as it can be while having the desired aspect ratio, *box_aspect*. If the box coordinates are relative (i.e. fractions of a larger box such as a figure) then the physical aspect ratio of that figure is specified with *fig_aspect*, so that *box_aspect* can also be given as a ratio of the absolute dimensions, not the relative dimensions. rz.'box_aspect' and 'fig_aspect' must be positive) ValueErrorrrr3)r box_aspectr5 fig_aspectr8r9r<r0s rshrunk_to_aspectBboxBase.shrunk_to_aspects ?jAoMN N  I~~ NZ ' 6A+AAT\\!_\\!_v-/0 0rc S/UQSPnURup4pVXS- n[R"U5VV s/sH up[X8U--U/X9U--U//5PM" sn n$s sn nf)z Return a list of new `Bbox` objects formed by splitting the original one with vertical lines at fractional positions given by *args*. rrr itertoolspairwiser) r r+xfrrrrr8xf0xf1s rsplitxBboxBase.splitxsy ]$]] G ) 2 22 68 6HCr!G|R(2a<*<=> 68 88s'Ac S/UQSPnURup4pVXd- n[R"U5VV s/sHup[X4X--/XTX--//5PM sn n$s sn nf)z Return a list of new `Bbox` objects formed by splitting the original one with horizontal lines at fractional positions given by *args*. rrrM) r r+yfrrrrr9yf0yf1s rsplityBboxBase.splity%su ]$]] G ) 2 22 68 6HCr<(2CG|*<=> 68 88s%Ac[U5S:Xag[R"U5n[R"SS9 URU:XR :-R SS9R5sSSS5 $!,(df  g=f)z Count the number of vertices contained in the `Bbox`. Any vertices with a non-finite x or y value are ignored. Parameters ---------- vertices : (N, 2) array rignore)invalidrrN)lenrrerrstaterrallsum)r verticess rcount_containsBboxBase.count_contains0se x=A ::h' [[ *hh))+,/CQCK+ * *s 9A>> B c [U[R"UVs/sHn[R"U5PM sn55$s snf)zs Count the number of bounding boxes that overlap this one. Parameters ---------- bboxes : sequence of `.BboxBase` )rr atleast_3dr)r bboxesrs rcount_overlapsBboxBase.count_overlaps@s;- "--f =f!f =>@ @ =s AcURnURnX-U- S- nX$-U- S- n[R"U*U*/XV//5n[ UR U-5$)zZ Construct a `Bbox` by expanding this one around its center by the factors *sw* and *sh*. g@)rrrrrr3)r swshrrdeltawdeltahas rexpandedBboxBase.expandedKsk  *u$++&#- HHw(6*:; <DLL1$%%rcTUR5nUcUn[X1*U*/X//-5$)z Construct a `Bbox` by padding this one on all four sides. Parameters ---------- w_pad : float Width pad h_pad : float, optional Height pad. Defaults to *w_pad*. )rr)r w_padh_padrs rpaddedBboxBase.paddedWs8" =EFvv.??@@rc4[URX4-5$)z>wGyy{    > rc[U5(d [S5e[R"UVs/sHoRPM sn5n[R "UVs/sHoR PM sn5n[R"UVs/sHoRPM sn5n[R "UVs/sHoRPM sn5n[X$/X5//5$s snfs snfs snfs snf)z8Return a `Bbox` that contains all of the given *bboxes*.z'bboxes' cannot be empty) r^rGrrrrrrrr)rgrrrrrs runionBboxBase.unions6{{78 8 VV6264YY62 3 VV6264YY62 3 VV6264YY62 3 VV6264YY62 3bXx()) 3222sC+ C0C5C:c[R"URUR5n[R"URUR5n[R"UR UR 5n[R"UR UR 5nX#::aXE::a[X$/X5//5$S$)zZ Return the intersection of *bbox1* and *bbox2* if they intersect, or None if they don't. N)rmaximumrminimumrrrr)bbox1bbox2rrrrs r intersectionBboxBase.intersections ZZ EJJ / ZZ EJJ / ZZ EJJ / ZZ EJJ /-/X"(tbXx()LLrr:)Nr'r )>r(rrrrrrrrrlr staticmethodrr~r4rpropertyrrrrrrrrrrrrrrrrrrrrrrrrrrrrr$r2r?rDrJrSrYrcrhrprur{r~rrrrr:rrrrs ooe$T%7%78H%IJGI  5  5."**FN!''''''''$$$$////////1111''''++ ++ %% ** ++"..7 G(**C C** E.0 :00 8 8? @ &A"-B ** M Mrrc^\rSrSrSrU4Sjr\(a \rSrU4SjrU4Sjr \ S5r \ S5r \ S 5r \ S S .S j5rS rSrSrSrS+SjrS,SjrS,SjrS+Sjr\R0R2S5r\R4R2S5r\R6R2S5r\R8R2S5r\R:R2S5r\R<R2S5r\R>R2S5r\R@R2S5r \RBR2S5r!\"S5r#\#R2S5r#\"S 5r$\$R2S!5r$\"S"5r%\%R2S#5r%S$r&S%r'S&r(S'r)S(r*S)r+S*r,U=r-$)-ria A mutable bounding box. Examples -------- **Create from known bounds** The default constructor takes the boundary "points" ``[[xmin, ymin], [xmax, ymax]]``. >>> Bbox([[1, 1], [3, 7]]) Bbox([[1.0, 1.0], [3.0, 7.0]]) Alternatively, a Bbox can be created from the flattened points array, the so-called "extents" ``(xmin, ymin, xmax, ymax)`` >>> Bbox.from_extents(1, 1, 3, 7) Bbox([[1.0, 1.0], [3.0, 7.0]]) or from the "bounds" ``(xmin, ymin, width, height)``. >>> Bbox.from_bounds(1, 1, 2, 6) Bbox([[1.0, 1.0], [3.0, 7.0]]) **Create from collections of points** The "empty" object for accumulating Bboxs is the null bbox, which is a stand-in for the empty set. >>> Bbox.null() Bbox([[inf, inf], [-inf, -inf]]) Adding points to the null bbox will give you the bbox of those points. >>> box = Bbox.null() >>> box.update_from_data_xy([[1, 1]]) >>> box Bbox([[1.0, 1.0], [1.0, 1.0]]) >>> box.update_from_data_xy([[2, 3], [3, 2]], ignore=False) >>> box Bbox([[1.0, 1.0], [3.0, 3.0]]) Setting ``ignore=True`` is equivalent to starting over from a null bbox. >>> box.update_from_data_xy([[1, 1]], ignore=True) >>> box Bbox([[1.0, 1.0], [1.0, 1.0]]) .. warning:: It is recommended to always specify ``ignore`` explicitly. If not, the default value of ``ignore`` can be changed at any time by code with access to your Bbox, for example using the method `~.Bbox.ignore`. **Properties of the ``null`` bbox** .. note:: The current behavior of `Bbox.null()` may be surprising as it does not have all of the properties of the "empty set", and as such does not behave like a "zero" object in the mathematical sense. We may change that in the future (with a deprecation period). The null bbox is the identity for intersections >>> Bbox.intersection(Bbox([[1, 1], [3, 7]]), Bbox.null()) Bbox([[1.0, 1.0], [3.0, 7.0]]) except with itself, where it returns the full space. >>> Bbox.intersection(Bbox.null(), Bbox.null()) Bbox([[-inf, -inf], [inf, inf]]) A union containing null will always return the full space (not the other set!) >>> Bbox.union([Bbox([[0, 0], [0, 0]]), Bbox.null()]) Bbox([[-inf, -inf], [inf, inf]]) c >[TU]"S0UD6 [R"U[5nUR S:wa [ S5eXl[R5Ul SUl URR5Ul g)zj Parameters ---------- points : `~numpy.ndarray` A (2, 2) array of the form ``[[x0, y0], [x1, y1]]``. rz7Bbox points must be of the form "[[x0, y0], [x1, y1]]".TNr:) r]rErrfloatshaperGr3_default_minposr\_minpos_ignore _points_orig)r rr,rds rrE Bbox.__init__sv "6"FE* <<6 !78 8 &++-  !LL--/rc LURU5 UR"U40UD6 gr )r ___init__)r rr,s rrErs KK  NN6 ,V ,rcX>URUR5 [TU] 5 gr )rr3r]rn)r rds rrnBbox.invalidates KK % G  rcb>[TU]5nURR5UlU$r )r]r~minposr\r)r frozen_bboxrds rr~ Bbox.frozen s*gn& "kk..0 rc$[SS/SS//5$)z/Create a new unit `Bbox` from (0, 0) to (1, 1).rr)rr:rrr Bbox.unitsaVaV$%%rc[[R[R/[R*[R*//5$)z9Create a new null `Bbox` from (inf, inf) to (-inf, -inf).)rrinfr:rrnull Bbox.nulls2bffbff%"&&'9:;;rc8[RXX-X-5$)zc Create a new `Bbox` from *x0*, *y0*, *width* and *height*. *width* and *height* may be negative. )r from_extents)rrrrs r from_boundsBbox.from_boundss  R[AArN)rch[[R"US55nUbXRSS&U$)a Create a new Bbox from *left*, *bottom*, *right* and *top*. The *y*-axis increases upwards. Parameters ---------- left, bottom, right, top : float The four extents of the bounding box. minpos : float or None If this is supplied, the Bbox will have a minimum positive value set. This is useful when dealing with logarithmic scales and other scales where negative bounds result in floating point errors. rN)rrreshaper)rr+rs rrBbox.from_extents$s/ BJJtV,-  $LLO rc$SRX5$)Nz@Bbox(x0={0.x0:{1}}, y0={0.y0:{1}}, x1={0.x1:{1}}, y1={0.y1:{1}})format)r fmts r __format__Bbox.__format__9s N F4  rc[US5$)Nr?rrHs rrI Bbox.__str__>sdBrc$SRU5$)Nz*Bbox([[{0.x0}, {0.y0}], [{0.x1}, {0.y1}]])rrHs r__repr__ Bbox.__repr__As;BB4HHrcXlg)aj Set whether the existing bounds of the box should be ignored by subsequent calls to :meth:`update_from_data_xy`. value : bool - When ``True``, subsequent calls to `update_from_data_xy` will ignore the existing bounds of the `Bbox`. - When ``False``, subsequent calls to `update_from_data_xy` will include the existing bounds of the `Bbox`. N)r)r values rr\ Bbox.ignoreDs  rcUc URnURRS:Xag[USURUR U5upVnU(axUR 5 U(a,USS2S4URSS2S4'USUR S'U(a-USS2S4URSS2S4'USUR S'ggg)a Update the bounds of the `Bbox` to contain the vertices of the provided path. After updating, the bounds will have positive *width* and *height*; *x0* and *y0* will be the minimal values. Parameters ---------- path : `~matplotlib.path.Path` ignore : bool, optional - When ``True``, ignore the existing bounds of the `Bbox`. - When ``False``, include the existing bounds of the `Bbox`. - When ``None``, use the last value passed to :meth:`ignore`. updatex, updatey : bool, default: True When ``True``, update the x/y values. Nrr)rrbrrr3rrn)r pathr\updatexupdateyrrchangeds rupdate_from_pathBbox.update_from_pathQs >\\F ==   " "5 $ dllF#<  OO %+AqD\ QT""() Q%+AqD\ QT""() Q rc[R"U5nUR[R"U[R"UR 5/5USS9 g)a Update the x-bounds of the `Bbox` based on the passed in data. After updating, the bounds will have positive *width*, and *x0* will be the minimal value. Parameters ---------- x : `~numpy.ndarray` Array of x-values. ignore : bool, optional - When ``True``, ignore the existing bounds of the `Bbox`. - When ``False``, include the existing bounds of the `Bbox`. - When ``None``, use the last value passed to :meth:`ignore`. F)r\rNrravelr column_stackonesr)r rr\s rupdate_from_data_xBbox.update_from_data_xssE HHQK   !RWWQVV_1E!F(. ! ?rc[R"U5nUR[R"[R"UR 5U/5USS9 g)a Update the y-bounds of the `Bbox` based on the passed in data. After updating, the bounds will have positive *height*, and *y0* will be the minimal value. Parameters ---------- y : `~numpy.ndarray` Array of y-values. ignore : bool, optional - When ``True``, ignore the existing bounds of the `Bbox`. - When ``False``, include the existing bounds of the `Bbox`. - When ``None``, use the last value passed to :meth:`ignore`. F)r\rNr)r rr\s rupdate_from_data_yBbox.update_from_data_ysE HHQK   "''!&&/11E!F(. ! ?rcZ[U5S:Xag[U5nURXRX4S9 g)a( Update the `Bbox` bounds based on the passed in *xy* coordinates. After updating, the bounds will have positive *width* and *height*; *x0* and *y0* will be the minimal values. Parameters ---------- xy : (N, 2) array-like The (x, y) coordinates. ignore : bool, optional - When ``True``, ignore the existing bounds of the `Bbox`. - When ``False``, include the existing bounds of the `Bbox`. - When ``None``, use the last value passed to :meth:`ignore`. updatex, updatey : bool, default: True When ``True``, update the x/y values. rN)r\rr)r^r r)r xyr\rrrs rrBbox.update_from_data_xys4$ r7a< Bx d&-  @rc@XRS'UR5 gNrr3rnr rcs rrBbox.x0 T rc@XRS'UR5 gNrrrs rrBbox.y0rrc@XRS'UR5 gNrrrs rrBbox.x1rrc@XRS'UR5 gNrrrs rrBbox.y1rrc@XRS'UR5 gNrrrs rrBbox.p0 Q rc@XRS'UR5 gNrrrs rrBbox.p1rrcHXRSS2S4'UR5 grrr intervals rrBbox.intervalx% QT rcHXRSS2S4'UR5 grrrs rrBbox.intervalyrrcUup#pE[R"X#/X$-X5-//[5n[R"URU:g5(aX`lUR 5 ggr )rrrrr3rn)r rr6r7r8r9rs rr Bbox.boundssV aA6AE15>2E: 66$,,&( ) )!L OO  *rcUR$)z The minimum positive value in both directions within the Bbox. This is useful when dealing with logarithmic scales and other scales where negative bounds result in floating point errors, and will be used as the minimum extent instead of *p0*. rrHs rr Bbox.minposs||rc XRSS&gr rrs rrrs  Qrc URS$)z The minimum positive value in the *x*-direction within the Bbox. This is useful when dealing with logarithmic scales and other scales where negative bounds result in floating point errors, and will be used as the minimum *x*-extent instead of *x0*. rrrHs rminposx Bbox.minposx||Arc XRS'grrrs rrr  Qrc URS$)z The minimum positive value in the *y*-direction within the Bbox. This is useful when dealing with logarithmic scales and other scales where negative bounds result in floating point errors, and will be used as the minimum *y*-extent instead of *y0*. rrrHs rminposy Bbox.minposyrrc XRS'grrrs rrr rrc(SUlUR$)zV Get the points of the bounding box as an array of the form ``[[x0, y0], [x1, y1]]``. r)rBr3rHs rrBbox.get_pointss  ||rc[R"URU:g5(aXlUR5 gg)z Set the points of the bounding box directly from an array of the form ``[[x0, y0], [x1, y1]]``. No error checking is performed, as this method is mainly for internal use. N)rrr3rnrs r set_pointsBbox.set_pointss0 66$,,&( ) )!L OO  *rc[R"URUR5:g5(a&UR5UlUR 5 gg)zC Set this bounding box from the "frozen" bounds of another `Bbox`. N)rrr3rrnr ras rsetBbox.set!sD 66$,,%"2"2"44 5 5 ++-DL OO  6rcPUR5=(d UR5$)z/Return whether the bbox has changed since init.)mutatedxmutatedyrHs rmutated Bbox.mutated)s}}1$--/1rcURSURS:g=(d URSURS:g$)z4Return whether the x-limits have changed since init.rrr3rrHs rr Bbox.mutatedx-D T"d&7&7&==> T"d&7&7&== ?rcURSURS:g=(d URSURS:g$)z4Return whether the y-limits have changed since init.rrrrHs rr Bbox.mutatedy2rr)rrBrr3r)NTTr ).r(rrrrrErrrnr~rrrrrrrIrr\rrrrrrsetterrrrrrrrrrrrrrrr rrrrrrs@rrrsaN`0&   - ! &&<<BB#'(  I  ,D?&?&@2[[[[[[[[[[[[__ ]] ^^ ^^2? ??rrch^\rSrSrSrU4Sjr\"SS5rSr\ (a\r SrSr S r S r U=r$) TransformedBboxi8z A `Bbox` that is automatically transformed by a given transform. When either the child bounding box or transform changes, the bounds of this bbox will update accordingly. c (>[R"[US9 [R"[US9 URS:wdUR S:wa [ S5e[TU] "S0UD6 Xl X l URX5 SUl g)z= Parameters ---------- bbox : `Bbox` transform : `Transform` rrrz8The input and output dimensions of 'transform' must be 2Nr:) rcheck_isinstancer Transform input_dims output_dimsrGr]rE_bbox _transformr`r3)r rrr,rds rrETransformedBbox.__init__?s hT2 i9=   1 $ (=(=(BJL L "6" # $* rr#r$cxUR(GaURR5nURR USUS/USUS/USUS/USUS//5n[ R RUS5n[USS2S45[USS2S454nUSUS:aUSSS2n[USS2S45[USS2S454nUSUS:aUSSS2n[ R"USUS/USUS//5Ul SUlUR$) Nrrrrrr) rBr#rr$rrrfilledrrrr3)r prxsyss rrTransformedBbox.get_pointsTsV === %%'A__..D'1T7#D'1T7#D'1T7#D'1T7#%&F UU\\&#.FVAqD\"Cq!t $55Bw4 "XVAqD\"Cq!t $55Bw4 "X88A1A1%DL DM||rcHUR5nURU5 U$r  _get_pointsrrs rrr-u!%%'F KK MrcURR"URR5R X456$r )r#rr$invertedrrs rrTransformedBbox.containszs1zz""DOO$<$<$>$H$H!$PQQrcURR"URR5R X456$r )r#rr$r3rrs rrTransformedBbox.fully_contains~s2zz(($//*B*B*D*N*NPQv*VWWr)r#rBr3r$)r(rrrrrEr2rIrrr0rrrrrs@rrr8sA &w 5G<    RXXrrc0^\rSrSrSrSU4Sjjr\"SS5rSr\ (a\r Sr\ S5r \ RS 5r \ S 5r\RS 5r\ S 5r\RS 5r\ S5r\RS5rSrU=r$) LockableBboxiz A `Bbox` where some elements may be locked at certain values. When the child bounding box changes, the bounds of this bbox will update accordingly with the exception of the locked elements. c :>[R"[US9 [T U]"S0UD6 XlUR U5 SUlX#XE/nUVs/sHoSLPM n n[RRU[U S9RS5Ul gs snf)az Parameters ---------- bbox : `Bbox` The child bounding box to wrap. x0 : float or None The locked value for x0, or None to leave unlocked. y0 : float or None The locked value for y0, or None to leave unlocked. x1 : float or None The locked value for x1, or None to leave unlocked. y1 : float or None The locked value for y1, or None to leave unlocked. rNmaskrr:)rrrr]rEr#r`r3rrrrr_locked_points) r rrrrrr,fprcr;rds rrELockableBbox.__init__s( hT2 "6"  $ b ')*rt r* eekk"e$k?GGO+s Br#r<cUR(a\URR5n[R"UR R UUR 5UlSUlUR$r)rBr#rrwherer<r;r3rs rrLockableBbox.get_pointssX ==ZZ**,F88D$7$7$<$<$*$($7$79DLDM||rcHUR5nURU5 U$r r/rs rrrAr1rc^URRS(agURS$)z2 float or None: The value used for the locked x0. rNr<r;rHs r locked_x0LockableBbox.locked_x0,    # #D )&&t, ,rcUSLURRS'XRRS'UR5 grr<r;datarn)r rs rrErF:)+t  &)+  & rc^URRS(agURS$)z2 float or None: The value used for the locked y0. rNrDrHs r locked_y0LockableBbox.locked_y0rGrcUSLURRS'XRRS'UR5 grrI)r rs rrMrNrKrc^URRS(agURS$)z2 float or None: The value used for the locked x1. rNrDrHs r locked_x1LockableBbox.locked_x1rGrcUSLURRS'XRRS'UR5 grrI)r rs rrQrRrKrc^URRS(agURS$)z2 float or None: The value used for the locked y1. rNrDrHs r locked_y1LockableBbox.locked_y1rGrcUSLURRS'XRRS'UR5 grrI)r rs rrUrVrKr)r#rBr<r3)NNNN)r(rrrrrEr2rIrrr0rrErrMrQrUrrrs@rr8r8s P:w(89G    -- -- -- --rr8c\rSrSrSrSrSrSrSrSr Sr Sr \ S5r S rS rS rS rS rSrSrSrSrSrSrSrSrSrSSjrSrSrg)r iaU The base class of all `TransformNode` instances that actually perform a transformation. All non-affine transformations should be subclasses of this class. New affine transformations should be subclasses of `Affine2D`. Subclasses of this class should override the following members (at minimum): - :attr:`input_dims` - :attr:`output_dims` - :meth:`transform` - :meth:`inverted` (if an inverse exists) The following attributes may be overridden if the default is unsuitable: - :attr:`is_separable` (defaults to True for 1D -> 1D transforms, False otherwise) - :attr:`has_inverse` (defaults to True if :meth:`inverted` is overridden, False otherwise) If the transform needs to do something non-standard with `matplotlib.path.Path` objects, such as adding curves where there were once line segments, it should override: - :meth:`transform_path` NFcJ[SUR55S:Xa+URURs=:XaS:Xa O OSUl[SUR55S:Xa8[ US5(a&UR [R LaSUlgggg)Nc3># UHnS[U5;v M g7f) is_separableNr^rrts rr!.Transform.__init_subclass__..1sI[6$v,.[rTc3># UHnS[U5;v M g7f) has_inverseNr\r]s rr!r^7sHK& f-Kr_r3) ra__mro__r!r"r[hasattrr3r rar;s r__init_subclass__Transform.__init_subclass__,s IS[[I IQ NNNcoo::#C  HCKKH HA MC,,LL (:(::"CO;- NrcN[U[5(a [X5$[$)z Compose two transforms together so that *self* is followed by *other*. ``A + B`` returns a transform ``C`` so that ``C.transform(x) == B.transform(A.transform(x))``. )rr composite_transform_factoryNotImplementedr s r__add__Transform.__add__<s(eY//,D8  rc#(# [5U4v g7f)aj Return an iterator breaking down this transform stack from left to right recursively. If self == ((A, N), A) then the result will be an iterator which yields I : ((A, N), A), followed by A : (N, A), followed by (A, N) : (A), but not ((A, N), A) : I. This is equivalent to flattening the stack then yielding ``flat_stack[:i], flat_stack[i:]`` where i=0..(n-1). NIdentityTransformrHs r_iter_break_from_left_to_right(Transform._iter_break_from_left_to_rightKs !4''scg)z Return the number of transforms which have been chained together to form this Transform instance. .. note:: For the special case of a Composite transform, the maximum depth of the two is returned. rr:rHs rdepthTransform.depthWsrczURUR:agUR5H up#X1:XdM g g)a! Return whether the given transform is a sub-tree of this transform. This routine uses transform equality to identify sub-trees, therefore in many situations it is object id which will be used. For the case where the given transform represents the whole of this transform, returns True. FT)rqrn)r rarSsub_trees rcontains_branchTransform.contains_branches= :: # >>@KA ArcbURS:wa [S5eURU54S-$)a% Return whether the given branch is a sub-tree of this transform on each separate dimension. A common use for this method is to identify if a transform is a blended transform containing an Axes' data transform. e.g.:: x_isdata, y_isdata = trans.contains_branch_seperately(ax.transData) rLcontains_branch_seperately only supports transforms with 2 output dimensions)r"rGrur other_transforms rcontains_branch_seperately$Transform.contains_branch_seperatelyxsB   q CD D$$_581<??!))++ $J   ..** *23 3rc>UR5R5$)z9Array interface to get at this Transform's affine matrix. get_affine get_matrixrs rrTransform.__array__ ++--rc[R"U5nURnURSUR45nUR UR U55nUS:Xa+[RRU5(aeUS$US:XaURS5$US:XaU$[SRURS95e)a` Apply this transformation on the given array of *values*. Parameters ---------- values : array-like The input values as an array of length :attr:`input_dims` or shape (N, :attr:`input_dims`). Returns ------- array The output values as an array of length :attr:`output_dims` or shape (N, :attr:`output_dims`), depending on the input. r(rrrrz5Input values must have shape (N, {dims}) or ({dims},))dims) r asanyarrayndimrr!transform_affinetransform_non_affiner is_maskedrGr)r rsrress rrTransform.transforms$v&{{T__ 56##D$=$=f$EF 19uus++ ++t9  19;;r? " QYJ C VV )+ +rc@UR5RU5$)aX Apply only the affine part of this transformation on the given array of values. ``transform(values)`` is always equivalent to ``transform_affine(transform_non_affine(values))``. In non-affine transformations, this is generally a no-op. In affine transformations, this is equivalent to ``transform(values)``. Parameters ---------- values : array The input values as an array of length :attr:`input_dims` or shape (N, :attr:`input_dims`). Returns ------- array The output values as an array of length :attr:`output_dims` or shape (N, :attr:`output_dims`), depending on the input. rrr rss rrTransform.transform_affines0 **622rcU$)aF Apply only the non-affine part of this transformation. ``transform(values)`` is always equivalent to ``transform_affine(transform_non_affine(values))``. In non-affine transformations, this is generally equivalent to ``transform(values)``. In affine transformations, this is always a no-op. Parameters ---------- values : array The input values as an array of length :attr:`input_dims` or shape (N, :attr:`input_dims`). Returns ------- array The output values as an array of length :attr:`output_dims` or shape (N, :attr:`output_dims`), depending on the input. r:rs rrTransform.transform_non_affines . rcR[URUR555$)z Transform the given bounding box. For smarter transforms including caching (a common requirement in Matplotlib), see `TransformedBbox`. )rrr)r rs rtransform_bboxTransform.transform_bboxsDNN4??#4566rc[5$)z&Get the affine part of this transform.rlrHs rrTransform.get_affine!s  ""rc>UR5R5$)z5Get the matrix for the affine part of this transform.rrHs rrTransform.get_matrix%rrcl[U5UR:wa [S5eURU5$)aI Return a transformed point. This function is only kept for backcompatibility; the more general `.transform` method is capable of transforming both a list of points and a single point. The point is given as a sequence of length :attr:`input_dims`. The transformed point is returned as a sequence of length :attr:`output_dims`. z/The length of 'point' must be 'self.input_dims')r^r!rGr)r points rtransform_pointTransform.transform_point)s/ u: (NO O~~e$$rcBURURU55$)z Apply the transform to `.Path` *path*, returning a new `.Path`. In some cases, this transform may insert curves into the path that began as line segments. )transform_path_affinetransform_path_non_affiner rs rtransform_pathTransform.transform_path9s ))$*H*H*NOOrc@UR5RU5$)z Apply the affine part of this transform to `.Path` *path*, returning a new `.Path`. ``transform_path(path)`` is equivalent to ``transform_path_affine(transform_path_non_affine(values))``. )rrrs rrTransform.transform_path_affineBs 66t<)r(rrrrr!r"r[rardrirnrrqrur{rrrrrrrrrrrrrr3rr:rrr r s:J K LJKG#   (  &=$03d.#+J3427#.% P= D/b $rr c^\rSrSrSrSrU4SjrSr\"S5r Sr Sr \ "S 5r \ "S 5r\ "S 5r\ "S 5r\ "S 5rSrU=r$)TransformWrapperia A helper class that holds a single child transform and acts equivalently to it. This is useful if a node of the transform tree must be replaced at run time with a transform of a different type. This class allows that replacement to correctly trigger invalidation. `TransformWrapper` instances must have the same input and output dimensions during their entire lifetime, so the child transform may only be replaced with another child transform of the same dimensions. Tcv>[R"[US9 [TU]5 UR U5 g)zV *child*: A `Transform` instance. This child may later be replaced with :meth:`set`. )r{N)rrr r]rEr )r r{rds rrETransformWrapper.__init__s+ iu5  rc8URRU5$r )_child__eq__r s rrTransformWrapper.__eq__s{{!!%((rrc6URR5$r )rr~rHs rr~TransformWrapper.frozens{{!!##rc[US5(aUR5 URUR4nURRURR4nX#:wa[ SUSU35eURR R[U5S5 XlURU5 URUl URUl URUl URUl URUlURUlUR UlUR"UlUR$UlSUlUR5 SUlg)z Replace the current child of this transform with another one. The new child must have the same number of input and output dimensions as the current child. rz+The input and output dims of the new child z% do not match those of current child Nr)rcrnr!r"rrGr@rTr_r`rrrrrrrr3rrB)r r{new_dimsold_dimss rr TransformWrapper.sets? 4 " " OO ((%*;*;$>!#22%*%@%@").)H)H&** **    rc.URR$r )rr!rHs rr-TransformWrapper.st{{'='=rc.URR$r )rr"rHs rr-r (?(?rc.URR$r )rrlrHs rr-rsdkk&;&;rc.URR$r )rr[rHs rr-rs)A)Arc.URR$r )rrarHs rr-rrr) rrBrrr3rrrrrr)r(rrrrrqrErr2rIr~r rr!r"rlr[rarrrs@rrrsi L)x(G$#J=>J?@K;[TU]"U0UD6 SUlgr )r]rE _inverted)r r+r,rds rrEAffineBase.__init__s $)&)rc"UR5$r rrs rrAffineBase.__array__s  rc[USS5(a@[US5(a/UR5UR5:HR5$[$)NrlFr)rrcrr`rhr s rrAffineBase.__eq__sG 5+u - -'%2N2NOO%)9)9);;@@B Brc$URU5$r )rrs rrAffineBase.transforms$$V,,rc[S5e)Nz.Affine subclasses should override this method.rrs rrAffineBase.transform_affines!#,- -rcU$r r:rs rrAffineBase.transform_non_affines rc$URU5$r )rrs rrAffineBase.transform_paths))$//rcv[URUR5URUR5$r )r rrbr_interpolation_stepsrs rr AffineBase.transform_path_affines/D))$--8JJ 9 9; ;rcU$r r:rs rr$AffineBase.transform_path_non_affine  rcU$r r:rHs rrAffineBase.get_affinerr)r)r(rrrrrlrErrrrrrrrrrrrs@rrrsFI! -- 0; rrc`\rSrSrSrSrSrSr\S5r Sr Sr \ (a\ r Sr S rS rg ) Affine2DBaseia The base class of all 2D affine transformations. 2D affine transformations are performed using a 3x3 numpy array:: a c e b d f 0 0 1 This class provides the read-only interface. For a mutable 2D affine transformation, use `Affine2D`. Subclasses of this class will generally only need to override a constructor and `~.Transform.get_matrix` that generates a custom 3x3 matrix. rcP[UR5R55$r )rrr\rHs rr~Affine2DBase.frozen(s)..011rcXUR5nUSUSs=:H=(a S:H$s $)Nrrr'rr mtxs rr[Affine2DBase.is_separable,s/oo4yCI,,,,,,rcrUR5n[USSRSS5R5$)zE Return the values of the matrix as an ``(a, b, c, d, e, f)`` tuple. Nrrr)rtupleswapaxesflatrs r to_valuesAffine2DBase.to_values1s4ooS!W%%a+0011rc,UR5n[U[RR5(aQ[ UR U5n[RR U[RRU5S9$[ X5$)Nr:)rrrrrrrJgetmask)r rsrtpointss rrAffine2DBase.transform_affine8sgoo fbee// 0 0&v{{C8G55$$W255==3H$I I,,rc[U[R5(d#[R"S[ U5S35 UR U5$)NzA non-numpy array of type zE was passed in for transformation, which results in poor performance.)rrndarrayrrr'_transform_affiners rrrBsN fbjj11""0f?MNO))&1 1rcURbUR(aQUR5nSnUR(aSUR-n[ [ U5US9UlSUlUR$)Nz(%s)-1)rDr)rrBrrCrr)r rrDs rr3Affine2DBase.invertedMs_ >> !T]]//#C!N##!)D,@,@!@%c#h~NDNDM~~r)rBrN)r(rrrrr!r"r~rr[rrrrr3rr:rrrrsKJK2--2- , 2 rrc^\rSrSrSrSU4Sjjr\"S5rSr\ S5r Sr Sr S r S rS rS rS rSrSrSSjrSrSrSrU=r$)riYz% A mutable 2D affine transformation. c >[TU]"S0UD6 Uc[RnUR 5UlSUlg)z Initialize an Affine transform from a 3x3 numpy float array:: a c e b d f 0 0 1 If *matrix* is None, initialize with the identity transform. Nrr:)r]rErm_mtxr\rB)r matrixr,rds rrEAffine2D.__init__^s9 "6" >&++FKKM  rrcvUR[R"[R"UR55:gR5(aUR 5$URSURS:wa#SURSSURSS3$SURSS3$)NrrzAffine2D().scale(z, r&)rrdiagr _base_strrHs rrIAffine2D.__str__qsII);!<<AACC  =99T?diio5)4(9DIIdO;LAN =)4(9;  =rc t[[R"XXAX5SSS/ [5R S55$)zT Create a new Affine2D instance from the given values:: a c e b d f 0 0 1 . r'r')r6r6)rrrrr)ror7r4refs r from_valuesAffine2D.from_valuesxs9 HHaA!S#6 > F Fv NP PrcXUR(aSUlSUlUR$)zW Get the underlying transformation matrix as a 3x3 array:: a c e b d f 0 0 1 . NrrBrrrHs rrAffine2D.get_matrixs# ==!DNDMyyrc0XlUR5 g)zY Set the underlying transformation matrix from a 3x3 array:: a c e b d f 0 0 1 . Nrrnrs r set_matrixAffine2D.set_matrixs  rc[R"[US9 UR5UlUR 5 g)zP Set this transformation from the frozen copy of another `Affine2DBase` object. )raN)rrrrrrnr s rr  Affine2D.sets. l%8$$&  rcl[RR5UlUR5 U$)z8 Reset the underlying matrix to the identity transform. )rmrr\rnrHs rclearAffine2D.clears) &**//1   rcX[R"U5n[R"U5nURnUR 5uupVnuppX%-X8-- US'X&-X9-- US'X'-X:-- US'X5-X(--US'X6-X)--US'X7-X*--US'UR 5 U$)z Add a rotation (in radians) to this transform in place. Returns *self*, so this method can easily be chained with more calls to :meth:`rotate`, :meth:`rotate_deg`, :meth:`translate` and :meth:`scale`. rrrrrrrr)mathrrrtolistrn) r thetaror7rxxrryxyyrrSs rrAffine2D.rotates HHUO HHUOii(+ % lrrFQVOD FQVOD FQVOD FQVOD FQVOD FQVOD   rcLUR[R"U55$)z Add a rotation (in degrees) to this transform in place. Returns *self*, so this method can easily be chained with more calls to :meth:`rotate`, :meth:`rotate_deg`, :meth:`translate` and :meth:`scale`. )rr!r)r degreess r rotate_degAffine2D.rotate_degs{{4<<011rcfURU*U*5RU5RX5$)z Add a rotation (in radians) around the point (x, y) in place. Returns *self*, so this method can easily be chained with more calls to :meth:`rotate`, :meth:`rotate_deg`, :meth:`translate` and :meth:`scale`. ) translater)r rrr#s r rotate_aroundAffine2D.rotate_arounds/~~qb1"%,,U3==aCCrc[U5[U5p!URU*U*5RU5RX5$)z Add a rotation (in degrees) around the point (x, y) in place. Returns *self*, so this method can easily be chained with more calls to :meth:`rotate`, :meth:`rotate_deg`, :meth:`translate` and :meth:`scale`. )rr-r*)r rrr)s rrotate_deg_aroundAffine2D.rotate_deg_arounds>Qxq1~~qb1"%009CCAIIrcURS==U- ss'URS==U- ss'UR5 U$)z Add a translation in place. Returns *self*, so this method can easily be chained with more calls to :meth:`rotate`, :meth:`rotate_deg`, :meth:`translate` and :meth:`scale`. rr rrxs rr-Affine2D.translates7 $2 $2  rcDUcUnURS==U-ss'URS==U-ss'URS==U-ss'URS==U-ss'URS==U-ss'URS==U-ss'UR5 U$)z Add a scale in place. If *sy* is None, the same scale is applied in both the *x*- and *y*-directions. Returns *self*, so this method can easily be chained with more calls to :meth:`rotate`, :meth:`rotate_deg`, :meth:`translate` and :meth:`scale`. rrrrrr r)r sxsys rscaleAffine2D.scales :B $2 $2 $2 $2 $2 $2  rc|[R"U5n[R"U5nURnUR5uupgnuppUS==X9-- ss'US==X:-- ss'US==X;-- ss'US==XF-- ss'US==XG-- ss'US==XH-- ss'UR 5 U$)a  Add a skew in place. *xShear* and *yShear* are the shear angles along the *x*- and *y*-axes, respectively, in radians. Returns *self*, so this method can easily be chained with more calls to :meth:`rotate`, :meth:`rotate_deg`, :meth:`translate` and :meth:`scale`. rrrrrr )r!tanrr"rn) r xShearyShearrxryrr$rrr%r&rrSs rskew Affine2D.skewsXXf  XXf ii(+ % lrr D RW  D RW  D RW  D RW  D RW  D RW   rcvUR[R"U5[R"U55$)a  Add a skew in place. *xShear* and *yShear* are the shear angles along the *x*- and *y*-axes, respectively, in degrees. Returns *self*, so this method can easily be chained with more calls to :meth:`rotate`, :meth:`rotate_deg`, :meth:`translate` and :meth:`scale`. )r@r!r)r r<r=s rskew_degAffine2D.skew_deg)s'yyf-t||F/CDDrrr )r(rrrrrEr2r rIrrrrr rrr*r.r1r-r8r@rCrrrs@rrrYsy"!(I= P P  .2D J .4 E Errc\rSrSrSr\R "S5rSr\ "5r Sr Sr Sr SrS rS rS rS rS rSrg)rmi7zM A special class that does one thing, the identity transform, in a fast way. r6cU$r r:rHs rr~IdentityTransform.frozen>rrcUR$r )rrHs rrIdentityTransform.get_matrixDs yyrc.[R"U5$r rrrs rrIdentityTransform.transformH}}V$$rc.[R"U5$r rKrs rr"IdentityTransform.transform_affineLrMrc.[R"U5$r rKrs rr&IdentityTransform.transform_non_affinePrMrcU$r r:rs rr IdentityTransform.transform_pathTrrcU$r r:rs rr'IdentityTransform.transform_path_affineXrrcU$r r:rs rr+IdentityTransform.transform_path_non_affine\rrcU$r r:rHs rrIdentityTransform.get_affine`rrcU$r r:rHs rr3IdentityTransform.inverteddrrr:N)r(rrrrridentityrr~r2rIrrrrrrrrr3rr:rrrmrm7sR ;;q>D G%%%rrmc6\rSrSrSrSrSr\"SS5rSr g) _BlendedMixiniizCCommon methods for `BlendedGenericTransform` and `BlendedAffine2D`.c[U[[45(a9URUR:H=(a URUR:H$URUR:XaURU:H$[ $r )rBlendedAffine2DBlendedGenericTransform_x_yrhr s rr_BlendedMixin.__eq__ls_ eo/FG H HGGuxx'Bdgg.A B WW 77e# #! !rcnURRU5URRU54$r )rbrurc)r rs rr{(_BlendedMixin.contains_branch_seperatelyts0'' 2'' 24 4rrbrcr:N) r(rrrrrr{r2rIrr:rrr^r^isM"4tT*Grr^c\rSrSrSrSrSrSrSrSr \ S5r Sr \ "S5r \ "S 5rS rS rS rS rSrg)rai{z A "blended" transform uses one transform for the *x*-direction, and another transform for the *y*-direction. This "generic" version can handle any given child transform in the *x*- and *y*-directions. rTc z[R"U40UD6 XlX lUR X5 SUlg)a; Create a new "blended" transform using *x_transform* to transform the *x*-axis and *y_transform* to transform the *y*-axis. You will generally not call this constructor directly but use the `blended_transform_factory` function instead, which can determine automatically which kind of blended transform to create. N)r rErbrcr`_affine)r x_transform y_transformr,s rrE BlendedGenericTransform.__init__s6 4*6* +3 rcj[URRURR5$r )rrbrqrcrHs rrqBlendedGenericTransform.depths477==$''--00rcgr9r:r s rru'BlendedGenericTransform.contains_branchsrchURR=(a URR$r )rbrlrcrHs rr- BlendedGenericTransform. dgg&7&7&MDGG>;KLLrcURR(aURR(aU$URnURnX#:Xa!URS:XaUR U5$URS:XaUR U5SS2SS24nO4UR USS2S45nUR [ U5S45nURS:XaUR U5SS2SS24nO4UR USS2S45nUR [ U5S45n[U[RR5(d)[U[RR5(a![RRXE4S5$[R"XE4S5$)Nrrr) rbrlrcr!rrr^rrrr concatenate)r rsrrx_pointsy_pointss rr,BlendedGenericTransform.transform_non_affinesa 77  !2!2M GG GG 6alla'))&1 1 <<1 --f5a1f=H--fQTl;H''X(:;H <<1 --f5ae>8"6: :rcz[URR5URR55$r )rarbr3rcrHs rr3 BlendedGenericTransform.inverteds)&tww'7'7'9477;K;K;MNNrcUR(d URcURUR:Xa URR 5UlOURR 5R 5nURR 5R 5n[ R"USUS/SQ/5n[U5UlSUlUR$Nrrr'r'r') rBrirbrcrrrrr)r x_mtxy_mtxrs rr"BlendedGenericTransform.get_affines ==DLL0ww$''!#ww113 **,779**,779hha%(ODE'} DM||r)rirBrbrcN)r(rrrrr!r"r[rqrErrqrurlrar~rr3rrr:rrrara{slJKLL 11 MNI@BKM;8O rrac(\rSrSrSrSrSrSrSrg)r`iz A "blended" transform uses one transform for the *x*-direction, and another transform for the *y*-direction. This version is an optimization for the case where both child transforms are of type `Affine2DBase`. Tc ZUR=(a URnUR=(a URnU=(a UnU(d [S5e[R"U40UD6 XlX lURX5 [R U5 SUl g)a Create a new "blended" transform using *x_transform* to transform the *x*-axis and *y_transform* to transform the *y*-axis. Both *x_transform* and *y_transform* must be 2D affine transforms. You will generally not call this constructor directly but use the `blended_transform_factory` function instead, which can determine automatically which kind of blended transform to create. zABoth *x_transform* and *y_transform* must be 2D affine transformsN) rlr[rGr rErbrcr`rr)r rjrkr,rlr[ is_corrects rrEBlendedAffine2D.__init__s ))Ck.C.C "//LK4L4L /< 12 2 4*6* +3d# rcUR(aURUR:Xa URR5UlOZURR5nURR5n[ R "USUS/SQ/5UlSUlSUlUR$r)rBrbrcrrrrr)r rrs rrBlendedAffine2D.get_matrixs ==ww$''! GG..0 **,**,HHeAha/%JK !DNDMyyr)rBrrrbrcN) r(rrrrr[rErrr:rrr`r`sL4 rr`c[U[5(a [U[5(a [X5$[X5$)z Create a new "blended" transform using *x_transform* to transform the *x*-axis and *y_transform* to transform the *y*-axis. A faster version of the blended transform is returned for the case where both child transforms are affine. )rrr`ra)rjrks rrwrw s4 ; -- {L 1 1{88 "; <URUR:wa [S5eURUlURUl[TU]"S0UD6 XlX lURX5 g)a Create a new composite transform that is the result of applying transform *a* then transform *b*. You will generally not call this constructor directly but write ``a + b`` instead, which will automatically choose the best kind of composite transform instance to create. HThe output dimension of 'a' must be equal to the input dimensions of 'b'Nr:)r"r!rGr]rE_a_br`r ror7r,rds rrE"CompositeGenericTransform.__init__% sf ==ALL (;< <,,== "6" !rcSUl[URR5URR55n[ U[ 5(dUR5$U$r)rBrgrr~rrr)r r~s rr~ CompositeGenericTransform.frozen9 sM , GGNN dggnn.0&";<<==? " rc>X RLa+URR(d[Rn[ TU]X5 gr )rrrlr rAr]rk)r rirjrds rrk.CompositeGenericTransform._invalidate_internalB s3  '0A0A++E $U>rc[U[[45(aCXL=(d9 URUR:H=(a URUR:H$gr9)rrCompositeAffine2Drrr s rr CompositeGenericTransform.__eq__I sN e79JK L L=>TWW%8&=)-EHH)< >rc## URR5HupXUR-4v M URR5HupURU-U4v M g7fr rrnrr leftrights rrn8CompositeGenericTransform._iter_break_from_left_to_rightP ]77AACKD' 'D77AACKD''D.%' 'DA-A/czURS:wa [S5eX:XagURRU5$)Nrrx)TT)r"rGrr{rys rr{4CompositeGenericTransform.contains_branch_seperatelyV sC   q CD D  "ww11/BBrc\URRURR-$r rrqrrHs rr-"CompositeGenericTransform._ s$''--$''--"?rchURR=(a URR$r )rrlrrHs rr-r` rsrchURR=(a URR$r )rr[rrHs rr-rb s TWW))Bdgg.B.BBrchURR=(a URR$r )rrarrHs rr-rd rurrrc@UR5RU5$r rrs rr*CompositeGenericTransform.transform_affineh s **622rc|URR(aURR(aU$URR(d6URR(aURRU5$URRURR U55$r )rrlrrrrs rr.CompositeGenericTransform.transform_non_affinel sr 77  !2!2M""tww'8'877//7 777//0A0A&0IJ Jrc|URR(aURR(aU$URR(d6URR(aURRU5$URRURR U55$r )rrlrrrrs rr3CompositeGenericTransform.transform_path_non_affineu sy 77  !2!2K""tww'8'87744T: :7744$(GG$:$:4$@B BrcDURR(dURR5$[[R "URR5R 5URR5R 555$r )rrlrrrdotrrrHs rr$CompositeGenericTransform.get_affine snww  77%%' 'BFF477#5#5#7#B#B#D#'77#5#5#7#B#B#DFG Grcz[URR5URR55$r )rrr3rrHs rr3"CompositeGenericTransform.inverted s.( GG    0 0 24 4r)rrrBr!r")r(rrrrrqrEr~rkrrnr{rrqrlr[rar2rIrrrrr3rrrs@rrr sL (?( C ? @EMNIBDL@BKtT*G3KBG44rrcZ^\rSrSrSrU4Sjr\S5rSr\ "SS5r Sr S r U=r $) ri z A composite transform formed by applying transform *a* then transform *b*. This version is an optimization that handles the case where both *a* and *b* are 2D affines. c V>UR(aUR(d [S5eURUR:wa [S5eURUlURUl[TU]"S0UD6 XlX lURX5 SUl g)a Create a new composite transform that is the result of applying `Affine2DBase` *a* then `Affine2DBase` *b*. You will generally not call this constructor directly but write ``a + b`` instead, which will automatically choose the best kind of composite transform instance to create. z%'a' and 'b' must be affine transformsrNr:) rlrGr"r!r]rErrr`rrs rrECompositeAffine2D.__init__ s{{!++DE E ==ALL (;< <,,== "6" ! rc\URRURR-$r rrHs rrqCompositeAffine2D.depth sww}}tww}},,rc## URR5HupXUR-4v M URR5HupURU-U4v M g7fr rrs rrn0CompositeAffine2D._iter_break_from_left_to_right rrrrcUR(aZ[R"URR 5UR R 55UlSUlSUlUR $r)rBrrrrrrrrHs rrCompositeAffine2D.get_matrix sS ==""$""$&DI"DNDMyyr)rrrBrrr!r")r(rrrrrErrqrnr2rIrrrrs@rrr s> .--( tT*Grrc[U[5(aU$[U[5(aU$[U[5(a [U[5(a [X5$[ X5$)aR Create a new composite transform that is the result of applying transform a then transform b. Shortcut versions of the blended transform are provided for the case where both child transforms are affine, or one or the other is the identity transform. Composite transforms may also be created using the '+' operator, e.g.:: c = a + b )rrmrrr)ror7s rrgrg sY$!&'' A( ) ) Ax Z8%<%< && $Q **rcH^\rSrSrSrSrU4Sjr\"SS5rSr Sr U=r $) BboxTransformi zH `BboxTransform` linearly transforms points from one `Bbox` to another. Tc >[R"[XS9 [TU]"S0UD6 XlX lURX5 SUlSUl g)zX Create a new `BboxTransform` that linearly transforms points from *boxin* to *boxout*. )boxinboxoutNr:) rrrr]rE_boxin_boxoutr`rr)r rrr,rds rrEBboxTransform.__init__ sK heC "6"   %( rrrcUR(aURRupp4URRupVpxXs- n X- n [(aU S:XdU S:Xa [ S5e[ R"U SU*U -U-/SX*U -U-//SQ/[5Ul SUl SUlUR$)Nrz/Transforming from or to a singular bounding boxr'r) rBrrrrrGrrrrr) r inlinbinwinhoutloutboutwouthx_scaley_scales rrBboxTransform.get_matrix s ==!%!3!3 Cc%)\\%8%8 "DjGjGu'Q,'Q, EGG7cT'\$5F"G'*GT'\$5F"G"G"I"'(DI"DNDMyyr)rrrBrr r(rrrrr[rEr2rIrrrrs@rrr s,L x3GrrcF^\rSrSrSrSrU4Sjr\"S5rSr Sr U=r $)BboxTransformToi zu `BboxTransformTo` is a transformation that linearly transforms points from the unit bounding box to a given `Bbox`. Tc >[R"[US9 [TU]"S0UD6 XlUR U5 SUlSUlg)zh Create a new `BboxTransformTo` that linearly transforms points from the unit bounding box to *boxout*. )rNr:) rrrr]rErr`rr)r rr,rds rrEBboxTransformTo.__init__ sF hv6 "6"  &! rrc"UR(asURRupp4[(aUS:XdUS:Xa [ S5e[ R "USU/SXB//SQ/[5UlSUl SUlUR$Nrz(Transforming to a singular bounding box.r'r) rBrrrrGrrrrr)r rrrrs rrBboxTransformTo.get_matrix s ==%)\\%8%8 "Du$!)tqy !KLL4#t"4$'"4"4"6"'(DI"DNDMyyr)rrBrrrrs@rrr s* L y)G  rrr7c\rSrSrSrSrSrg)BboxTransformToMaxOnlyi- z `BboxTransformToMaxOnly` is a transformation that linearly transforms points from the unit bounding box to a given `Bbox` with a fixed upper left of (0, 0). c"UR(asURRup[(aUS:XdUS:Xa [ S5e[ R "USS/SUS//SQ/[5UlSUl SUlUR$r) rBrrrrGrrrrr)r rrs rr!BboxTransformToMaxOnly.get_matrix3 s ==))JDu$!)tqy !KLL4#s"3$'s"3"3"5"'(DI"DNDMyyrrN)r(rrrrrrr:rrrr- s  rrcF^\rSrSrSrSrU4Sjr\"S5rSr Sr U=r $)BboxTransformFromiB z^ `BboxTransformFrom` linearly transforms points from a given `Bbox` to the unit bounding box. Tc >[R"[US9 [TU]"S0UD6 XlUR U5 SUlSUlg)N)rr:) rrrr]rErr`rr)r rr,rds rrEBboxTransformFrom.__init__I sD he4 "6"  %  rrcFUR(aURRupp4[(aUS:XdUS:Xa [ S5eSU- nSU- n[ R "USU*U-/SXb*U-//SQ/[5UlSUl SUlUR$)Nrz*Transforming from a singular bounding box.r'r'r) rBrrrrGrrrrr)r rrrrrrs rrBboxTransformFrom.get_matrixT s ==!%!3!3 Ccu#(cQh !MNNCiGCiG7cT'\"B'*GT'\"B"B"D"'(DI"DNDMyyr)rrBrrrrs@rrrB s*Lx(GrrcB^\rSrSrSrU4Sjr\"S5rSrSr U=r $)ScaledTranslationie zp A transformation that translates by *xt* and *yt*, after *xt* and *yt* have been transformed by *scale_trans*. c >[TU]"S0UD6 X4UlX0lUR U5 SUlSUlgNr:)r]rE_t _scale_transr`rr)r xtyt scale_transr,rds rrEScaledTranslation.__init__j s> "6"(' +& rrc UR(ag[RR5UlURR UR 5URSS2S4'SUlSUlUR$)Nrr)rBrmrr\rrrrrHs rrScaledTranslation.get_matrixt sb ==)..335DI#00::477CDIIbqb!e DM!DNyyr)rBrrrr) r(rrrrrEr2rIrrrrs@rrre s#t$Grrc2^\rSrSrSrU4SjrSrSrU=r$)_ScaledRotationi zV A transformation that applies rotation by *theta*, after transform by *trans_shift*. cH>[TU]5 XlX lSUlgr )r]rE_theta _trans_shiftr)r r# trans_shiftrds rrE_ScaledRotation.__init__ s   ' rcUR(a^URRURS//5SnUSn[ 5R U5nUR 5UlUR$r)rBrrrrrrr)r transformed_coordsadjusted_thetarotations rr_ScaledRotation.get_matrix sh ==!%!2!2!N=O!PQR!S /2Nz((8H ++-DIyyr)rrr) r(rrrrrErrrrs@rrr s rrcF^\rSrSrSrSrU4Sjr\"S5rSr Sr U=r $)AffineDeltaTransformi aJ A transform wrapper for transforming displacements between pairs of points. This class is intended to be used to transform displacements ("position deltas") between pairs of points (e.g., as the ``offset_transform`` of `.Collection`\s): given a transform ``t`` such that ``t = AffineDeltaTransform(t) + offset``, ``AffineDeltaTransform`` satisfies ``AffineDeltaTransform(a - b) == AffineDeltaTransform(a) - AffineDeltaTransform(b)``. This is implemented by forcing the offset components of the transform matrix to zero. This class is experimental as of 3.3, and the API may change. Tc T>[TU]"S0UD6 XlURU5 gr)r]rE_base_transformr`)r rr,rds rrEAffineDeltaTransform.__init__ s' "6"( )$rrcUR(a@URR5R5UlSURSS2S4'UR$)Nrrr()rBrrr\rrHs rrAffineDeltaTransform.get_matrix sH ==,,779>>@DI !DIIbqb"f yyr)rr) r(rrrrrqrEr2rIrrrrs@rrr s+ L% 01GrrcJ^\rSrSrSrU4SjrSrSrSrSr Sr S r U=r $) TransformedPathi aE A `TransformedPath` caches a non-affine transformed copy of the `~.path.Path`. This cached copy is automatically updated when the non-affine part of the transform changes. .. note:: Paths are considered immutable by this class. Any update to the path's vertices/codes will not trigger a transform recomputation. c>[R"[US9 [TU]5 XlX lURU5 SUlSUl g)zD Parameters ---------- path : `~.path.Path` transform : `Transform` rN) rrr r]rE_pathr$r`_transformed_path_transformed_points)r rrrds rrETransformedPath.__init__ sH i9=  # )$!%#' rc\URUR:Xd URc~URR UR 5Ul[ R"URRUR R5SUR 5Ul SUlgr) rBrAr r$rr r rrrbr rHs r _revalidateTransformedPath._revalidate s MMT// /))199$**E  "//OO889L9LM$**&  $ rcZUR5 URUR54$)a Return a copy of the child path, with the non-affine part of the transform already applied, along with the affine part of the path necessary to complete the transformation. Unlike :meth:`get_transformed_path_and_affine`, no interpolation will be performed. )rr rrHs r!get_transformed_points_and_affine1TransformedPath.get_transformed_points_and_affine s( ''):::rcZUR5 URUR54$)z Return a copy of the child path, with the non-affine part of the transform already applied, along with the affine part of the path necessary to complete the transformation. )rr rrHs rget_transformed_path_and_affine/TransformedPath.get_transformed_path_and_affine s( %%t'888rclUR5 URRUR5$)z4 Return a fully-transformed copy of the child path. )rr$rr rHs rget_fully_transformed_path*TransformedPath.get_fully_transformed_path s+ 44T5K5KLLrc6URR5$r )r$rrHs rrTransformedPath.get_affine s))++r)rBr r$r r ) r(rrrrrErrrrrrrrs@rrr s,  (  ;9M,,rrc8^\rSrSrSrU4SjrU4SjrSrU=r$)TransformedPatchPathi z A `TransformedPatchPath` caches a non-affine transformed copy of the `~.patches.Patch`. This cached copy is automatically updated when the non-affine part of the transform or the patch changes. cj>[TU]UR5UR55 Xlg)z1 Parameters ---------- patch : `~.patches.Patch` N)r]rEget_path get_transform_patch)r patchrds rrETransformedPatchPath.__init__ s) )5+>+>+@A rc>URR5nXR:wa XlSUl[TU]5 gr )r rr r r]r)r patch_pathrds rr TransformedPatchPath._revalidate s9[[))+   ##J%)D " r)r r r ) r(rrrrrErrrrs@rrr s rrc[R"U5(a"U5(dU*U4$SnX:aXpSn[[X/5up[ [ U5[ U55nUSU- [R "[5R-:aU*nUnO *vmax*. Returns ------- vmin, vmax : float Endpoints, expanded and/or swapped if necessary. If either input is inf or NaN, or if both inputs are 0 or very close to zero, it returns -*expander*, *expander*. FTg.Ar)risfinitemaprrabsfinfotiny)vminvmaxexpanderr+ increasingswapped maxabsvalues r nonsingularr2 s8 KK  r{{4'8'8y(""G {dUTL)JDc$iT+KcDjBHHUO$8$888y  * * 199DD SY& &D SY& &Dzd :rc@Uup#X#:aX2p2X!s=:*=(a U:*$s $)a  Check, inclusively, whether an interval includes a given value. Parameters ---------- interval : (float, float) The endpoints of the interval. val : float Value to check is within interval. Returns ------- bool Whether *val* is within the *interval*. r:rrcror7s rinterval_containsr5O s( DAu1 ==q==rcXUup4X4:aXCpCXC- U-nX2- Us=:*=(a XB-:*$s $)aP Check, inclusively, whether an interval includes a given value, with the interval expanded by a small tolerance to admit floating point errors. Parameters ---------- interval : (float, float) The endpoints of the interval. val : float Value to check is within interval. rtol : float, default: 1e-10 Relative tolerance slippage allowed outside of the interval. For an interval ``[a, b]``, values ``a - rtol * (b - a) <= val <= b + rtol * (b - a)`` are considered inside the interval. Returns ------- bool Whether *val* is within the *interval* (with tolerance). r:)rrcrtolror7s r_interval_contains_closer8e s=, DAu1 ET>D 8s & &ah && &&rchUup#X!s=:=(a U:Os =(d X!s=:=(a U:$s $)a Check, excluding endpoints, whether an interval includes a given value. Parameters ---------- interval : (float, float) The endpoints of the interval. val : float Value to check is within interval. Returns ------- bool Whether *val* is within the *interval*. r:r4s rinterval_contains_openr: s+ DA ;;Q; %!++A+%+%rc[R"/SQUS9 US:XaU[5RX#5-$Uc [ S5eUS:Xa US-nUS-nU[ X#UR 5-$)a Return a new transform with an added offset. Parameters ---------- trans : `Transform` subclass Any transform, to which offset will be applied. fig : `~matplotlib.figure.Figure`, default: None Current figure. It can be None if *units* are 'dots'. x, y : float, default: 0.0 The offset to apply. units : {'inches', 'points', 'dots'}, default: 'inches' Units of the offset. Returns ------- `Transform` subclass Transform with applied offset. )dotsrinches)unitsr<z3For units of inches or points a fig kwarg is neededrgR@)r check_in_listrr-rGrdpi_scale_trans)transfigrrr>s r offset_copyrC sx( 35A xz++A111 {NOO  T  T  $Q3+>+>? ??r)gMbP?gV瞯rHsJ  JJ 8yyxFM}FMR((BFFBFF+,Y?8Y?x HXhHXVv8vrV$ V$r KAyKA\//dA:AH[E|[E|/ /d++$ZmYZz2m\2j =o4 o4d2 2j+6'L'T#l#L_(  F 4l&<BD,mD,N?67t,':&(@r