
    ߧe-l                     |	   d Z dZddlZddlZddlZddlZddlZddlZddlZddl	Z	ddl
Z
	 ddlZn# e$ r dZY nw xY w	 ddlZn# e$ r dZY nw xY w	 ddlZn# e$ r dZY nw xY w	 ddlZn# e$ r dZY nw xY w	 ddlZn# e$ r dZY nw xY w	 ddlZn# e$ r dZY nw xY w	 ddlZddlZddlZn# e$ r dZY nw xY w	 ddlZn# e$ r dZY nw xY w	 ddlZn# e$ r dZY nw xY w	 ddlZn# e$ r dZY nw xY w	 ddlZn# e$ r dZY nw xY w	 ddlZn# e$ r dZY nw xY w	 ddlZn# e$ r dZY nw xY w	 ddlZn# e$ r dZY nw xY w	 ddl Z n# e$ r dZ Y nw xY w	 ddl!Z!n# e$ r dZ!Y nw xY w	 ddl"Z"n# e$ r dZ"Y nw xY wdg fdZ#dLdZ$d Z%d Z&dMd	Z'dNd
Z(dOdZ)dOdZ*dPdZ+dPdZ,dQdZ-e$dOd            Z.dg fdZ/e/Z0dRdZ1dMdZ2dMdZ3 e$e          dSd            Z4 e$e          dTd            Z5dUdZ6dRdZ7dVdZ8dWdZ9dUdZ:dRd Z;dXd"Z<dRd#Z= e$e          	 	 	 	 	 	 	 dYd&            Z> e$e          dRd'            Z?dNd(Z@dRd)ZA e$e           dZd+            ZB e$e           dRd,            ZC e$e          d[d/            ZD e$e          dRd0            ZE e$e          dNd1            ZF e$e          dRd2            ZG e$e          dNd3            ZH e$e          dRd4            ZI e$e          d\d5            ZJ e$e          dWd6            ZK e$e          dNd7            ZL e$e          dRd8            ZM e$e          dNd9            ZN e$e          dRd:            ZO e$e          	 d]d<            ZP e$e          d^d=            ZQ e$e          dTd>            ZR e$e          dMd?            ZS e$e          d_d@            ZT e$e          dWdA            ZU e$e          dRdB            ZV e$e          d`dC            ZW e$e          dRdD            ZX e$e          	 dadE            ZY e$e          dMdF            ZZ e$e          dRdG            Z[ e$e          dRdH            Z\e]dIk    r:ddl^Z^ e_ e#                        e
j`        d;dJK            e^ja                     dS dS )bzPython implementations of image codecs.

This module implements a limited set of image and compression codecs using
pure Python and 3rd party Python packages.
The module is intended for testing and reference, not production code.

z
2022.12.22    Nc                    |s|                     dt          fdt          j        fdt          j        fddt          t          dd          fdt          rt          j        nd	fd
t          rt          j        nd	fdt          rt          j
                    dd         nd	fdt          rt          j        nd	fdt          rdnd	fdt          rdnd	fdt          rdnd	fdt           rdnd	fdt"          rt"          j        nd	fdt$          rt$          j        nd	fdt&          rt&          j        nd	fdt(          rt(          j        nd	fdt*          rt*          j        nd	fdt,          rt,          j        nd	fdt.          rt.          j        nd	fdt0          rt0          j        nd	ff           | t2          u s| d                    d |D                       S | t6          u rt7          |          S t9          |          S )z<Return detailed version information about test dependencies.zimagecodecs.pynumpyzlib)bz2stdliblzma__version__r   blosczn/ablosc2zstd   lz4lzfunknownlzham
pyliblzfsesnappyzopflipyzfpy
bitshufflepillow	numcodecszarrtifffileczifileNz, c              3   *   K   | ]\  }}| d | V  dS )-N ).0kvs      8lib/python3.11/site-packages/imagecodecs/_imagecodecs.py	<genexpr>zversion.<locals>.<genexpr>   s0      ;;1A;;;;;;    )extendr	   r   r   ZLIB_VERSIONgetattrr   r
   r   r   versionr   VERSIONr   r   lzfser   zopflizfpr   r   r   r   r   r   strjoindicttuple)astype
_versions_s     r#   r)   r)      s    
!;/%+,*+!}h??@u?%++%@B6--UC@"--5As56S3		e4u7))%8E<yyu=999E:6DV//uEC:U; .8CJ**e B6--UCyKi33eLT<))u=XHX115I7EG//F1	
 	
 	
8 }}yy;;
;;;;;;~~Jr%   Fc                 N    d }t          |           r ||           S | s|S d }|S )a0  Return function decorator that raises NotImplementedError if not arg.

    >>> @notimplemented
    ... def test(): pass
    >>> test()
    Traceback (most recent call last):
    ...
    NotImplementedError: test not implemented

    >>> @notimplemented(True)
    ... def test(): pass
    >>> test()

    c                 F     t          j                    fd            }|S )Nc                  2    t          j         d          )N not implemented)NotImplementedError__name__)argskwargsfuncs     r#   notimplementedz7notimplemented.<locals>.wrapper.<locals>.notimplemented   s    %&H&H&HIIIr%   )	functoolswraps)r<   r=   s   ` r#   wrapperznotimplemented.<locals>.wrapper   s>    				J 	J 	J 	J 
		J r%   c                     | S Nr   )r<   s    r#   nopznotimplemented.<locals>.nop   s    r%   )callable)argr@   rC   s      r#   r=   r=      sR        }} ws||    Jr%   c                     | S )zDecode NOP.r   datar:   r;   s      r#   none_decoderI          Kr%   c                     | S )zEncode NOP.r   rG   s      r#   none_encoderL      rJ   r%   c                     t          j        |           5 }t          j        |fi |}t	          |d          r'	 |j        |         }n# t          $ r Y nw xY w||         }ddd           n# 1 swxY w Y   |S )zDecode NPY and NPZ.filesN)ioBytesIOr   loadhasattrrN   	Exception)rH   indexoutr;   fhs        r#   numpy_decoderW      s    	D		 Rj&&v&&3   		%(   e*C               Js4   #A+AA+
