Traitement d'image léger avec Python x OpenCV

Ceci est un article de ZOZO Technologies # 1 Advent Calendar 2019. Hier, c'était "Connaissances requises lors de l'utilisation de Mac dans une équipe Windows" par @e_tyubo. J'ai également de nombreuses opportunités d'utiliser correctement plusieurs systèmes d'exploitation, ce qui a été très utile. J'ai été présenté comme "un ingénieur ludique qui apporte un drone au camp de développement", mais cette fois j'aimerais écrire un contenu solide qui soit plus proche du travail lol

L'équipe de l'usine intelligente à laquelle j'appartiens est en charge de l'amélioration des affaires et de l'automatisation qui se produisent dans le processus de production de vêtements. Parmi eux, il existe de nombreux projets liés au traitement d'image, et les genres varient du contenu orienté entreprise au contenu orienté recherche.

Lors d'un développement basé sur des demandes aussi diverses, la priorité est donnée au développement en jugeant «si l'efficacité et l'automatisation sont nécessaires en premier lieu», «si cela peut être réalisé immédiatement» et «s'il existe un avantage commercial». Vous devez prescrire.

Cependant, il n'est pas rare que l'industrie du vêtement ait peu de cas et de données d'automatisation, il est donc difficile de comprendre sans essayer. Par conséquent, il n'est pas nécessaire qu'il soit à 100%, il est donc pratique d'avoir des résultats d'index.

Cette fois, je présenterai le processus utilisé pour montrer les résultats en prototypage dans les situations ci-dessus. Si vous êtes trop proche de l'entreprise, il peut être difficile de publier le contenu, donc cet article ne concerne que le traitement de base.

Entrée / sortie d'image

Quand j'essaye le traitement d'image expérimentalement, je crée un "dossier de données" et un "dossier de résultat" dans l'espace de travail, et j'entrent et sortent dans ces dossiers. Il m'est plus facile personnellement de mettre uniquement les images que je souhaite traiter dans un dossier et de les traiter, je prends donc ce formulaire.

Code source

import os.path
import datetime

import cv2

#constant
#dossier de données
DATA_PATH = "data"
#dossier de résultats
RESULT_PATH = "result"


def main():
    #Obtenez le répertoire actuel
    current_path = os.getcwd()

    #Obtenir le répertoire de données
    data_path = os.path.join(current_path, DATA_PATH)
    #Obtenir le répertoire de données
    result_path = os.path.join(current_path, RESULT_PATH)
    #Obtenez une liste de fichiers directement sous le répertoire
    data_list = os.listdir(data_path)

    for file in data_list:

        #Obtenir l'extension de fichier
        file_name, ext = os.path.splitext(file)

        #Lorsque l'extension est png ou jpeg
        if ext == u'.png' or ext == u'.jpg' or ext == u'.jpeg':
            #Charger l'image
            input_path = os.path.join(data_path, file)
            image = cv2.imread(cv2.samples.findFile(input_path))
            
            #Écrivez un traitement ici

            #Nommé en utilisant l'heure pour que le nom du fichier ne soit pas couvert
            output_path = os.path.join(result_path, create_time_path(file_name, "extension"))
            #Enregistrer l'image
            cv2.imwrite(output_path, "Image de sortie")

    return

#Sortie d'un chemin de fichier unique avec l'heure
def create_time_path(file_name, ext):
    #Obtenez l'heure actuelle
    time = datetime.datetime.now()
    #Créer un chemin
    path = file_name + time.strftime("%Y%m%d%H%M%S") + ext

    return path


if __name__ == '__main__':
    main()

Filtre gaussien de lissage

Le filtre gaussien utilise la distribution gaussienne pour ajouter des poids en fonction de sa distance par rapport au pixel d'intérêt. Plus la valeur de l'écart type est élevée, plus l'effet du lissage est important.

Avant le traitement principal d'une image bruyante, elle est appliquée en tant que préparation. Essayez d'ajuster la taille du noyau en fonction de la nature de l'image que vous souhaitez traiter.

Code source

#Taille du noyau de filtre gaussien(Impair)
GAUSSIAN_KERNEL = (5, 5)

