intellecton/venv/lib/python3.12/site-packages/matplotlib/__pycache__/image.cpython-312.pyc

<EFBFBD>
<00>Rj<>
<00><00><><00>dZd
dl
Z
d
dlZd
dlZd
dlmZ
d
dlZd
dlZd
dl	Z
d
dlZ
d
dlZ
d
dlmZmZ
d
dlmZ
d
dl<11>
d
dlmZ
d
dlmZ
d
dlmZ
d
dlmZ
d
dlmZmZm Z m!Z!m"Z"m#Z#m$Z$
ejJe&<26>
Z'id	ejP<00>
d
ejP<00>
dejP<00>
dejR<00>
d
ejT<00>
dejV<00>
dejX<00>
dejZ<00>
dej\<00>
dej^<00>
dej`<00>
dejb<00>
dejd<00>
dejf<00>
dejh<00>
dejj<00>
dejl<00>
ejnejpejPd<1A><03>
Z9e:e9<65>
Z;d3d<1B>
Z<	d4d<1C>
Z=ddd<1E>d<1F>Z>d <20>Z?Gd!<21>d"ej<><00>ZAGd#<23>d$eA<65>ZBGd%<25>d&eB<65>ZCGd'<27>d(eB<65>ZDGd)<29>d*eA<65>ZEGd+<2B>d,eA<65>ZFd4d-<2D>
ZG		d5ddd.<2E>d/<2F>ZHd0<64>ZId1<64>ZJ		d6d2<64>
ZKy)7zR
The image module supports basic image loading, rescaling and display
operations.
<EFBFBD>N)
<01>Path)<02>_api<70>cbook)
<01>_image)
<01>
*)
<01>FigureCanvasBase)<07>Affine2D<32>BboxBase<73>Bbox<6F>
BboxTransform<72>BboxTransformTo<54>IdentityTransform<72>TransformedBbox<6F>auto<74>none<6E>nearest<73>bilinear<61>bicubic<69>spline16<31>spline36<33>hanning<6E>hamming<6E>hermite<74>kaiser<65>quadric<69>catrom<6F>gaussian<61>bessel<65>mitchell<6C>sinc)<03>lanczos<6F>blackman<61>antialiasedc
<00><><00>t
|<00>
d
k(r(tjdtj<00><03>d
d
fSg}g}|D]<5D>}|j	|
|<02>\}}}}	|<06>
<01>||z}||z}|j||||j
<00>f<04>

|jt||g||jdz||jd
zgg<02>
<00>

<00><>t
|<03>
d
k(r(tjdtj<00><03>d
d
fStj|<04>
}
tjt|
j<00>
t|
j<00>
dftj<00><03>}|D]d\}}}}t<00>j||
j z
||
j"z
<00>}	t%j&|||	t$j(d|<0C><07>
<00>f||
j |z|
j"|zfS)a5
    Composite a number of RGBA images into one.  The images are
    composited in the order in which they appear in the *images* list.

    Parameters
    ----------
    images : list of Images
        Each must have a `make_image` method.  For each image,
        `can_composite` should return `True`, though this is not
        enforced by this function.  Each image must have a purely
        affine transformation with no shear.

    renderer : `.RendererBase`

    magnification : float, default: 1
        The additional magnification to apply for the renderer in use.

    Returns
    -------
    image : (M, N, 4) `numpy.uint8` array
        The composited RGBA image.
    offset_x, offset_y : float
        The (left, bottom) offset where the composited image should be placed
        in the output figure.
    r)rr<00><00>
<01>dtype<70>
r%F<><02>resample<6C>alpha)<15>len<65>np<6E>empty<74>uint8<74>
make_image<EFBFBD>append<6E>_get_scalar_alphar<00>shape<70>union<6F>zeros<6F>int<6E>height<68>widthr	<00>	translate<74>x0<78>y0rr*<00>NEAREST)
<0A>images<65>renderer<65>
magnification<6F>parts<74>bboxes<65>image<67>data<74>
x<>
y<>trans<6E>bbox<6F>outputr+s
             <20>S/home/antigravity/intellecton/venv/lib/python3.12/site-packages/matplotlib/image.py<70>composite_imagesrJ<s<>
<00><00>4<0B>6<EFBFBD>{<7B>a<EFBFBD><17><11>x<EFBFBD>x<EFBFBD>	<09><12><18><18>2<>A<EFBFBD>q<EFBFBD>8<>8<><0E>E<EFBFBD>
<0F>F<EFBFBD><17>H
<01><05>!<21>,<2C>,<2C>X<EFBFBD>}<7D>E<><19><04>a<EFBFBD><11>E<EFBFBD><0F><1B>
<0A><1D><1E>A<EFBFBD>
<0A><1D><1E>A<EFBFBD><11>L<EFBFBD>L<EFBFBD>$<24>
<01>1<EFBFBD>e<EFBFBD>&=<3D>&=<3D>&?<3F>@<40>A<><12>M<EFBFBD>M<EFBFBD><14>q<EFBFBD>!<21>f<EFBFBD>q<EFBFBD>4<EFBFBD>:<3A>:<3A>a<EFBFBD>=<3D>0<>!<21>d<EFBFBD>j<EFBFBD>j<EFBFBD><11>m<EFBFBD>2C<32>D<>E<>F<>

H
<01>
H
<01><0B>5<EFBFBD>z<EFBFBD>Q<EFBFBD><EFBFBD><11>x<EFBFBD>x<EFBFBD>	<09><12><18><18>2<>A<EFBFBD>q<EFBFBD>8<>8<><0F>:<3A>:<3A>f<EFBFBD><1D>D<EFBFBD>
<0F>X<EFBFBD>X<EFBFBD>	<0C>T<EFBFBD>[<5B>[<5B>	<19>3<EFBFBD>t<EFBFBD>z<EFBFBD>z<EFBFBD>?<3F>A<EFBFBD>.<2E>b<EFBFBD>h<EFBFBD>h<EFBFBD>
@
<01>F<EFBFBD>#<23>5<><19><04>a<EFBFBD><11>E<EFBFBD><18>
<EFBFBD>$<24>$<24>Q<EFBFBD><14><17><17>[<5B>!<21>d<EFBFBD>g<EFBFBD>g<EFBFBD>+<2B>><3E><05><0E><0F><0F><04>f<EFBFBD>e<EFBFBD>V<EFBFBD>^<5E>^<5E>!&<26>e<EFBFBD>
	5<>5<>
<12>4<EFBFBD>7<EFBFBD>7<EFBFBD>]<5D>*<2A>D<EFBFBD>G<EFBFBD>G<EFBFBD>m<EFBFBD>,C<>C<>C<>c<00><>
<00><00>
<01><08>	<09>t
d
<01>|D<00><00>
}|<03>|n<0F>j<00>}|s|s|D]}|j<00><00>

<00>yg<00><08>j<00><00>	<09><08>	<09>
<01>fd<03>}|D]l}t	|t
<00>rB|j
<00>r2|j<00>r"|j<00>s<12>j|<06>

<00>U|<07>
|j<00><00>

<00>n|<07>
y)a

    Draw a sorted list of artists, compositing images into a single
    image where possible.

    For internal Matplotlib use only: It is here to reduce duplication
    between `Figure.draw` and `Axes.draw`, but otherwise should not be
    generally useful.
    c
3<00><K
<00>|]}
t
|
t<00><00>
<01>

<00>y<00>w
<01>
N)<02>
isinstance<EFBFBD>
_ImageBase<EFBFBD><02>.0rDs  rI<00>	<genexpr>z0_draw_list_compositing_images.<locals>.<genexpr>~s<00><00><><00>@<40>1<EFBFBD>Z<EFBFBD>
<01>:<3A>.<2E>@<40>s<00>
Nc<00><>
<00><04>t
<00><04>
d
k(r<15>dj<00><07>

n<>t
<00><04>
d
kDr<>t<00><04><07><05>\}}
}|jdk7r<><72>j	<00>}|j<00>j<00>

|j<00>j<00><00>

<00>j|t|
<01>
t|<02>
|<00>
|j<00>
<00>dd<00>=y)Nr(r)r,<00>drawrJ<00>size<7A>new_gc<67>set_clip_rectanglerG<00>
set_clip_path<74>
get_clip_path<74>
draw_image<EFBFBD>round<6E>restore)rC<00>
l<>
b<>gc<67>image_group<75>mag<61>parentr>s    <20><><EFBFBD><EFBFBD>rI<00>flush_imagesz3_draw_list_compositing_images.<locals>.flush_images<65>s<><00><><00><12>;<3B><1F>1<EFBFBD>$<24><1B>A<EFBFBD><0E>#<23>#<23>H<EFBFBD>-<2D><14>[<5B>!<21>A<EFBFBD>%<25>-<2D>k<EFBFBD>8<EFBFBD>S<EFBFBD>I<>
<EFBFBD><04>a<EFBFBD><11><17>9<EFBFBD>9<EFBFBD>
<01>><3E>!<21><1F><1F>*<2A>B<EFBFBD><16>)<29>)<29>&<26>+<2B>+<2B>6<><16>$<24>$<24>V<EFBFBD>%9<>%9<>%;<3B><<3C><1C>'<27>'<27><02>E<EFBFBD>!<21>H<EFBFBD>e<EFBFBD>A<EFBFBD>h<EFBFBD><04>E<><16>J<EFBFBD>J<EFBFBD>L<EFBFBD><1B>A<EFBFBD>rK)
<EFBFBD>any<6E>option_image_nocompositerU<00>get_image_magnificationrOrP<00>
can_composite<74>get_clip_onrZr1)
r>rc<00>artists<74>suppress_composite<74>
has_images<EFBFBD>
not_composite<74>
ardrarbs
``      @@rI<00>_draw_list_compositing_imagesrots<><00><><00><15>@<40><07>@<40>@<40>J<EFBFBD>,><3E>+I<>'<27>"<22>;<3B>;<3B>=<3D><12><15>J<EFBFBD><18>
	<1D>A<EFBFBD>
<0A>F<EFBFBD>F<EFBFBD>8<EFBFBD><1C>
	<1D><19><0B><16>.<2E>.<2E>0<><03>	<1F><19>	!<21>A<EFBFBD><1A>1<EFBFBD>j<EFBFBD>)<29>a<EFBFBD>o<EFBFBD>o<EFBFBD>.?<3F><15>M<EFBFBD>M<EFBFBD>O<EFBFBD>A<EFBFBD>O<EFBFBD>O<EFBFBD>,=<3D><1B>"<22>"<22>1<EFBFBD>%<25><1C><0E><11><06><06>x<EFBFBD> <20>
	!<21>	<15>rKr(r)c<00><><00>d
}|
jddkDr|tj|jd<04><05>
<00>

t	tj|
jddz<00>
<00>
}|
dd<06>dd|<07>f}
t<00>j|d<02>|z}|
jddkDr|tj|jd	<09><05>
<00>

t	tj|
jddz<00>
<00>
}|
dd|<07>dd<06>f}
t<00>jd|<07>|z}|j<00>}|d
v<00>
r!tjddg|
jd|
jdgg<02>
}	|j|	<09>
}
tjtj|
dd<06>df<00>
<00>
}tjtj|
dd<06>df<00>
<00>
}|d|
jdzkDs'||
jdk(s|d|
jdzk(r?|d|
jdzkDs'||
jdk(s|d|
jdzk(rd
}nd}tj||
jddz|
j<00>}
|<04>|j!<00>}t#j$|
|
|t&||||j)<00>|j+<00><00>
|
S)a

    Convenience wrapper around `._image.resample` to resample *data* to
    *out_shape* (with a third dimension if *data* is RGBA) that takes care of
    allocating the output array and fetching the relevant properties from the
    Image object *image_obj*.
    z<>Data with more than {n} cannot be accurately displayed. Downsampling to less than {n} before displaying. To remove this warning, manually downsample your data.r(i<00>z
2**23 columns)
<01>
nNri
z
2**24 rows<77>r#r<00><00>rr)r3<00>warnings<67>warn<72>formatr6r-<00>ceilr	<00>scale<6C>get_interpolation<6F>array<61>	transform<72>abs<62>diffr5r'<00>get_resamplerr*<00>	_interpd_<64>get_filternorm<72>
get_filterrad)<0E>	image_objrC<00>	out_shaper|r*r+<00>msg<73>step<65>
interpolation<6F>pos<6F>disp<73>dispx<70>dispy<70>outs              rI<00>	_resampler<65><00>sw<00><00>D
<01>C<EFBFBD><0C>z<EFBFBD>z<EFBFBD>!<21>}<7D>u<EFBFBD><1C><10>
<0A>
<0A>c<EFBFBD>j<EFBFBD>j<EFBFBD>?<3F>j<EFBFBD>3<>4<><12>2<EFBFBD>7<EFBFBD>7<EFBFBD>4<EFBFBD>:<3A>:<3A>a<EFBFBD>=<3D>5<EFBFBD>0<>1<>2<><04><13>A<EFBFBD>v<EFBFBD><14>v<EFBFBD>I<EFBFBD><EFBFBD><04><1C>J<EFBFBD>$<24>$<24>T<EFBFBD>1<EFBFBD>-<2D>	<09>9<>	<09><0B>z<EFBFBD>z<EFBFBD>!<21>}<7D>u<EFBFBD><1C><10>
<0A>
<0A>c<EFBFBD>j<EFBFBD>j<EFBFBD><<3C>j<EFBFBD>0<>1<><12>2<EFBFBD>7<EFBFBD>7<EFBFBD>4<EFBFBD>:<3A>:<3A>a<EFBFBD>=<3D>5<EFBFBD>0<>1<>2<><04><13>F<EFBFBD>d<EFBFBD>F<EFBFBD>A<EFBFBD>I<EFBFBD><EFBFBD><04><1C>J<EFBFBD>$<24>$<24>Q<EFBFBD><04>-<2D>	<09>9<>	<09><1E>/<2F>/<2F>1<>M<EFBFBD><14>/<2F>/<2F><11>h<EFBFBD>h<EFBFBD><11>A<EFBFBD><06><14><1A><1A>A<EFBFBD><1D><04>
<EFBFBD>
<EFBFBD>1<EFBFBD>
<0A> ><3E>?<3F>@<40><03><18>"<22>"<22>3<EFBFBD>'<27><04><12><06><06>r<EFBFBD>w<EFBFBD>w<EFBFBD>t<EFBFBD>A<EFBFBD>q<EFBFBD>D<EFBFBD>z<EFBFBD>*<2A>+<2B><05><12><06><06>r<EFBFBD>w<EFBFBD>w<EFBFBD>t<EFBFBD>A<EFBFBD>q<EFBFBD>D<EFBFBD>z<EFBFBD>*<2A>+<2B><05>
<12>Q<EFBFBD><14><1A><1A>A<EFBFBD><1D>&<26>
&<26><15><14><1A><1A>A<EFBFBD><1D>&<26><15><11>T<EFBFBD>Z<EFBFBD>Z<EFBFBD>
<01>]<5D>*<2A>*<2A>
<12>Q<EFBFBD><14><1A><1A>A<EFBFBD><1D>&<26>
&<26><15><14><1A><1A>A<EFBFBD><1D>&<26><15><11>T<EFBFBD>Z<EFBFBD>Z<EFBFBD>
<01>]<5D>*<2A>*<2A>%<25>M<EFBFBD>%<25>M<EFBFBD>
<0C>(<28>(<28>9<EFBFBD>t<EFBFBD>z<EFBFBD>z<EFBFBD>!<21>"<22>~<7E>-<2D>t<EFBFBD>z<EFBFBD>z<EFBFBD>
:<3A>C<EFBFBD><0F><17><1C>)<29>)<29>+<2B><08>
<EFBFBD>O<EFBFBD>O<EFBFBD>D<EFBFBD>#<23>y<EFBFBD><1D>m<EFBFBD>,<2C><1C><19><1D>,<2C>,<2C>.<2E><1D>+<2B>+<2B>-<2D>/<2F><0F>JrKc
<00>
<00>t
j|jd
|jddf|j<00><04>}
||
dd<05>dd<05>dd<06>f<|
jtjk(rd|
dd<05>dd<05>df<|
Sd|
dd<05>dd<05>df<|
S)	z\
    Convert an RGB image to RGBA, as required by the image resample C++
    extension.
    rr(r%r&Nrs<00><><00><00>?)r-r5r3r'r/)<02>
A<>rgbas  rI<00>_rgb_to_rgbar<61><00>s~<00><00>
<0E>8<EFBFBD>8<EFBFBD>Q<EFBFBD>W<EFBFBD>W<EFBFBD>Q<EFBFBD>Z<EFBFBD><11><17><17><11><1A>Q<EFBFBD>/<2F>q<EFBFBD>w<EFBFBD>w<EFBFBD>?<3F>D<EFBFBD><16>D<EFBFBD><11>A<EFBFBD>r<EFBFBD>
<01>r<EFBFBD><18>N<EFBFBD><0B>z<EFBFBD>z<EFBFBD>R<EFBFBD>X<EFBFBD>X<EFBFBD><1D><1B><04>Q<EFBFBD>
<01>1<EFBFBD>W<EFBFBD>
<0A><10>K<EFBFBD><1C><04>Q<EFBFBD>
<01>1<EFBFBD>W<EFBFBD>
<0A><0F>KrKc<00>
<00><00>eZ
dZd
ZdZ								d!dd<04>
<01>f
d<05>Zd<06>Z<06>f
d<07>Zd<08>Zd	<09>Z	d
<EFBFBD>Z
d<0B>Z<0B>f
d<0C>Z		d"d
<0A>
Z
d#d<0E>
Zd<0F>Zej"d<10><00>Zd<11>Zd<12>Zed<13><00>Zd<14>Zd<15>Zd<16>Zd<17>Zd<18>Zd<19>Zd<1A>Zd<1B>Zd<1C>Zd<1D>Z d<1E>Z!d<1F>Z"d <20>Z#<23>x
Z$S)$rPa<>

    Base class for images.

    interpolation and cmap default to their rc settings

    cmap is a colors.Colormap instance
    norm is a colors.Normalize instance to map luminance to 0-1

    extent is data axes (left, right, bottom, top) for making image plots
    registered with data plots.  Default is to label the pixel
    centers with the zero-based row and column indices.

    Additional kwargs are matplotlib.artist properties
    rN)
<01>interpolation_stagec

<00><>
<00>
<01>t<00>|<00>|j|||<04><00>

|<06>tjd
}tjddg|<06><04>
||_|j|<07>

|j|<08>

|j|<05>

|j|
<EFBFBD>

|j|	<09>

|
|_
d|_|j|<0B>

y)N<>image.origin<69>upper<65>lower<65>
<01>origin)<10>super<65>__init__<5F>_get_colorizer<65>mpl<70>rcParamsr<00>
check_in_listr<74><00>set_filternorm<72>
set_filterrad<61>set_interpolation<6F>set_interpolation_stage<67>set_resample<6C>axes<65>_imcache<68>_internal_update)
<0A>self<6C>ax<61>cmap<61>norm<72>	colorizerr<72>r<><00>
filternorm<EFBFBD>	filterradr*r<><00>kwargs<67>	__class__s
            <20>rIr<>z_ImageBase.__init__<5F>s<><00><><00>	<0E><07><18><14>,<2C>,<2C>T<EFBFBD>4<EFBFBD><19>C<>D<><11>><3E><18>\<5C>\<5C>.<2E>1<>F<EFBFBD><0C><1A><1A>G<EFBFBD>W<EFBFBD>-<2D>f<EFBFBD>=<3D><1C><04><0B><0C><1B><1B>J<EFBFBD>'<27><0C><1A><1A>9<EFBFBD>%<25><0C><1E><1E>}<7D>-<2D><0C>$<24>$<24>%8<>9<><0C><19><19>(<28>#<23><16><04>	<09><1C><04>
<0A><0C><1D><1D>f<EFBFBD>%rKc
<00><><00>	|j
<00>}
t|<00>
j<00>d
|
<01>d<02>S#t$r
t|<00>
jcYSwxYw
)Nz(shape=<3D>
))<04>	get_shape<70>type<70>__name__<5F>RuntimeError)r<>r3s  rI<00>__str__z_ImageBase.__str__
sP<00><00>	'<27><18>N<EFBFBD>N<EFBFBD>$<24>E<EFBFBD><1A>4<EFBFBD>j<EFBFBD>)<29>)<29>*<2A>'<27>%<25><19>!<21><<3C><<3C><><1B>
	'<27><17><04>:<3A>&<26>&<26>&<26>
	'<27>s<00>*-<00>A<03>

Ac
<00>,<00>
<01>it<00>
|<00><00><00>
d
di
<01>
S)Nr<4E>)r<><00>__getstate__<5F>r<>r<>s <20>rIr<>z_ImageBase.__getstate__
s<00><><00>;<3B>%<25>'<27>&<26>(<28>;<3B>*<2A>d<EFBFBD>;<3B>;rKc
<00>(<00>|j
<00>d
dS)z9Return the size of the image as tuple (numrows, numcols).Nrt)
r<><00>
r<>s
 rI<00>get_sizez_ImageBase.get_size"
s<00><00><13>~<7E>~<7E><1F><02><11>#<23>#rKc
<00>\<00>|j<00>td
<01>
<00>
|jjS)zV
        Return the shape of the image as tuple (numrows, numcols, channels).
        <20>"You must first set the image array)<03>_Ar<41>r3r<>s
 rIr<>z_ImageBase.get_shape&
s'<00><00><10>7<EFBFBD>7<EFBFBD>?<3F><1E>C<>D<>D<><13>w<EFBFBD>w<EFBFBD>}<7D>}<7D>rKc<00><><00>tjj||
<01>
tj|
<01>
d
v
rtd<02>
<00>
d|_y)z<>
        Set the alpha value used for blending - not supported on all backends.

        Parameters
        ----------
        alpha : float or 2D array-like or None
        )rrtz5alpha must be a float, two-dimensional array, or NoneN)<07>martist<73>Artist<73>_set_alpha_for_arrayr-<00>ndim<69>	TypeErrorr<72>)r<>r+s  rI<00>	set_alphaz_ImageBase.set_alpha/
sA<00><00>	<10><0E><0E>+<2B>+<2B>D<EFBFBD>%<25>8<>
<0A>7<EFBFBD>7<EFBFBD>5<EFBFBD>><3E><16>'<27><1B>
-<2D>
.<2E>

.<2E><1C><04>
rKc
<00>z<00>|j<00>"tj|j<00>
d
kDrdS|jS)a<>

        Get a scalar alpha value to be applied to the artist as a whole.

        If the alpha value is a matrix, the method returns 1.0 because pixels
        have individual alpha values (see `~._ImageBase._make_image` for
        details). If the alpha value is a scalar, the method returns said value
        to be applied to the artist as a whole because pixels do not have
        individual alpha values.
        rr<>)<03>_alphar-r<>r<>s
 rIr2z_ImageBase._get_scalar_alpha=
s5<00><00><1B>k<EFBFBD>k<EFBFBD>)<29>R<EFBFBD>W<EFBFBD>W<EFBFBD>T<EFBFBD>[<5B>[<5B>-A<>A<EFBFBD>-E<>s<EFBFBD>
	<1D><15><1B><1B>
	rKc
<00>0<00>
<01>d
|_t<00>
|<00>	<00>
y
)zU
        Call this whenever the mappable is changed so observers can update.
        N)r<>r<><00>changedr<64>s <20>rIr<>z_ImageBase.changedJ
s<00><><00><1D><04>
<0A>
<0A><07><0F>rKc
<00>$<00>|
<01>t
d<02>
<00>
|
jdk(rt
d<04>
<00>
tj||<04>}|<08>
y|j|z}	|j
|z}
|	dk(s|
dk(r
y|jdk(r9t<00>jd|
jd<00>jdd<08>}n
t<00>}|t<00>j|j|
jdz|j
|
jdz<00>j|j|j<00>|j<00>zz
}|t<00>j|j|j<00>j|<05>
z}|s||jrp|rn|	d	zd
k7s|
d	zd
k7r^t!j"|	<09>
}
t!j"|
<EFBFBD>
}|
|	z
|	z}||
z
|
z}|t<00>jd	|zd	|z<00>z
}nt%|	<09>
}
t%|
<EFBFBD>
}||
f}|<06>s}|
j&dk(s9|
j&dk(r|
jdd
vst)d|
j<00>d<0F><03>
<00>
|j*}|dvr<>t-j.ddg|
jd|
jdgg<02>
}|j1|<13>
}t-j2t-j4|d
d
<01>df<00>
<00>
|
jdz}t-j2t-j4|d
d
<01>df<00>
<00>
|
jdz}|dks|dkrd}nd}|
j&dk(<00>rt|dk(<00>rn|
j6j8dk(rzt-j6|
j6j:dkDrdn
d<16>
}|j:|
j6j:krot=j>d|
j6<00>d|<17>d<19><05>

nH|
jA<00>jCd<15>
|
jE<00>jCd<15>
z
}|dkDrdn
d}tG||
jC|<17>
||<0C>}tI|jJtLjN<00>r|jC|
j6<00>
}|
jPj|
jk(rUt-jR|
jPt-jTt,jV<00>
t-jTd<07>
<00>n#t-jX|
t,jT<00>}tG||||d<1B><1C>}~t-jZ|<1B>
}d||<|j]<00>}|<1D>+t-j&|<1D>
dkDr|tG||||d<1B><1C>z}t,j^ja||<1C>}|jK|<1E>
}<1F>
nd|
j&dk(r,|jJjc|
<01>

|je|
<01>
}
|j]<00>}|<1D>d|
jddk(r"|
j6t,jfk(rdn
d	} ntG||
d||<0C>} tG|ti|
dd
d<0C>f<00>
||<0C>}n<>t-j&|<1D>
dkDr-tG||||<0C>} tG|ti|
dd
d<0C>f<00>
||<0C>}ni|
jddk(r%|
j6t,jfk(rd|zn
|} ntG||
d||<0C>|z} tG|ti|
dd
d<0C>f<00>
||<0C>}| |d<|je|dd <20>!<21>}|
j&dk(<00>
r<>|jk<00>}|d
d
<01>d
d
<01>df}!|!jCt,jT<00>
z|z|!d
d
<00>
n\|jl<00>&|je|
d|
j&dk(<00>!<21>|_6|jl}to||jq<00><00>js<00>}"|t%tA|"jtd<03><00>
t%tE|"jvdz|jd<00><00>
<00>t%tA|"jxd<03><00>
t%tE|"jzdz|jd<00><00>
<00>f}t<00>jt%tA|"jxd<03><00>
t%tA|"jtd<03><00>
<00>|z}||j|j|fS)"a<>
        Normalize, rescale, and colormap the image *A* from the given *in_bbox*
        (in data space), to the given *out_bbox* (in pixel space) clipped to
        the given *clip_bbox* (also in pixel space), and magnified by the
        *magnification* factor.

        Parameters
        ----------
        A : ndarray

            - a (M, N) array interpreted as scalar (greyscale) image,
              with one of the dtypes `~numpy.float32`, `~numpy.float64`,
              `~numpy.float128`, `~numpy.uint16` or `~numpy.uint8`.
            - (M, N, 4) RGBA image with a dtype of `~numpy.float32`,
              `~numpy.float64`, `~numpy.float128`, or `~numpy.uint8`.

        in_bbox : `~matplotlib.transforms.Bbox`

        out_bbox : `~matplotlib.transforms.Bbox`

        clip_bbox : `~matplotlib.transforms.Bbox`

        magnification : float, default: 1

        unsampled : bool, default: False
            If True, the image will not be scaled, but an appropriate
            affine transformation will be returned instead.

        round_to_pixel_border : bool, default: True
            If True, the output image size will be rounded to the nearest pixel
            boundary.  This makes the images align correctly with the Axes.
            It should not be used if exact scaling is needed, such as for
            `.FigureImage`.

        Returns
        -------
        image : (M, N, 4) `numpy.uint8` array
            The RGBA image, resampled unless *unsampled* is True.
        x, y : float
            The upper left corner where the image should be drawn, in pixel
            space.
        trans : `~matplotlib.transforms.Affine2D`
            The affine transformation from image to pixel space.
        Nz9You must first set the image array or the image attributerzk_make_image must get a non-empty image. Your Artist's draw method must filter before this method is called.)NrrNr<4E>r(<00><><EFBFBD><EFBFBD><EFBFBD>r<EFBFBD><00>rtrs<00>rsr%<00>Invalid shape <20> for image datarrr<>rC<00>
fr%<00>f8<66>f4zCasting input data from z to z for imshow.g<00>חAT)
r*r<>).rs.F<><02>bytesr<73>)>r<>rVr<00>intersectionr8r7r<>r	r9r3ryrr:r;<00>
get_transform<72>	is_affine<6E>mathrxr6r<><00>
ValueError<EFBFBD>_interpolation_stager-r{r|r}r~r'<00>kind<6E>itemsizer<00>
warn_external<61>max<61>astype<70>minr<6E>rOr<><00>mcolors<72>NoNorm<72>mask<73>where<72>float32<33>nan<61>	ones_like<6B>isnan<61>	get_alpha<68>ma<6D>masked_array<61>autoscale_None<6E>to_rgbar/r<>r2r<>r<00>inverted<65>frozen<65>ymin<69>ymax<61>xmin<69>xmax)#r<>r<><00>in_bbox<6F>out_bbox<6F>	clip_bboxr?<00>	unsampled<65>round_to_pixel_border<65>clipped_bbox<6F>out_width_base<73>out_height_base<73>t0<74>
t<>	out_width<74>
out_height<EFBFBD>extra_width<74>extra_heightr<74>r<>r<>r<>r<>r<><00>scaled_dtype<70>da<64>A_resampledr<64><00>	out_alpha<68>out_maskr+<00>resampled_maskedrH<00>output_alpha<68>
alpha_channel<65>subsets#                                   rI<00>_make_imagez_ImageBase._make_imageQ
s<><00><00>\

<0A>9<EFBFBD><1E>
 ><3E>
?<3F>

?<3F><0C>6<EFBFBD>6<EFBFBD>Q<EFBFBD>;<3B><1E> 8<>9<>
9<><1C>(<28>(<28><18>9<EFBFBD>=<3D><0C><17><1F>#<23>%<25>+<2B>+<2B>m<EFBFBD>;<3B><0E>&<26>-<2D>-<2D>
<0A>=<3D><0F><19>Q<EFBFBD><1E>/<2F>Q<EFBFBD>"6<>#<23><0F>;<3B>;<3B>'<27>!<21><1A><1A>%<25>%<25>a<EFBFBD>!<21>'<27>'<27>!<21>*<2A><1B>5<>;<3B>;<3B>A<EFBFBD>r<EFBFBD>B<>B<EFBFBD>"<22>$<24>B<EFBFBD>
<EFBFBD><14>J<EFBFBD>
<12>U<EFBFBD><17>
<0A>
<0A>
<01><07><07>
<01>
<EFBFBD>*<2A><17><0E><0E><11><17><17><11><1A>+<2B>-<2D><17>Y<EFBFBD>w<EFBFBD>z<EFBFBD>z<EFBFBD>7<EFBFBD>:<3A>:<3A>
.<2E><12> <20> <20>"<22>
#<23>	$<24><02><10><18>
<EFBFBD><1A><19>L<EFBFBD>O<EFBFBD>O<EFBFBD>+<2B>l<EFBFBD>o<EFBFBD>o<EFBFBD>-=<3D>><3E><16><15>}<7D>%<25>'<27>
<01><1B>
<01><0B><0B>0E<30><1F>#<23>%<25><13>,<2C><0F>#<23>0E<30><13>0L<30><1C>	<09>	<09>.<2E>1<>I<EFBFBD><1D><19><19>?<3F>3<>J<EFBFBD>$<24>~<7E>5<><1E>G<>K<EFBFBD>&<26><1F>8<>O<EFBFBD>K<>L<EFBFBD>
<0A><18><1A>!<21>!<21>#<23><0B>"3<>S<EFBFBD><<3C>5G<35>H<>H<>A<EFBFBD><1B>N<EFBFBD>+<2B>I<EFBFBD><1C>_<EFBFBD>-<2D>J<EFBFBD><1F><19>+<2B>	<09><18><15>F<EFBFBD>F<EFBFBD>a<EFBFBD>K<EFBFBD>1<EFBFBD>6<EFBFBD>6<EFBFBD>Q<EFBFBD>;<3B>1<EFBFBD>7<EFBFBD>7<EFBFBD>2<EFBFBD>;<3B>&<26>3H<33> <20>><3E>!<21>'<27>'<27><19>/<2F>!J<>K<>K<>#'<27>";<3B>";<3B><1F>"<22>&=<3D>=<3D><18>h<EFBFBD>h<EFBFBD><11>A<EFBFBD><06><11><17><17><11><1A>Q<EFBFBD>W<EFBFBD>W<EFBFBD>Q<EFBFBD>Z<EFBFBD>(@<40>A<>B<><03><18>{<7B>{<7B>3<EFBFBD>'<27><04><1A><06><06>r<EFBFBD>w<EFBFBD>w<EFBFBD>t<EFBFBD>A<EFBFBD>q<EFBFBD>D<EFBFBD>z<EFBFBD>2<>3<>a<EFBFBD>g<EFBFBD>g<EFBFBD>a<EFBFBD>j<EFBFBD>@<40><05><1A><06><06>r<EFBFBD>w<EFBFBD>w<EFBFBD>t<EFBFBD>A<EFBFBD>q<EFBFBD>D<EFBFBD>z<EFBFBD>2<>3<>a<EFBFBD>g<EFBFBD>g<EFBFBD>a<EFBFBD>j<EFBFBD>@<40><05><19>A<EFBFBD>I<EFBFBD>5<EFBFBD>1<EFBFBD>9<EFBFBD>*0<>'<27>*0<>'<27><10>v<EFBFBD>v<EFBFBD><11>{<7B>2<>f<EFBFBD><<3C><15>7<EFBFBD>7<EFBFBD><<3C><<3C>3<EFBFBD>&<26>#%<25>8<EFBFBD>8<EFBFBD>A<EFBFBD>G<EFBFBD>G<EFBFBD>4D<34>4D<34>q<EFBFBD>4H<34>D<EFBFBD>d<EFBFBD>#S<>L<EFBFBD>#<23>,<2C>,<2C>q<EFBFBD>w<EFBFBD>w<EFBFBD>/?<3F>/?<3F>?<3F><1C>*<2A>*<2A>-E<>a<EFBFBD>g<EFBFBD>g<EFBFBD>Y<EFBFBD>-1<>,<2C><1E>|<7C>
,M
<01>
N
<01><1B><15><15><17><1E><1E><04>-<2D>
<01><05><05><07><0E><0E>t<EFBFBD>0D<30>D<>B<EFBFBD>+-<2D><03>8<EFBFBD>4<EFBFBD><14>L<EFBFBD>(<28><04>a<EFBFBD>h<EFBFBD>h<EFBFBD>|<7C>.D<>i<EFBFBD>QR<51>S<><0B><1E>d<EFBFBD>i<EFBFBD>i<EFBFBD><17><1E><1E>8<>"-<2D>"4<>"4<>Q<EFBFBD>W<EFBFBD>W<EFBFBD>"=<3D>K<EFBFBD><1D>6<EFBFBD>6<EFBFBD><<3C><<3C>1<EFBFBD>7<EFBFBD>7<EFBFBD>2<><1B><08><08><11><16><16><12><1A><1A>B<EFBFBD>F<EFBFBD>F<EFBFBD>);<3B>R<EFBFBD>Z<EFBFBD>Z<EFBFBD>
<01>]<5D>K<><1F>\<5C>\<5C>!<21>R<EFBFBD>Z<EFBFBD>Z<EFBFBD>8<><15>
&<26>d<EFBFBD>D<EFBFBD>)<29>Q<EFBFBD><14>N<>	<09><18><1D>8<EFBFBD>8<EFBFBD>I<EFBFBD>.<2E><08>&'<27>	<09>(<28>#<23><1C><0E><0E>(<28><05><18>$<24><12><17><17><15><1E>!<21>);<3B><1D><19>4<EFBFBD><15>	<09>1<EFBFBD>t<EFBFBD>!T<>T<>I<EFBFBD>#%<25>5<EFBFBD>5<EFBFBD>#5<>#5<>k<EFBFBD>8<EFBFBD>#L<> <20><1D><19><19>#3<>4<><06><14>6<EFBFBD>6<EFBFBD>Q<EFBFBD>;<3B><18>I<EFBFBD>I<EFBFBD>,<2C>,<2C>Q<EFBFBD>/<2F><1C><0C><0C>Q<EFBFBD><0F>A<EFBFBD><1C><0E><0E>(<28><05><18>=<3D><18>w<EFBFBD>w<EFBFBD>q<EFBFBD>z<EFBFBD>Q<EFBFBD><EFBFBD>./<2F>g<EFBFBD>g<EFBFBD><12><18><18>.A<>s<EFBFBD>s<EFBFBD><0C>'0<> <20>!<21>F<EFBFBD>)<29>Y<EFBFBD>
<01>
(;<3B><0C>&<26><1C>l<EFBFBD>1<EFBFBD>S<EFBFBD>"<22>1<EFBFBD>"<22>W<EFBFBD>:<3A>6<>	<09>1<EFBFBD>
F
<01>F<EFBFBD><17>W<EFBFBD>W<EFBFBD>U<EFBFBD>^<5E>a<EFBFBD>'<27>#,<2C>T<EFBFBD>5<EFBFBD>)<29>Q<EFBFBD>#G<>L<EFBFBD>&<26><1C>l<EFBFBD>1<EFBFBD>S<EFBFBD>"<22>1<EFBFBD>"<22>W<EFBFBD>:<3A>6<>	<09>1<EFBFBD>
F
<01>F<EFBFBD><19>w<EFBFBD>w<EFBFBD>q<EFBFBD>z<EFBFBD>Q<EFBFBD><EFBFBD>89<38><07><07>2<EFBFBD>8<EFBFBD>8<EFBFBD>8K<38><03>e<EFBFBD><0B>QV<51><0C>'0<><14>q<EFBFBD><16>y<EFBFBD>)<29>Q<EFBFBD>'O<>RW<52>'W<><0C>&<26><1C>l<EFBFBD>1<EFBFBD>S<EFBFBD>"<22>1<EFBFBD>"<22>W<EFBFBD>:<3A>6<>	<09>1<EFBFBD>
F
<01>F<EFBFBD>!-<2D><06>v<EFBFBD><0E><1A>\<5C>\<5C>&<26><04>5<EFBFBD>\<5C>A<>F<EFBFBD><11>v<EFBFBD>v<EFBFBD><11>{<7B><1C>.<2E>.<2E>0<><05> &<26>q<EFBFBD>!<21>Q<EFBFBD>w<EFBFBD><0F>
<0A>!<21>(<28>(<28><12><1A><1A>4<>y<EFBFBD>@<40>5<EFBFBD>H<><1E>a<EFBFBD> <20><14>}<7D>}<7D>$<24> $<24><0C><0C>Q<EFBFBD>d<EFBFBD>!<21>&<26>&<26>A<EFBFBD>+<2B><0C> O<><04>
<0A><19>]<5D>]<5D>F<EFBFBD>%<25>Y<EFBFBD><02><0B><0B>
<0A>><3E>E<>E<>G<>F<EFBFBD><1B><13>C<EFBFBD><06><0B><0B>Q<EFBFBD>'<27>(<28><13>C<EFBFBD><06><0B><0B>a<EFBFBD><0F><16><1C><1C>a<EFBFBD><1F>9<>:<3A>
;<3B><13>C<EFBFBD><06><0B><0B>Q<EFBFBD>'<27>(<28><13>C<EFBFBD><06><0B><0B>a<EFBFBD><0F><16><1C><1C>a<EFBFBD><1F>9<>:<3A>
;<3B>;<3B><<3C>F<EFBFBD><19>
<EFBFBD>$<24>$<24><13>C<EFBFBD><06><0B><0B>Q<EFBFBD>'<27>(<28>#<23>c<EFBFBD>&<26>+<2B>+<2B>q<EFBFBD>.A<>*B<>
D
<01>FG<46>
H
<01>A<EFBFBD><16>|<7C><EFBFBD><EFBFBD><0C><0F><0F><11>:<3A>:rKc<00><00>t
d
<01>
<00>
)a<>
        Normalize, rescale, and colormap this image's data for rendering using
        *renderer*, with the given *magnification*.

        If *unsampled* is True, the image will not be scaled, but an
        appropriate affine transformation will be returned instead.

        Returns
        -------
        image : (M, N, 4) `numpy.uint8` array
            The RGBA image, resampled unless *unsampled* is True.
        x, y : float
            The upper left corner where the image should be drawn, in pixel
            space.
        trans : `~matplotlib.transforms.Affine2D`
            The affine transformation from image to pixel space.
        z(The make_image method must be overridden<65>
<01>NotImplementedError)r<>r>r?r<>s    rIr0z_ImageBase.make_image-s<00><00>$"<22>"L<>M<>MrKc
<00><00>y
)z|
        Return whether the image is better to be drawn unsampled.

        The derived class needs to override it.
        F<>r<>s
 rI<00>_check_unsampled_imagez!_ImageBase._check_unsampled_imageAs<00><00>rKc<00>`<00>|j
