DEV Community: Aspose.PDF

Extract Text from PDF Files Using the Aspose.PDF Library in Python

write-IT-here — Mon, 20 Nov 2023 22:10:52 +0000

Portable Document Format (PDF) files have become an integral part of our digital landscape, offering a reliable and standardized means of sharing and storing information across multiple platforms. Despite their convenience, PDF users face many challenges and problems when interacting with these documents on a daily basis. These tasks range from the mundane to the complex, shaping the user experience for navigating and managing PDF files.

One of the main tasks that PDF users face is extracting and editing text. PDF files are often used due to their static nature, but extracting text for reuse or modification is a common requirement.

There are several libraries in Python that allow you to solve this problem (for example, PDFMiner). In this post I want to talk about working with the Aspose.PDF for Python via .NET library. As the name suggests, the library is based on .NET code, but it is completely self-contained; all the necessary components for running runtime are already included in the library. You can install this library using the following command:

pip install aspose-pdf

Note! Get a temporary license and try to work with text without any limitation.

Extract Text Content from PDF Document

Okay, let's kick things off with the basics. This Python snippet shows how to grab and print text from a PDF using the Aspose.PDF library. Here's a quick rundown of what's happening in the code:

Import the necessary module from Aspose.PDF library.
Load the PDF file (let say "input.pdf") using the Document class and store it in the pdfDocument variable.
Create a TextAbsorber object to extract text from the PDF document.
Use the textAbsorber to visit the page of the PDF using textAbsorber.visit(pdfDocument.pages[1]). In our case, we will visit 1st page and will parse and extract the text content from the specified page.
At the last, we can print the extracted text content or do something else.

import aspose.pdf as pdf
pdfDocument = pdf.Document("input.pdf")
textAbsorber = pdf.text.TextAbsorber()
textAbsorber.visit(pdfDocument.pages[1])
print(textAbsorber.text)

As you can see, TextAbsorber allows us to extract all the text from a page, but what if we need a more detailed analysis? Let’s try other tools.

Extract Text Fragments from PDF Document

The TextFragmentAbsorber allows you to extract small pieces of text named Text Fragments. You can loop through all the fragments and get their properties like Text, Position (XIndent, YIndent) etc.

The steps to perform an extraction are basically the same:Import the necessary module.
Load the PDF document.
Initialize a TextFragmentAbsorber.
Process a specific page: The textFragmentAbsorber.visit(pdfDocument.pages[1]) method processes the text on the first page of the loaded PDF document.
Iterate through text fragments: The for loop iterates through each text fragment detected by the TextFragmentAbsorber on the processed page.
Print text fragments: print(textFragment.text) – prints the text content of each extracted text fragment or perform another action.

import aspose.pdf as pdf
pdfDocument = pdf.Document("input.pdf")
textFragmentAbsorber =  pdf.text.TextFragmentAbsorber()
textFragmentAbsorber.visit(pdfDocument.pages[1])
for textFragment in textFragmentAbsorber.text_fragments:
    print(textFragment.text)

So, this piece of code does something pretty cool: it helps you pluck text from a particular page in a PDF using the Aspose.PDF library. It's a nifty way to snag text for later analysis or tinkering around in Python.

Extract Paragraphs of the text from PDF Document

Yet another tool helps us handle text as paragraphs. ParagraphAbsorber works similar to the previous tool, but it has its own collection for paragraphs.

Since the purpose of this post is not a detailed examination of the ParagraphAbsorber, I will limit myself to only a short example and a brief description:

Import the necessary module and load the PDF document.
Initialize a ParagraphAbsorber and process a specific page. In this step, we got a collection of the text sections.
Iterate through text sections. The outer for loop iterates through each section of text detected by the ParagraphAbsorber on the processed page. Within the inner for loop, each text fragment within a section is concatenated to form a complete paragraph of text.
Do something (like print paragraphs).

import aspose.pdf as pdf
pdfDocument = pdf.Document("input.pdf")
paragraphAbsorber = pdf.text.ParagraphAbsorber()
paragraphAbsorber.visit(pdfDocument.pages[1])
for section in paragraphAbsorber.page_markups:
    paragraphText=""
    for textFragment in section.text_fragments:
        paragraphText=paragraphText+textFragment.text
        paragraphText=paragraphText+"\r\n"
    print(paragraphText)

Basically, this bit of code helps you pull out paragraphs from a chosen page in a PDF. It's a handy way to grab text for all sorts of things like analysis or other processing you might want to do.

Aspose.PDF Cloud: Converting documents using CSharp SDK (part 3)

Andriy Andruhovski — Mon, 20 Aug 2018 15:49:32 +0000

Full sample can be downloaded from here.

In the previous part, we learned how to PDF docs can be converted to other formats, but only with default settings. Now will try to customize some conversion settings and get more flexible results. The number and purpose of the settings depend on the conversion format. It should also be noted that there are formats that do not require additional settings, for example, PDF to XPS or PDF to PDF/A. Therefore, we start learning from simple conversions to more complex ones.

In this part, we continue to use ASP.NET MVC5 application, but with changes:

we should rewrite Index.cshtml and call different actions for different formats;
we need new actions for each format in HomeController;

The new version of Index.cshtml is shown below:

Next, we remove unused and add new actions to HomeContoller.

In addition, we create a model for basic options and derive from it models for specific formats.

public class OptionsModel
{
    [Display(Name = "File Name:")]
    public string Name { get; set; }

    [Display(Name = "Folder:")]
    public string Folder { get; set; }
}

Convert files from PDF to XPS, SVG, PDF/A

As stated above, we have a few formats without additional settings - XPS, SVG and PDF/A. The code for XPS and SVG is very simple and doesn't require additional explanations.

