Filigraner des images à l'aide d'OpenCV | Comment marquer une image avec OpenCV

Contenu

Cet article a été publié dans le cadre du Blogathon sur la science des données

Dans cet article, nous allons apprendre à filigraner plusieurs images à l'aide d'OpenCV.

Sujets à couvrir:

  1. Qu'est-ce qu'un filigrane?
  2. Redimensionner les images dans OpenCV
  3. Créer un filigrane à l'aide d'une image

1. Qu'est-ce qu'un filigrane?

Un filigrane est un logo, Société, texte ou motif intentionnellement superposé sur différentes images et utilisé pour protéger le droit d'auteur de l'image.

Son objectif principal est de promouvoir une marque et de rendre difficile la copie ou l'utilisation de l'image originale sans l'autorisation du propriétaire..

Les organisations professionnelles utilisent souvent des filigranes pour empêcher les autres d'utiliser leur contenu après l'avoir hébergé en ligne..

Ensuite, Avez-vous déjà pensé à ajouter un filigrane à vos images? Bon, Je l'ai fait.

Par exemple, nous écrivons des blogs et mentionnons la source des images externes. Mais, Qu'en est-il des images que vous créez vous-même? Ne serait-il pas agréable de laisser votre marque sur eux?

Hourra! Commençons cette tâche passionnante.

2. Redimensionner les images dans OpenCV

Le redimensionnement n'est rien de plus que la mise à l'échelle de l'image, ce que cela signifie de redimensionner l'image d'origine. Nous pouvons augmenter ou diminuer la taille de l'image en fonction des besoins de l'entreprise.

Le redimensionnement peut être effectué de différentes manières.

1. Conserver les proportions. Le rapport hauteur/largeur d'une image est le rapport entre sa largeur et sa hauteur.

  • Réduire ou agrandir la taille de l'image

2. Ne préserve pas le rapport hauteur/largeur

  • Largeur de rétrécissement seulement / augmenter, hauteur de rétraction uniquement / augmenter

3. Changer la largeur et la hauteur à des valeurs spécifiques

Sonne bien jusqu'à présent, mais comment faire en pratique? La réponse est OpenCV et sa fonction de redimensionnement (). En savoir plus sur la fonction de redimensionnement d'OpenCV dans ce Documentation.

Syntaxe de la fonction Cv2.resize ():
cv2.redimensionner (src, dsize, interpolation)

  • src – image source
  • dsize: la taille souhaitée de l'image de sortie
  • interpolation – Définition Wikipédia: C'est une méthode pour construire (trouve) nouveaux points de données basés sur la plage d'un ensemble discret de points de données connus.

Consultez cette documentation pour en savoir plus sur drapeaux d'interpolation.

À présent, prenons un exemple de photo et modifions sa taille. Ci-dessous est notre exemple d'image.

44364cerf-9418003
Image de l'auteur

À présent, essayez de l'afficher en utilisant OpenCV.

  1. importer cv2
    img = cv2.imread('images/cerf.JPG')
    cv2.imshow("Image originale", img)
    cv2.waitKey(0)
    cv2.destroyAllWindows()

Voici à quoi ressemble notre image lorsqu'elle est affichée à l'aide d'OpenCV. Comme notre image est en haute résolution, seule une partie est visible.

79507cerf20avant20redimensionnement-8155746

Ensuite, il est certainement nécessaire de le redimensionner. Nous devons réduire sa taille.

Étapes pour redimensionner une image dans OpenCV:

  • Lire l'image en utilisant cv2.imread ()
  • Définir la nouvelle largeur et la nouvelle hauteur.
  • Créer un tuple pour les nouvelles dimensions
  • Redimensionner l'image à l'aide de cv2.resize ()
  • Si c'est nécessaire, enregistrer l'image redimensionnée sur l'ordinateur à l'aide de cv2.imwrite ()
  • Afficher les images originales, redimensionné à l'aide de cv2.imshow ()

1. Conserver les proportions: réduit l'échelle de l'image à 20% de sa taille d'origine.

