Automatisation des tests à partir de la caméra Web intégrée L-Chika (5) et de l'OCR

1.Tout d'abord

Il s'agit de la 5ème série d'automatisation de tests commençant par L Chika.

Technologie des éléments d'essai d'automatisation des tests d'acceptation avec M5Stack et Python Capture d'image de la caméra Web, découpe d'image, programme de test OCR réalisé avec un shell interactif Intégrez et automatisez.

S'il vous plaît voir ici pour les articles jusqu'à présent.

  1. Automatisation des tests à partir de L Chika
  2. Automatisation des tests à partir de L Chika (2) Amélioration de la maintenabilité des scripts de test
  3. Automatisation des tests à partir de l'incorporation de l'oscilloscope L-Chika (3)
  4. Automatisation des tests à partir de L Chika (4) Amélioration de la maintenabilité des scripts de test (2)

2. Réparation du testeur

--Créez les commandes et fonctions suivantes.

|commander|argument|une fonction |--------+--------+-------- |open_cam|Numéro de l'appareil photo|Exécutez OpenCV Video Capture |close_cam|Aucun|Libérez OpenCV Video Capture |capture_cam|nom de fichier|Capturez l'image de la caméra et enregistrez-la dans un fichier |crop_img|Nom du fichier d'entrée
Position de découpe (verticale)
Position de découpe (horizontale)
Nom du fichier de sortie|Découpez la zone spécifiée du fichier image et enregistrez-la dans le fichier |open_ocr|Aucun|Rendre PyOCR disponible |exec_ocr|Nom du fichier image à appliquer à l'OCR|Chaînes OCR US ASCII à partir de fichiers image

test-runner.py


#!/usr/bin/python3

#
# This software includes the work that is distributed in the Apache License 2.0
#

from time import sleep
import serial
import codecs
import csv
import sys
import visa
import cv2
from PIL import Image
import pyocr
import pyocr.builders

UNINITIALIZED = 0xdeadbeef

def open_cam(camera_number):
    return cv2.VideoCapture(camera_number)

def close_cam(cam):
    if cam != UNINITIALIZED:
        cam.release()

def capture_cam(cam, filename):
    if cam != UNINITIALIZED:
        _, img = cam.read()
        cv2.imwrite(filename, img)
        return True
    else:
        print("CAM Not Ready.")
        return False

def crop_img(filename_in, v, h, filename_out):
    img = cv2.imread(filename_in, cv2.IMREAD_COLOR)
    v0 = int(v.split(':')[0])
    v1 = int(v.split(':')[1])
    h0 = int(h.split(':')[0])
    h1 = int(h.split(':')[1])
    img2 = img[v0:v1, h0:h1]
    cv2.imwrite(filename_out, img2)
    return True

def open_ocr():
    ocr = pyocr.get_available_tools()
    if len(ocr) != 0:
        ocr = ocr[0]
    else:
        ocr = UNINITIALIZED
        print("OCR Not Ready.")
    return ocr

def exec_ocr(ocr, filename):
    try:
        txt = ocr.image_to_string(
            Image.open(filename),
            lang = "eng",
            builder = pyocr.builders.TextBuilder()
        )
    except:
        print("OCR Not Ready.")
    else:
        return txt

def serial_write(h, string):
    if h != UNINITIALIZED:
        string = string + '\n'
        string = str.encode(string)
        h.write(string)
        return True
    else:
        print("UART Not Initialized.")
        return False

def open_dso():
    rm = visa.ResourceManager()
    resources = rm.list_resources()
    #print(resources)
    for resource in resources:
        #print(resource)
        try:
            dso = rm.open_resource(resource)
        except:
            print(resource, "Not Found.")
        else:
            print(resource, "Detected.")
            return dso

    #Throw an error to caller if none succeed.
    return dso

