Golang implementiert Methoden zur Generierung von Miniaturansichten von Bildern und zur Gesichtserkennung

Golangs Methode zur Implementierung der Generierung von Miniaturansichten und Gesichtserkennung

Zusammenfassung:
In diesem Artikel wird erläutert, wie Sie mit Golang die Generierung von Miniaturansichten und Gesichtserkennung implementieren. Zuerst generieren wir Miniaturansichten über die Bildverarbeitungsbibliothek von Golang und speichern die Miniaturansichten auf der lokalen Festplatte. Anschließend stellen wir vor, wie Sie die Gesichtserkennungsbibliothek von Golang verwenden, um Gesichter in den generierten Miniaturansichten zu erkennen und die Erkennungsergebnisse zurückzugeben.

1. Generierung von Miniaturansichten von Bildern:
   Zuerst müssen wir die Bildverarbeitungsbibliothek von Golang verwenden, um Miniaturansichten zu generieren. Um dies zu erreichen, können wir Bibliotheken von Drittanbietern wie „github.com/nfnt/resize“ verwenden. Hier ist ein Beispielcode, der zeigt, wie man ein Miniaturbild generiert:

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!")
}

Dieser Code öffnet zunächst eine Bilddatei mit dem Namen „input.jpg“ und dekodiert sie. Verwenden Sie dann die Größenänderungsbibliothek, um das Bild auf eine bestimmte Größe zu skalieren (Breite in diesem Beispiel 200 Pixel, Höhe automatisch berechnet). Speichern Sie anschließend das generierte Miniaturbild in einer Datei mit dem Namen „thumbnail.jpg“. Abschließend wird eine Meldung ausgegeben, dass die Miniaturansicht erfolgreich erstellt wurde.

2. Gesichtserkennung:
   Als nächstes stellen wir vor, wie Sie die Gesichtserkennungsbibliothek von Golang verwenden, um Gesichter in den generierten Miniaturansichten zu erkennen. Wir können die Drittanbieter-Bibliothek „github.com/esimov/stackblur-go“ für die Bildunschärfeverarbeitung verwenden und dann eine andere Drittanbieter-Bibliothek „github.com/Kagami/go-face“ für die Gesichtserkennung verwenden. Hier ist ein Beispielcode, der zeigt, wie Gesichter in Miniaturansichten erkannt werden:

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)
    }
}

Dieser Code lädt zunächst das Gesichtserkennungsmodell und öffnet eine Bilddatei mit dem Namen „thumbnail.jpg“. Anschließend werden die Miniaturansichten unscharf gemacht und in Graustufen umgewandelt, um die Genauigkeit der Gesichtserkennungsergebnisse zu verbessern. Als nächstes verwenden Sie eine Gesichtserkennungsbibliothek, um Gesichter in den Miniaturansichten zu erkennen und die Anzahl der erkannten Gesichter auszugeben. Abschließend werden die erkannten Gesichter in Form von rechteckigen Kästchen markiert und in einer Datei mit dem Namen „face.jpg“ gespeichert.

Zusammenfassung:
In diesem Artikel wird erläutert, wie Sie mit Golang Miniaturansichten von Bildern erstellen und Gesichter erkennen können. Durch die Unterstützung von Bibliotheken Dritter können wir diese Funktionen problemlos in Golang implementieren. Mit diesen Techniken können wir Bilder verarbeiten und daraus nützliche Informationen extrahieren, beispielsweise Miniaturansichten erstellen und Gesichter erkennen. Ich hoffe, dieser Artikel kann Ihnen hilfreich sein. Vielen Dank fürs Lesen!

Das obige ist der detaillierte Inhalt vonGolang implementiert Methoden zur Generierung von Miniaturansichten von Bildern und zur Gesichtserkennung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!