(Nous réduisons la taille de l'image originale à 20% de sa taille d'origine. Donc, nous allons créer un tuple pour les nouvelles dimensions en calculant le 20% de la largeur d'origine, les 20% de la hauteur d'origine).

  1. importer cv2
    img = cv2.imread('images/cerf.JPG')
    percent_of_scaling = 20
    nouvelle_largeur = entier(img.forme[1] * percent_of_scaling/100)
    nouvelle_hauteur = entier(img.forme[0] * percent_of_scaling/100)
    nouveau_dim = (nouvelle_largeur, nouvelle_hauteur)
    resized_img = cv2.resize(img, new_dim, interpolation=cv2.INTER_AREA)
    nom de fichier="resized_img_aspect ratio.jpg"
    cv2.imwrite(nom de fichier, redimensionné_img)
    cv2.imshow("Image originale", img)
    cv2.imshow("Image redimensionnée", redimensionné_img)
    cv2.waitKey(0)
    cv2.destroyAllWindows()

Le code ci-dessus enregistre l'image redimensionnée et affiche les images redimensionnées d'origine.

19874redimensionné20cerf-1114087

Bien fait. Nous avons réussi à redimensionner notre image en tenant compte du rapport hauteur/largeur.

2. Sans préserver le rapport hauteur/largeur: juste rétrécir / augmenter la largeur, juste rétrécir / augmenter la hauteur

Les étapes pour redimensionner seront les mêmes que ci-dessus. La seule différence est que nous gardons l'une ou l'autre des deux dimensions inchangées.

  1. importer cv2
    img = cv2.imread('images/cerf.JPG')
    nouveau_dim = (img.forme[1], 500) # change de hauteur
    resized_img = cv2.resize(img, new_dim, interpolation=cv2.INTER_AREA)
    cv2.imshow("Image originale", img)
    cv2.imshow("Image redimensionnée", redimensionné_img)
    cv2.waitKey(0)
    cv2.destroyAllWindows()

Ci-dessous sont les images montrées du code ci-dessus.

75562déformé20cerf-6442633

L'image redimensionnée est déformée et non la sortie souhaitée.

3. Changer la largeur et la hauteur à des valeurs spécifiques

  1. importer cv2
  2. img = cv2.imread ('images / cerf.JPG ')
  3. nouveau_dim = (450, 450)
  4. resized_img = cv2.resize (img, new_dim, interpolation = cv2.INTER_AREA)
  5. cv2.imshow (“Image originale”, img)
  6. cv2.imshow (“image redimensionnée”, redimensionné_img)
  7. cv2.waitKey (0)
  8. cv2.destroyAllWindows ()

Ci-dessous sont les images montrées du code ci-dessus.

81666spécifique20redimensionner-5118588

Cela a l'air plutôt cool, mais pas aussi bon que l'image de sortie avec un rapport hauteur/largeur préservé. C'est pourquoi je préfère redimensionner tout en préservant les proportions.

La prochaine étape est de voir comment créer un filigrane.

Créer un filigrane à l'aide d'une image

J'ai choisi de mettre un filigrane avec l'image de mon nom. Fais une photo de ton nom et essaie-le sur moi.

65473filigrane-3243336
Image en filigrane

Étapes pour ajouter le filigrane au centre d'une image:

