B 0d6E@sdZddlZddlmZmZmZmZmZmZmZm Z m Z m Z m Z m Z yHyddlmZWnek rrddlZYnXdZeedseje_Wnek rdZYnXdd d d d d gZdZdddZddd Zddd Zddd ZdZddd Zddd ZdS)aA A collection of image utilities using the Python Imaging Library (PIL). This is a local version of utility functions from scipy that are wrapping PIL functionality. These functions are deprecated in scipy 1.0.0 and will be removed in scipy 1.2.0. Therefore, the functionality used in sklearn is copied here. This file is taken from scipy/misc/pilutil.py in scipy 1.0.0. Modifications include: making this module importable if pillow is not installed, removal of DeprecationWarning, removal of functions scikit-learn does not need. Copyright (c) 2001, 2002 Enthought, Inc. All rights reserved. Copyright (c) 2003-2017 SciPy Developers. All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: a. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. b. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. c. Neither the name of Enthought nor the names of the SciPy Developers may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. N) aminamaxravelasarrayarangeonesnewaxis transpose iscomplexobjuint8 issubdtypearray)ImageT frombytesF bytescaleimreadimsave fromimagetoimageimresizezThe Python Imaging Library (PIL) is required to load data from jpeg files. Please refer to https://pillow.readthedocs.io/en/stable/installation.html for installing PIL.cCs|jtkr|S|dkrtd|dkr.td||kr>td|dkrN|}|dkr^|}||}|dkrxtdn |dkrd}t|||}||||}|||d tS) a Byte scales an array (image). Byte scaling means converting the input image to uint8 dtype and scaling the range to ``(low, high)`` (default 0-255). If the input image already has dtype uint8, no scaling is done. This function is only available if Python Imaging Library (PIL) is installed. Parameters ---------- data : ndarray PIL image data array. cmin : scalar, default=None Bias scaling of small values. Default is ``data.min()``. cmax : scalar, default=None Bias scaling of large values. Default is ``data.max()``. high : scalar, default=None Scale max value to `high`. Default is 255. low : scalar, default=None Scale min value to `low`. Default is 0. Returns ------- img_array : uint8 ndarray The byte-scaled array. Examples -------- >>> import numpy as np >>> from scipy.misc import bytescale >>> img = np.array([[ 91.06794177, 3.39058326, 84.4221549 ], ... [ 73.88003259, 80.91433048, 4.88878881], ... [ 51.53875334, 34.45808177, 27.5873488 ]]) >>> bytescale(img) array([[255, 0, 236], [205, 225, 4], [140, 90, 70]], dtype=uint8) >>> bytescale(img, high=200, low=100) array([[200, 100, 192], [180, 188, 102], [155, 135, 128]], dtype=uint8) >>> bytescale(img, cmin=0, cmax=255) array([[91, 3, 84], [74, 81, 5], [52, 34, 28]], dtype=uint8) rz+`high` should be less than or equal to 255.rz+`low` should be greater than or equal to 0.z0`high` should be greater than or equal to `low`.Nz$`cmax` should be larger than `cmin`.g?)dtyper ValueErrorminmaxfloatZclipastype)datacmincmaxhighlowZcscalescalebytedatar%L/var/www/html/venv/lib/python3.7/site-packages/sklearn/externals/_pilutil.pyrJs(1  cCs$ts ttt|}t|||dS)a Read an image from a file as an array. This function is only available if Python Imaging Library (PIL) is installed. Parameters ---------- name : str or file object The file name or file object to be read. flatten : bool, default=False If True, flattens the color layers into a single gray-scale layer. mode : str, default=None Mode to convert image to, e.g. ``'RGB'``. See the Notes for more details. Returns ------- imread : ndarray The array obtained by reading the image. Notes ----- `imread` uses the Python Imaging Library (PIL) to read an image. The following notes are from the PIL documentation. `mode` can be one of the following strings: * 'L' (8-bit pixels, black and white) * 'P' (8-bit pixels, mapped to any other mode using a color palette) * 'RGB' (3x8-bit pixels, true color) * 'RGBA' (4x8-bit pixels, true color with transparency mask) * 'CMYK' (4x8-bit pixels, color separation) * 'YCbCr' (3x8-bit pixels, color video format) * 'I' (32-bit signed integer pixels) * 'F' (32-bit floating point pixels) PIL also provides limited support for a few special modes, including 'LA' ('L' with alpha), 'RGBX' (true color with padding) and 'RGBa' (true color with premultiplied alpha). When translating a color image to black and white (mode 'L', 'I' or 'F'), the library uses the ITU-R 601-2 luma transform:: L = R * 299/1000 + G * 587/1000 + B * 114/1000 When `flatten` is True, the image is converted using mode 'F'. When `mode` is not None and `flatten` is True, the image is first converted according to `mode`, and the result is then flattened using mode 'F'. )flattenmode)pillow_installed ImportErrorPILLOW_ERROR_MESSAGEropenr)namer'r(imr%r%r&rs4 cCs0t|dd}|dkr ||n |||dS)a Save an array as an image. This function is only available if Python Imaging Library (PIL) is installed. .. warning:: This function uses `bytescale` under the hood to rescale images to use the full (0, 255) range if ``mode`` is one of ``None, 'L', 'P', 'l'``. It will also cast data for 2-D images to ``uint32`` for ``mode=None`` (which is the default). Parameters ---------- name : str or file object Output file name or file object. arr : ndarray, MxN or MxNx3 or MxNx4 Array containing image values. If the shape is ``MxN``, the array represents a grey-level image. Shape ``MxNx3`` stores the red, green and blue bands along the last dimension. An alpha layer may be included, specified as the last colour band of an ``MxNx4`` array. format : str, default=None Image format. If omitted, the format to use is determined from the file name extension. If a file object was used instead of a file name, this parameter should always be used. Examples -------- Construct an array of gradient intensity values and save to file: >>> import numpy as np >>> from scipy.misc import imsave >>> x = np.zeros((255, 255)) >>> x = np.zeros((255, 255), dtype=np.uint8) >>> x[:] = np.arange(255) >>> imsave('gradient.png', x) Construct an array with three colour bands (R, G, B) and store to file: >>> rgb = np.zeros((255, 255, 3), dtype=np.uint8) >>> rgb[..., 0] = np.arange(255) >>> rgb[..., 1] = 55 >>> rgb[..., 2] = 1 - np.arange(255) >>> imsave('rgb_gradient.png', rgb) ) channel_axisN)rsave)r-arrformatr.r%r%r&rs /   cCsts ttt|std|dk r<||jkrf||}n*|jdkrfd|jkr\|d}n |d}|rv|d}n|jdkr|d }t |}|S) a Return a copy of a PIL image as a numpy array. This function is only available if Python Imaging Library (PIL) is installed. Parameters ---------- im : PIL image Input image. flatten : bool, default=False If true, convert the output to grey-scale. mode : str, default=None Mode to convert image to, e.g. ``'RGB'``. See the Notes of the `imread` docstring for more details. Returns ------- fromimage : ndarray The different colour bands/channels are stored in the third dimension, such that a grey-image is MxN, an RGB-image MxNx3 and an RGBA-image MxNx4. zInput is not a PIL image.NPZ transparencyRGBARGBF1L) r)r*r+rZ isImageType TypeErrorr(convertinfor )r.r'r(ar%r%r&rs"          z7Mode is unknown or incompatible with input array shape.cCsvts ttt|}t|r$tdt|j} t| dkpTt| dkoTd| kpTd| k} | sbtdt| dkr| d| df} |dkr| t j } t || | } | S|d krPt|||||d } t d | | } |d k r| t|td nT|dkrLtdddtd d d tftdtd td d f}| t|td | S|dkrx||k} t d| | } | S|d krtt|}|d krtt|}|d||||||}|dkr| t j} t || | } ntt| S|d krVd| kr&t t| dkd}n.t t| dk}t|rL|d}ntdn|}| |}|dkrttdt|||||d } |dkr| }| d| df} nR|dkrt| d}| d| df} n(|dkrt| d}| d| df} |d kr|dkrd}nd}|dkr,tt|dkrH|dkrHtd|dkrd|dkrdtdt || |} | S)a#Takes a numpy array and returns a PIL image. This function is only available if Python Imaging Library (PIL) is installed. The mode of the PIL image depends on the array shape and the `pal` and `mode` keywords. For 2-D arrays, if `pal` is a valid (N,3) byte-array giving the RGB values (from 0 to 255) then ``mode='P'``, otherwise ``mode='L'``, unless mode is given as 'F' or 'I' in which case a float and/or integer array is made. .. warning:: This function uses `bytescale` under the hood to rescale images to use the full (0, 255) range if ``mode`` is one of ``None, 'L', 'P', 'l'``. It will also cast data for 2-D images to ``uint32`` for ``mode=None`` (which is the default). Notes ----- For 3-D arrays, the `channel_axis` argument tells which dimension of the array holds the channel data. For 3-D arrays if one of the dimensions is 3, the mode is 'RGB' by default or 'YCbCr' if selected. The numpy array must be either 2 dimensional or 3 dimensional. z&Cannot convert a complex-valued array.r/z8'arr' does not have a suitable array shape for any mode.rrr7)Nr9r4)r!r"rr r9N)rr4)r>r8g?Iz!Could not find channel dimension.)r>r?z$Channel axis dimension is not valid.)rr/r)rr/rr6r5)r6r5YCbCrCMYK)r6rBzInvalid array shape for mode.)r5rC)r)r*r+rr rlistshapelenrnumpyZfloat32rrtobytesrZ putpaletter rrrrrrZuint32_errstrZ flatnonzeror )r2r!r"rr Zpalr(r0rrEZvalidZdata32imager$caZnumchZstrdatar%r%r&rCs                             bilinearc Cst||d}t|}t|tjrB|d}tt|j|t }n:tt|tj rltt|j|t }n|d|df}dddddd}|j |||d}t |S) at Resize an image. This function is only available if Python Imaging Library (PIL) is installed. .. warning:: This function uses `bytescale` under the hood to rescale images to use the full (0, 255) range if ``mode`` is one of ``None, 'L', 'P', 'l'``. It will also cast data for 2-D images to ``uint32`` for ``mode=None`` (which is the default). Parameters ---------- arr : ndarray The array of image to be resized. size : int, float or tuple * int - Percentage of current size. * float - Fraction of current size. * tuple - Size of the output image (height, width). interp : str, default='bilinear' Interpolation to use for re-sizing ('nearest', 'lanczos', 'bilinear', 'bicubic' or 'cubic'). mode : str, default=None The PIL image mode ('P', 'L', etc.) to convert `arr` before resizing. If ``mode=None`` (the default), 2-D images will be treated like ``mode='L'``, i.e. casting to long integer. For 3-D and 4-D arrays, `mode` will be set to ``'RGB'`` and ``'RGBA'`` respectively. Returns ------- imresize : ndarray The resized array of image. See Also -------- toimage : Implicitly used to convert `arr` according to `mode`. scipy.ndimage.zoom : More generic implementation that does not use PIL. )r(gY@rrr/r>)ZnearestZlanczosrLZbicubicZcubic)Zresample) rtyper rGZ signedintegertupler sizerintZfloatingresizer) r2rOZinterpr(r.tspercentfuncZimnewr%r%r&rs*  )NNrr)FN)N)FN)rrNNNNN)rLN)__doc__rGrrrrrrrr r r r r ZPILrr*r)hasattr fromstringr__all__r+rrrrrIrrr%r%r%r&*s,8    K ; 7 9 }