public ActionResult ToSvg(string filename)
{
    SaaSposeResponse response;
    var outPath = $"{FolderName}/svg/{filename.Replace("pdf","zip")}";
    try
    {
        response = PdfApi.PutPdfInStorageToSvg(filename, outPath, folder: FolderName);
    }
    catch (ApiException ex)
    {
        return View("ConvertError", ex);
    }

    ViewBag.OutPath = outPath;
    return View("ConvertSuccess", response);
}

public ActionResult ToXps(string filename)
{
    SaaSposeResponse response;
    var outPath = $"{FolderName}/xps/{filename.Replace("pdf", "zip")}";
    try
    {
        response = PdfApi.PutPdfInStorageToXps(filename, outPath, FolderName);
    }
    catch (ApiException ex)
    {
        return View("ConvertError", ex);
    }

    ViewBag.OutPath = outPath;
    return View("ConvertSuccess", response);
}

Aspose.PDF Cloud supports two subformats: PDF/A-1a and PDF/A-1b, so we can clarify these subtypes.

public enum PdfaSubType
{
    [Display(Name = "PDF/A-1a – Level A (accessible) conformance")]
    PDFA1A,
    [Display(Name = "PDF/A-1b – Level B (basic) conformance")]
    PDFA1B
}
public class PdfaOptionsModel : OptionsModel
{
    public PdfaSubType PdfaSubType { get; set; }
}

For this and other types of transformations, we use the standard approach: we show possible settings for the user (by HTTPGet) and perform the conversion (by HTTPPost).

public ActionResult ToPdfa(string filename)
{
    var pdfaOptions = new PdfaOptionsModel
    {
        Name = filename,
        Folder = FolderName,
        PdfaSubType = PdfaSubType.PDFA1A
    };
    return View(pdfaOptions);
}

[HttpPost]
public ActionResult ToPdfa(PdfaOptionsModel options)
{            
    SaaSposeResponse response;
    var outPath = $"{options.Folder}/pdfa/{options.Name}";
    try
    {
        response = PdfApi.PutPdfInStorageToPdfA(
            options.Name,
            outPath,
            options.PdfaSubType.ToString(),                    
            options.Folder);
    }
    catch (ApiException ex)
    {
        return View("ConvertError", ex);
    }

    ViewBag.OutPath = outPath;
    return View("ConvertSuccess", response);
}

Convert files from PDF to DOC

Let's consider the more complex case. For this conversion we have the following settings:

Format - an output format: Word 2003 (doc) or Word 2007 (docx)
Mode - a recognition mode: TextBox or Flow. The TextBox mode applies when we need layout much closer to the original doc. We can use the Flow mode when the output document needs further editing. Paragraphs and text lines in the flow mode allow easy modification of text, but unsupported formatting objects will look worse than in the Textbox mode.
AddReturnToLineEnd - this setting allow to generate lines (true) or paragraphs (false)
MaxDistanceBetweenTextLines - max distance between text lines. This option allows customizing paragraph creation. The larger value allows creating fewer paragraphs and vice versa.
RelativeHorizontalProximity - this setting defines the width of space between text elements(letters, syllables) that must be treated as the distance between words during recognition of words in source PDF. It used only in cases when source PDF contains specific rarely used fonts for which optimal value cannot be calculated from the font.
RecoginzeBullets - a boolean switch for list markers detection
ImageResolutionX, ImageResolutionY - image resolution settings;

Here is DocxOptionsModel class:

public class DocxOptionsModel : OptionsModel
{
    [Display(Name = "File Format:")]
    [RegularExpression("doc|docx")]
    public string Format { get; set; }

    [Display(Name = "Recognition Mode:")]
    public RecognitionMode Mode { get; set; }

    [Display(Name = "Add return to line end:")]
    public bool AddReturnToLineEnd { get; set; }

    [Display(Name = "Max Distance between text lines:")]
    public int? MaxDistanceBetweenTextLines { get; set; }

    [Display(Name = "Relative horizontal proximity:")]
    public double? RelativeHorizontalProximity { get; set; }

    [Display(Name = "Recognize bullets:")]
    public bool RecognizeBullets { get; set; }

    [Display(Name = "Image Resolution X:")]
    public int? ImageResolutionX { get; set; }

    [Display(Name = "Image Resolution Y:")]
    public int? ImageResolutionY { get; set; }
}

Following snippet shows the code of ToWord action:

public ActionResult ToWord(string filename)

{

    var docOptions = new DocxOptionsModel

    {

        Name = filename,

        Folder = FolderName,

        AddReturnToLineEnd = false,

        Format = "docx",

        Mode = RecognitionMode.Flow

    };

    return View(docOptions);

}

[HttpPost]

public ActionResult ToWord(DocxOptionsModel options)

{

    SaaSposeResponse response;

    try

    {

        response = PdfApi.PutPdfInStorageToDoc(options.Name,

            $"{options.Folder}/{options.Format}/{options.Name.Replace("pdf", "docx")}",

            options.AddReturnToLineEnd,

            options.Format,

            options.ImageResolutionX,

            options.ImageResolutionY,

            options.MaxDistanceBetweenTextLines,

            options.Mode.ToString(),

            options.RecognizeBullets,

            options.RelativeHorizontalProximity,

            options.Folder

            );

    }

    catch (ApiException ex)

    {

        return View("ConvertError", ex);

    }

return View("ConvertSuccess", response);



}

Convert files from PDF to TIFF

The settings for this type conversions we can divide into 3 subsections:general, image and page layout settings.

The general settings include:

PageIndex - start page;
PageCount - number of pages to be converted;
SkipBlankPages - skip blank pages;

The next section allows customize image quality:

