I was able to do this with an affine transformation (thanks to this question). After the affine transformation, the destination triangle is drawn to a mask and then pasted on to the destination image. Here's what I came up with:
import Image
import ImageDraw
import numpy
def transformblit(src_tri, dst_tri, src_img, dst_img):
((x11, x12), (x21, x22), (x31, x32)) = src_tri((y11, y12), (y21, y22), (y31, y32)) = dst_tri
M = numpy.array([
[y11, y12, 1, 0, 0, 0],
[y21, y22, 1, 0, 0, 0],
[y31, y32, 1, 0, 0, 0],
[0, 0, 0, y11, y12, 1],
[0, 0, 0, y21, y22, 1],
[0, 0, 0, y31, y32, 1]
])
y = numpy.array([x11, x21, x31, x12, x22, x32])
A = numpy.linalg.solve(M, y)
src_copy = src_img.copy()
srcdraw = ImageDraw.Draw(src_copy)
srcdraw.polygon(src_tri)
src_copy.show()
transformed = src_img.transform(dst_img.size, Image.AFFINE, A)
mask = Image.new('1', dst_img.size)
maskdraw = ImageDraw.Draw(mask)
maskdraw.polygon(dst_tri, fill = 255)
dstdraw = ImageDraw.Draw(dst_img)
dstdraw.polygon(dst_tri, fill = (255, 255, 255))
dst_img.show()
dst_img.paste(transformed, mask = mask)
dst_img.show()
im100 = Image.open('test100.jpg')
im250 = Image.open('test250.jpg')
tri1 = [(10, 10), (20, 20), (10, 20)]
tri2 = [(35, 30), (75, 19), (50, 90)]
transformblit(tri1, tri2, im100, im250)Returns a rectangular region from this image. The box is a 4-tuple defining the left, upper, right, and lower pixel coordinate. See Coordinate System.,The bounding box is returned as a 4-tuple defining the left, upper, right, and lower pixel coordinate. See Coordinate System. If the image is completely empty, this method returns None.,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)). See Coordinate System. If a 4-tuple is given, the size of the pasted image must match the size of the region.,If any changes are made, returns a tuple with the chosen mode and box with coordinates of the original image within the altered one.
from PIL
import Image
with Image.open("hopper.jpg") as im:
im.rotate(45).show()from PIL
import Image
import glob, os
size = 128, 128
for infile in glob.glob("*.jpg"):
file, ext = os.path.splitext(infile)
with Image.open(infile) as im:
im.thumbnail(size)
im.save(file + ".thumbnail", "JPEG")out = image1 * (1.0 - alpha) + image2 * alpha
from PIL
import Image
import numpy as np
im = Image.open("hopper.jpg")
a = np.asarray(im)im = Image.fromarray(a)
from PIL import Image import numpy as np a = np.full((1, 1), 300) im = Image.fromarray(a, mode = "L") im.getpixel((0, 0)) # 44 im = Image.fromarray(a, mode = "RGB") im.getpixel((0, 0)) #(44, 1, 0)
Last Updated On: December 02, 2020
You can install Pillow with pip as shown:
python3 - m pip install--upgrade pip
python3 - m pip install--upgrade PillowTo load an image from a file, we use the open() function in the Image module, passing it the path to the image.
from PIL
import Image
image = Image.open('demo_image.jpg')After obtaining an Image object, you can now use the methods and attributes defined by the class to process and manipulate it. Let's start by displaying the image. You can do this by calling the show() method on it. This displays the image on an external viewer (usually Preview on macOS, xv on Unix, and the Paint program on Windows).
image.show()
When you are done processing an image, you can save it to a file with the save() method, passing in the name that will be used to label the image file. When saving an image, you can specify a different extension from its original, and the saved image will be converted to the specified format.
image = Image.open('demo_image.jpg')
image.save('new_image.png')To resize an image, you call the resize() method on it, passing in a two-integer tuple argument representing the width and height of the resized image. The function doesn't modify the used image; it instead returns another Image with the new dimensions.
image = Image.open('demo_image.jpg')
new_image = image.resize((400, 400))
new_image.save('image_400.jpg')
print(image.size) # Output: (1920, 1280)
print(new_image.size) # Output: (400, 400)Making an Exact Copy Generating a New Image Copying all Pixels to the New Image Saving the New Image Copying Individual RGB Values ,The Pillow package is a fork of the older PIL library, which stood for Python Imaging Library. This package allows you to load and work with existing images, and it also allows you to create new images and fill the pixels programmatically. This makes it possible to make your own photo filters, build your own image adjustment tools, and explore digitally-generated art.,Let’s make one modification to the image. We’ll brighten the image, which corresponds to increasing all of the component values for each pixel.,Before working with many pixels, let’s just look at one single pixel. The following code loads all the pixels in the image, and then prints the pixel data for the very first pixel in the image:
$ python - m pip install--user pillow
from PIL
import Image
filename = 'starr_bears.jpg'
filepath = f "original_images/{filename}"
# Load the original image, and get its size and color mode.
orig_image = Image.open(filepath)
width, height = orig_image.size
mode = orig_image.mode
# Show information about the original image.
print(f "Original image: {filename}")
print(f "Size: {width} x {height} pixels")
print(f "Mode: {mode}")
# Show the image.
orig_image.show()Original image: starr_bears.jpg Size: 1560 x 811 pixels Mode: RGB
from PIL
import Image
filename = 'starr_bears.jpg'
filepath = f "original_images/{filename}"
# Load the original image, and get its size and color mode.
orig_image = Image.open(filepath)
width, height = orig_image.size
mode = orig_image.mode
# Show information about the original image.
print(f "Original image: {filename}")
print(f "Size: {width} x {height} pixels")
print(f "Mode: {mode}")
# Load all pixels from the image.
orig_pixel_map = orig_image.load()
# Look at the pixel in the top left corner.
first_pixel = orig_pixel_map[0, 0]
print(f "\nFirst pixel: {first_pixel}")Original image: starr_bears.jpg Size: 1560 x 811 pixels Mode: RGB First pixel: (31, 52, 21)
from PIL
import Image
filename = 'starr_bears.jpg'
filepath = f "original_images/{filename}"
# Load the original image, and get its size and color mode.
orig_image = Image.open(filepath)
width, height = orig_image.size
mode = orig_image.mode
# Show information about the original image.
print(f "Original image: {filename}")
print(f "Size: {width} x {height} pixels")
print(f "Mode: {mode}")
# Load all pixels from the image.
orig_pixel_map = orig_image.load()
# Examine the 100 pixels in the top left corner of the image.
print("\nPixel data:")
for x in range(10):
for y in range(10):
pixel = orig_pixel_map[x, y]
print(pixel)Cropping a region from an image is done using the crop() method:,Computing the image derivatives can be done using discrete approximations. These are most easily implemented as convolutions,Color conversions are done using the convert() method. To read an image and convert it to grayscale, just add convert('L') like this:,The Python Imaging Library (PIL) provides general image handling and lots of useful basic image operations like resizing, cropping, rotating, color conversion and much more. PIL is free and available from http://www.pythonware.com/products/pil/.
from PIL
import Image
from pylab
import *
# read image to array
im = array(Image.open('empire.jpg'))
# plot the image
imshow(im)
# some points
x = [100, 100, 400, 400]
y = [200, 500, 200, 500]
# plot the points with red star - markers
plot(x, y, 'r*')
# line plot connecting the first two points
plot(x[: 2], y[: 2])
# add title and show the plot
title('Plotting: "empire.jpg"')
show()