{"id":203,"date":"2026-08-12T04:47:52","date_gmt":"2026-08-11T20:47:52","guid":{"rendered":"http:\/\/www.kilasinformasi.com\/blog\/?p=203"},"modified":"2026-08-12T04:47:52","modified_gmt":"2026-08-11T20:47:52","slug":"how-to-perform-image-transformation-affine-perspective-in-pillow-core-459c-83473f","status":"publish","type":"post","link":"http:\/\/www.kilasinformasi.com\/blog\/2026\/08\/12\/how-to-perform-image-transformation-affine-perspective-in-pillow-core-459c-83473f\/","title":{"rendered":"How to perform image transformation (affine, perspective) in Pillow Core?"},"content":{"rendered":"

As a reputable provider of Pillow Core products, I’m frequently asked about the intricacies of image transformation, particularly affine and perspective transformations, using Pillow Core. In this blog post, I’ll share in – depth knowledge on how to perform these transformations, providing practical insights and tips on leveraging the full capabilities of our Pillow Core. Pillow Core<\/a><\/p>\n

<\/p>\n

Understanding the Basics of Affine and Perspective Transformations<\/h3>\n

Before diving into the actual implementation, it’s crucial to understand what affine and perspective transformations are. An affine transformation is a linear mapping method that preserves points, straight lines, and planes. In the context of images, it can be used to perform operations such as translation, rotation, scaling, and shearing. A perspective transformation, on the other hand, changes the perspective of an image, simulating a three – dimensional view. It can correct images that are captured at an angle, making objects appear as if they are being viewed head – on.<\/p>\n

Prerequisites<\/h3>\n

To start working with affine and perspective transformations in Pillow Core, you first need to have Pillow Core installed in your Python environment. You can install it using pip install pillow<\/code>. Additionally, you should have a basic understanding of Python programming and some familiarity with handling images in Python.<\/p>\n

Affine Transformations in Pillow Core<\/h3>\n

Let’s first explore how to perform an affine transformation in Pillow Core. The Image.transform()<\/code> method in Pillow can be used to apply an affine transformation. The method takes the following parameters:<\/p>\n

    \n
  1. size<\/code>: The output size of the transformed image.<\/li>\n
  2. method<\/code>: Set to Image.AFFINE<\/code> to indicate that you’re performing an affine transformation.<\/li>\n
  3. data<\/code>: A 6 – tuple of floats representing the affine transformation matrix.<\/li>\n
  4. resample<\/code>: The resampling filter to use.<\/li>\n
  5. fillcolor<\/code>: The color used to fill the area outside the transformed image.<\/li>\n<\/ol>\n

    Here is an example code snippet:<\/p>\n

    from PIL import Image\n\n# Open the original image\nimage = Image.open('original_image.jpg')\n\n# Define the affine transformation matrix\n# This is an example of a simple translation\naffine_matrix = (1, 0, 50, 0, 1, 20)\n\n# Apply the affine transformation\ntransformed_image = image.transform(image.size, Image.AFFINE, affine_matrix)\n\n# Save the transformed image\ntransformed_image.save('affine_transformed_image.jpg')\n<\/code><\/pre>\n
    In this example, we open an image using Image.open()<\/code>, define an affine transformation matrix that translates the image 50 pixels to the right and 20 pixels down, apply the transformation using image.transform()<\/code>, and then save the result.<\/p>\n
    You can also perform more complex affine transformations, such as rotation and scaling, by adjusting the affine transformation matrix. For rotation, the matrix elements need to be set according to trigonometric functions. For example, to rotate an image by 45 degrees:<\/p>\n
    import math\nfrom PIL import Image\n\nimage = Image.open('original_image.jpg')\nangle = 45\ntheta = math.radians(angle)\ncos_theta = math.cos(theta)\nsin_theta = math.sin(theta)\naffine_matrix = (cos_theta, -sin_theta, 0, sin_theta, cos_theta, 0)\ntransformed_image = image.transform(image.size, Image.AFFINE, affine_matrix)\ntransformed_image.save('rotated_image.jpg')\n<\/code><\/pre>\n
    Perspective Transformations in Pillow Core<\/h3>\n
    Perspective transformations are a bit more complex than affine transformations. The Image.transform()<\/code> method is also used for perspective transformations, but this time, the method<\/code> parameter is set to Image.PERSPECTIVE<\/code>. The data<\/code> parameter now requires an 8 – tuple of floats representing the perspective transformation matrix.<\/p>\n
    Here is an example of applying a perspective transformation:<\/p>\n
    from PIL import Image\n\nimage = Image.open('original_image.jpg')\nwidth, height = image.size\n\n# Define the perspective transformation matrix\nperspective_matrix = (0.8, 0.05, 10, 0.1, 0.9, 20, 0.001, 0.002)\n\n# Apply the perspective transformation\ntransformed_image = image.transform((width, height), Image.PERSPECTIVE, perspective_matrix)\n\n# Save the transformed image\ntransformed_image.save('perspective_transformed_image.jpg')\n<\/code><\/pre>\n
    In practice, determining the correct perspective transformation matrix can be challenging. One way to do this is by specifying four source points and four corresponding destination points in the image. Pillow Core doesn’t provide a built – in function to calculate the perspective matrix from these points, but you can use external libraries like numpy<\/code> to perform the calculation.<\/p>\n
    import numpy as np\nfrom PIL import Image\n\ndef find_perspective_transform(src_points, dst_points):\n    matrix = []\n    for s, d in zip(src_points, dst_points):\n        matrix.append([s[0], s[1], 1, 0, 0, 0, -d[0]*s[0], -d[0]*s[1]])\n        matrix.append([0, 0, 0, s[0], s[1], 1, -d[1]*s[0], -d[1]*s[1]])\n    A = np.array(matrix, dtype='float')\n    B = np.array(dst_points).reshape(8)\n    perspective_matrix = np.linalg.solve(A, B)\n    perspective_matrix = np.append(perspective_matrix, 1)\n    return tuple(perspective_matrix[:8])\n\nimage = Image.open('original_image.jpg')\nsrc_points = [(0, 0), (image.width, 0), (image.width, image.height), (0, image.height)]\ndst_points = [(50, 50), (image.width - 50, 100), (image.width - 100, image.height - 50), (100, image.height - 100)]\nperspective_matrix = find_perspective_transform(src_points, dst_points)\ntransformed_image = image.transform(image.size, Image.PERSPECTIVE, perspective_matrix)\ntransformed_image.save('perspective_transformed_image_new.jpg')\n<\/code><\/pre>\n
    Tips for High – Quality Transformations<\/h3>\n
    When performing image transformations in Pillow Core, it’s important to pay attention to several factors to ensure high – quality results:<\/p>\n