This repository contains
- A command-line tool to recognize text in documents.
- The official Go client for the Sight API. GoDoc here.
Download the latest executable from the releases page.
./sight receipt_1.jpg receipt_2.pdf -o recognized_text.json --prompt-api-key
You must specify an output file with -o
or --output
.
You must specify your API key with --prompt-api-key
or --api-key-file <filename>
. The latter flag expects a text file containing your API key on a single line.
Run ./sight
with no flags or arguments to display the full usage section and list all optional flags.
Mac and Linux users may need to run chmod u+x sight
on the downloaded executable before it can be executed.
Go to https://siftrics.com/, sign up for an account, then go to the Sight dashboard and create an API key.
Here's the GoDoc page.
Import this repository:
import "github.com/siftrics/sight"
Create a client (it is up to you to set up the variable apiKey
):
c := sight.NewClient(apiKey)
Recognize text in files:
pagesChan, err := client.Recognize("file1.png", "file2.jpeg", "file3.pdf")
if err != nil {
...
}
for {
page, isOpen := <- pagesChan
if !isOpen {
break
}
if page.Error != "" {
...
}
...
}
The Recognize
function accepts a variable number of strings as input:
func (c *Client) Recognize(filePaths ...string) (<-chan RecognizedPage, error)
The pages from pagesChan
are this type:
type RecognizedPage struct {
Error string
FileIndex int
PageNumber int
NumberOfPagesInFile int
RecognizedText []RecognizedText
}
type RecognizedText struct {
Text string
TopLeftX, TopLeftY, TopRightX, TopRightY int
BottomLeftX, BottomLeftY, BottomRightX, BottomRightY int
Confidence float64
}
The function (c *Client) RecognizeWords
has the same signature has Recognize
, but it returns word-level bounding boxes instead of sentence-level bounding boxes.
The Sight API can rotate and return input images so the majority of the recognized text is upright. Note that this feature is part of the "Advanced" Sight API and therefore each page processed with this behavior enabled is billed as 4 pages. To enable this behavior, call the RecognizeCfg
function with DoAutoRotate
set to true
:
pagesChan, err := c.RecognizeCfg(
sight.Config{
DoAutoRotate: true,
MakeSentences: true,
},
"invoice1.jpg",
"invoice2.jpg",
)
Now, the Base64Image
field will be set in the page
objects you receive from pagesChan
.
A common desire is to decode the images and write them to disk. Here's a snippet of code that does that:
f, err := os.Create("auto-rotated.png")
if err != nil {
...
}
defer f.Close()
if _, err := io.Copy(f, base64.NewDecoder(base64.StdEncoding, strings.NewReader(page.Base64Image))); err != nil {
...
}
Some images, particularly .jpeg images, use the EXIF data format. This data format contains a metadata field indicating the orientation of an image --- i.e., whether the image should be rotated 90 degrees, 180 degrees, flipped horizontally, etc., when viewing it in an image viewer.
This means that when you view such an image in Chrome, Firefox, Safari, or the stock Windows and Mac image viewer applications, it will appear upright, despite the fact that the underlying pixels of the image are encoded in a different orientation.
If you find your bounding boxes are rotated or flipped relative to your image, it is because the image decoder you are using to load images in your program obeys EXIF orientation, but the Sight API ignores it (or vice versa).
All the most popular imaging libraries in Go, such as "image" and "github.com/disintegration/imaging", ignore EXIF orientation. You should determine whether your image decoder obeys EXIF orientation and tell the Sight API to do the same thing. You can tell the Sight API to obey the EXIF orientation by calling the RecognizeCfg
function with DoExifRotate
set to true
:
pagesChan, err := c.RecognizeCfg(
sight.Config{
DoExifRotate: true,
MakeSentences: true,
},
"invoice1.jpg",
"invoice2.jpg",
)
By default, the Sight API ignores EXIF orientation.
It is possible to tell the Sight API to only recognize certain scripts (e.g., latin, cyrillic, etc.). To do this, pass script hint codes into the RecgonizeCfg
function:
pagesChan, err := c.RecognizeCfg(
sight.Config{
ScriptHints: []string{"latin", "cyrillic"},
},
"invoice1.jpg",
"invoice2.jpg",
)
By default, ScriptHints
is empty and the Sight API automatically detects scripts.
The cost of the service is $0.50 per 1,000 pages, which is one third the price of Google Cloud Vision and Amazon Textract.
The accuracy and capability of the Sight API is comparable to Google Cloud Vision. It can handle human handwriting.
go get -u github.com/siftrics/sight/...
This will place the executable command-line tool sight
in your $GOBIN
directory.
If that fails (due to environment variables, go tooling, etc.), you can try
$ git clone https://github.com/siftrics/sight
$ cd sight/cli
$ go build -o sight main.go
Now the sight
executable should be in your current working directory.