c# pdf to image : Extract table data from pdf to excel control SDK platform web page wpf winforms web browser final2-part324

Final Report                           PDF
TO 
HTML
C
ONVERSION
Page 15 
 Design and implementation 
This  section  details  the  steps  taken  in  designing  and  implementing  the  conversion 
software.  As the author had decided to attempt a new approach, it was not possible to 
produce a complete design at the outset.  Instead, small sections of the program were 
designed and implemented at a time.  Many of the later features were included as a 
result  of  viewing  the  program’s  output  and  carrying  out  modifications  and 
improvements where necessary. 
Section 4.1  briefly describes the  class  hierarchy  in  which  the  program is organized.  
Sections  4.2  and  4.3  describe  the  two  main  processes  in  converting  from  PDF  to 
HTML,  text  extraction  and  text  merging.    The  next  two  sections  describe 
improvements to the implementation to cope with more complex PDF files; section 4.4 
describes the modifications made to cope with multi-column layouts and section 4.5 
describes a number other features in the layout, such as hyphenation and line spacing, 
and how they have been understood by the conversion software.  The final section, 4.6, 
describes the front end’s role in the implementation. 
4.1  Class hierarchy 
The  class  PdfGenericGrouping  was  provided  in  JPedal  as  a  base  class  for  which 
grouping and merging routines could be added.  The PdfGrouping class was written to 
extend PdfGenericGrouping, adding merging, ordering and other routines necessary for 
the conversion software, as shown below. 
org
jpedal
grouping
PdfGeneric
Grouping
PdfGrouping
Fig 4.1: PdfGrouping: class hierarchy 
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 c#; how to fill out pdf forms in reader
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
c# read pdf form fields; pdf data extraction open source
PDF
TO 
HTML
C
ONVERSION
           Final Report 
Page 16 
The main method, processPageFragments, is used to interface between the front end 
and PdfGrouping itself.  It was designed to replace the method decodePageFragments 
from  PdfGenericGrouping  although  decodePageFragments  is  still  accessible  if  un-
merged data is sought. 
The only method that has been replaced is getUnusedFragments as it was necessary to 
pass a value, usedFragments, in order for it to function properly.  Otherwise the code 
remains identical to that included in PdfGenericGrouping. 
The  front  end,  pdf2html,  requires  PdfGrouping  and  all  its  dependencies  but  is 
otherwise stand-alone. 
4.2  Text extraction principles 
The general procedure to open a PDF file and extract text fragments with JPedal is 
shown below. 
Open PDF file
Create instance of
PdfDecoder object
Get page count
Decode page(s)
PdfDecoder.openPdfFile( filename )
Constructor 
PdfDecoder( false )
PdfDecoder.getPageCount()
PdfDecoder.decodePage(false,  pageno )
Task
Method
Get data object
decode_pdf.getPdfData()
Run merging/grouping
algorithm
pdf_grouping.processPageFragments
(data_object ,  pageno ,  column_flag )
Get text element count
data_object .getTextElementCount()
Extract individual text
elements
data_object .getTextElementAt( position )
Extract data from text
elements
text_element .getAttributeValue( attribute )
Fig 4.2: Text extraction process 
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).
exporting pdf form to excel; extracting data from pdf to excel
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
extracting data from pdf forms; saving pdf forms in acrobat reader
Final Report                           PDF
TO 
HTML
C
ONVERSION
Page 17 
Text in a PDF is held as a series of text fragments.  These fragments may be written to 
the PDF file (and hence extracted by JPedal) in any order.  Each text fragment usually 
contains  one  full  line  of  text  although  changes  in  formatting  and  the  inclusion  of 
certain symbols require the line to be separated into separate fragments.  Some PDF file 
creators place each word or character as a separate fragment. 
Each  text  fragment  is  held  as  an  XML  Element,  containing  the  various  attributes 
holding information about the text fragment itself.  The only attribute used at this stage 
was  content,  which  was  a  string  including  the  text  embedded  in  XML/HTML 
formatting information, START and END tags, as shown below: 
<~START><FONT face="Minion-Regular" style="font-size:12pt">The quick 
brown fox jumps over the lazy dog</FONT><~END> 
Fig 4.3: Example of output from JPedal 
It is therefore necessary to process the string to separate the text from the formatting 
information and the method textOf does this.  Other data, such as co-ordinates and 
font size information, were accessed directly from the arrays by the PdfGrouping class. 
4.3  Text merging principles 
The processPageFragments method in the PdfGrouping class performs the text merging 
procedure, calling other methods in the PdfGrouping class and interfacing between the 
front end and the library. 
In the PdfGrouping class text fragment data is held in a number of arrays, each being 
the same size as the total number of text fragments.  The contents of these arrays is 
updated  when  the  copyToFragmentArrays  method is  called at  the  beginning of the 
processPageFragments  method.    Each  array holds  information  about  one  particular 
attribute and data about a particular text fragment is held in the same index across all 
the arrays.  Hence heights[36], f_start_font_size[36], contents[36] and text_length[36] 
are all attributes of the same text fragment. 
The attributes that were used in the grouping and merging algorithms include: 
•  contents[]: the actual text embedded in XML/HTML formatting information 
•  f_x1[], f_x2[], f_y1[], f_y2[]: co-ordinates of the bounding box of the text fragment 
•  heights[]: the height of the text fragment 
•  f_start_font_size[] and f_end_font_size[]: start and end font sizes respectively 
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
extract data from pdf form to excel; how to type into a pdf form in 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
using pdf forms to collect data; how to fill in a pdf form in reader
PDF
TO 
HTML
C
ONVERSION
           Final Report 
