c# encrypt pdf : Extract table data from pdf to excel Library control API .net web page windows sharepoint import0-part1194

ImportingVectorGraphics:
ThegrImportPackageforR
PaulMurrell
TheUniversityofAuckland
Abstract
This introduction to the grImport package is a modified version of Murrell(2009),
which was published in the Journal of Statistical Software.
This article describes an approach to importing vector-based graphical images into
statistical software as implemented in a package called grImport for the R statistical com-
puting environment. This approach assumes that an original image can be transformed
into a PostScript format (i.e., the opriginal image is in a standard vector graphics format
suchas PostScript, PDF, or SVG). The grImport package consists of three components: a
function for converting PostScript files to an R-specific XML format; a function for read-
ing the XML format into special Picture objects in R; and functions for manipulating
and drawing Picture objects. Several examples and applications are presented, including
annotating a statistical plot with an imported logo and using imported images as plotting
symbols.
Keywords:˜PostScript, R, statistical graphics, XML.
1. Introduction
One of the important features of statistical software is the ability to create sophisticated
statistical plots of data. Software systems such as the lattice (Sarkar2008) package in R (R
Development Core Team 2008)canproducecompleximagesfromaverycompactexpression.
For example, the following code is all that is needed to produce the image in Figure1, which
shows density estimates for the number of moves in a set of chess games, broken down by the
result of the games.
R> xyplot(Freq ~ nmoves | result, data = chess.df, type = "h",
+
layout = c(1, 3), xlim = c(0, 100))
R>
On the other hand, statistical graphics software does not typically provide support for pro-
ducing more free-form or artistic graphical images. As a very simple example, it would be
difficult to produce an image of a chess piece, like the pawn shown in Figure2, using statistical
software.
In the case of R, there is a general polygon-drawing function, but determining the vertices
for the boundary of this pawn image would be non-trivial. These sorts of artistic images are
produced much more easily using the tools that are provided by drawing software such as
Extract table data from pdf to excel - extract form data from PDF in C#.net, ASP.NET, MVC, Ajax, WPF
Help to Read and Extract Field Data from PDF with a Convenient C# Solution
extract data from pdf to excel; pdf data extraction
Extract table data from pdf to excel - VB.NET PDF Form Data Read library: extract form data from PDF in vb.net, ASP.NET, MVC, Ajax, WPF
Convenient VB.NET Solution to Read and Extract Field Data from PDF
can reader edit pdf forms; exporting pdf form to excel
2
grImport: Importing Vector Graphics
nmoves
Freq
0
2
4
6
20
40
60
80
win
0
2
4
6
draw
0
2
4
6
loss
Figure 1: A statistical plot produced in R using the lattice package. The data are from chess
games involving Louis Charles Mahe De La Bourdonnais between 1821 and 1838 (original
source:http://www.chessgames.com/).
Figure 2: A free-form image of a chess pawn. This is an example of the sort of artistic graphic
that is difficult to produce using statistical software.
C# Word - MailMerge Processing in C#.NET
using RasterEdge.XDoc.Word; Execute MailMerge in OpenXML File with Data Source. Execute MailMerge in Microsoft Access Database by Using Data Source(X86 Only).
how to save fillable pdf form in reader; how to save editable pdf form in reader
C# PDF Convert to Word SDK: Convert PDF to Word library in C#.net
key. Quick to remove watermark and save PDF text, image, table, hyperlink and bookmark to Word without losing format. Powerful components
how to fill out pdf forms in reader; extracting data from pdf to excel
Paul Murrell
3
nmoves
Freq
0
2
4
6
20
40
60
80
win
0
2
4
6
draw
0
2
4
6
loss
Figure 3: The statistical plot from Figure1 with a pawn added to each panel.
the GIMP (KylanderandKylander1999,http://www.gimp.org/) or Inkscape (Bah2007,
http://www.inkscape.org/),nottomentionthatproducinganaestheticallypleasingresult
for this sort of image also requires a healthy dose of artistic skill.
However, there are situations where it is useful to be able to include artistic images as part
of a statistical plot. Figure3 demonstrates this sort of annotation by adding a pawn to each
panel of the plot from Figure1, to provide an additional visual cue as to whether the games
in the panel were won (white pawn), drawn (grey pawn) or lost (black pawn).
This is one example of the problem that is addressed in this article. Stating the issue more
generally, this article is concerned with the ability to import graphical images that have been
generated using third party software into a statistical software system so that the images
can be manipulated within the statistical software, including incorporating the images within
statistical plots.
1.1. Raster images versus vector images
There are two basic types of image formats: raster images and vector images. A raster image
consists of a matrix of pixels (picture elements) and the image is represented by recording a
separate color value for each pixel. A vector image consists of a set of mathematical shapes,
such as lines and polygons, and the image is represented by recording the locations and colors
of the shapes.
The images in Figure4 demonstrate the difference between raster and vector images. On the
left is a raster image of a circle both at normal size and magnified to show that the image is
made up of a set of square pixels. At an appropriate size, this image looks fine, but it does
not scale well. On the right is a vector version of the same image. At the smaller scale, this
image appears very similar to the raster image, but the zoomed portion shows that the vector
How to C#: Basic SDK Concept of XDoc.Word
Conversely, conversion from PDF to Word (.docx) is also supported. methods and events necessary to load a Word document from file or query data and save the
how to extract data from pdf file using java; filling out pdf forms with reader
C# PDF File Permission Library: add, remove, update PDF file
Field Data. Data: Auto Fill-in Field Data. Field: Insert NET convert PDF to text, VB.NET extract PDF pages, VB In the following code table, you will find a piece
sign pdf form reader; pdf form data extraction
4
grImport: Importing Vector Graphics
C# Image: C# Code to Upload TIFF File to Remote Database by Using
Create the Data Abstraction Layer. Drag and drop the REImageDatabase table from the server provide powerful & profession imaging controls, PDF document, image
pdf data extraction tool; how to flatten a pdf form in reader
C# PDF url edit Library: insert, remove PDF links in C#.net, ASP.
Easy to put link into specified position of PDF text, image and PDF table. Enable users to copy and paste PDF link. Help to extract and search url in PDF file.
extract pdf form data to excel; c# read pdf form fields
% start a new shape
to
% move to a start location
neto
% line to a new location
0 20 5 10 curveto % curve to a third location
Table 1: The file petal.ps, which contains PostScript code to draw a simple “petal” shape
(shown to the right of the code).
into R data structures; and drawing the R data structures. Each of these steps is described
in a separate section below.
2.1. PostScript to XML
The starting point for any import using this system is a PostScript file and the first step
in the import process is a conversion of this PostScript file to a new file in a special XML
(Bray,Paoli,Sperberg-McQueen,Maler,andYergeau2006) format called RGML (R Graphics
Markup Language).
The RGML format is specific to the grImport package. It is a very simple graphics format
that describes an image in terms that the R graphics system can understand. It will be
described in more detail in later sections.
As a simple example to follow through in detail, Table1 shows a file, petal.ps, that consists
of PostScript code for drawing a simple“petal”shape, which is shown to the right of the code
in Table1.
This simple example demonstrates some basic PostScript commands. A shape, called a path,
is defined by specifying lines and curves between a set of points and this shape is then filled
with a color.
Another common PostScript operation involves drawing just the boundary outline of the
shape. This could be achieved in the example in Table1 by replacing the command fill (the
last line of Table1) with the command stroke (PostScript calls drawing the outline stroking
apath).
The user interface provided by grImport for the conversion from PostScript to RGML format
is very simple, consisting of a single function, PostScriptTrace(). In the most basic usage,
the only required argument is the name of the PostScript file to convert, as in the code below.
The resulting RGML file, petal.ps.xml is shown in Table2.
R> PostScriptTrace("petal.ps")
R>
The RGML format in this example is roughly a one-to-one translation of the PostScript code.
The shape is recorded as a <path> element that has a type attribute with the value fill
indicating that the shape should be filled. The <context> element for this shape specifies the
VB.NET PDF url edit library: insert, remove PDF links in vb.net
position, such as PDF text, image and PDF table. Extract and search url in existing PDF file in VB including website, image, document, bookmark, PDF page number
using pdf forms to collect data; how to type into a pdf form in reader
VB.NET PDF File Permission Library: add, remove, update PDF file
Extract Field Data. Data: Auto Fill-in Field Data. Field: Insert & pages edit, C#.NET PDF pages extract, copy, paste In the following code table, you will find
extract table data from pdf to excel; pdf form save with reader
6
grImport: Importing Vector Graphics
<?xml version=
1.0
encoding=
ISO-8859-1
?>
<picture version=
3
xmlns:rgml=
http://r-project.org/RGML
source=
petal.ps
date=
2013-12-12 08:21:55
creator=
R (3.1.0)
>
<path type=
fill
id=
1
>
<context>
<rgb r=
0.0
g=
0.0
b=
0.0
/>
<style lwd=
10.0
lty=
lineend=
0
linemitre=
10.0
linejoin=
0
/>
</context>
<move y=
0.0
x=
0.0
/>
<line y=
100.0
x=
-50.0
/>
<line y=
109.082
x=
-53.9727
/>
<line y=
117.578
x=
-56.5703
/>
<line y=
125.488
x=
-57.8828
/>
<line y=
132.812
x=
-58.0078
/>
<line y=
139.551
x=
-57.0352
/>
<line y=
145.703
x=
-55.0547
/>
<line y=
151.27
x=
-52.1602
/>
<line y=
156.25
x=
-48.4375
/>
<line y=
160.645
x=
-43.9883
/>
<line y=
164.453
x=
-38.8945
/>
<line y=
167.676
x=
-33.25
/>
<line y=
170.312
x=
-27.1484
/>
<line y=
172.363
x=
-20.6836
/>
<line y=
173.828
x=
-13.9414
/>
<line y=
174.707
x=
-7.01953
/>
<line y=
175.0
x=
0.0
/>
<line y=
174.707
x=
7.01562
/>
<line y=
173.828
x=
13.9375
/>
<line y=
172.363
x=
20.6797
/>
<line y=
170.312
x=
27.1484
/>
<line y=
167.676
x=
33.2461
/>
<line y=
164.453
x=
38.8906
/>
<line y=
160.645
x=
43.9844
/>
<line y=
156.25
x=
48.4375
/>
<line y=
151.27
x=
52.1562
/>
<line y=
145.703
x=
55.0508
/>
<line y=
139.551
x=
57.0312
/>
<line y=
132.812
x=
58.0078
/>
<line y=
125.488
x=
57.8789
/>
<line y=
117.578
x=
56.5664
/>
<line y=
109.082
x=
53.9688
/>
<line y=
100.0
x=
50.0
/>
<line y=
100.0
x=
50.0
/>
<line y=
0.0
x=
0.0
/>
</path>
<summary count=
1
ymax=
175.0
ymin=
0.0
xmax=
58.0078
xmin=
-58.0078
/>
</picture>
Table 2: The file petal.ps.xml, which contains RGML code created by calling
PostScriptTrace() on the PostScript code in Table1.
VB Imaging - VB ISBN Barcode Tutorial
BarcodeType.ISBN 'set barcode data barcode.Data = "978047082163" 'set print ISBN on these files: PDF, TIFF, Microsoft with the properties from the table in the
how to extract data from pdf to excel; how to fill out a pdf form with reader
VB Imaging - VB Code 2 of 5 Generator
5 barcode size with parameters listed in the table below. quality Code 2 of 5 on PDF, TIFF, Microsoft of 5 type barcode encoding numeric data text "112233445566
extract data from pdf form; export pdf form data to excel
Paul Murrell
7
●●●● ● ● ● ●●●●●
Figure 5: The PostScriptTrace() function breaks a path into a series of locations on the
boundary of the path. This image shows how the curved petal shape from Table1 can be
converted into a set of points describing the outline of the petal shape.
colour to be used to fill the shape and then a series of <move> and <line> elements describe
the outline of the shape itself. A <summary> element provides information on how many paths
there are in the image, plus bounding box information.
One detail to notice is that the curveto in the PostScript file has become a series of <line>
elements in the RGML file. We will discuss this issue further in Section3. The main point
to focus on for now is that the image has become a set of (x, y) locations that describe the
outline of the shape in the image, as illustrated in Figure5.
One reason for choosing PostScript as the original format to focus on is that it is a sophis-
ticated graphics language. PostScript has commands to draw a wide variety of shapes and
PostScript provides advanced facilities to control the placement of shapes and to control
such things as the colors and line styles for filling and stroking the shapes. This means that
PostScript is capable of describing very complex images; by focusing on PostScript we should
be able to import virtually any vector image no matter how complicated it is.
This is not to say that PostScript is the most sophisticated graphics language—PDF and SVG
are also sophisticated graphics languages with various strengths and weaknesses compared to
PostScript. The point is that, amongst graphics formats, PostScript is one of the sophisticated
ones.
PostScript is also a complete programming language. As a simple demonstration of this,
Table3 shows a file, flower.ps, that contains PostScript code for drawing a simple “flower”
shape, which is shown to the right of the code in Table3.
The important feature of this PostScript code is that it defines a“macro”that describes how
to draw a petal, then it runs this macro five times (at five different angles) to produce the
overall flower.
This complexity presents an imposing challenge for us. How can we convert PostScript code
when the code can be extremely complicated? The approach taken by the grImport package
is to use the power of PostScript against itself.
The first part of the solution is based on the fact that it is possible to write PostScript code
that runs other PostScript code. The basis for the conversion from an original PostScript file
to an RGML file is a set of additional PostScript code that processes the original PostScript
file.
The other part of the solution is based on the fact that it is possible to redefine some of
the core PostScript commands. For example, the grImport PostScript code redefines the
meaning of the PostScript commands stroke and fill so that, instead of drawing shapes,
these commands print out information about the shapes that would have been drawn.
Table 4 shows a very simplified version of how the grImport PostScript conversion code
works. This code first defines a macro, printtwo that prints out two values. It also defines
8
grImport: Importing Vector Graphics
%!PS
/petal {
newpath
0 0 moveto
-5 10 lineto
-10 20 10 20 5 10 curveto
5 10 lineto
closepath
0 setgray
fill
} def
20 20 translate
5 {
petal 72 rotate
} repeat
showpage
Table 3: The file flower.ps, which contains PostScript code to draw a simple“flower”shape
(shown to the right of the code).
a macro, donothing, which does nothing. The next macro, fill, is the important one.
This is redefining the standard PostScript fill command. This macro, instead of filling a
shape, breaks any curves in the current path into short line segments (flattenpath), then it
calls the pathforall command. This command converts the current path into four possible
operations: a move, a line, a curve, or a closing of the path (joining the last location in the
path back to the first location in the path). The four values in front of pathforall specify
what to do for each of these operations. Overall, the code says that, if there is a move or a
line in the path, then we should print out two values (the position moved to or the position
“lined” to). For curves and closes, we do nothing. The final line of code in Table4 says to
run the PostScript code in the file petal.ps.
The PostScript code in the grImport package is a lot more complicated than the code in Table
4,butthisdemonstratesthemainidea.
At this point, we have new PostScript code that can process the original PostScript code and
print out information about the shapes in the original image. However, we still need software
to run the new PostScript code. The grImport package uses ghostscript for this purpose. For
example, the code below shows how to run the simplified conversion code in Table4, with the
resulting output shown below that. Several of the values printed out should be recognisable
from the PostScript code in the file petal.ps (see Table1).
$ gs -dBATCH -dQUIET -dNOPAUSE convert.ps
0.0 0.0
10.0 -5.0
10.41 -4.78
11.41 -4.14
12.64 -3.15
13.75 -1.87
Paul Murrell
9
%!PS
/printtwo {
/printnum {
100 mul round 100 div 20 string cvs print
} def
printnum
( ) print
printnum
(\n) print
} def
/donothing { } def
/fill {
flattenpath
{printtwo} {printtwo} {donothing} {donothing} pathforall
} def
(petal.ps) run
Table 4: The file convert.ps, which contains PostScript code to process the PostScript file
petal.ps.
14.39 -0.36
14.22 1.33
12.87 3.13
10.0 5.0
10.0 5.0
This dependence means that ghostscript must be installed for the grImport package to work,
but it is readily available for all major platforms. On Windows, the R_GSCMD environment
variable may also need to be set appropriately.
The beauty of this solution is that, no matter how complicated the PostScript code gets, it
ultimately calls stroke or fill to do the actual drawing. For example, the code in Table
3performs alooptodrawfivepetals,but we donot have to write codethat understands
PostScript loops; all we have to do is to ensure that whenever the PostScript code ultimately
tries to fill one of the petals, we intervene and simply print out the information about the
petal instead.
Table5 shows the RGML file that results from running PostScriptTrace() on the PostScript
code in the file flower.ps. Many of the <line> elements have been left out in order to show
the overall structure of the file.
R> PostScriptTrace("flower.ps")
R>
The overall effect is that the PostScript program in the file flower.ps has become a much
longer, but much simpler RGML file consisting simply of descriptions of the five shapes that
would have been drawn if the PostScript file had been viewed normally. The PostScript code
that is used to perform the conversion from the original PostScript file to an RGML file can
be found within the file PostScript2RGML.R of the grImport package.
10
grImport: Importing Vector Graphics
<?xml version=
1.0
encoding=
ISO-8859-1
?>
<picture version=
3
xmlns:rgml=
http://r-project.org/RGML
source=
flower.ps
date=
2013-12-12 08:21:55
creator=
R (3.1.0)
>
<path type=
fill
id=
1
>
<context>
<rgb r=
0.0
g=
0.0
b=
0.0
/>
<style lwd=
10.0
lty=
lineend=
0
linemitre=
10.0
linejoin=
0
/>
</context>
<move y=
200.0
x=
200.0
/>
...
<line y=
200.0
x=
200.0
/>
</path>
<path type=
fill
id=
2
>
<context>
<rgb r=
0.0
g=
0.0
b=
0.0
/>
<style lwd=
9.99999
lty=
lineend=
0
linemitre=
10.0
linejoin=
0
/>
</context>
<move y=
200.0
x=
200.0
/>
...
<line y=
200.0
x=
200.0
/>
</path>
<path type=
fill
id=
3
>
<context>
<rgb r=
0.0
g=
0.0
b=
0.0
/>
<style lwd=
10.0
lty=
lineend=
0
linemitre=
10.0
linejoin=
0
/>
</context>
<move y=
200.0
x=
200.0
/>
...
<line y=
200.0
x=
200.0
/>
</path>
<path type=
fill
id=
4
>
<context>
<rgb r=
0.0
g=
0.0
b=
0.0
/>
<style lwd=
10.0
lty=
lineend=
0
linemitre=
10.0
linejoin=
0
/>
</context>
<move y=
200.0
x=
200.0
/>
...
<line y=
200.0
x=
200.0
/>
</path>
<path type=
fill
id=
5
>
<context>
<rgb r=
0.0
g=
0.0
b=
0.0
/>
<style lwd=
9.99999
lty=
lineend=
0
linemitre=
10.0
linejoin=
0
/>
</context>
<move y=
200.0
x=
200.0
/>
...
<line y=
200.0
x=
200.0
/>
</path>
<summary count=
5
ymax=
375.0
ymin=
44.0938
xmax=
370.363
xmin=
29.6328
/>
</picture>
Table 5: The file flower.ps.xml, which contains RGML code created by calling
PostScriptTrace() on the PostScript code in Table3. Most of the <line> elements have
been removed and replaced with ... so that the overall structure of the complete file can be
displayed.
Documents you may be interested
Documents you may be interested