itextsharp pdf to image c# example : Add text field to pdf acrobat application software cloud windows html .net class Automate%20the%20Boring%20Stuff%20with%20Python%20(2015)41-part1632

17
mAniPulAting imAgeS
If you have a digital camera or even if 
you just upload photos from your phone 
to Facebook, you probably cross paths with 
digital image files all the time. You may know 
how to use basic graphics software, such as Microsoft 
Paint or Paintbrush, or even more advanced applica-
tions such as Adobe Photoshop. But if you need to 
edit a massive number of images, editing them by 
hand can be a lengthy, boring job.
Enter Python. Pillow is a third-party Python module for interacting 
with image files. The module has several functions that make it easy to 
crop, resize, and edit the content of an image. With the power to manipu-
late images the same way you would with software such as Microsoft Paint 
or Adobe Photoshop, Python can automatically edit hundreds or thousands 
of images with ease.
Add text field to pdf acrobat - C# PDF Field Edit Library: insert, delete, update pdf form field in C#.net, ASP.NET, MVC, Ajax, WPF
Online C# Tutorial to Insert, Delete and Update Fields in PDF Document
adding image to pdf form; allow saving of pdf form
Add text field to pdf acrobat - VB.NET PDF Field Edit library: insert, delete, update pdf form field in vb.net, ASP.NET, MVC, Ajax, WPF
How to Insert, Delete and Update Fields in PDF Document with VB.NET Demo Code
create pdf forms; add form fields to pdf
388   
Chapter 17
computer image fundamentals
In order to manipulate an image, you need to understand the basics of how 
computers deal with colors and coordinates in images and how you can 
work with colors and coordinates in Pillow. But before you continue, install 
the 
pillow
module. See Appendix A for help installing third-party modules.
Colors and RGBA Values
Computer programs often represent a color in an image as an RGBA value. 
An RGBA value is a group of numbers that specify the amount of red, green, 
blue, and alpha (or transparency) in a color. Each of these component values 
is an integer from 
0
(none at all) to 
255
(the maximum). These RGBA values 
are assigned to individual pixels; a pixel is the smallest dot of a single color 
the computer screen can show (as you can imagine, there are millions of 
pixels on a screen). A pixel’s RGB setting tells it precisely what shade of 
color it should display. Images also have an alpha value to create RGBA 
values. If an image is displayed on the screen over a background image 
or desktop wallpaper, the alpha value determines how much of the back-
ground you can “see through” the image’s pixel.
In Pillow, RGBA values are represented by a tuple of four integer values. 
For example, the color red is represented by 
(255, 0, 0, 255)
. This color has 
the maximum amount of red, no green or blue, and the maximum alpha 
value, meaning it is fully opaque. Green is represented by 
(0, 255, 0, 255)
and blue is 
(0, 0, 255, 255)
. White, the combination of all colors, is 
(255, 
255, 255, 255)
, while black, which has no color at all, is 
(0, 0, 0, 255)
.
If a color has an alpha value of 
0
, it is invisible, and it doesn’t really mat-
ter what the RGB values are. After all, invisible red looks the same as invis-
ible black. 
Pillow uses the standard color names that HTML uses. Table 17-1 lists a 
selection of standard color names and their values.
table 17-1: Standard Color Names and Their RGBA Values
name
rgBA value
name
rgBA value
White
(255, 255, 255, 255)
Red
(255, 0, 0, 255)
Green
(0, 128, 0, 255)
Blue
(0, 0, 255, 255)
Gray
(128, 128, 128, 255)
Yellow
(255, 255, 0, 255)
Black
(0, 0, 0, 255)
Purple
(128, 0, 128, 255)
Pillow offers the 
ImageColor.getcolor()
function so you don’t have to 
memorize RGBA values for the colors you want to use. This function takes 
a color name string as its first argument, and the string 
'RGBA'
as its second 
argument, and it returns an RGBA tuple. 
C# PDF Converter Library SDK to convert PDF to other file formats
Allow users to convert PDF to Text (TXT) file. can manipulate & convert standard PDF documents in other external third-party dependencies like Adobe Acrobat.
pdf form creator; change font size in pdf form
Manipulating Images
389
To see how this function works, enter the following into the interactive 
shell:
u >>> from PIL import ImageColor
v >>> ImageColor.getcolor('red', 'RGBA')
(255, 0, 0, 255)
w >>> ImageColor.getcolor('RED', 'RGBA')
(255, 0, 0, 255)
>>> ImageColor.getcolor('Black', 'RGBA')
(0, 0, 0, 255)
>>> ImageColor.getcolor('chocolate', 'RGBA')
(210, 105, 30, 255)
>>> ImageColor.getcolor('CornflowerBlue', 'RGBA')
(100, 149, 237, 255)
First, you need to import the 
ImageColor
module from PIL u (not 
from Pillow; you’ll see why in a moment). The color name string you pass 
to 
ImageColor.getcolor()
is case insensitive, so passing 
'red'
v and passing 
'RED'
w give you the same RGBA tuple. You can also pass more unusual 
color names, like 
'chocolate'
and 
'Cornflower Blue'
.
Pillow supports a huge number of color names, from 
'aliceblue'
to 
'whitesmoke'
. You can find the full list of more than 100 standard color 
names in the resources at http://nostarch.com/automatestuff/. 
Coordinates and Box Tuples
Image pixels are addressed with x- and y-coordinates, which respectively 
specify a pixel’s horizontal and vertical location in an image. The origin is 
the pixel at the top-left corner of the image and is specified with the nota-
tion (0, 0). The first zero represents the x-coordinate, which starts at zero 
at the origin and increases going from left to right. The second zero repre-
sents the y-coordinate, which starts at zero at the origin and increases going 
Cmyk AnD rgB Coloring
In grade school you learned that mixing red, yellow, and blue paints can 
form other colors; for example, you can mix blue and yellow to make green 
paint‮ This is known as the subtractive color model, and it applies to dyes, inks, 
and pigments‮ This is why color printers have CMYK ink cartridges: the Cyan 
(blue), Magenta (red), Yellow, and blacK ink can be mixed together to form any 
color‮
However, the physics of light uses what’s called an additive color model‮ 
When combining light (such as the light given off by your computer screen), 
red, green, and blue light can be combined to form any other color‮ This is why 
RGB values represent color in computer programs‮
390   
Chapter 17
down the image. This bears repeating: 
y-coordinates increase going downward, 
which is the opposite of how you may 
remember y-coordinates being used in 
math class. Figure 17-1 demonstrates how 
this coordinate system works.
Many of Pillow’s functions and 
methods take a box tuple argument. This 
means Pillow is expecting a tuple of four 
integer coordinates that represent a rect-
angular region in an image. The four 
integers are, in order, as follows:
• Left: The x-coordinate of the leftmost 
edge of the box.
• Top: The y-coordinate of the top edge 
of the box.
• Right: The x-coordinate of one pixel 
to the right of the rightmost edge of 
the box. This integer must be greater 
than the left integer.
• Bottom: The y-coordinate of one pixel 
lower than the bottom edge of the 
box. This integer must be greater 
than the top integer.
Note that the box includes the left 
and top coordinates and goes up to but 
does not include the right and bottom 
coordinates. For example, the box tuple  
(3, 1, 9, 6)
represents all the pixels in 
the black box in Figure 17-2.
manipulating images with Pillow
Now that you know how colors and coordinates work in Pillow, let’s use 
Pillow to manipulate an image. Figure 17-3 is the image that will be used 
for all the interactive shell examples in this chapter. You can download it 
from http://nostarch.com/automatestuff/.
Once you have the image file Zophie.png in your current working direc-
tory, you’ll be ready to load the image of Zophie into Python, like so:
>>> from PIL import Image
>>> catIm = Image.open('zophie.png')
Figure 17-2: The area represented 
by the box tuple (3, 1, 9, 6)
x increases
y increases
(0,0)
(27,26)
Figure 17-1: The x- and y-coordinates 
of a 27×26 image of some sort of 
ancient data storage device
Manipulating Images
391
Figure 17-3: My cat Zophie. The camera  
adds 10 pounds (which is a lot for a cat).
To load the image, you import the 
Image
module from Pillow and call 
Image.open()
, passing it the image’s filename. You can then store the loaded 
image in a variable like 
CatIm
. The module name of Pillow is 
PIL
to make it 
backward compatible with an older module called Python Imaging Library, 
which is why you must run 
from PIL import Image
instead of 
from Pillow import 
Image
. Because of the way Pillow’s creators set up the 
pillow
module, you must 
use the 
from PIL import Image
form of 
import
statement, rather than simply 
import PIL
.
If the image file isn’t in the current working directory, change the 
working directory to the folder that contains the image file by calling the 
os.chdir()
function.
>>> import os
>>> os.chdir('C:\\folder_with_image_file')
The 
Image.open()
function returns a value of the 
Image
object data type, 
which is how Pillow represents an image as a Python value. You can load an 
Image
object from an image file (of any format) by passing the 
Image.open()
function a string of the filename. Any changes you make to the 
Image
object can be saved to an image file (also of any format) with the 
save()
method. All the rotations, resizing, cropping, drawing, and other image 
manipulations will be done through method calls on this 
Image
object.
To shorten the examples in this chapter, I’ll assume you’ve imported 
Pillow’s 
Image
module and that you have the Zophie image stored in a variable 
named 
catIm
. Be sure that the zophie.png file is in the current working direc-
tory so that the 
Image.open()
function can find it. Otherwise, you will also have 
to specify the full absolute path in the string argument to 
Image.open()
.
392   
Chapter 17
Working with the Image Data Type
An 
Image
object has several useful attributes that give you basic information 
about the image file it was loaded from: its width and height, the filename, 
and the graphics format (such as JPEG, GIF, or PNG). 
For example, enter the following into the interactive shell:
>>> from PIL import Image
>>> catIm = Image.open('zophie.png')
>>> catIm.size
u (816, 1088)
v >>> width, height = catIm.size
w >>> width
816
x >>> height
1088
>>> catIm.filename
'zophie.png'
>>> catIm.format
'PNG'
>>> catIm.format_description
'Portable network graphics'
y >>> catIm.save('zophie.jpg')
After making an 
Image
object from Zophie.png and storing the 
Image
object in 
catIm
, we can see that the object’s 
size
attribute contains a tuple 
of the image’s width and height in pixels u. We can assign the values in the 
tuple to 
width
and 
height
variables v in order to access with width w and 
height x individually. The 
filename
attribute describes the original file’s 
name. The 
format
and 
format_description
attributes are strings that describe 
the image format of the original file (with 
format_description
being a bit 
more verbose).
Finally, calling the 
save()
method and passing it 
'zophie.jpg'
saves a new 
image with the filename zophie.jpg to your hard drive y. Pillow sees that the 
file extension is .jpg and automatically saves the image using the JPEG image 
format. Now you should have two images, zophie.png and zophie.jpg, on your 
hard drive. While these files are based on the same image, they are not iden-
tical because of their different formats.
Pillow also provides the 
Image.new()
function, which returns an 
Image
object—much like 
Image.open()
, except the image represented by 
Image.new()
’s 
object will be blank. The arguments to 
Image.new()
are as follows:
• The string 
'RGBA'
, which sets the color mode to RGBA. (There are other 
modes that this book doesn’t go into.)
• The size, as a two-integer tuple of the new image’s width and height.
Manipulating Images
393
• The background color that the image should start with, as a four-
integer tuple of an RGBA value. You can use the return value of 
the 
ImageColor.getcolor()
function for this argument. Alternatively, 
Image.new()
also supports just passing the string of the standard 
color name.
For example, enter the following into the interactive shell:
>>> from PIL import Image
u >>> im = Image.new('RGBA', (100, 200), 'purple')
>>> im.save('purpleImage.png')
v >>> im2 = Image.new('RGBA', (20, 20))
>>> im2.save('transparentImage.png')
Here we create an 
Image
object for an image that’s 100 pixels wide and 
200 pixels tall, with a purple background u. This image is then saved to 
the file purpleImage.png. We call 
Image.new()
again to create another 
Image
object, this time passing (20, 20) for the dimensions and nothing for the 
background color v. Invisible black, 
(0, 0, 0, 0)
, is the default color used if 
no color argument is specified, so the second image has a transparent back-
ground; we save this 20×20 transparent square in transparentImage.png.
Cropping Images
Cropping an image means selecting a rectangular region inside an image 
and removing everything outside the rectangle. The 
crop()
method on 
Image
objects takes a box tuple and returns an 
Image
object representing 
the cropped image. The cropping does not happen in place—that is, the 
original 
Image
object is left untouched, and the 
crop()
method returns a 
new 
Image
object. Remeber that a boxed tuple—in this case, the cropped 
section—includes the left column and top row of pixels but only goes up 
to and does not include the right column and bottom row of pixels.
Enter the following into the interactive shell:
>>> croppedIm = catIm.crop((335, 345, 565, 560))
>>> croppedIm.save('cropped.png')
This makes a new 
Image
object for the cropped image, stores the 
object in 
croppedIm
, and then calls 
save()
on 
croppedIm
to save the cropped 
image in cropped.png. The new file cropped.png will be created from the ori-
ginal image, like in Figure 17-4.
394   
Chapter 17
Figure 17-4: The new image will be just the cropped  
section of the original image.
Copying and Pasting Images onto Other Images
The 
copy()
method will return a new 
Image
object with the same image 
as the 
Image
object it was called on. This is useful if you need to make 
changes to an image but also want to keep an untouched version of the 
original. For example, enter the following into the interactive shell:
>>> catIm = Image.open('zophie.png')
>>> catCopyIm = catIm.copy()
The 
catIm
and 
catCopyIm
variables contain two separate 
Image
objects, 
which both have the same image on them. Now that you have an 
Image
object stored in 
catCopyIm
, you can modify 
catCopyIm
as you like and save 
it to a new filename, leaving zophie.png untouched. For example, let’s try 
modifying 
catCopyIm
with the 
paste()
method.
The 
paste()
method is called on an 
Image
object and pastes another image 
on top of it. Let’s continue the shell example by pasting a smaller image onto 
catCopyIm
.
>>> faceIm = catIm.crop((335, 345, 565, 560))
>>> faceIm.size
(230, 215)
>>> catCopyIm.paste(faceIm, (0, 0))
>>> catCopyIm.paste(faceIm, (400, 500))
>>> catCopyIm.save('pasted.png')
Manipulating Images
395
First we pass 
crop()
a box tuple for the rectangular area in zophie.png 
that contains Zophie’s face. This creates an 
Image
object representing a 
230×215 crop, which we store in 
faceIm
. Now we can paste 
faceIm
onto 
catCopyIm
. The 
paste()
method takes two arguments: a “source” 
Image
object and a tuple of the x- and y-coordinates where you want to paste 
the top-left corner of the source 
Image
object onto the main 
Image
object. 
Here we call 
paste()
twice on 
catCopyIm
, passing (0, 0) the first time and 
(400, 500) the second time. This pastes 
faceIm
onto 
catCopyIm
twice: once 
with the top-left corner of 
faceIm
at (0, 0) on 
catCopyIm
, and once with 
the top-left corner of 
faceIm
at (400, 500). Finally, we save the modified 
catCopyIm
to pasted.png. The pasted.png image looks like Figure 17-5.
Figure 17-5: Zophie the cat, with her face  
pasted twice
note
Despite their names, the 
copy()
and 
paste()
methods in Pillow do not use your com-
puter’s clipboard.
Note that the 
paste()
method modifies its 
Image
object in place; it does 
not return an 
Image
object with the pasted image. If you want to call 
paste()
but also keep an untouched version of the original image around, you’ll 
need to first copy the image and then call 
paste()
on that copy.
Say you want to tile Zophie’s head across the entire image, as in 
Figure 17-6. You can achieve this effect with just a couple 
for
loops. 
Continue the interactive shell example by entering the following:
>>> catImWidth, catImHeight = catIm.size
>>> faceImWidth, faceImHeight = faceIm.size
u >>> catCopyTwo = catIm.copy()
396   
Chapter 17
v >>> for left in range(0, catImWidth, faceImWidth):
        for top in range(0, catImHeight, faceImHeight):
print(left, top)
catCopyTwo.paste(faceIm, (left, top))
0 0
0 215
0 430
0 645
0 860
0 1075
230 0
230 215
--snip--
690 860
690 1075
>>> catCopyTwo.save('tiled.png')
Here we store the width of height of 
catIm
in 
catImWidth
and 
catImHeight
. At u we make a copy of 
catIm
and store it in 
catCopyTwo
. Now 
that we have a copy that we can paste onto, we start looping to paste 
faceIm
onto  
catCopyTwo
. The outer 
for
loop’s 
left
variable starts at 0 and increases by 
faceImWidth(230)
v. The inner 
for
loop’s 
top
variable start at 0 and increases 
by 
faceImHeight(215)
w. These nested 
for
loops produce values for 
left
and 
top
to paste a grid of 
faceIm
images over the 
catCopyTwo
Image
object, as in 
Figure 17-6. To see our nested loops working, we print 
left
and 
top
. After 
the pasting is complete, we save the modified 
catCopyTwo
to tiled.png.
Figure 17-6: Nested for loops used  
with paste() to duplicate the cat’s face  
(a dupli-cat, if you will).
Documents you may be interested
Documents you may be interested