convert pdf to tiff using ghostscript c# : Add signature to pdf Library application component .net azure wpf mvc ProgrammingComputerVision_CCdraft11-part1283

Figure 4.3: A simple camera calibration setup. (left) an image of the setup used.
(right) the image used for the calibration. Measuring the width and height of the
calibration object in the image and the physical dimensions of the setup is enough to
determine the focal length.
translation) if the image contains a planar marker object. This is marker object can be
almost any flat object.
Let’s illustrate with an example. Consider the two top images in Figure 4.4, the
following code will extract SIFT features in both images and robustly estimate a ho-
mography using RANSAC.
import homography
import camera
import sift
# compute features
sift.process
_
image(book
_
frontal.JPG’,’im0.sift’)
l0,d0 = sift.read
_
features
_
from
_
file(im0.sift)
sift.process
_
image(book
_
perspective.JPG’,’im1.sift’)
l1,d1 = sift.read
_
features
_
from
_
file(im1.sift)
# match features and estimate homography
matches = sift.match
_
twosided(d0,d1)
ndx = matches.nonzero()[0]
fp = homography.make
_
homog(l0[ndx,:2].T)
ndx2 [int(matches[i]for i in ndx]
tp = homography.make
_
homog(l1[ndx2,:2].T)
model = homography.RansacModel()
= homography.H
_
from
_
ransac(fp,tp,model)
Now we have a homography that maps points on the marker (in this case the book)
4.3. PoseEstimation from Planes and Markers
111
Add signature to pdf - 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
pdf sign; pdf will signature
Add signature to pdf - 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
add jpeg signature to pdf; sign pdf online
in one image to their corresponding locations in the other image. Let’s define our
3D coordinate system so that the marker lies in the X-Y plane (
Z= 0
)with the origin
somewhere on the marker.
To check our results we will need some simple 3D object placed on the marker.
Here we will use a cube and generate the cube points using the function:
def cube
_
points(c,wid):
""" Creates a list of points for plotting
a cube with plot. (the first 5 points are
the bottom square, some sides repeated). """
= []
#bottom
p.append([c[0]-wid,c[1]-wid,c[2]-wid])
p.append([c[0]-wid,c[1]+wid,c[2]-wid])
p.append([c[0]+wid,c[1]+wid,c[2]-wid])
p.append([c[0]+wid,c[1]-wid,c[2]-wid])
p.append([c[0]-wid,c[1]-wid,c[2]-wid]#same as first to close e plot
#top
p.append([c[0]-wid,c[1]-wid,c[2]+wid])
p.append([c[0]-wid,c[1]+wid,c[2]+wid])
p.append([c[0]+wid,c[1]+wid,c[2]+wid])
p.append([c[0]+wid,c[1]-wid,c[2]+wid])
p.append([c[0]-wid,c[1]-wid,c[2]+wid]#same as first to close e plot
#vertical sides
p.append([c[0]-wid,c[1]-wid,c[2]+wid])
p.append([c[0]-wid,c[1]+wid,c[2]+wid])
p.append([c[0]-wid,c[1]+wid,c[2]-wid])
p.append([c[0]+wid,c[1]+wid,c[2]-wid])
p.append([c[0]+wid,c[1]+wid,c[2]+wid])
p.append([c[0]+wid,c[1]-wid,c[2]+wid])
p.append([c[0]+wid,c[1]-wid,c[2]-wid])
return array(p).T
Some points are reoccurring so that
plot()
will generate a nice looking cube.
With a homography and a camera calibration matrix, we can now determine the
relative transformation between the two views.
# camera calibration
= my
_
calibration((747,1000))
# 3D points at plane z=0 with sides of length 0.2
box = cube
_
points([0,0,0.1],0.1)
# project bottom square in first image
112
4.3. PoseEstimation from Planes and Markers
C# PDF Digital Signature Library: add, remove, update PDF digital
things. Add a signature or an empty signature field in any PDF file page. Search unsigned signature field in PDF document. Prepare
add signature pdf online; pdf signature stamp
VB.NET PDF Digital Signature Library: add, remove, update PDF
things. Add a signature or an empty signature field in any PDF file page. Search unsigned signature field in PDF document. Prepare
export pdf to word sign in; add signature to pdf in preview
cam1 = camera.Camera( hstack((K,dot(K,array([[0],[0],[-1]])) )) )
# first points are the bottom square
box
_
cam1 = cam1.project(homography.make
_
homog(box[:,:5]))
# use H to transfer points to the second image
box
_
trans = homography.normalize(dot(H,box
_
cam1))
# compute second camera matrix from cam1 and H
cam2 = camera.Camera(dot(H,cam1.P))
dot(linalg.inv(K),cam2.P[:,:3])
array([A[:,0],A[:,1],cross(A[:,0],A[:,1])]).T
cam2.P[:,:3] = dot(K,A)
# project with the second camera
box
_
cam2 = cam2.project(homography.make
_
homog(box))
# test: projecting point on z=0 should give the same
point array([1,1,0,1]).T
print homography.normalize(dot(dot(H,cam1.P),point))
print cam2.project(point)
Here we use a version of the image with resolution
747 ⇥1000
and first generate the
calibration matrix for that image size. Next points for a cube at the origin is created.
The first five points generated by
cube
_
points()
correspond to the bottom, which in
this case will lie on the plane defined by
Z = 0
, the plane of the marker. The first
image (top left in Figure 4.4) is roughly a straight frontal view of the book and will be
used as our template image. Since the scale of the scene coordinates is arbitrary, we
create a first camera with matrix
P
1
=K
2
4
1 0 0
0
0 1 0
0
0 0 1  1
3
5
,
which has coordinate axis aligned with the camera and placed above the marker. The
first five 3D points are projected onto the image. With the estimated homography we
can transform these to the second image. Plotting them should show the corners at
the same marker locations (see top right in Figure 4.4).
Now, composing
P
1
with
H
as a camera matrix for the second image,
P
2
=HP
1
,
will transform points on the marker plane
Z= 0
correctly. This means that the first
two columns and the fourth column of
P
2
are correct. Since we know that the first
3⇥ 3
block should be
KR
and
R
is a rotation matrix, we can recover the third column
4.3. PoseEstimation from Planes and Markers
113
C# PDF insert image Library: insert images into PDF in C#.net, ASP
How to insert and add image, picture, digital photo, scanned signature or logo into PDF document page in C#.NET class application?
add signature to pdf acrobat reader; add signature field to pdf
C# HTML5 Viewer: Load, View, Convert, Annotate and Edit PDF
HTML5 Viewer for C# .NET enables you to create signatures to PDF, including freehand signature, text and date signature. If you need to add your own signatures
add jpg signature to pdf; click to sign pdf
by multiplying
P
2
with the inverse of the calibration matrix and replacing the third
column with the cross product of the first two.
As a sanity check we can project a point on the marker plane with the new matrix
and check that it gives the same as the same point transformed with the first camera
and the homography. You should get the same printout in your console.
Visualizing the projected points can be done like this.
im0 array(Image.open(’book
_
frontal.JPG’))
im1 array(Image.open(’book
_
perspective.JPG’))
# 2D projection of bottom square
figure()
imshow(im0)
plot(box
_
cam1[0,:],box
_
cam1[1,:],linewidth=3)
# 2D projection transferred with H
figure()
imshow(im1)
plot(box
_
trans[0,:],box
_
trans[1,:],linewidth=3)
# 3D cube
figure()
imshow(im1)
plot(box
_
cam2[0,:],box
_
cam2[1,:],linewidth=3)
show()
This should give three figures like the images in Figure 4.4. To be able to reuse these
computations for future examples, we can save the camera matrices using Pickle.
import pickle
with open(’ar
_
camera.pkl’,’w’) as f:
pickle.dump(K,f)
pickle.dump(dot(linalg.inv(K),cam2.P),f)
Now we have seen how to compute the camera matrix given a planar scene object.
We combined feature matching with homographies and camera calibration to produce
asimple example of placing a cube in an image. With camera pose estimation, we now
have the building blocks in place for creating simple augmented reality applications.
4.4 Augmented Reality
Augmented reality (AR) is a collective term for placing objects and information on top
of image data. The classic example is placing a 3D computer graphics model so that
114
4.4. Augmented Reality
C# HTML5 Viewer: Load, View, Convert, Annotate and Edit Word
Convert Microsoft Office Word to searchable PDF online, create Viewer for C# .NET Signatures supports add signatures to Word and remove signature from Word
adding signature to pdf document; create signature from pdf
VB.NET PDF Library SDK to view, edit, convert, process PDF file
NET program. Password, digital signature and PDF text, image and page redaction will be used and customized. PDF Annotation Edit.
add signature to pdf file; add signature image to pdf acrobat
Figure 4.4: Example of computing the projection matrix for a new view using a planar
object as marker. Matching image features to an aligned marker gives a homography
that can be used to compute the pose of the camera. (top left) template image with
ablue square. (top right) an image taken from an unknown viewpoint with the same
square transformed with the estimated homography. (bottom) a cube transformed
using the estimated camera matrix.
4.4. Augmented Reality
115
C# WPF Viewer: Load, View, Convert, Annotate and Edit Tiff
functionalities. convert Tiff file to PDF, add annotations to Tiff, Create signature on tiff, etc. Please refer to more details below:
add signature box to pdf; adding a signature to a pdf document
C# WinForms Viewer: Load, View, Convert, Annotate and Edit Tiff
Viewer provides other utility features for processing Tiff while in preview, such as convert Tiff file to PDF, add annotations to Tiff, Create signature on tiff
create signature field in pdf; create pdf signature stamp
it looks like it belongs in the scene, and moves naturally with the camera motion in
the case of video. Given an image with a marker plane as in the section above, we
can compute the camera’s position and pose and use that to place computer graphics
models so that they are rendered correctly. In this last section of our camera chapter
we will show how to build a simple AR example. We will use two tools for this, PyGame
and PyOpenGL.
PyGame and PyOpenGL
PyGame is a popular package for game development that easily handles display win-
dows, input devices, events and much more. PyGame is open source and available
from http://www.pygame.org/. It is actually a Python binding for the SDL game en-
gine. For installation instructions, see the Appendix. For more details onprogramming
with PyGame, see for example [21].
PyOpenGL is the Python binding to the OpenGL graphics programming interface.
OpenGL comes pre-installed on almost all systems and is a crucial part for graph-
ics performance. OpenGL is cross platform and works the same across operating
systems. Take a look at http://www.opengl.org/ for more information on OpenGL.
The getting started page (http://www.opengl.org/wiki/Getting
_
started) has re-
sources for beginners. PyOpenGL is open source and easy to install, see the Ap-
pendix for details. More information can be found on the project website http:
//pyopengl.sourceforge.net/.
There is no way we can cover any significant portion of OpenGL programming,
we will instead just show the important parts, for example how to use camera ma-
trices in OpenGL and setting up a basic 3D model. Some good examples and de-
mos are available in the PyOpenGL-Demo package (http://pypi.python.org/pypi/
PyOpenGL-Demo). This is a good place to start if you are new to PyOpenGL.
We want to place a 3D model in a scene using OpenGL. To use PyGame and Py-
OpenGL for this application we need to import the following at the top of our scripts:
from OpenGL.GL import
*
from OpenGL.GLU import
*
import pygame, pygame.image
from pygame.locals import
*
As you can see we need two main parts from OpenGL. The GL part contains all func-
tions stating with "gl", which you will see are most of the ones we need. The GLU
part is the OpenGL Utility library and contains some higher-level functionality. We will
mainly use it to set up the camera projection. The
pygame
part sets up the window
and event controls, and
pygame.image
is used for loading image and creating OpenGL
textures. The
pygame.locals
is needed for setting up the display area for OpenGL.
116
4.4. Augmented Reality
.NET PDF SDK - Description of All PDF Processing Control Feastures
Create signatures in existing PDF signature fields; Create signatures in new fields which hold the signature; Add signature image to PDF file. PDF Hyperlink Edit
pdf add signature field; adding signature to pdf in preview
VB.NET PDF insert image library: insert images into PDF in vb.net
project. Import graphic picture, digital photo, signature and logo into PDF document. Add images to any selected PDF page in VB.NET.
add a signature to a pdf file; adding signature to pdf file
The two main components of setting up an OpenGL scene are the projection and
model view matrices. Let’s get started and see how to create these matrices from our
pin-hole cameras.
From camera matrix to OpenGL format
OpenGL uses
4⇥4
matrices to represent transforms (both 3D transforms and projec-
tions). This is only slightly different from our use of
3⇥ 4
camera matrices. However,
the camera-scenetransformations are separated in two matrices, the GL_PROJECTION
matrix and the GL_MODELVIEW matrix. GL_PROJECTION handles the image forma-
tion properties and is the equivalent of our internal calibration matrix
K
.GL_MODELVIEW
handles the 3D transformation of the relation between the objects and the camera.
This corresponds roughly to the
R
and
t
part of our camera matrix. One differ-
ence is that the coordinate system is assumed to be centered at the camera so the
GL_MODELVIEW matrix actually contains the transformation that places the objects
in front of the camera. There are many peculiarities with working in OpenGL, we will
comment on them as they are encountered in the examples below.
Given that we have a camera calibrated so that the calibration matrix
K
is known,
the following function translates the camera properties to an OpenGL projection ma-
trix.
def set
_
projection
_
from
_
camera(K):
""" Set view from a camera calibration matrix. """
glMatrixMode(GL
_
PROJECTION)
glLoadIdentity()
fx = K[0,0]
fy = K[1,1]
fovy = 2
*
arctan(0.5
*
height/fy)
*
180/pi
aspect = (width
*
fy)/(height
*
fx)
# define the near and far clipping planes
near = 0.1
far = 100.0
# set perspective
gluPerspective(fovy,aspect,near,far)
glViewport(0,0,width,height)
We assume the calibration to be of the simpler form in (4.3) with the optical cen-
ter at the image center. The first function
glMatrixMode()
sets the working ma-
4.4. Augmented Reality
117
trix to GL_PROJECTION and subsequent commands will modify this matrix
1
. Then
glLoadIdentity()
sets the matrix to the identity matrix, basically reseting any prior
changes. We then calculate the vertical field of view in degrees with the help of the
image height and the camera’s focal length as well as the aspect ratio. An OpenGL
projection also has a near and far clipping plane to limit the depth range of what is ren-
dered. We just set the near depth to be small enough to contain the nearest object and
the far depth to some large number. We use the GLU utility function
gluPerspective()
to set the projection matrix and define the whole image to be the view port (essen-
tially what is to be shown). There is also an option to load a full projection matrix
with
glLoadMatrixf()
similar to the model view function below. This is useful when
the simple version of the calibration matrix is not good enough.
The model view matrix should encode the relative rotation and translation that
brings the object in front of the camera (as if the camera was at the origin). It is a
4⇥4
matrix that typically looks like this
R t
0 1
,
where
R
is a rotation matrixwith columns equal to the direction of the three coordinate
axis and
t
is a translation vector. When creating a model view matrix the rotation part
will need to hold all rotations (object and coordinate system) by multiplying together
the individual components.
The following function shows how to take a
3⇥ 4
pin-hole camera matrix with the
calibration removed (multiply
P
with
K
1
)and create a model view.
def set
_
modelview
_
from
_
camera(Rt):
""" Set the model view matrix from camera pose. """
glMatrixMode(GL
_
MODELVIEW)
glLoadIdentity()
# rotate teapot 90 deg around x-axis so that z-axis is up
Rx array([[1,0,0],[0,0,-1],[0,1,0]])
# set rotation to best approximation
= Rt[:,:3]
U,S,V = linalg.svd(R)
dot(U,V)
R[0,:] = -R[0,:] # change e sign of x-axis
# set translation
1
This is an odd way to handle things, but there are only two matrices to switch between,
GL_PROJECTION and GL_MODELVIEW, so it is manageable.
118
4.4. Augmented Reality
= Rt[:,3]
# setup 4
*
4 model view matrix
eye(4)
M[:3,:3] = dot(R,Rx)
M[:3,3] = t
# transpose and flatten to get column order
= M.T
= M.flatten()
# replace model view with the new matrix
glLoadMatrixf(m)
First we switch to work on the GL_MODELVIEW matrix and reset it. Then we create
a 90 degree rotation matrix since the object we want to place needs to be rotated
(you will see below). Then we make sure that the rotation part of the camera matrix
is indeed a rotation matrix in case there are errors or noise when we estimated the
camera matrix. This is done with SVD and the best rotation matrix approximation is
given by
R= UV
T
. The OpenGL coordinate system is a little different so we flip the
x-axis around. Then we set the model view matrix M by multiplying the rotations.
The function
glLoadMatrixf()
sets the model view matrix and takes an array of the 16
values of the matrix taken column-wise. Transposing and then flattening accomplishes
this.
Placing virtual objects in the image
The first thing we need to do is to add the image (the one we want to place virtual
objects in) as a background. In OpenGL this is done by creating a quadrilateral, a
quad, that fills the whole view. The easiest way to do this is to draw the quad with
the projection and model view matrices reset so that the coordinates go from -1 to 1
in each dimension.
This function loads an image, converts it to an OpenGL texture and places that
texture on the quad.
def draw
_
background(imname):
""" Draw background image using a quad. """
# load background image (should be .bmp) to OpenGL texture
bg
_
image = pygame.image.load(imname).convert()
bg
_
data = pygame.image.tostring(bg
_
image,"RGBX",1)
glMatrixMode(GL
_
MODELVIEW)
glLoadIdentity()
4.4. Augmented Reality
119
glClear(GL
_
COLOR
_
BUFFER
_
BIT | GL
_
DEPTH
_
BUFFER
_
BIT)
# bind the texture
glEnable(GL
_
TEXTURE
_
2D)
glBindTexture(GL
_
TEXTURE
_
2D,glGenTextures(1))
glTexImage2D(GL
_
TEXTURE
_
2D,0,GL
_
RGBA,width,height,0,GL
_
RGBA,GL
_
UNSIGNED
_
BYTE,bg
_
data)
glTexParameterf(GL
_
TEXTURE
_
2D,GL
_
TEXTURE
_
MAG
_
FILTER,GL
_
NEAREST)
glTexParameterf(GL
_
TEXTURE
_
2D,GL
_
TEXTURE
_
MIN
_
FILTER,GL
_
NEAREST)
# create quad to fill the whole window
glBegin(GL
_
QUADS)
glTexCoord2f(0.0,0.0); glVertex3f(-1.0,-1.0,-1.0)
glTexCoord2f(1.0,0.0); glVertex3f( 1.0,-1.0,-1.0)
glTexCoord2f(1.0,1.0); glVertex3f( 1.0, 1.0,-1.0)
glTexCoord2f(0.0,1.0); glVertex3f(-1.0, 1.0,-1.0)
glEnd()
# clear the texture
glDeleteTextures(1)
This function first uses some PyGame functions to load an image and serialize it to a
raw string representation that can be used by PyOpenGL. Then we reset the model
view and clear the color and depth buffer. Next we bind the texture so that we can use
it for the quad and specify interpolation. The quad is defined with corners at -1 and 1
in both dimensions. Note that the coordinates in the texture image goes from 0 to 1.
Finally, we clear the texture so it doesn’t interfere with what we want to draw later.
Now we are ready to place objects in the scene. We will use the "hello world"
computer graphics example, the Utah teapot http://en.wikipedia.org/wiki/Utah
_
teapot. This teapot has a rich history and is available as one of the standard shapes
in GLUT:
from OpenGL.GLUT import
*
glutSolidTeapot(size)
This generates a solid teapot model of relative size size.
The following function will set up the color and properties to make a pretty red
teapot.
def draw
_
teapot(size):
""" Draw a red teapot at the origin. """
glEnable(GL
_
LIGHTING)
glEnable(GL
_
LIGHT0)
glEnable(GL
_
DEPTH
_
TEST)
glClear(GL
_
DEPTH
_
BUFFER
_
BIT)
# draw red teapot
120
4.4. Augmented Reality
Documents you may be interested
Documents you may be interested