Python 스크립트를 통해 스크린샷을 찍습니다.[리눅스]

Question

Python 스크립트를 통해 스크린샷을 찍고 눈에 띄지 않게 저장하고 싶습니다.

저는 Linux 솔루션에만 관심이 있으며 모든 X 기반 환경을 지원해야 합니다.

Answer 1

이것은 scrot이나 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."

다음에서 빌림 http://ubuntuforums.org/showpost.php?p=2681009&postcount=5

Answer 2

모든 답변을 한 수업에 모아보세요.PIL 이미지를 출력합니다.

#!/usr/bin/env python
# encoding: utf-8
"""
screengrab.py

Created by Alex Snet on 2011-10-10.
Copyright (c) 2011 CodeTeam. All rights reserved.
"""

import sys
import os

import Image


class screengrab:
    def __init__(self):
        try:
            import gtk
        except ImportError:
            pass
        else:
            self.screen = self.getScreenByGtk

        try:
            import PyQt4
        except ImportError:
            pass
        else:
            self.screen = self.getScreenByQt

        try:
            import wx
        except ImportError:
            pass
        else:
            self.screen = self.getScreenByWx

        try:
            import ImageGrab
        except ImportError:
            pass
        else:
            self.screen = self.getScreenByPIL


    def getScreenByGtk(self):
        import gtk.gdk      
        w = gtk.gdk.get_default_root_window()
        sz = w.get_size()
        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 is None:
            return False
        else:
            width,height = pb.get_width(),pb.get_height()
            return Image.fromstring("RGB",(width,height),pb.get_pixels() )

    def getScreenByQt(self):
        from PyQt4.QtGui import QPixmap, QApplication
        from PyQt4.Qt import QBuffer, QIODevice
        import StringIO
        app = QApplication(sys.argv)
        buffer = QBuffer()
        buffer.open(QIODevice.ReadWrite)
        QPixmap.grabWindow(QApplication.desktop().winId()).save(buffer, 'png')
        strio = StringIO.StringIO()
        strio.write(buffer.data())
        buffer.close()
        del app
        strio.seek(0)
        return Image.open(strio)

    def getScreenByPIL(self):
        import ImageGrab
        img = ImageGrab.grab()
        return img

    def getScreenByWx(self):
        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)
        myWxImage = wx.ImageFromBitmap( myBitmap )
        PilImage = Image.new( 'RGB', (myWxImage.GetWidth(), myWxImage.GetHeight()) )
        PilImage.fromstring( myWxImage.GetData() )
        return PilImage

if __name__ == '__main__':
    s = screengrab()
    screen = s.screen()
    screen.show()

Answer 3

완전성을 위해 :Xlib - 하지만 전체 화면을 캡처할 때는 다소 느립니다.

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

PyXlib의 병목 현상 파일에서 일부 유형을 찾아낸 다음 Cython을 사용하여 컴파일할 수 있습니다.그러면 속도가 조금 더 빨라질 수 있습니다.

---

편집하다:우리는 함수의 핵심을 C로 작성한 다음 ctypes에서 Python으로 사용할 수 있습니다. 여기에 제가 함께 해킹한 내용이 있습니다.

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

그리고 파이썬 파일:

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

Answer 4

이것은 X11에서 작동하며 Windows에서도 작동할 수 있습니다(누군가 확인해주세요).요구사항 PyQt4:

import sys
from PyQt4.QtGui import QPixmap, QApplication
app = QApplication(sys.argv)
QPixmap.grabWindow(QApplication.desktop().winId()).save('test.png', 'png')

Answer 5

래퍼 프로젝트가 있습니다(파이스크린샷) scrot, imagemagick, pyqt, wx 및 pygtk의 경우.그 중 하나가 있으면 사용할 수 있습니다.이 토론에는 모든 솔루션이 포함되어 있습니다.

설치하다:

easy_install pyscreenshot

예:

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

Answer 6

다음을 사용한 크로스 플랫폼 솔루션 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)

Answer 7

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

Python 이미징 라이브러리가 필요합니다.

Answer 8

짧은 검색 결과가 나왔습니다 gtk샷 GPLed Python 스크린샷 프로그램이므로 도움이 될 것 같습니다. 따라서 필요한 내용이 포함되어 있어야 합니다.

Answer 9

이것을 사용할 수 있습니다

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

Answer 10

이를 위한 Python 패키지가 있습니다. 자동피

비트 맵 모듈은 스크린 잡기 (bitmap.capture_screen)를 스크린 할 수 있습니다. Multiplateform (Windows, Linux, OSX)입니다.

Answer 11

조금 늦었지만 신경쓰지 마세요 쉬운 건

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

Answer 12

에서 이 스레드:

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

Answer 13

Linux에서 pyscreenshot 또는 scrot을 사용하여 스크린샷을 찍을 수 없었습니다. pyscreenshot 그냥 검은색 화면 png 이미지 파일이었습니다.

하지만 다행스럽게도 아무 것도 설치하지 않고 Linux에서 스크린샷을 찍을 수 있는 아주 쉬운 또 다른 방법이 있었습니다.아래 코드를 디렉토리에 넣고 다음과 같이 실행하십시오. python demo.py

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

또한 사용할 수 있는 옵션이 많이 있습니다. 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

Answer 14

나는 최근에 X11 라이브러리를 사용하여 스크린샷을 찍고 이미지를 numpy 배열로 반환하는 패키지를 작성했습니다.나는 실제로이 스레드에서 언급되어 개선 된 몇 가지 제안을 사용했습니다.최신 기계에서는 1080p 해상도의 경우 60+ fps의 일반적인 프레임 속도가 가능합니다.실제로 내 개발 기계 (즉, 3 세)에서 나는 200fps를 얻었습니다.프로젝트에 대한 링크는 다음과 같습니다 https://github.com/mherkazandjian/fastgrab

Answer 15

오래된 질문입니다.새로운 도구를 사용하여 이에 답하고 싶습니다.

Python 3(Python 2에서도 작동해야 하지만 테스트하지는 않음) 및 PyQt5에서 작동합니다.

최소한의 작업 예.Python 쉘에 복사하고 결과를 얻으십시오.

from PyQt5.QtWidgets import QApplication
app = QApplication([])
screen = app.primaryScreen()
screenshot = screen.grabWindow(QApplication.desktop().winId())
screenshot.save('/tmp/screenshot.png')

Answer 16

시도 해봐:

#!/usr/bin/python

import gtk.gdk
import time
import random
import socket
import fcntl
import struct
import getpass
import os
import paramiko     

while 1:
    # generate a random time between 120 and 300 sec
    random_time = random.randrange(20,25)
    # wait between 120 and 300 seconds (or between 2 and 5 minutes) 

    print "Next picture in: %.2f minutes" % (float(random_time) / 60)

    time.sleep(random_time)
    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])
    ts = time.asctime( time.localtime(time.time()) )
    date = time.strftime("%d-%m-%Y")
    timer = time.strftime("%I:%M:%S%p")
    filename = timer
    filename += ".png"

    if (pb != None):
        username = getpass.getuser() #Get username
        newpath = r'screenshots/'+username+'/'+date #screenshot save path
        if not os.path.exists(newpath): os.makedirs(newpath)
        saveas = os.path.join(newpath,filename)
        print saveas
        pb.save(saveas,"png")
    else:
        print "Unable to get the screenshot."