<00>sd
|_
y|j<00>jdk(rd
|_
y|
j	<00>}|j|<02>

|j
|j<00><00>

|j|j<00><00>

|j|j<00><00>

|
j<00>r<>|j<00>r<>|j<00>jrg|j!|
d<03><04>\}}}}|<03><>t#<00>j%|j&d|j&d<00>|z}|
j)|||||<06>
n;|j!|
|
j+<00><00>\}}}}|<03>|
j)||||<03>
|j-<00>
d
|_
y)NFrT<>
r<>r()<17>get_visible<6C>stale<6C>	get_arrayrVrW<00>_set_gc_clipr<70>r2<00>set_url<72>get_url<72>set_gid<69>get_gid<69>option_scale_imager
r<>r<>r0r	ryr3r[rgr])r<>r>r`<00>imr^r_rFs       rIrUz_ImageBase.drawIsa
<00><00><14><1F><1F>!<21><1E>D<EFBFBD>J<EFBFBD><12><0F>><3E>><3E><1B> <20> <20>A<EFBFBD>%<25><1E>D<EFBFBD>J<EFBFBD><12>
<15>_<EFBFBD>_<EFBFBD>
<1E><02><0C><19><19>"<22><1D>
<EFBFBD><0C><0C>T<EFBFBD>+<2B>+<2B>-<2D>.<2E>
<EFBFBD>
<EFBFBD>
<EFBFBD>4<EFBFBD><<3C><<3C>><3E>"<22>
<EFBFBD>
<EFBFBD>
<EFBFBD>4<EFBFBD><<3C><<3C>><3E>"<22><14>'<27>'<27>)<29><18>/<2F>/<2F>1<><18>&<26>&<26>(<28>2<>2<>"<22>o<EFBFBD>o<EFBFBD>h<EFBFBD>$<24>o<EFBFBD>G<>O<EFBFBD>B<EFBFBD>
<01>1<EFBFBD>e<EFBFBD><11>~<7E> <20>
<EFBFBD>(<28>(<28><12><18><18>!<21><1B>b<EFBFBD>h<EFBFBD>h<EFBFBD>q<EFBFBD>k<EFBFBD>B<>U<EFBFBD>J<><05><18>#<23>#<23>B<EFBFBD>
<01>1<EFBFBD>b<EFBFBD>%<25>8<>"<22>o<EFBFBD>o<EFBFBD><18>(<28>:<3A>:<3A><<3C>
><3E>O<EFBFBD>B<EFBFBD>
<01>1<EFBFBD>e<EFBFBD><11>~<7E><18>#<23>#<23>B<EFBFBD>
<01>1<EFBFBD>b<EFBFBD>1<>
<EFBFBD>
<EFBFBD>
<EFBFBD><0C><1A><04>
rKc<00>~
<00>|j
|
<01>
s|jj|
<01>
d
sdifS|j<00>j	<00>}|j|
j|
jg<02>
\}}|j<00>\}}}}|du
x
r$
||z
||z
zd
kx
r
|du
x
r
||z
||z
zd
k}	|	ifS)<04>7Test whether the mouse event occurred within the image.rFN)	<09>_different_canvasr<73><00>containsr<73>r<>r|rDrE<00>
get_extent)
r<EFBFBD><00>
mouseeventrFrDrEr<>r<>r<>r<><00>insides
          rIr%
z_ImageBase.containshs<><00><00><10>"<22>"<22>:<3A>.<2E><1B>y<EFBFBD>y<EFBFBD>)<29>)<29>*<2A>5<>a<EFBFBD>8<><18>"<22>9<EFBFBD><1C>
<15>"<22>"<22>$<24>-<2D>-<2D>/<2F><05><14><EFBFBD><EFBFBD>
<EFBFBD><0C><0C>j<EFBFBD>l<EFBFBD>l<EFBFBD>;<3B><<3C><04>
<01>1<EFBFBD>!%<25><1F><1F>!2<><1E><04>d<EFBFBD>D<EFBFBD>$<24><13>4<EFBFBD>-<2D>
E
<01>Q<EFBFBD><14>X<EFBFBD>!<21>d<EFBFBD>(<28>$;<3B>q<EFBFBD>$@<40>
E
<01><17>t<EFBFBD>m<EFBFBD>
E
<01>)*<2A>T<EFBFBD><18>a<EFBFBD>$<24>h<EFBFBD>(?<3F>1<EFBFBD>(D<>	<0F><15>r<EFBFBD>z<EFBFBD>rKc<00><><00>|j
|jd
k(r|jddd<03>n|jdd<04><05>}tjj|<02>
j
|
d<06><07>
y)z$Write the image to png file *fname*.r<>Nr<4E>Tr<54><00>png)
rw)r<>r<>r<><00>PIL<49>Image<67>	fromarray<61>save)r<><00>fnamer!
s   rI<00>	write_pngz_ImageBase.write_pngzs[<00><00>
<11>\<5C>\<5C>4<EFBFBD>;<3B>;<3B>'<27>+A<>$<24>'<27>'<27>$<24>B<EFBFBD>$<24>-<2D>t<EFBFBD>w<EFBFBD>w<EFBFBD> $<24>4<EFBFBD><1A>
1<><02><0B>	<09>	<09><1B><1B>B<EFBFBD><1F>$<24>$<24>U<EFBFBD>5<EFBFBD>$<24>9rKc
<00><00>t
j|d
<01><02>}|jtjk7r>tj
|jtd<03>std|j<00>d<05><03>
<00>
|jdk(r#|jddk(r|jd<07>
}|jd	k(s9|jdk(r|jdd
vstd|j<00>d<0C><03>
<00>
|jdk(<00>
rtj|jtj<00>rd
n
d}
|j<00>dks|
|j<00>krJtj!d|j<00>|j<00><00>
tj"|d|
<01>}|jtjk7rMtj|jtj<00>r|j%tj<00>
}|S)z|
        Check validity of image-like input *A* and normalize it to a format suitable for
        Image subclasses.
        T)
<01>copy<70>	same_kindzImage data of dtype z cannot be converted to floatrsr<>r(rtr<>r<>r<>r<>rz<>Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers). Got range [%s..%s].)r<00>safe_masked_invalidr'r-r/<00>can_cast<73>floatr<74>r<>r3<00>squeeze<7A>
issubdtype<EFBFBD>integerr<72>r<><00>_log<6F>warning<6E>clipr<70>)r<><00>highs  rI<00>_normalize_image_arrayz!_ImageBase._normalize_image_array<61>st
<00><00>
<12>%<25>%<25>a<EFBFBD>d<EFBFBD>3<>
<01><0C>7<EFBFBD>7<EFBFBD>b<EFBFBD>h<EFBFBD>h<EFBFBD><1E>r<EFBFBD>{<7B>{<7B>1<EFBFBD>7<EFBFBD>7<EFBFBD>E<EFBFBD>;<3B>'O<><1B>2<>1<EFBFBD>7<EFBFBD>7<EFBFBD>)<29>
<1<>
2<>
3<>

3<><0C>6<EFBFBD>6<EFBFBD>Q<EFBFBD>;<3B>1<EFBFBD>7<EFBFBD>7<EFBFBD>2<EFBFBD>;<3B>!<21>+<2B><11>	<09>	<09>"<22>
<0A>A<EFBFBD><11><06><06>!<21><0B>q<EFBFBD>v<EFBFBD>v<EFBFBD><11>{<7B>q<EFBFBD>w<EFBFBD>w<EFBFBD>r<EFBFBD>{<7B>f<EFBFBD>/D<><1B>n<EFBFBD>Q<EFBFBD>W<EFBFBD>W<EFBFBD>I<EFBFBD>_<EFBFBD>E<>F<>F<><0C>6<EFBFBD>6<EFBFBD>Q<EFBFBD>;<3B>
<1D>-<2D>-<2D>
<01><07><07><12><1A><1A><<3C>3<EFBFBD>!<21>D<EFBFBD><10>u<EFBFBD>u<EFBFBD>w<EFBFBD><11>{<7B>d<EFBFBD>Q<EFBFBD>U<EFBFBD>U<EFBFBD>W<EFBFBD>n<EFBFBD><14><0C><0C>*<2A><16>E<EFBFBD>E<EFBFBD>G<EFBFBD>Q<EFBFBD>U<EFBFBD>U<EFBFBD>W<EFBFBD>	<12><17>G<EFBFBD>G<EFBFBD>A<EFBFBD>q<EFBFBD>$<24>'<27>
<01><10>w<EFBFBD>w<EFBFBD>"<22>(<28>(<28>"<22>r<EFBFBD>}<7D>}<7D>Q<EFBFBD>W<EFBFBD>W<EFBFBD>b<EFBFBD>j<EFBFBD>j<EFBFBD>'I<><15>H<EFBFBD>H<EFBFBD>R<EFBFBD>X<EFBFBD>X<EFBFBD>&<26>
<01><10>rKc<00><><00>t
|
tjj<00>rt|
<01>
}
|j	|
<01>
|_d
|_d|_y
)z<>
        Set the image array.

        Note that this function does *not* update the normalization used.

        Parameters
        ----------
        A : array-like or `PIL.Image.Image`
        NT)rOr+
r,
<00>pil_to_arrayr>
r<>r<>r
<00>r<>r<>s  rI<00>set_dataz_ImageBase.set_data<74>s?<00><00><16>a<EFBFBD><13><19><19><1F><1F>)<29><1C>Q<EFBFBD><0F>A<EFBFBD><16>-<2D>-<2D>a<EFBFBD>0<><04><07><1C><04>
<0A><19><04>
rKc<00>&<00>|j
|
<01>

y
)z<>
        Retained for backwards compatibility - use set_data instead.

        Parameters
        ----------
        A : array-like
        N)
rB
rA
s  rI<00>	set_arrayz_ImageBase.set_array<61>s<00><00>	
<0A>
<0A>
<0A>a<EFBFBD>rKc

<00><00>|jS)
aH

        Return the interpolation method the image uses when resizing.

        One of 'auto', 'antialiased', 'nearest', 'bilinear', 'bicubic',
        'spline16', 'spline36', 'hanning', 'hamming', 'hermite', 'kaiser',
        'quadric', 'catrom', 'gaussian', 'bessel', 'mitchell', 'sinc', 'lanczos',
        or 'none'.
        )
<01>_interpolationr<6E>s
 rIrzz_ImageBase.get_interpolation<6F>s<00><00><14>"<22>"<22>"rKc<00><><00>t
j|
d
<01>j<00>}
tjt
|
<01><02>
|
|_d|_y)a9
        Set the interpolation method the image uses when resizing.

        If None, use :rc:`image.interpolation`. If 'none', the image is
        shown as is without interpolating. 'none' is only supported in
        agg, ps and pdf backends and will fall back to 'nearest' mode
        for other backends.

        Parameters
        ----------
        s : {'auto', 'nearest', 'bilinear', 'bicubic', 'spline16', 'spline36', 'hanning', 'hamming', 'hermite', 'kaiser', 'quadric', 'catrom', 'gaussian', 'bessel', 'mitchell', 'sinc', 'lanczos', 'none'} or None
        zimage.interpolation<6F>
r<>TN)r<><00>
_val_or_rcr<EFBFBD>rr<><00>interpolations_namesrF
r
<00>r<><00>
ss  rIr<>z_ImageBase.set_interpolation<6F>s><00><00>
<10>N<EFBFBD>N<EFBFBD>1<EFBFBD>3<>4<>:<3A>:<3A><<3C>
<01><0C><1A><1A>/<2F>q<EFBFBD>A<><1F><04><1B><19><04>
rKc

<00><00>|jS)
zy
        Return when interpolation happens during the transform to RGBA.

        One of 'data', 'rgba', 'auto'.
        )
r<>r<>s
 rI<00>get_interpolation_stagez"_ImageBase.get_interpolation_stage<67>s<00><00><14>(<28>(<28>(rKc<00>~<00>t
j|
d
<01>}
tjgd<02>
|
<01><03>
|
|_d|_y)a<>

        Set when interpolation happens during the transform to RGBA.

        Parameters
        ----------
        s : {'data', 'rgba', 'auto'} or None
            Whether to apply up/downsampling interpolation in data or RGBA
            space.  If None, use :rc:`image.interpolation_stage`.
            If 'auto' we will check upsampling rate and if less
            than 3 then use 'rgba', otherwise use 'data'.
        zimage.interpolation_stage)rCr<>r)
rL
TN)r<>rI
rr<>r<>r
rK
s  rIr<>z"_ImageBase.set_interpolation_stage<67>s5<00><00>
<10>N<EFBFBD>N<EFBFBD>1<EFBFBD>9<>:<3A>
<01><0C><1A><1A>3<>q<EFBFBD>9<>$%<25><04>!<21><19><04>
rKc
<00>x<00>|j
<00>}
|jd
k7x
r
|
jx
r
|
jS)z>Return whether the image can be composited with its neighbors.r)r<>rF
r<><00>is_separable)r<>rFs  rIrhz_ImageBase.can_composite<74>s=<00><00><14>"<22>"<22>$<24><05><10><1F><1F>6<EFBFBD>)<29>
<1F><11>O<EFBFBD>O<EFBFBD>
<1F><11><1E><1E>	 rKc<00>L<00>t
j|
d
<01>}
|
|_d|_y)z<>
        Set whether image resampling is used.

        Parameters
        ----------
        v : bool or None
            If None, use :rc:`image.resample`.
        zimage.resampleTN)r<>rI
r<>r
)r<><00>
vs  rIr<>z_ImageBase.set_resample<6C>s#<00><00>
<10>N<EFBFBD>N<EFBFBD>1<EFBFBD>.<2E>/<2F>
<01><1A><04><0E><19><04>
rKc

<00><00>|jS)
z(Return whether image resampling is used.)
r<>r<>s
 rIrz_ImageBase.get_resample
s<00><00><13>~<7E>~<7E>rKc<00>2<00>t
|
<01>
|_
d
|_y)z<>
        Set whether the resize filter normalizes the weights.

        See help for `~.Axes.imshow`.

        Parameters
        ----------
        filternorm : bool
        TN)<03>bool<6F>_filternormr
<00>r<>r<>s  rIr<>z_ImageBase.set_filternorms<00><00> <20>
<EFBFBD>+<2B><04><18><19><04>
rKc

<00><00>|jS)
z8Return whether the resize filter normalizes the weights.)
rW
r<>s
 rIr<>z_ImageBase.get_filternorms<00><00><13><1F><1F>rKc<00>V<00>t
|
<01>
}|d
krtd<02>
<00>
||_d|_y)z<>
        Set the resize filter radius only applicable to some
        interpolation schemes -- see help for imshow

        Parameters
        ----------
        filterrad : positive float
        rz+The filter radius must be a positive numberTN)r6
r<><00>
_filterradr
)r<>r<><00>
rs   rIr<>z_ImageBase.set_filterrads/<00><00>
<12>)<29><1C>
<01><0C>
<01>6<EFBFBD><1C>J<>K<>K<><1B><04><0F><19><04>
rKc

<00><00>|jS)
zReturn the filterrad setting.)
r[
r<>s
 rIr<>z_ImageBase.get_filterrad.s<00><00><13><EFBFBD><EFBFBD>rK)NNNNNT<4E>@F)r<>FT<46>r<>F)%r<><00>
__module__<EFBFBD>__qualname__<5F>__doc__<5F>zorderr<72>r<>r<>r<>r<>r<>r2r<>r
r0r
r<><00>allow_rasterizationrUr%
r0
<00>staticmethodr>
rB
rD
rzr<>rN
r<>rhr<>rr<>r<>r<>r<><00>
__classcell__<5F>
r<>s
@rIrPrP<00>s<><00><><00>
<08><0F>F<EFBFBD><1B><1A><1F>#<23><1C> <20><1E><1F>&<26>&*<2A>&<26>:'<27><<3C>$<24><1D><1D><1D><1A>J
M
<01>;?<3F>Z;<3B>xN
<01>(<15>
<0A> <20> <20><1B>!<21><1B><<1A>$:<3A><12><11><12><11>@
<1A> 
<19>	#<23><1A>()<29><1A>" <20><1A><1E><1A> <20>
<1A>rKrPc<00>b<00><00>eZ
dZd
Zddddddddddd<06>
<EFBFBD>f
d<07>
Zdd<08>
Zdd	<09>
Zd
<EFBFBD>Zd<0B>Zd<0C>Z	d
<0A>Z
<EFBFBD>x
ZS)<10>	AxesImagear	
    An image with pixels on a regular grid, attached to an Axes.

    Parameters
    ----------
    ax : `~matplotlib.axes.Axes`
        The Axes the image will belong to.
    cmap : str or `~matplotlib.colors.Colormap`, default: :rc:`image.cmap`
        The Colormap instance or registered colormap name used to map scalar
        data to colors.
    norm : str or `~matplotlib.colors.Normalize`
        Maps luminance to 0-1.
    interpolation : str, default: :rc:`image.interpolation`
        Supported values are 'none', 'auto', 'nearest', 'bilinear',
        'bicubic', 'spline16', 'spline36', 'hanning', 'hamming', 'hermite',
        'kaiser', 'quadric', 'catrom', 'gaussian', 'bessel', 'mitchell',
        'sinc', 'lanczos', 'blackman'.
    interpolation_stage : {'data', 'rgba'}, default: 'data'
        If 'data', interpolation
        is carried out on the data provided by the user.  If 'rgba', the
        interpolation is carried out after the colormapping has been
        applied (visual interpolation).
    origin : {'upper', 'lower'}, default: :rc:`image.origin`
        Place the [0, 0] index of the array in the upper left or lower left
        corner of the Axes. The convention 'upper' is typically used for
        matrices and images.
    extent : tuple, optional
        The data axes (left, right, bottom, top) for making image plots
        registered with data plots.  Default is to label the pixel
        centers with the zero-based row and column indices.
    filternorm : bool, default: True
        A parameter for the antigrain image resize filter
        (see the antigrain documentation).
        If filternorm is set, the filter normalizes integer values and corrects
        the rounding errors. It doesn't do anything with the source floating
        point values, it corrects only integers according to the rule of 1.0
        which means that any sum of pixel weights must be equal to 1.0. So,
        the filter function must produce a graph of the proper shape.
    filterrad : float > 0, default: 4
        The filter radius for filters that have a radius parameter, i.e. when
        interpolation is one of: 'sinc', 'lanczos' or 'blackman'.
    resample : bool, default: False
        When True, use a full resampling method. When False, only resample when
        the output image is larger than the input image.
    **kwargs : `~matplotlib.artist.Artist` properties
    NTr^
F)
r<EFBFBD>r<>r<>r<>r<><00>extentr<74>r<>r*r<>c

<00>H<00>
<01>||_t<00>
|<00>|
f
|||||||	|
|d
<01>	|<0C>
<01>

y)N)	r<>r<>r<>r<>r<>r<>r<>r*r<>)<03>_extentr<74>r<>)r<>r<>r<>r<>r<>r<>r<>rj
r<>r<>r*r<>r<>r<>s             <20>rIr<>zAxesImage.__init__csF<00><><00><1E><04><0C>
<0A><07><18><0E>	
<EFBFBD><15><15><1F>'<27><19>!<21><1F><1D> 3<>	
<EFBFBD><15>	
rKc<00><><00>|j\}}}}tj||||g<04>
}|j|j	<00><00>
SrN)rl
r<00>from_extents<74>transformedr<64>)r<>r>r:<00>x1r;<00>y1rGs       rI<00>get_window_extentzAxesImage.get_window_extent<6E>sF<00><00><1D><1C><1C><0E><02>B<EFBFBD><02>B<EFBFBD><13> <20> <20>"<22>b<EFBFBD>"<22>b<EFBFBD>!1<>2<><04><13><1F><1F><04> 2<> 2<> 4<>5<>5rKc<00><>
<00>|j
<00>}|j<00>\}}}}ttj||g||gg<02>
<00>
}	t|	|<04>}
|j
<00>r(|j<00>x
s2
|jjn|jd
<01><02>
j}|j|j|	|
|||<03><03>S)NT<4E>
<01>rootr
)
r<>r&
rr-r{rri<00>get_clip_boxr<78>rG<00>
get_figurer
r<>)r<>r>r?r<>rFrp
<00>x2rq
<00>y2rG<00>transformed_bboxr<
s            rIr0zAxesImage.make_image<67>s<><00><00><14>"<22>"<22>$<24><05><1D><1F><1F>*<2A><0E><02>B<EFBFBD><02>B<EFBFBD><13>B<EFBFBD>H<EFBFBD>H<EFBFBD>r<EFBFBD>2<EFBFBD>h<EFBFBD><12>R<EFBFBD><08>1<>2<>3<><04>*<2A>4<EFBFBD><15>7<><18>;?<3F>;K<>;K<>;M<><14>"<22>"<22>$<24>6<><04>	<09>	<09><0E><0E><19>_<EFBFBD>_<EFBFBD>$<24>_<EFBFBD>/<2F>4<>4<>	
<0A><13><1F><1F><04><07><07><14>/?<3F><14> -<2D><19> <20>
D
<01>
	D
rKc
<00>(<00>|j
<00>d
k(S)z9Return whether the image would be better drawn unsampled.r)
rzr<>s
 rIr
z AxesImage._check_unsampled_image<67>s<00><00><13>%<25>%<25>'<27>6<EFBFBD>1<>1rKc<00><><00>|jjd
|
d|
dgfd|
d|
dgfg|<02>\\}}\}}|rtjd|<02><00>
|jj	||j
<00>}|jj	||j
<00>}|jj	||j<00>}|jj	||j<00>}||||g}
|
|_||f||ff}|jj|<07>

||g|jjdd||g|jjdd|jj<00>r|jj||fd<08>	<09>
|jj<00>r|jj||fd<08>	<09>
d
|_y)a
        Set the image extent.

        Parameters
        ----------
        extent : 4-tuple of float
            The position and size of the image as tuple
            ``(left, right, bottom, top)`` in data coordinates.
        **kwargs
            Other parameters from which unit info (i.e., the *xunits*,
            *yunits*, *zunits* (for 3D Axes), *runits* and *thetaunits* (for
            polar Axes) entries are applied, if present.

        Notes
        -----
        This updates `.Axes.dataLim`, and, if autoscaling, sets `.Axes.viewLim`
        to tightly fit the image, regardless of `~.Axes.dataLim`.  Autoscaling
        state is not changed, so a subsequent call to `.Axes.autoscale_view`
        will redo the autoscaling in accord with `~.Axes.dataLim`.
        rDrr(rErtrs<00>
set_extentN)
rT)r<><00>_process_unit_infor<00>kwarg_error<6F>_validate_converted_limits<74>convert_xunits<74>convert_yunitsrl
<00>update_datalim<69>sticky_edgesrDrE<00>get_autoscalex_on<6F>set_xlim<69>get_autoscaley_on<6F>set_ylimr
)r<>rj
r<>r<>r<>r<>r<><00>cornerss        rIr}
zAxesImage.set_extent<6E>s<>
<00><00>*&*<2A>Y<EFBFBD>Y<EFBFBD>%A<>%A<><11>F<EFBFBD>1<EFBFBD>I<EFBFBD>v<EFBFBD>a<EFBFBD>y<EFBFBD>)<29>
*<2A><11>F<EFBFBD>1<EFBFBD>I<EFBFBD>v<EFBFBD>a<EFBFBD>y<EFBFBD>)<29>
*<2A>

,<2C><12>&<14>"<22><0C><14>t<EFBFBD>l<EFBFBD>t<EFBFBD>T<EFBFBD><12><16>"<22>"<22><<3C><16>8<>8<><13>y<EFBFBD>y<EFBFBD>3<>3<><10>$<24>%<25>%<25>
'<27><04><13>y<EFBFBD>y<EFBFBD>3<>3<><10>$<24>%<25>%<25>
'<27><04><13>y<EFBFBD>y<EFBFBD>3<>3<><10>$<24>%<25>%<25>
'<27><04><13>y<EFBFBD>y<EFBFBD>3<>3<><10>$<24>%<25>%<25>
'<27><04><16><04>d<EFBFBD>D<EFBFBD>)<29><06><1D><04><0C><17><14>,<2C><14>t<EFBFBD><0C>,<2C><07><0C>	<09>	<09> <20> <20><17>)<29>"&<26><04><1C><04><19><19><1B><1B>A<EFBFBD><1E>"&<26><04><1C><04><19><19><1B><1B>A<EFBFBD><1E><0F>9<EFBFBD>9<EFBFBD>&<26>&<26>(<28><10>I<EFBFBD>I<EFBFBD><1E><1E><04>d<EFBFBD>|<7C>$<24><1E>7<><0F>9<EFBFBD>9<EFBFBD>&<26>&<26>(<28><10>I<EFBFBD>I<EFBFBD><1E><1E><04>d<EFBFBD>|<7C>$<24><1E>7<><19><04>
rKc
<00><><00>|j<00>|jS|j<00>}
|
\}}|jd
k(rd|dz
|dz
dfSd|dz
d|dz
fS)<04><Return the image extent as tuple (left, right, bottom, top).r<><00><00><><EFBFBD><00>?)rl
r<>r<>)r<><00>sz<73>numrows<77>numcolss    rIr&
zAxesImage.get_extent<6E>se<00><00><0F><<3C><<3C>#<23><17><<3C><<3C><1F><15><1D><1D><1F>B<EFBFBD>!<21><1C>G<EFBFBD>W<EFBFBD><13>{<7B>{<7B>g<EFBFBD>%<25><1C>g<EFBFBD>c<EFBFBD>k<EFBFBD>7<EFBFBD>3<EFBFBD>;<3B><04>=<3D>=<3D><1C>g<EFBFBD>c<EFBFBD>k<EFBFBD>4<EFBFBD><17><13><1B>=<3D>=rKc<00>|<00>|j
<00>\}}}}|jd
k(r||}}|j<00>}t||g||gg<02>
}tddg|jd|jdgg<02>
}|j<00>j
<00>}	|	t||<08><04>z
}	|	j|
j|
jg<02>
}
ttj|
<EFBFBD>
<00>
r
y|
jt<00>
\}}d|cxkr|jdkrn
yd|cxkr|jdksy
y|||fS)z<>
        Return the image value at the event position or *None* if the event is
        outside the image.

        See Also
        --------
        matplotlib.artist.Artist.get_cursor_data
        r<>rr()<02>boxin<69>boxoutN)r&
r<>r
rr3r<>r<>rr|rDrErer-r<>r<>r6)
r<><00>eventr<74>r<>r<>r<><00>arr<72>data_extent<6E>array_extentrF<00>point<6E>
j<>
is
             rI<00>get_cursor_datazAxesImage.get_cursor_data<74>s*
<00><00>"&<26><1F><1F>!2<><1E><04>d<EFBFBD>D<EFBFBD>$<24><0F>;<3B>;<3B>'<27>!<21><1D>t<EFBFBD>$<24>D<EFBFBD><12>n<EFBFBD>n<EFBFBD><1E><03><1A>T<EFBFBD>4<EFBFBD>L<EFBFBD>4<EFBFBD><14>,<2C>7<>8<><0B><1B>a<EFBFBD><11>V<EFBFBD>c<EFBFBD>i<EFBFBD>i<EFBFBD>
<01>l<EFBFBD>C<EFBFBD>I<EFBFBD>I<EFBFBD>a<EFBFBD>L<EFBFBD>%A<>B<>C<><0C><14>"<22>"<22>$<24>-<2D>-<2D>/<2F><05>
<0A><1D>[<5B><1C>F<>F<><05><15><0F><0F><15><17><17>%<25>'<27>'<27> 2<>3<><05><0E>r<EFBFBD>x<EFBFBD>x<EFBFBD><05><EFBFBD><1F><17><14>|<7C>|<7C>C<EFBFBD> <20><04>
<01>1<EFBFBD><11>Q<EFBFBD>%<25><13><19><19>1<EFBFBD><1C>%<25><17>01<30>A<EFBFBD>/D<><03>	<09>	<09>!<21><0C>/D<><17>0E
<01><17><16>q<EFBFBD>!<21>t<EFBFBD>9<EFBFBD>rKrNr_
)r<>r`
ra
rb
r<>rr
r0r
r}
r&
r<>
rf
rg
s
@rIri
ri
3sN<00><><00>-<08>b
<1B><1A><1F>#<23><1C><1C> <20><1E><1F>%)<29>
<EFBFBD>>6<>

