
    dh                        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g fdZ dHdZ!d Z"d Z#dId	Z$dJd
Z%dKdZ&dKdZ'dLdZ(dLdZ)dMdZ*e!dKd            Z+dg fdZ,e,Z-dNdZ.dIdZ/dIdZ0 e!e          dOd            Z1 e!e          dPd            Z2dQdZ3dNdZ4dRdZ5dSdZ6dQdZ7dNd Z8dTd"Z9dNd#Z: e!e          	 	 	 	 	 	 	 dUd&            Z; e!e          dNd'            Z<dJd(Z=dNd)Z> e!e          dVd+            Z? e!e          dNd,            Z@ e!e          dWd/            ZA e!e          dNd0            ZB e!e          dJd1            ZC e!e          dNd2            ZD e!e          dJd3            ZE e!e          dNd4            ZF e!e          dXd5            ZG e!e          dSd6            ZH e!e          	 dYd8            ZI e!e          dZd9            ZJ e!e          dPd:            ZK e!e          dId;            ZL e!e          d[d<            ZM e!e          dSd=            ZN e!e          dNd>            ZO e!e          d\d?            ZP e!e          dNd@            ZQ e!e          	 d]dA            ZR e!e          dIdB            ZS e!e          dNdC            ZT e!e          dNdD            ZUeVdEk    r:ddlWZW eX e                         e
jY        d7dFG            eWjZ                     dS dS )^zPython 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	2021.8.26    Nc                 z   |sh|                     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	                    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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t*          rt*          j        nd	ff           | t,          u s| d                    d |D                       S | t0          u rt1          |          S t3          |          S )z<Return detailed version information about test dependencies.zimagecodecs.pynumpyzlib)bz2stdliblzma__version__r   blosczn/azstd   lz4lzfunknown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   versionr   VERSIONr   r   zopflizfpr   r   r   r   r   r   strjoindicttuple)astype
_versions_s     r    r&   r&      s    
!;/%+,*+!}h??@u?%++%@@"--5As56S3		e4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//F+	
 	
 	
2 } < <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)r8   r9   s   ` r    wrapperznotimplemented.<locals>.wrapper   s>    				J 	J 	J 	J 
		J r"   c                     | S Nr   )r8   s    r    nopznotimplemented.<locals>.nop   s    r"   )callable)argr<   r?   s      r    r9   r9      sR        }} ws||    Jr"   c                     | S )zDecode NOP.r   datar6   r7   s      r    none_decoderE          Kr"   c                     | S )zEncode NOP.r   rC   s      r    none_encoderH      rF   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hasattrrJ   	Exception)rD   indexoutr7   fhs        r    numpy_decoderS      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)rK   rL   r   savez_compressedsaveseekread)rD   levelrQ   r7   rR   s        r    numpy_encoderZ      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 r3   u1dtyper   axisfuNT)r4   
isinstancebytes	bytearrayr   
frombufferdiffinserttobytesr_   kindview	byteorderitemsizeslicendimr-   isnativebyteswapnewbyteorder)rD   ra   distrQ   rh   r_   keys          r    delta_encoderv      sn    qy B!"@$"@"@"@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\   r3   Nr]   r^   r   ra   r_   rQ   T)r4   flags	writeablerd   re   rf   r   rg   cumsumrj   r_   rq   rr   rs   rD   ra   rt   rQ   s       r    delta_decoder}   	  s     qy B!"@$"@"@"@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'

    r]   r^   r   Nr   r   rb   rc   r`   T)rd   re   rf   r   rg   bitwise_xorri   rj   r_   rk   rl   rn   ro   rp   r-   rq   rr   rs   )rD   ra   rQ   xorr_   ru   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 0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)rd   re   rf   chrappendr+   encoder4   )rD   ra   rQ   prevbcs         r    
