image_imagenet - CSDN
精华内容
参与话题
  • python的Image模块

    万次阅读 2018-07-10 14:19:43
    Image 模块Image 模块提供了同名的类用来表示PIL的图像。Image模块还提供了许多工厂(factory)函数,包块从文件加载图像的函数,以及创建新图像的函数。 例子 下面的脚本加载了一个图像,并把它旋转了45度,然后...
    原文链接: https://www.cnblogs.com/DjangoBlog/p/3557744.html
    Image 模块
    Image 模块提供了同名的类用来表示PIL的图像。Image模块还提供了许多工厂(factory)函数,包块从文件加载图像的函数,以及创建新图像的函数。 
     
    例子 
    下面的脚本加载了一个图像,并把它旋转了45度,然后调用外部的查看器(通常在Unix下是xv,Windows下是paint)。 
     
    打开,旋转,和显示图像(使用默认的查看器) 
     
    from PIL import Image 
    im = Image.open("bride.jpg") 
    im.rotate(45).show() 
    下面的脚本为当前目录下所以的JPEG图像创建漂亮128x128的缩略图。 
     创建缩略图 
     
    from PIL import Image 
    import glob, os 
     
    size = 128, 128 
     
    for infile in glob.glob("*.jpg"): 
        file, ext = os.path.splitext(infile) 
        im = Image.open(infile) 
        im.thumbnail(size, Image.ANTIALIAS) 
        im.save(file + ".thumbnail", "JPEG") 

    函数  new 

    Image.new(mode, size) => image 

    Image.new(mode, size, color) => image 

     
    以指定的模式和大小创建一个新图像。大小以2元元组的形式给出。给colour赋单个值,表示要创建单波段图像,元组表示创建多波段图像(每个波段一个值)。如果忽略colour参数,图像将以黑色填充。如果colour设为None,图像不会被初始化。 
     

    open 

    Image.open(infile) => image 

    Image.open(infile, mode) => image 

    打开并识别给定图像文件。这是一个偷懒的操作;真正的图像数据只有到处理的时候才会被读入(调用load函数强制加载)。如果给出了模式(mode)参数,它必须设为“r”。 
     
    要打开图像,即可以使用字符串(表示文件名)也可以使用文件对象。对后一种情况,文件对象必须实现了read,seek,和 tell 方法,并以二进制模式打开。 

    blend 

    Image.blend(image1, image2, alpha) => image 

     通过使用alpha常量,在图像进行差值操作,创建新图像。两个图像必须具有相同的大小和模式。 
     out = image1 * (1.0 - alpha) + image2 * alpha 
    (注:没有成功) 
    如果设置alpha为0.0,将返回第一个图像的拷贝。如果设置alpha为1.0,将返回第二个图像的拷贝。对alpha的值没有限制。必要的话,结果会被剪裁,以适合允许的输出范围。 

     composite 

    Image.composite(image1, image2, mask) => image 

     使用遮罩(mask)作为alpha,通过在两个图像之间进行插值来创建一个新图像。遮罩图像的模式可以是“1”,“L”,或者“RGBA”。所有的图像的大小必须有相同。 

     eval 

    Image.eval_r(image, function) => image 

     把函数(function)(应该接收一个参数)应用到所给图像的每一个像素。如果图像有多个波段,相同的函数会应用到每一个波段。注意,该函数对每一个可能的像素值只计算一次,所有不能使用随机组件(components)或者其它发生器(generators)。 

     frombuffer 

    Image.frombuffer(mode, size, data) => image 

     (PIL1.1.4添加)。使用标准的“raw”解码器,把来自字符串或者缓冲区(buffer)对象的图像数据创建为一个图像内存(image memory)。对于某些模式,图像内存会和原来的缓冲区共享内存(这意味着对原始缓冲区对象的修改会影响图像)。不是所有的模式都能共享内存;支持共享内存的模式包括:“L”,“RGBX”,“RGBA”和“CMYK”。对其其它模式,这个函数的作用与fromstring函数类似。 
     
    注意:1.1.6版中,默认的方向与fromstring的不同。这些可能会在未来的版本中发生变化,所以为了最大的兼容性,建议在使用“raw”解码器的时候给出所有的参数。 
     
    im = Image.frombuffer(mode, size, data, "raw", mode, 0, 1)Image.frombuffer(mode, size, data, decoder, parameters) => image 
     
    与调用fromstring 相同。 

     fromstring 

    Image.fromstring(mode, size, data) => image 

     使用标准的“raw”解码器从来自字符串的像素数据创建一个图像内存。 
     
    Image.fromstring(mode, size, data, decoder, parameters) => image 
     
    也一样,但是允许你使用PIL支持的任何像素解码器。关于可用解码器的更多信息,参见Writing Your Own File Decoder节 
     
    注意,这个函数只对像素数据解码,而不是整个图像。如果字符串中包含了一个完整的图像文件,可以使用StringIO对象对它进行处理,并使用open函数加载图像。 

     merge 

    Image.merge(mode, bands) => image 

     从几个单波段图像创建一个新图像。bands参数是包含图像的元组或列表,一个图像对应模式中描述的一个波段。所有波段的图像必须有相同的大小。 
     
    方法 
    一个Image类的实例具有下列方法。除非另外指出,所有的方法都返回一个新的Image类的实例,包含处理过的图像数据。 

     convert 

    im.convert(mode) => image 

    返回图像转换后的副本 
     
    如果原始图像是调色板图像,这个函数通过调色板转换像素。忽略mode参数,会自动选择一个模式,以保证所有的图像信息和调色板信息在没有调色板的时候也能表示出来。 
     
    从彩色图像转换到黑白图像时,图像库使用ITU-R 601-2 luma转换: 
     
        L = R * 299/1000 + G * 587/1000 + B * 114/1000在把图像转换为二值图(bilevel image)(模式“1”)时,源图像首先被转换为黑白图。然后在结果中,值大于127的像素点被设置为白色,图像抖动(and the image is dithered)。使用point方法可以改变阈值。 
     
    im.convert(mode, matrix) => image 
     
    使用转换矩阵,把一个 "RGB" 图像转换为 "L" 或者 "RGB" 图像。其中矩阵是一个4元或16元元组。 
     
    下面的例子把一个RGB图像转换(根据ITU-R 709进行线性校正,using the D65 luminant)到CIE XYZ颜色空间: 
     
    Convert RGB to XYZ 
         rgb2xyz = ( 
            0.412453, 0.357580, 0.180423, 0, 
            0.212671, 0.715160, 0.072169, 0, 
            0.019334, 0.119193, 0.950227, 0 ) 
        out = im.convert("RGB", rgb2xyz)

    copy 

    im.copy() => image 

     Copies the image. Use this method if you wish to paste things into an image, but still retain the original.复制图像。如果你想往图像上粘贴东西,但是又保持源图像不变可以使用这个函数。  

    crop 

    im.crop(box) => image 

    返回当前图像的一个矩形区域。box参数是一个定义了左,上,右,下像素坐标的4元元组。 
     
    这是一个投篮操作。改变源图像可能会也可能不会影响剪裁的图像。要得到一个单独的拷贝,可以在剪裁的副本上应用load函数。 

     draft 

    im.draft(mode, size)  

    配置图像文件加载器,使它返回一个与给定模式和大小尽可能匹配的图像。比如,你可以在加载的时候,把一个彩色的JPEG图像转换为一个灰度图,或者从一个PCD文件中提取出一个128x192的版本。 
     
    注意这个方法在适当的时候修改图像对象。如果图像已经加载了,这个方法可能无效。 

     filter 

    im.filter(filter) => image 

    Returns a copy of an image filtered by the given filter. For a list of available filters, see the ImageFilter module. 
     

    fromstring 

    im.fromstring(data)  

    im.fromstring(data, decoder, parameters)  
    Same as the fromstring function, but loads data into the current image.  

    getbands 

    im.getbands() => tuple of strings  

    Returns a tuple containing the name of each band. For example, getbands on an RGB image returns ("R", "G", "B"). 

     getbbox 

    im.getbbox() => 4-tuple or None 
     
    Calculates the bounding box of the non-zero regions in the image. The bounding box is returned as a 4-tuple defining the left, upper, right, and lower pixel coordinate. If the image is completely empty, this method returns None. 

     getcolors 

    im.getcolors() => a list of (count, color) tuples or None 
    im.getcolors(maxcolors) => a list of (count, color) tuples or None 
     
    (New in 1.1.5) Returns an unsorted list of (count, color) tuples, where the count is the number of times the corresponding color occurs in the image. 
     
    If the maxcolors value is exceeded, the method stops counting and returns None. The default maxcolors value is 256. To make sure you get all colors in an image, you can pass in size[0]*size[1] (but make sure you have lots of memory before you do that on huge images). 

     getdata 

    im.getdata() => sequence 
     
    Returns the contents of an image as a sequence object containing pixel values. The sequence object is flattened, so that values for line one follow directly after the values of line zero, and so on. 
     
    Note that the sequence object returned by this method is an internal PIL data type, which only supports certain sequence operations, including iteration and basic sequence access. To convert it to an ordinary sequence (e.g. for printing), use list(im.getdata()).  

    getextrema 

    im.getextrema() => 2-tuple 
     
    Returns a 2-tuple containing the minimum and maximum values of the image. In the current version of PIL, this is only applicable to single-band images.  

    getpixel 

    im.getpixel(xy) => value or tuple 
     
    Returns the pixel at the given position. If the image is a multi-layer image, this method returns a tuple. 
     
    Note that this method is rather slow; if you need to process larger parts of an image from Python, you can either use pixel access objects (see load), or the getdata method.  

    histogram 

    im.histogram() => list 
     
    Returns a histogram for the image. The histogram is returned as a list of pixel counts, one for each pixel value in the source image. If the image has more than one band, the histograms for all bands are concatenated (for example, the histogram for an "RGB" image contains 768 values). 
     
    A bilevel image (mode "1") is treated as a greyscale ("L") image by this method. 
     
    im.histogram(mask) => list 
     
    Returns a histogram for those parts of the image where the mask image is non-zero. The mask image must have the same size as the image, and be either a bi-level image (mode "1") or a greyscale image ("L"). 

    load 

    im.load() 
     
    Allocates storage for the image and loads it from the file (or from the source, for lazy operations). In normal cases, you don't need to call this method, since the Image class automatically loads an opened image when it is accessed for the first time. 
     
    (New in 1.1.6) In 1.1.6 and later, load returns a pixel access object that can be used to read and modify pixels. The access object behaves like a 2-dimensional array, so you can do: 
     
    pix = im.load() 
    print pix[x, y] 
    pix[x, y] = value 
    Access via this object is a lot faster than getpixel and putpixel.  

    offset 

    im.offset(xoffset, yoffset) => image 
     
    (Deprecated) Returns a copy of the image where the data has been offset by the given distances. Data wraps around the edges. If yoffset is omitted, it is assumed to be equal to xoffset. 
     
    This method is deprecated. New code should use the offset function in the ImageChops module.  

    paste 

    im.paste(image, box) 
     
    Pastes another image into this image. The box argument is either a 2-tuple giving the upper left corner, a 4-tuple defining the left, upper, right, and lower pixel coordinate, or None (same as (0, 0)). If a 4-tuple is given, the size of the pasted image must match the size of the region. 
     
    If the modes don't match, the pasted image is converted to the mode of this image (see the convert method for details). 
     
    im.paste(colour, box) 
     
    Same as above, but fills the region with a single colour. The colour is given as a single numerical value for single-band images, and a tuple for multi-band images. 
     
    im.paste(image, box, mask) 
     
    Same as above, but updates only the regions indicated by the mask. You can use either "1", "L" or "RGBA" images (in the latter case, the alpha band is used as mask). Where the mask is 255, the given image is copied as is. Where the mask is 0, the current value is preserved. Intermediate values can be used for transparency effects. 
     
    Note that if you paste an "RGBA" image, the alpha band is ignored. You can work around this by using the same image as both source image and mask. 
     
    im.paste(colour, box, mask) 
     
    Same as above, but fills the region indicated by the mask with a single colour.  

    point 

    im.point(table) => image 
     
    im.point(function) => image 
     
    Returns a copy of the image where each pixel has been mapped through the given table. The table should contains 256 values per band in the image. If a function is used instead, it should take a single argument. The function is called once for each possible pixel value, and the resulting table is applied to all bands of the image. 
     
    If the image has mode "I" (integer) or "F" (floating point), you must use a function, and it must have the following format: 
     
        argument * scale + offsetExample: 
     
        out = im.point(lambda i: i * 1.2 + 10)You can leave out either the scale or the offset. 
     
    im.point(table, mode) => image 
     
    im.point(function, mode) => image 
     
    Map the image through table, and convert it on fly. This can be used to convert "L" and "P" images to "1" in one step, e.g. to threshold an image. 
     
    (New in 1.1.5) This form can also be used to convert "L" images to "I" or "F", and to convert "I" images with 16-bit data to "L". In the last case, you must use a 65536-item lookup table.  

    putalpha 

    im.putalpha(band) 
     
    Copies the given band to the alpha layer of the current image. 
     
    The image must be an "RGBA" image, and the band must be either "L" or "1". 
     
    (New in PIL 1.1.5) You can use putalpha on other modes as well; the image is converted in place, to a mode that matches the current mode but has an alpha layer (this usually means "LA" or "RGBA"). Also, the band argument can be either an image, or a colour value (an integer).  

    putdata 

    im.putdata(data) 
     
    im.putdata(data, scale, offset) 
     
    Copy pixel values from a sequence object into the image, starting at the upper left corner (0, 0). The scale and offset values are used to adjust the sequence values: 
     
        pixel = value * scale + offsetIf the scale is omitted, it defaults to 1.0. If the offset is omitted, it defaults to 0.0. 

    putpalette 

    im.putpalette(sequence) 
     
    Attach a palette to a "P" or "L" image. The palette sequence should contain 768 integer values, where each group of three values represent the red, green, and blue values for the corresponding pixel index. Instead of an integer sequence, you can use an 8-bit string. 

    putpixel 

    im.putpixel(xy, colour) 
     
    Modifies the pixel at the given position. The colour is given as a single numerical value for single-band images, and a tuple for multi-band images. 
     
    Note that this method is relatively slow. If you're using 1.1.6, pixel access objects (see load) provide a faster way to modify the image. If you want to generate an entire image, it can be more efficient to create a Python list and use putdata to copy it to the image. For more extensive changes, use paste or the ImageDraw module instead. 
     
    You can speed putpixel up a bit by "inlining" the call to the internal putpixel implementation method: 
     
        im.load() 
        putpixel = im.im.putpixel 
        for i in range(n): 
           ... 
           putpixel((x, y), value) 
    In 1.1.6, the above is better written as: 
     
        pix = im.load() 
        for i in range(n): 
            ... 
            pix[x, y] = value 
     
    resize 
    im.resize(size) => image 
     
    im.resize(size, filter) => image 
     
    Returns a resized copy of an image. The size argument gives the requested size in pixels, as a 2-tuple: (width, height). 
     
    The filter argument can be one of NEAREST (use nearest neighbour), BILINEAR (linear interpolation in a 2x2 environment), BICUBIC (cubic spline interpolation in a 4x4 environment), or ANTIALIAS (a high-quality downsampling filter). If omitted, or if the image has mode "1" or "P", it is set to NEAREST. 

     rotate 

    im.rotate(angle) => image 
     
    im.rotate(angle, filter=NEAREST, expand=0) => image 
     
    Returns a copy of an image rotated the given number of degrees counter clockwise around its centre. 
     
    The filter argument can be one of NEAREST (use nearest neighbour), BILINEAR (linear interpolation in a 2x2 environment), or BICUBIC (cubic spline interpolation in a 4x4 environment). If omitted, or if the image has mode "1" or "P", it is set to NEAREST. 
     
    The expand argument, if true, indicates that the output image should be made large enough to hold the rotated image. If omitted or false, the output image has the same size as the input image. 

     save 

    im.save(outfile, options...) 
     
    im.save(outfile, format, options...) 
     
    Saves the image under the given filename. If format is omitted, the format is determined from the filename extension, if possible. This method returns None. 
     
    Keyword options can be used to provide additional instructions to the writer. If a writer doesn't recognise an option, it is silently ignored. The available options are described later in this handbook. 
     
    You can use a file object instead of a filename. In this case, you must always specify the format. The file object must implement the seek, tell, and write methods, and be opened in binary mode. 
     
    If the save fails, for some reason, the method will raise an exception (usually an IOError exception). If this happens, the method may have created the file, and may have written data to it. It's up to your application to remove incomplete files, if necessary. 

     seek 

    im.seek(frame) 
     
    Seeks to the given frame in a sequence file. If you seek beyond the end of the sequence, the method raises an EOFError exception. When a sequence file is opened, the library automatically seeks to frame 0. 
     
    Note that in the current version of the library, most sequence formats only allows you to seek to the next frame. 

     show 

    im.show() 
     
    Displays an image. This method is mainly intended for debugging purposes. 
     
    On Unix platforms, this method saves the image to a temporary PPM file, and calls the xv utility. 
     
    On Windows, it saves the image to a temporary BMP file, and uses the standard BMP display utility to show it. 
     
    This method returns None.  

    split 

    im.split() => sequence 
     
    Returns a tuple of individual image bands from an image. For example, splitting an "RGB" image creates three new images each containing a copy of one of the original bands (red, green, blue). 

     tell 

    im.tell() => integer 
    Returns the current frame number.  

    thumbnail 

    im.thumbnail(size)  
    im.thumbnail(size, filter) 
     
    Modifies the image to contain a thumbnail version of itself, no larger than the given size. This method calculates an appropriate thumbnail size to preserve the aspect of the image, calls the draft method to configure the file reader (where applicable), and finally resizes the image. 
     
    The filter argument can be one of NEAREST, BILINEAR, BICUBIC, or ANTIALIAS (best quality). If omitted, it defaults to NEAREST. 
     
    Note that the bilinear and bicubic filters in the current version of PIL are not well-suited for thumbnail generation. You should use ANTIALIAS unless speed is much more important than quality. 
     
    Also note that this function modifies the Image object in place. If you need to use the full resolution image as well, apply this method to a copy of the original image. This method returns None.  

    tobitmap 

    im.tobitmap() => string 
     
    Returns the image converted to an X11 bitmap.  

    tostring 

    im.tostring() => string  
    Returns a string containing pixel data, using the standard "raw" encoder.  
    im.tostring(encoder, parameters) => string  
    Returns a string containing pixel data, using the given data encoding.  

    transform 

    im.transform(size, method, data) => image  
    im.transform(size, method, data, filter) => image 
     
    Creates a new image with the given size, and the same mode as the original, and copies data to the new image using the given transform. 
     
    In the current version of PIL, the method argument can be EXTENT (cut out a rectangular subregion), AFFINE (affine transform), QUAD (map a quadrilateral to a rectangle), or MESH (map a number of source quadrilaterals in one operation). The various methods are described below. 
     
    The filter argument defines how to filter pixels from the source image. In the current version, it can be NEAREST (use nearest neighbour), BILINEAR (linear interpolation in a 2x2 environment), or BICUBIC (cubic spline interpolation in a 4x4 environment). If omitted, or if the image has mode "1" or "P", it is set to NEAREST. 
     
    im.transform(size, EXTENT, data) => image 
     
    im.transform(size, EXTENT, data, filter) => image 
     
    Extracts a subregion from the image. 
     
    Data is a 4-tuple (x0, y0, x1, y1) which specifies two points in the input image's coordinate system. The resulting image will contain data sampled from between these two points, such that (x0, y0) in the input image will end up at (0,0) in the output image, and (x1, y1) at size. 
     
    This method can be used to crop, stretch, shrink, or mirror an arbitrary rectangle in the current image. It is slightly slower than crop, but about as fast as a corresponding resize operation. 
     
    im.transform(size, AFFINE, data) => image 
     
    im.transform(size, AFFINE, data, filter) => image 
     
    Applies an affine transform to the image, and places the result in a new image with the given size. 
     
    Data is a 6-tuple (a, b, c, d, e, f) which contain the first two rows from an affine transform matrix. For each pixel (x, y) in the output image, the new value is taken from a position (a x + b y + c, d x + e y + f) in the input image, rounded to nearest pixel. 
     
    This function can be used to scale, translate, rotate, and shear the original image. 
     
    im.transform(size, QUAD, data) => image 
     
    im.transform(size, QUAD, data, filter) => image 
     
    Maps a quadrilateral (a region defined by four corners) from the image to a rectangle with the given size. 
     
    Data is an 8-tuple (x0, y0, x1, y1, x2, y2, y3, y3) which contain the upper left, lower left, lower right, and upper right corner of the source quadrilateral. 
     
    im.transform(size, MESH, data) image => image 
     
    im.transform(size, MESH, data, filter) image => image 
     
    Similar to QUAD, but data is a list of target rectangles and corresponding source quadrilaterals. 

     transpose 

    im.transpose(method) => image 
     
    Returns a flipped or rotated copy of an image. 
     
    Method can be one of the following: FLIP_LEFT_RIGHT, FLIP_TOP_BOTTOM, ROTATE_90, ROTATE_180, or ROTATE_270.  

    verify 

    im.verify() 
     
    Attempts to determine if the file is broken, without actually decoding the image data. If this method finds any problems, it raises suitable exceptions. This method only works on a newly opened image; if the image has already been loaded, the result is undefined. Also, if you need to load the image after using this method, you must reopen the image file. 
     

    Attributes 

    Instances of the Image class have the following attributes:  

    format 

    im.format => string or None 
     
    The file format of the source file. For images created by the library, this attribute is set to None.  

    mode 

    im.mode => string 
     
    Image mode. This is a string specifying the pixel format used by the image. Typical values are "1", "L", "RGB", or "CMYK."  

    size 

    im.size => (width, height) 
     
    Image size, in pixels. The size is given as a 2-tuple (width, height).  

    palette 

    im.palette => palette 
    展开全文
  • Python图像库PIL的类Image及其方法介绍

    万次阅读 多人点赞 2018-11-29 19:10:59
    Python图像库PIL(Python Image Library)是python的第三方图像处理库,但是由于其强大的功能与众多的使用人数,几乎已经被认为是python官方图像处理库了。其官方主页为:PIL。 PIL历史悠久,原来是只支持python2.x的...

    Python图像库PIL(Python Image Library)是python的第三方图像处理库,但是由于其强大的功能与众多的使用人数,几乎已经被认为是python官方图像处理库了。其官方主页为:PIL。 PIL历史悠久,原来是只支持python2.x的版本的,后来出现了移植到python3的库pillow,pillow号称是friendly fork for PIL,其功能和PIL差不多,但是支持python3。本文主要介绍PIL那些最常用的特性与用法,主要参考自:http://www.effbot.org/imagingbook

    PIL可以做很多和图像处理相关的事情:

    • 图像归档(Image Archives)。PIL非常适合于图像归档以及图像的批处理任务。你可以使用PIL创建缩略图,转换图像格式,打印图像等等。
    • 图像展示(Image Display)。PIL较新的版本支持包括Tk PhotoImage,BitmapImage还有Windows DIB等接口。PIL支持众多的GUI框架接口,可以用于图像展示。
    • 图像处理(Image Processing)。PIL包括了基础的图像处理函数,包括对点的处理,使用众多的卷积核(convolution kernels)做过滤(filter),还有颜色空间的转换。PIL库同样支持图像的大小转换,图像旋转,以及任意的仿射变换。PIL还有一些直方图的方法,允许你展
    • 示图像的一些统计特性。这个可以用来实现图像的自动对比度增强,还有全局的统计分析等。

    图像类Image class

        Image类是PIL中的核心类,你有很多种方式来对它进行初始化,比如从文件中加载一张图像,处理其他形式的图像,或者是从头创造一张图像等。Image模块操作的基本方法都包含于此模块内。如opensaveconvershow…等方法。下面是PIL的 Image类中常用的方法和属性:

    open方法
      Image.open(file) ⇒ image 
      Image.open(file, mode) ⇒ image


    要从文件加载图像,使用 open() 函数, 在 Image 模块(类):

    代码如下:-------------------------------------------
        from PIL import Image             ##调用库,包含图像类
        im = Image.open("3d.jpg")  ##文件存在的路径,如果没有路径就是当前目录下文件
        im.show()
    运行结果:----------------------------------------------

    需要知道的是在win的环境下im.show的方式为win自带的图像显示应用。打开并确认给定的图像文件。这个是一个懒操作;该函数只会读文件头,而真实的图像数据直到试图处理该数据才会从文件读取(调用load()方法将强行加载图像数据)。如果变量mode被设置,那必须是“r”。用户可以使用一个字符串(表示文件名称的字符串)或者文件对象作为变量file的值。文件对象必须实现read(),seek()和tell()方法,并且以二进制模式打开。

    save方法
      im.save(outfile,options…)
      im.save(outfile, format, options…)


          用 Image 类的 save() 方法保存文件的文件,使用给定的文件名保存图像。如果变量format缺省,如果可能的话,则从文件名称的扩展名判断文件的格式。该方法返回为空。关键字options为文件编写器提供一些额外的指令。如果编写器不能识别某个选项,它将忽略它。用户可以使用文件对象代替文件名称。在这种情况下,用户必须指定文件格式。文件对象必须实现了seek()、tell()和write()方法,且其以二进制模式打开。如果方法save()因为某些原因失败,这个方法将产生一个异常(通常为IOError异常)。如果发生了异常,该方法也有可能已经创建了文件,并向文件写入了一些数据。如果需要的话,用户的应用程序可以删除这个不完整的文件。

    jpg 转换成png

    #----------------------------------------------
    from PIL import Image
    im = Image.open("3d.jpg")
    print(im)
    im.save("3d.png")     ## 将"3d.jpg"保存为3d.png"
    im = Image.open("3d.png")  ##打开新的png图片
    print(im.format, im.size, im.mode)
    #-----------------------------------------------

    执行 结果:

    format属性

    im.format ⇒ string or None

    这个属性标识了图像来源,如果图像不是从文件读取它的值就是None。

    #-----------------------------------------------

    from PIL import Image
    im = Image.open("3d.jpg")
    print(im.format) ## 打印出格式信息
    im.show()

    #-----------------------------------------------

    mode属性

    im.mode ⇒ string

    图像的模式,常见的mode 有 “L” (luminance) 表示灰度图像,“RGB”表示真彩色图像,和 “CMYK” 表示出版图像,表明图像所使用像素格式。如下表为常见的nodes描述:

    modes Description
    1 1位像素,黑白图像,存成8位像素
    L 8位像素,黑白
    P 9位像素,使用调色板映射到任何其他模式
    RGB 3*8位像素,真彩
    RGBA 4*8位像素,真彩+透明通道
    CMYK 4*8位像素,印刷四色模式或彩色印刷模式
    YCbCr 3*8位像素,色彩视频格式
    I 32位整型像素
    F 33位浮点型像素

     

    #---------------------------------------------------------
    from PIL import Image
    im = Image.open("3d.jpg")
    print(im.mode) ## 打印模式属性
    im.show()

    #---------------------------------------------------------

    convert方法


      im.convert(mode)⇒ image


    将当前图像转换为其他模式,并且返回新的图像。当从一个调色板图像转换时,这个方法通过这个调色板来转换像素。如果不对变量mode赋值,该方法将会选择一种模式,在没有调色板的情况下,使得图像和调色板中的所有信息都可以被表示出来。当从一个颜色图像转换为黑白图像时,PIL库使用ITU-R601-2 luma转换公式:


      L = R * 299/1000 + G * 587/1000 + B * 114/1000


    当转换为2位图像(模式“1”)时,源图像首先被转换为黑白图像。结果数据中大于127的值被设置为白色,其他的设置为黑色;这样图像会出现抖动。如果要使用其他阈值,更改阈值127,可以使用方法point()。为了去掉图像抖动现象,可以使用dither选项。

    #-----------------------------------------------

    from PIL import Image
    im = Image.open("3d.jpg")
    new_im = im.convert('P')
    print(new_im.mode)
    new_im.show()
    #-----------------------------------------------

                               P模式

     

    im.convert(“P”,**options) ⇒ image


    这个与第一个方法定义一样,但是当“RGB”图像转换为8位调色板图像时能更好的处理。可供选择的选项为:

    Dither=. 控制颜色抖动。默认是FLOYDSTEINBERG,与邻近的像素一起承担错误。不使能该功能,则赋值为NONE。

    Palette=. 控制调色板的产生。默认是WEB,这是标准的216色的“web palette”。要使用优化的调色板,则赋值为ADAPTIVE。

    Colors=. 当选项palette为ADAPTIVE时,控制用于调色板的颜色数目。默认是最大值,即256种颜色


      im.convert(mode,matrix) ⇒ image


    使用转换矩阵将一个“RGB”图像转换为“L”或者“RGB”图像。变量matrix为4或者16元组。

    #-----------------------------------------------------------
    from PIL import Image
    im = Image.open("3d.jpg")
    print(im.mode)
    rgb2xyz = (0.412453,0.357580, 0.180423, 0,
               0.212671,0.715160, 0.072169, 0,
               0.019334,0.119193, 0.950227, 0 )
    new_im = im.convert("L", rgb2xyz)
    print(new_im.mode)
    new_im.show()

                                      原图                                                               转换后图

    size属性

    im.size ⇒ (width, height)
    图像的尺寸,按照像素数计算,它的返回值为宽度和高度的二元组(width, height)。

    #----------------------------------------------------
    from PIL import Image
    im = Image.open("3d.jpg")
    print(im.size) ## 打印图像尺寸
    im.show()

    命令行显示图片的尺寸为426*306。

    palette属性
      im.palette ⇒ palette or None


    颜色调色板表格。如果图像的模式是“P”,则返回Image  Palette类的实例;否则,将为None。
    如下为对非“P”模式下的图像进行palette信息显示。

    #----------------------------------------------
    from PIL import Image
    im = Image.open("3d.jpg")
    print(im.palette)

    返回值为none

     
    对图像进行convert操作,转换成“P”模式

    #----------------------------------------------------
    from PIL import Image
    im = Image.open("3d.jpg")
    new_im = im.convert('P')
    print(new_im.mode)
    print(new_im.palette)

    则返回值为ImagePalette类的实例。如下:

    info属性
      im.info ⇒ dictionary
    存储图像相关数据的字典。文件句柄使用该字典传递从文件中读取的各种非图像信息。大多数方法在返回新的图像时都会忽略这个字典;因为字典中的键并非标准化的,对于一个方法,它不知道自己的操作如何影响这个字典。如果用户需要这些信息,需要在方法open()返回时保存这个字典。

    #-------------------------------------------
    from PIL import Image
    im = Image.open("3d.jpg")
    print(im.info)

    执行结果:

    new方法

      Image.new(mode,size) ⇒ image
      Image.new(mode, size,color) ⇒ image


    使用给定的变量mode和size生成新的图像。Size是给定的宽/高二元组,这是按照像素数来计算的。对于单通道图像,变量color只给定一个值;对于多通道图像,变量color给定一个元组(每个通道对应一个值)。在版本1.1.4及其之后,用户也可以用颜色的名称,比如给变量color赋值为“red”。如果没有对变量color赋值,图像内容将会被全部赋值为0(为黑色)。如果变量color是空,图像将不会被初始化,即图像的内容全为0。这对向该图像复制或绘制某些内容是有用的。

    下面将图像设置为128x128大小的红色图像:

    #-------------------------------------------------------
    from PIL import Image
    im = Image.open("3d.jpg")
    n_im= Image.new("RGB", (128, 128), "#FF0000")
    n_im.show()

    效果如下:

     
    下图像为128x128大小的黑色图像,因为变量color不赋值的话,图像内容被设置为0,即黑色

    #------------------------------------------
    from PIL import Image
    im = Image.open("3d.jpg")
    n_im= Image.new("RGB", (128, 128))
    n_im.show()

    图像为128x128大小的绿色图像

    #----------------------------------------
    from PIL import Image
    im = Image.open("3d.jpg")
    n_im= Image.new("RGB", (128, 128),"green")
    n_im.show()

    Copy方法


      im.copy() ⇒ image


    拷贝这个图像。如果用户想粘贴一些数据到这张图,可以使用这个方法,但是原始图像不会受到影响。
    from PIL import Image
    im = Image.open("3d.jpg")
    im_copy = im.copy()

    图像im_copy和im完全一样。

    crop方法

     im.crop(box) ⇒ image


    从当前的图像中返回一个矩形区域的拷贝。变量box是一个四元组,定义了左、上、右和下的像素坐标。用来表示在原始图像中截取的位置坐标,如box(100,100,200,200)就表示在原始图像中以左上角为坐标原点,截取一个100*100(像素为单位)的图像,为方便理解,如下为示意图box(b1,a1,b2,a2)。作图软件为Visio2016。这是一个懒操作。对源图像的改变可能或者可能不体现在裁减下来的图像中。为了获取一个分离的拷贝,对裁剪的拷贝调用方法load()。

    #-------------------------------------
    from PIL import Image
    im = Image.open("3d.jpg")
    box = (20, 30, 300, 200)              ##确定拷贝区域大小
    region = im.crop(box)                   ##将im表示的图片对象拷贝到region中,大小为box
    region.show()

    #-------------------------------------

    paste方法

      im.paste(image,box)

    将一张图粘贴到另一张图像上。变量box或者是一个给定左上角的2元组,或者是定义了左,上,右和下像素坐标的4元组,或者为空(与(0,0)一样)。如果给定4元组,被粘贴的图像的尺寸必须与区域尺寸一样。如果模式不匹配,被粘贴的图像将被转换为当前图像的模式。

    #-------------------------------------

    from PIL import Image
    im = Image.open("3d.jpg")
    box=[0,0,100,100]
    im_crop = im.crop(box)
    print(im_crop.size,im_crop.mode)
    im.paste(im_crop, (100,100))             ##(100,100,0,0)
    im.paste(im_crop, (400,400,500,500))
    im.show()

    #-------------------------------------

    filter方法

      im.filter(filter) ⇒ image

    返回一个使用给定滤波器处理过的图像的拷贝。具体参考图像滤波在ImageFilter 模块的应用,在该模块中,预先定义了很多增强滤波器,可以通过filter( )函数使用,预定义滤波器包括:BLUR、CONTOUR、DETAIL、EDGE_ENHANCE、EDGE_ENHANCE_MORE、EMBOSS、FIND_EDGES、SMOOTH、SMOOTH_MORE、SHARPEN。其中BLUR就是均值滤波,CONTOUR找轮廓,FIND_EDGES边缘检测,使用该模块时,需先导入。

    #-------------------------------------

    from PIL import Image
    from PIL import ImageFilter                         ## 调取ImageFilter
    imgF = Image.open("3d.jpg")
    bluF = imgF.filter(ImageFilter.BLUR)                ##均值滤波
    conF = imgF.filter(ImageFilter.CONTOUR)             ##找轮廓
    edgeF = imgF.filter(ImageFilter.FIND_EDGES)         ##边缘检测
    imgF.show()
    bluF.show()
    conF.show()
    edgeF.show()

    #------------------------------------

    blend方法

    Image.blend(image1,image2, alpha) ⇒ image

    使用给定的两张图像及透明度变量alpha,插值出一张新的图像。这两张图像必须有一样的尺寸和模式。

      合成公式为:out = image1 (1.0 - alpha) + image2  alpha

    若变量alpha为0.0,返回第一张图像的拷贝。若变量alpha为1.0,将返回第二张图像的拷贝。对变量alpha的值无限制。

    #-------------------------------------

    from PIL import Image
    im1 = Image.open("3d.jpg")
    im2 = Image.open("3dd.jpg")
    print(im1.mode,im1.size)
    print(im2.mode,im2.size)
    im = Image.blend(im1, im2, 0.40)
    im.show()

    #-------------------------------------

    需保证两张图像的模式和大小是一致的。
    im1按照40%的透明度,im2按照60%的透明度,合成为一张。


    split方法

     im.split() ⇒ sequence


    返回当前图像各个通道组成的一个元组。例如,分离一个“RGB”图像将产生三个新的图像,分别对应原始图像的每个通道(红,绿,蓝)。

     

    #-------------------------------------

    from PIL import Image
    im = Image.open("3d.jpg")
    r,g,b = im.split()
    print(r.mode)
    print(r.size)
    print(im.size)

    #-------------------------------------

    composite方法

    Image.composite(image1,image2, mask) ⇒ image


    复合类使用给定的两张图像及mask图像作为透明度,插值出一张新的图像。变量mask图像的模式可以为“1”,“L”或者“RGBA”。所有图像必须有相同的尺寸。

     

    #-------------------------------------

    from PIL import Image
    im1 = Image.open("3d.jpg")
    im2 = Image.open("3dd.jpg")
    r,g,b = im1.split()             ##分离出r,g,b
    print(b.mode)
    print(im1.mode,im1.size)
    print(im2.mode,im2.size)
    im = Image.composite(im1,im2,b)
    im.show()

    #-------------------------------------

    b.mode为”L”,两图尺寸一致。

     

    eval方法

      Image.eval(image,function) ⇒ image

    使用变量function对应的函数(该函数应该有一个参数)处理变量image所代表图像中的每一个像素点。如果变量image所代表图像有多个通道,那变量function对应的函数作用于每一个通道。注意:变量function对每个像素只处理一次,所以不能使用随机组件和其他生成器。

    #-------------------------------------------------------
    from PIL import Image
    im = Image.open("3d.jpg")
    def fun1(x):
        return x*0.3
    def fun2(y):
        return y*2.0
    im1_eval = Image.eval(im, fun1)
    im2_eval = Image.eval(im, fun2)
    im1_eval.show()
    im2_eval.show()
    #-------------------------------------------------------

     

    merge方法

      Image.merge(mode,bands) ⇒ image
    合并类使用一些单通道图像,创建一个新的图像。变量bands为一个图像的元组或者列表,每个通道的模式由变量mode描述。所有通道必须有相同的尺寸。
    变量mode与变量bands的关系:


      len(ImageMode.getmode(mode).bands)= len(bands)
    #-------------------------------------------------------
    from PIL import Image
    im1 = Image.open("3d.jpg")
    im2 = Image.open("3dd.jpg")
    r1,g1,b1 = im1.split()
    r2,g2,b2 = im2.split()
    print(r1.mode,r1.size,g1.mode,g1.size)
    print(r2.mode,r2.size,g2.mode,g2.size)
    new_im=[r1,g2,b2]
    print(len(new_im))
    im_merge = Image.merge("RGB",new_im)
    im_merge.show()

    #-------------------------------------------------------

     
    merge操作

     

    draft方法

      im.draft(mode,size)

     

    #-------------------------------------------------------
    from PIL import Image
    im = Image.open("3d.jpg")
    print(im.size,im.mode)
    new_im = im.draft("L", (200,200))
    print(new_im.size,new_im.mode)
    new_im.show()

    #-------------------------------------------------------

    关键信息显示
    转换效果

     

    getbands方法


      im.getbands()⇒ tuple of strings


    返回包括每个通道名称的元组。例如,对于RGB图像将返回(“R”,“G”,“B”)。

    #-------------------------------------------------------
    from PIL import Image
    im = Image.open("3d.jpg")
    print(im.getbands())
    #-------------------------------------------------------

     

     

    getbbox方法


      im.getbbox() ⇒ 4-tuple or None


    计算图像非零区域的包围盒。这个包围盒是一个4元组,定义了左、上、右和下像素坐标。如果图像是空的,这个方法将返回空。

     

    #-------------------------------------------------------
    from PIL import Image
    im = Image.open("3d.jpg")
    print(im.getbbox())

    #-------------------------------------------------------

    getdata方法


      im.getdata() ⇒ sequence


    以包含像素值的sequence对象形式返回图像的内容。这个sequence对象是扁平的,以便第一行的值直接跟在第零行的值后面,等等。这个方法返回的sequence对象是PIL内部数据类型,它只支持某些sequence操作,包括迭代和基础sequence访问。使用list(im.getdata()),将它转换为普通的sequence。Sequence对象的每一个元素对应一个像素点的R、G和B三个值。

     

    #-------------------------------------------------------
    from PIL import Image
    im = Image.open("3d.jpg")
    sequ = im.getdata()
    sequ0 = list(sequ)
    print(sequ0[0])
    print(sequ0[1])
    print(sequ0[2])

    #-------------------------------------------------------

     

    getextrema方法


      im.getextrema() ⇒ 2-tuple
    返回一个2元组,包括该图像中的最小和最大值

    #-------------------------------------------------------
    from PIL import Image
    im = Image.open("3d.jpg")
    print(im.getextrema())

    #-------------------------------------------------------

    该方法返回了R/G/B三个通道的最小和最大值的2元组。

    getpixel方法


      im.getpixel(xy) ⇒ value or tuple


    返回给定位置的像素值。如果图像为多通道,则返回一个元组。该方法执行比较慢;如果用户需要使用python处理图像中较大部分数据,可以使用像素访问对象(见load),或者方法getdata()。

    #-------------------------------------------------------
    from PIL import Image
    im = Image.open("3d.jpg")
    print(im.getpixel((0,0)))
    print(im.getpixel((4,0)))
    r,g,b = im.split()
    print(b.getpixel((11,8)))  

    #-------------------------------------------------------

    直方图histogram方法


      im.histogram()⇒ list


    返回一个图像的直方图。这个直方图是关于像素数量的list,图像中的每个象素值对应一个成员。如果图像有多个通道,所有通道的直方图会连接起来(例如,“RGB”图像的直方图有768个值)。二值图像(模式为“1”)当作灰度图像(模式为“L”)处理。

    #-------------------------------------------------------
    from PIL import Image
    im = Image.open("3d.jpg")
    imhis = im.histogram()
    print(len(imhis))
    print(imhis[0])
    print(imhis[150])
    print(imhis[300])

    #-------------------------------------------------------


      im.histogram(mask)⇒ list
    返回图像中模板图像非零地方的直方图。模板图像与处理图像的尺寸必须相同,并且要么是二值图像(模式为“1”),要么为灰度图像(模式为“L”)。

    #-------------------------------------------------------
    from PIL import Image
    im = Image.open("3d.jpg")
    r,g,b = im.split()
    imhis = im.histogram()
    print(r.mode)
    print(len(imhis))
    print(imhis[0])
    print(imhis[150])
    print(imhis[300])

    #-------------------------------------------------------

     

    load方法

    im.load()
    为图像分配内存并从文件中加载它(或者从源图像,对于懒操作)。正常情况下,用户不需要调用这个方法,因为在第一次访问图像时,Image类会自动地加载打开的图像。目前的版本,方法load()返回一个用于读取和修改像素的像素访问对象。这个访问对象像一个二维队列,如:
      pix = im.load()
      print pix[x, y]
      pix[x, y] =value


    通过这个对象访问比方法getpixel()和putpixel()快很多。

    #-------------------------------------------------------
    from PIL import Image
    im = Image.open("3d.jpg")
    pix = im.load()
    print(pix[0,2])

    #-------------------------------------------------------
     im.paste(colour,box)


    使用同一种颜色填充变量box对应的区域。对于单通道图像,变量colour为单个颜色值;对于多通道,则为一个元组。

    #-------------------------------------------------------
    from PIL import Image
    im = Image.open("3d.jpg")
    im.paste((256,256,0),(0,0,100,100))  ##(256,256,0)表示黄色
    im.show()

    #-------------------------------------------------------

    #-------------------------------------------------------
    from PIL import Image
    im = Image.open("3d.jpg")
    im.paste("blue",(0,0,100,100))   ##或者“blue”
    im.show()

    #-------------------------------------------------------


      im.paste(image,box, mask)
    使用变量mask对应的模板图像来填充所对应的区域。可以使用模式为“1”、“L”或者“RGBA”的图像作为模板图像。模板图像的尺寸必须与变量image对应的图像尺寸一致。如果变量mask对应图像的值为255,则模板图像的值直接被拷贝过来;如果变量mask对应图像的值为0,则保持当前图像的原始值。变量mask对应图像的其他值,将对两张图像的值进行透明融合,如果变量image对应的为“RGBA”图像,即粘贴的图像模式为“RGBA”,则alpha通道被忽略。用户可以使用同样的图像作为原图像和模板图像。

    #-------------------------------------------------------
    from PIL import Image
    im = Image.open("3d.jpg")
    box=[300,300,400,400]
    im_crop =im.crop(box)
    r,g,b =im_crop.split()
    im.paste(im_crop, (200,200,300,300), r)
    im.show()

    #-------------------------------------------------------

    putdata方法

      im.putdata(data)
      im.putdata(data, scale, offset)
    从sequence对象中拷贝数据到当前图像,从图像的左上角(0,0)位置开始。变量scale和offset用来调整sequence中的值:
      pixel = value*scale + offset
    如果变量scale忽略,则默认为1.0。如果变量offset忽略,则默认为0.0。

    #-------------------------------------------------------
    from PIL import Image
    im = Image.open("3d.jpg")
    r, g, b = im.split()
    print(r.getpixel((0, 0)),r.getpixel((1, 0)),r.getpixel((2, 0)),r.getpixel((3, 0)),r.putdata([1, 2, 3, 4]),r.getpixel((0, 0)),r.getpixel((1, 0)),r.getpixel((2, 0)),r.getpixel((3, 0)),
    #-------------------------------------------------------

    resize方法

      im.resize(size) ⇒ image
      im.resize(size, filter) ⇒ image
    返回改变尺寸的图像的拷贝。变量size是所要求的尺寸,是一个二元组:(width, height)。变量filter为NEAREST、BILINEAR、BICUBIC或者ANTIALIAS之一。如果忽略,或者图像模式为“1”或者“P”,该变量设置为NEAREST。在当前的版本中bilinear和bicubic滤波器不能很好地适应大比例的下采样(例如生成缩略图)。用户需要使用ANTIALIAS,除非速度比质量更重要。

    #-------------------------------------------------------
    from PIL import Image
    im = Image.open("3d.jpg")
    region = im.resize((400, 400))     ##重新设定大小
    region.show()

    #-------------------------------------------------------
    rotate方法

      im.rotate(angle) ⇒ image
      im.rotate(angle,filter=NEAREST, expand=0) ⇒ image


    返回一个按照给定角度顺时钟围绕图像中心旋转后的图像拷贝。变量filter是NEAREST、BILINEAR或者BICUBIC之一。如果省略该变量,或者图像模式为“1”或者“P”,则默认为NEAREST。变量expand,如果为true,表示输出图像足够大,可以装载旋转后的图像。如果为false或者缺省,则输出图像与输入图像尺寸一样大。

    #-------------------------------------------------------
    from PIL import Image
    im = Image.open("3d.jpg")
    im_45 = im.rotate(45)
    im_30 = im.rotate(30, Image.NEAREST,1)
    print(im_45.size,im_30.size)
    im_45.show()
    im_30.show()

    #-------------------------------------------------------

    seek方法

      im.seek(frame)
    在给定的文件序列中查找指定的帧。如果查找超越了序列的末尾,则产生一个EOFError异常。当文件序列被打开时,PIL库自动指定到第0帧上。

    #-------------------------------------------------------
    from PIL import Image
    im_gif = Image.open("miaomiao.gif")
    print(im_gif.mode)
    im_gif.show()    ##第0帧
    im_gif.seek(1)
    im_gif.show()
    im_gif.seek(3)
    im_gif.show()

    #-------------------------------------------------------

     

    tell方法

      im.tell() ⇒ integer


    返回当前帧所处位置,从0开始计算。

    #-------------------------------------------------------
    from PIL import Image
    im_gif = Image.open("3d.gif")
    print(im_gif.tell())
    im_gif.seek(8)
    print(im_gif.tell())

    #-------------------------------------------------------

    thumbnail方法

      im.thumbnail(size)
      im.thumbnail(size, filter)
    修改当前图像,使其包含一个自身的缩略图,该缩略图尺寸不大于给定的尺寸。该方法计算一个合适的缩略图尺寸,使其符合当前图像的宽高比,调用方法draft()配置文件读取器,最后改变图像的尺寸。变量filter应该是NEAREST、BILINEAR、BICUBIC或者ANTIALIAS之一。如果省略该变量,则默认为NEAREST。注意:在当前PIL的版本中,滤波器bilinear和bicubic不能很好地适应缩略图产生。用户应该使用ANTIALIAS,图像质量最好。如果处理速度比图像质量更重要,可以选用其他滤波器。这个方法在原图上进行修改。如果用户不想修改原图,可以使用方法copy()拷贝一个图像。这个方法返回空。

    #-------------------------------------------------------
    from PIL import Image
    im = Image.open("3d.jpg")
    im.thumbnail((100,100))

    #-------------------------------------------------------

     

    transform方法
      im.transform(size,method, data) ⇒ image
      im.transform(size, method, data, filter) ⇒ image


    用给定的尺寸生成一张新的图像,与原图有相同的模式,使用给定的转换方式将原图数据拷贝到新的图像中。在当前的PIL版本中,参数method为EXTENT(裁剪出一个矩形区域),AFFINE(仿射变换),QUAD(将正方形转换为矩形),MESH(一个操作映射多个正方形)或者PERSPECTIVE。变量filter定义了对原始图像中像素的滤波器。在当前的版本中,变量filter为NEAREST、BILINEAR、BICUBIC或者ANTIALIAS之一。如果忽略,或者图像模式为“1”或者“P”,该变量设置为NEAREST。

    #-------------------------------------------------------
    from PIL import Image
    im = Image.open("3d.jpg")
    print(im.size)
    imtra = im.transform((200, 200), Image.EXTENT, (0, 0, 300, 300))
    print(imtra.size)
    imtra.show()

    #-------------------------------------------------------


      im.transform(size,EXTENT, data) ⇒ image
      im.transform(size, EXTENT, data, filter) ⇒ image


    从图像中裁剪一个区域。变量data为指定输入图像中两个坐标点的4元组(x0,y0,x1,y1)。输出图像为这两个坐标点之间像素的采样结果。例如,如果输入图像的(x0,y0)为输出图像的(0,0)点,(x1,y1)则与变量size一样。这个方法可以用于在当前图像中裁剪,放大,缩小或者镜像一个任意的长方形。它比方法crop()稍慢,但是与resize操作一样快。


      im.transform(size, AFFINE, data) ⇒ image
      im.transform(size, AFFINE,data, filter) ⇒ image


    对当前的图像进行仿射变换,变换结果体现在给定尺寸的新图像中。变量data是一个6元组(a,b,c,d,e,f),包含一个仿射变换矩阵的第一个两行。输出图像中的每一个像素(x,y),新值由输入图像的位置(ax+by+c, dx+ey+f)的像素产生,使用最接近的像素进行近似。这个方法用于原始图像的缩放、转换、旋转和裁剪。

    #-------------------------------------------------------
    from PIL import Image
    im = Image.open("3d.jpg")
    print(im.size)
    imtra = im.transform((200, 200), Image.AFFINE, (1,2,3,2,1,4))
    print(imtra.size)
    imtra.show()

    #-------------------------------------------------------

      im.transform(size,QUAD, data) ⇒ image
      im.transform(size, QUAD, data, filter) ⇒ image


    输入图像的一个四边形(通过四个角定义的区域)映射到给定尺寸的长方形。变量data是一个8元组(x0,y0,x1,y1,x2,y2,x3,y3),它包括源四边形的左上,左下,右下和右上四个角。

    #----------------------------------------------------------
    from PIL import Image
    im = Image.open("3d.jpg")
    print(im.size)
    imtra = im.transform((200, 200), Image.QUAD, (0,0,0,500,600,500,600,0))
    print(imtra.size)
    imtra.show()

     

      im.transform(size,PERSPECTIVE, data) ⇒ image
      im.transform(size, PERSPECTIVE, data, filter) ⇒ image


    对当前图像进行透视变换,产生给定尺寸的新图像。变量data是一个8元组(a,b,c,d,e,f,g,h),包括一个透视变换的系数。对于输出图像中的每个像素点,新的值来自于输入图像的位置的(a x + b y + c)/(g x + h y + 1), (d x+ e y + f)/(g x + h y + 1)像素,使用最接近的像素进行近似。这个方法用于原始图像的2D透视。

    #-----------------------------------------------------------------------
    from PIL import Image
    im = Image.open("3d.jpg")
    print(im.size)
    imtra = im.transform((200, 200), Image.PERSPECTIVE, (1,2,3,2,1,6,1,2))
    print(imtra.size)
    imtra.show()

    transpose方法

      im.transpose(method)⇒ image
    返回当前图像的翻转或者旋转的拷贝。变量方法的取值为:FLIP_LEFT_RIGHT,FLIP_TOP_BOTTOM,ROTATE_90,ROTATE_180,或ROTATE_270。

    #---------------------------------------------------------------------------
    from PIL import Image
    im = Image.open("3d.jpg")
    im.show()
    im1=im.rotate(45)
    im1.show()                            #逆时针旋转 45 度角。
    im2=im.transpose(Image.FLIP_LEFT_RIGHT)       #左右对换
    im2.show()
    im3=im.transpose(Image.FLIP_TOP_BOTTOM)       #上下对换。
    im3.show()
    im4=im.transpose(Image.ROTATE_90)             #旋转 90 度角。
    im4.show()
    im5=im.transpose(Image.ROTATE_180)            #旋转 180 度角。
    im5.show()
    im6=im.transpose(Image.ROTATE_270)            #旋转 270 度角。
    im6.show()           
    #------------------------------------------------------------------------------

          

    展开全文
  • image

    2019-03-12 13:14:36
  • WPF打开图片文件放入image

    热门讨论 2020-07-28 23:33:20
    简单的浏览图片并放入image中。。新手合适~
  • Pygame详解(六):image 模块

    千次阅读 2019-01-11 16:02:41
    pygame.image 用于图像传输的 Pygame 模块。 函数 pygame.image.load() — 从文件加载新图片 pygame.image.save() — 将图像保存到磁盘上 pygame.image.get_extended() — 检测是否支持载入扩展的图像...

    pygame.image

    用于图像传输的 Pygame 模块。

    函数

    • pygame.image.load()  —  从文件加载新图片
    • pygame.image.save()  —  将图像保存到磁盘上
    • pygame.image.get_extended()  —  检测是否支持载入扩展的图像格式
    • pygame.image.tostring()  —  将图像转换为字符串描述
    • pygame.image.fromstring()  —  将字符串描述转换为图像
    • pygame.image.frombuffer()  —  创建一个与字符串描述共享数据的 Surface 对象

    image 模块包含了加载和保存图像的函数,同时转换为 Surface 对象支持的格式。

    注意:没有 Image 类;当一个图像被成功载入后,将转换为 Surface  对象。Surface  对象允许你在上边画线、设置像素、捕获区域等。

    Image 是 Pygame 相当依赖的一个模块,支持载入的图像格式如下:

    • JPG
    • PNG
    • GIF(无动画)
    • BMP
    • PCX
    • TGA(无压缩)
    • TIF
    • LBM(和 PBM)
    • PBM(和 PGM,PPM)
    • XPM

    支持保存为以下格式:

    • BMP
    • TGA
    • PNG
    • JPEG

    其中,保存为 PNG 和 JPEG 格式是 Pygame 1.8 新增加的。

    函数详解

    pygame.image.load()

    从文件加载新图片。

    load(filename) -> Surface

    load(fileobj, namehint=””) -> Surface

    从文件加载一张图片,你可以传递一个文件路径或一个 Python 的文件对象。

    Pygame 将自动判断图像的格式(比如 GIF 或位图)并创建一个新的 Surface  对象。有时它可能需要知道文件的后缀名(比如 GIF 图像应该以 ".gif" 为后缀)。如果你传入原始文件对象,你需要传入它对应的文件名到 namehint 参数中。

    返回的 Surface  对象将包含与源文件相同的颜色格式,colorkey 和 alpha 透明度通道。你通常需要调用 Surface.convert() 函数进行转换,这样可以使得在屏幕上绘制的速度更快。

    对于含有 alpha 通道的图片(支持部分位置透明,像 PNG 图像),需要使用 Surface.convert_alpha() 函数进行转换。

    在某些环境下,Pygame 可能无法支持上述所有的图像格式,但至少无压缩的 BMP 格式是支持的。你可以调用 pygame.image.get_extended() 函数,如果返回 True,说明可以加载上述的格式(包含 PNG,JPG 和 GIF)。

    你应该使用 os.path.join() 提高代码的兼容性:

    asurf = pygame.image.load(os.path.join('data', 'Python.png'))

    pygame.image.save()

    将图像保存到磁盘上。

    save(Surface, filename) -> None

    该函数将保存 Surface  对象到磁盘上,支持存储为 BMP,TGA,PNG 或 JPEG 格式的图像。如果 filename 没有指定后缀名,那么默认是保存为 TGA 格式。TGA 和 BMP 格式是无压缩的文件。

    保存为 PNG 和 JPEG 格式是 Pygame 1.8 新增的。

    pygame.image.get_extended()

    检测是否支持载入扩展的图像格式。

    get_extended() -> bool

    如果 Pygame 支持上述所有的扩展图像格式,则返回 True。

    pygame.image.tostring()

    将图像转换为字符串描述。

    tostring(Surface, format, flipped=False) -> string

    将图像转换为一个字符串描述,可以被 Python 的其他图像模块通过 "fromstring" 转换回图像。一些 Python 图像模块喜欢“自下而上”的存储格式(例如 PyOpenGL)。如果 flipped 参数为 True,那么字符串将会垂直翻转以适用这类图像模块。

    format 参数可以是下表中任何一个字符串。注意:只有 8 位的 Surface  对象可以使用 "P" 格式。其他格式可以用于任何 Surface  对象上。

    字符串

    含义

    P 8 位调色板的 Surface  对象
    RGB 24 位图像
    RGBX 32 位图像,不留空白
    RGBA 32 位图像,带 alpha 通道
    ARGB 32 位图像,带 alpha 通道,并将 alpha 放在前边
    RGBA_PREMULT 32 位图像,通过 alpha 通道缩放
    ARGB_PREMULT 32 位图像,通过 alpha 通道缩放,并将 alpha 放在前边

    pygame.image.fromstring()

    将字符串描述转换为图像。

    fromstring(string, size, format, flipped=False) -> Surface

    该函数的使用跟 pygame.image.tostring() 相似。size 参数是一对表示宽度和高度的数字。一旦新的 Surface 对象创建成功,你就可以删除字符串描述。

    size 和 format 参数指定的数据需要跟字符串描述相符,否则将抛出异常。

    更快地将图片转换到 Pygame,请参考 pygame.image.frombuffer() 函数。

    pygame.image.frombuffer()

    创建一个与字符串描述共享数据的 Surface 对象。

    frombuffer(string, size, format) -> Surface

    创建一个新的 Surface 对象,与字符串描述直接共享像素数据。该函数的使用跟 pygame.image.fromstring() 类似,但没法垂直翻转原始数据。

    该函数的速度会比 pygame.image.fromstring() 快很多,因为该函数不需要申请和拷贝任何像素数据。

    展开全文
  • 浅析image,imagesc,imshow的用法

    万次阅读 多人点赞 2014-11-07 15:35:02
    区别:imshow将图像以原始尺寸显示,image和imagesc则会对图像进行适当 的缩放,注意这里只是图像显示的尺寸。 2、显示灰度图像 说明:先搞明白什么是索引图像?(灰度图像也是索引图像的一种)  当用Matlab中的...
  • Image uImage与zImage的区别

    千次阅读 2018-09-11 09:50:30
    (1)、内核编译(make)之后会生成两个文件,一个Image,一个zImage,其中Image为内核映像文件,而zImage为内核的一种映像压缩文件,Image大约为4M,而zImage不到2M。 那么uImage又是什么的?它是uboot专用的映像...
  • image.shape[0],image.shape[1],image.shape[2]

    万次阅读 2018-06-09 11:33:15
    import cv2image=cv2.imread("D:/shape.bmp")print(image.shape[0])print(image.shape[1])print(image.shape[2])结果3002003其中shape.bmp是一张水平200像素,垂直300像素的彩色图
  • (二十九)Image和Raw Image的区别

    万次阅读 2018-04-25 20:12:40
    RawImage核心代码比Image少很多,Raw Image不支持交互,可用于显示任何图片而不仅仅是Sprite,一般用在背景、图标上,支持UV Rect(用来设置只显示图片的某一部分),而Image不支持UV Rect...
  • numpy与Image互转

    万次阅读 2018-05-07 09:48:09
    from PIL import Image import numpy as np im = Image.open("/home/lw/a.jpg") im.show() img = np.array(im) # image类 转 numpy img = img[:,:,0] #第1通道 im=Image.fromarray(img) # numpy 转 ...
  • python提示ImportError: No module named Image

    万次阅读 2018-03-02 16:06:39
    把import Image替换成"import PIL.Image",凡是用到Image的都修改成PIL.Image(前提你的安装pillow(PIL))
  • Unity UGUI——ImageImage Type)

    万次阅读 2015-03-18 09:14:15
    Simple、Sliced、Tiled、Filled、Set Native Size
  • Python3.4加载第三方库PIL的使用

    万次阅读 2015-05-13 18:10:08
    Python3.4加载第三方库PIL的使用 一、安装PIL库 方式1:利用python自带的pip安装或easy_instal安装。  在cmd 直接输入pip install PIL 方式2:下载zip或tar等压缩格式后手动安装。 后缀名改为zip解压,然后把你需要...
  • this.pictureBox2.Image=Image.FromFile("D:\\001.jpg"); 2.相对路径: Application.StartupPath;  可以得到程序根目录  this.pictureBox2.Image=Image.FromFile(Application.StartupPath "\\1.gif"); ...
  • mkyaffs2image的用法

    万次阅读 2012-01-06 18:03:43
    在Ubuntu中第一次使用mkyaffs2image命令时,会提示 mkyaffs2image:找不到命令 还需要安装mkyaffs2image http://code.google.com/p/fatplus/downloads/detail?name=yaffs2-source.tar&can=2&q= 下载yaffs2-...
  • C# 图像处理:Bitmap 与 Image 之间的转换

    万次阅读 多人点赞 2016-09-08 11:36:19
    C# 图像处理:Bitmap 与 Image 之间的转换 Image img = this.pictureBox1.Image; Bitmap map = new Bitmap(img); Bitmap map = new Bitmap(img); Image img=map; mage和Bitmap类概述 GDI+的Image类封装了对BMP...
  • background-image(自适应宽高)

    万次阅读 2018-10-01 21:46:40
    \  .zoomImage {  background-image:url(images/yuantiao.jpg);  background-repeat:no-repeat;  background-size:100% 100%;  -moz-b...
  • 微信文件夹下imageimage2是微信表情图片的缓存文件夹,emoji是表情,然后还有很多个类似1a,1b,1c为这样的文件夹,每个文件夹下面也有很多这样的文件夹。 这两个目录里自动保存了微信聊天记录中的表情图片、微信...
  • ImageJ的安装与简单使用

    万次阅读 2017-04-20 17:35:30
    ImageJ在Windows下的安装与使用
  • PIL.Image.open()与open() python

    万次阅读 2019-06-19 12:18:08
    PIL.Image.open()专接图片路径,用来直接读取该路径指向的图片。要求路径必须指明到哪张图,不能只是所有图所在的文件夹; open()接路径,常附带r、w、a等,表明需要对该路径读取的文件的操作。 ...
1 2 3 4 5 ... 20
收藏数 1,536,853
精华内容 614,741
关键字:

image