PyTesseract: eenvoudige Python optische tekenherkenning

Inleiding

mensen kunnen de inhoud van een afbeelding begrijpen door simpelweg te kijken. We zien de tekst op het beeld als tekst en kunnen het lezen.

Computers werken niet op dezelfde manier. Ze hebben iets concreters nodig, georganiseerd op een manier die ze kunnen begrijpen.

Dit is waar Optical Character Recognition (OCR) van start gaat. Of het nu gaat om het herkennen van auto-platen van een camera, of handgeschreven documenten die moeten worden omgezet in een digitale kopie, deze techniek is erg handig. Hoewel het niet altijd perfect, het is erg handig en maakt het een stuk gemakkelijker en sneller voor sommige mensen om hun werk te doen.

In dit artikel zullen we dieper ingaan op de diepte van optische tekenherkenning en de toepassingsgebieden ervan. We zullen ook een eenvoudig script bouwen in Python dat ons zal helpen karakters van afbeeldingen te detecteren en dit bloot te leggen door middel van een kolf applicatie voor een handiger interactie medium.

Wat is optische tekenherkenning?

optische tekenherkenning omvat de detectie van tekstinhoud op afbeeldingen en de vertaling van de afbeeldingen naar gecodeerde tekst die de computer gemakkelijk kan begrijpen. Een afbeelding met tekst wordt gescand en geanalyseerd om de tekens erin te identificeren. Bij identificatie wordt het teken geconverteerd naar machinaal gecodeerde tekst.

Hoe wordt dit werkelijk bereikt? Voor ons is tekst op een beeld gemakkelijk waarneembaar en zijn we in staat om tekens te detecteren en de tekst te lezen, maar voor een computer is het allemaal een reeks punten.

de afbeelding wordt eerst gescand en de tekst-en grafische elementen worden omgezet in een bitmap, die in wezen een matrix van zwarte en witte stippen is. Het beeld wordt dan vooraf verwerkt waar de helderheid en het contrast worden aangepast om de nauwkeurigheid van het proces te verbeteren.

de afbeelding is nu opgesplitst in zones die de gebieden van belang identificeren, zoals waar de afbeeldingen of tekst zich bevinden en dit helpt bij het aftrappen van het extractieproces. De gebieden die tekst bevatten kunnen nu verder worden opgesplitst in lijnen en woorden en tekens en nu is de software in staat om de tekens te matchen door middel van vergelijking en verschillende detectie-algoritmen. Het uiteindelijke resultaat is de tekst in het beeld dat we krijgen.

het proces is mogelijk niet 100% nauwkeurig en heeft mogelijk menselijke interventie nodig om bepaalde elementen die niet correct zijn gescand te corrigeren. Foutcorrectie kan ook worden bereikt met behulp van een woordenboek of zelfs Natural Language Processing (NLP).

De uitvoer kan nu worden geconverteerd naar andere media zoals word-documenten, PDF ‘ s of zelfs audio-inhoud via tekst-naar-spraak-technologieën.

gebruik van OCR

voorheen werd de digitalisering van documenten bereikt door de tekst handmatig op de computer te typen. Door middel van OCR, dit proces wordt gemakkelijker gemaakt als het document kan worden gescand, verwerkt en de tekst geëxtraheerd en opgeslagen in een bewerkbare vorm, zoals een word-document.

als u een documentscanner op uw telefoon hebt, zoals Adobe Scan, hebt u waarschijnlijk OCR-technologie in gebruik.

luchthavens kunnen OCR ook gebruiken om het proces van paspoortherkenning en extractie van informatie uit hen te automatiseren.

andere toepassingen van OCR omvatten automatisering van gegevensinvoerprocessen, detectie en herkenning van kentekenplaten van auto ‘ s.

wat we

voor dit OCR-project zullen gebruiken, zullen we de Python-Tesseract, of gewoon PyTesseract, bibliotheek gebruiken die een wrapper is voor Google ‘ s Tesseract-OCR-Engine.

Ik koos dit omdat het volledig open-source is en wordt ontwikkeld en onderhouden door de gigant die Google is. Volg deze instructies om Tesseract op uw machine te installeren, aangezien PyTesseract ervan afhankelijk is.

we zullen ook het kolf web framework gebruiken om onze eenvoudige OCR-server te maken waar we foto ’s kunnen maken via de webcam of foto’ s kunnen uploaden voor karakterherkenning.

We gaan ook Pipenv gebruiken omdat het ook de virtuele omgeving setup en requirements management afhandelt.

naast deze, zullen we ook de Pillow library gebruiken die een fork is van de Python Imaging Library (PIL) om het openen en manipuleren van afbeeldingen in vele formaten in Python af te handelen.

