Package extractor

Overview ▾

Package extractor is used for quickly extracting PDF content through a simple interface. Currently offers functionality for extracting textual content.

Index ▾

Package files

const.go doc.go extractor.go font.go image.go text.go text_bag.go text_bound.go text_const.go text_line.go text_mark.go text_page.go text_para.go text_ruling.go text_table.go text_utils.go text_word.go utils.go

type Extractor

Extractor stores and offers functionality for extracting content from PDF pages.

type Extractor struct {
    // contains filtered or unexported fields

func New

func New(page *model.PdfPage) (*Extractor, error)

New returns an Extractor instance for extracting content from the input PDF page.

func NewFromContents

func NewFromContents(contents string, resources *model.PdfPageResources) (*Extractor, error)

NewFromContents creates a new extractor from contents and page resources.

func (*Extractor) ExtractFonts

func (e *Extractor) ExtractFonts(previousPageFonts *PageFonts) (*PageFonts, error)

ExtractFonts returns all font information from the page extractor, including font name, font type, the raw data of the embedded font file (if embedded), font descriptor and more.

The argument `previousPageFonts` is used when trying to build a complete font catalog for multiple pages or the entire document. The entries from `previousPageFonts` are added to the returned result unless already included in the page, i.e. no duplicate entries.

NOTE: If previousPageFonts is nil, all fonts from the page will be returned. Use it when building up a full list of fonts for a document or page range.

func (*Extractor) ExtractPageImages

func (e *Extractor) ExtractPageImages(options *ImageExtractOptions) (*PageImages, error)

ExtractPageImages returns the image contents of the page extractor, including data and position, size information for each image. A set of options to control page image extraction can be passed in. The options parameter can be nil for the default options. By default, inline stencil masks are not extracted.

func (*Extractor) ExtractPageText

func (e *Extractor) ExtractPageText() (*PageText, int, int, error)

ExtractPageText returns the text contents of `e` (an Extractor for a page) as a PageText. TODO(peterwilliams97): The stats complicate this function signature and aren't very useful.

Replace with a function like Extract() (*PageText, error)

func (*Extractor) ExtractText

func (e *Extractor) ExtractText() (string, error)

ExtractText processes and extracts all text data in content streams and returns as a string. It takes into account character encodings in the PDF file, which are decoded by CharcodeBytesToUnicode. Characters that can't be decoded are replaced with MissingCodeRune ('\ufffd' = �).

func (*Extractor) ExtractTextWithStats

func (e *Extractor) ExtractTextWithStats() (extracted string, numChars int, numMisses int, err error)

ExtractTextWithStats works like ExtractText but returns the number of characters in the output (`numChars`) and the number of characters that were not decoded (`numMisses`).

type Font

Font represents the font properties on a PDF page.

type Font struct {
    PdfFont *model.PdfFont

    // FontName represents Font Name from font properties.
    FontName string

    // FontType represents Font Subtype entry in the font dictionary inside page resources.
    // Examples : type0, Type1, MMType1, Type3, TrueType, CIDFont.
    FontType string

    // ToUnicode is true if font provides a `ToUnicode` mapping.
    ToUnicode bool

    // IsCID is true if underlying font is a composite font.
    // Composite font is represented by a font dictionary whose Subtype is `Type0`
    IsCID bool

    // IsSimple is true if font is simple font.
    // A simple font is limited to only 8 bit (255) character codes.
    IsSimple bool

    // FontData represents the raw data of the embedded font file.
    // It can have format TrueType (TTF), PostScript Font (PFB) or Compact Font Format (CCF).
    // FontData value can be indicates from `FontFile`, `FontFile2` or `FontFile3` inside Font Descriptor.
    // At most, only one of `FontFile`, `FontFile2` or `FontFile3` will be FontData value.
    FontData []byte

    // FontFileName is a name representing the font. it has format:
    // (Font Name) + (Font Type Extension), example: helvetica.ttf.
    FontFileName string

    // FontDescriptor represents metrics and other attributes inside font properties from PDF Structure (Font Descriptor).
    FontDescriptor *model.PdfFontDescriptor

type ImageExtractOptions

ImageExtractOptions contains options for controlling image extraction from PDF pages.

type ImageExtractOptions struct {
    IncludeInlineStencilMasks bool

type ImageMark

ImageMark represents an image drawn on a page and its position in device coordinates. All coordinates are in device coordinates.

type ImageMark struct {
    Image *model.Image

    // Dimensions of the image as displayed in the PDF.
    Width  float64
    Height float64

    // Position of the image in PDF coordinates (lower left corner).
    X float64
    Y float64

    // Angle in degrees, if rotated.
    Angle float64

type PageFonts

PageFonts represents extracted fonts on a PDF page.

type PageFonts struct {
    Fonts []Font

type PageImages

PageImages represents extracted images on a PDF page with spatial information: display position and size.

type PageImages struct {
    Images []ImageMark

type PageText

PageText represents the layout of text on a device page.

type PageText struct {
    // contains filtered or unexported fields

func (*PageText) ApplyArea

func (pt *PageText) ApplyArea(bbox model.PdfRectangle)

ApplyArea processes the page text only within the specified area `bbox`. Each time ApplyArea is called, it updates the result set in `pt`. Can be called multiple times in a row with different bounding boxes.

func (PageText) Marks

func (pt PageText) Marks() *TextMarkArray

Marks returns the TextMark collection for a page. It represents all the text on the page.

func (PageText) String

func (pt PageText) String() string

String returns a string describing `pt`.

func (PageText) Tables

func (pt PageText) Tables() []TextTable

Tables returns the tables extracted from the page.

func (PageText) Text

func (pt PageText) Text() string

Text returns the extracted page text.

func (PageText) ToText

func (pt PageText) ToText() string

ToText returns the page text as a single string. Deprecated: This function is deprecated and will be removed in a future major version. Please use Text() instead.

type RenderMode

RenderMode specifies the text rendering mode (Tmode), which determines whether showing text shall cause glyph outlines to be stroked, filled, used as a clipping boundary, or some combination of the three. Stroking, filling, and clipping shall have the same effects for a text object as they do for a path object (see 8.5.3, "Path-Painting Operators" and 8.5.4, "Clipping Path Operators").

type RenderMode int

Render mode type.

const (
    RenderModeStroke RenderMode = 1 << iota // Stroke
    RenderModeFill                          // Fill
    RenderModeClip                          // Clip

type TableCell

TableCell is a cell in a TextTable.

type TableCell struct {
    // Text is the extracted text.
    Text string
    // Marks returns the TextMarks corresponding to the text in Text.
    Marks TextMarkArray

type TextMark

TextMark represents extracted text on a page with information regarding both textual content, formatting (font and size) and positioning. It is the smallest unit of text on a PDF page, typically a single character.

getBBox() in test_text.go shows how to compute bounding boxes of substrings of extracted text. The following code extracts the text on PDF page `page` into `text` then finds the bounding box `bbox` of substring `term` in `text`.

ex, _ := New(page)
// handle errors
pageText, _, _, err := ex.ExtractPageText()
// handle errors
text := pageText.Text()
textMarks := pageText.Marks()

	start := strings.Index(text, term)
 end := start + len(term)
 spanMarks, err := textMarks.RangeOffset(start, end)
 // handle errors
 bbox, ok := spanMarks.BBox()
 // handle errors
type TextMark struct {
    // Text is the extracted text.
    Text string
    // Original is the text in the PDF. It has not been decoded like `Text`.
    Original string
    // BBox is the bounding box of the text.
    BBox model.PdfRectangle
    // Font is the font the text was drawn with.
    Font *model.PdfFont
    // FontSize is the font size the text was drawn with.
    FontSize float64
    // Offset is the offset of the start of TextMark.Text in the extracted text. If you do this
    //   text, textMarks := pageText.Text(), pageText.Marks()
    //   marks := textMarks.Elements()
    // then marks[i].Offset is the offset of marks[i].Text in text.
    Offset int
    // Meta is set true for spaces and line breaks that we insert in the extracted text. We insert
    // spaces (line breaks) when we see characters that are over a threshold horizontal (vertical)
    //  distance  apart. See wordJoiner (lineJoiner) in PageText.computeViews().
    Meta bool
    // FillColor is the fill color of the text.
    // The color is nil for spaces and line breaks (i.e. the Meta field is true).
    FillColor color.Color
    // StrokeColor is the stroke color of the text.
    // The color is nil for spaces and line breaks (i.e. the Meta field is true).
    StrokeColor color.Color
    // Orientation is the text orientation
    Orientation int

func (TextMark) String

func (tm TextMark) String() string

String returns a string describing `tm`.

type TextMarkArray

TextMarkArray is a collection of TextMarks.

type TextMarkArray struct {
    // contains filtered or unexported fields

func (*TextMarkArray) Append

func (ma *TextMarkArray) Append(mark TextMark)

Append appends `mark` to the mark array.

func (*TextMarkArray) BBox

func (ma *TextMarkArray) BBox() (model.PdfRectangle, bool)

BBox returns the smallest axis-aligned rectangle that encloses all the TextMarks in `ma`.

func (*TextMarkArray) Elements

func (ma *TextMarkArray) Elements() []TextMark

Elements returns the TextMarks in `ma`.

func (*TextMarkArray) Len

func (ma *TextMarkArray) Len() int

Len returns the number of TextMarks in `ma`.

func (*TextMarkArray) RangeOffset

func (ma *TextMarkArray) RangeOffset(start, end int) (*TextMarkArray, error)

RangeOffset returns the TextMarks in `ma` that overlap text[start:end] in the extracted text. These are tm: `start` <= tm.Offset + len(tm.Text) && tm.Offset < `end` where `start` and `end` are offsets in the extracted text. NOTE: TextMarks can contain multiple characters. e.g. "ffi" for the ffi ligature so the first and last elements of the returned TextMarkArray may only partially overlap text[start:end].

func (TextMarkArray) String

func (ma TextMarkArray) String() string

String returns a string describing `ma`.

type TextTable

TextTable represents a table. Cells are ordered top-to-bottom, left-to-right. Cells[y] is the (0-offset) y'th row in the table. Cells[y][x] is the (0-offset) x'th column in the table.

type TextTable struct {
    W, H  int
    Cells [][]TableCell