Page 18 
•  f_is_horizontal[]: a boolean variable set to true if the text is horizontal 
•  isUsed[]:  a  Boolean  variable  provided  to  flag  elements  that  have  already  been 
merged into other elements 
Once the data has been processed the writeFromFragmentArrays method is called to 
write the modified data back to the PdfData object. 
4.3.1  Simple text merging 
The general procedure for merging text fragments is shown below.  For simple page 
layouts this  sort is  simply in order of Y co-ordinate then  X  co-ordinate.   The text 
fragments  will  then  be  in  the  correct  order  so  that  successive  fragments  can  be 
appropriately merged together to form a continuous flow of text.   
Sort array indices
Merge previous fragment
with current fragment
Mark previous fragment
as unused
Write used fragments to
PdfData object
Find indices of current
and previous fragments
Remove all fragments
from memory on exit
For each
text
fragment
Fig 4.4: Basic text extraction method 
4.3.2  Sorting text fragments 
As the text fragments were held in a series of arrays it would be necessary to sort every 
single array identically to ensure that all data is preserved.  As this method was felt to 
be inefficient and clumsy, it was decided not to sort the arrays but to create a new 
array,  Order[],  which  would  keep  track  of  the  current order  of  the  indices  of the 
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
how to save filled out pdf form in reader; extract data from pdf table
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.
extracting data from pdf forms to excel; extract data from pdf form fields
Final Report                           PDF
TO 
HTML
C
ONVERSION
Page 19 
elements.  Initially this array was set to count 0, 1, 2, … , up to the highest numbered 
text fragment. 
The sort was carried out by using a modified version of the XYComparator method 
downloaded from java.sun.com
[3]
and calling the Arrays.sort(Comparator) method. 
A further problem was encountered when investigating the co-ordinates of each text 
fragment.  The vertical co-ordinates of fragments on the same line were found to differ 
slightly.    This  was  because  certain  fragments  included  capital  letters,  symbols  or 
characters such as “g” which extend beyond the baseline.  This sometimes caused the 
text to be merged in the incorrect order.  The figure below illustrates this problem. 
high  game  make  –
Fig 4.5: Example of words and symbols with different y co-ordinates 
This problem was overcome by the creation of the sameLine method which works in 
two steps.  First, both y1 and y2 co-ordinates are examined, and returns true if either 
co-ordinates intersect.  Secondly, an “error margin” of 25% of the line height is used 
and, if the fragments are within this margin, the method also returns true.   
 new  comparator  was  created,  YErrComparator,  which  calls  sameLine  with  two 