Brightness - a fractional number from 0.0 to 1.0,
Compression - a compression algoritm (RLE, CCITT3, CCITT4 or LZW),
TiffColorDepth - a color depth value (1, 4 or 8 bit per pixel);
ImageResolutionX, ImageResolutionY - image resolution settings;
Width, Height - dimensions for output image.

And the last section allows to make additional design for rendered page:
LeftMargin, RightMargin, TopMargin, BottomMargin and Orientation

The code of action ToTIFF is mostly the same as for DOC.

Conclusion

In most cases, Aspose.PDF Cloud performs the transformation qualitatively without additional settings but also allows you to configure the conversion. In this article, we looked at the most popular formats, but the Aspose.PDF Cloud API also makes it possible to convert PDF to EPUB, XLS, XML, to some other formats.

Aspose.PDF Cloud: Converting documents using CSharp SDK (part 2)

Andriy Andruhovski — Tue, 26 Jun 2018 20:50:03 +0000

In the previous part we considered a process of conversion from other formats to PDF. Now, we continue exploring API of Aspose.PDF Cloud and we will see how to PDF docs can be converted to other formats: DOC/DOCX, EPUB, HTML, LaTeX, TIFF, PPTX, SVG, XLS. Obviously, that conversion process is specific for each format, therefore, we first consider the general algorithm and then tune up additional params for some formats.

Unlike the previous post, we will use an ASP.NET MVC5 application template. This will allow us to see both sync and async methods in action.

So, let assume that we need to write an ASP.NET MVC5 application that shows the content of some folder from cloud storage to the user and he can convert PDF files from that folder to appropriate format.

Step 0. Basic preparations

Add new ASP.NET Web Application with name MvcConverter and select No Authentication and MVC template options
Add packages for Aspose.Cloud:
- Install-Package Aspose.Storage-Cloud
- Install-Package Aspose.PDF-Cloud
Update other packages
- Update-Package
Update layout in _Layout.cshtml

Step 1. Setup API client

We will create an additional controller class (i.g. AsposeCloudController) for more convenient work with the API.

public class AsposeCloudController : Controller
{
    private const string AppSid = "*** Put App Sid here ***";
    private const string AppKey = "*** Put App Key here ***";

    protected readonly StorageApi _storageApi;
    protected readonly PdfApi _pdfApi;

    public AsposeCloudController()
    {
        _storageApi = new StorageApi(AppKey, AppSid);
        _pdfApi = new PdfApi(AppKey, AppSid);
    }
}

Step 2. Modify HomeController

By default, ASP.NET MVC5 application template has HomeController with 3 actions: Index, About, Contacts. Let's change Index so that the list of files is displayed.

public class HomeController : AsposeCloudController
{
    protected string StorageName = "First Storage";
    protected string FolderName = "pdf-demo";
    public ActionResult Index()
    {
        // Check if the folder exists
        var fileExistResponse = _storageApi.GetIsExist(
            new GetIsExistRequest(FolderName, null, StorageName));
        if (fileExistResponse.Status.Equals("OK"))
        {
            if (fileExistResponse.FileExist.IsFolder == false)
            {
                return View("ApiError", new AsposeResponse
                {
                    Code = fileExistResponse.Code,
                    Status = "Folder not found"
                });
            }
        }
        else
        {
            return View("ApiError", fileExistResponse);
        }
        // Get the filelist
        var filesResponse = _storageApi.GetListFiles(    
         new GetListFilesRequest(FolderName, StorageName));
        if (filesResponse.Status.Equals("OK"))
            return View("ApiError", filesResponse);
        // Get .pdf files only
        var filesInCloudFolder =
            filesResponse.Files.Where(f => f.IsFolder == false || f.Name.EndsWith(".pdf",
                                        StringComparison.OrdinalIgnoreCase)).ToList();
        return View(filesInCloudFolder);
    }
//... other actions are omitted
}

Also, we need to create an Index view. We will show the data in a tabular form. One table row will contain the name, size, modified date of one file and links for converter actions.

Step 3. Add converter action

As you can see in the previous step we will use ConvertPDF action with 2 parameters: filename and desired format.

public ActionResult ConvertPDF(string filename, string format)
{
    if (string.IsNullOrEmpty(filename) || string.IsNullOrEmpty(format))
        return RedirectToAction("Index");
    format = format.ToLowerInvariant();           
    try
    {
        string outPath;
        switch (format)
        {
            case "tiff":
                outPath = $"{FolderName}/{format}/{filename.Replace("pdf", "tif")}";
                _pdfApi.PutPdfInStorageToTiff(filename, outPath, folder: FolderName);
                break;

            case "docx":
                outPath = $"{FolderName}/{format}/{filename.Replace("pdf", "docx")}";
                _pdfApi.PutPdfInStorageToDoc(filename, outPath, folder: FolderName, format: "docx");
                break;                    
            case "pdfa":
                outPath = $"{FolderName}/{format}/{filename}";
                _pdfApi.PutPdfInStorageToPdfA(filename, outPath, type: "PDFA1A", folder: FolderName);
                break;
            case "html":
                outPath = $"{FolderName}/{format}/{filename.Replace("pdf", "zip")}";
                _pdfApi.PutPdfInStorageToHtml(filename, outPath, folder: FolderName);
                break;
            case "svg":
                outPath = $"{FolderName}/{format}/{filename.Replace("pdf", "zip")}";
                _pdfApi.PutPdfInStorageToSvg(filename, outPath, folder: FolderName);
                break;
        }
    }
    catch (ApiException ex)
    {
        ViewBag.ErrorCode = ex.ErrorCode;
        ViewBag.ErrorMessage = ex.Message;
        return View();
    }

    ViewBag.Success = true;
    return View();
}

Despite the fact that we use the similar calls PutPdfInStorageTo... to convert to different formats, I must add some explanations.
In the simplest case, it's enough to call PutPdfInStorageTo... with two parameters: input filename and output file path. Other parameters are optional and they used as necessary, eg. folder - used, when we list the files in subfolders (not in root).

