c# pdf to image without ghostscript : Convert pdf to pdf form fillable software control dll winforms azure windows web forms shawn_thesis10-part633

CHAPTER 3. XML REPRESENTATION OF REGULATIONS 
86
6
starting “§” symbols, trailing punctuation, unba lanced opening or closing parenthesis
36
and groups of characters enclosed in parenthesis. 
An iterative process is used to develop the reference parsing grammar.  First, a core 
grammar and lexicon  are  created  by  manually  reading  through  the regulations  and 
developing a grammar and lexicon to parse the manually identified references.  Next a 
reference prediction system, discussed in section 3.4.3.2, is run on a large regulation text 
corpus to produce lists of text with high probability of containing a reference that the 
system could not parse.  Actual references are then manually identified from this list and 
the parsing grammar and lexicon updated to capture the references.  This process is 
repeated until the reference prediction system fails to find any real references that could 
not be parsed.  Figure 3.15 shows the basic grammar and Figure 3.16 shows the basic 
lexicon. 
3.4.3.1.3   Interpreting the Reference Parse Tree 
Once a parse tree is created using the parsing algorithm described above, the problem 
remains of interpreting this parse tree so that references can be listed in a standard format.  
This section describes the process used to convert parse trees into lists of references. 
The semantic parsing system is built on top of a simple tabular parser that does a 
modified depth-first processing of the parse tree.  Each node in the tree is treated as an 
input token.  The processing deviates from strict depth-first processing when special 
control  categories  are  encountered.    Grammar  and  lexicon  files  provide  control 
information to the semantic interpreter.  The parsing algorithm differs from a simple 
tabular parser in that when a category label is found, it is not removed from the category 
search stack.  Instead, the category found is marked “found” and remains on top of the  
36
This means splitting off unequal numbers of “(“ or “)” on a token.  For example, “(d))” is split into “(d)” 
and “)”. 
Convert pdf to pdf form fillable - C# PDF Form Data fill-in Library: auto fill-in PDF form data in C#.net, ASP.NET, MVC, WinForms, WPF
Online C# Tutorial to Automatically Fill in Field Data to PDF
create a fillable pdf form in word; convert word form to pdf with fillable
Convert pdf to pdf form fillable - VB.NET PDF Form Data fill-in library: auto fill-in PDF form data in vb.net, ASP.NET, MVC, WinForms, WPF
VB.NET PDF Form Data fill-in library: auto fill-in PDF form data in vb.net, ASP.NET, MVC, WinForms, WPF
convert pdf forms to fillable; convert word form to fillable pdf form
CHAPTER 3.  XML REPRESENTATION OF REGULATIONS 
87
7
Figure 3.15 Partial grammar for the reference parsing system 
stack.  The next matching category can be the “found” category or the second category in 
the stack.  If the second category in the stack is matched, it is marked found and the top 
category is removed. 
The grammar file is essentially a list of templates that specify what type of reference is 
well formed.  All grammar rules for the parser that interprets the reference parse trees 
must start with “REF --> “.  The grammar used for interpreting the parse trees is shown in 
Figure 3.17. 
The two grammar rules in Figure 3.17 correspond to the two types of references that 
appear in 40 CFR regulations: 40 CFR 262 Subpart F (which refers to Chapter 40, Part 
262, Subpart F), and 40 CFR 262.12(a)(13)(iv) (which refers to Chapter 40, Part 262, 
Section 12, subsection a, paragraph 13, subparagraph iv) 
REF --> LEV0' 
REF --> ASSUME_LEV0 LEV2' BackRefKey LEV1r' 
LEV0' --> LEV0 
LEV0' --> LEV0 CONN' LEV0' 
LEV0 --> INT CFR LEV1a' 
LEV1a' --> LEV1a CONN' LEV1a' 
LEV1a' --> LEV1a 
LEV1a --> LEV1p 
LEV1a --> LEV1s 
LEV1p --> PART INT CONL2 
LEV1r' --> LEV1r CONN' LEV1a' 
LEV1r --> LEV1p 
LEV1s --> INT 
CONN' --> CONN 
CONL2 --> txt(,) LEV2' 
CONL2 --> e 
LEV2' --> SUBPART UL' 
UL' --> UL 
UL' --> UL CONN' UL' 
VB.NET Create PDF from PowerPoint Library to convert pptx, ppt to
URL. Bookmark: Edit Bookmark. Metadata: Edit, Delete Metadata. Form Process. Dim doc As PPTXDocument = New PPTXDocument(inputFilePath) ' Convert it to a PDF.
convert pdf to form fill; create a pdf with fields to fill in
VB.NET Create PDF from Word Library to convert docx, doc to PDF in
Link: Edit URL. Bookmark: Edit Bookmark. Metadata: Edit, Delete Metadata. Form Process. Convert Word to PDF file with embedded fonts or without original fonts
attach file to pdf form; convert fillable pdf to html form
CHAPTER 3.  XML REPRESENTATION OF REGULATIONS 
88
8
Figure 3.16 Partial lexicon for the reference parser 
Figure 3.17 Reference interpretation grammar 
The lexicon file specifies how to treat different parsing categories. A shortened version of 
the interpretation lexicon is shown in Figure 3.18.  The complete lexicon appears in 
Appendix B.  As shown in Table 3.3, there are five semantic interpretation categories that 
can be used in the lexicon.  These categories are used to classify the categories used by 
the reference parser when constructing the parse tree. 
CONN --> and 
CONN --> or 
CONN --> , 
PART --> part 
PART --> parts 
PART --> Part 
PART --> Parts 
SUBPART --> subpart 
SUBPART --> subparts 
SUBPART --> Subpart 
SUBPART --> Subparts 
BackRefKey --> of 
BackRefKey --> in 
CFR --> CFR 
CFR --> cfr 
REF --> LEV0 LEV1 LEV2 
REF --> LEV0 LEV3 LEV4 LEV5 LEV6 LEV7 
VB.NET Create PDF from Excel Library to convert xlsx, xls to PDF
Link: Edit URL. Bookmark: Edit Bookmark. Metadata: Edit, Delete Metadata. Form Process. Convert to PDF with embedded fonts or without original fonts fast.
convert an existing form into a fillable pdf form; c# fill out pdf form
C# Create PDF from OpenOffice to convert odt, odp files to PDF in
Convert OpenOffice Text Document to PDF with embedded Create PDF document from OpenOffice Presentation in both ODT, ODS, ODP forms to fillable PDF formats in
create fillable form pdf online; pdf form filler
CHAPTER 3.  XML REPRESENTATION OF REGULATIONS 
89
9
Table 3.3 Lexicon categories 
Category 
Meaning 
PTERM 
Indicates the node is a printing terminal string (to be 
added the reference string currently being built) 
NPTERM 
Indicates the node is a non-printing terminal string 
(the node is ignored) 
SKIPNEXT 
Indicates  the  next child node  of parent  should  be 
ignored and not processed 
REFBREAK 
Indicates the current reference string is complete, and 
a new reference string should be started 
INTERPOLATE 
Indicates that a list of references should be generated 
to make a continuous list between the previous child 
node  and  the  next  child  node.  (If the  child  node 
sequence  was  “262,  INTERPOLATE,  265”,  this 
would generate the list “263, 264”) 
Figure 3.18 Partial lexicon for the parse tree interpreter 
The semantic parser works by attempting to match the category stack to the nodes in the 
tree.  The parser maintains a “current refere nce” string that is updated as nodes in the 
parse tree are encountered.  References are added to a list of complete references when 
PTERM --> INT 
PTERM --> CFR 
PTERM --> UL 
NPTERM --> PART 
NPTERM --> SUBPART 
NPTERM --> e 
SKIPNEXT --> BackRefKey 
REFBREAK --> CONN 
REFBREAK --> CONN' 
C# Create PDF from Excel Library to convert xlsx, xls to PDF in C#
Create fillable and editable PDF documents from Excel in both .NET WinForms and ASP.NET. Create searchable and scanned PDF files from Excel. Convert to PDF with
pdf create fillable form; convert pdf to fillable form online
C# Create PDF from PowerPoint Library to convert pptx, ppt to PDF
Convert multiple pages PowerPoint to fillable and editable PDF documents. Easy to create searchable and scanned PDF files from PowerPoint.
convert pdf to fill in form; convert excel to fillable pdf form
CHAPTER 3.  XML REPRESENTATION OF REGULATIONS 
90
0
the parser encounters “REFBREAK” or “I NTERPOLATE” nodes, or completes a full 
parse of the tree.  Two examples follow that explain this process in detail. 
Figure 3.19 shows a parse tree where the original reference is “40 CFR parts 264 and 
265”.  The semantic interpreta tion parser transforms this reference into two complete 
references: 40.cfr.264, and 40.cfr.265.  Figure 3.19 is an example of a simple parse tree 
that can be interpreted.  The parser starts by expanding the REF category in its search list 
to “LEV0 LEV1 LEV2”.  It then starts a depth-first parse down the tree, starting at REF.  
The LEV0’ node matches LEV0, so this categ ory is marked as found.  The LEV0 node 
also matches the LEV0 search category 
Next the children of LEV0 are processed from left to right.  Looking up INT in the 
interpreter lexicon (Figure 3.18) shows it is a PTERM, so the current reference string is 
updated to be “40”.  Looking CFR up in the in terpreter lexicon shows that it is also a 
PTERM, so the leaf’s value is appended to th e current reference string to form “40.cfr”.  
Next, LEV1a’ is processed, and a note is made  that the incoming current reference string 
was “40.cfr”.  LEV1a’ matches  LEV1, so the top LEV0 search category is discarded and 
the LEV1 category is marked as found.  Processing continues down the LEV1a branch of 
the tree to the LEV1p node.  The PART child node is found to be a NPTERM in the 
lexicon, so the content of the PART leaf node is not appended to the current reference 
string.  INT is found to be a PTERM, so the content of this leaf node is concatenated to 
the search string.  Since CONL2 is also a NPTERM, the algorithm traverses back up to 
LEV1a’.  The next child node to be pro cessed is CONN’, which is found to be a 
REFBREAK  in the lexicon.  This means that the current reference is complete, so 
“40.cfr.264” is added  to  the  lis t of references and  the current  reference is reset  to 
“40.cfr”, the value it had when the LEV1a’ pa rent node was first reached.  Processing 
then continues down from LEV1a’ to the right-most leaf of the tree.  At this point the 
current reference is updated to “40.cfr.265” and a note is ma de that the entire tree has 
been traversed, so “40.cfr.265” is  added to the list of identified references.  Next the  
C# Create PDF from Word Library to convert docx, doc to PDF in C#.
Convert multiple pages Word to fillable and editable PDF documents in both .NET WinForms and ASP.NET. Convert both DOC and DOCX formats to PDF files.
create fill pdf form; convert excel spreadsheet to fillable pdf form
C# Create PDF Library SDK to convert PDF from other file formats
Create fillable PDF document with fields. Load PDF from existing documents and image in SQL server. Load PDF from stream programmatically.
convert word document to fillable pdf form; create a fillable pdf form online
CHAPTER 3.  XML REPRESENTATION OF REGULATIONS 
91
1
REF 
LEV0’ 
LEV0 
LEV1p 
CONN’ 
LEV1a’ 
LEV1a 
INT 
CONN 
PART 
INT 
CONL2 
parts  264 
CFR 
LEV1a 
LEV1a’ 
LEV1s 
INT 
and 
265 
CFR 
40 
Figure 3.19 Example of a simple parse tree 
parser would try the other expansion of REF as “LEV0 LEV3 LEV4 LEV5”, but since it 
would be  unable  to match  LEV3  this attempt would fail.   The final list of parsed 
references thus contains 40.cfr.264 and 40.cfr.265. 
The basic approach described above can be extended to handle references where the 
components of the reference do not appear in order.  For example, the parser might 
encounter the reference “paragraph (d) of  section 262.14”.  A proper ordering of this 
reference would be “section 262.14,  paragraph (d)”.  To handle these cases, if the top of 
the category search stack cannot be matched to a node in the tree, the remainder of the 
parse tree is scanned to see if the missing category appears elsewhere in the tree (a “back-
reference”).   If  the  category  is found,  it is   processed and  appended  to  the  current 
reference before the algorithm returns to the original part of the parse tree.  If multiple 
references are found during the back-reference call, the order needs to be reversed to 
VB.NET Create PDF from OpenOffice to convert odt, odp files to PDF
Link: Edit URL. Bookmark: Edit Bookmark. Metadata: Edit, Delete Metadata. Form Process. ' odt convert to pdf Dim odt As ODTDocument = New ODTDocument("C:\1.odt
change font size pdf fillable form; convert word to fillable pdf form
VB.NET Create PDF Library SDK to convert PDF from other file
Best VB.NET component to convert Microsoft Office Word Create and save editable PDF with a blank page Create fillable PDF document with fields in Visual Basic
convert word form to fillable pdf; create pdf fill in form
CHAPTER 3.  XML REPRESENTATION OF REGULATIONS 
92
2
maintain correctness.  This allows parsing an interpretation from complex parse trees as 
shown in Figure 3.20. 
The parse tree shown in Figure 3.20 originates from the reference, “Subpart O of part 264 
or 265”.  The semantic interpre tation parser transforms the reference into two complete 
references: 40.cfr.264.O, and 40.cfr.265.  In cases of ambiguous meaning, the parser 
maximizes the scope of ambiguous references.  For example, the parse tree in Figure 3.20 
could also be interpreted as 40.cfr.264.O and 40.cfr.265.O, but this might be incorrect if 
40.cfr.264.O and 40.cfr.265 were actually intended. 
Figure 3.20 is an example of a complex parse tree that can be interpreted.  A brief 
explanation of this parse tree follows.  In this example, the semantic parser first expands 
the  starting  REF  category  to  be  “LEV0  LEV1  LEV2”.    LEV0  matches  the 
ASSUME_LEV0 leaf, and the current reference string is updated to be “40.cfr”.  Next, 
the parser encounters LEV2’, which does not  match LEV0 or LEV1.  The parser then 
searches for a possible “back-refe rence” (a level of the reference that is out of order,  
REF 
ASSUME_LEV0 
LEV2’ 
SUBPART  UL’ 
UL 
BACKREFKEY 
LEV1r’ 
LEV1p 
LEV1r 
CONN’  LEV1a’ 
LEV1a 
LEV1s 
INT 
CONN 
PART INT  CONL2 
Subpart 
part 
of 
265 
264 
or 
40.cfr 
Figure 3.20 Complex parse tree 
CHAPTER 3.  XML REPRESENTATION OF REGULATIONS 
93
3
referring back to a lower level), which it finds as LEV1r’.  The parser processes this part 
of the tree, concatenating the INT under LEV1p to the reference string.  It also notes the 
reference string is complete upon encountering the CONN’ (a REFBREAK), so a new 
reference string is started with “265” and a note is made that  the rightmost leaf of the tree 
has been found.  The parser uses back-reference calls to effectively re-order the depth-
first parsing process such that reference components are parsed in descending order.  
Upon returning from the back-reference function call, it is noted that multiple references 
have been encountered, so a reconciliation procedure is run to swap “40.cfr.264” with 
“40.cfr.265” in the complete re ference list and to set “40.cfr .264” as the current reference 
string.  Now the parser can match the LEV2’ category and update the current reference 
list to be “40.cfr.264.O”.  Next the pars er encounters the BACKREFKEY category, 
which the lexicon identifies as type SKIPNEXT, so the parser can skip the next child 
node.  Skipping the next child node brings the parser to the end of the tree.  Since the 
parser noted earlier that it had processed the right-most leaf, which indicates a successful 
semantic parsing attempt, the parser adds the “40.c fr.264.O” to the lists of references 
found in the parse tree.  The subsequent attempt to parse the tree using “LEV0 LEV3 
LEV4…” will fail to reach the rightmost leaf,  so no more parses will be recorded.  Thus, 
the final reference list is 40.cfr.264.O and 40.cfr.265. 
The parsing system developed in this research work, along with the semantic interpreter 
for the parse trees, should be simple to reconfigure to parse and interpret a variety of 
different referencing systems or text patterns.  Using a grammar and lexicon to specify 
how to treat categories from a parsed reference provides a great deal of flexibility for the 
system.  New grammar and lexicon files can be introduced to change the system for new 
types of references.  The main limitation of the system is that grammar rules cannot be 
left-recursive. 
CHAPTER 3.  XML REPRESENTATION OF REGULATIONS 
94
4
3.4.3.2  Statistically-Based Reference Parser 
In this research, an n-gram model is employed to make the parsing process more efficient 
by skimming over text that was not predicted to contain a reference.  An n-gram model is 
a probabilistic model for sets of n sequential words [56].  For example, one might use 
unigrams, bigrams or trigrams in a model.  A unigram is a single word, a bigram is a pair 
of words, and a trigram is a sequence of three consecutive words.  These n-grams can be 
used to predict where a reference occurs in a regulation by how frequently each n-gram 
precedes a reference string. 
To develop an n-gram model, a regulation corpus of about 650,000 words was assembled.  
The parser found 8,503 references after training on this corpus.   These 8,503 references 
are preceded by 184 unique unigrams, 1,136 unique bigrams, and 2,276 unique trigrams.  
For these n-grams to be good predictors of a reference, they should occur frequently 
enough to be useful predictors, but they should not occur so frequently in the general 
corpus that their reference prediction value is low. 
For the unigrams, it is interesting to note that 18 of the most “certain” predictors are 
identified as highly “certain” because they ar e only seen once in the entire corpus.  Some 
other unigrams that one might intuitively expect to be good predictors actually are weak 
predictors for references.  For example, “in”  has a 5% prediction value.  This is because 
the 2,626 references that are preceded by “i n” are so heavily outweighed by the 49,325 
total occurrences of “in” in the corpus.  These two factors make the unigram model a 
weak one, since words with high certainty tend to be those that are rarely seen, and words 
that  preceded  many  references  tend  to  be  common  words  that  also  appear  often 
throughout the corpus.  One exception to this is the word “under”, which precedes 1,135 
references and only appears 2,403 times in the corpus (a 47% prediction rate). 
The bigram model is a good predictor of references.  While over 200 (18%) of the 
bigrams  only  occur  once in the corpus, the significance  of  bigrams that  precede  a 
reference is not diminished by an even larger number of occurrences in the corpus (as is 
CHAPTER 3.  XML REPRESENTATION OF REGULATIONS 
95
5
the case for the “in” unigram ).  For example, “require ments of”, which precedes 1,059 
references is seen 1,585 times total in the regulation corpus. 
The trigram model helps refine some of the bigram predictors.  For example, “described 
in” with a 61% prediction rate is refined  into 35 trigrams with prediction probabilities 
ranging from 11% to 100%.  In general however, the trigram model appears to split 
things too far, since about 1/3 of the trigrams only appear a single time in the entire 
corpus. 
Before attempting a parse on the input, the three n-gram models are used together by 
calculating a weighted sum  of unigram (U), bigram (B) and trigrams (T) using the 
following equation: λ
1
U + λ
2
B + λ
3
T ≥ ≥  1.  In this equation, a threshold of 1 is used to 
determine if the parse should be carried out.  By changing the λ λ  weightings, different 
parts of the text are selected for parse attempts. 
While the n-gram model is effective for speeding up parsing, there is a tradeoff between 
parsing speed and recall.  To study this tradeoff, the n-gram model was trained on the 
650,000-word  corpus  and  then  tested  on  a  36,600-word  corpus.    There  were  569 
references in the test corpus.  To experiment with the possible λ λ  parameter values, a 
brute-force search was done through a range of values (
λ
1
= 1-20,000, 
λ
2
= 1-10,000, 
λ
3
1-640).  There were over 10,000 passes through the test file completed during this 
experiment.  The number of reference parse attempts and successful reference parses 
were recorded.  Examples with the lowest number of parse attempts for a given level of 
recall were selected from the test runs.  This process provides an efficient frontier that 
shows the best efficiency (successful parses / total parse attempts) for a given level of 
recall.  These results are shown in Figure 3.21. 
The x-axis in Figure 3.21 shows the level of recall for the pass through the test file.  So as 
to provide an indicator of the extra work by the parser, the y-axis shows the total number 
of parse attempts divided by the total number of references in the document.  As can be 
seen from Figure 3.21, there is clearly a change in the difficulty of predicting references 
Documents you may be interested
Documents you may be interested