[PYTHON] Conversion de pdf en txt 2 [pyocr]

introduction

La dernière fois, j'ai utilisé pdfminer pour convertir de pdf en txt. Cependant, cela n'a pas fonctionné à cause du problème du pdf cible. Cette fois, nous travaillerons à résoudre le problème avec pyocr.

Article précédent https://qiita.com/ptxyasu/items/4180035bd0ccd789c858

Objectif

Extrayez le texte du pdf.

Ce qui a été utilisé

Cette fois, j'ai pensé à extraire du texte en utilisant pyocr. Cependant, pyocr a également converti de pdf en image en utilisant pdf2image pour extraire le texte de l'image.

[pyocr] https://gitlab.gnome.org/World/OpenPaperwork/pyocr [pdf2image]https://github.com/Belval/pdf2image

L'introduction de tesseract et pyocr a été faite en se référant aux articles suivants. https://qiita.com/nabechi6011/items/3a367ca94dbd208efcc7 https://github.com/tesseract-ocr/tesseract/wiki

Flux de processus

1. Veuillez saisir le nom du pdf suivi du nom du fichier pdf cible
2. Convertissez le fichier pdf en image
3. Créez un répertoire de résultats pour afficher les résultats
4. Extraction de texte de l'image avec pyocr
5. Exportez le résultat dans le fichier txt dans result

Est. Le programme est présenté à la fin de l'article.

résultat

Entrée: object1.pdf

production

object1.txt

8 CLASSES AND OBJECT-ORIENTED PROGRAMMING

We now turn our attention to our last major topic related to writing programs in
Python: using classes to organize programs around modules and data
abstractions.

Classes can be used in many different ways. In this book we emphasize using
them in the context of object-oriented programming. The key to object-
oriented programming is thinking about objects as collections of both data and
the methods that operate on that data.

The ideas underlying object-oriented programming are about forty years old, and
have been widely accepted and practiced over the last twenty years or so, In the
mid-1970s people began to write articles explaining the benefits of this approach
to programming. About the same time, the programming languages SmallTalk
(at Xerox PARC) and CLU (at MIT) provided linguistic support for the ideas. But
it wasn’t until the arrival of C++ and Java that it really took off in practice.

We have been implicitly relying on object-oriented programming throughout
most of this book. Back in Section 2.1.1 we said “Objects are the core things
that Python programs manipulate. Every object has a type that defines the
kinds of things that programs can do with objects of that type.” Since Chapter
5, we have relied heavily upon built-in types such as list and dict and the
methods associated with those types. But just as the designers of a
programming language can build in only a small fraction of the useful functions,
they can only build in only a small fraction of the useful types. We have already
looked at a mechanism that allows programmers to define new functions; we
now look at a mechanism that allows programmers to define new types.

 

8.1

Abstract Data Types and Classes

The notion of an abstract data type is quite simple. An abstract data type is a
set of objects and the operations on those objects. These are bound together so
that one can pass an object from one part of a program to another, and in doing
so provide access not only to the data attributes of the object but also to
operations that make it easy to manipulate that data.

The specifications of those operations define an interface between the abstract
data type and the rest of the program. The interface defines the behavior of the
operations—what they do, but not how they do it. The interface thus provides
an abstraction barrier that isolates the rest of the program from the data
structures, algorithms, and code involved in providing a realization of the type
abstraction.

Programming is about managing complexity in a way that facilitates change.
There are two powerful mechanisms available for accomplishing this:
decomposition and abstraction. Decomposition creates structure in a program,
and abstraction suppresses detail. The key is to suppress the appropriate

Dans la 10e ligne, des années environ, Dans le, est devenu., Mais à part ça, c'était correct. Eh bien, c'est parfait.

Ce que je ne pouvais pas faire avec le pdfminer précédent peut être fait en utilisant pyocr (tesseract)!

Puisqu'il a été fait avec l'image d'entrée cette fois, je pense que le texte peut être extrait du pdf créé en scannant les imprimés. Cette fois également, je prévois de coller ce texte extrait dans Google Traduction, La prochaine fois, je veux utiliser googletrans pour le changer en japonais par programmation.

programme

Le programme a été publié sur github https://github.com/ptxyasu/pdf2text

Le fichier pdf2text_pyocr.py suivant est exécuté. Changez le fichier pdf d'entrée en image par convert_from_path. Ensuite, passez les images à pyocr_read une par une.

pdf2text_pyocr.py

  
from pdf2image import convert_from_path
from pyocr_read import pyocr_read

path = input("Please input pdf name\n")
images = convert_from_path(path)

i = 0
path,e = path.split(".")
pdf2read = pyocr_read(path)

for image in images:
    pdf2read.oneshot_read(image)
    i += 1

Le pyocr_read.py suivant est appelé à partir du pdf2text_pyocr ci-dessus. Init () détermine l'outil pyocr et crée un répertoire pour stocker les résultats. Il détermine également la langue à reconnaître. La langue affichée dans "Langues disponibles" peut être sélectionnée. Par exemple, l'anglais est eng et le japonais est jpn Ensuite, extrayez le texte de l'image reçue de pdf2text_pyocr avec pyocr et écrivez la sortie dans un fichier.

pyocr_read.py

import pyocr
import pyocr.builders
import os

class pyocr_read(object):
    def __init__(self,path):
        self.path = path
        tools = pyocr.get_available_tools()
        if len(tools) == 0:
            print("No OCR tool found")
            sys.exit(1)
        self.tool = tools[0]

        langs = self.tool.get_available_languages()
        print("Available languages: %s" % ", ".join(langs))
        self.lang = input("Please input language you want to recognize : ")

        if os.path.exists("./result") != True:
            os.mkdir("./result")
        return

    def oneshot_read(self,img):
        txt = self.tool.image_to_string(img, lang=self.lang, builder=pyocr.builders.TextBuilder())
        print(txt)
        file = open("./result/"+ self.path + ".txt",mode = "a",encoding = "utf-8")
        file.write(txt+"\n")