Python: PIL基本代码

太过爱你忘了你带给我的痛 2022-12-26 11:18 103阅读 0赞

## Python: PIL基本代码 ##

# 声明使用字符库
    # -*- coding: utf-8 -*-
    # 导入系统库
    import os
    # 导入文件读写库
    import io
    # 导入数学库
    import math
    # 导入 PIL 图像库（The Image Module）
    from PIL import Image
    # 导入 PIL 图像通道运算库（The ImageChops Module）
    from PIL import ImageChops
    # 导入 PIL 图像绘制库（The ImageDraw Module）
    from PIL import ImageDraw
    # 导入 PIL 图像增强库（The ImageEnhance Module）
    from PIL import ImageEnhance
    # 导入 PIL 图像滤波库（The ImageFilter Module）
    from PIL import ImageFilter
    # 导入 PIL 图像截屏库（The ImageGrab Module）
    from PIL import ImageGrab
    # 导入 PIL 图像运算库（The ImageOps Module）
    from PIL import ImageOps
    # 导入 PIL 图像统计库（The ImageStat Module）
    from PIL import ImageStat
    # 导入 PIL 图像字符库
    from PIL import ImageFont
    # 导入 Matplotlib 库
    from pylab import *
    # 导入 NumPy 库
    from numpy import *
    # 保持命名空间
    # 导入 NumPy 库
    import numpy as np
    # 导入 Matplotlib 库
    import matplotlib.pyplot as plt
    
    # 显示数据
    print("PI=%10.3f;" % math.pi)
    print("PI=%06d;" % int(math.pi))
    
    # 直接读取Color图像
    PilImg_Color = Image.open('empire.jpg')
    # PilImg_Color.show()
    print("格式:", PilImg_Color.format, "    大小:", PilImg_Color.size,
          "    模式:", PilImg_Color.mode)
    
    # 根据字符串名称读取Color图像
    NameString = io.StringIO()
    NameString.write('empire.jpg')
    print(NameString.getvalue())
    PilImg_String = Image.open(NameString.getvalue())
    # PilImg_String.show()
    
    # 将Color图像转换为Bin图像
    PilImg_Bin = PilImg_Color.convert('1')
    # PilImg_Bin.show()
    
    # 将Color图像转换为Gray图像
    PilImg_Gray = PilImg_Color.convert('L')
    # PilImg_Gray.show()
    
    # 将Color图像转换为Color Palette图像
    PilImg_Palette = PilImg_Color.convert('P')
    # PilImg_Palette.show()
    
    # 将Color图像转换为RGB图像
    PilImg_RGB = PilImg_Color.convert('RGB')
    # PilImg_RGB.show()
    
    # 将Color图像转换为RGBA图像
    PilImg_RGBA = PilImg_Color.convert('RGBA')
    # PilImg_RGBA.show()
    
    # 将Color图像转换为CMYK图像
    PilImg_CMYK = PilImg_Color.convert('CMYK')
    # PilImg_CMYK.show()
    
    # 将Color图像转换为YCbCr图像
    PilImg_YCbCr = PilImg_Color.convert('YCbCr')
    # PilImg_YCbCr.show()
    
    # 将Color图像转换为I图像
    PilImg_I = PilImg_Color.convert('I')
    # PilImg_I.show()
    
    # 将Color图像转换为F图像
    PilImg_F = PilImg_Color.convert('F')
    # PilImg_F.show()
    
    '''
    # 从文件名列表(filelist)中读取所有的图像文件，并转换成JPEG格式
    from PIL import Image
    import os
    for infile in filelist:
    outfile = os.path.splitext(infile)[0] + ".jpg"
    if infile != outfile:
    try:
    Image.open(infile).save(outfile)
    except IOError:
    print "cannot convert", infile
    '''
    
    '''
    # 创建一个包含文件夹中所有图像文件的文件名列表。
    # 首先新建一个文件，命名为 imtools.py，来存储一些经常使用的图像操作，
    # 然后将下面的函数添加进去
    import os
    def get_imlist(path):
    """ 返回目录中所有 JPG 图像的文件名列表 """
    return [os.path.join(path,f) for f in os.listdir(path) if f.endswith('.jpg')]
    '''
    
    """
    The Image Module
    """
    # 创建新图像（new）
    # 1.Image.new(mode, size) ⇒ image
    # 2.Image.new(mode, size, color) ⇒ image
    Mode_NewImg = "RGB"
    Width_NewImg = 800
    Height_NewImg = 640
    Color_NewImg = "#78b8e7"
    PilImg_Color_New = Image.new(Mode_NewImg, (Width_NewImg, Height_NewImg),
                                 Color_NewImg)
    # PilImg_Color_New.show()
    
    # 融合图像（blend）
    # Image.blend(image1, image2, alpha) ⇒ image
    PilImg_Blend1 = Image.open('融合1.jpg')
    PilImg_Blend2 = Image.open('融合2.jpg')
    BlendAlpha = 0.20
    PilImg_Blend = Image.blend(PilImg_Blend1, PilImg_Blend2, BlendAlpha)
    # PilImg_Blend.show()
    
    # 复合图像（composite）
    # Image.composite(image1, image2, mask) ⇒ image
    PilImg_Composite = Image.open('融合1.jpg')
    PilImg_Composite1 = PilImg_Composite.convert('RGB')
    PilImg_Composite = Image.open('融合2.jpg')
    PilImg_Composite2 = PilImg_Composite.convert('RGB')
    PilImg_Composite = PilImg_Color_New.copy()
    PilImg_Composite3 = PilImg_Composite.convert('1')  # "1"、"L"、"RGBA"
    PilImg_Composite = Image.composite(PilImg_Composite1,
                                       PilImg_Composite2, PilImg_Composite3)
    # PilImg_Composite.show()
    
    # eval
    # Image.eval(image, function) ⇒ image
    
    # frombuffer
    # Image.frombuffer(mode, size, data) ⇒ image
    # 仅支持“L”, “RGBX”, “RGBA”, and “CMYK”
    # im = Image.frombuffer(mode, size, data, "raw", mode, 0, 1)
    
    # fromstring
    # Image.fromstring(mode, size, data) ⇒ image
    
    # 合并图像（merge）
    # Image.merge(mode, bands) ⇒ image
    # PilImg_Merge1 = Image.open('融合1.jpg')
    # PilImg_Merge2 = Image.open('融合2.jpg')
    # PilImg_Merge = Image.blend(PilImg_Merge1, PilImg_Merge2)
    # PilImg_Merge.show()
    
    # 转换图像（convert）
    # im.convert(mode) ⇒ image
    PilImg_Convert1 = Image.open('图像4.jpg')
    # PilImg_Convert1 = PilImg_Convert1.convert("RGBA")   # "1"\"L"\"RGB"\"RGBA"
    # PilImg_Convert1.show()
    # dither = "FLOYDSTEINBERG"
    PilImg_Convert2 = PilImg_Convert1.convert("P", dither=Image.FLOYDSTEINBERG,
                                              palette=Image.WEB, colors=5)
    # PilImg_Convert2.show()
    
    rgb2xyz = (
        0.412453, 0.357580, 0.180423, 0,
        0.212671, 0.715160, 0.072169, 0,
        0.019334, 0.119193, 0.950227, 0)
    PilImg_Convert3 = PilImg_Convert1.convert("RGB", rgb2xyz)
    # PilImg_Convert3.show()
    
    # 复制图像（copy）
    PilImg_Color_Copy = PilImg_Color.copy()
    PilImg_Gray_Copy = PilImg_Gray.copy()
    
    # 裁切图像（crop）
    Region = (100, 100, 400, 400)
    PilImg_Crop = PilImg_Color.crop(Region)
    # PilImg_Crop.show()
    
    # 草稿（draft）
    # im.draft(mode, size)
    PilImg_Draft = Image.open('图像4.jpg')
    PilImg_Draft.draft(mode='L', size=(120, 100))  # "L"\"RGB"\"RGBA"
    # PilImg_Draft.show()
    
    # 图像滤波（filter）
    # im.filter(filter) ⇒ image
    PilImg_Filter1 = Image.open('图像4.jpg')
    # PilImg_Filter = PilImg_Filter1.filter(ImageFilter.BLUR)
    # PilImg_Filter = PilImg_Filter1.filter(ImageFilter.CONTOUR)
    # PilImg_Filter = PilImg_Filter1.filter(ImageFilter.DETAIL)
    # PilImg_Filter = PilImg_Filter1.filter(ImageFilter.EDGE_ENHANCE)
    # PilImg_Filter = PilImg_Filter1.filter(ImageFilter.EDGE_ENHANCE_MORE)
    # PilImg_Filter = PilImg_Filter1.filter(ImageFilter.EMBOSS)
    # PilImg_Filter = PilImg_Filter1.filter(ImageFilter.FIND_EDGES)
    # PilImg_Filter = PilImg_Filter1.filter(ImageFilter.GaussianBlur)
    # PilImg_Filter = PilImg_Filter1.filter(ImageFilter.MaxFilter(3))
    # PilImg_Filter = PilImg_Filter1.filter(ImageFilter.MedianFilter(15))
    # PilImg_Filter = PilImg_Filter1.filter(ImageFilter.MinFilter(3))
    # PilImg_Filter = PilImg_Filter1.filter(ImageFilter.ModeFilter(5))
    # PilImg_Filter = PilImg_Filter1.filter(ImageFilter.RankFilter)
    # PilImg_Filter = PilImg_Filter1.filter(ImageFilter.SHARPEN)
    # PilImg_Filter = PilImg_Filter1.filter(ImageFilter.SMOOTH)
    # PilImg_Filter = PilImg_Filter1.filter(ImageFilter.SMOOTH_MORE)
    PilImg_Filter = PilImg_Filter1.filter(ImageFilter.UnsharpMask)
    # PilImg_Filter.show()
    
    # 获得通道名称（getbands）
    # im.getbands() ⇒ tuple of strings
    PilImg_Getbands1 = Image.open('图像4.jpg')
    PilImg_Getbands2 = PilImg_Getbands1.convert('RGBA')
    PilImg_Getbands = PilImg_Getbands2.getbands()
    print("通道名称:", PilImg_Getbands)
    
    # 获得图像大小（getbbox）
    # im.getbbox() ⇒ 4-tuple or None
    PilImg_Getbbox1 = Image.open('图像4.jpg')
    PilImg_Getbbox = PilImg_Getbbox1.getbbox()
    print("图像大小:", PilImg_Getbbox)
    
    # 获得一个未排序列表，其元素是元组（count, color）（getcolors）
    # im.getcolors() ⇒ a list of (count, color) tuples or None
    # im.getcolors(maxcolors) ⇒ a list of (count, color) tuples or None
    PilImg_Getcolors1 = Image.open('图像4.jpg')
    PilImg_Getcolors = PilImg_Getcolors1.getcolors()
    # print("图像颜色:", PilImg_Getcolors.color)
    
    # 以序列方式返回图像内容（getdata）
    # im.getdata() ⇒ sequence
    Image_Size = (6, 6)
    PilImg_Getdata1 = Image.open('图像4.jpg')
    PilImg_Getdata2 = PilImg_Getdata1.resize(Image_Size)
    PilImg_Getdata = PilImg_Getdata2.getdata()
    print("图像数据:", list(PilImg_Getdata))
    
    # 获得图像最小值和最大值的二元数组（getextrema）
    # im.getextrema() ⇒ 2-tuple
    PilImg_Getextrema1 = Image.open('图像4.jpg').convert('L')
    PilImg_Getextrema = PilImg_Getextrema1.getextrema()
    print("图像最小值和最大值:", PilImg_Getextrema)
    
    # 返回给定位置的像素值（getpixel）
    # im.getpixel(xy) ⇒ value or tuple
    PilImg_Getpixel1 = Image.open('图像4.jpg')
    PilImg_Getpixel = PilImg_Getpixel1.getpixel((150, 150))
    print("像素值:", PilImg_Getpixel)
    
    # 计算图像直方图（histogram）
    # im.histogram() ⇒ list
    PilImg_Histogram1 = Image.open('图像4.jpg').convert('L')
    PilImg_Histogram = PilImg_Histogram1.histogram()
    print("图像直方图:", list(PilImg_Histogram))
    
    # 为图像分配内存并从文件中加载（load）
    # pix = Image.load('图像4.jpg')
    # print(pix[100, 100])
    # pix[100, 100] = (100, 200, 150)
    
    # 将图像粘贴到另一张图像上（paste）
    # im.paste(image, box)
    PilImg_Paste1 = Image.open('图像6.jpg')
    PilImg_Paste = Image.open('图像1.jpg')
    PilImg_Paste.paste(PilImg_Paste1, (100, 100))
    Region = (600, 600, 1112, 1112)
    PilImg_Paste2 = PilImg_Paste1.resize((1112 - 600, 1112 - 600))
    PilImg_Paste.paste(PilImg_Paste2, Region)
    # PilImg_Paste.show()
    
    # 根据查找表进行映射每个像素，然后返回一个图像的副本（point）
    # im.point(table) ⇒ image
    # im.point(function) ⇒ image
    # im.point(table, mode) ⇒ image
    # im.point(function, mode) ⇒ image
    
    # 拷贝给定通道图像到当前图像的alpha层（putalpha）
    # im.putalpha(band)
    PilImg_Putalpha1 = Image.open('图像4.jpg').convert('L')
    PilImg_Putalpha = Image.open('图像5.jpg')
    PilImg_Putalpha.putalpha(PilImg_Putalpha1)
    # PilImg_Putalpha.show()
    
    # 从序列对象拷贝像素值到图像（putdata）
    # im.putdata(data)
    # im.putdata(data, scale, offset)
    
    # 把一个调色板附加到"P"或"L"模式的图像（putpalette）
    # im.putpalette(sequence)
    
    # 将“L”或“RGB”图像转换成带有给定颜色的“P”图像，并返回新图像（quantize）
    # im.quantize(colors, **options) ⇒ image
    PilImg_Quantize1 = Image.open('图像5.jpg')
    PilImg_Quantize = PilImg_Quantize1.convert("P", palette=Image.ADAPTIVE,
                                               colors=256)
    # PilImg_Quantize.show()
    
    # 调整图像大小（resize）
    # im.resize(size) ⇒ image
    # im.resize(size, filter) ⇒ image
    PilImg_Resize1 = Image.open('图像5.jpg')
    PilImg_Resize1 = PilImg_Resize1.resize((256, 256))
    # filter="NEAREST"\"BILINEAR"\"BICUBIC"\"ANTIALIAS"
    PilImg_Resize2 = PilImg_Resize1.resize((256, 256), Image.NEAREST)
    # PilImg_Resize2.show()
    
    # 按给定的角度顺时针旋转图像（rotate）
    # im.rotate(angle) ⇒ image
    # im.rotate(angle, filter=NEAREST, expand=0) ⇒ image
    PilImg_Rotate1 = Image.open('图像5.jpg')
    PilImg_Rotate2 = PilImg_Rotate1.rotate(30)
    # filter="NEAREST"\"BILINEAR"\"BICUBIC"
    PilImg_Rotate3 = PilImg_Rotate1.rotate(30, Image.BICUBIC, 1)
    # PilImg_Rotate3.show()
    
    # 保存图像（save）
    # im.save(outfile, options…)
    # im.save(outfile, format, options…)
    
    # 在一个序列文件中寻找指定的帧，seek超过了序列结尾时产生EOFError异常。
    # im.seek(frame)
    
    # 显示一幅图像（show）
    # im.show()
    
    # 分离图像（split）
    PilImg_Split = Image.open('图像6.jpg')
    R, G, B = PilImg_Split.split()
    # B.show()
    PilImg_Merge = Image.merge("RGB", (B, G, R))
    # PilImg_Merge.show()
    
    # 获得当前帧数（tell）
    # im.tell() ⇒ integer
    
    # 创建缩略图
    # im.thumbnail(size)
    # im.thumbnail(size, filter)
    # filter="NEAREST"\"BILINEAR"\"BICUBIC"\"ANTIALIAS"
    PilImg_Thumbnail = Image.open('图像6.jpg')
    PilImg_Thumbnail.thumbnail((512, 512))
    PilImg_Thumbnail.thumbnail((256, 256), Image.ANTIALIAS)
    # PilImg_Thumbnail.show()
    
    # 返回被转换成X11位图的图像（）
    # im.tobitmap() ⇒ bitmap
    PilImg_Tobitmapl = Image.open('图像6.bmp').resize((32, 32)).convert('1')
    PilImg_Tobitmap = PilImg_Tobitmapl.tobitmap()
    print(PilImg_Tobitmap)
    
    # 使用标准的“原始”编码器返回一个包含像素数据的字符串（tobytes）
    # im.tobytes() ⇒ string
    # im.tobytes(encoder, parameters) ⇒ string
    PilImg_Tobytes1 = Image.open('图像6.bmp').resize((32, 32)).convert('1')
    PilImg_Tobytes = PilImg_Tobytes1.tobytes()
    print(PilImg_Tobytes)
    
    # 变换图像
    # im.transform(size, method, data) ⇒ image
    # im.transform(size, method, data, filter) ⇒ image
    # filter="NEAREST"\"BILINEAR"\"BICUBIC"
    PilImg_Transform1 = Image.open('图像6.jpg')
    # im.transform(size, EXTENT, data) ⇒ image
    # im.transform(size, EXTENT, data, filter) ⇒ image
    PilImg_Transform1 = PilImg_Transform1.transform(
        (512, 512), Image.EXTENT, (100, 100, 800, 800), Image.BICUBIC)
    # im.transform(size, AFFINE, data) ⇒ image
    # im.transform(size, AFFINE, data, filter) ⇒ image
    # (a x + b y + c, d x + e y + f)
    PilImg_Transform2 = PilImg_Transform1.transform(
        (512, 512), Image.AFFINE,
        (0.15, 0.25, 25, 0.10, 0.20, 30), Image.BICUBIC)
    # im.transform(size, QUAD, data) ⇒ image
    # im.transform(size, QUAD, data, filter) ⇒ image
    # (x0, y0, x1, y1, x2, y2, y3, y3)
    PilImg_Transform3 = PilImg_Transform1.transform(
        (512, 512), Image.QUAD,
        (10, 10, 640, 10, 700, 800, 800, 800), Image.BICUBIC)
    # im.transform(size, MESH, data) image ⇒ image
    # im.transform(size, MESH, data, filter) image ⇒ image
    # PilImg_Transform = PilImg_Transform1.convert('F').transform(
    #        (512, 512), Image.MESH,
    #        (10, 10, 640, 10, 700, 800, 800, 800), Image.BICUBIC)
    # im.transform(size, PERSPECTIVE, data) image ⇒ image
    # im.transform(size, PERSPECTIVE, data, filter) image ⇒ image
    PilImg_Transform4 = PilImg_Transform1.transform(
        (512, 512), Image.PERSPECTIVE,
        (0.05, 0.05, 200, 0.10, 0.05, 400, 0.05, 0.05),
        Image.BICUBIC)
    # PilImg_Transform4.show()
    
    # 转置图像（transpose）
    # im.transpose(method) ⇒ image
    PilImg_Transpose1 = Image.open('图像6.jpg')
    # "FLIP_LEFT_RIGHT"\"FLIP_TOP_BOTTOM"\"ROTATE_90"\"ROTATE_180"\"ROTATE_270"
    PilImg_Transpose = PilImg_Transpose1.transpose(Image.ROTATE_270)
    # PilImg_Transpose.show()
    
    # 试图确定该文件是否被破坏，而不需要实际解码图像数据（verify）
    # im.verify()
    PilImg_Transpose1 = Image.open('图像6.jpg')
    PilImg_Transpose1.verify()
    
    # 获得图像属性
    PilImg_Attributes = Image.open('图像6.jpg')
    print("****图像属性****")
    print("图像格式:", PilImg_Attributes.format)
    print("图像模式:", PilImg_Attributes.mode)
    print("图像大小:", PilImg_Attributes.size)
    print("图像调色板:", PilImg_Attributes.palette)
    # print("图像信息:", PilImg_Attributes.info)
    
    # 生成指定灰度值图像（constant）
    # ImageChops.constant(image, value) ⇒ image
    PilImg_Constant1 = Image.open('图像6.jpg')
    PilImg_Constant = ImageChops.constant(PilImg_Constant1, 128)
    # PilImg_Constant.show()
    
    # 复制图像（duplicate）
    # ImageChops.duplicate(image) ⇒ image
    PilImg_Duplicate1 = Image.open('图像6.jpg')
    PilImg_Duplicate = ImageChops.duplicate(PilImg_Duplicate1)
    # PilImg_Duplicate.show()
    
    # 反转图像（invert）。公式：out = MAX - image。
    # ImageChops.invert(image) ⇒ image
    PilImg_Invert1 = Image.open('图像6.jpg')
    PilImg_Invert = ImageChops.invert(PilImg_Invert1)
    # PilImg_Invert.show()
    
    # 按像素比较图像（lighter）。公式：out = max(image1, image2)。
    # ImageChops.lighter(image1, image2) ⇒ image
    PilImg_Lighter1 = Image.open('图像5.jpg')
    PilImg_Lighter2 = Image.open('图像6.jpg')
    PilImg_Lighter = ImageChops.lighter(PilImg_Lighter1, PilImg_Lighter2)
    # PilImg_Lighter.show()
    
    # 按像素比较图像（darker）。公式：out = min(image1, image2)。
    # ImageChops.darker(image1, image2) ⇒ image
    PilImg_Darker1 = Image.open('图像5.jpg')
    PilImg_Darker2 = Image.open('图像6.jpg')
    PilImg_Darker = ImageChops.darker(PilImg_Darker1, PilImg_Darker2)
    # PilImg_Darker.show()
    
    # 计算图像差值的绝对值（difference）。公式：out = abs(image1 - image2)。
    # ImageChops.difference(image1, image2) ⇒ image
    PilImg_Difference1 = Image.open('图像5.jpg')
    PilImg_Difference2 = Image.open('图像6.jpg')
    PilImg_Difference = ImageChops.difference(PilImg_Difference1,
                                              PilImg_Difference2)
    # PilImg_Difference.show()
    
    # 图像相乘（multiply）。公式：out = image1 * image2 / MAX。
    # 如果你把一个图像和一个实心的黑色图像相乘，结果是黑色的。如果你用一个纯白色的图像，图像是不受影响的。
    # ImageChops.multiply(image1, image2) ⇒ image
    PilImg_Multiply1 = Image.open('图像5.jpg')
    PilImg_Multiply2 = Image.open('图像6.jpg')
    PilImg_Multiply = ImageChops.multiply(PilImg_Multiply1, PilImg_Multiply2)
    # PilImg_Multiply.show()
    
    # 反转图像乘法（screen）。公式：out = MAX - ((MAX - image1) * (MAX - image2) / MAX)。
    # ImageChops.screen(image1, image2) ⇒ image
    PilImg_Screen1 = Image.open('图像5.jpg')
    PilImg_Screen2 = Image.open('图像6.jpg')
    PilImg_Screen = ImageChops.screen(PilImg_Screen1, PilImg_Screen2)
    # PilImg_Screen.show()
    
    # 图像加法运算，并根据比例调整运算结果（add）。公式：out = (image1 + image2) / scale + offset。
    # ImageChops.add(image1, image2, scale, offset) ⇒ image
    PilImg_Add1 = Image.open('图像5.jpg')
    PilImg_Add2 = Image.open('图像6.jpg')
    PilImg_Add = ImageChops.add(PilImg_Add1, PilImg_Add2, 2.0, 30)
    # PilImg_Add.show()
    
    # 图像减法运算，并根据比例调整运算结果（subtract）。公式：out = (image1 - image2) / scale + offset。
    # ImageChops.subtract(image1, image2, scale, offset) ⇒ image
    PilImg_Subtract1 = Image.open('图像5.jpg')
    PilImg_Subtract2 = Image.open('图像6.jpg')
    PilImg_Subtract = ImageChops.subtract(PilImg_Subtract1,
                                          PilImg_Subtract2, 2.0, 30)
    # PilImg_Subtract.show()
    
    # 图像混合操作（blend）。
    # ImageChops.blend(image1, image2, alpha) ⇒ image
    PilImg_Blend1 = Image.open('图像5.jpg')
    PilImg_Blend2 = Image.open('图像6.jpg')
    PilImg_Blend3 = ImageChops.blend(PilImg_Blend1, PilImg_Blend2, 0.25)
    # PilImg_Blend3.show()
    
    # 图像复合操作（composite）。
    # ImageChops.composite(image1, image2, mask) ⇒ image
    PilImg_Composite0 = Image.open('图像5.jpg')
    PilImg_Composite1 = PilImg_Composite0.convert('RGB')
    PilImg_Composite4 = Image.open('图像6.jpg')
    PilImg_Composite2 = PilImg_Composite4.convert('RGB')
    PilImg_Composite5 = PilImg_Composite2.copy()
    PilImg_Composite3 = PilImg_Composite5.convert('1')  # "1"、"L"、"RGBA"
    PilImg_Composite6 = ImageChops.composite(PilImg_Composite1,
                                             PilImg_Composite2, PilImg_Composite3)
    # PilImg_Composite6.show()
    
    # ImageChops.offset(image, xoffset, yoffset) ⇒ image
    # ImageChops.offset(image, offset) ⇒ image
    # Returns a copy of the image where 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.
    
    # 图像绘制库
    Mode_NewImg = "RGB"
    Width_NewImg = 1000
    Height_NewImg = 1000
    Color_NewImg = "#78b8e7"
    PilImg_Draw = Image.new(Mode_NewImg, (Width_NewImg, Height_NewImg),
                            Color_NewImg)
    
    # 绘制图像
    Draw = ImageDraw.Draw(PilImg_Draw)
    
    # 绘制圆弧（arc）
    # draw.arc(xy, start, end, options)
    # draw.arc([x1, y1, x2, y2], startAngle, endAngle, options)
    # 在左上角坐标为(x1,y1)，右下角坐标为 (x2,y2)的矩形区域内，
    # 以starangle为起始角度，endAngle为终止角度，
    # 截取圆O的一部分圆弧绘制出来。如果[x1,y1,x2,y2]区域不是正方形，
    # 则在该区域内的最大椭圆中根据角度截取片段。注意：
    # [x1,y1,x2,y2]规定矩形框的水平中位线为0度角，
    # 角度顺时针变大（与数学坐标系规定方向相反），
    # 绘制一个90度蓝色圆弧
    Draw.arc((0, 0) + (PilImg_Draw.width / 2, PilImg_Draw.height / 2),
             30, 150, fill="blue")
    # 绘制一个红色上半圆弧
    Draw.arc((0, 0) + (PilImg_Draw.width / 2, PilImg_Draw.height / 2),
             180, 360, fill="red")
    # 绘制一个右半椭圆，只需改区域大小为长方形
    Draw.arc((0, 0) + (PilImg_Draw.width / 2, PilImg_Draw.height / 2 - 150),
             90, 270, fill="green")
    
    # 绘制正弦（chord）
    # Draw.chord(xy, start, end, options)
    # 用法与arc相同，用来画圆从startAngle到endAngle的弦。
    # 绘制一条弦
    Draw.chord((PilImg_Draw.width / 2, 0) +
               (PilImg_Draw.width, PilImg_Draw.height / 2),
               270, 360, outline="red")
    # 绘制弦并且将弦与弧包围区域涂色
    Draw.chord((PilImg_Draw.width / 2, 0) +
               (PilImg_Draw.width, PilImg_Draw.height / 2),
               90, 180, fill="red")
    
    # 绘制椭圆（ellipse）
    # draw.ellipse(xy, options)
    Draw.ellipse((PilImg_Draw.width / 2, 100) +
                 (PilImg_Draw.width, PilImg_Draw.height / 2 - 100),
                 outline=128)
    Draw.ellipse((PilImg_Draw.width / 2, 100) +
                 (PilImg_Draw.width, PilImg_Draw.height / 2 - 100),
                 fill="blue")
    
    # 绘制直线（line）
    # draw.line(xy, options)
    Draw.line((0, 0) + PilImg_Draw.size, fill=128)
    Draw.line((0, PilImg_Draw.size[1], PilImg_Draw.size[0], 0), fill=128)
    
    # 绘制起始角度间的扇形区域（pieslice）
    # draw.pieslice(xy, start, end, options)
    # 绘制180度到210度的扇形区域轮廓
    Draw.pieslice((0, PilImg_Draw.height / 2) +
                  (PilImg_Draw.width / 2, PilImg_Draw.height),
                  180, 210, outline=128)
    # 绘制60度到90度的扇形区域
    Draw.pieslice((0, PilImg_Draw.height / 2) +
                  (PilImg_Draw.width / 2, PilImg_Draw.height),
                  60, 90, fill="blue")
    
    # 绘制点（point）
    # draw.point(xy, options)
    Draw.point((PilImg_Draw.width / 2, PilImg_Draw.height / 2 + 10),
               fill="black")
    
    # 绘制多边形（polygon）
    # draw.polygon(xy, options)
    Draw.polygon([(200, 200), (600, 300), (300, 600)],
                 outline="green")
    Draw.polygon([(300, 300), (500, 300), (300, 500), (500, 500)],
                 fill="#34a2b6")
    
    # 绘制矩形（rectangle）
    # draw.rectangle(box, options)
    Draw.rectangle((750, 750, 850, 850), outline="red")
    Draw.rectangle((850, 850, 900, 920), fill="#9934c5")
    
    # 加载bitmap字体
    # TextFont = ImageFont.truetype('Arial.ttf', 36)
    # TextFont = ImageFont.load("arial.pil")
    
    # 绘制文本（text）
    # draw.text(position, string, options)
    Text = "I love python!"
    Draw.text([600, 600], Text, "red")
    # Draw.text((800, 800), Text, font=TextFont)
    
    # 获取文本位置
    # width, height = Draw.textsize(Text, "red")
    # print("文本位置:", width, height)
    # PilImg_Draw.show()
    del Draw
    
    # 图像增强模块（ImageEnhance Module）
    PilImg_Enhance = Image.open('图像5.jpg')
    
    # 颜色增强
    # ImageEnhance.Color(image) ⇒ Color enhancer instance
    PilImg_Color = ImageEnhance.Color(PilImg_Enhance)
    # for i in range(5):
    #    factor = i * 4.0
    #    PilImg_Color.enhance(factor).show("Color %f" % factor)
    
    # 亮度增强
    # ImageEnhance.Brightness(image) ⇒ Brightness enhancer instance
    # PilImg_Brightness = ImageEnhance.Brightness(PilImg_Enhance)
    # for i in range(5):
    #    factor = i * 2.0
    #    PilImg_Brightness.enhance(factor).show("Brightness %f" % factor)
    
    # 对比度增强
    # ImageEnhance.Contrast(image) ⇒ Contrast enhancer instance
    # PilImg_Contrast = ImageEnhance.Contrast(PilImg_Enhance)
    # for i in range(5):
    #    factor = i * 2.0
    #    PilImg_Contrast.enhance(factor).show("Contrast %f" % factor)
    
    # 锐度增强
    # ImageEnhance.Sharpness(image) ⇒ Sharpness enhancer instance
    # PilImg_Sharpness = ImageEnhance.Sharpness(PilImg_Enhance)
    # for i in range(5):
    #    factor = i * 4.0
    #    PilImg_Sharpness.enhance(factor).show("Sharpness %f" % factor)
    
    # 截取屏幕
    Box = (300, 300, 900, 900)
    PilImg_Grab1 = ImageGrab.grab()
    PilImg_Grab2 = ImageGrab.grab(Box)
    # PilImg_Grab2.show()
    
    # 获取剪切板图像
    PilImg_Grab3 = ImageGrab.grabclipboard()
    # if isinstance(PilImg_Grab, Image.Image):
    #    PilImg_Grab3.show()
    # else:
    #    print("clipboard empty ...")
    
    # 图像对比度最大化(规范化)（autocontrast）
    # ImageOps.autocontrast(image, cutoff=0) ⇒ image
    PilImg_Autocontrast1 = Image.open('图像5.jpg')
    PilImg_Autocontrast = ImageOps.autocontrast(PilImg_Autocontrast1,
                                                cutoff=0.9)
    # PilImg_Autocontrast.show()
    
    # 灰度图像彩色化（colorize）
    # ImageOps.colorize(image, black, white) ⇒ image
    PilImg_Colorize1 = Image.open('图像5.jpg').convert('L')
    PilImg_Colorize = ImageOps.colorize(PilImg_Colorize1,
                                        black=(100, 126, 189),
                                        white=(56, 146, 231))
    # PilImg_Colorize.show()
    
    # 删除边框像素（crop）
    # ImageOps.crop(image, border=0) ⇒ image
    PilImg_Crop1 = Image.open('图像5.jpg').convert('L')
    PilImg_Crop2 = ImageOps.crop(PilImg_Crop1, border=500)
    # PilImg_Crop1.show()
    
    # 直方图均衡化（equalize）
    # ImageOps.equalize(image) ⇒ image
    PilImg_Equalize1 = Image.open('图像5.jpg')
    PilImg_Equalize2 = ImageOps.equalize(PilImg_Equalize1)
    # PilImg_Equalize2.show()
    
    # 添加边框像素（expand）
    # ImageOps.expand(image, border=0, fill=0) ⇒ image
    PilImg_Expand1 = Image.open('图像5.jpg')
    PilImg_Expand = ImageOps.expand(PilImg_Expand1, border=1, fill=1)
    # PilImg_Expand.show()
    
    # 垂直翻转图像（flip）
    # ImageOps.flip(image) ⇒ image
    PilImg_Flip1 = Image.open('图像5.jpg')
    PilImg_Flip = ImageOps.flip(PilImg_Flip1)
    # PilImg_Flip.show()
    
    # 水平翻转图像（mirror）
    # ImageOps.mirror(image) ⇒ image
    PilImg_Mirror1 = Image.open('图像5.jpg')
    PilImg_Mirror = ImageOps.mirror(PilImg_Mirror1)
    # PilImg_Mirror.show()
    
    # 将图像转换为灰度值图像（grayscale）
    # ImageOps.grayscale(image) ⇒ image
    PilImg_Grayscale1 = Image.open('图像5.jpg')
    PilImg_Grayscale = ImageOps.grayscale(PilImg_Grayscale1)
    # PilImg_Grayscale.show()
    
    # 反转(取反)图像（invert）
    # ImageOps.invert(image) ⇒ image
    PilImg_Invert1 = Image.open('图像5.jpg')
    PilImg_Invert2 = ImageOps.invert(PilImg_Invert1)
    # PilImg_Invert2.show()
    
    # 减少每个颜色通道的位数（posterize）
    # ImageOps.posterize(image, bits) ⇒ image
    PilImg_Posterize1 = Image.open('图像5.jpg')
    PilImg_Posterize = ImageOps.posterize(PilImg_Posterize1, bits=2)
    # PilImg_Posterize.show()
    
    # 将给定阈值之上所有像素值取反（solarize）
    # ImageOps.solarize(image, threshold=128) ⇒ image
    PilImg_Solarize1 = Image.open('图像5.jpg')
    PilImg_Solarize = ImageOps.solarize(PilImg_Solarize1, threshold=250)
    # PilImg_Solarize.show()
    
    # 将调色板添加到图像中 (序列语法，Sequence Syntax)
    # palette = []
    # for i in range(256):
    #    palette.extend((i, i, i)) # grayscale wedge
    # assert len(palette) == 768
    # im.putpalette(palette)
    
    # 将调色板添加到图像中 (未支持)
    # import ImagePalette
    # palette = ImagePalette.ImagePalette("RGB")
    # palette.putdata(...)
    # im.putpalette(palette)
    
    # 使用Resize/Convert获取调色板内容
    # assert im.mode == "P"
    # lut = im.resize((256, 1))
    # lut.putdata(range(256))
    # lut = lut.convert("RGB").getdata()
    # lut now contains a sequence of (r, g, b) tuples
    
    # 计算图像统计信息
    # PilImg_Stat1 = Image.open('图像3.jpg')
    # PilImg_Stat = ImageStat.Stat(PilImg_Stat1)
    # 计算图像每个通道的最小值和最大值（stat.extrema）
    # print("STAT最小值和最大值:", PilImg_Stat.extrema)
    # 计算图像的像素总数（stat.count）
    # print("STAT像素总数:", PilImg_Stat.count)
    # 计算图像所有像素的总和（stat.sum）
    # print("STAT像素总和:", PilImg_Stat.sum)
    # 计算图像所有像素的平方和（stat.sum2）
    # print("STAT像素平方和:", PilImg_Stat.sum2)
    # 计算图像的平均像素值（stat.mean）
    # print("STAT平均像素值:", PilImg_Stat.mean)
    # 计算图像的像素中值（stat.median）
    # print("STAT像素中值:", PilImg_Stat.median)
    # 计算图像的RMS(均方根)（stat.rms）
    # print("STAT均方根:", PilImg_Stat.rms)
    # 计算图像的方差（stat.var）
    # print("STAT方差:", PilImg_Stat.var)
    # 计算图像的标准差（stat.stddev）
    # print("STAT标准差:", PilImg_Stat.stddev)
    
    # Matplotlib 绘图示例。 带有坐标轴和不带坐标轴的包含点和一条线段的图像
    # 使坐标轴不显示
    # axis('off')
    # 读取图像到数组中
    # im = array(Image.open('empire.jpg'))
    # 绘制图像
    # imshow(im)
    # 一些点
    # x = [100,100,400,400]
    # y = [200,500,200,500]
    # 使用红色星状标记绘制点
    # plt.plot(x, y, 'r*')
    # 绘制连接前两个点的线
    # plt.plot(x[:2], y[:2])
    # 添加标题，显示绘制的图像
    # plt.title('Plotting: "empire.jpg"')
    # plot(x,y) # 默认为蓝色实线
    # plot(x,y,'r*') # 红色星状标记
    # plot(x,y,'go-') # 带有圆圈标记的绿线
    # plot(x,y,'ks:') # 带有正方形标记的黑色虚线
    # 基本颜色格式命令：'b' 蓝色；'g' 绿色；'r' 红色；'c' 青色；'m' 品红；'y' 黄色；'k' 黑色；'w' 白色
    # 基本线型格式命令：'-' 实线；'--' 虚线；':' 点线
    # 基本绘制标记格式命令：'.' 点；'o' 圆圈；'s' 正方形；'*' 星形；'+' 加号；'x' 叉号
    # show()
    
    # 用 Matplotlib 绘制图像等轮廓线和直方图
    # 读取图像到数组中
    # im = array(Image.open('empire.jpg').convert('L'))
    # 新建一个图像
    # figure()
    # 不使用颜色信息
    # gray()
    # 在原点的左上角显示轮廓图像
    # contour(im, origin='image')
    # axis('equal')
    # axis('off')
    # figure()
    # hist(im.flatten(),128)
    # show()
    
    # 交互式标注
    # im = array(Image.open('empire.jpg'))
    # imshow(im)
    # print("Please click 3 points")
    # x = ginput(3)
    # print("you clicked:", x)
    # show()
    
    # 图像数组表示
    # %clear
    # im = array(Image.open('empire.jpg'))
    # print(im.shape, im.dtype)
    # im = array(Image.open('empire.jpg').convert('L'),'f')
    # print(im.shape, im.dtype)
    
    # 切片方式访问数组
    # im[i,:] = im[j,:] # 将第 j 行的数值赋值给第 i 行
    # im[:,i] = 100 # 将第 i 列的所有数值设为 100
    # im[:100,:50].sum() # 计算前 100 行、前 50 列所有数值的和
    # im[50:100,50:100] # 50~100 行， 50~100 列（不包括第 100 行和第 100 列）
    # im[i].mean() # 第 i 行所有数值的平均值
    # im[:,-1] # 最后一列
    # im[-2,:] (or im[-2]) # 倒数第二行
    
    # 灰度变换
    # im1 = array(Image.open('empire.jpg').convert('L'))
    # im2 = 255 - im1 # 对图像进行反相处理
    # im3 = (100.0/255) * im1 + 100 # 将图像像素值变换到 100...200 区间
    # im4 = 255.0 * (im1/255.0)**2 # 对图像像素值求平方后得到的图像
    # figure()
    # imshow(im1)
    # plt.title('fanxiangchuli')
    # figure()
    # imshow(im2)
    # figure()
    # imshow(im3)
    # figure()
    # imshow(im4)
    # print(int(im1.min()), int(im1.max()))
    # array() 变换的相反操作
    # pil_im = Image.fromarray(im)
    # pil_im = Image.fromarray(uint8(im))
    
    im = array(Image.open('empire.jpg').convert('L'))
    im2, cdf = imtools.histeq(im)