Découpez une image avec python

Un historique de difficultés à découvrir ce qui peut être fait en utilisant Python et OCR (Tesseract-OCR est utilisé pour l'OCR)

Tout d'abord, lisons une feuille entière de l'objet à lire En raison de mes efforts pour lire des choses comme des timbres et des photos, je ne comprends pas le sens Même si je peux le lire, je ne connais pas la rupture entre les données À cause de cela, c'est inutile. Par conséquent, j'ai décidé de ne découper que les parties nécessaires et de les lire.

Si vous écrivez le code suivant, vous pouvez le placer n'importe où à partir du fichier image Vous pouvez découper et enregistrer l'image découpée sous un nom différent.

   from PIL import Image

#Ouvrir l'image avec PIL img_trim = Image.open ('nom du fichier image d'origine')

Découpez les coordonnées spécifiées

img_trim.crop ((x1, y1, x2, y2)). save ('Enregistrer le nom de l'image recadrée')

A ce rythme, il est nécessaire d'ajuster les coordonnées plusieurs fois pour découper la pièce souhaitée. Créons une application qui acquiert des coordonnées en actionnant la souris afin de rationaliser le travail de furtivité des coordonnées. Il existe différentes manières de créer une interface graphique telle que C # et VB, mais cette fois, je vais essayer un mécanisme pour créer une interface graphique Python appelée Kivy. Le travail d'installation aurait dû être effectué en installant Kivy avec pip. .. .. (Détails omis)

Définition de la partie de l'interface utilisateur (main.kv):

#:import hex_color kivy.utils.get_color_from_hex
<ImageWidget>:
    canvas.before:
    Color:
        rgb: 1,1,1
    Rectangle:
        pos: self.pos
        size: self.size
BoxLayout:
    orientation: 'horizontal'
    height: root.height
    width: root.width

    Image:
        id: img
        allow_stretch: True
        source: root.image_src

    BoxLayout:
        size: root.size
        orientation: 'vertical'
        width: 200

        Label:
            id: lbl_file_name
            color: 0, 0, 0, 1
            font_size: 20
            background_color: hex_color('#000000')
        Label:
            id: lbl_result
            color: 0, 0, 0, 1
            font_size: 20

Il est écrit comme une version simplifiée de HTML Puis la source du corps principal (main.py):

from kivy.app import App

de kivy.core.text import LabelBase, DEFAULT_FONT #Addition from kivy.config import Config depuis kivy.resources import resource_add_path #addition from kivy.properties import StringProperty from kivy.uix.widget import Widget from kivy.graphics import Line from kivy.graphics import Color from kivy.utils import get_color_from_hex from PIL import Image import math import os import pyocr import pyocr.builders

resource_add_path ('c: / Windows / Fonts') #Addition LabelBase.register (DEFAULT_FONT, 'msgothic.ttc') #Addition

Config.set('graphics', 'width', '1224')
Config.set('graphics', 'height', '768')  # 16:9

class ImageWidget(Widget):
    image_src = StringProperty('')

def __init__(self, **kwargs):
    super().__init__(**kwargs)
    self.image_src = 'read_img/0112-3.png'

self.ids.lbl_file_name.text = "Nom de fichier: \ n {}" .format (self.image_src) self.lines = []

def on_touch_down(self, touch):
    self.x1 = touch.x
    self.y1 = touch.y
    self.x2 = None
    self.y2 = None

def on_touch_move(self, touch):
    img = self.ids.img
    if touch.x > img.width:
        self.x2 = img.width
    else:
        self.x2 = touch.x
    if touch.y > img.height:
        self.y2 = 0
    else:
        self.y2 = touch.y

    for line in self.lines:
        self.canvas.remove(line)
    self.lines = []

    with self.canvas:

#Settings pour la ligne rouge Color(100, 0, 0) touch.ud['line'] = Line(points=[self.x1, self.y1, self.x2, self.y1, self.x2, self.y2, self.x1, self.y2], close='True') self.lines.append(touch.ud['line'])

Réglage pour faire une ligne brisée

        Color(1, 1, 1)
        touch.ud['line'] = Line(points=[self.x1, self.y1, self.x2, self.y1,
                                        self.x2, self.y2, self.x1, self.y2],
                                dash_offset=5, dash_length=3,
                                close='True')
        self.lines.append(touch.ud['line'])

def on_touch_up(self, touch):

Quitter si # événement touch_move ne s'est pas produit if self.x2 is None: return

Processus d'initialisation:

#Obtenir un objet IMG img = self.ids.img

Trouvez la taille de l'image redimensionnée:

    vs = img.norm_image_size

#Ouvrir l'image avec PIL img_trim = Image.open(self.image_src)

Obtenir la taille de l'image

    rs = img_trim.size

#Calculer l'échelle de l'image ratio = rs[0] / vs[0]

Trouvez la valeur du remplissage appliqué:

MEMO En supposant un alignement central (taille de l'objet image-taille d'affichage) / 2

    px = 0
    py = 0
    if img.width > vs[0]:
        px = (img.width - vs[0]) / 2
    if img.height > vs[1]:
        py = (img.height - vs[1]) / 2

Supprimer le remplissage des objets IMG

    x1 = (self.x1 - px) * ratio
    x2 = (self.x2 - px) * ratio
    y1 = (img.height - self.y1 - py) * ratio
    y2 = (img.height - self.y2 - py) * ratio

Trier les coordonnées de la position de découpe de petite à grande

    if x1 < x2:
        real_x1 = math.floor(x1)
        real_x2 = math.ceil(x2)
    else:
        real_x1 = math.floor(x2)
        real_x2 = math.ceil(x1)
    if y1 < y2:
        real_y1 = math.floor(y1)
        real_y2 = math.ceil(y2)
    else:
        real_y1 = math.floor(y2)
        real_y2 = math.ceil(y1)

Découpez les coordonnées spécifiées

    img_trim.crop((real_x1, real_y1, real_x2, real_y2)).save('write_img/test.png')

#Lire le texte de l'image self.read_image_to_string()

def read_image_to_string(self):
    try:

1. Passez le chemin Tesseract installé

        path_tesseract = r"C:\Program Files\Tesseract-OCR"
        if path_tesseract not in os.environ["PATH"].split(os.pathsep):
            os.environ["PATH"] += os.pathsep + path_tesseract

1. Acquisition du moteur OCR

        tools = pyocr.get_available_tools()
        tool = tools[0]

2. Lecture de l'image originale

        img = Image.open("write_img/test.png ")

3. Exécution OCR

        builder = pyocr.builders.TextBuilder(tesseract_layout=6)
        result = tool.image_to_string(img, lang="jpn", builder=builder)

self.ids.lbl_result.text = f "Résultat de lecture: \ n {result}" print(result) except Exception as ex: print(ex) self.ids.lbl_result.text = f "Résultat de lecture: \ nEchec"

class MainApp(App):
    def __init__(self, **kwargs):
        super(MainApp, self).__init__(**kwargs)

self.title = 'test'

def build(self):
    return ImageWidget()

if __name__ == '__main__':
    app = MainApp()
    app.run()

Déroulement du programme: Obtenez le point sur lequel vous avez cliqué lorsque vous avez cliqué Continuez à dessiner le cadre carré tout en faisant glisser Obtenez les coordonnées de fin lorsque vous cliquez dessus Le processus de découpe de l'image et de laisser OCR lire l'image est effectué.

point: Les coordonnées cliquées sur l'écran ne peuvent pas être utilisées même si elles sont appliquées à l'image d'origine Il est nécessaire de calculer les coordonnées réelles en tenant compte du contraste Il est nécessaire de considérer que le remplissage est inclus dans l'objet image sur l'interface graphique. Il faut également considérer que la direction de glissement de la souris est entourée en haut à gauche

À la suite de la lecture de l'OCR, ... Pas très précis lorsqu'il est exécuté sans aucun réglage Il semble que nous puissions ajuster les paramètres et faire diverses choses. En premier lieu, il peut y avoir un problème avec les performances de l'OCR. À l'avenir, j'aimerais sélectionner un moteur OCR, etc.