rectangle - python screenshot to file




Erstellen Sie einen Screenshot über ein Python-Skript. (10)

Ich möchte einen Screenshot über ein Python-Skript machen und es unauffällig speichern.

Ich bin nur an der Linux-Lösung interessiert und sollte jede X-basierte Umgebung unterstützen.


Aus diesem Thread :

 import os
 os.system("import -window root temp.png")

Dies funktioniert ohne die Verwendung von Scrot oder ImageMagick.

import gtk.gdk

w = gtk.gdk.get_default_root_window()
sz = w.get_size()
print "The size of the window is %d x %d" % sz
pb = gtk.gdk.Pixbuf(gtk.gdk.COLORSPACE_RGB,False,8,sz[0],sz[1])
pb = pb.get_from_drawable(w,w.get_colormap(),0,0,0,0,sz[0],sz[1])
if (pb != None):
    pb.save("screenshot.png","png")
    print "Screenshot saved to screenshot.png."
else:
    print "Unable to get the screenshot."

Ausgeliehen von http://ubuntuforums.org/showpost.php?p=2681009&postcount=5


Eine kurze Suche nach oben gtkShots sieht aus, als könnte es Ihnen helfen, da es ein GPL-Python-Screenshot-Programm ist, also sollten Sie haben, was Sie brauchen.


Es gibt ein Python-Paket für diese Autopy

Das Bitmap-Modul kann screen-greifern (bitmap.capture_screen) Es ist multiplateform (Windows, Linux, Osx).


Ich habe ein Wrapper-Projekt ( pyscreenshot ) für scrot, imagemagick, pyqt, wx und pygtk. Wenn Sie einen von ihnen haben, können Sie ihn verwenden. Alle Lösungen sind von dieser Diskussion enthalten.

Installieren:

easy_install pyscreenshot

Beispiel:

import pyscreenshot as ImageGrab

# fullscreen
im=ImageGrab.grab()
im.show()

# part of the screen
im=ImageGrab.grab(bbox=(10,10,500,500))
im.show()

# to file
ImageGrab.grab_to_file('im.png')

Ich konnte den Screenshot in Linux nicht mit pyscreenshot oder scrot machen, weil die Ausgabe von pyscreenshot nur eine Black-Screen-PNG-Bilddatei war.

Aber Gott sei Dank gab es eine weitere sehr einfache Möglichkeit, Screenshots in Linux zu erstellen, ohne etwas zu installieren. python demo.py einfach den Code in dein Verzeichnis und python demo.py mit python demo.py

import os
os.system("gnome-screenshot --file=this_directory.png")

auch gibt es viele verfügbare optionen für gnome-screenshot --help

Application Options:
  -c, --clipboard                Send the grab directly to the clipboard
  -w, --window                   Grab a window instead of the entire screen
  -a, --area                     Grab an area of the screen instead of the entire screen
  -b, --include-border           Include the window border with the screenshot
  -B, --remove-border            Remove the window border from the screenshot
  -p, --include-pointer          Include the pointer with the screenshot
  -d, --delay=seconds            Take screenshot after specified delay [in seconds]
  -e, --border-effect=effect     Effect to add to the border (shadow, border, vintage or none)
  -i, --interactive              Interactively set options
  -f, --file=filename            Save screenshot directly to this file
  --version                      Print version information and exit
  --display=DISPLAY              X display to use

Nur der Vollständigkeit halber: Xlib - Aber es ist etwas langsam, wenn Sie den gesamten Bildschirm erfassen:

from Xlib import display, X
import Image #PIL

W,H = 200,200
dsp = display.Display()
root = dsp.screen().root
raw = root.get_image(0, 0, W,H, X.ZPixmap, 0xffffffff)
image = Image.fromstring("RGB", (W, H), raw.data, "raw", "BGRX")
image.show()

Man könnte versuchen, einige Typen in den Engpassdateien in PyXlib zu triggern und dann mit Cython zu kompilieren. Das könnte die Geschwindigkeit etwas erhöhen.

Bearbeiten: Wir können den Kern der Funktion in C schreiben, und dann in Python von Ctypes verwenden, hier ist etwas, was ich zusammen gehackt habe:

#include <stdio.h>
#include <X11/X.h>
#include <X11/Xlib.h>
//Compile hint: gcc -shared -O3 -lX11 -fPIC -Wl,-soname,prtscn -o prtscn.so prtscn.c

void getScreen(const int, const int, const int, const int, unsigned char *);
void getScreen(const int xx,const int yy,const int W, const int H, /*out*/ unsigned char * data) 
{
   Display *display = XOpenDisplay(NULL);
   Window root = DefaultRootWindow(display);

   XImage *image = XGetImage(display,root, xx,yy, W,H, AllPlanes, ZPixmap);

   unsigned long red_mask   = image->red_mask;
   unsigned long green_mask = image->green_mask;
   unsigned long blue_mask  = image->blue_mask;
   int x, y;
   int ii = 0;
   for (y = 0; y < H; y++) {
       for (x = 0; x < W; x++) {
         unsigned long pixel = XGetPixel(image,x,y);
         unsigned char blue  = (pixel & blue_mask);
         unsigned char green = (pixel & green_mask) >> 8;
         unsigned char red   = (pixel & red_mask) >> 16;

         data[ii + 2] = blue;
         data[ii + 1] = green;
         data[ii + 0] = red;
         ii += 3;
      }
   }
   XDestroyImage(image);
   XDestroyWindow(display, root);
   XCloseDisplay(display);
}

Und dann die Python-Datei:

import ctypes
import os
from PIL import Image

LibName = 'prtscn.so'
AbsLibPath = os.path.dirname(os.path.abspath(__file__)) + os.path.sep + LibName
grab = ctypes.CDLL(AbsLibPath)

def grab_screen(x1,y1,x2,y2):
    w, h = x2-x1, y2-y1
    size = w * h
    objlength = size * 3

    grab.getScreen.argtypes = []
    result = (ctypes.c_ubyte*objlength)()

    grab.getScreen(x1,y1, w, h, result)
    return Image.frombuffer('RGB', (w, h), result, 'raw', 'RGB', 0, 1)

if __name__ == '__main__':
  im = grab_screen(0,0,1440,900)
  im.show()

Plattformübergreifende Lösung mit wxPython :

import wx
wx.App()  # Need to create an App instance before doing anything
screen = wx.ScreenDC()
size = screen.GetSize()
bmp = wx.EmptyBitmap(size[0], size[1])
mem = wx.MemoryDC(bmp)
mem.Blit(0, 0, size[0], size[1], screen, 0, 0)
del mem  # Release bitmap
bmp.SaveFile('screenshot.png', wx.BITMAP_TYPE_PNG)

ein bisschen spät, aber vergiss es einfach

import autopy
import time
time.sleep(2)
b = autopy.bitmap.capture_screen()
b.save("C:/Users/mak/Desktop/m.png")

import ImageGrab
img = ImageGrab.grab()
img.save('test.jpg','JPEG')

Dies erfordert Python Imaging Library







screenshot