Cattura lo schermo in Go?

Question

Esiste un modo multipiattaforma per acquisire lo schermo in Google Go? O in ogni caso, ma la piattaforma incrociata sarebbe preferibile.

Answer 1

Non riesco a trovare una libreria per farlo. L'acquisizione stabile dello schermo multipiattaforma richiede molto lavoro. La cattura dello schermo richiede l'interfacciamento con il display manager/server dei sistemi operativi o frame-buffer, che è diverso per molti sistemi operativi e distribuzioni Linux. Dovresti scrivere interfacce per ciascuna API del sistema operativo (o racchiudere le librerie che forniscono la funzionalità) e quindi astrarre tutti i diversi metodi in un unico pacchetto in modo che funzioni su più piattaforme.

Un altro modo per farlo sarebbe quello di eseguire un'applicazione di cattura dello schermo esistente (riga di comando) per eseguire il lavoro di cattura dello schermo, incluso il salvataggio in un file. Quindi leggi il file nella tua applicazione go. Per fare in modo che un'applicazione Go esegua un'applicazione di terze parti, usa il pacchetto os/exec, è nella libreria standard. Per Linux è possibile utilizzare fbgrab per salvare il frame-buffer in un file png.

Answer 2

Sfortunatamente, non esiste una libreria per farlo. Esistono un paio di associazioni per magickwand (linguaggio di programmazione C e le librerie di elaborazione immagini ImageMagick), vedere http://go-lang.cat-v.org/library-bindings ma queste sono incomplete e non hanno la funzione di cattura dello schermo.

Nel frattempo, come suggerito da GeertJohan, è possibile utilizzare os.exec per eseguire un programma esterno e acquisire lo schermo (vedere il codice di esempio riportato di seguito). Ad esempio, è possibile utilizzare import comando da ImageMagick per bloccare lo schermo (dovrebbe funzionare su una piattaforma che può essere eseguito ImageMagick)

package main 

import (
    "bytes" 
    "fmt" 
    "log" 
    "os/exec" 
) 

func main() { 

    var buf bytes.Buffer 

    path, err := exec.LookPath("import") 
    if err != nil { 
     log.Fatal("import not installed !") 
    } 
    fmt.Printf("import is available at %s\n", path) 

    cmd := exec.Command("import", "-window", "root", "root.png") 

    cmd.Stdout = &buf 
    cmd.Stderr = &buf 

    err = cmd.Run() 
    if err != nil { 
     panic(err) 
    } 
    fmt.Println(buf.String()) 
} 

Answer 3

Non so di qualsiasi libreria multi-piattaforma, ma si può fare questo con il Libreria xgbutil quando è presente un server X. È possibile vedere un example of how to capture a screenshot here.

Se si desidera ottenere questo funzionamento su sistemi Mac/Windows, probabilmente inizierò esaminando la fonte per go.wde, che include i backend per Windows e Mac. Dubito che troverai direttamente il codice per catturare uno screenshot, ma potrebbe darti qualche suggerimento o un percorso da seguire.

Answer 4

Non esiste un modo multipiattaforma per acquisire lo schermo in Google's Go, perché lo schermo catturato si basa su una specifica API dei sistemi operativi sottostanti. Ma ci sono le librerie per Go che fanno questo.

Per esempio https://github.com/vova616/screenshot

Answer 5

È. Si tratta di una procedura in due passaggi:

Studio https://github.com/ShareX/ShareX/tree/master/ShareX.ScreenCaptureLib per vedere quale API win32 chiama per acquisire la schermata/finestra Tradurre quella logica su Vai. È possibile utilizzare uno dei pochi collegamenti win32 api Go esistenti (ad esempio https://github.com/AllenDang/w32). Se mancano funzionalità necessarie, è possibile aggiungere più wrapper.

Answer 6

Ora c'è:

https://github.com/vova616/screenshot

go get github.com/vova616/screenshot

Esempio:

package main 

import "github.com/vova616/screenshot" 

func main() { 
    img, err := screenshot.CaptureScreen() // *image.RGBA 
    myImg := image.Image(img) // can cast to image.Image, but not necessary 
} 

Se avete bisogno di supporto MacOS così (fino a quando la richiesta di pull è fusa), ottiene:

https://github.com/kesarion/screenshot