D
<01>2<>.<1A>`

><3E>rKri
c<00>x<00><00>eZ
dZd
Zdd<03>
<01>f
d<04>
Zd<05>Zdd<06>
Zd<07>Zd<08>Z<08>f
d	<09>Z	d
<EFBFBD>Z
d<0B>Zd<0C>Z<0C>f
d
<0A>Z
<0A>f
d<0E>Zd<0F>Z<0F>x
ZS)<11>NonUniformImagea

    An image with pixels on a rectilinear grid.

    In contrast to `.AxesImage`, where pixels are on a regular grid,
    NonUniformImage allows rows and columns with individual heights / widths.

    See also :doc:`/gallery/images_contours_and_fields/image_nonuniform`.
    rrH
c
<00>H<00>
<01>t
<00>|<00>|
f
i|<03>
<01>

|j|<02>

y
)ae

        Parameters
        ----------
        ax : `~matplotlib.axes.Axes`
            The Axes the image will belong to.
        interpolation : {'nearest', 'bilinear'}, default: 'nearest'
            The interpolation scheme used in the resampling.
        **kwargs
            All other keyword arguments are identical to those of `.AxesImage`.
        N)r<>r<>r<>)r<>r<>r<>r<>r<>s    <20>rIr<>zNonUniformImage.__init__<5F>s%<00><><00>	<0E><07><18><12>&<26>v<EFBFBD>&<26><0C><1E><1E>}<7D>-rKc
<00><00>y
)z)Return False. Do not use unsampled image.Fr
r<>s
 rIr
z&NonUniformImage._check_unsampled_images<00><00>rKc<00><><00>|j<00>td
<01>
<00>
|rtd<02>
<00>
|j}|jdk(rm|jt
jk7r|j|d<04><05>}n<>tj|dd<00>dd<00>t
jfdd<03>}d|dd<00>dd<00>df<n<>|jt
jk7r"d|zjt
j<00>
}|jddk(rZtjtg|jd	d<00>
d<06>
<01>
t
j<00>}||dd<00>dd<00>d	d<08>f<d|dd<00>dd<00>df<|}|jjj \}}}}	t#t%|<08>
d
zt%|<06>
d
z
z
|z<00>
}
t#t%|	<09>
d
zt%|<07>
d
z
z
|z<00>
}|jj&j)<00>}|j+tj,|||
<EFBFBD>D<00>
cgc]}
|
|f<02><02>c}
<0A>
dd<00>d	f}|j+tj,||	|<0B>D<00>cgc]}||f<02><02>c}<0F>
dd<00>df}|j.dk(<00>
r|j0dd
|j0ddzdz}|j2dd
|j2ddzdz}|j5|<0E>
}|j5|<10>
}tj6|<04>
j9t
j:<00>
j=<00>t
j>jA||jdz|<13>j9t
j<00>
jC||
df<03>
}<15>n<>tjD|j0j5|<0E>
dz
d	tG|j0<00>
dz
<00>}tjD|j2j5|<10>
dz
d	tG|j2<00>
dz
<00>}t
j>jA||jdz|<13>}tjDtjH||j0|z
tjJ|j0<00>
|t
jL<00><0E>d	d<0B>}tjDtjH||j2|z
tjJ|j2<00>
|t
jL<00><0E>d	d<0B>}tj@d|z
d|z
<00>}tj@|d|z
<00>}tj@d|z
|<17>}tj@||<17>}tjN||
dft
j<00>}tQd<06>
D]x}|dd<00>dd<00>|fjCd
<0A>
}|||z}||||jdd|zz
}|||dd|zz
}||||jddzd|zz
}||dd<00>dd<00>|f<<00>z|||tS<00>fSc
c}
wc
c}w)Nr<4E>z*unsampled not supported on NonUniformImagertT<>
r<>r%r<>rsrr<>
r(rr<>r&)*r<>r<>r<>r<>r'r-r/r<><00>repeat<61>newaxisr<73>r3r5<00>tupler<65>rG<00>extentsr6r\<00>	transDatar<61>r|<00>linspacerF
<00>_Ax<41>_Ay<41>searchsorted<65>ascontiguousarray<61>view<65>uint32<33>ravel<65>add<64>outer<65>reshaper<
r,<00>divider~r<>r.<00>ranger) r<>r>r?r<>r<><00>
Br^r_r\
r

r8r7<00>invertedTransformrD<00>x_pixrE<00>y_pix<69>x_mid<69>y_mid<69>x_int<6E>y_intr!
<00>idx_int<6E>x_frac<61>y_frac<61>f00<30>f10<31>f01<30>f11<31>chan<61>ac<61>bufs                                 rIr0zNonUniformImage.make_imagesK<00><00><0F>7<EFBFBD>7<EFBFBD>?<3F><1E>C<>D<>D<><14><1C>I<>J<>J<><10>G<EFBFBD>G<EFBFBD>
<01><0C>6<EFBFBD>6<EFBFBD>Q<EFBFBD>;<3B><10>w<EFBFBD>w<EFBFBD>"<22>(<28>(<28>"<22><18>L<EFBFBD>L<EFBFBD><11>$<24>L<EFBFBD>/<2F>
<01><16>I<EFBFBD>I<EFBFBD>a<EFBFBD>
<01>1<EFBFBD>b<EFBFBD>j<EFBFBD>j<EFBFBD> 0<>1<>1<EFBFBD>a<EFBFBD>8<>
<01> <20>
<01>!<21>Q<EFBFBD>
<01>'<27>
<EFBFBD><10>w<EFBFBD>w<EFBFBD>"<22>(<28>(<28>"<22><18><11>U<EFBFBD>N<EFBFBD>N<EFBFBD>2<EFBFBD>8<EFBFBD>8<EFBFBD>,<2C>
<01><10>w<EFBFBD>w<EFBFBD>q<EFBFBD>z<EFBFBD>Q<EFBFBD><EFBFBD><16>H<EFBFBD>H<EFBFBD>U<EFBFBD>#5<>Q<EFBFBD>W<EFBFBD>W<EFBFBD>Q<EFBFBD>q<EFBFBD>\<5C>#5<>1<EFBFBD>#5<>6<><02><08><08>A<>
<01> <20>
<01>!<21>Q<EFBFBD>
<01>!<21><03>)<29><0C> <20>
<01>!<21>Q<EFBFBD>
<01>'<27>
<EFBFBD><15>
<01><19>Y<EFBFBD>Y<EFBFBD>^<5E>^<5E>+<2B>+<2B>
<EFBFBD>
<01>1<EFBFBD>a<EFBFBD><11><13>e<EFBFBD>A<EFBFBD>h<EFBFBD><13>n<EFBFBD><15>q<EFBFBD><18>C<EFBFBD><1E>8<>M<EFBFBD>I<>J<><05><14>u<EFBFBD>Q<EFBFBD>x<EFBFBD>#<23>~<7E>%<25>
<01>(<28>S<EFBFBD>.<2E>9<>]<5D>J<>K<><06> <20>I<EFBFBD>I<EFBFBD>/<2F>/<2F>8<>8<>:<3A><19>!<21>+<2B>+<2B><1F>[<5B>[<5B><11>A<EFBFBD>u<EFBFBD>5<>6<>
<01>a<EFBFBD><11>V<EFBFBD>6<>
8<>89<38>1<EFBFBD><04>
><3E><05>!<21>+<2B>+<2B><1F>[<5B>[<5B><11>A<EFBFBD>v<EFBFBD>6<>7<>
<01>a<EFBFBD><11>V<EFBFBD>7<>
9<>9:<3A>A<EFBFBD><14>
?<3F><05><10><1E><1E>)<29>+<2B><19>X<EFBFBD>X<EFBFBD>c<EFBFBD>r<EFBFBD>]<5D>T<EFBFBD>X<EFBFBD>X<EFBFBD>a<EFBFBD>b<EFBFBD>\<5C>1<>Q<EFBFBD>6<>E<EFBFBD><19>X<EFBFBD>X<EFBFBD>c<EFBFBD>r<EFBFBD>]<5D>T<EFBFBD>X<EFBFBD>X<EFBFBD>a<EFBFBD>b<EFBFBD>\<5C>1<>Q<EFBFBD>6<>E<EFBFBD><19>&<26>&<26>u<EFBFBD>-<2D>E<EFBFBD><19>&<26>&<26>u<EFBFBD>-<2D>E<EFBFBD>
<13>$<24>$<24>Q<EFBFBD>'<27>,<2C>,<2C>R<EFBFBD>Y<EFBFBD>Y<EFBFBD>7<>=<3D>=<3D>?<3F><16>F<EFBFBD>F<EFBFBD>L<EFBFBD>L<EFBFBD><15><11><17><17><11><1A>!3<>U<EFBFBD>;<3B>
=<3D><15><14>b<EFBFBD>h<EFBFBD>h<EFBFBD><1E><07><07><16><15>
<01>(:<3A> ;<3B>
<0F><17>G<EFBFBD>G<EFBFBD><14><08><08>%<25>%<25>e<EFBFBD>,<2C>q<EFBFBD>0<>!<21>S<EFBFBD><14><18><18>]<5D>Q<EFBFBD>5F<35>
H
<01>E<EFBFBD><16>G<EFBFBD>G<EFBFBD><14><08><08>%<25>%<25>e<EFBFBD>,<2C>q<EFBFBD>0<>!<21>S<EFBFBD><14><18><18>]<5D>Q<EFBFBD>5F<35>
H
<01>E<EFBFBD><18>f<EFBFBD>f<EFBFBD>l<EFBFBD>l<EFBFBD>5<EFBFBD>1<EFBFBD>7<EFBFBD>7<EFBFBD>1<EFBFBD>:<3A>#5<>u<EFBFBD>=<3D>G<EFBFBD><17>W<EFBFBD>W<EFBFBD><12>	<09>	<09>%<25>$<24>(<28>(<28>5<EFBFBD>/<2F>1<>2<EFBFBD>7<EFBFBD>7<EFBFBD>4<EFBFBD>8<EFBFBD>8<EFBFBD>3D<33>U<EFBFBD>3K<33> "<22>
<EFBFBD>
<EFBFBD>
,<2C><11>1<EFBFBD><16>F<EFBFBD><18>W<EFBFBD>W<EFBFBD><12>	<09>	<09>%<25>$<24>(<28>(<28>5<EFBFBD>/<2F>1<>2<EFBFBD>7<EFBFBD>7<EFBFBD>4<EFBFBD>8<EFBFBD>8<EFBFBD>3D<33>U<EFBFBD>3K<33> "<22>
<EFBFBD>
<EFBFBD>
,<2C><11>1<EFBFBD><16>F<EFBFBD><15>(<28>(<28>1<EFBFBD>v<EFBFBD>:<3A>q<EFBFBD>6<EFBFBD>z<EFBFBD>2<>C<EFBFBD><14>(<28>(<28>6<EFBFBD>1<EFBFBD>v<EFBFBD>:<3A>.<2E>C<EFBFBD><14>(<28>(<28>1<EFBFBD>v<EFBFBD>:<3A>v<EFBFBD>.<2E>C<EFBFBD><14>(<28>(<28>6<EFBFBD>6<EFBFBD>*<2A>C<EFBFBD><13><18><18>6<EFBFBD>5<EFBFBD>!<21>,<2C>b<EFBFBD>h<EFBFBD>h<EFBFBD>7<>B<EFBFBD><1D>a<EFBFBD><08>
%<25><04><16>q<EFBFBD>!<21>T<EFBFBD>z<EFBFBD>]<5D>*<2A>*<2A>2<EFBFBD>.<2E><02><1A>B<EFBFBD>w<EFBFBD>K<EFBFBD>'<27><03><13>s<EFBFBD>R<EFBFBD>
<01><07><07>
<01>
<EFBFBD><0B>_<EFBFBD>W<EFBFBD>5<>5<>5<><03><13>s<EFBFBD>R<EFBFBD>
<01><02>V<EFBFBD>G<EFBFBD>_<EFBFBD>,<2C>,<2C><03><13>s<EFBFBD>R<EFBFBD>
<01><07><07>
<01>
<EFBFBD>Q<EFBFBD><0E><0F>0<><17>9<>9<>9<><03>!$<24><02>1<EFBFBD>a<EFBFBD><14>:<3A><0E>
%<25><12>1<EFBFBD>a<EFBFBD>*<2A>,<2C>,<2C>,<2C><>[

7<><37>7s<00>X<<08>Y
c<00><>
<00>|j
|<03>
}tj|
tj<00>}
tj|tj<00>}|
j|jcxk(rd
k(r6n
t
d<04>
<00>
|j
dd|j
|
j
zk(st
d<04>
<00>
||_|
|_||_	d|_
d|_y)a<>

        Set the grid for the pixel centers, and the pixel values.

        Parameters
        ----------
        x, y : 1D array-like
            Monotonic arrays of shapes (N,) and (M,), respectively, specifying
            pixel centers.
        A : array-like
            (M, N) `~numpy.ndarray` or masked array of values to be
            colormapped, or (M, N, 3) RGB array, or (M, N, 4) RGBA array.
        r(NrtzAxes don't match array shapeT)r>
r-r{r<>r<>r3r<>r<>r<>
r<>
r<>r
<00>r<>rDrEr<>s    rIrB
zNonUniformImage.set_dataUs<><00><00>
<11>'<27>'<27>
<01>*<2A>
<01><0E>H<EFBFBD>H<EFBFBD>Q<EFBFBD><02>
<EFBFBD>
<EFBFBD>#<23>
<01><0E>H<EFBFBD>H<EFBFBD>Q<EFBFBD><02>
<EFBFBD>
<EFBFBD>#<23>
<01><11><06><06>!<21>&<26>&<26>%<25>A<EFBFBD>%<25><1B>:<3A>;<3B>;<3B>+,<2C>'<27>'<27>"<22>1<EFBFBD>+<2B><11><17><17>1<EFBFBD>7<EFBFBD>7<EFBFBD>9J<39>*J<><1B>:<3A>;<3B>;<3B><13><04><07><14><04><08><14><04><08><1C><04>
<0A><19><04>
rKc
<00><00>t
d
<01>
<00>
<01>NzMethod not supportedr
<00>r<><00>argss  rIrD
zNonUniformImage.set_arraym<00><00><00>!<21>"8<>9<>9rKc<00>F<00>
<01>|
<01>|
dv
rt
d<03>
<00>
t<00>|<00>	|
<01>

y
)z<>
        Parameters
        ----------
        s : {'nearest', 'bilinear'} or None
            If None, use :rc:`image.interpolation`.
        N)rrz?Only nearest neighbor and bilinear interpolations are supported)r
r<>r<>)r<>rL
r<>s  <20>rIr<>z!NonUniformImage.set_interpolationps4<00><><00>
<0A>=<3D>Q<EFBFBD>&=<3D>=<3D>%<25>
'N
<01>
O
<01>

O
<01>
<0A><07>!<21>!<21>$rKc
<00><><00>|j<00>td
<01>
<00>
|jd|jd|jd|jdfS)NzMust set data firstrr<>)r<>r<>r<>
r<>
r<>s
 rIr&
zNonUniformImage.get_extent|sF<00><00><0F>7<EFBFBD>7<EFBFBD>?<3F><1E>4<>5<>5<><13>x<EFBFBD>x<EFBFBD>
<01>{<7B>D<EFBFBD>H<EFBFBD>H<EFBFBD>R<EFBFBD>L<EFBFBD>$<24>(<28>(<28>1<EFBFBD>+<2B>t<EFBFBD>x<EFBFBD>x<EFBFBD><02>|<7C>C<>CrKc<00><00>yrNr
rX
s  rIr<>zNonUniformImage.set_filternorm<72><00><00><00>rKc<00><00>yrNr
)r<>r<>s  rIr<>zNonUniformImage.set_filterrad<61>r<>
rKc<00>R<00>
<01>|j<00>td
<01>
<00>
t<00>|<00>
|
<01>

y<00>Nz'Cannot change colors after loading data)r<>r<>r<><00>set_norm)r<>r<>r<>s  <20>rIr<>
zNonUniformImage.set_norm<72><00>&<00><><00><0F>7<EFBFBD>7<EFBFBD><1E><1E>H<>I<>I<>
<0A><07><18><14>rKc<00>R<00>
<01>|j<00>td
<01>
<00>
t<00>|<00>
|
<01>

yr<>
)r<>r<>r<><00>set_cmap)r<>r<>r<>s  <20>rIr<>
zNonUniformImage.set_cmap<61>r<>
rKc<00>r
<00>|
j|
j}}||jd
ks6||jdkDs$||jd
ks||jdkDr
yt	j
|j|<02>dz
}t	j
|j|<03>dz
}|j||fS<00>Nrr<>r(<00><07>xdata<74>ydatar<61>
r<>
r-r<>
r<><00>r<>r<>
rDrEr<>
r<>
s      rIr<>
zNonUniformImage.get_cursor_data<74><00><><00><00><14>{<7B>{<7B>E<EFBFBD>K<EFBFBD>K<EFBFBD>1<EFBFBD>
<01>
<0A><04><08><08><11><0B>O<EFBFBD>q<EFBFBD>4<EFBFBD>8<EFBFBD>8<EFBFBD>B<EFBFBD><<3C>/<2F><11>D<EFBFBD>H<EFBFBD>H<EFBFBD>Q<EFBFBD>K<EFBFBD><0F>1<EFBFBD>t<EFBFBD>x<EFBFBD>x<EFBFBD><02>|<7C>#3<><17><0E>O<EFBFBD>O<EFBFBD>D<EFBFBD>H<EFBFBD>H<EFBFBD>a<EFBFBD>(<28>1<EFBFBD>,<2C>
<01><0E>O<EFBFBD>O<EFBFBD>D<EFBFBD>H<EFBFBD>H<EFBFBD>a<EFBFBD>(<28>1<EFBFBD>,<2C>
<01><13>w<EFBFBD>w<EFBFBD>q<EFBFBD>!<21>t<EFBFBD>}<7D>rKr_
)r<>r`
ra
rb
r<>r
r0rB
rD
r<>r&
r<>r<>r<>
r<>
r<>
rf
rg
s
@rIr<>
r<>
<00>sL<00><><00><08>-6<>.<2E><15>H
-<2D>T<1A>0
:<3A>
%<25>D
<01>