AA+AA++A/2A/c                     t          j                    5 }|rt          j        || fi | nt          j        || fi | |                    d           |                                }ddd           n# 1 swxY w Y   |S )zEncode NPY and NPZ.r   N)rO   rP   r   savez_compressedsaveseekread)rH   levelrU   r;   rV   s        r#   numpy_encoder^      s    	  	+"2t66v6666Jr4**6***



ggii               Js   AA33A7:A7r   r   c                    |dk    rt          d| d          t          | t          t          f          rZt	          j        | d          } t	          j        | d          }t	          j        |d| d                                                   S | j	        }|j
        dk    r$|                     |j         d	|j                   } t	          j        | |          }t          d
          g| j        z  }d||<   t	          j        |d| t!          |                   |          }| j	        j        r|n&|                    d                                          }|j
        dk    r|                    |          S |S )zeEncode Delta.

    >>> delta_encode(b'0123456789')
    b'0\x01\x01\x01\x01\x01\x01\x01\x01\x01'

    r   dist r7   u1dtyper   axisfuNT)r8   
isinstancebytes	bytearrayr   
frombufferdiffinserttobytesrc   kindview	byteorderitemsizeslicendimr1   isnativebyteswapnewbyteorder)rH   re   distrU   rl   rc   keys          r#   delta_encoderz      se    qyy!"@$"@"@"@AAA$	*++ 8D111z$Q'''|D!T!W--55777JEzSyyEO>>en>>??:d&&&D;;-$)
#CCI<aeCjj!1===D:&N44DMM$,?,?,L,L,N,NDzSyyKr%   c                    |dk    rt          d| d          ||j        j        sd}t          | t          t
          f          r@t          j        | d          } t          j        | dd|          	                                S t          j        | || j
        |          }| j
        j        r|n&|                    d	                                          S )
