Skip to content

hansalemaos/fast_ctypes_screenshots

Folders and files

NameName
Last commit message
Last commit date

Latest commit

 

History

2 Commits
 
 
 
 
 
 
 
 
 
 

Repository files navigation

Screenshots in record time - up to 2.5x faster than MSS (Multiple Screen Shots)

The module provides classes for capturing screenshots in Windows operating systems. It offers four different classes: ScreenshotOfRegion, ScreenshotOfOneMonitor, ScreenshotOfAllMonitors, and ScreenshotOfWindow. These classes allow you to capture screenshots of specific regions, individual monitors, all monitors, or specific windows (even background windows) on the screen.

For users who need to capture screenshots programmatically in their Python applications, this module can be of great interest. It provides a convenient and efficient way to capture screenshots using the Windows API, allowing for customization and flexibility in screenshot capturing.

One notable advantage of this module is its speed. It utilizes direct access to the Windows API and minimizes overhead, resulting in faster screenshot capturing compared to other libraries like MSS (Multiple Screen Shots). This can be beneficial for applications that require real-time or high-frequency screenshot capturing.

Furthermore, the module has minimal dependencies, making it lightweight and easy to integrate into existing projects. It relies on standard Windows libraries and ctypes for accessing the Windows API functions, reducing the need for additional external dependencies.

pip install fast-ctypes-screenshots

Tested against Windows 10 / Python 3.10 / Anaconda

How to use it

from time import time

import cv2
import numpy as np
from fast_ctypes_screenshots import (
    ScreenshotOfRegion,
    ScreenshotOfOneMonitor,
    ScreenshotOfAllMonitors,
    ScreenshotOfWindow,
)


# a simple benchmark function
def show_screenshot(
    screenshotiter, stop_at_frame=100, quitkey="q", show_screenshot=True
):
    def show_screenshotx():
        cv2.imshow("test", screenshot)
        if cv2.waitKey(1) & 0xFF == ord(quitkey):
            cv2.destroyAllWindows()
            return False
        return True

    framecounter = 0
    fps = 0
    start_time = time()
    for screenshot in screenshotiter:
        if stop_at_frame:
            if framecounter > stop_at_frame:
                break
            framecounter += 1
        if show_screenshot:
            sho = show_screenshotx()
        else:
            sho = True
        fps += 1
        if not sho:
            break
    print(f"fast_ctypes_screenshots: {fps / (time() - start_time)}")
    cv2.destroyAllWindows()


if __name__ == "__main__":
    # Take one screenshot

    # ScreenshotOfWindow works even with background windows
    with ScreenshotOfWindow(
        hwnd=920542, client=False, ascontiguousarray=False
    ) as screenshots_window:
        img1 = screenshots_window.screenshot_window()
    print(img1.shape)

    with ScreenshotOfWindow(
        hwnd=920542, client=True, ascontiguousarray=False
    ) as screenshots_window:
        img2 = screenshots_window.screenshot_window()
    print(img2.shape)

    # Screenshot of all monitors
    with ScreenshotOfAllMonitors(ascontiguousarray=False) as screenshots_all_monitor:
        img4 = screenshots_all_monitor.screenshot_monitors()
    print(img4.shape)

    # Screenshot of one monitor, starting at 0
    with ScreenshotOfOneMonitor(
        monitor=0, ascontiguousarray=False
    ) as screenshots_monitor:
        img5 = screenshots_monitor.screenshot_one_monitor()
    print(img5.shape)

    # x0=0, y0=40, x1=800, y1=680 -> rectangle
    with ScreenshotOfRegion(
        x0=0, y0=40, x1=800, y1=680, ascontiguousarray=False
    ) as screenshots_region:
        img6 = screenshots_region.screenshot_region()
    print(img6.shape)
    #######################################################################
    # Take many screenshots
    # from a window
    # screenshots_window is iterable
    with ScreenshotOfWindow(
        hwnd=920542, client=False, ascontiguousarray=False
    ) as screenshots_window:
        show_screenshot(
            screenshots_window, stop_at_frame=1500, quitkey="q", show_screenshot=True
        )

    with ScreenshotOfWindow(
        hwnd=920542, client=True, ascontiguousarray=False
    ) as screenshots_window:
        show_screenshot(
            screenshots_window, stop_at_frame=1500, quitkey="q", show_screenshot=True
        )

    # from all monitors
    # screenshots_all_monitor is iterable too
    with ScreenshotOfAllMonitors(ascontiguousarray=False) as screenshots_all_monitor:
        show_screenshot(
            screenshots_all_monitor,
            stop_at_frame=150,
            quitkey="q",
            show_screenshot=True,
        )

    # from one monitor
    # screenshots_monitor is iterable as well
    with ScreenshotOfOneMonitor(
        monitor=0, ascontiguousarray=False
    ) as screenshots_monitor:
        show_screenshot(
            screenshots_monitor, stop_at_frame=150, quitkey="q", show_screenshot=True
        )
    with ScreenshotOfRegion(
        x0=0, y0=40, x1=800, y1=680, ascontiguousarray=False
    ) as screenshots_region:
        show_screenshot(
            screenshots_region, stop_at_frame=150, quitkey="q", show_screenshot=True
        )

Benchmark - MSS vs. fast-ctypes-screenshots