<0A>

<0A><1F>
<1F>
rKr<>
c<00>T<00><00>eZ
dZd
Z			d
dddd<03><03>f
d<04>Zdd<05>
Zd<06>Zd<07>Zd<08>Zd	<09>Z	<09>x
Z
S)<0C>PcolorImagez<65>
    Make a pcolor-style plot with an irregular rectangular grid.

    This uses a variation of the original irregular image code,
    and it is used by pcolorfast for the corresponding grid type.
    N)r<>r<>r<>c<00>z<00>
<01>t<00>	|<00>|
|||<07>
<01>
|j|<08>

|<04>|j|||<04>
yy)a<>
        Parameters
        ----------
        ax : `~matplotlib.axes.Axes`
            The Axes the image will belong to.
        x, y : 1D array-like, optional
            Monotonic arrays of length N+1 and M+1, respectively, specifying
            rectangle boundaries.  If not given, will default to
            ``range(N + 1)`` and ``range(M + 1)``, respectively.
        A : array-like
            The data to be color-coded. The interpretation depends on the
            shape:

            - (M, N) `~numpy.ndarray` or masked array: values to be colormapped
            - (M, N, 3): RGB array
            - (M, N, 4): RGBA array

        cmap : str or `~matplotlib.colors.Colormap`, default: :rc:`image.cmap`
            The Colormap instance or registered colormap name used to map
            scalar data to colors.
        norm : str or `~matplotlib.colors.Normalize`
            Maps luminance to 0-1.
        **kwargs : `~matplotlib.artist.Artist` properties
        )r<>r<>r<>N)r<>r<>r<>rB
)
r<EFBFBD>r<>rDrEr<>r<>r<>r<>r<>r<>s
         <20>rIr<>zPcolorImage.__init__<5F>sD<00><><00>D
	<0E><07><18><12>$<24>T<EFBFBD>Y<EFBFBD><18>G<><0C><1D><1D>f<EFBFBD>%<25><0C>=<3D><10>M<EFBFBD>M<EFBFBD>!<21>Q<EFBFBD>