It should also be understood that the result of the conversion is not always a one-page document and some formats are multipage in their nature, but others are not. Also, we can't store additional resources in HTML. So if we will convert to TIFF or DOC/DOCX, we no need to care about multipage and resource storing, but for HTML or SVG we need it. Obviously, for the last two formats, we need some container. Aspose.PDF Cloud uses ZIP-archive as the container.

The last thought: some formats need to clarify their subtypes. This concerns, for example, to Microsoft Word DOC/DOCX or PDF/A-1a, PDF/A-1b.

Final step. View results and handle error

In this demo, we have a pretty straightforward view that only display a static message with result status.

To sum up: we considered a general algorithm how to use Aspose.PDF Cloud conversion API in ASP.NET MVC applications. What's next? In the next part, we will learn how to tune up the converter from PDF to other formats.

Rendering HTML5 Canvas to PDF documents using Aspose.HTML

Andriy Andruhovski — Mon, 04 Jun 2018 20:52:12 +0000

In many cases, HTML documents are used to create templates for various reports with subsequent conversion into PDF docs. The Canvas API is a powerful tool for creating images and it can also be used to place graphics in PDF documents. This API is used by writing JS-scripts that can access the canvas area through a full set of drawing functions, thus allowing for dynamically generated graphics.

Aspose.HTML supports two methods of accessing to canvas elements:

via JavaScript code - this is a traditional method and it is preferable when we use standard HTML docs;
via Aspose.HTML API - this method is more convenient for creating in-memory HTML docs;

Since the first method is very popular, we will consider only a small example of its usage.

As has been said before, we will use the Aspose.HTML API in the second method. This method has some differences from the previous, mainly because of the features of the .NET platform, but the main concept is the same.
As an example, consider the following problem: suppose that we need to generate a report for one (or several) images on which we need to mark certain regions (faces, animals, etc) and add it with text. Thus, our solution will consist of the following steps:

Generate a template;
Get details about the image (from external service);
Generate report as HTML document;
Convert HTML document to PDF one.

Step 1 is pretty straightforward:

In step 2, we will use Microsoft Cognitive Services (Face API). You may learn more about this service on Microsoft Docs. In short, we call the REST API and get the result with a set of detected faces with additional info.

Now we can add the data to report: modify canvas and add p element after the canvas. In order to modify canvas, we need to get the context of this element and make the drawing.

The resulting object from the previous step is an array, which contains rectangles, that describes face locations on the image. So, we run the loop and draw the rectangles in the manner as in JavaScript code. At the last, we add details as p elements below canvas.

Оbtained HTML document we can easily convert to PDF.

You can see full example here:

Aspose.PDF Cloud: Converting documents using C# SDK

Andriy Andruhovski — Tue, 29 May 2018 22:52:04 +0000

In the previous post, we taught upload files to Aspose.Cloud. Now we will consider basic steps to convert documents with Aspose.Cloud API v1.0.
For the first example, we will use converting HTML to PDF. Let assume for easy that source files will be located in "Html-Demo" folder on the default storage and we will store resultant files on "Pdf-Demo" folder.

As in the previous post, we create a console application, but now we will add two packages:

to manage storage (Install-Package Aspose.Storage-Cloud)
to manipulate documents (Install-Package Aspose.PDF-Cloud)

UPD: This post is valid for Aspose.PDF-Cloud v.18.8

The next step is to declare the necessary fields and constants in our class.

So, we are ready to convert our files from HTML to PDF. To get a list of files we call a GetListFiles method and filter the results.

All that's left to do is call a conversion API method PutCreateDocument with appropriate parameters. It should be noted that this method has parameters for several cases of converting, but we set values required only for this one:

name - destination filename (only name, not a path);
templateFile - the source file path;
templateType - the content type of source file, can be xml, html, bmp, jpg, png, tiff, emf, cgm, tex;
folder - destination folder;
storage - storage name.

In this case, we deal with an ApiException. This class is similar to the generic exception, but it has an additional field ErrorContent. This field usually holds JSON-string with the error message.

The following snippet holds the full code of our function:

As you can see above, we can convert to PDF from different file types. Let's try to change HTML to JPEG:

In this case, we get the PDF document too, but with raster image per file.
To combine a series of images into one PDF we need to call PutCreateDocumentFromImages method. The following snippet shows how we can combine JPEG files into one PDF. To reduce the explanation, named arguments were used.

So, in this post, we were considered how to create PDF from different formats. In the next article, we will consider the reverse process - converting from PDF to another file formats.

3 simple steps to start using Aspose.Cloud Storage

Andriy Andruhovski — Tue, 15 May 2018 16:31:27 +0000

Solving the problems of document processing, we often encounter the problem of getting source documents from different sources and from different providers. Aspose.Cloud Storage is a component of Aspose.Cloud platform, which releases a transparent interface for access to different sources. Now Aspose.Cloud Storage supports popular services from Amazon, Dropbox, Google, Microsoft. Let's see how we can use this component.

Step 1: Create an Aspose.Cloud account

We can create a free Aspose.Cloud account using the link "Create a new Account" on http://dashboard.aspose.cloud or sign in with GitHub or Google Account.

When registering, for each account an Aspose.Cloud Storage is created. We add another storage later, and now we are trying to access the current storage using C#. To do this we need to get an application credential.

Step 2: Get an Application credentials

Aspose.Cloud Application allows us to manage access to Cloud API. By default, each account has one application named "First App". Using the "My Apps" tab, we can see the list of all applications, change settings or get the credential.