#Filtre gaussien
def exc_gaussian_blur(image):
    #Appliquer le filtre gaussien
    gaussian_image = cv2.GaussianBlur(image, GAUSSIAN_KERNEL, 0)

    return gaussian_image

Résultat d'exécution

L'image originale

Image post-traitée

Processus de détection des bords Canny

Pour expliquer brièvement le contenu, le traitement est effectué dans le flux de «(1) réduction et différenciation du bruit», «(2) détection de la position maximale du gradient» et «(3) traitement de seuil». Le résultat de la sortie changera en fonction de la valeur de réglage, veuillez donc l'ajuster en fonction de la nature de l'image que vous souhaitez traiter.

Code source

#seuil minimum de détection de bord canny
CANNY_MIN = 100
#seuil maximum de détection de bord canny
CANNY_MAX = 150

#Fonction de génération d'image de bord
def exc_canny_blur(image):
    #Appliquer le filtre Canny
    edgeImg = cv2.Canny(image, CANNY_MIN, CANNY_MAX)

    return edgeImg

Résultat d'exécution

L'image originale

Image post-traitée

Processus d'expansion

Processus qui ajoute un pixel au pixel cible qui touche l'arrière-plan ou le trou de l'image. Il est souvent utilisé avec le traitement de retrait, principalement pour la réduction du bruit.

Code source

#Taille du noyau de filtre d'expansion / réduction
MAX_MIN_KERNEL = (10, 10)
#Nombre d'exécutions de filtre d'extension / réduction
MAX_MIN_ITERATION = 10

#Fonction de traitement d'expansion
def exc_dilate(image):
    #Application de filtre d'expansion
    dstImg = cv2.dilate(image, MAX_MIN_KERNEL, MAX_MIN_ITERATION)

    return dstImg

Résultat d'exécution

L'image originale

Image post-traitée

Image de différence entre l'image d'origine et l'image traitée

Traitement de retrait

Processus qui dépouille un pixel autour du pixel cible qui touche l'arrière-plan ou le trou de l'image. Il est souvent utilisé avec le traitement de retrait, principalement pour la réduction du bruit.

Code source

#Taille du noyau de filtre d'expansion / réduction
MAX_MIN_KERNEL = (10, 10)
#Nombre d'exécutions de filtre d'extension / réduction
MAX_MIN_ITERATION = 10

#Fonction de traitement de retrait
def exc_erode(image):
    #Application de filtre de rétrécissement
    dstImg = cv2.erode(image, MAX_MIN_KERNEL, MAX_MIN_ITERATION)

    return dstImg

Résultat d'exécution

L'image originale

Image post-traitée

Image de différence entre l'image traitée et l'image d'origine

Conversion d'affine

Une transformation qui combine une transformation linéaire arbitraire et un mouvement parallèle. Je l'utilise souvent pour faire pivoter des images.

Code source

#Conversion d'affine
def exc_affine(dx, dy, image):
    #Conversion d'affine(Mouvement parallèle)
    affine_mat = np.float32([[1, 0, dx], [0, 1, dy]])
    height, width = image.shape[:2]
    image_affine = cv2.warpAffine(image, affine_mat, (width, height))

    return image_affine


#Rotation d'image
def exc_rotation(angle, scale, image):
    #Obtenir la position centrale
    center = tuple(np.array([image.shape[1] * 0.5, image.shape[0] * 0.5]))
    #Calcul de la matrice de conversion de rotation
    affine_mat = cv2.getRotationMatrix2D(center, angle, scale)
    #Conversion d'affine(rotation)
    height, width = image.shape[:2]
    rotation_image = cv2.warpAffine(image, affine_mat, (width, height), cv2.INTER_CUBIC)

    return rotation_image

Résultat d'exécution

L'image originale

Mouvement parallèle de l'image après le traitement

Lors du déplacement de 100 verticalement et horizontalement.

Rotation de l'image après le traitement

Mise à l'échelle de l'image post-traitée

Définissez l'état de mise à l'échelle sur 10.

en conclusion

Le traitement introduit ci-dessus est utilisé dans différentes combinaisons en fonction de l'image cible. Vous pouvez répondre à diverses scènes en modifiant la combinaison, veuillez donc la personnaliser pour vous-même.

ZOZO Technologies # 1 Advent Calendar 2019 Demain, c'est "Calculer avec Rust" par @ niba1122.