successive fragments and sorts these fragments in X order if it evaluates to true. 
4.3.3  Merging process 
Merging  of  text  fragments  is  performed  by  the  mergeTextObjects  method  in 
PdfGrouping.  Text fragments are processed in the order that they are sorted, and each 
fragment  is  merged  with  the  next,  building  up  a  continuous  page  of  text.    The 
relationship  between  two  successive  text  fragments  determines  how  they  will  be 
merged, and is ascertained by examining both sets of co-ordinates, as performed in the 
sameLine, nextChar and nextLine methods. 
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
pdf data extraction to excel; extract data from pdf to excel
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
edit pdf form in reader; exporting pdf data to excel
PDF
TO 
HTML
C
ONVERSION
           Final Report 
Page 20 
A simplified version of the procedure for each pair of text fragments is shown in the 
diagram  below.    Features  such  as  dropped  capitals,  hyphenation  and  variable  line 
spacing have made this process more complex and these are covered in later sections. 
Are the text fragments on
the same line?
sameLine(cur,prev)
Is the current fragment
horizontally adjacent to the
previous fragment?
nextChar(cur,prev)
Concatenate the two text
fragments
Is the current fragment
directly below the previous
fragment?
nextLine(cur,prev)
Next word in paragraph:
concatenate the two
fragments adding a space in
between
Next word in paragraph:
concatenate the two
fragments adding a space in
between*
Next paragraph:
concatenate the two
fragments adding a
paragraph space in between
YES
YES
YES
NO
NO
NO
Fig 4.6: Text merging process 
4.3.4  nextChar and nextLine methods 
The nextChar method returns true if two text fragments are horizontally adjacent.  It is 
unnecessary to evaluate vertical co-ordinates as this method is only ever called when 
sameLine has evaluated to true.  An “error margin” of 25% of the line height is used, 
and the x1 co-ordinate of the current text fragment has to be equal to, or within the 
error margin of, the x2 co-ordinate of the previous fragment. 
If nextChar evaluates to true, the merging algorithm concatenates the two fragments 
without inserting an intermediate space.  Otherwise, it assumes that the two fragments 
are separate words and inserts a space between them. 
* At this stage, two separate lines are detected as 
belonging to the same paragraph and are concatenated 
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
extract data from pdf forms; export excel to pdf form
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
export pdf form data to excel; how to fill pdf form in reader
Final Report                           PDF
TO 
HTML
C
ONVERSION
Page 21 
The  nextLine  method  returns  true  if  two  text  fragments  are  vertically  adjacent.  
Originally this method was programmed to return true if the y1 co-ordinate of the 
current text fragment was equal  to the y2 co-ordinate of the previous fragment, or 
within an error margin of 30% of the line height.  However, this method was rewritten 
when the program was improved to allow for varying line spacing.  This is covered in 
section 4.5.1. 
If  nextLine  evaluates  to  true,  the  simple  merging  algorithm  assumes  that  the  text 
fragments are separate words that have been wrapped to the next line, and belong to 
the same paragraph.  It therefore concatenates the two fragments,  inserting a space in 
between.  Otherwise, it assumes that the two fragments belong to different paragraphs 
and inserts the appropriate HTML tags to indicate this. 
4.4  Column-based layouts 
This section describes how column-based layouts, such as those of a typical newsletter, 
were detected and processed so that the text was extracted in the correct order.  The 
general approach was to use the array group[] to group the text fragments according to 
which column they belong, and to output each group (column) of fragments in order 
from  left  to  right.    Since  the  fragments  were  already  sorted  on  their  vertical  co-
ordinate, a stable sort on the group number was all that is required.  Two different 
methods of grouping the fragments were tried; the original method was found not to 
work reliably in practice and was replaced by a different method which was found to 
give better results. 
4.4.1  Original column detection algorithm 
The  original  method  was  to  partition  the  page  into  several  blocks  which  would 
correspond to separate columns and possibly separate articles, as shown in the figure 
below.  A class called rectangle was created to hold the co-ordinates of the bounding 
boxes of these blocks of text.  Each fragment was examined in the order that they were 
sorted (Y then X) and compared to each bounding box.  If the fragment looked like it 
was part of an existing text block; for example by being directly under it, the bounding 
box would be grown to encompass the text fragment.  If, on the other hand, the text 
fragment did not fit into any of the existing text blocks, a new text block would be 
created with the co-ordinates of the bounding box of the text fragment. 
PDF
TO 
HTML
C
ONVERSION
           Final Report 
