capture d'écran de l'implémentation de Golang

Ces dernières années, alors que les gens sont devenus de plus en plus dépendants d'Internet, de nombreux secteurs ont commencé à se transformer vers la numérisation. Parmi eux, la demande de communication en réseau et de travail à distance augmente de jour en jour, et divers outils de conférence en ligne et de travail à distance ont également vu le jour. Pour ces scénarios d'application, la fonction de capture d'écran est devenue une fonction indispensable. Dans cet article, nous présenterons comment utiliser Golang, un langage de programmation puissant, pour implémenter la fonction de capture d'écran.

Introduction à Golang
Golang, également connu sous le nom de langage Go, est un langage de programmation émergent. Ses objectifs de conception sont d'être facile à apprendre, efficace et rapide, tout en garantissant la sécurité et la fiabilité du code. Golang dispose d'un mécanisme de récupération de place et de primitives de programmation simultanée, qui sont très adaptées au développement d'applications Internet.

Implémentation de capture d'écran Golang
Dans Golang, l'implémentation de la fonction de capture d'écran est principalement divisée en les étapes suivantes :

1. Tout d'abord, vous devez introduire certains packages nécessaires, tels que l'image et l'appel système, etc.

import (

"image"
"os"
"syscall"

)

2. Ensuite, vous devez utiliser la fonction système pour obtenir les informations sur la fenêtre en cours d'exécution, obtenir le handle de la fenêtre du système d'exploitation, puis le convertir en objet image dans Golang.

func getScreenShot() error {

hwnd := syscall.GetForegroundWindow()
if hwnd == 0 {
    return fmt.Errorf("could not find foreground window")
}
dc := syscall.GetDC(hwnd)
defer syscall.ReleaseDC(hwnd, dc)
rect := &syscall.Rect{}
if !syscall.GetWindowRect(hwnd, rect) {
    return fmt.Errorf("could not get window rect")
}
width := rect.Right - rect.Left
height := rect.Bottom - rect.Top
img, err := image.NewRGBA(image.Rect(0, 0, width, height))
if err != nil {
    return err
}
return nil

}

3. Ensuite, vous devez obtenir les données d'image du contexte de l'appareil et les stocker dans un objet image dans Golang.

pixels := make([]uint8, widthheight4)
_, _, err = syscall.BitBlt(0, 0, width, height, dc, 0, 0, syscall.SRCCOPY)
if err != néant {

return err

}
bi := &syscall.Bitmapinfo{}
bi.BmiHeader.BiSize = uint32(unsafe.Sizeof(bi.BmiHeader))
bi.BmiHeader.BiWidth = width;
bi.BmiHeader.BiHeight = -hauteur;
bi.BmiHeader.BiPlanes = 1
bi.BmiHeader.BiBitCount = 32
bi.BmiHeader.BiCompression = syscall.BI_RGB
bi.BmiHeader.BiSizeImage = uint32(len(pixels))
if _, _, err = syscall.GetDIBits(dc, syscall.HBITMAP(syscall.GetStockObject(syscall.BLACK_BRUSH)), 0, uint32(height), &pixels[0], bi, 0); err != nil {

return err

}
for y := 0; y < height; y++ {

for x := 0; x < width; x++ {
    i := (y*width + x) * 4
    R := pixels[i+2]
    G := pixels[i+1]
    B := pixels[i]
    img.Set(x, y, color.RGBA{R, G, B, 255})
}

}

4. Enfin, enregistrez l'objet image dans Golang en tant que fichier.

file, err := os.Create("screenshot.png")
if err != nil {

return err

}
defer file.Close()
if err = png.Encode(file, img err); != nul {

return err

}

Implémentation complète du code :

package main

import (

"fmt"
"image"
"image/color"
"image/png"
"os"
"syscall"
"unsafe"

)

func getScreenShot() erreur {

hwnd := syscall.GetForegroundWindow()
if hwnd == 0 {
    return fmt.Errorf("could not find foreground window")
}
dc := syscall.GetDC(hwnd)
defer syscall.ReleaseDC(hwnd, dc)
rect := &syscall.Rect{}
if !syscall.GetWindowRect(hwnd, rect) {
    return fmt.Errorf("could not get window rect")
}
width := rect.Right - rect.Left
height := rect.Bottom - rect.Top
img, err := image.NewRGBA(image.Rect(0, 0, width, height))
if err != nil {
    return err
}

defer func() {
    if panicErr := recover(); panicErr != nil {
        err = fmt.Errorf("%v", panicErr)
    }
}()

pixels := make([]uint8, width*height*4)
_, _, err = syscall.BitBlt(0, 0, width, height, dc, 0, 0, syscall.SRCCOPY)
if err != nil {
    return err
}
bi := &syscall.Bitmapinfo{}
bi.BmiHeader.BiSize = uint32(unsafe.Sizeof(bi.BmiHeader))
bi.BmiHeader.BiWidth = width;
bi.BmiHeader.BiHeight = -height;
bi.BmiHeader.BiPlanes = 1
bi.BmiHeader.BiBitCount = 32
bi.BmiHeader.BiCompression = syscall.BI_RGB
bi.BmiHeader.BiSizeImage = uint32(len(pixels))

if _, _, err = syscall.GetDIBits(dc, syscall.HBITMAP(syscall.GetStockObject(syscall.BLACK_BRUSH)), 0, uint32(height), &pixels[0], bi, 0); err != nil {
    return err
}

for y := 0; y < height; y++ {
    for x := 0; x < width; x++ {
        i := (y*width + x) * 4
        R := pixels[i+2]
        G := pixels[i+1]
        B := pixels[i]
        img.Set(x, y, color.RGBA{R, G, B, 255})
    }
}

file, err := os.Create("screenshot.png")
if err != nil {
    return err
}
defer file.Close()
if err = png.Encode(file, img); err != nil {
    return err
}

return nil

}

func main() {

err := getScreenShot()
if err != nil {
    fmt.Println(err)
}

}

Conclusion
Cet article explique comment utiliser Golang pour implémenter la fonction de capture d'écran. Golang est un langage de programmation efficace, simple et sûr avec de bonnes performances de concurrence et convient à divers scénarios d'application. Grâce à l'introduction de cet article, je pense que les lecteurs maîtrisent les compétences nécessaires pour utiliser Golang pour implémenter la fonction de capture d'écran. J'espère que cet article sera utile à tout le monde.

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!