zeDecode Delta.

    >>> delta_decode(b'0\x01\x01\x01\x01\x01\x01\x01\x01\x01')
    b'0123456789'

    r   r`   r7   Nra   rb   r   re   rc   rU   T)r8   flags	writeablerh   ri   rj   r   rk   cumsumrn   rc   ru   rv   rw   rH   re   rx   rU   s       r#   delta_decoder     s     qyy!"@$"@"@"@AAA
sy2$	*++ ID111|Dq#>>>FFHHH
,t$djc
B
B
BC*%L333<<+=+=+J+J+L+LLr%   c                    t          | t          t          f          rit          j        | d          } t          j        | dd         | dd                   }t          j        |d| d                                                   S | j        }|j	        dk    r| 
                    d|j                   } t          d          g| j        z  }d||<   t          d          g| j        z  }t          ddd          ||<   t          d          g| j        z  }t          ddd          ||<   t          |          }t          |          }t          |          }t          j        | |         | |                   }t          j        |d| |         |	          }|j	        dk    r|
                    |          S | j        j        s'|                    d
                                          }|S )zgEncode XOR delta.

    >>> xor_encode(b'0123456789')
    b'0\x01\x03\x01\x07\x01\x03\x01\x0f\x01'

    ra   rb   r   Nr   r   rf   rg   rd   T)rh   ri   rj   r   rk   bitwise_xorrm   rn   rc   ro   rp   rr   rs   rt   r1   ru   rv   rw   )rH   re   rU   xorrc   ry   key0key1s           r#   
xor_encoder   (  s    $	*++ 7D111QRR$ss)44|CDG,,44666JEzSyy-U^--..;;-$)
#CCI$KK=49$Dq$%%DJ$KK=49$Dq"d##DJ
**C;;D;;D

DJT

3
3C
,sAtCyt
4
4
4CzSxxZ  0ll4  --//Jr%   c                 0   t          | t          t          f          rt| d         }t          |          g}| dd         D ])}||z  }|                    t          |                     *d                    |                              d          S t          )zgDecode XOR delta.

    >>> xor_decode(b'0\x01\x03\x01\x07\x01\x03\x01\x0f\x01')
    b'0123456789'

    r   r   N latin1)rh   ri   rj   chrappendr/   encoder8   )rH   re   rU   prevbcs         r#   
xor_decoder   M  s     $	*++ +AwYYKabb 	  	 At8DHHSYYwwqzz  ***
r%   c                    |dk    rt          d| d          |dk    rt          d|d          | j        }| j        }t          |          dk     rt	          d          |j        d	vrt	          d
          | j        j        dk    pt          j        dk    o| j        j        dk    }|                     d          } |dd         dz   |dd         z   | _        t          j
        | dd|            |r|dd         dz   |dd         z   | _        t          j        | dd          } t          j        | dd          } | ddddf         } t          j        |           } |                     |          } || _        | S )a  Decode floating point horizontal differencing.

    The TIFF predictor type 3 reorders the bytes of the image values and
    applies horizontal byte differencing to improve compression of floating
    point images. The ordering of interleaved color channels is preserved.

    Parameters
    ----------
    data : numpy.ndarray
        The image to be decoded. The dtype must be a floating point.
        The shape must include the number of contiguous samples per pixel
        even if 1.

    r   r`   r7   r   zaxis z != -2   zinvalid data shapedfeznot a floating point image<little=uint8N)r   r   r|   .)r8   shaperc   len