The application credentials (App SID/App Key) are placed directly on the "First App" tile, but if you want to change the settings of the "First App", just click on tile heading. for testing purposes, we have enough default settings, so we will proceed to the next step, writing the client application. In this example, we will use a "Console Application" template in Microsoft Visual Studio 2017.

Step 3: Create a Client application

To demonstrate the main concept of the cloud storage working, we will write an application that will synchronize certain local folder with a cloud folder with the same name. So, let's start.

Create a console application (in VS2017 File->New->Project>Windows Classic Desktop->Console App);
Install Aspose.Storage for Cloud SDK (in Package Manager Console: Install-Package Aspose.Storage-Cloud)

Step 3a: Setup an API client

To be able making API requests, we must initialize an API client. It's pretty straightforward: declare StorageApi object and initialize it with AppKey and AppSID.

Step 3b: Write own code using API client

This part of our example will show the usage of most frequent API requests:

Check if a file exists
Create a folder
Get a list of files
Create (upload) file to cloud storage

It is worth noting, that all StorageApi methods accept a request object and returns a response object. All response objects have common properties such us Code and Status and we can use there to check if API call was successful.

According to our problem, we need to synchronize certain local folder with a cloud folder with the same name. So first, we must ensure that the cloud folder exists, otherwise create one. Storage API provides GetIsExist and PutCreateFolder.
Thus, checking if the cloud folder would look like this:

Next step, we prepare a file list for upload. What will we do? It's easy: we need to get a list of all files from the local folder and a list of files in the cloud. The difference of these lists give us a list of files need to upload.

Finally, we will call PutCreateDocument the loop through the resultant list.

Conclusion

Q: Is it one-way synchronizer?
A: Yes. It showed the main ways of usage Aspose.Cloud Storage, and you can improve it yourself.
Q: And what about other storages?
A: Learn more in the article "How to Configure 3rd Party Cloud Storages".
Q: What's next?
A: In the next posts, we will continue to deal with the Aspose.Cloud features.

Generating PDF file using C#

Andriy Andruhovski — Mon, 02 Apr 2018 07:40:00 +0000

In this post, I want to share some of my experience in generating PDF documents using Aspose.PDF for .NET and introduce basic render techniques.

As an example, I chose a frequently used document - an invoice. Our document will consist of 5 sections:

header section - contains the corporate logo and general info;
address section - contains the info about the seller and the customer;
grid section - contains the table of product items and the totals subsection;
terms section - contains the list of strings for additional;
footer - optional section with one string placed at the bottom of the page.

Disclaimer: please note, that Apose.PDF is a paid product, but a trial version is fully appropriate to make some experiments like creating a document up to 4 pages.

Step 0. Creating a model of the document. For convenient work, we will create several classes for describing invoice details.

Class LogoImage will be used for a render company logo in the upper left corner.

namespace Aspose.PDF.Invoicer
{
    public class LogoImage
    {
        public string FileName;
        public int Width;
        public int Height;

        public LogoImage(string filename, int width, int height)
        {
            FileName = filename;
            Width = width;
            Height = height;
        }
    }
}

Class TotalRow will be used for render row in the totals subsection.

namespace Aspose.PDF.Invoicer
{
    public class TotalRow
    {
        public string Text;
        public decimal Value;

        public TotalRow(string text, decimal value)
        {
            Text = text;
            Value = value;
        }                
    }
}

Class ProductItem represents one product item in the grid section.

namespace Aspose.PDF.Invoicer
{
    public class ProductItem
    {
        public string Id;
        public string Name;
        public decimal Price;
        public int Quantity;
        public decimal Total => Price * Quantity;

        public ProductItem(string id, string name, decimal price, int quantity)
        {
            Id = id;
            Name = name;
            Price = price;
            Quantity = quantity;
        }
    }
}

And the last class will be used to represent a PDF document.

using System;
using System.Collections.Generic;
using System.IO;
using Aspose.Pdf;
using Aspose.Pdf.Text;

namespace Aspose.PDF.Invoicer
{

    public class Invoice: IDisposable
    {
        #region Private memebers
        private static readonly License Licence = new License();
        private Color _textColor, _backColor;
        private readonly Font _timeNewRomanFont;
        private readonly TextBuilder _builder;
        private readonly Page _pdfPage;
        private readonly Document _pdfDocument;
        private readonly Rectangle _logoPlaceHolder;        
        #endregion

        public string ForegroundColor
        {
            get { return _textColor.ToString(); }
            set { _textColor = Color.Parse(value); }
        }
        public string BackgroundColor
        {
            get { return _backColor.ToString(); }
            set { _backColor = Color.Parse(value); }
        }

        //Invoice details
        public string Number;
        public uint PaymentPeriod = 14;
        public LogoImage Logo;
        public List<string> BillFrom;
        public List<string> BillTo;
        public List<ProductItem> Items;
        public List<TotalRow> Totals;
        public List<string> Details;
        public string Footer;

        public Invoice()
        {
            _pdfDocument = new Document();
            _pdfDocument.PageInfo.Margin.Left = 36;
            _pdfDocument.PageInfo.Margin.Right = 36;
            _pdfPage = _pdfDocument.Pages.Add();
            _textColor = Color.Black;
            _backColor = Color.Transparent;
            _logoPlaceHolder = new Rectangle(20, 700, 120, 800);
            _timeNewRomanFont = FontRepository.FindFont("Times New Roman");
            _builder = new TextBuilder(_pdfPage);
        }
        public void Save(Stream stream)
        {
            HeaderSection();
            AddressSection();
            GridSection();
            TermsSection();
            FooterSection();

            _pdfDocument.Save(stream);
        }
        private void HeaderSection()
        {
            // TODO: Generate header section
        }
        private void AddressSection()
        {
            // TODO: Generate Address section
        }
        private void GridSection()
        {
            // TODO: Generate Grid section
        }
        private void TermsSection()
        {
            // TODO: Generate Terms section
        }
        private void FooterSection()
        {
            // TODO: Generate Footer section
        }
        #region IDisposable Support
        private bool disposedValue = false; // To detect redundant calls