def main():
    is_passed = True
    val = str(UNINITIALIZED)
    cam = UNINITIALIZED
    ocr = UNINITIALIZED
    dso = UNINITIALIZED
    uart = UNINITIALIZED

    with codecs.open('script.csv', 'r', 'utf-8') as file:
        script = csv.reader(file, delimiter=',', lineterminator='\r\n', quotechar='"')

        with codecs.open('result.csv', 'w', 'utf-8') as file:
            result = csv.writer(file, delimiter=',', lineterminator='\r\n', quotechar='"')

            for cmd in script:
                print(cmd)

                if "#" in cmd[0]:
                    pass

                elif cmd[0] == "sleep":
                    sleep(float(cmd[1]))

                elif cmd[0] == "open_cam":
                    cam = open_cam(int(cmd[1]))

                elif cmd[0] == "close_cam":
                    close_cam(cam)
                    cam = UNINITIALIZED

                elif cmd[0] == "capture_cam":
                    ret = capture_cam(cam, cmd[1])
                    if ret == False:
                        is_passed = False

                elif cmd[0] == "crop_img":
                    crop_img(cmd[1], cmd[2], cmd[3], cmd[4])

                elif cmd[0] == "open_ocr":
                    ocr = open_ocr()
                    if ocr == UNINITIALIZED:
                        is_passed = False

                elif cmd[0] == "exec_ocr":
                    try:
                        val = exec_ocr(ocr, cmd[1])
                    except:
                        is_passed = False
                    else:
                        cmd.append(str(val))

                elif cmd[0] == "open_dso":
                    try:
                        dso = open_dso()
                    except:
                        is_passed = False

                elif cmd[0] == "dso":
                    try:
                        if "?" in cmd[1]:
                            val = dso.query(cmd[1]).rstrip().replace(",", "-")
                            cmd.append(val)
                        else:
                            dso.write(cmd[1])
                    except:
                        is_passed = False

                elif cmd[0] == "open_uart":
                    try:
                        uart = serial.Serial(cmd[1], 115200, timeout=1.0, dsrdtr=1)
                    except:
                        is_passed = False

                elif cmd[0] == "send":
                    ret = serial_write(uart, cmd[1])
                    if ret == False:
                        is_passed = False

                elif cmd[0] == "rcvd":
                    try:
                        val = uart.readline().strip().decode('utf-8')
                        cmd.append(val)
                    except:
                        is_passed = False

                elif cmd[0] == "eval_str_eq":
                    if str(val) != str(cmd[1]):
                        is_passed = False

                elif cmd[0] == "eval_int_eq":
                    if int(val) != int(cmd[1]):
                        is_passed = False

                elif cmd[0] == "eval_int_gt":
                    if int(val) < int(cmd[1]):
                        is_passed = False

                elif cmd[0] == "eval_int_lt":
                    if int(val) > int(cmd[1]):
                        is_passed = False

                elif cmd[0] == "eval_dbl_eq":
                    if float(val) != float(cmd[1]):
                        is_passed = False

                elif cmd[0] == "eval_dbl_gt":
                    if float(val) < float(cmd[1]):
                        is_passed = False

                elif cmd[0] == "eval_dbl_lt":
                    if float(val) > float(cmd[1]):
                        is_passed = False

                else:
                    cmd.append("#")

                if is_passed == True:
                    cmd.append("OK")
                    print(cmd)
                    result.writerow(cmd)
                else:
                    cmd.append("NG")
                    print(cmd)
                    result.writerow(cmd)
                    close_cam(cam)
                    print("FAIL")
                    sys.exit(1)

    if is_passed == True:
        close_cam(cam)
        print("PASS")
        sys.exit(0)

main()

3. Script de test

Pour vérifier la commande crop_img, voir 3.2 Capture d'image webcam dans Tester les technologies élémentaires pour l'automatisation des tests d'acceptation avec M5Stack et Python. J'utilise le fichier 123abc.bmp généré par / pbjpkas / items / 97b6e596a4009a71f1ab # 32-webcam capture d'image).

script.csv


open_cam,1
capture_cam,abc1234.jpg
close_cam
crop_img,123abc.bmp,234:274,240:400,123abc_crop.bmp
open_ocr
exec_ocr,123abc_crop.bmp
eval_str_eq,123-abc

4. Résultat de l'exécution du test

result.csv


open_cam,1,OK
capture_cam,abc1234.jpg,OK
close_cam,OK
crop_img,123abc.bmp,234:274,240:400,123abc_crop.bmp,OK
open_ocr,OK
exec_ocr,123abc_crop.bmp,123-abc,OK
eval_str_eq,123-abc,OK

5. Conclusion

Transmission / réception de commande UART, activation / désactivation de l'équipement intégré, mesure de la tension à l'aide du convertisseur A / N d'Arduino, oscilloscope intégré, caméra Web intégrée, recadrage d'images, extraction et comparaison de chaînes de caractères à l'aide de l'OCR C'est désormais possible. Je pense que les possibilités de CI / CD au niveau du système pour les appareils embarqués et les appareils IoT ont considérablement augmenté.

[^ 1]: Installation d'OpenCV, Tesseract-OCR, PyOCR, PIL et paramétrage des variables d'environnement de Tesseract-OCR Essayez la technologie élémentaire d'automatisation des tests d'acceptation avec M5Stack et Python Veuillez consulter / items / 97b6e596a4009a71f1ab).

Recommended Posts

Automatisation des tests à partir de la caméra Web intégrée L-Chika (5) et de l'OCR
Automatisation des tests à partir de L-Chika (3) Incorporation d'un oscilloscope
[Automation] Manipulez la souris et le clavier avec Python
GRPC commençant par le serveur Go et le client Dart
Trading système commençant par Python 3: investissement et risque
Airtest, une question à la fois. Test E2E de l'application Unity commençant par Airtest et Poco