ValueErrorcharrq   sysrp   r   r   swapaxesascontiguousarray)rH   re   rx   rU   r   rc   littleendians          r#   floatpred_decoder   ^  s    qyy!"@$"@"@"@AAArzz!"8$"8"8"8999JEJE
5zzA~~-...z5666:'3. !Adj&:c&A  99WDsse#eBCCj0DJ	LBg48888 53B3Z%'%*4
>$B''D>$B''DTTrT	?D"4((D99UDDJKr%   c                     dS )z Encode Floating Point Predictor.Nr   r   s       r#   floatpred_encoder     s      r%   c                 ~   |sD|                     d           |                     t          j        |d         d                     	 |                     d          }t          j        |d         ||           | S # t
          $ r |                     |d                   cY S t          $ r t          d          w xY w)a  Reverse bits in each byte of byte string or numpy array.

    Decode data where pixels with lower column values are stored in the
    lower-order bits of the bytes (TIFF FillOrder is LSB2MSB).

    Parameters
    ----------
    data : byte string or ndarray
        The data to be bit reversed. If byte string, a new bit-reversed byte
        string is returned. Numpy arrays are bit-reversed in-place.

    Examples
    --------
    >>> bitorder_decode(b'\x01\x64')
    b'\x80&'
    >>> data = numpy.array([1, 666], dtype='uint16')
    >>> bitorder_decode(data)
    array([  128, 16473], dtype=uint16)
    >>> data
    array([  128, 16473], dtype=uint16)

    s    @ `P0pH(hX8xD$dT4tL,l\<|B"bR2r
J*jZ:zF&fV6vN.n^>~A!aQ1q	I)iY9yE%eU5uM-m]=}C#cS3sK+k[;{G'gW7wO/o_?r   r   rb   r   )rU   zslices of arrays not supported)	r   r   rk   rp   takeAttributeError	translater   r8   )rH   rU   	_bitorderrp   s       r#   bitorder_decoder     s    .  H!	
 	
 	
 	))A,gFFFGGGDyy!!
9Q<40000 , , ,~~il+++++ D D D!"BCCCDs   3A< <%B<#B<c                 2   g }|j         }d}	 	 t          | ||dz                      dz   }|dz  }|dk    r" || ||dz            d|z
  z             |dz  }n!|dk     r || |||z                       ||z  }l# t          $ r Y nw xY wt          |          S )aJ  Decompress PackBits encoded byte string.

    >>> packbits_decode(b'\x80\x80')  # NOP
    b''
    >>> packbits_decode(b'\x02123')
    b'123'
    >>> packbits_decode(
    ...   b'\xfe\xaa\x02\x80\x00\x2a\xfd\xaa\x03\x80\x00\x2a\x22\xf7\xaa')[:-4]
    b'\xaa\xaa\xaa\x80\x00*\xaa\xaa\xaa\xaa\x80\x00*"\xaa\xaa\xaa\xaa\xaa\xaa'

    r   Tr        )r&   ord	TypeErrorri   )encodedrU   
out_extendins        r#   packbits_decoder     s     CJ	A
	GAAI&''!+AFA3ww
71q1u9-q9:::QS
71q1u9-...Q
	    ::s   A-A: :
BBc           	          t                     }|dz  }t          j        d t          d          D             }|                    d            fd}ddt          dd	          fd
dt          dd	          fddt          dd	          fddt          dd	          fd}|d         \  }d|dk     rt          d           |            dk    rt          d          d}	d}
g }|j        }	  |            }	|z  |	dk    s|k    rn|	dk    rG|dd         }|j        }d}|d         \  } |            }	|z  |	dk    rny |||	                    nT|	|k     r||	         }||
         |dd         z   }n||
         }||dd         z  }|} ||            ||           |dz  }|	}
||v r||         \  }|	dk    r	 d                    |          S )a  Decompress LZW (Lempel-Ziv-Welch) encoded TIFF strip (byte string).

    The strip must begin with a CLEAR code and end with an EOI code.

    This implementation of the LZW decoding algorithm is described in TIFF v6
    and is not compatible with old style LZW compressed files like
    quad-lzw.tif.

    >>> lzw_decode(b'\x80\x1c\xcc\'\x91\x01\xa0\xc2m6\x99NB\x03\xc9\xbe\x0b'
    ...            b'\x07\x84\xc2\xcd\xa68|"\x14 3\xc3\xa0\xd1c\x94\x02\x02')
    b'say hammer yo hammer mc hammer go hammer'

       c                 .    g | ]}t          |g          S r   )ri   )r    r   s     r#   
<listcomp>zlzw_decode.<locals>.<listcomp>  s     ///qqc

///r%      )r   r   c            
          dz  } | | dz            }	  d|          d         }n8# t           $ r+  d|ddt          |          z
  z  z             d         }Y nw xY w|dz  z  }|z  }|z	  S )Nr      z>Ir       )rS   r   )startscodebitcountr   maskshrunpacks      r#   	next_codezlzw_decode.<locals>.next_code  s    AEEAI%&	?6$??1%DD 	? 	? 	?6$Gq3q66z$: :;;A>DDD	?As{s   ( 2AA	       11111111100000000000000000000000   
       11111111110000000000000000000000       11111111111000000000000000000000       11111111111100000000000000000000)   i  i  i  r   r   r   z(strip must be at least 4 characters longz strip must begin with CLEAR codeTi  Nr   r   r%   )	r   structr   ranger&   intr   r   r/   )r   
buffersizerU   len_encodedbitcount_maxnewtabler   
switchbitsbitwr   oldcoderesultresult_appendtabletable_appendlentabledecodednewcoder   r   r   r   s   `                 @@@@r#   
lzw_decoder     s    g,,K?L]F//E#JJ///HOOF
 
 
 
 
 
 
 
 
 S+Q//0"c-q1122s.2232s.223	 J !oOD#tHQCDDDy{{c;<<<DGFMM3y{{D3;;(l223;;QQQKE <LH(oOD#t9;;DHs{{M%+&&&&h+.72A2;6.72A2;&!M'"""L!!!MHz!!(2OD#t93< s{{88Fr%   c                    dk    rt          j        | d          } t          j        |           } |dz  r@|                     d|d|dz  z
  z             } | ddd|f                             d          } |                     |          S t          j        |          }dv rt          j        | |          S dvrt          d           |j        d	vrt          d
          t          fddD                       }||j	        k    rt          d          |dk    rdt          |           z  z  }|z  dz  }|rd|z
  }|dz  z
  }t          dz  d|z  z   d          }d|j        z   }	t          j        }