xor_decoder   @  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\   r3   r   zaxis z != -2   zinvalid data shapedfeznot a floating point image<little=uint8N)r   r   rx   .)r4   shaper_   len
ValueErrorcharrm   sysrl   r   r{   swapaxesascontiguousarray)rD   ra   rt   rQ   r   r_   littleendians          r    floatpred_decoder   Q  s    qy B!"@$"@"@"@AAArz :!"8$"8"8"8999JEJE
5zzA~ /-...z 7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   r^   r   )rQ   zslices of arrays not supported)	r   r   rg   rl   takeAttributeError	translater   r4   )rD   rQ   	_bitorderrl   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	TypeErrorre   )encodedrQ   
out_extendins        r    packbits_decoder     s     CJ	A
	GAAI&''!+AFA3w 
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   )re   )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       )rO   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   
buffersizerQ   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 ECDDDy{{c =;<<<DGFMM3y{{D3; 	(l2 	3; 	QQQKE <LH(oOD#t9;;DHs{ M%+&&&&h "+.72A2;6.72A2;&!M'"""L!!!MHz! 	3(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>Z  s1      GG1A0FGQGGGGGGr"   )r   r   r   r   zdtype.itemsize too smallr   10r   >r   )r   rg   
unpackbitsreshaper.   r_   r   rk   nextrn   r   r   r   r   r   emptyr   rO   )rD   r_   r   runlenrQ   	itembytesskipbitsshrbitsbitmaskdtypestrr   sizer   r   r   r   r   r   s     `               r    packints_decoder   1  s   2  "d++%%A: 	0<<Fa&1*n$=>>D7F7
#++B//D{{5!!!KE' -e,,,00 ECMCCDDDz *)))GGGGGGGGGIEN" 53444{ 2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   r^   )rd   r   ndarrayr   rg   rj   )rD   rY   rn   	blocksizerQ   s        r    bitshuffle_encoder   z  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   r^   )rd   r   r   r   bitunshufflerg   rj   )rD   rn   r   rQ   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rD   rY   rQ   s      r    zlib_encoder        =u%%%r"   c                 *    t          j        |           S )zDecompress Zlib.)r   
decompressrD   rQ   s     r    zlib_decoder	        ?4   r"   c                 >    |rt           t          j        | |          S )zCompress Deflate/Zlib.)r4   r   r  )rD   rY   rawrQ   s       r    deflate_encoder    s"    
 "!!=u%%%r"   c                 <    |rt           t          j        |           S )zDecompress deflate/Zlib.)r4   r   r  )rD   r  rQ   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  )rD   rY   
compressor
numthreadsr  r   r  rQ   s           r    blosc_encoder"    sH       - >   r"   c                 *    t          j        |           S )zDecompress Blosc.)r
   r  r  s     r    blosc_decoder$    s     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_encoder+    s     =u%%%r"   c                 *    t          j        |           S )zDecompress ZStandard.)r   r  r  s     r    zstd_decoder-    s     ?4   r"   r   r   c                 2    t          j        | |||          S )zCompress Brotli.)qualitymodelgwin)brotlir  )rD   rY   r0  r1  rQ   s        r    brotli_encoder3    s     ?4TGGGGr"   c                 *    t          j        |           S )zDecompress Brotli.)r2  r  r  s     r    brotli_decoder5         T"""r"   c                 *    t          j        |           S )zCompress Snappy.)r   r  r  s      r    snappy_encoder8    s     ?4   r"   c                 *    t          j        |           S )zDecompress Snappy.)r   r  r  s     r    snappy_decoder:    r6  r"   c                     t          j        t           j                  }|                    |           |                                z   S )zCompress Zopfli.)r(   ZopfliCompressorZOPFLI_FORMAT_ZLIBr  flush)rD   rY   rQ   r   s       r    zopfli_encoder?    s6     	 9::A::daggii''r"   c                     t          j        t           j                  }|                    |           |                                z   S )zDecompress Zopfli.)r(   ZopfliDecompressorr=  r  r>  )rD   rQ   ds      r    zopfli_decoderC    s6     	!&";<<A<<		))r"   c                 *    t          j        |           S )zCompress LZF.)r   r  rD   rY   headerrQ   s       r    
lzf_encoderG    s     <r"   c                 *    t          j        |           S )zDecompress LZF.)r   r  )rD   rF  rQ   s      r    
lzf_decoderI    s     >$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_expertr4   compress_numpy)rD   rY   r0  	executionrF  rQ   r7   minbitsmaxbitsmaxprecminexps              r    
zfp_encodera  !  s    
 f%FcmS,77 
"	#*C=	= "$)<bbu{	#%sF3	3 "$7%v	#)3
;	; "$)<bbu{	#/31	1 ",1)'6!!d--f---r"   c                 *    t          j        |           S )zDecompress ZFP.)r)   decompress_numpy)rD   r   r_   rQ   s       r    
zfp_decoderd  5  s     %%%r"   c                 ,    t          j        | |          S )zCompress LZ4 with Bitshuffle.)r   compress_lz4)rD   rY   r   rQ   s       r    bitshuffle_lz4_encoderg  ;  s     "4333r"   c                 0    t          j        | |||          S )zDecompress LZ4 with Bitshuffle.)r   decompress_lz4)rD   r   r_   r   rQ   s        r    bitshuffle_lz4_decoderj  A  s     $T5%CCCr"   c                 D    t           j                            | |          S )zCompress LZ4.)
store_size)r   blockr  rE  s       r    
lz4_encodern  G  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   rm  r  rd   r   maxr   )rD   rF  rQ   outsizes       r    
lz4_decodert  M  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.ru   N)rK   rL   r   imread)rD   ru   r7   rR   rQ   s        r    tiff_decoderw  X  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)rK   rL   r   imwriterW   rX   )rD   rY   r7   rR   rQ   s        r    tiff_encoderz  `  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openrK   rL   r  s     r    
pil_decoder  j  s.     =**2:d+;+;<<===r"   c                      t          |           S )zDecode JPEG 8-bit.r  )rD   tables
colorspaceoutcolorspacerQ   s        r    jpeg8_decoder  p  s    
 dr"   c                      t          |           S )zDecode JPEG 2000.r  )rD   verboserQ   s      r    jpeg2k_decoder  x       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   )suppressrO  )F)r   N)NN)r   r   N)r   N)r   r   Nr>   )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)[__doc__r	   r   r:   r  rK   r   r   r   r   r   PILr   ImportErrorr   r
   blosc2r2  r   rO   r   	lz4.block	lz4.framer   r   r   r   r)   r(   r   r   r   r&   r9   rE   rH   rS   rZ   rv   r}   r   r   r   r   r   bitorder_encoder   r   r   r   r   r  r	  r  r  r  r  r  r  r"  r$  r&  r(  r+  r-  r3  r5  r8  r:  r?  rC  rG  rI  ra  rd  rg  rj  rn  rt  rw  rz  r  r  r  r  r  r5   doctestprintset_printoptionstestmodr   r"   r    <module>r     s
  @   



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



     FFF   JJJLLLL   EEEMMMM   FFFMMMM   FFFNNNN   GGGJJJ   
CCCJJJJ   
CCCMMMM   FFFOOOO   HHH   
CCCMMMM   FFFKKKK   DDDKKKK   DDD   III B        F   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