<01>"<22>rKc<00><><00>|j<00>td
<01>
<00>
|rtd<02>
<00>
|j<00>;|j	|jd<03><04>}tj|gd<05>
d<06>|_|j}tj|jjj<00>d<07>}tj|<06>
dzjt
j<00>
}|d	|k7j<00>r|x
|dd
gdd<00>f<|dd<00>dd
gf<|jjj \}}}	}
t#|	<09>
dzt#|<07>
dz
z
}t#|
<EFBFBD>
dzt#|<08>
dz
z
}t#||z<00>
}t#||z<00>
}|jj$}
tj&|
j(|
j*|<0B>}tj&|
j,|
j.|<0C>}|j0j3|<0E>
}|j4j3|<0F>
}|j7t
j8<00>
j;<00>t
j<j?||j@dz|<10>j7t
j<00>
jC||d
f<03>
}|||tE<00>fS)Nr<4E>z&unsampled not supported on PColorImageTr<54>
)<03>r(r(r<>
<00>rr<00>constantrr<>r<>
r<>r<>
r(r%)#r<>r<>r<>r<>r<>r-<00>padr<64>r<><00>patch<63>
get_facecolorr{r<>r/<00>allrGr<>
r\<00>viewLimr<6D>
r:rp
r;rq
r<>
r<>
r<>
r<>
r<>
r<>
r<>
r<>
r3r<>
r)r<>r>r?r<>r<><00>padded_A<5F>bgr^r_r\
r

r8r7<00>vlr<6C>
r<>
r<>
r<>
r!
s                   rIr0zPcolorImage.make_image<67>s-<00><00><0F>7<EFBFBD>7<EFBFBD>?<3F><1E>C<>D<>D<><14><1C>E<>F<>F<><0F>=<3D>=<3D> <20><14><0C><0C>T<EFBFBD>W<EFBFBD>W<EFBFBD>D<EFBFBD><0C>1<>A<EFBFBD><1E>F<EFBFBD>F<EFBFBD>1<EFBFBD>&><3E>
<EFBFBD>K<>D<EFBFBD>M<EFBFBD><17>=<3D>=<3D><08>
<14>_<EFBFBD>_<EFBFBD>T<EFBFBD>Y<EFBFBD>Y<EFBFBD>_<EFBFBD>_<EFBFBD>:<3A>:<3A><<3C>a<EFBFBD>
@<40><02><10>h<EFBFBD>h<EFBFBD>r<EFBFBD>l<EFBFBD>S<EFBFBD> <20>
(<28>
(<28><12><18><18>
2<><02><14>T<EFBFBD>N<EFBFBD>b<EFBFBD> <20>%<25>%<25>'<27>:<<3C><<3C>H<EFBFBD>a<EFBFBD><12>W<EFBFBD>a<EFBFBD>Z<EFBFBD> <20>8<EFBFBD>A<EFBFBD>
<01>2<EFBFBD>w<EFBFBD>J<EFBFBD>#7<><19>Y<EFBFBD>Y<EFBFBD>^<5E>^<5E>+<2B>+<2B>
<EFBFBD>
<01>1<EFBFBD>a<EFBFBD><11><16>q<EFBFBD><18>C<EFBFBD><1E>E<EFBFBD>!<21>H<EFBFBD>s<EFBFBD>N<EFBFBD>3<><05><17>
<01>(<28>S<EFBFBD>.<2E>U<EFBFBD>1<EFBFBD>X<EFBFBD><03>^<5E>4<><06><15>e<EFBFBD>m<EFBFBD>+<2B>,<2C><05><16>v<EFBFBD>
<0A>-<2D>.<2E><06>
<11>Y<EFBFBD>Y<EFBFBD>
<1E>
<1E><02><12><0B><0B>B<EFBFBD>E<EFBFBD>E<EFBFBD>2<EFBFBD>5<EFBFBD>5<EFBFBD>%<25>0<><05><12><0B><0B>B<EFBFBD>E<EFBFBD>E<EFBFBD>2<EFBFBD>5<EFBFBD>5<EFBFBD>&<26>1<><05><14><08><08>%<25>%<25>e<EFBFBD>,<2C><05><14><08><08>%<25>%<25>e<EFBFBD>,<2C><05><14>M<EFBFBD>M<EFBFBD>"<22>)<29>)<29>$<24>*<2A>*<2A>,<2C><12><06><06><0C><0C>U<EFBFBD>X<EFBFBD>^<5E>^<5E>A<EFBFBD>%6<>6<><05>><3E>

@
<01>
<11>T<EFBFBD>"<22>(<28>(<28>^<5E>G<EFBFBD>G<EFBFBD>V<EFBFBD>U<EFBFBD>A<EFBFBD>$6<>7<>	<0B><12>1<EFBFBD>a<EFBFBD>*<2A>,<2C>,<2C>,rKc
<00><00>y
)NFr
r<>s
 rIr
z"PcolorImage._check_unsampled_image<67>s<00><00>rKc<00><><00>|j
|<03>
}|
<01>&tjd|jddz<00>n'tj|
t
<00>j
<00>}
|<02>&tjd|jddz<00>n'tj|t
<00>j
<00>}|jd
d|jdz
|
jdz
fk7r;td|jd
d<00>
d|jdz
|
jdz
f<02>
d<08><05>
<00>
|
d	|
dkr|
d
d
d	<09>}
|d
d
<01>d
d
d	<09>f}|d	|dkr|d
d
d	<09>}|d
d
d	<09>}||_	|
|_
||_d
|_d
|_
y
)az
        Set the grid for the rectangle boundaries, and the data values.

        Parameters
        ----------
        x, y : 1D array-like, optional
            Monotonic arrays of length N+1 and M+1, respectively, specifying
            rectangle boundaries.  If not given, will default to
            ``range(N + 1)`` and ``range(M + 1)``, respectively.
        A : array-like
            The data to be color-coded. The interpretation depends on the
            shape:

            - (M, N) `~numpy.ndarray` or masked array: values to be colormapped
            - (M, N, 3): RGB array
            - (M, N, 4): RGBA array
        Nr<4E>r(rrtz"Axes don't match array shape. Got z, expected <20>
.r<>T)r>
r-<00>aranger3r{r6
r<>
rVr<>r<>r<>
r<>
r<>r
r<>
s    rIrB
zPcolorImage.set_data<74>sX
<00><00>$
<11>'<27>'<27>
<01>*<2A>
<01>-.<2E>Y<EFBFBD>B<EFBFBD>I<EFBFBD>I<EFBFBD>b<EFBFBD>!<21>'<27>'<27>!<21>*<2A>q<EFBFBD>.<2E>)<29>B<EFBFBD>H<EFBFBD>H<EFBFBD>Q<EFBFBD><05><N<><T<><T<><V<>
<01>-.<2E>Y<EFBFBD>B<EFBFBD>I<EFBFBD>I<EFBFBD>b<EFBFBD>!<21>'<27>'<27>!<21>*<2A>q<EFBFBD>.<2E>)<29>B<EFBFBD>H<EFBFBD>H<EFBFBD>Q<EFBFBD><05><N<><T<><T<><V<>
<01><0C>7<EFBFBD>7<EFBFBD>2<EFBFBD>A<EFBFBD>;<3B>1<EFBFBD>6<EFBFBD>6<EFBFBD>A<EFBFBD>:<3A>q<EFBFBD>v<EFBFBD>v<EFBFBD>
<01>z<EFBFBD>2<>2<><1C><12><17><17><12>!<21><1B>q<EFBFBD>v<EFBFBD>v<EFBFBD>
<01>z<EFBFBD>1<EFBFBD>6<EFBFBD>6<EFBFBD>A<EFBFBD>:<3A>6<>
8<>9<>
9<>
<0A>R<EFBFBD>5<EFBFBD>1<EFBFBD>Q<EFBFBD>4<EFBFBD><<3C><11>$<24>B<EFBFBD>$<24><07>A<EFBFBD><11>!<21>T<EFBFBD>r<EFBFBD>T<EFBFBD>'<27>
<EFBFBD>A<EFBFBD><0C>R<EFBFBD>5<EFBFBD>1<EFBFBD>Q<EFBFBD>4<EFBFBD><<3C><11>$<24>B<EFBFBD>$<24><07>A<EFBFBD><11>$<24>B<EFBFBD>$<24><07>A<EFBFBD><13><04><07><14><04><08><14><04><08><1C><04>
<0A><19><04>
rKc
<00><00>t
d
<01>
<00>
r<>
r
r<>
s  rIrD
zPcolorImage.set_arrayr<>
rKc<00>r
<00>|
j|
j}}||jd
ks6||jdkDs$||jd
ks||jdkDr
yt	j
|j|<02>dz
}t	j
|j|<03>dz
}|j||fSr<>
r<>
r<>
s      rIr<>
zPcolorImage.get_cursor_datar<>
rK)NNNr_
)r<>r`
ra
rb
r<>r0r
rB
rD
r<>
rf
rg
s
@rIr<>
r<>
<00>sD<00><><00><08><18><17><17>%#<23>
<1B><1A><1F>%#<23>N
-<2D>B

<15>$<1A>L

:<3A>rKr<>
c<00>R<00><00>eZ
dZd
ZdZdZddddddd<05><06>f
d<06>
Zd<07>Zd
d<08>
Z<08>f
d	<09>Z	<09>x
Z
S)<0B>FigureImagezAn image attached to a figure.rrN)r<>r<>r<><00>offsetx<74>offsetyr<79>c<00><><00>
<01>t<00>	|<00>d
||||<07><02>
|j|
<01>

||_||_|j|<08>

d|_y
)<04><>
        cmap is a colors.Colormap instance
        norm is a colors.Normalize instance to map luminance to 0-1

        kwargs are an optional list of Artist keyword args
        N)r<>r<>r<>r<>r<>)r<>r<><00>
set_figure<EFBFBD>ox<6F>oyr<79>r?)
r<EFBFBD><00>figr<67>r<>r<>r<>
r<>
r<>r<>r<>s
         <20>rIr<>zFigureImage.__init__*sX<00><><00> 	<0E><07><18><10><15><15><1F><19>	<19>	
<EFBFBD>	
<0A><0F><0F><03><1C><19><04><07><19><04><07><0C><1D><1D>f<EFBFBD>%<25> <20><04>rKc
<00><><00>|j
<00>\}
}d
|jz|dz
|jzd
|jz|
dz
|jzfS)r<>
r<>
r<>
)r<>r<>
r<>
)r<>r<>
r<>
s   rIr&
zFigureImage.get_extentGsP<00><00><1F>=<3D>=<3D>?<3F><18><07><17><14>t<EFBFBD>w<EFBFBD>w<EFBFBD><0E><07><03><0B>d<EFBFBD>g<EFBFBD>g<EFBFBD> 5<><14>t<EFBFBD>w<EFBFBD>w<EFBFBD><0E><07><03><0B>d<EFBFBD>g<EFBFBD>g<EFBFBD> 5<>
7<>
	7rKc	<00><00>|j
d
<01><02>
}|
j|jz}t|j|z|j|zg|j|z|j
jdz|j|z|j
jdzgg<02>
}|j<00>\}}||
jz}||
jz}tddg||gg<02>
}	|j|j
|||	||z|d<05><06>S)NTrt
r(rF)r?r<>r<>)	rw
<00>dpirr<>
r<>
r<>r3<00>get_size_inchesr
)
r<EFBFBD>r>r?r<>r<>
<00>facrGr8r7r<
s
          rIr0zFigureImage.make_imageMs
<00><00><12>o<EFBFBD>o<EFBFBD>4<EFBFBD>o<EFBFBD>(<28><03><16>l<EFBFBD>l<EFBFBD>3<EFBFBD>7<EFBFBD>7<EFBFBD>"<22><03><14>d<EFBFBD>g<EFBFBD>g<EFBFBD>c<EFBFBD>k<EFBFBD>4<EFBFBD>7<EFBFBD>7<EFBFBD>3<EFBFBD>;<3B>/<2F><1B>w<EFBFBD>w<EFBFBD>s<EFBFBD>{<7B>T<EFBFBD>W<EFBFBD>W<EFBFBD>]<5D>]<5D>1<EFBFBD>%5<>5<><1A>g<EFBFBD>g<EFBFBD>c<EFBFBD>k<EFBFBD>D<EFBFBD>G<EFBFBD>G<EFBFBD>M<EFBFBD>M<EFBFBD>!<21>$4<>4<>
7<>8<>9<><04><1C>+<2B>+<2B>-<2D>
<0A><05>v<EFBFBD>
<0A><18><1C><1C><1D><05><0E>(<28>,<2C>,<2C><1E><06><13>a<EFBFBD><11>V<EFBFBD>e<EFBFBD>V<EFBFBD>_<EFBFBD>-<2D>.<2E><04><13><1F><1F><10>G<EFBFBD>G<EFBFBD>T<EFBFBD>4<EFBFBD><14>]<5D>S<EFBFBD>5H<35><1F>u<EFBFBD> <20>><3E>	>rKc<00>2<00>
<01>t<00>|<00>|
<01>

d
|_y)zSet the image array.TN)r<>rB
r
)r<>r<>r<>s  <20>rIrB
zFigureImage.set_data_s<00><><00>
<0A><07><18><11><1B><19><04>
rKr_
)r<>r`
ra
rb
rc
rF
r<>r&
r0rB
rf
rg
s
@rIr<>
r<>
#s=<00><><00>(<28>
<0E>F<EFBFBD><1E>N<EFBFBD><1B><1A><1F><1A><1A><1C>!<21>:7<>><3E>$<1A>rKr<>
c	<00>L<00><00>eZ
dZd
Zddddddddd<06><08>f
d<07>
Zdd<08>
Zd	<09>Zdd
<EFBFBD>
Z<07>x
ZS)
<0A>	BboxImagez;The Image class whose size is determined by the given bbox.NTr^
F<>r<>r<>r<>r<>r<>r<>r<>r*c<00>F<00>
<01>t
<00>|<00>	d||||||||	d<02>|
<EFBFBD>
<01>