|t          |           dz  |z  |z   z  z  }t          j        |f|          }d}t!          |          D ]}|dz  }| |||z            }	  |
|	|          d         }n8# t"          $ r+  |
|	|d|t          |          z
  z  z             d         }Y nw xY w||dz  z  }||z  }||z	  ||<   |z  }|dz   |z  dk    r||z  }|S )a  Decompress byte string to array of integers of any bit size <= 32.

    This Python implementation is slow and only handles itemsizes 1, 2, 4, 8,
    16, 32, and 64.

    Parameters
    ----------
    data : byte str
        Data to decompress.
    dtype : numpy.dtype or str
        A numpy boolean or integer type.
    bitspersample : int
        Number of bits per integer.
    runlen : int
        Number of consecutive integers, after which to start at next byte.

    Examples
    --------
    >>> packints_decode(b'a', 'B', 1)
    array([0, 1, 1, 0, 0, 0, 0, 1], dtype=uint8)
    >>> packints_decode(b'ab', 'B', 2)
    array([1, 2, 0, 1, 1, 2, 0, 2], dtype=uint8)

    r   z|Br   r   N)r          @   )r   r   r   r   r   r   zitemsize not supported: buzinvalid dtypec              3   .   K   | ]}d |z  k    |V  dS )r   Nr   )r    r   bitspersamples     r#   r$   z"packints_decode.<locals>.<genexpr>g  s1      GG1A0F0FQ0F0F0F0FGGr%   )r   r   r   r   zdtype.itemsize too smallr   10r   >r   )r   rk   