in dit bericht zullen we ons concentreren op PyTesseract, hoewel er andere Python-bibliotheken zijn die u kunnen helpen om tekst uit afbeeldingen te extraheren, zoals:

• Textract: dat gegevens uit PDF ‘ s kan extraheren, maar een zwaar pakket is.
• Pyocr: biedt meer detectieopties zoals zinnen, cijfers of woorden.

Setup

begin met het installeren van Pipenv met behulp van het volgende commando via Pip (voor het geval u het moet instellen, refereer hier naar).

$ pip install pipenv

maak de projectmap aan en start het project met het volgende commando:

$ mkdir ocr_server && cd ocr_server && pipenv install --three

We kunnen nu onze virtuele omgeving activeren en beginnen met het installeren van onze afhankelijkheden:

$ pipenv shell$ pipenv install pytesseract Pillow 

in het geval dat u Pipenv niet gebruikt, kunt u altijd de PIP en de virtuele omgeving benadering gebruiken. Volg de officiële documentatie om u te helpen met Pip en virtuele omgeving:

opmerking: in dat geval, in plaats van pipenv install Pillow, zal het commando pip install Pillowzijn.

implementatie

We gaan dit project in 2 fasen implementeren. In de eerste maken we het script, en in de volgende bouwen we een kolf applicatie om te fungeren als een interface.

OCR-Script

Met de installatie voltooid is, kunnen we nu een eenvoudige functie neemt een afbeelding en geeft de tekst aangetroffen in het beeld – is dit de kern van ons project:

try: from PIL import Imageexcept ImportError: import Imageimport pytesseractdef ocr_core(filename): """ This function will handle the core OCR processing of images. """ text = pytesseract.image_to_string(Image.open(filename)) # We'll use Pillow's Image class to open the image and pytesseract to detect the string in the image return textprint(ocr_core('images/ocr_example_1.png'))

De functie is heel eenvoudig, in de eerste 5 regels die we importeren Image van de Pillow bibliotheek en onze PyTesseract bibliotheek.

We maken en ocr_core functie die een bestandsnaam opneemt en de tekst in de afbeelding retourneert.

laten we eens kijken hoe het script presteert met een eenvoudige afbeelding die wat tekst bevat:

en bij het uitvoeren van het stuk code, worden we begroet met dit:

ons eenvoudige OCR script werkt! Dit was duidelijk een beetje gemakkelijk, want dit is digitale tekst, perfect en nauwkeurig, in tegenstelling tot handschrift. Er is veel meer dat we kunnen doen met de pytesseract bibliotheek, maar meer hierover later in de post.

laten we dit script eerst integreren in een kolf-toepassing, om het makkelijker te maken om afbeeldingen te uploaden en tekenherkenning uit te voeren.

Flashwebinterface

ons script kan worden gebruikt via de opdrachtregel, maar een Flashtoepassing zou het gebruiksvriendelijker en veelzijdiger maken. Bijvoorbeeld, we kunnen foto ’s uploaden via de website en krijgen de uitgepakte tekst weergegeven op de website of we kunnen foto’ s vastleggen via de webcamera en het uitvoeren van karakterherkenning op hen.

als u niet bekend bent met het kolf-framework, is dit een goede tutorial om u op de hoogte te houden.

laten we beginnen met het installeren van het Kolfpakket:

$ pipenv install Flask

nu definiëren we een basisroute:

from flask import Flaskapp = Flask(__name__)@app.route('/')def home_page(): return "Hello World!"if __name__ == '__main__': app.run()

sla het bestand op en voer uit:

$ python3 app.py

Als u uw browser opent en naar 127.0.0.1:5000 or localhost:5000 u zou “Hello world!”op de pagina. Dit betekent dat onze Flask app klaar is voor de volgende stappen.

We maken nu een templates map om onze HTML-bestanden te hosten. Laten we een eenvoudige index.html:

<!DOCTYPE html><html> <head> <title>Index</title> </head> <body> Hello World. </body></html>

laten we ook onze app.py aanpassen om onze nieuwe sjabloon te renderen:

from flask import Flask, render_templateapp = Flask(__name__)@app.route('/')def home_page(): return render_template('index.html')if __name__ == '__main__': app.run()

merk op dat we nu render_template en gebruikte het om het html-bestand te renderen. Als u uw Flask-app opnieuw opstart, moet u nog steeds zien ” Hello World!”op de homepage.

dat is genoeg op de kolf crash course, laten we nu ons OCR script integreren in de web applicatie.

