Python Imaging Library: ImageChops Module（图像通道操作模块）

Python Imaging Library: ImageChops Module（图像通道操作模块）

ImageChops模块包含一定数量的算术图像操作。目前，大多数通道操作只支持8位图像（如“L”和“RGB”）。

函数

constant

ImageChops.constant(image, value) ⇒ image

生成指定灰度值图像。

duplicate #

ImageChops.duplicate(image) ⇒ image

复制图像。

invert #

ImageChops.invert(image) ⇒ image

反转图像。公式：out = MAX - image

lighter #

ImageChops.lighter(image1, image2) ⇒ image

按像素比较图像。公式：out = max(image1, image2)

darker #

ImageChops.darker(image1, image2) ⇒ image

按像素比较图像。公式：out = min(image1, image2)

difference #

ImageChops.difference(image1, image2) ⇒ image

计算图像差值的绝对值。公式：out = abs(image1 - image2)

multiply #

ImageChops.multiply(image1, image2) ⇒ image

图像相乘。如果你把一个图像和一个实心的黑色图像相乘，结果是黑色的。如果你用一个纯白色的图像，图像是不受影响的。公式：out = image1 * image2 / MAX

screen #

ImageChops.screen(image1, image2) ⇒ image

反转图像乘法。公式：out = MAX - ((MAX - image1) * (MAX - image2) / MAX)

add 

ImageChops.add(image1, image2, scale, offset) ⇒ image

图像加法运算，并根据比例调整运算结果。公式：out = (image1 + image2) / scale + offset

subtract

ImageChops.subtract(image1, image2, scale, offset) ⇒ image

图像减法运算，并根据比例调整运算结果。公式：out = (image1 - image2) / scale + offset

blend

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

图像混合操作。

composite

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

图像复合操作。

offset

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.

# 生成指定灰度值图像（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_Blend = ImageChops.blend(PilImg_Blend1, PilImg_Blend2, 0.25)

# PilImg_Blend.show()

# 图像复合操作（composite）。

# ImageChops.composite(image1, image2, mask) ⇒ image

PilImg_Composite = Image.open('图像5.jpg')

PilImg_Composite1 = PilImg_Composite.convert('RGB')

PilImg_Composite = Image.open('图像6.jpg')

PilImg_Composite2 = PilImg_Composite.convert('RGB')

PilImg_Composite = PilImg_Composite2.copy()

PilImg_Composite3 = PilImg_Composite.convert('1')    # "1"、"L"、"RGBA"

PilImg_Composite = ImageChops.composite(PilImg_Composite1,

                                        PilImg_Composite2, PilImg_Composite3)

PilImg_Composite.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.