unpackbitsreshaper2   rc   r   ro   nextrr   r   r   r   r   r   emptyr   rS   )rH   rc   r   runlenrU   	itembytesskipbitsshrbitsbitmaskdtypestrr   sizer   r   r   r   r   r   s     `               r#   packints_decoder   >  s   2 d++%%A: 	0<<Fa&1*n$=>>D7F7
#++B//D{{5!!!KE''e,,,000CMCCDDDz)))GGGGGGGGGIEN""3444{{c$ii-M1%)H  x<!mm+G-#%g5q99GUZH]FSYY]v'='HIJD[$%((FH4[[ ! !A**+	K6(A&&q)DD 	K 	K 	K6(A9s1vv3E(F$FGGJDDD	KAGOq	M!EVq   HMs   G))2HHc                     t          | t          j                  rt          j        | |          S t          j        | d|dz             } t          j        | |          } |                                 S )zBitshuffle.uintr   rb   )rh   r   ndarrayr   rk   rn   )rH   r]   rr   	blocksizerU   s        r#   bitshuffle_encoder     sm     $&& 6$T9555D(=x!|(=(=>>>D y11D<<>>r%   c                     t          | t          j                  rt          j        | |          S t          j        | d|dz             } t          j        | |          } |                                 S )zBitunshuffle.r   r   rb   )rh   r   r   r   bitunshufflerk   rn   )rH   rr   r   rU   s       r#   bitshuffle_decoder    sm     $&& 8&tY777D(=x!|(=(=>>>D"433D<<>>r%      c                 ,    t          j        | |          S )zCompress Zlib.)r   compressrH   r]   rU   s      r#   zlib_encoder        =u%%%r%   c                 *    t          j        |           S )zDecompress Zlib.)r   
decompressrH   rU   s     r#   zlib_decoder        ?4   r%   c                 >    |rt           t          j        | |          S )zCompress Deflate/Zlib.)r8   r   r  )rH   r]   rawrU   s       r#   deflate_encoder    s"    
 "!!=u%%%r%   c                 <    |rt           t          j        |           S )zDecompress deflate/Zlib.)r8   r   r  )rH   r  rU   s      r#   deflate_decoder    s     
 "!!?4   r%   c                 ,    t          j        | |          S )zCompress GZIP.)gzipr  r  s      r#   gzip_encoder    r	  r%   c                 *    t          j        |           S )zDecompress GZIP.)r  r  r  s     r#   gzip_decoder    r  r%   r   c                 ,    t          j        | |          S )zCompress BZ2.)r   r  r  s      r#   
bz2_encoder    s    <e$$$r%   c                 *    t          j        |           S )zDecompress BZ2.)r   r  r  s     r#   
bz2_decoder    s    >$r%   blosclzr   c                 X    |t           j        }|d}t          j        | ||||          S )zCompress Blosc.Nr   )typesizeclevelshufflecname)r
   SHUFFLEr  )rH   r]   
compressor
numthreadsr  r   r!  rU   s           r#   blosc_encoder&    sB     -}>   r%   c                 *    t          j        |           S )zDecompress Blosc.)r
   r  r  s     r#   blosc_decoder(         D!!!r%   c                 *    t          j        |           S )zCompress LZMA.)r   r  r  s      r#   lzma_encoder+    s    =r%   c                 *    t          j        |           S )zDecompress LZMA.)r   r  r  s     r#   lzma_decoder-    r  r%      c                 ,    t          j        | |          S )zCompress ZStandard.)r   r  r  s      r#   zstd_encoder0    s     =u%%%r%   c                 *    t          j        |           S )zDecompress ZStandard.)r   r  r  s     r#   zstd_decoder2    s     ?4   r%   r   r   c                 2    t          j        | |||          S )zCompress Brotli.)qualitymodelgwin)brotlir  )rH   r]   r5  r6  rU   s        r#   brotli_encoder8    s     ?4TGGGGr%   c                 *    t          j        |           S )zDecompress Brotli.)r7  r  r  s     r#   brotli_decoder:         T"""r%   c                 *    t          j        |           S )zCompress Snappy.)r   r  r  s      r#   snappy_encoder=    s     ?4   r%   c                 *    t          j        |           S )zDecompress Snappy.)r   r  r  s     r#   snappy_decoder?    r;  r%   c                     t          j        t           j                  }|                    |           |                                z   S )zCompress Zopfli.)r,   ZopfliCompressorZOPFLI_FORMAT_ZLIBr  flush)rH   r]   rU   r   s       r#   zopfli_encoderD    s6     	 9::A::daggii''r%   c                     t          j        t           j                  }|                    |           |                                z   S )zDecompress Zopfli.)r,   ZopfliDecompressorrB  r  rC  )rH   rU   ds      r#   zopfli_decoderH    s6     	!&";<<A<<		))r%   c                 *    t          j        |           S )zCompress LZF.)r   r  rH   r]   headerrU   s       r#   
lzf_encoderL  "  s     <r%   c                 *    t          j        |           S )zDecompress LZF.)r   r  )rH   rK  rU   s      r#   
lzf_decoderN  (  s     >$r%   c                 *    t          j        |           S )zCompress LZFSE.)r+   r  r  s      r#   lzfse_encoderP  .  s     >$r%   c                 *    t          j        |           S )zDecompress LZFSE.)r+   r  r  s     r#   lzfse_decoderR  4  r)  r%   c                 .    t          j        | |          S )zCompress LZHAM.)r]   )r   r  r  s      r#   lzham_encoderT  :  s     >$e,,,,r%   c                 ,    t          j        | |          S )zDecompress LZHAM.)r   r  r  s     r#   lzham_decoderV  @  s     D#&&&r%   Tc                 4   d|i}|dt           j        ddfv rnp|t           j        ddfv r
|dn||d<   nU|t           j        dd	fv r
|dn||d	<   n:|t           j        d
dfv r
|dn||d<   n|t           j        ddfv r|\  }}}	}
t          t          j        | fi |S )zCompress ZFP.write_headerNR
reversiblep	precisionr   rrateaaccuracy	tolerancer   expert)r-   	mode_nullmode_fixed_precisionmode_fixed_ratemode_fixed_accuracymode_expertr8   compress_numpy)rH   r]   r5  	executionrK  rU   r;   minbitsmaxbitsmaxprecminexps              r#   
zfp_encodern  F  s    
 f%FcmS,777	#*C=	=	=$)Mbbu{	#%sF3	3	3$}%v	#)3
;	;	;$)Mbbu{	#/31	1	1,1)'6!!d--f---r%   c                 *    t          j        |           S )zDecompress ZFP.)r-   decompress_numpy)rH   r   rc   rU   s       r#   
zfp_decoderq  Z  s     %%%r%   c                 ,    t          j        | |          S )zCompress LZ4 with Bitshuffle.)r   compress_lz4)rH   r]   r   rU   s       r#   bitshuffle_lz4_encodert  `  s     "4333r%   c                 0    t          j        | |||          S )zDecompress LZ4 with Bitshuffle.)r   decompress_lz4)rH   r   rc   r   rU   s        r#   bitshuffle_lz4_decoderw  f  s     $T5%CCCr%   c                 D    t           j                            | |          S )zCompress LZ4.)
store_size)r   blockr  rJ  s       r#   
lz4_encoder{  l  s     9dv666r%   c                 >   |rt           j                            |           S t          |t                    r!t           j                            | |          S t          dddt          |           dz
  z  z             }t           j                            | |          S )zDecompress LZ4.)uncompressed_size   r   r   )r   rz  r  rh   r   maxr   )rH   rK  rU   outsizes       r#   