Lire et redimensionner des images (image en filigrane, image d'entrée) si c'est nécessaire.

importer cv2
img = cv2.imread('images/cerf.JPG')
filigrane = cv2.imread("filigrane.PNG")

percent_of_scaling = 20
nouvelle_largeur = entier(img.forme[1] * percent_of_scaling/100)
nouvelle_hauteur = entier(img.forme[0] * percent_of_scaling/100)
nouveau_dim = (nouvelle_largeur, nouvelle_hauteur)
resized_img = cv2.resize(img, new_dim, interpolation=cv2.INTER_AREA)

wm_scale = 40
wm_width = entier(filigrane.forme[1] * wm_scale/100)
wm_height = entier(filigrane.forme[0] * wm_scale/100)
wm_dim = (wm_largeur, wm_height)
resized_wm = cv2.resize(filigrane, wm_dim, interpolation=cv2.INTER_AREA)

Définir le emplacement du logo selon les nouvelles dimensions de l'image d'entrée redimensionnée.

h_img, w_img, _ = redimensionné_img.shape
center_y = entier(h_img/2)
center_x = entier(w_img/2)
h_wm, w_wm, _ = redimensionné_wm.shape
top_y = center_y - entier(h_wm / 2)
left_x = center_x - entier(w_wm / 2)
bottom_y = top_y + h_wm
right_x = left_x + w_wm

Obtenir le Région d'intérêt rectangulaire (ROI) et le stocker dans une variable appelée 'roi'.

roi = redimensionné_img[top_y:bas_y, gauche_x:right_x]

Superposez le filigrane redimensionné au retour sur investissement en utilisant cv2.addWeighted ()et stockez-le dans une variable appelée 'résultat'.

résultat = cv2.addWeighted(roi, 1, redimensionné_wm, 0.3, 0)

À présent, ajouter ce résultat à l'image d'entrée redimensionnée

redimensionné_img[top_y:bas_y, gauche_x:right_x] = résultat

Enregistrez l'image en filigrane résultante sur votre ordinateur

nom de fichier="watermarked_deer.jpg"
cv2.imwrite(nom de fichier, redimensionné_img)

Afficher l'image en filigrane résultante

cv2.imshow("Image d'entrée redimensionnée", redimensionné_img)
cv2.waitKey(0)
cv2.destroyAllWindows()

Puis! Ci-dessous se trouve l'image en filigrane résultante.

13873watermarked_deer-3759783

Jusqu'à maintenant, nous avons appris à filigraner une seule image. Comme notre objectif est de filigraner plusieurs images, nous devons créer une liste de toutes ces images d'entrée et les parcourir. Ci-dessous les images que je vais utiliser.

63013all_images-1359651

Créer une liste d'images d'entrée

  1. importer le système d'exploitation
    chemindossier = "images"
    imgList = os.listdir(chemindossier)
    imgListe
61186liste20sortie-3775418

Code pour filigraner plusieurs images

  1. importer cv2
    filigrane = cv2.imread("filigrane.PNG")
    wm_scale = 40
    wm_width = entier(filigrane.forme[1] * wm_scale/100)
    wm_height = entier(filigrane.forme[0] * wm_scale/100)
    wm_dim = (wm_largeur, wm_height)
    resized_wm = cv2.resize(filigrane, wm_dim, interpolation=cv2.INTER_AREA)
    h_wm, w_wm, _ = redimensionné_wm.shape
    
    pour l'image dans imgList:
        img = cv2.imread(F'{chemindossier}/{image}')
        percent_of_scaling = 20
        nouvelle_largeur = entier(img.forme[1] * percent_of_scaling/100)
        nouvelle_hauteur = entier(img.forme[0] * percent_of_scaling/100)
        nouveau_dim = (nouvelle_largeur, nouvelle_hauteur)
        resized_img = cv2.resize(img, new_dim, interpolation=cv2.INTER_AREA)
        h_img, w_img, _ = redimensionné_img.shape
        center_y = entier(h_img/2)
        center_x = entier(w_img/2)
        top_y = center_y - entier(h_wm / 2)
        left_x = center_x - entier(w_wm / 2)
        bottom_y = top_y + h_wm
        right_x = left_x + w_wm
        roi = redimensionné_img[top_y:bas_y, gauche_x:right_x]
        résultat = cv2.addWeighted(roi, 1, redimensionné_wm, 0.3, 0)
        redimensionné_img[top_y:bas_y, gauche_x:right_x] = résultat
        nom de fichier = os.path.basename(image)
        cv2.imwrite("images filigranées/filigrane_"+nom de fichier, redimensionné_img)
        cv2.imshow("Image filigranée", redimensionné_img)
        cv2.waitKey(0)
        cv2.destroyAllWindows()
16658filigrane_all-6649323

Finalement, nous avons terminé avec le filigrane sur toutes les images d'entrée.

Remarques finales:

Merci d'avoir lu jusqu'au bout. A la fin de cet article, nous sommes habitués à travailler dans certaines des opérations OpenCV: lire plusieurs images, les redimensionner et les filigraner.

J'espère que vous avez apprécié la lecture de cet article. Essayez-le par vous-même et n'hésitez pas à le partager avec vos camarades..

Les références:

Documentation OpenCV

Téléchargez le fichier de code pour cela Lien du référentiel GitHub.

D'autres articles de mon blog

N'hésitez pas à consulter mes autres articles de blog depuis mon profil DataPeaker.

Vous pouvez me trouver dans LinkedIn, Twitter au cas où vous voudriez vous connecter. j'aimerai me connecter avec toi.

Pour un échange d'idées immédiat, écris moi [email protégé].

Les médias présentés dans cet article ne sont pas la propriété de DataPeaker et sont utilisés à la discrétion de l'auteur.

Abonnez-vous à notre newsletter

Nous ne vous enverrons pas de courrier SPAM. Nous le détestons autant que vous.