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.