lz4_decoder  r  s      *y##D)))#s Ay##DC#@@@"b3#d))b.1122G9@@@r%   c                     t          j        |           5 }t          j        |fd|i|}ddd           n# 1 swxY w Y   |S )zDecode TIFF.ry   N)rO   rP   r   imread)rH   ry   r;   rV   rU   s        r#   tiff_decoder  }  s     
D		 5Rob44c4V445 5 5 5 5 5 5 5 5 5 5 5 5 5 5Js   6::c                     t          j                    5 }t          j        || fi | |                    d           |                                }ddd           n# 1 swxY w Y   |S )zEncode TIFF.r   N)rO   rP   r   imwriter[   r\   )rH   r]   r;   rV   rU   s        r#   tiff_encoder    s     
 T,,V,,,



ggii               Js   =AA!$A!c                     t          j        t          j                            t          j        |                               S )zDecode image data using Pillow.)r   asarrayr   ImageopenrO   rP   r  s     r#   
pil_decoder    s.     =**2:d+;+;<<===r%   c                      t          |           S )zDecode JPEG 8-bit.r  )rH   tables
colorspaceoutcolorspacerU   s        r#   jpeg8_decoder    s    
 dr%   c                      t          |           S )zDecode JPEG 2000.r  )rH   verboserU   s      r#   jpeg2k_decoder         dr%   c                      t          |           S )zDecode WebP.r  r  s     r#   webp_decoder    r  r%   c                      t          |           S )zDecode PNG.r  r  s     r#   