eerst voegen we functionaliteit toe om afbeeldingen te uploaden naar onze Flask-app en geven ze door aan de ocr_core functie die we hierboven hebben geschreven. We zullen dan de afbeelding naast de geëxtraheerde tekst op onze web app renderen als resultaat:

import osfrom flask import Flask, render_template, request# import our OCR functionfrom ocr_core import ocr_core# define a folder to store and later serve the imagesUPLOAD_FOLDER = '/static/uploads/'# allow files of a specific typeALLOWED_EXTENSIONS = set()app = Flask(__name__)# function to check the file extensiondef allowed_file(filename): return '.' in filename and \ filename.rsplit('.', 1).lower() in ALLOWED_EXTENSIONS# route and function to handle the home [email protected]('/')def home_page(): return render_template('index.html')# route and function to handle the upload [email protected]('/upload', methods=)def upload_page(): if request.method == 'POST': # check if there is a file in the request if 'file' not in request.files: return render_template('upload.html', msg='No file selected') file = request.files # if no file is selected if file.filename == '': return render_template('upload.html', msg='No file selected') if file and allowed_file(file.filename): # call the OCR function on it extracted_text = ocr_core(file) # extract the text and display it return render_template('upload.html', msg='Successfully processed', extracted_text=extracted_text, img_src=UPLOAD_FOLDER + file.filename) elif request.method == 'GET': return render_template('upload.html')if __name__ == '__main__': app.run()

zoals we kunnen zien in onze upload_page() functie, zullen we de afbeelding via POST ontvangen en de upload HTML renderen als het verzoek GET is.

We controleren of de gebruiker een bestand echt heeft geüpload en gebruiken de functie allowed_file() om te controleren of het bestand van een aanvaardbaar type is.

nadat we hebben gecontroleerd of de afbeelding van het vereiste type is, geven we het door aan het tekenherkenningsscript dat we eerder hebben gemaakt.

De functie detecteert de tekst in de afbeelding en geeft deze terug. Tot slot, als reactie op de afbeelding upload, maken we de gedetecteerde tekst naast de afbeelding zodat de gebruiker de resultaten kan zien.

het upload.html bestand behandelt het posten van de afbeelding en het renderen van het resultaat met behulp van de Jinja templating engine, die standaard met kolf wordt geleverd:

<!DOCTYPE html><html> <head> <title>Upload Image</title> </head> <body> {% if msg %} <h1>{{ msg }}</h1> {% endif %} <h1>Upload new File</h1> <form method=post enctype=multipart/form-data> <p><input type=file name=file> <input type=submit value=Upload> </form> <h1>Result:</h1> {% if img_src %} <img src="{{ img_src }}"> {% endif %} {% if extracted_text %} <p> The extracted text from the image above is: <b> {{ extracted_text }} </b></p> {% else %} The extracted text will be displayed here {% endif %} </body></html>

Jinja templating stelt ons in staat om tekst in specifieke scenario ‘ s weer te geven via de {% if %} {% endif %} tags. We kunnen ook berichten van onze Flask-app doorgeven om te worden weergegeven op de webpagina binnen de{{ }} tags. We gebruiken een formulier om de afbeelding te uploaden naar onze Flask app.

het resultaat is:

nu, als we doorgaan en onze afbeelding uploaden van eerder:

Ja! Onze kolf applicatie is in staat geweest om de OCR-functionaliteit te integreren en de tekst in de browser weer te geven. Dit maakt het makkelijker om afbeeldingen te verwerken in plaats van het uitvoeren van opdrachten op de CLI elke keer dat we een nieuwe afbeelding te verwerken.

laten we wat meer afbeeldingen toevoegen om de grenzen van ons eenvoudige OCR-script verder te verkennen, omdat het niet in alle situaties zal werken.

bijvoorbeeld, laten we proberen tekst uit de volgende afbeelding te halen en het resultaat is gemarkeerd op de afbeelding:

Dit is het bewijs dat OCR niet altijd 100% accuraat is en van tijd tot tijd menselijke interventie nodig kan hebben.

Ik heb het OCR-script ook getest op mijn handschrift om te zien hoe het zou werken, en dit is het resultaat:

zoals u kunt zien, kan het geen tekst uit mijn handschrift halen zoals het deed met andere afbeeldingen die we eerder hebben gezien. Ik besloot het nog een keer te proberen, deze keer met een afbeelding van deze bron, en dit waren de resultaten:

De tekenherkenning op deze afbeelding is veel beter dan die waar ik mijn eigen handschrift gebruikte. Zoals je kunt zien zijn de regels in de gedownloade afbeelding dikker en is er een beter contrast tussen de tekst en de achtergrond en dit zou de reden kunnen zijn voor de slechte detectie op mijn handschrift.

