Golang implémente des méthodes de génération de vignettes d'images et de détection de visage

Méthode de Golang pour implémenter la génération de vignettes d'images et la détection de visages

Résumé :
Cet article présente comment utiliser Golang pour implémenter la génération de vignettes d'images et la détection de visages. Tout d'abord, nous générerons des vignettes via la bibliothèque de traitement d'image de Golang et enregistrerons les vignettes sur le disque local. Ensuite, nous présenterons comment utiliser la bibliothèque de détection de visages de Golang pour détecter les visages dans les vignettes générées et renvoyer les résultats de détection.

1. Génération de vignettes d'images :
   Tout d'abord, nous devons utiliser la bibliothèque de traitement d'images de Golang pour générer des vignettes. Nous pouvons utiliser des bibliothèques tierces telles que « github.com/nfnt/resize » pour y parvenir. Voici un exemple de code qui montre comment générer une vignette :

package main

import (
    "fmt"
    "image"
    "image/jpeg"
    "log"
    "os"

    "github.com/nfnt/resize"
)

func main() {
    inFile, err := os.Open("input.jpg")
    if err != nil {
        log.Fatal(err)
    }
    defer inFile.Close()

    // Decode the image
    srcImg, _, err := image.Decode(inFile)
    if err != nil {
        log.Fatal(err)
    }

    // Resize the image
    thumbnail := resize.Resize(200, 0, srcImg, resize.Lanczos3)

    // Create a new file for the thumbnail
    outFile, err := os.Create("thumbnail.jpg")
    if err != nil {
        log.Fatal(err)
    }
    defer outFile.Close()

    // Encode the thumbnail to JPEG format
    err = jpeg.Encode(outFile, thumbnail, &jpeg.Options{jpeg.DefaultQuality})
    if err != nil {
        log.Fatal(err)
    }

    fmt.Println("Thumbnail generated successfully!")
}

Ce code ouvre d'abord un fichier image nommé "input.jpg" et le décode. Ensuite, utilisez la bibliothèque de redimensionnement pour redimensionner l'image à une certaine taille (largeur 200 pixels dans cet exemple, hauteur calculée automatiquement). Après cela, enregistrez la vignette générée dans un fichier nommé "thumbnail.jpg". Enfin, un message d'invite indiquant que la génération de vignettes a réussi est affiché.

2. Détection de visage :
   Ensuite, nous présenterons comment utiliser la bibliothèque de détection de visage de Golang pour détecter les visages dans les vignettes générées. Nous pouvons utiliser la bibliothèque tierce "github.com/esimov/stackblur-go" pour le traitement du flou d'image, puis utiliser une autre bibliothèque tierce "github.com/Kagami/go-face" pour la détection des visages. Voici un exemple de code qui montre comment détecter les visages dans les vignettes :

package main

import (
    "fmt"
    "image"
    "image/jpeg"
    "log"
    "os"

    "github.com/esimov/stackblur-go"
    "github.com/Kagami/go-face"
)

func main() {
    // Load the face detection model
    model, err := face.NewRecognizer("models")
    if err != nil {
        log.Fatal(err)
    }
    defer model.Close()

    // Open the thumbnail image file
    inFile, err := os.Open("thumbnail.jpg")
    if err != nil {
        log.Fatal(err)
    }
    defer inFile.Close()

    // Decode the thumbnail image
    srcImg, _, err := image.Decode(inFile)
    if err != nil {
        log.Fatal(err)
    }

    // Blur the image for better face detection results
    stackblur.Process(srcImg, uint32(srcImg.Bounds().Dx()), uint32(srcImg.Bounds().Dy()), 20)

    // Convert the image to grayscale
    grayImg, err := face.ConvertImageToGray(srcImg)
    if err != nil {
        log.Fatal(err)
    }

    // Detect faces in the image
    faces, err := model.Recognize(grayImg, 1.5, 3)
    if err != nil {
        log.Fatal(err)
    }

    fmt.Printf("Detected %d face(s) in the thumbnail
", len(faces))

    // Draw rectangles around the detected faces
    for _, f := range faces {
        x, y, w, h := f.Rectangle()
        faceImg := face.Crop(grayImg, face.Rect(x, y, x+w, y+h))
        outFile, err := os.Create("face.jpg")
        if err != nil {
            log.Fatal(err)
        }
        defer outFile.Close()

        // Encode the face image to JPEG format
        err = jpeg.Encode(outFile, faceImg, &jpeg.Options{jpeg.DefaultQuality})
        if err != nil {
            log.Fatal(err)
        }

        fmt.Printf("Face detected at coordinates (%d,%d,%d,%d)
", x, y, w, h)
    }
}

Ce code charge d'abord le modèle de détection de visage et ouvre un fichier image nommé "thumbnail.jpg". Ensuite, les vignettes sont floues et converties en niveaux de gris pour améliorer la précision des résultats de détection des visages. Ensuite, utilisez une bibliothèque de détection de visages pour détecter les visages dans les vignettes et afficher le nombre de visages détectés. Enfin, les visages détectés sont marqués sous forme de cases rectangulaires et enregistrés dans un fichier nommé « face.jpg ».

Résumé :
Cet article explique comment utiliser Golang pour générer des vignettes d'images et détecter des visages. Grâce à la prise en charge de bibliothèques tierces, nous pouvons facilement implémenter ces fonctions dans Golang. Grâce à ces techniques, nous pouvons traiter des images et en extraire des informations utiles, telles que la génération de vignettes et la détection de visages. J'espère que cet article pourra vous être utile, merci d'avoir lu !

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!