png_decoder    r  r%   __main__r   )suppressr\  )F)r   N)NN)r   r   N)r   N)r   r   NrB   )r   r   r   N)r   r   N)r  N)r  FN)FN)r   N)Nr  r   r   r   NN)r.  N)r   r   r   N)NFN)NNNTN)NNN)r   FN)r   )NNNN)b__doc__r	   r   r>   r  rO   r   r   r   r   r   PILr   ImportErrorr   r
   r   r7  r   rS   r   	lz4.block	lz4.framer   liblzfser+   r   r   r   r   r-   r,   r   r   r   r)   r=   rI   rL   rW   r^   rz   r   r   r   r   r   r   bitorder_encoder   r   r   r   r  r  r  r  r  r  r  r  r  r&  r(  r+  r-  r0  r2  r8  r:  r=  r?  rD  rH  rL  rN  rP  rR  rT  rV  rn  rq  rt  rw  r{  r  r  r  r  r  r  r  r  r9   doctestprintset_printoptionstestmodr   r%   r#   <module>r     s  @   



      				   



     FFF   JJJLLLL   EEEMMMM   FFFMMMM   FFFNNNN   GGGJJJ   
CCCJJJJ   
CCC   EEELLLL   EEEMMMM   FFFOOOO   HHH   
CCCMMMM   FFFKKKK   DDDKKKK   DDD   III B # # # #L   D  
  

 
 
 
	 	 	 	   <M M M M$" " " "J   "* * * *Z + + + + #b 0 0 0 0f "   @U U U UpF F F FR 
    
   & & & &
! ! ! !
& & & &! ! ! !& & & &
! ! ! !
% % % %
       
     0 " " " "
   
! ! ! !
 & & & &
 ! ! ! !
 H H H H
 # # # #
 ! ! ! !
 # # # #
 ( ( ( ( * * * *    
        
        
 " " " "
 - - - -
 ' ' ' '
 BF. . . .& & & & &
 
4 4 4 4
 
D D D D
 7 7 7 7
 A A A A         > > > >
 @D       
    
    
 zNNN	E''))EDA6666GO s+  / 99A AAA AA#A( (A21A26A; ;BB	B BBB) )B32B37B< <CC
C CCC" "C,+C,0C5 5C?>C?D DDD D%$D%)D. .D87D8<E E
EE EE"E' 'E10E1