        protected virtual void Dispose(bool disposing)
        {
            if (!disposedValue)
            {
                if (disposing)
                {                    
                    _pdfPage.Dispose();
                    _pdfDocument.Dispose();
                }
                disposedValue = true;
            }
        }

        public void Dispose()
        {            
            Dispose(true);           
        }
        #endregion
    }
}

Step 1. Writing a simple application for testing. In this console application, we create the invoice with C:\aspose\company-logo-design.png as a logo image, 3 product items, some comments, and a demo footer.

using System.Collections.Generic;
using System.IO;
using System.Linq;
using Aspose.PDF.Invoicer;

namespace ConsoleDemo
{
    class Program
    {
        static void Main()
        {
            var productItems = new List<ProductItem> {
                new ProductItem ("1", "Chocolate with Milk", 166.66M, 20),
                new ProductItem ("2", "Chocolate with Nuts", 166.66M, 20),
                new ProductItem ("3", "Chocolate with Pepper", 166.66M, 20)
            };
            var subTotal = productItems.Sum(i => i.Total);
            var invoice = new Invoice
            {
                ForegroundColor = "#0000CC",
                BackgroundColor = "#FFFFFF",
                Number = "ABC-123",
                Logo = new LogoImage(@"C:\aspose\company-logo-design.png", 160, 120),
                BillFrom = new List<string> { "Eastern Chocolate Factory", "Eastern Chocolate House", "44 Shirley Ave.", "West Chicago", "IL 60185" },
                BillTo = new List<string> { "Eastern Chocolate Cafe", "Eastern Chocolate House", "44 Shirley Ave.", "West Chicago", "IL 60185" },
                Items = productItems,
                Totals = new List<TotalRow>
                {
                    new TotalRow("Sub Total", subTotal),
                    new TotalRow("VAT @ 20%", subTotal*0.2M),
                    new TotalRow("Total", subTotal*1.2M)
                },
                Details = new List<string> {
                    "Terms & Conditions",
                    "Payment is due within 15 days",
                    string.Empty,
                    "If you have any questions concerning this invoice, contact our sales department at sales@east-chocolate.factory",
                    "", "Thank you for your business."
                },
                Footer = "https://www.facebook.com/AsposePDF/"
            };


            var fileStream = new FileStream(@"C:\\aspose\\invoice.pdf", FileMode.OpenOrCreate);
            invoice.Save(fileStream);
            fileStream.Close();

        }
    }
}

Step 2. Rendering the header section. The Aspose.PDF library provides several ways to place elements in the document. The simplest way to place a sequence of elements with minimal settings is by using the Document Object Model. According to this conception, the Document object contains a collection of Page objects. This collection, in turn, contains a collection of BaseParagraph objects. Descendants of BaseParagraph is TextFragment, FloatingBox, Table etc.
We will use the TextFragment object to place lines "Invoice", "DATE:" and "DUE DATE". The first line will be centered, and the rest is right-aligned. Logo image breaks the hierarchy of DOM elements and must be placed in the upper left corner, so to place the logo we will apply another technique - adding a resource to the page. A detailed explanation of using resources is not the aim of this post. We will return to this technique in future posts. In short, we complete the following steps:

Add image to Images collection of Page Resources
Save current graphics state
Define a Matrix object for placing the image in the appropriate location
Apply matrix to the image
Restore graphics state

The following snippet contains the full implementation of the HeaderSection() method.

private void HeaderSection()
{
    var lines = new TextFragment[3];
    // Create text fragment
    lines[0] = new TextFragment($"INVOICE #{Number}");
    lines[0].TextState.FontSize = 20;
    lines[0].TextState.ForegroundColor = _textColor;
    lines[0].HorizontalAlignment = HorizontalAlignment.Center;

    _pdfPage.Paragraphs.Add(lines[0]);

    lines[1] = new TextFragment($"DATE: {DateTime.Today:MM/dd/yyyy}");
    lines[2] = new TextFragment($"DUE DATE: {DateTime.Today.AddDays(PaymentPeriod):MM/dd/yyyy}");
    for (var i = 1; i < lines.Length; i++)
    {
        // Set text properties                
        lines[i].TextState.Font = _timeNewRomanFont;
        lines[i].TextState.FontSize = 12;
        lines[i].HorizontalAlignment = HorizontalAlignment.Right;

        // Add fragment to paragraph
        _pdfPage.Paragraphs.Add(lines[i]);
    }
    // Logo 
    // Set coordinates
    _logoPlaceHolder.URX = _logoPlaceHolder.LLX + Logo.Width;
    _logoPlaceHolder.URY = _logoPlaceHolder.LLY + Logo.Height;


    // Load image into stream
    var imageStream = new FileStream(Logo.FileName, FileMode.Open);
    // Add image to Images collection of Page Resources
    _pdfPage.Resources.Images.Add(imageStream);
    // Using GSave operator: this operator saves current graphics state
    _pdfPage.Contents.Add(new Operator.GSave());
    // Create Rectangle and Matrix objects

    var matrix = new Matrix(new[] { _logoPlaceHolder.URX - _logoPlaceHolder.LLX, 0, 0,
        _logoPlaceHolder.URY - _logoPlaceHolder.LLY,
        _logoPlaceHolder.LLX, _logoPlaceHolder.LLY });
    // Using ConcatenateMatrix (concatenate matrix) operator: defines how image must be placed
    _pdfPage.Contents.Add(new Operator.ConcatenateMatrix(matrix));
    var ximage = _pdfPage.Resources.Images[_pdfPage.Resources.Images.Count];
    // Using Do operator: this operator draws image
    _pdfPage.Contents.Add(new Operator.Do(ximage.Name));
    // Using GRestore operator: this operator restores graphics state
    _pdfPage.Contents.Add(new Operator.GRestore());
}

