convert pdf to tiff using ghostscript c# : Adding signature to pdf document software Library cloud windows .net wpf class ProgrammingComputerVision_CCdraft26-part1299

Figure 10.2: Flood fill of a color image. The cyan area marks all pixels filled using a
single seed in the upper left corner.
import cv2
# read image
im = cv2.imread(’empire.jpg’)
# down sample
im
_
lowres = cv2.pyrDown(im)
# convert to grayscale
gray = cv2.cvtColor(im
_
lowres,cv2.COLOR
_
RGB2GRAY)
# detect feature points
= cv2.SURF()
mask = uint8(ones(gray.shape))
keypoints = s.detect(gray,mask)
# show image and points
vis = cv2.cvtColor(gray,cv2.COLOR
_
GRAY2BGR)
for k in keypoints[::10]:
cv2.circle(vis,(int(k.pt[0]),int(k.pt[1])),2,(0,255,0),-1)
cv2.circle(vis,(int(k.pt[0]),int(k.pt[1])),int(k.size),(0,255,0),2)
cv2.imshow(’local descriptors’,vis)
cv2.waitKey()
After reading the image it is down sampled using the function
pyrDown()
which if no
new size is given, creates a new image half the size of the original. Then the image
is converted to grayscale and passed to a
SURF
keypoint detection object. The mask
determines what areas to apply the keypoint detector. When it comes to plotting we
10.2. OpenCV Basics
261
Adding signature to pdf document - C# PDF File Permission Library: add, remove, update PDF file permission in C#.net, ASP.NET, MVC, WPF
Tell C# users how to set PDF file permissions, like printing, copying, modifying, extracting, annotating, form filling, etc
export pdf to word sign in; pdf to word converter sign in
Adding signature to pdf document - VB.NET PDF File Permission Library: add, remove, update PDF file permission in vb.net, ASP.NET, MVC, WPF
VB.NET Tutorial for How to Set PDF File Access Permissions Using XDoc.PDF for .NET
create pdf with signature field; click to sign pdf
Figure 10.3: Sample SURF features extracted and plotted using OpenCV.
convert the grayscale image to a color image and use the green channel for plotting.
We loop over every tenthkeypoint and plot a circle at the center andone circle showing
the scale (size) of the keypoint. The plotting function
circle()
takes an image, a tuple
with image coordinates (integer only), a radius, a tuple with plot color and finally the
line thickness (-1 gives a solid circle). Figure 10.3 shows the result.
10.3 Processing Video
Video with pure Python is hard. There is speed, codecs, cameras, operating systems
and file formats to consider. There is currently no video library for Python. OpenCV
with its Python interface is the only good option. In this section we’ll look at some
basic examples using video.
Video input
Reading video from a camera is very well supported in OpenCV. A basic complete
example that captures frames and shows them in an OpenCV window looks like this.
import cv2
262
10.3.Processing Video
C# PDF Digital Signature Library: add, remove, update PDF digital
Help to Improve the Security of Your PDF File by Adding Digital Signatures. Overview. Search unsigned signature field in PDF document.
pdf secure signature; adding signature to pdf file
VB.NET PDF Library SDK to view, edit, convert, process PDF file
Capable of adding PDF file navigation features to your VB allows users to perform PDF document security settings Password, digital signature and PDF text, image
adding signature to pdf; create pdf signature
# setup video capture
cap = cv2.VideoCapture(0)
while True:
ret,im = cap.read()
cv2.imshow(’video test’,im)
key = cv2.waitKey(10)
if key == 27:
break
if key == ord(’ ’):
cv2.imwrite(’vid
_
result.jpg’,im)
The capture object
VideoCapture
captures video from cameras or files. Here we pass
an integer at initialization. This is the id of the video device, with a single camera
connected this is 0. The method
read()
decodes and returns the next video frame.
The first value is a success flag and the second the actual image array. The
waitKey()
function waits for a key to be pressed and quit the application if the ’esc’ key (Ascii
number 27) is pressed or saves the frame if the ’space’ key is pressed.
Let’s extend this example with some simple processing by taking the camera input
and show a blurred (color) version of the input in an OpenCV window. This is only a
slight modification to the base example above:
import cv2
# setup video capture
cap = cv2.VideoCapture(0)
# get frame, apply Gaussian smoothing, show result
while True:
ret,im = cap.read()
blur = cv2.GaussianBlur(im,(0,0),5)
cv2.imshow(’camera blur’,blur)
if cv2.waitKey(10) == 27:
break
Each frame is passed to the function
GaussianBlur()
which applies a Gaussian filter to
the image. In this case we are passing a color image so each color channel is blurred
separately. The function takes a tuple for filter size and the standard deviation for the
Gaussian function (in this case 5). If the filter size is set to zero, it will automatically
be determined from the standard deviation. The result looks like Figure 10.4.
Reading video from files works the same way but with the call to
VideoCapture()
taking the video filename as input.
capture = cv2.VideoCapture(’filename’)
10.3. Processing Video
263
C# PDF insert image Library: insert images into PDF in C#.net, ASP
scanned signature or logo into PDF document page in C#.NET class application? To help you solve this technical problem, we provide this C#.NET PDF image adding
pdf export sign in; add signature to pdf
VB.NET PDF Digital Signature Library: add, remove, update PDF
Guide VB.NET Programmers to Improve the Security of Your PDF File by Adding Digital Signatures in VB.NET. Search unsigned signature field in PDF document.
adding a signature to a pdf file; create signature from pdf
Figure 10.4: Screenshot of a blurred video of the author as he’s writing this chapter.
Reading video to NumPy arrays
Using OpenCV it is possible to read video frames from a file and convert them to NumPy
arrays. Here is an example of capturing video from a camera and storing the frames
in a NumPy array.
import cv2
# setup video capture
cap = cv2.VideoCapture(0)
frames = []
# get frame, store in array
while True:
ret,im = cap.read()
cv2.imshow(’video’,im)
frames.append(im)
if cv2.waitKey(10) == 27:
break
frames array(frames)
# check the sizes
print im.shape
print frames.shape
Each frame array is added to the end of a list until the capturing is stopped. The
resulting arraywill have size (number of frames,height,width,3). The printout confirms
264
10.3.Processing Video
C# HTML5 Viewer: Load, View, Convert, Annotate and Edit PDF
C# .NET provides permanent annotations adding feature, all to PDF, including freehand signature, text and date signature. such as logo to PDF document, you and
pdf signature; pdf sign in
C# HTML5 Viewer: Load, View, Convert, Annotate and Edit PowerPoint
can convert PowerPoint to PDF (.pdf) online, convert Viewer to view PowerPoint Document, users can Users can perform text signature adding, freehand signature
copy and paste signature into pdf; adding signature to pdf document
this:
(480, 640, 3)
(40, 480, 640, 3)
In this case there were 40 frames recorded. Arrays with video data like this are useful
for video processing such as computing frame differences and tracking.
10.4 Tracking
Optical flow
Optical flow (sometimes calledoptic flow) is the image motion of objects as the objects,
scene or camera moves between two consecutive images. It is a 2D vector field of
within-image translation. Is is a classic and well studied field in computer vision with
many successful applications in for example video compression, motion estimation,
object tracking and image segmentation.
Optical flow relies on three major assumptions.
1. Brightness constancy: The pixel intensities of an object in an image does not
change between consecutive images.
2. Temporal regularity: The between-frame time is short enough to consider the
motion change between images using differentials (used to derive the central
equation below).
3. Spatial consistency: Neighboring pixels have similar motion.
In many cases these assumptions break down, but for small motions and short time
steps between images it is a good model. Assuming that an object pixel
I(x, y, t)
at
time
t
has the same intensity at time
t+ t
after motion
[ x, y])
means that
I(x, y, t) =
I(x + x,y + y, t +  t)
.Differentiating this constraint gives the optical flow equation:
rI
T
v=  I
t
,
where
v= [u, v]
is the motion vector and
I
t
the time derivative. For individual points
in the image, this equation is under-determined and cannot be solved (one equation
with two unknowns in
v
). By enforcing some spatial consistency, it is possible to
obtain solutions though. In the Lucas-Kanade algorithm below we will see how that
assumption is used.
OpenCVcontains several optical flow implementations,
CalcOpticalFlowBM()
which
uses block matching,
CalcOpticalFlowHS()
which uses [15] (both of these currently
only in the old
cv
module), the pyramidal Lucas-Kanade algorithm[19]
calcOpticalFlowPyrLK()
10.4. Tracking
265
XDoc.HTML5 Viewer for .NET, All Mature Features Introductions
or typing new signature, deleting added signature from the file After adding such a control button, with a & profession imaging controls, PDF document, image to
add signature image to pdf; create transparent signature stamp for pdf
.NET PDF SDK - Description of All PDF Processing Control Feastures
Add signature image to PDF file. PDF Hyperlink Edit. Support adding and inserting hyperlink (link) to PDF document; Allow to create, edit, and remove PDF bookmark
adding signature to pdf form; pdf signature field
and finally
calcOpticalFlowFarneback()
based on [10]. The last one is considered one
of the best methods for obtaining dense flow fields. Let’s look at an example of using
this to find motion vectors in video (the Lucas-Kanade version is the subject of the next
section).
Try running the following script.
import cv2
def draw
_
flow(im,flow,step=16):
""" Plot optical flow at sample points
spaced step pixels apart. """
h,w = im.shape[:2]
y,x = mgrid[step/2:h:step,step/2:w:step].reshape(2,-1)
fx,fy = flow[y,x].T
# create line endpoints
lines vstack([x,y,x+fx,y+fy]).T.reshape(-1,2,2)
lines = int32(lines)
# create image and draw
vis = cv2.cvtColor(im,cv2.COLOR
_
GRAY2BGR)
for (x1,y1),(x2,y2) in lines:
cv2.line(vis,(x1,y1),(x2,y2),(0,255,0),1)
cv2.circle(vis,(x1,y1),1,(0,255,0), -1)
return vis
# setup video capture
cap = cv2.VideoCapture(0)
ret,im = cap.read()
prev
_
gray = cv2.cvtColor(im,cv2.COLOR
_
BGR2GRAY)
while True:
# get grayscale image
ret,im = cap.read()
gray = cv2.cvtColor(im,cv2.COLOR
_
BGR2GRAY)
# compute flow
flow = cv2.calcOpticalFlowFarneback(prev
_
gray,gray,None,0.5,3,15,3,5,1.2,0)
prev
_
gray = gray
# plot the flow vectors
cv2.imshow(’Optical flow’,draw
_
flow(gray,flow))
if cv2.waitKey(10) == 27:
break
266
10.4. Tracking
C# Create PDF Library SDK to convert PDF from other file formats
What's more, you can also protect created PDF file by adding digital signature (watermark) on PDF using C# code.
copy and paste signature into pdf; pdf sign
DocImageSDK - How to Install .NET Imaging SDK
Help (RasterEdge Developer Guide6.0.pdf): a PDF file for DocImage SDK By Adding to Toolbox. As for RasterEdge Document Image Web Viewer more details, please see
add jpeg signature to pdf; pdf add signature field
Figure 10.5: Optical flow vectors (sampled at every 16th pixel) shown on video of a
translating book and a turning head.
This example will capture images from a webcam and call the optical flow estimation
on every consecutive pair of images. The motion flow vectors are stored in the two-
channel image flow returned by
calcOpticalFlowFarneback()
. Besides the previous
frame and the current frame, this function takes a sequence of parameters. Look
them up in the documentation if you are interested. The helper function
draw
_
flow()
plots the motion vectors at regularly sample points in the image. It uses the OpenCV
drawing functions
line()
and
circle()
and the variable step controls the spacing of
the flow samples. The result can look like the screenshots in Figure 10.5. Here the
positions of the flow samples are shown as a grid of green circles and the flow vectors
with lines show how each sample point moves.
The Lucas-Kanade algorithm
Tracking is the process of following objects through a sequence of images or video.
The most basic form of tracking is to follow interest points such as corners. A popular
algorithm for this is the Lucas-Kanade tracking algorithm which uses a sparse optical
flow algorithm.
Lucas-Kanade tracking can be applied to any type of features but usually makes
use of corner points similar to the Harris corner points in Section 2.1. The function
goodFeaturesToTrack()
detects corners according to an algorithm by Shi and Tomasi
[33] where corners are points with two large eigenvalues of the structure tensor (Har-
ris matrix) equation (2.2) and where the smaller eigenvalue is above a threshold.
The optical flow equation is under-determined (meaning that there are too many
unknowns per equation) if considered on a per-pixel basis. Using the assumption that
neighboring pixels have the same motion it is possible to stack many of these equations
10.4. Tracking
267
into one system of equations like this
2
6
6
4
rI
T
(x
1
)
rI
T
(x
2
)
.. .
rI
T
(x
n
)
3
7
7
5
v=
2
6
6
4
I
x
(x
1
) I
y
(x
1
)
I
x
(x
2
) I
y
(x
2
)
...
I
x
(x
n
) I
y
(x
n
)
3
7
7
5
u
v
2
6
6
4
I
t
(x
1
)
I
t
(x
2
)
.. .
I
t
(x
n
)
3
7
7
5
for some neighborhood of
n
pixels. This has the advantage that the system now has
more equations than unknowns and can be solved with least square methods. Typi-
cally, the contribution from the surrounding pixels is weighted so that pixels farther
away have less influence. A Gaussian weighting is the most commonchoice. This turns
the matrix above into the structure tensor in equation (2.2) and we have the relation
M
I
v=  
2
6
6
4
I
t
(x
1
)
I
t
(x
2
)
...
I
t
(x
n
)
3
7
7
5
or simpler Av = b .
This over-determined equation system can be solved in a least square sense and the
motion vector is given by
v= (A
T
A)
1
A
T
b .
This is solvable only when
A
T
A
is invertible, which it is by construction if applied at
Harris corner points or the "good features to track" of Shi-Tomasi. This is how the
motion vectors are computed in the Lucas-Kanade tracking algorithms.
Standard Lucas-Kanade tracking works for small displacements. To handle larger
displacements a hierarchical approach is used. In this case the optical flow is com-
puted at coarse to fine versions of the image. This is what the OpenCV function
calcOpticalFlowPyrLK()
does.
The Lucas-Kanade functions are included in OpenCV. Let’s look at how to use those
to build a Python tracker class. Create a file lktrack.py and add the following class
and constructor.
import cv2
# some constants and default parameters
lk
_
params dict(winSize=(15,15),maxLevel=2,
criteria=(cv2.TERM
_
CRITERIA
_
EPS | cv2.TERM
_
CRITERIA
_
COUNT,10,0.03))
subpix
_
params dict(zeroZone=(-1,-1),winSize=(10,10),
criteria = (cv2.TERM
_
CRITERIA
_
COUNT | cv2.TERM
_
CRITERIA
_
EPS,20,0.03))
feature
_
params dict(maxCorners=500,qualityLevel=0.01,minDistance=10)
268
10.4. Tracking
class LKTracker(object):
""" Class for Lucas-Kanade tracking with
pyramidal optical flow."""
def
__
init
__
(self,imnames):
""" Initialize with a list of image names. """
self.imnames = imnames
self.features = []
self.tracks = []
self.current
_
frame = 0
The tracker object is initialized with a list of filenames. The variables features and
tracks will hold the corner points and their tracked positions. We also use a variable
to keep track of the current frame. We define three dictionaries with parameters for
the feature extraction, the tracking, and the subpixel feature point refinement.
Now, to start detecting points, we need to load the actual image, create grayscale
version and extract the "good features to track" points. The OpenCV function doing
the main work is
goodFeaturesToTrack()
. Add this
detect
_
points()
method to the
class.
def detect
_
points(self):
""" Detect ’good features to track’ (corners) in the current frame
using sub-pixel accuracy. """
# load the image and create grayscale
self.image = cv2.imread(self.imnames[self.current
_
frame])
self.gray = cv2.cvtColor(self.image,cv2.COLOR
_
BGR2GRAY)
# search for good points
features = cv2.goodFeaturesToTrack(self.gray,
**
feature
_
params)
# refine the corner locations
cv2.cornerSubPix(self.gray,features,
**
subpix
_
params)
self.features = features
self.tracks = [[p] for p in features.reshape((-1,2))]
self.prev
_
gray = self.gray
The point locations are refined using
cornerSubPix()
and stored in the member vari-
ables features and tracks. Note that running this function clears the track history.
Now that we can detect the points, we also need to track them. First we need
to get the next frame, then apply the OpenCV function
calcOpticalFlowPyrLK()
that
finds out where the points moved and remove and clean the lists of tracked points.
10.4. Tracking
269
The method
track
_
points()
below does this.
def track
_
points(self):
""" Track the detected features. """
if self.features != []:
self.step() # move to the next frame
# load the image and create grayscale
self.image = cv2.imread(self.imnames[self.current
_
frame])
self.gray = cv2.cvtColor(self.image,cv2.COLOR
_
BGR2GRAY)
# reshape to fit input format
tmp = float32(self.features).reshape(-1, 1, 2)
# calculate optical flow
features,status,track
_
error = cv2.calcOpticalFlowPyrLK(self.prev
_
gray,
self.gray,tmp,None,
**
lk
_
params)
# remove points lost
self.features = [for (st,p) in zip(status,features) if st]
# clean tracks from lost points
features array(features).reshape((-1,2))
for i,f in enumerate(features):
self.tracks[i].append(f)
ndx = [for (i,st) in enumerate(status) if not st]
ndx.reverse() #remove from back
for i in ndx:
self.tracks.pop(i)
self.prev
_
gray = self.gray
This makes use of a simple helper method
step()
that moves to the next available
frame.
def step(self,framenbr=None):
""" Step to another frame. If no argument is
given, step to the next frame. """
if framenbr is None:
self.current
_
frame = (self.current
_
frame + 1) len(self.imnames)
else:
self.current
_
frame = framenbr len(self.imnames)
This method jumps to a given frame or just to the next if no argument is given.
Finally, we also want to be able to draw the result using OpenCV windows and
drawing functions. Add this
draw()
method to the
LKTracker
class.
270
10.4. Tracking
Documents you may be interested
Documents you may be interested