Page 22 
Fig 4.7: Example of newsletter partitioned into columns and articles 
In practice this method was unreliable as miscellaneous items of text could sometimes 
be included in other text blocks, severely altering their dimensions and including other 
columns within the  same  text  block.   Sometimes  the  algorithm  recognized the  gap 
between  two  columns  as  a  gap  between  two  words  and  grew  the  text  block  to 
encompass the neighbouring column.   
After studying the layout of a newsletter it became clear that indicates to the reader that 
there are two distinct columns is a continuous vertical gap.  Hence it was decided to create 
a new algorithm based on detecting gaps between the columns instead of blocks of text. 
4.4.2  Improved column detection algorithm 
The new method, findColumnGaps, used the type rectangle to store the co-ordinates of 
gaps  between  text  fragments rather  than  the  co-ordinates  of  the text itself.   These 
rectangles were held in a Vector named gaps. 
Text fragments were, again, processed in the order that they had been sorted.  When a 
horizontal gap between successive fragments was found, a rectangle was created with 
the horizontal co-ordinates of the gap, and the highest and lowest vertical co-ordinates 
of the two text fragments, as shown below. 
Fig 4.8: First two steps in gap detection algorithm 
Final Report                           PDF
TO 
HTML
C
ONVERSION
Page 23 
After each gap in the text was found, its co-ordinates were compared to those of the 
rectangles  that  had  already  been  created.    This  was  performed  by  the 
rectangle.checkAndUpdate method.  If the  horizontal co-ordinates were identical or 
intersected each other, instead of creating a new rectangle, the existing rectangle was 
“grown”  downwards  so  that its  bottom  co-ordinates  became  equal  to  those  of  the 
lowest text block.  If the horizontal co-ordinates partly intersected those of the existing 
rectangle, the rectangle was “shrunk” horizontally so that it no longer intersected the 
text block, as shown below. 
Fig 4.9: Both rectangles have been “grown” vertically; the left rectangle  
has also been “shrunk” horizontally. 
If the existing gap was totally intersected by a text block it was grown only to the top 
of the text block and marked as “closed”.  After the gap was marked as closed it would 
no longer be possible to grow the gap to accommodate further gaps and any further 
gaps in that horizontal position would lead to the creation of new rectangles, as shown 
below. 
Fig 4.10: The rectangle on the left has been “closed” such that any future  
gaps in that horizontal position will lead to the creation of new rectangles 
The checkAndUpdate method returns true if it manages to grow the current rectangle 
to  accommodate  the  gap  between  the  supplied  co-ordinates.    This  informs  the 
findColumnGaps method that it is not necessary to create a new rectangle object. 
In order not to allow small gaps (e.g. between words) to interfere with the algorithm, a 
threshold height of 36 points and a threshold width of 4 points were set; all rectangles 
PDF
TO 
HTML
C
ONVERSION
           Final Report 
Page 24 
below the threshold height or width are removed from the vector.  This value was 
taken  after  finding  the  smallest  likely  gap  with  very  small  (6  point)  newsprint.  
Newspapers often use very  narrow  gaps, ruling a line between the two columns  to 
compensate visually for this. 
Finally, once the number of rectangles is fixed, they are copied to an array, gap[], and 
sorted to facilitate grouping of the text fragments in the correct order. 
4.4.3  Ordering of text in columns 
In order to work with the majority of column layouts, it was decided to order the text 
by column, starting at the left most column, working down the column and moving 
horizontally onto the next column as shown below. 
This is achieved by sorting the gap[] array in order of x2 co-ordinate.  This array is 
then  passed  to  the  groupTextElements  method  that  assigns  a  group[]  to  each  text 
fragment based on the horizontally closest gap to its left.  Text fragments that do not 
have a gap to their left (i.e. the first column) are assigned to group 0. 
The text fragments are then sorted in group order using the GroupComparator.  As this 
is a stable sort, the existing Y-then-X order inside each column remains. 
Fig 4.11: Example of column ordering 
Documents you may be interested
Documents you may be interested