|
|_y
)r<>
NrrN)r<>r<>rG)r<>rGr<>r<>r<>r<>r<>r<>r<>r*r<>r<>s           <20>rIr<>zBboxImage.__init__hsE<00><><00>$	<0E><07><18><10>	
<EFBFBD><15><15><1F>'<27><19>!<21><1F><1D>	
<EFBFBD><15>	
<EFBFBD><19><04>	rKc<00><><00>|
<01>|j
<00>j<00>}
t|jt<00>r|jSt|j<00>
r|j|
<01>
St
d
<01>
<00>
)NzUnknown type of bbox)rw
<00>
_get_rendererrOrGr
<00>callabler<65>)r<>r>s  rIrr
zBboxImage.get_window_extent<6E>s\<00><00><13><1B><1B><EFBFBD><EFBFBD>(<28>6<>6<>8<>H<EFBFBD><15>d<EFBFBD>i<EFBFBD>i<EFBFBD><18>*<2A><17>9<EFBFBD>9<EFBFBD><1C>
<15>d<EFBFBD>i<EFBFBD>i<EFBFBD>
 <20><17>9<EFBFBD>9<EFBFBD>X<EFBFBD>&<26>&<26><1C>3<>4<>4rKc<00><><00>|j
|
<01>
s|j<00>sd
ifS|
j|
j}}|j	<00>j||<03>}|ifS)r#
F)r$
r
rDrErr
r%
)r<>r'
rDrEr(
s     rIr%
zBboxImage.contains<6E>s[<00><00><0F>!<21>!<21>*<2A>-<2D>T<EFBFBD>5E<35>5E<35>5G<35><18>"<22>9<EFBFBD><1C><19>|<7C>|<7C>Z<EFBFBD>\<5C>\<5C>1<EFBFBD>
<01><15>'<27>'<27>)<29>2<>2<>1<EFBFBD>a<EFBFBD>8<><06><15>r<EFBFBD>z<EFBFBD>rKc<00>:
<00>|
j
<00>\}}|j|
<01>
j<00>}|x
j||gzc_|j|
<01>
}t	d
d
g||gg<02>
}t|<08>
|_|j|j|||||<03><02>S)Nrr
)	<09>get_canvas_width_heightrr
r<><00>_pointsrr
<00>
_transformr
r<>)	r<>r>r?r<>r8r7<00>bbox_in<69>bbox_outr<
s	         rIr0zBboxImage.make_image<67>s<><00><00> <20>8<>8<>:<3A>
<0A><05>v<EFBFBD><16>(<28>(<28><18>2<>9<>9<>;<3B><07><0F><0F><0F>E<EFBFBD>6<EFBFBD>?<3F>*<2A><0F><17>)<29>)<29>(<28>3<><08><13>a<EFBFBD><11>V<EFBFBD>e<EFBFBD>V<EFBFBD>_<EFBFBD>-<2D>.<2E><04>)<29>$<24>/<2F><04><0F><13><1F><1F><10>G<EFBFBD>G<EFBFBD><13>X<EFBFBD>t<EFBFBD>]<5D>i<EFBFBD> <20>I
<01>	I
rKrNr_
)	r<>r`
ra
rb
r<>rr
r%
r0rf
rg
s
@rIrres6<00><><00>E<><1B><1A><1F>#<23><1C> <20><1E><1F><19>@
	5<><1A>
I
rKrc<00> <00>d
dlm
}
|
<01><>t|t<00>rS|j	|<00>
}t|j<00>
dkDrd}nxt|<00>
jj<00>dd}nQt|d<06>rd}nBt|d<07>r1t|j<00>
jj<00>dd}nd}n|
}|dk(rtjjntjj }t|t<00>r2t|j	|<00>
j<00>
dkDrt#d<08>
<00>
||<00>
5}t|tjj<00>rt%|<06>
n
t'|<06>
cddd<03>
S#1s
w
Y

yxYw
)	a

    Read an image from a file into an array.

    .. note::

        This function exists for historical reasons.  It is recommended to
        use `PIL.Image.open` instead for loading images.

    Parameters
    ----------
    fname : str or file-like
        The image file to read: a filename, a URL or a file-like object opened
        in read-binary mode.

        Passing a URL is deprecated.  Please open the URL
        for reading and pass the result to Pillow, e.g. with
        ``np.array(PIL.Image.open(urllib.request.urlopen(url)))``.
    format : str, optional
        The image file format assumed for reading the data.  The image is
        loaded as a PNG file if *format* is set to "png", if *fname* is a path
        or opened file with a ".png" extension, or if it is a URL.  In all
        other cases, *format* is ignored and the format is auto-detected by
        `PIL.Image.open`.

    Returns
    -------
    `numpy.array`
        The image data. The returned array has shape

        - (M, N) for grayscale images.
        - (M, N, 3) for RGB images.
        - (M, N, 4) for RGBA images.

        PNG images are returned as float arrays (0-1).  All other formats are
        returned as int arrays, with a bit depth determined by the file's
        contents.
    r)
<01>parseNr(r*
<00>geturl<72>namez<65>Please open the URL for reading and pass the result to Pillow, e.g. with ``np.array(PIL.Image.open(urllib.request.urlopen(url)))``.)<14>urllibrrO<00>str<74>urlparser,<00>schemer<00>suffixr<78><00>hasattrrr+
<00>PngImagePlugin<69>PngImageFiler,
<00>openr<6E><00>_pil_png_to_float_arrayr@
)r/
rwr<00>parsed<65>ext<78>img_openrBs       rI<00>imreadr#<00>sI
<00><00>N
<1D>
<0A>~<7E><15>e<EFBFBD>S<EFBFBD>!<21><1A>^<5E>^<5E>E<EFBFBD>*<2A>F<EFBFBD><13>6<EFBFBD>=<3D>=<3D>!<21>A<EFBFBD>%<25><1B><03><1A>5<EFBFBD>k<EFBFBD>(<28>(<28>.<2E>.<2E>0<><11><12>4<><03>
<14>U<EFBFBD>H<EFBFBD>
%<25><18>C<EFBFBD>
<14>U<EFBFBD>F<EFBFBD>
#<23><16>u<EFBFBD>z<EFBFBD>z<EFBFBD>"<22>)<29>)<29>/<2F>/<2F>1<>!<21>"<22>5<>C<EFBFBD><17>C<EFBFBD><14><03>+.<2E>%<25><<3C><03><1A><1A>'<27>'<27>S<EFBFBD>Y<EFBFBD>Y<EFBFBD>^<5E>^<5E>
<0A><11>%<25><13><1D>#<23>e<EFBFBD>n<EFBFBD>n<EFBFBD>U<EFBFBD>&;<3B>&B<>&B<>"C<>a<EFBFBD>"G<><18>
I
<01><0E>	<0E>

<12>%<25><1F>%<25>E<EFBFBD><1D>e<EFBFBD>S<EFBFBD>%7<>%7<>%D<>%D<>E<>(<28><05>.<2E><1C>U<EFBFBD>#<23>%<25>%<25>%<25>s<00>:F<03>F
)<02>metadata<74>
pil_kwargsc	<00><><00>d
dlm
}

tj|
<01>
}
t	|t
j<00>rtj|<00>
}|<05>It	|t<00>rt|<00>
jddntjdj<00>}|dvrH|	<09>td|<05><00><02>
<00>
|
|d<08>	<09>}|j|
||||d
<EFBFBD><0B>
|j!|||d
|<08><0C>
y|<06>tjd
}nt#j$d|<06><0F>
|dk(r|
ddd<11>}
t	|
t&<00>r3|
j(dk(r$|
j*dk(r|
j,ddk(r|
}n;t/j0|<04><15>
}
|
j3||<03>
|
j5|
d
<EFBFBD><16>}|	<09>i}	n|	j7<00>}	|j,d|j,d
f}tj8|d<17><18>}t:j<j?d||ddd
d<04>}|dk(r<>d|	vr|r<>t#j@d<1D>

n}ddtjB<00>d <20>i
|<08>|n
i<00>
}t:jDjG<00>x
|	d<}|jI<00>D]\}}|<12>
<01>	|jK||<12>
<00>n|<08>td!|<05><02><02>
<00>
|d"vr<>d#}tjd$}tMjN|d%<25>rtjd&}tQd'<27>tSjT|<13>
D<00><00>
}t:j<jWd(||<14>}|jY||<0F>
|}|	j[d)|<05>
|	j[d*||f<02>
|j\|f
i|	<09>
<01>

y)+ae	
    Colormap and save an array as an image file.

    RGB(A) images are passed through.  Single channel images will be
    colormapped according to *cmap* and *norm*.

    .. note::

       If you want to save a single channel image as gray scale please use an
       image I/O library (such as pillow, tifffile, or imageio) directly.

    Parameters
    ----------
    fname : str or path-like or file-like
        A path or a file-like object to store the image in.
        If *format* is not set, then the output format is inferred from the
        extension of *fname*, if any, and from :rc:`savefig.format` otherwise.
        If *format* is set, it determines the output format.
    arr : array-like
        The image data. Accepts NumPy arrays or sequences
        (e.g., lists or tuples). The shape can be one of
        MxN (luminance), MxNx3 (RGB) or MxNx4 (RGBA).
    vmin, vmax : float, optional
        *vmin* and *vmax* set the color scaling for the image by fixing the
        values that map to the colormap color limits. If either *vmin*
        or *vmax* is None, that limit is determined from the *arr*
        min/max value.
    cmap : str or `~matplotlib.colors.Colormap`, default: :rc:`image.cmap`
        A Colormap instance or registered colormap name. The colormap
        maps scalar data to colors. It is ignored for RGB(A) data.
    format : str, optional
        The file format, e.g. 'png', 'pdf', 'svg', ...  The behavior when this
        is unset is documented under *fname*.
    origin : {'upper', 'lower'}, default: :rc:`image.origin`
        Indicates whether the ``(0, 0)`` index of the array is in the upper
        left or lower left corner of the Axes.
    dpi : float
        The DPI to store in the metadata of the file.  This does not affect the
        resolution of the output image.  Depending on file format, this may be
        rounded to the nearest integer.
    metadata : dict, optional
        Metadata in the image file.  The supported keys depend on the output
        format, see the documentation of the respective backends for more
        information.
        Currently only supported for "png", "pdf", "ps", "eps", and "svg".
    pil_kwargs : dict, optional
        Keyword arguments passed to `PIL.Image.Image.save`.  If the 'pnginfo'
        key is present, it completely overrides *metadata*, including the
        default 'Software' key.
    r<00>
<01>FigureNr(zsavefig.format)<04>pdf<64>ps<70>eps<70>svgz'Cannot use 'pil_kwargs' when saving to F)r<00>frameonT)r<><00>vmin<69>vmaxr<78><00>resize)rrw<00>transparentr$r<>)r<>r<>r<>r<>r<>r<>
rsr%)
r<>r<>
<00>
C)
<01>requirements<74>RGBA<42>rawr*
<00>pnginfoz@'metadata' is overridden by the 'pnginfo' entry in 'pil_kwargs'.<2E>SoftwarezMatplotlib versionz, https://matplotlib.org/z"metadata not supported for format )<02>jpg<70>jpegr9zsavefig.facecolorrzfigure.facecolorc
3<00>8K
<00>|]}
t
|
dz<00>
<00>
<01>

<00>y
<01>w
)r<>N)
r6rQs  rIrSzimsave.<locals>.<genexpr>ss<00><00><><00>J<>1<EFBFBD>#<23>a<EFBFBD>#<23>g<EFBFBD>,<2C>J<>s<00>
<01>RGBrwr)/<2F>matplotlib.figurer(r-<00>
asanyarrayrO<00>os<6F>PathLike<6B>fspathrrrr<>r<>r<>r<><00>figimage<67>savefigrr<><00>
memoryviewrwr<>r3<00>
mcolorizer<EFBFBD>	Colorizer<65>set_climr<6D>r2
<00>requirer+
r,
<00>
frombufferr<EFBFBD><00>__version__r<00>PngInfo<66>items<6D>add_textr<00>
_str_equalr<EFBFBD>
r<><00>to_rgb<67>new<65>paste<74>
setdefaultr.
)r/
r<>
r.r/r<>rwr<>rr$r%r(r<>
r<><00>sm<73>	pil_shaperBr6<00>
krS
<00>	facecolor<6F>color<6F>
backgrounds                      rI<00>imsaverX<00>s`<00><00>h
)<29>
<0A>-<2D>-<2D><03>
<1C>C<EFBFBD><11>%<25><12><1B><1B>%<25><12>	<09>	<09>%<25> <20><05>
<0A>~<7E>,6<>u<EFBFBD>c<EFBFBD>,B<>$<24>u<EFBFBD>+<2B>$<24>$<24>Q<EFBFBD>R<EFBFBD>(<28><1A>|<7C>|<7C>$4<>5<>u<EFBFBD>u<EFBFBD>w<EFBFBD>	<0F>
<0A>,<2C>,<2C><15>!<21><1C>9<>&<26><18>B<>
D
<01>

D
<01><14><13>e<EFBFBD>,<2C><03><0B><0C><0C>S<EFBFBD>t<EFBFBD>$<24>T<EFBFBD>&<26> <20>	<15>
	"<22><0B><0B><0B>E<EFBFBD>s<EFBFBD>6<EFBFBD>t<EFBFBD>%<25>	<14>
	'<27>
<12>><3E><18>\<5C>\<5C>.<2E>1<>F<EFBFBD><10><1E><1E>1<>&<26>A<><11>W<EFBFBD><1C><15>d<EFBFBD><02>d<EFBFBD>)<29>C<EFBFBD><16>s<EFBFBD>J<EFBFBD>'<27>C<EFBFBD>J<EFBFBD>J<EFBFBD>#<23>,=<3D><17>H<EFBFBD>H<EFBFBD>
<01>M<EFBFBD>c<EFBFBD>i<EFBFBD>i<EFBFBD><02>m<EFBFBD>q<EFBFBD>&8<>
<17>D<EFBFBD><1B>%<25>%<25>4<EFBFBD>0<>B<EFBFBD><0E>K<EFBFBD>K<EFBFBD><04>d<EFBFBD>#<23><15>:<3A>:<3A>c<EFBFBD><14>:<3A>.<2E>D<EFBFBD><15><1D><1B>J<EFBFBD>$<24><1F><1F>*<2A>J<EFBFBD><19>Z<EFBFBD>Z<EFBFBD>
<01>]<5D>D<EFBFBD>J<EFBFBD>J<EFBFBD>q<EFBFBD>M<EFBFBD>2<>	<09><11>z<EFBFBD>z<EFBFBD>$<24>S<EFBFBD>1<><04><13>	<09>	<09>$<24>$<24><12>I<EFBFBD>t<EFBFBD>U<EFBFBD>F<EFBFBD>A<EFBFBD>q<EFBFBD>
:<3A><05><11>U<EFBFBD>?<3F><19>J<EFBFBD>&<26><1B><18>&<26>&<26>
(J
<01>
K
<01><1F>#5<>c<EFBFBD>o<EFBFBD>o<EFBFBD>5F<35>
G
;<3B>
"<<3C><12>$,<2C>#7<>x<EFBFBD>R<EFBFBD><12><08>
36<33>2D<32>2D<32>2L<32>2L<32>2N<32>N<>
<EFBFBD>9<EFBFBD>%<25><07>$<24>N<EFBFBD>N<EFBFBD>,<2C>/<2F>D<EFBFBD>A<EFBFBD>q<EFBFBD><18>}<7D><1F>(<28>(<28><11>A<EFBFBD>.<2E>/<2F><16>
!<21><1C>A<>&<26><1A>L<>M<>M<><11>_<EFBFBD>$<24><1B>F<EFBFBD><1B><0C><0C>%8<>9<>I<EFBFBD><14><1F><1F>	<09>6<EFBFBD>2<><1F>L<EFBFBD>L<EFBFBD>);<3B><<3C>	<09><19>J<><07><0E><0E>y<EFBFBD>0I<30>J<>J<>E<EFBFBD><1C><19><19><1D><1D>u<EFBFBD>i<EFBFBD><15>?<3F>J<EFBFBD><16><1C><1C>U<EFBFBD>E<EFBFBD>*<2A><1E>E<EFBFBD><12><1D><1D>h<EFBFBD><06>/<2F><12><1D><1D>e<EFBFBD>c<EFBFBD>3<EFBFBD>Z<EFBFBD>0<><12><05>
<EFBFBD>
<EFBFBD>5<EFBFBD>'<27>J<EFBFBD>'rKc
<00>.<00>|jd
vrtj|<00>
S|jjd<02>
r<>|j	d|j<00>}
|jjd<04>
rtj|
d<05>}ntj|
d<06>}|j|jddd<08><00>
jd	<09>
S	|jd
<EFBFBD>
}tj|<00>
S#t$r}td<0B>
|<03>d}~w
wxYw
)a`

    Load a `PIL image`_ and return it as a numpy int array.

    .. _PIL image: https://pillow.readthedocs.io/en/latest/reference/Image.html

    Returns
    -------
    numpy.array

        The array shape depends on the image type:

        - (M, N) for grayscale images.
        - (M, N, 3) for RGB images.
        - (M, N, 4) for RGBA images.
    )r4<00>RGBXr;<00>
LzI;16r5r<>
z>u2z<u2Nr<4E>z=u2r4zUnknown image mode)
<0A>moder-<00>asarray<61>
startswith<EFBFBD>tobytes<65>endswithrHr<>
rVr<><00>convertr<74>r<>)<04>pilImager5rD<00>errs    rIr@
r@
|s<><00><00> <10>}<7D>}<7D>4<>4<><11>z<EFBFBD>z<EFBFBD>(<28>#<23>#<23>	<11><1D><1D>	!<21>	!<21>&<26>	)<29><16><1E><1E>u<EFBFBD>h<EFBFBD>m<EFBFBD>m<EFBFBD>4<><03><13>=<3D>=<3D>!<21>!<21>#<23>&<26><12>
<0A>
<0A>c<EFBFBD>5<EFBFBD>)<29>A<EFBFBD><12>
<0A>
<0A>c<EFBFBD>5<EFBFBD>)<29>A<EFBFBD><10>y<EFBFBD>y<EFBFBD><18><1D><1D>t<EFBFBD><12>t<EFBFBD>,<2C>-<2D>4<>4<>U<EFBFBD>;<3B>;<3B>	><3E><1F>'<27>'<27><06>/<2F>H<EFBFBD><12>z<EFBFBD>z<EFBFBD>(<28>#<23>#<23><><1A>
	><3E><1E>3<>4<>#<23>=<3D><>
	><3E>s<00>C:<00>:	D<03>D<03>Dc
<00><><00>|j}
|jj}|d
k(r$tj|tj
<00>S|dk(r&tj|dtj
<00><04>S|dk(r&tj|dtj
<00><04>S|dk(r&tj|dtj
<00><04>S|d	k(r&tj|d
tj
<00><04>S|
dk(r&tj|dtj
<00><04>S|
dk(r5tj|jd
<0A>
dtj
<00><04>S|
dk(r5tj|jd
<0A>
dtj
<00><04>S|
d
k(r&tj|dtj
<00><04>Std|<02><00><02>
<00>
)z2Convert a PIL `PNGImageFile` to a 0-1 float array.<2E>
1zL;2rsr&zL;4<>r[r<>zI;16Bi<42><69>r;<00>
Pr4<00>LAzUnknown PIL rawmode: )	r\r*
<00>
im_rawmoder-r]r<>r<>
rar<>)<03>pil_pngr\<00>rawmodes   rIrr<00>sP
<00><00><13><<3C><<3C>D<EFBFBD><15>k<EFBFBD>k<EFBFBD>$<24>$<24>G<EFBFBD><0E>#<23>~<7E><11>z<EFBFBD>z<EFBFBD>'<27>2<EFBFBD>:<3A>:<3A>.<2E>.<2E><0E>%<25><17><11>y<EFBFBD>y<EFBFBD><17>(<28>"<22>*<2A>*<2A>=<3D>=<3D><0E>%<25><17><11>y<EFBFBD>y<EFBFBD><17>(<28>"<22>*<2A>*<2A>=<3D>=<3D><0E>#<23>~<7E><11>y<EFBFBD>y<EFBFBD><17>(<28>"<22>*<2A>*<2A>=<3D>=<3D><0E>'<27><19><11>y<EFBFBD>y<EFBFBD><17>)<29>2<EFBFBD>:<3A>:<3A>><3E>><3E><0B>u<EFBFBD>}<7D><11>y<EFBFBD>y<EFBFBD><17>(<28>"<22>*<2A>*<2A>=<3D>=<3D><0B>s<EFBFBD>{<7B><11>y<EFBFBD>y<EFBFBD><17><1F><1F><16>0<>(<28>"<22>*<2A>*<2A>M<>M<><0B>t<EFBFBD>|<7C><11>y<EFBFBD>y<EFBFBD><17><1F><1F><16>0<>(<28>"<22>*<2A>*<2A>M<>M<><0B>v<EFBFBD>~<7E><11>y<EFBFBD>y<EFBFBD><17>(<28>"<22>*<2A>*<2A>=<3D>=<3D>
<14>,<2C>W<EFBFBD>I<EFBFBD>6<>
7<EFBFBD>7rKc<00>V
<00>t
|<00>
}|j\}}}d
}	||	z|z}
||	z|z}|rddlm}
|j	||
f|	<09><04>}
nddlm}
|||
f|	<09><04>}
t|
<0A>

|
jgd<06>
ddgg<00>	<09>}|j|dd
|<03><0B>
|
j|
|	<09><0C>
|
S)
a<>
    Make a thumbnail of image in *infile* with output filename *thumbfile*.

    See :doc:`/gallery/misc/image_thumbnail_sgskip`.

    Parameters
    ----------
    infile : str or file-like
        The image file. Matplotlib relies on Pillow_ for image reading, and
        thus supports a wide range of file formats, including PNG, JPG, TIFF
        and others.

        .. _Pillow: https://python-pillow.github.io

    thumbfile : str or file-like
        The thumbnail filename.

    scale : float, default: 0.1
        The scale factor for the thumbnail.

    interpolation : str, default: 'bilinear'
        The interpolation scheme used in the resampling. See the
        *interpolation* parameter of `~.Axes.imshow` for possible values.

    preview : bool, default: False
        If True, the default backend (presumably a user interface
        backend) will be used which will cause a figure to be raised if
        `~matplotlib.pyplot.show` is called.  If it is False, the figure is
        created using `.FigureCanvasBase` and the drawing backend is selected
        as `.Figure.savefig` would normally do.

    Returns
    -------
    `.Figure`
        The figure instance containing the thumbnail.
    <20>drN)<02>figsizerr')rrr(r(rF)<04>aspectr-<00>xticks<6B>yticksT)ror*r<>)
r)r#r3<00>matplotlib.pyplot<6F>pyplot<6F>figurer<r(r<00>add_axes<65>imshowrB)<10>infile<6C>	thumbfileryr<><00>previewr!
<00>rows<77>cols<6C>depthrr7r8<00>pltr<74>
r(r<>s                rI<00>	thumbnailr~<00>s<><00><00>N

<10><06><1E>B<EFBFBD><1A><08><08><15>D<EFBFBD>$<24><05><0E>C<EFBFBD>
<11>C<EFBFBD>Z<EFBFBD>%<25>
<1F>F<EFBFBD><10>3<EFBFBD>J<EFBFBD><15><1E>E<EFBFBD><0E>'<27><11>j<EFBFBD>j<EFBFBD>%<25><16><1F>c<EFBFBD>j<EFBFBD>:<3A><03>,<2C><14>e<EFBFBD>V<EFBFBD>_<EFBFBD>#<23>6<><03><18><13><1D>	<0C><1C><1C>l<EFBFBD>6<EFBFBD>#<23>B<EFBFBD>r<EFBFBD>
<16>

;<3B>B<EFBFBD><06>I<EFBFBD>I<EFBFBD>b<EFBFBD><16>$<24>m<EFBFBD>I<EFBFBD>L<><07>K<EFBFBD>K<EFBFBD>	<09>s<EFBFBD>K<EFBFBD>#<23><0E>JrK)
r<>rN)NNNNNrm)g<><67><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>?rF)Lrb
r<>r><00>logging<6E>pathlibrru<00>numpyr-<00>	PIL.Imager+
<00>PIL.PngImagePlugin<69>
matplotlibr<EFBFBD>rrr<00>matplotlib._image<67>matplotlib.artist<73>artistr<74><00>matplotlib.colorizerr<72>rD<00>matplotlib.backend_basesr<00>matplotlib.colors<72>colorsr<73><00>matplotlib.transformsr	r
rrr
rr<00>	getLoggerr<72>r:
r<<00>BILINEAR<41>BICUBIC<49>SPLINE16<31>SPLINE36<33>HANNING<4E>HAMMING<4E>HERMITE<54>KAISER<45>QUADRIC<49>CATROM<4F>GAUSSIAN<41>BESSEL<45>MITCHELL<4C>SINC<4E>LANCZOS<4F>BLACKMANr<4E><00>setrJ
rJror<>r<><00>ColorizingArtistrPri
r<>
r<>
r<>
rr#rXr@
rr~r
rKrI<00><module>r<>
s]<00>


<01>
<04>

<0C>	<09><0E><18><0F><12><10><19><18>"<22><1D>
 <20>#<23>)<29>5<>#<23>
(<28>
(<28>
(<28><19>w<EFBFBD><18><18><18>"<22><04>
<02>
<EFBFBD>F<EFBFBD>N<EFBFBD>N<EFBFBD>
<02>
<EFBFBD>F<EFBFBD>N<EFBFBD>N<EFBFBD>
<02><0E>v<EFBFBD>~<7E>~<7E>
<02><0F><06><0F><0F>	
<02>
<0E>v<EFBFBD>~<7E>~<7E>
<02><0F><06><0F><0F>

<02><0F><06><0F><0F>
<02><0E>v<EFBFBD>~<7E>~<7E>
<02><0E>v<EFBFBD>~<7E>~<7E>
<02><0E>v<EFBFBD>~<7E>~<7E>
<02>
<0A>f<EFBFBD>m<EFBFBD>m<EFBFBD>
<02><0E>v<EFBFBD>~<7E>~<7E>
<02>
<0A>f<EFBFBD>m<EFBFBD>m<EFBFBD>
<02><0F><06><0F><0F>
<02>
<0A>f<EFBFBD>m<EFBFBD>m<EFBFBD>
<02> <0F><06><0F><0F>!
<02>"<0B>F<EFBFBD>K<EFBFBD>K<EFBFBD>#
<02>$<16>~<7E>~<7E><16><0F><0F><19>><3E>><3E>)
<02>	<09>.<1B>9<EFBFBD>~<7E><14>5
D
<01>r
7;<3B>,
<17>`
<@
<01>q<EFBFBD>5
<0F>p

<10>G	
<1F><1A>,<2C>,<2C>G	
<1F>Ty
<1D>
<EFBFBD>y
<1D>xj
<1D>i<EFBFBD>j
<1D>ZD
<1D>)<29>D
<1D>N?
<1A>*<2A>?
<1A>D@

I
<01>
<EFBFBD>@

I
<01>FK

%<25>\@
D
<01><1F>C
(<28>-1<>d<EFBFBD>C
(<28>L 
$<24>F

8<><;E
<01><1B>=
rK