Dit is een gebied om verder te verkennen, u kunt handgeschreven notities krijgen van vrienden of collega ‘ s en zien hoe goed het script karakters kan detecteren. U kunt zelfs posters naar evenementen en probeer ze te scannen op tekst, de mogelijkheden zijn talrijk.

andere PyTesseract-opties

Python-Tesseract heeft meer opties die u kunt verkennen. Voor voorbeeld, kunt u de taal opgeven met behulp van een lang vlag:

pytesseract.image_to_string(Image.open(filename), lang='fra')

Dit is het resultaat van het scannen van een beeld, zonder de lang vlag:

En nu met de lang vlag:

het framework is ook geoptimaliseerd om talen beter te detecteren zoals te zien is in de schermafbeeldingen. (Bron van de afbeelding).

zonder de vlag lang miste het script enkele Franse woorden, maar na de introductie van de vlag kon het alle Franse inhoud detecteren. Vertaling is niet mogelijk, maar dit is nog steeds indrukwekkend. De officiële documentatie van Tesseract bevat de ondersteunde talen in deze sectie.

oriëntatie en scriptdetectie behoren ook tot de mogelijkheden van PyTesseract en dit helpt bij de detectie van de gebruikte lettertypen en de oriëntatie van de tekst op de gegeven afbeelding. Als we verwijzen naar de eerder gedownloade handgeschreven afbeelding:

print(pytesseract.image_to_osd(Image.open('downloaded_handwritten.png')))

Er was geen paginanummerinformatie op de afbeelding, dus dit werd niet gedetecteerd. De Tesseract engine is in staat om informatie te extraheren over de oriëntatie van de tekst in de afbeelding en rotatie. De oriëntatie vertrouwen is een cijfer van de zekerheid van de motor over de gedetecteerde oriëntatie te fungeren als een gids en om ook te laten zien dat het niet altijd 100% accuraat. De scriptsectie geeft het schrijfsysteem aan dat in de tekst wordt gebruikt en dit wordt ook gevolgd door de vertrouwensmarkering.

als we achter de herkende karakters en hun kadergrenzen aan zaten, bereikt PyTesseract dit via pytesseract.image_to_boxes(Image.open('downloaded_handwritten.png')).

Dit zijn enkele van de mogelijkheden van PyTesseract, zoals het omzetten van de geëxtraheerde tekst in een doorzoekbare PDF of HOCR-uitvoer.

wat we niet gedaan hebben

we hebben veel bereikt in dit bericht, maar er is nog meer te doen om ons project te verfijnen en voor te bereiden op de echte wereld. Ten eerste kunnen we stijl toevoegen aan onze website en maken het aantrekkelijker voor de eindgebruiker met behulp van CSS. We kunnen ook de optie Toevoegen om meerdere afbeeldingen tegelijk te uploaden en te scannen en al hun uitvoer tegelijk weer te geven. Zou dit het niet handiger maken om meerdere documenten te scannen?

de browser stelt ons in staat om in de camera van een machine te tappen en afbeeldingen vast te leggen, met toestemming van de gebruiker natuurlijk. Dit kan van grote hulp zijn, vooral op mobiele apparaten. In plaats van dat de gebruiker moet vastleggen en opslaan van de afbeelding vervolgens uploaden op de website, als we de camera-functionaliteit toe te voegen, kunnen we de gebruiker toestaan om de bewerkingen rechtstreeks uit te voeren vanuit de kolf webapplicatie. Dit zal het scanproces sneller te maken.

stel dat een kolf-toepassing niet bedoeld is om uw OCR-scanner bloot te leggen, dan kunt u ook een CLI-tool maken. De tool zou u toelaten om een commando met inbegrip van de locatie van de afbeelding uit te voeren en vervolgens het afdrukken van de uitvoer van de scanner naar uw terminal of het verzenden van het naar een database of API. Als je dit pad kiest is Docopt een fantastisch hulpmiddel voor het bouwen van command line tools met behulp van Python.

conclusie

door middel van Tesseract en de Python-Tesseract bibliotheek, zijn we in staat geweest om afbeeldingen te scannen en tekst uit hen te extraheren. Dit is Optische karakterherkenning en het kan in veel situaties van groot nut zijn.

we hebben een scanner gebouwd die een afbeelding neemt en de tekst in de afbeelding retourneert en deze als interface in een kolf-toepassing integreert. Dit stelt ons in staat om de functionaliteit bloot te leggen in een meer vertrouwd medium en op een manier die meerdere mensen tegelijk kan bedienen.