Benchmark FPS One Screen - with cv2.imshow - MSS FPS One Screen - with cv2.imshow - fast_ctypes_screenshots FPS One Screen - without cv2.imshow - MSS FPS One Screen - without cv2.imshow - fast_ctypes_screenshots
1 screen - 1920x1080 14.570637829934096 29.75346366655896 29.040460293245385 32.07449524721684
2 screens - 3840x1080 10.885839644361466 18.843871526097328 17.19836897143781 24.268109622214084
region - 2800x960 13.54247110293269 28.722819983256283 21.342393892806598 29.528899151991656
# MSS https://python-mss.readthedocs.io/ vs. fast_ctypes_screenshots


# The code for the benchmark 

import mss

print("\n\n-------------------------Benchmark - 1 screen - 1920x1080")
fps = 0
last_time = time()

with mss.mss() as sct:
    for _ in range(150):
        sct_img = sct.grab(sct.monitors[1])
        img = np.array(sct_img)
        cv2.imshow("test", img)
        fps += 1
        if cv2.waitKey(25) & 0xFF == ord("q"):
            cv2.destroyAllWindows()
            break
print(
    f"\n\n\nFPS One Screen - with cv2.imshow - MSS: {fps / (time() - last_time)}\n"
)
print("FPS One Screen - with cv2.imshow - ", end=" ")
cv2.destroyAllWindows()

with ScreenshotOfOneMonitor(
    monitor=0, ascontiguousarray=False
) as screenshots_monitor:
    show_screenshot(
        screenshots_monitor, stop_at_frame=150, quitkey="q", show_screenshot=True
    )
cv2.destroyAllWindows()
#########################################################
fps = 0
last_time = time()

with mss.mss() as sct:
    for _ in range(150):
        sct_img = sct.grab(sct.monitors[1])
        img = np.array(sct_img)
        fps += 1

print(
    f"\n\n\nFPS One Screen - without cv2.imshow - MSS: {fps / (time() - last_time)}\n"
)
print("FPS One Screen - without cv2.imshow - ", end=" ")

with ScreenshotOfOneMonitor(
    monitor=0, ascontiguousarray=False
) as screenshots_monitor:
    show_screenshot(
        screenshots_monitor, stop_at_frame=150, quitkey="q", show_screenshot=False
    )
cv2.destroyAllWindows()
#########################################################
print("\n\n-------------------------Benchmark - 2 screens - 3840x1080")
fps = 0
last_time = time()

with mss.mss() as sct:
    for _ in range(100):
        sct_img = sct.grab(sct.monitors[0])
        img = np.array(sct_img)
        cv2.imshow("test", img)
        fps += 1
        if cv2.waitKey(25) & 0xFF == ord("q"):
            cv2.destroyAllWindows()
            break

print(
    f"\n\n\nFPS All screens - with cv2.imshow - MSS: {fps / (time() - last_time)}\n"
)
cv2.destroyAllWindows()
print("FPS All screens - with cv2.imshow - ", end=" ")
with ScreenshotOfAllMonitors(ascontiguousarray=False) as screenshots_region:
    show_screenshot(
        screenshots_region, stop_at_frame=100, quitkey="q", show_screenshot=True
    )
cv2.destroyAllWindows()

#########################################################
fps = 0
last_time = time()
with mss.mss() as sct:
    for _ in range(100):
        sct_img = sct.grab(sct.monitors[0])
        img = np.array(sct_img)
        fps += 1
print(
    f"\n\n\nFPS All screens - without cv2.imshow - MSS: {fps / (time() - last_time)}\n"
)
print("FPS All screens - without cv2.imshow - ", end=" ")
with ScreenshotOfAllMonitors(ascontiguousarray=False) as screenshots_region:
    show_screenshot(
        screenshots_region, stop_at_frame=100, quitkey="q", show_screenshot=False
    )

#########################################################

print("\n\n-------------------------Benchmark - region - 2800x960")

fps = 0
last_time = time()
monitor = {"top": 40, "left": 0, "width": 2800, "height": 960}

with mss.mss() as sct:
    for _ in range(150):
        img = np.array(sct.grab(monitor))
        cv2.imshow("test", img)

        fps += 1
        if cv2.waitKey(25) & 0xFF == ord("q"):
            cv2.destroyAllWindows()
            break

print(f"\n\n\nFPS Region - with cv2.imshow - MSS: {fps / (time() - last_time)}\n")
print("FPS Region - with cv2.imshow - ", end=" ")
cv2.destroyAllWindows()

with ScreenshotOfRegion(
    x0=0, y0=40, x1=2800, y1=1000, ascontiguousarray=False
) as screenshots_region:
    show_screenshot(
        screenshots_region, stop_at_frame=150, quitkey="q", show_screenshot=True
    )

cv2.destroyAllWindows()

#########################################################

fps = 0
last_time = time()
monitor = {"top": 40, "left": 0, "width": 2800, "height": 960}

with mss.mss() as sct:
    for _ in range(150):
        img = np.array(sct.grab(monitor))
        fps += 1

print(
    f"\n\n\nFPS Region - without cv2.imshow - MSS: {fps / (time() - last_time)}\n"
)
print("FPS Region - without cv2.imshow: ", end=" ")
with ScreenshotOfRegion(
    x0=0, y0=40, x1=2800, y1=1000, ascontiguousarray=False
) as screenshots_region:
    show_screenshot(
        screenshots_region, stop_at_frame=150, quitkey="q", show_screenshot=False
    )

About

Screenshots in record time - up to 2.5x faster than MSS (Multiple Screen Shots)

Topics

Resources

License

Stars

Watchers

Forks

Languages