Step 3. Rendering the address section. We apply the two-column layout with mirror alignment: the left column is left-aligned and the right column is right-aligned. Such fragments can be easily rendered with FloatingBox class. To perform this layout we need to complete 4 steps:

Create an object of the FloatingBox class;
Add text fragments to the left column;
Add 1 text fragment to the to the right column with properties IsFirstParagraphInColumn=true and HorizontalAlignment = HorizontalAlignment.Right;
Add the rest fragments to the right column with the right alignment.

The following snippet shows these steps:

private void AddressSection()
{
    var box = new FloatingBox(524, 120)
    {
        ColumnInfo =
        {
            ColumnCount = 2,
            ColumnWidths = "252 252"
        },
        Padding =
        {
            Top = 20
        }
    };
    TextFragment fragment;

    BillFrom.Insert(0, "FROM:");
    foreach (var str in BillFrom)
    {
        fragment = new TextFragment(str);
        fragment.TextState.Font = _timeNewRomanFont;
        fragment.TextState.FontSize = 12;
        // Add fragment to paragraph
        box.Paragraphs.Add(fragment);
    }

    fragment = new TextFragment("BILL TO:") { IsFirstParagraphInColumn = true };
    fragment.TextState.Font = _timeNewRomanFont;
    fragment.TextState.FontSize = 12;
    fragment.TextState.HorizontalAlignment = HorizontalAlignment.Right;
    box.Paragraphs.Add(fragment);

    foreach (var str in BillTo)
    {
        fragment = new TextFragment(str);
        fragment.TextState.Font = _timeNewRomanFont;
        fragment.TextState.FontSize = 12;
        fragment.TextState.HorizontalAlignment = HorizontalAlignment.Right;
        // Add fragment to paragraph
        box.Paragraphs.Add(fragment);
    }
    _pdfPage.Paragraphs.Add(box);
}

Step 4. Rendering the grid section. We will use the Table object to represent data in tabular format. First, we need to define table columns and the default decoration of cells. Please, note that the ColumnWidths property implicitly defines a number of columns by setting their widths. In our grid, we will use an inverse color scheme for header rows. The following algorithm is used to create table rows:

Call table.Rows.Add() to create the row and get the reference to the new row;
Call row.Cells.Add() to create each cell and get the reference to the new cell;
Set cell decoration if needed;

The totals subsection is created similarly, but for a better view, we join up the 4 first cells by using the ColSpan property.

private void GridSection()
{
    // Initializes a new instance of the Table
    var table = new Table
    {
        ColumnWidths = "26 257 78 78 78",
        Border = new BorderInfo(BorderSide.Box, 1f, _textColor),
        DefaultCellBorder = new BorderInfo(BorderSide.Box, 0.5f, _textColor),
        DefaultCellPadding = new MarginInfo(4.5, 4.5, 4.5, 4.5),
        Margin =
        {
            Bottom = 10
        },
        DefaultCellTextState =
        {
            Font = _timeNewRomanFont
        }
    };

    var headerRow = table.Rows.Add();
    var cell = headerRow.Cells.Add("#");
    cell.Alignment = HorizontalAlignment.Center;
    headerRow.Cells.Add("Item");
    headerRow.Cells.Add("Price");
    headerRow.Cells.Add("Quantity");
    headerRow.Cells.Add("Sum");
    foreach (Cell headerRowCell in headerRow.Cells)
    {
        headerRowCell.BackgroundColor = _textColor;
        headerRowCell.DefaultCellTextState.ForegroundColor = _backColor;
    }

    foreach (var productItem in Items)
    {
        var row = table.Rows.Add();
        cell = row.Cells.Add(productItem.Id);
        cell.Alignment = HorizontalAlignment.Center;
        row.Cells.Add(productItem.Name);
        cell = row.Cells.Add(productItem.Price.ToString("C2"));
        cell.Alignment = HorizontalAlignment.Right;
        cell = row.Cells.Add(productItem.Quantity.ToString());
        cell.Alignment = HorizontalAlignment.Right;
        cell = row.Cells.Add(productItem.Total.ToString("C2"));
        cell.Alignment = HorizontalAlignment.Right;
    }

    foreach (var totalRow in Totals)
    {
        var row = table.Rows.Add();
        var nameCell = row.Cells.Add(totalRow.Text);
        nameCell.ColSpan = 4;
        var textCell = row.Cells.Add(totalRow.Value.ToString("C2"));
        textCell.Alignment = HorizontalAlignment.Right;
    }

    _pdfPage.Paragraphs.Add(table);
}

Step 5. Rendering theTerms and Conditions section.
This section contains only text fragments, and their rendering is the same as described above.

private void TermsSection()
{
    foreach (var detail in Details)
    {
        var fragment = new TextFragment(detail);
        fragment.TextState.Font = _timeNewRomanFont;
        fragment.TextState.FontSize = 12;
        _pdfPage.Paragraphs.Add(fragment);
    }
}

Step 6. Rendering Footer section
According to the previously declared layout, the last section is optional and must be placed at the bottom of the page. That is means we can't use adding the text fragment to the paragraph collection because this adding placed our fragment already after the 'Terms and Conditions' section.
In this case, we need to use a TextBuilder class. This class helps us to place text in any location. Additionally, the following snippet shows how we can add a hyperlink to the text fragment.

