c# encrypt pdf : Extract data out of pdf file software application cloud windows html azure class import1-part1195

Paul Murrell
Figure 6: A modified version of the original flower shape from Table3, with the fill color
changed to blue.
At this point, there might appear to be little cause for celebration. All that we have managed
to achieve is to convert the PostScript file into an RGML file. It is important to highlight
how much closer that has taken us to working with the image in R.
The main point is that the RGML format is simple. An RGML file only contains shape
descriptions, so all R has to do is read the information about each shape and draw it. It
is also important that the shape descriptions are simple enough for R to be able to draw
(the R graphics system does not have some of the sophisticated features of the PostScript
format). With the XML package (TempleLang2008), reading an XML file into R is relatively
straightforward and R has facilities for drawing each of the shapes in the RGML file.
Asecondary point is that the RGML format is XML code. This is useful because XML can
be produced and consumed by many different software systems. For example, it would be
quite straightforward to write XSL (Clark 1999) code that would convert an RGML file to
SVG with the help of the xsltproc utility from the libxslt library (Veillard2009) or using any
other XSL processor.
Another important class of software that can work with XML documents is text editor soft-
ware. One of the nice features of XML code is that it can be viewed and modified with very
elementary tools. In this context, basic image editing can be performed with a text editor.
The XML package makes it possible to process the raw XML in a bewildering variety of ways.
As a simple example, the following R code uses an XPath expression to select the <rgb>
elements in the RGML file flower.ps.xml then modifies them so that the flower is filled with
ablue color instead of being black. The modified flower image is shown in Figure6.
R> flowerRGML <- xmlParse("flower.ps.xml")
R> xpathApply(flowerRGML, "//path//rgb",
value = c(r = .3, g = .6, b = .8))
R> saveXML(flowerRGML, "blueflower.ps.xml")
Afinal point is that once the image has been converted into the RGML format, there is no
further need for ghostscript. The image can be freely shared between users, with the only
requirement being the availability of R (and the XML package).
In summary, the grImport package provides a function called PostScriptTrace(), which
uses ghostscript to process an original PostScript file and convert it into an RGML file.
2.2. XML to R
The next step in importing a PostScript image into R involves reading the RGML format
into R. As mentioned previously, reading XML files is straightforward with the XML package.
However, the R objects that are generated by the functions in the XML package are very
Extract data out of pdf file - 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
how to make pdf editable form reader; how to make a pdf form fillable in reader
Extract data out of pdf file - 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
flatten pdf form in reader; online form pdf output
grImport: Importing Vector Graphics
general-purpose, so the grImport package provides a function that produces an R object that
is specifically designed for representing a graphical image.
The function used to read RGML files is called readPicture(). This function has only one
argument, which is the name of the RGML file. The following code uses this function to read
the petal image from the file petal.ps.xml.
R> petal <- readPicture("petal.ps.xml")
The resulting object, petal, is a Picture object, with two slots: one slot contains all of the
paths from the image and the other slot contains the summary information about the image.
In this case, there is only one path and it is a PictureFill object (i.e., a shape that should
be filled with a color).
R> str(petal)
Formal class
[package "grImport"] with 2 slots
..@ paths :List of 1
.. ..$ path:Formal class
[package "grImport"] with 9 slots
.. .. .. ..@ rule
: chr "nonzero"
.. .. .. ..@ x
: Named num [1:36] 0 -50 -54 -56.6 -57.9 ...
.. .. .. .. ..- attr(*, "names")= chr [1:36] "move" "line" "line" "line" ...
.. .. .. ..@ y
: Named num [1:36] 0 100 109 118 125 ...
.. .. .. .. ..- attr(*, "names")= chr [1:36] "move" "line" "line" "line" ...
.. .. .. ..@ rgb
: chr "#000000"
.. .. .. ..@ lty
: num(0)
.. .. .. ..@ lwd
: num 10
.. .. .. ..@ lineend : num 1
.. .. .. ..@ linejoin : num 1
.. .. .. ..@ linemitre: num 10
..@ summary:Formal class
[package "grImport"] with 3 slots
.. .. ..@ numPaths: num 1
.. .. ..@ xscale : Named num [1:2] -58 58
.. .. .. ..- attr(*, "names")= chr [1:2] "xmin" "xmax"
.. .. ..@ yscale : Named num [1:2] 0 175
.. .. .. ..- attr(*, "names")= chr [1:2] "ymin" "ymax"
The Picture object has a clear one-to-one correspondence with the information in the XML
file and, again, we might question what we have gained by generating this object. Why not
just draw the information from the RGML file directly?
The main reason for having the special S4 class of Picture objects in R is that we can work
with the image using all of the powerful data processing tools that are available in R. One
specific example that is explicitly supported by the grImport package is the ability to subset
paths from an image.
As a simple example of subsetting, consider the Picture object that is generated by reading
in the RGML file that was generated from the PostScript file flower.ps (see Table5). Only
the summary information for this Picture object is shown.
C# PDF Text Extract Library: extract text content from PDF file in
class. Able to extract and get all and partial text content from PDF file. Ability to extract highlighted text out of PDF document.
extract table data from pdf; extract data from pdf table
VB.NET PDF Text Extract Library: extract text content from PDF
NET Programming. Extract and get partial and all text content from PDF file. Extract highlighted text out of PDF document. Image text
how to fill in a pdf form in reader; extract data from pdf file to excel
Paul Murrell
Figure 7: Two of the petals from the original flower shape in Table3.
R> PSflower <- readPicture("flower.ps.xml")
R> str(PSflower@summary)
Formal class
[package "grImport"] with 3 slots
..@ numPaths: num 5
..@ xscale : Named num [1:2] 29.6 370.4
.. ..- attr(*, "names")= chr [1:2] "xmin" "xmax"
..@ yscale : Named num [1:2] 44.1 375
.. ..- attr(*, "names")= chr [1:2] "ymin" "ymax"
This Picture object has five paths, corresponding to the five petals. A subsetting method
for Picture objects is defined by the grImport package so that we can extract just some of
the petals from the image as shown in the code below.
R> petals <- PSflower[2:3]
The result is a new Picture object consisting of just the second and third paths from the
originalPicture object. As the code below shows,the summary information has beenupdated
as well.
R> str(petals@summary)
Formal class
[package "grImport"] with 3 slots
..@ numPaths: int 2
..@ xscale : num [1:2] 29.6 200
..@ yscale : num [1:2] 44.1 297.4
Visually, the new picture is just the second and third petals from the original image, as shown
in Figure7.
In more complex images, it is often less obvious which path corresponds to a particular shape
within an image, so some trial and error may be necessary. Section3 discusses this issue in
more detail.
Another advantage of having an S4 class for representing the image information is that this
provides yet another way to store and share the image, via R’s save() and load() functions,
and one that no longer relies on the availability of the XML package.
In summary, the grImport package provides a function readPicture() that reads an RGML
file and creates a Picture object. Picture objects are used to draw the image, but they can
C# HTML5 PDF Viewer SDK to view PDF document online in C#.NET
Extract Field Data. Data: Auto Fill-in Field Data. Field: Insert VB.NET convert PDF to text, VB.NET extract PDF pages, VB Support to zoom in and zoom out PDF page
save pdf forms in reader; extract data from pdf form to excel
VB.NET PDF- View PDF Online with VB.NET HTML5 PDF Viewer
Extract Field Data. Data: Auto Fill-in Field Data. Field: Insert file & pages edit, C#.NET PDF pages extract, copy, paste Support to zoom in and zoom out PDF page
extract data from pdf c#; collect data from pdf forms
grImport: Importing Vector Graphics
also be manipulated to modify the image. For example, a Picture object can be subsetted
to extract individual paths from the overall image.
2.3. R to grid
Having read an RGML file into R as a Picture object, the final step is to draw the Picture
object. Conceptually, this step is very straightforward. A path is just a set of (x,y) pairs
and R graphics functions such as lines() and polygon() in the graphics package, and
grid.lines() and grid.polygon() in the grid package, can be used to stroke or fill these
paths (Murrell2005).
The main inconvenience in this step lies in dealing with coordinate systems. As the code
below demonstrates for the petal Picture, the (x,y) locations for an image can be on an
arbitrary scale.
R> petal@summary@xscale
-58.0078 58.0078
R> petal@summary@yscale
ymin ymax
0 175
In order to position and size the image in useful ways, the (x,y) locations for the paths need
to be scaled. Viewports in the grid package provide a convenient way to establish appropriate
coordinate systems for drawing, so the grImport package provides several functions based on
grid for drawing Picture objects.
The first of these, the grid.symbols() function, can be used to draw several copies of a
Picture object at a set of (x,y) locations and at a specified size. The following code makes
use of this function to draw the PSflower image as data symbols on a lattice scatterplot (see
Figure8). The important arguments are the Picture object to draw, the (x,y) locations (and
the coordinate system that those locations refer to), and the size of the individual images (in
this case, each flower image is 5
R> library("cluster")
R> xyplot(V8 ~ V7, data = flower,
xlab = "Height", ylab = "Distance Apart",
panel = function(x, y, ...) {
grid.symbols(PSflower, x, y, units = "native",
size = unit(5, "mm"))
C# PDF Form Data fill-in Library: auto fill-in PDF form data in C#
Able to fill out all PDF form field in C# RasterEdge XDoc.PDF SDK package provides PDF field processing features for will learn how to fill-in field data to PDF
pdf data extraction open source; cannot save pdf form in reader
C# WPF PDF Viewer SDK to view PDF document in C#.NET
Extract Field Data. Data: Auto Fill-in Field Data. Field: Insert & pages edit, C#.NET PDF pages extract, copy, paste, C# Abilities to zoom in and zoom out PDF page
how to save a filled out pdf form in reader; export pdf form data to excel spreadsheet
Paul Murrell
Distance Apart
Figure 8: A statistical plot produced in R using the lattice package, with an imported“flower”
image used as the plotting symbol. The data are the heights of 18 popular flower varieties
and the distance that should be left between plants when sowing seeds. These data are in a
data frame called flower in the cluster package.
This example also demonstrates one of the major reasons for going to all of the effort to
import an image into R in order to combine it with an R plot. An alternative approach to
adding an image to a plot is to only create the plot using R and then combine that plot with
other images using tools such as ImageMagick’s compose utility. However, the problem with
that approach is that it is impractical, if not impossible, to position the images relative to
the coordinate systems within the plot. By importing an image to R, the image can be drawn
within the same set of coordinate systems that are usedto produce the plot, so the positioning
of images is straightforward and accurate.
In additiontothe grid.symbols() function,the grImport package alsoprovides agrid.picture()
function. This is used to add a single copy of an image to a page. The grid.picture()
function also provides a little more flexibility in how the image is drawn, compared to the
grid.symbols() function; an example of this flexibility will be described in Section3.7.
As a simple demonstration of the grid.picture() function, the following code converts,
reads, and draws the“tiger”example PostScript file that is distributedwith ghostscript (minus
its grey background rectangle). The tiger image in Figure9 is produced by R.
R> PostScriptTrace("tiger.ps")
R> tiger <- readPicture("tiger.ps.xml")
R> grid.picture(tiger[-1])
In summary, the grImport package provides two functions for drawing Picture objects:
VB.NET PDF - View PDF with WPF PDF Viewer for VB.NET
Extract Field Data. Data: Auto Fill-in Field Data. Field: Insert & pages edit, C#.NET PDF pages extract, copy, paste, C# Abilities to zoom in and zoom out PDF page
extract pdf data to excel; pdf data extraction to excel
VB.NET PDF- HTML5 PDF Viewer for VB.NET Project
Extract Field Data. Data: Auto Fill-in Field Data. Field: Insert VB.NET convert PDF to text, VB.NET extract PDF pages, VB PDF page and zoom in or zoom out PDF page
vb extract data from pdf; pdf data extractor
grImport: Importing Vector Graphics
Figure 9: A tiger image from the ghostscript distribution that has been imported and drawn
using R.
grid.picture() and grid.symbols(). The grid.picture() function draws a single copy of
the Picture at a particular location and size and the grid.symbols() function draws several
copies of the Picture at a set of (x,y) locations.
The overall steps involved in importing an original image into R are as follows: generate a
PostScript version of the original image; use PostScriptTrace() to convert the image to an
RGML format; use readPicture() to read the RGML file into a Picture object; and use
grid.picture() or grid.symbols() to draw the Picture object.
3. Further details
The previous sectionprovided an overview of the structure of the grImport solutionto import-
ing vector graphics into statisticalsoftware. In order to make that overview as straightforward
as possible, some important details were ignored; this section fills in some additional details
about how the grImport package works.
3.1. Flattening PostScript paths
The PostScript language provides four basic operations for constructing a path: move to a
location, draw a (straight) line to a location, draw a curve to a location, and show text at a
location. The discussion in Section2 only properly addressed moving and drawing lines. The
simple petal image and flower image examples did actually include paths with curves, but
that was not properly dealt with. We will now look more closely at how curves in PostScript
files are handled by grImport. Section3.2 will deal with text.
Looking again at the PostScript code in Table1, the path that describes the petal image
consists of a move to the location (0,0), followed by a line to the location (−5,10), followed
VB.NET PDF - WPF PDF Viewer for VB.NET Program
Field Data. Data: Auto Fill-in Field Data. Field: Insert & pages edit, C#.NET PDF pages extract, copy, paste rotate PDF pages, zoom in or zoom out PDF pages and go
pdf form field recognition; how to save a pdf form in reader
VB.NET PDF File & Page Process Library SDK for vb.net, ASP.NET
Moreover, when you get a PDF document which is out of order, you need to adding a page into PDF document, deleting unnecessary page from PDF file and changing
export excel to pdf form; extracting data from pdf files
Paul Murrell
(−5, 10)    
(−10, 20)   
(10, 20)
(5, 10)
Figure 10: An illustration of how a bezier curve is drawn relative to four control points.
Figure 11: An illustration of how the import process “flattens”a bezier curve into a series of
straight lines.
by a curve. The PostScript code describing the curve is reproduced below.
-10 20 10 20 5 10 curveto
This curve creates the nice round“end” for the petal shape.
In PostScript, these curves are cubic B´ezier curves; a smoothcurve is drawn from the previous
location, in this case (−5,10), to the last location mentioned in the curveto command,(5,10),
with the other two locations, (−10,20) and (10,20), specifying control points that control the
shape of the curve. Specifically, the start of the curve is tangent to a line joining the first two
locations and the end of the curve is tangent to a line joining the last two locations, as shown
in Figure10.
Unfortunately, the R graphics system cannot natively draw B´ezier curves, and it does not have
the notion of a general path consisting of both straight lines and curves; it can only draw
a series of straight lines. Consequently, the conversion performed by PostScriptTrace()
breaks, or flattens, any curves into many short straight lines, as shown in Figure11.
In this way, the paths in an RGML file only consist of movements and lines, as can be seen
by looking at the RGML code in Table2.
This flattening of curves is not ideal because, although the resulting straight lines appear to
the eye as a smooth curve, under certain conditions, for example at large magnification or
when lines are very thick, the corners where the straight lines meet can become noticeable.
Because of this, PostScriptTrace() has an argument called setflat, which controls how
many straight lines the curve is broken into. Larger values (up to a maximum of 100) result
in fewer straight lines and smaller values (down to a minimum of 0.2) result in more straight
lines. The downside of a small value of setflat is that the RGML file will be much larger
because there will be many more <line> elements produced.
grImport: Importing Vector Graphics
/Times-Roman findfont
10 scalefont
0 0 moveto
(hello) show
Figure 12: The file hello.ps, which contains PostScript code to draw the word “hello”in a
Times Roman font. The resulting image is shown to the right of the PostScript code.
Figure 13: An illustration of the different ways that text can be imported: as filled shapes
(left); or as character glyphs from a font (right).
3.2. Text
The previous section explained how PostScript curves are handled by grImport, but the
ability to display text in a PostScript file has been completely ignored up to this point. That
omission is rectified in this section.
One reason for ignoring text in PostScript files is because the main focus of this article is on
importing images that are made up of shapes rather than text
Another good reason for ignoring text in PostScript files is the fact that importing text is
hard. In particular it is very difficult to replicate the exact font that is used in the original
PostScript file because that information can be extremely complex.
Despite these objections, the grImport package provides two simple approaches to importing
text from a PostScript image. Neither of these approaches is ideal, but they may be better
than nothing for certain images.
As a simple example to demonstrate these approaches, we will work with the file shown in
Figure12, which displays the word“hello” in a Times Roman font.
The first approach to importing this text into R is to convert each character in the text into
(flattened) paths. The advantage of this approach is that the resulting text will look quite a
lot like the original text because it will be based on the actual outlines of the characters in
the original text (see the text on the left of Figure13).
R> PostScriptTrace("hello.ps", "hello.xml")
R> hello <- readPicture("hello.xml")
R> grid.picture(hello)
There are several drawbacks to this approach. The first is that translating each individual
letter of text into its own path can result in a very large RGML file. The second problem
is that drawing text by filling paths is not the same as drawing text using fonts because the
Paul Murrell
latter uses sophisticated techniques, such as font hinting to make things look nice, especially
at small font sizes. There may also be problems with this approach if the font does not permit
copying or modifying the font outlines.
The other approach to importing text from a PostScript file is to completely ignore the font
that is being used and just import the actual character values from the file. The charpath
argument to the PostScriptTrace() function is used to trigger this option. When drawing
the resulting text, grImport attempts to get the size of the text roughly the same as the
original, but differences in fonts will mean that the location and size of text will not be
identical. The following code imports just the text from the file hello.ps and the resulting
image is approximately the right size, but uses a completely different font (see the text on
the right of Figure13).
R> PostScriptTrace("hello.ps",
charpath = FALSE)
R> hellotext <- readPicture("hellotext.xml")
R> grid.picture(hellotext)
The vignette “Importing Text” provides more details about importing text, including some
other options for fine-tuning the size and placement of imported text.
One problem that can completely stymie attempts to import text from a PostScript file is
that some font outlines are“protected”by the font creator, which means that the font outline
cannot be converted to flattened paths, so they will resist grImport’s attempts to extract
3.3. Bitmaps
As mentioned back in Section 1.2, PostScript is really a meta format rather than just a
vector graphics format, which means that a PostScript file can contain raster elements as
well as shapes and text. Currently, grImport will completely ignore any raster elements in a
PostScript file.
3.4. Graphical parameters
The description of an image in a PostScript file consists of a description of shapes, or paths,
plus a description of whether to stroke or fill each path, plus a description of what colors and
line styles to use when filling or stroking each path. This section addresses the last part: how
does grImport handle importing graphical parameters such as colors and line styles?
Whenever a path is converted from PostScript to RGML, in addition to recording the set of
locations that describe the path, PostScriptTrace() records the color, as an RGB triplet,
and the line width that are used to stroke or fill the path. A minor detail is that the line
width is scaled up by a factor of 4/3 because a line width of 1 corresponds to 1/72 inches in
PostScript, but a line width of 1 corresponds to roughly 1/96 inches on R graphics devices.
By default, the colors and line widths that are recorded in the RGML file are used when draw-
ing the image in R. This was vividly demonstrated on page15 with the tiger image. However,
grImport: Importing Vector Graphics
Figure 14: A modification of the flower shape from Table3, with each petal drawn just in
outline rather than being filled.
both the grid.picture() and grid.symbols() functions provide a use.gc argument that
allows the default graphical parameters to be overridden. As a simple example, the following
code draws just the outline of the flower image by turning off the default graphical parameter
settings and specifying a transparent fill and a black border instead (see Figure14).
R> grid.picture(PSflower,
use.gc = FALSE,
gp = gpar(fill = NA, col = "black"))
The following code demonstrates a similar usage of grid.symbols(), except in this case the
black fill has been retained and a white border has been added. This makes it is easier to see
where flower images overlap within the plot. Figure15 shows the resulting plot.
R> xyplot(V8 ~ V7, data = flower,
xlab = "Height", ylab = "Distance Apart",
panel=function(x, y, ...) {
grid.symbols(PSflower, x, y, units = "native",
size = unit(5, "mm"),
use.gc = FALSE,
gp = gpar(col = "white", fill = "black", lwd = .5))
3.5. The RGML format
This section provides a more complete description of the structure of RGML files, which may
be helpful for working directly with RGML files, for example, using R functions other than
those provided by the grImport package or when using other software altogether.
The root element for an RGML file is a <picture> element. This element will have a version
attribute that distinguishes betweendifferent versions of the RGML format, plus several other
attributes that describe the provenance of the file.
The content of the <picture> element will typically consist mostly of <path> elements. Each
<path> element is made upof <move> elements and <line> elements that describe a shape and
the type attribute of the <path> element is typically either "fill" or "stroke" to indicate
whether that shape should be filled or stroked. Each <move> and <line> element has two
attributes, x and y, which provide the location of a vertex on the boundary of the shape that
is being described.
Each <path> element also contains a <context> element, which in turn contains an <rgb>
element and a <style> element, with information about the color, line width, and line type
that should be used to fill or stroke the path.
Documents you may be interested
Documents you may be interested