private void FooterSection()
{
    var fragment = new TextFragment(Footer);
    var len = fragment.TextState.MeasureString(fragment.Text);
    fragment.Position = new Position(_pdfPage.PageInfo.Width / 2 - len / 2, 20);
    fragment.Hyperlink = new WebHyperlink(Footer);
    var builder = new TextBuilder(_pdfPage);

    builder.AppendText(fragment);
}

Conclusion

In this post, we considered how to create a simple PDF document from scratch. Most of the parameters such as font size, the width of the cell's border, column's width in the table are adjusted manually based on A4 page size.
It's obvious that we are able to tune these parameters in proportion to the size of the page, but this will slightly complicate the example, but will not change the technique of creating the document as a whole.

A fundamentally different approach is working with some templates and replacing part of the content.

Extract the text data from PDF file using Aspose.PDF for .NET

Andriy Andruhovski — Mon, 12 Mar 2018 22:54:24 +0000

While dealing with Portable Document Format files, at times, you might need to extract text from a PDF file.
Aspose.PDF several classes to extract the data:

The easiest way to extract the data from PDF is using TextFragmentAbsorber with the default options:

TextAbsorber performs text extraction and provides access to the result via Text object. In this case, we'll get all text data in one single object.
Call the Accept method on a particular page of the Document object. The Index is the particular page number from where text needs to be extracted.

Sometimes we need to extract the text from the particular area (i.e. the left upper corner of the page). TextAbsorber also can do it. We'll need to setup TextSearchOptions property. In the following example, we'll set up a LimitToPageBounds property and a Rectangle property. The last takes Rectangle object as a value and using this property, we can specify the region of the page from which we need to extract the text. In our example, the LimitToPageBounds property indicates that text is searched within the page bound and the Rectangle property indicates to the upper half of page.

The TextFragmentAbsorber object is basically used in text search scenario. When the search is completed the occurrences are represented as text fragments collection. The TextFragment object provides access to the search occurrence text, text properties, and allows to edit text and change the text state (font, font size, color etc).

The ParagraphAbsorber class performs the search for sections and paragraphs of text and provides access for rectangles and polygons that describe it in text coordinate space.

Export data to PDF using Aspose.PDF for .NET Core 2.0

Andriy Andruhovski — Mon, 19 Feb 2018 16:25:36 +0000

There are a number of tasks when for some reason it is more convenient to export data from databases to a PDF document without using the recently popular HTML to PDF conversion scheme. This article will show you how to generate a PDF document using the Aspose.PDF for .NET Core 2.0 library.

Using this library has some advantages:

It's a single cross-platform API for .NET/.NET Standard 2.0, Java, and Android platforms with native core, so you don't need additional dependencies;
Large set of data converters from/to PDF;
Wide range of functions for editing PDF and additional functions like signing, encryption, text extraction etc;
To demonstrate the solution, the standard template "ASP.NET Core Web Application / Web Application (Model-View-Controller)" was used.

Basics of generation PDF with Aspose.PDF

One of the most important classes in Aspose.PDF is a Document class. This class is a PDF rendering engine. To present a PDF structure, the Aspose.PDF library uses the Document-Page model, where:

Document - contains the properties of the PDF document including page collection;
Page - contains the properties of a specific page and various collections of elements associated with this page.

Therefore, to create a PDF document with Aspose.PDF, you should follow these steps:

Create the Document object;
Add the page (the Page object) for the Document object;
Create objects that are placed on the page (e.g. text fragment, table, etc.)
Add created items to the corresponding collection on the page (in our case it will be a paragraph collection);
Save the document as PDF file.

The most common problem is the output of data in a table format. The Table class is used to process tables. This class gives us the ability to create tables and place them in the document, using Rows and Cells. So, to create the table, you need to add the required number of rows and fill them with the appropriate number of cells.

The following example creates the table 4x10.

When initializing the Table object, the minimal skin settings were used:

ColumnWidths - width of columns (by default);
DefaultCellPadding - the default fields for the table cell;
Border - table frame attributes (style, thickness, color);
DefaultCellBorder - attributes of the cell frame (style, thickness, color).

As a result, we get the table 4x10 with equal-width columns.

Exporting Data from ADO.NET Objects

The Table class provides methods for interacting with ADO.NET data sources - ImportDataTable and ImportDataView. The first method imports data from the DataTable, the second from the DataView.
Premising that these objects are not very convenient for working in the MVC template, we will limit ourselves to a brief example. In this example (line 50), the ImportDataTable method is called and receives as parameters a DataTable instance and additional settings like the header flag and the initial position (rows/cols) for the data output.

Exporting Data from the Entity Framework

More relevant for .NET Core 2.0 is the import of data from ORM frameworks. In this case, it's a good idea to extend the Table class with extension methods for importing data from a simple list or from the grouped data. Let's give an example for one of the most popular ORMs - Entity Framework.

The Data Annotations attributes are often used to describe models and help us to create the table. Therefore, the following table generation algorithm was chosen for ImportEntityList:

lines 12-18: build a header row and add header cells according to the rule "If the DisplayAttribute is present, then take its value otherwise take the property name"
lines 50-53: build the data rows and add row cells according to the rule "If the attribute DataTypeAttribute is defined, then we check whether we need to make additional design settings for it, and otherwise just convert data to string and add to the cell;"

In this example, additional customizations were made for DataType.Currency (lines 32-34) and DataType.Date (lines 35-43), but you can add others if necessary.
The algorithm of the ImportGroupedData method is almost the same as the previous one. An additional GroupViewModel class is used, to store the grouped data.

Since we process groups, first we generate a line for the key value (lines 66-71), and after it - the lines of this group.

Saving result

The Document class has a Save method that allows you to save the result. In our case, the result is a file that will be downloaded by the client application (browser).

To sum up: this article shows you how to import data into tables in a new document. Adding a table to an existing document is also possible, but it is somewhat more complex and will be treated separately.