Сделайте снимок экрана из командной строки в Windows

На этот вопрос уже дан ответ, но я подумал, что тоже добавлю это. NirCmd (бесплатная, к сожалению, не с открытым исходным кодом) может делать снимки экрана из командной строки в сочетании с многочисленными другими функциями, которые он может выполнять.

Запустите его из командной строки либо в каталоге nircmd.exe, либо, если вы скопировали его в папку system32:

nircmd.exe savescreenshot screen1.png

делает то, что вы хотите. Вы также можете отложить это следующим образом:

nircmd.exe cmdwait 2000 savescreenshot screen1.png

Это будет ждать 2000 миллисекунд (2 секунды), а затем захватить и сохранить скриншот.

Это можно сделать без внешних инструментов (вам просто нужно установить.net Framework, который установлен по умолчанию на все, от Vista и выше) - screenCapture.bat. Это самоскомпилированная программа на C#, и вы можете сохранить вывод в нескольких форматах и ​​захватывать только активное окно или весь экран:

screenCapture- captures the screen or the active window and saves it to a file
Usage:
screenCapture  filename.format [WindowTitle]

filename - the file where the screen capture will be saved
format - Bmp,Emf,Exif,Gif,Icon,Jpeg,Png,Tiff and are supported - default is bmp
WindowTitle - instead of capturing the whole screen will capture the only a window with the given title if there's such

Примеры:

call screenCapture notepad.jpg "Notepad"
call screenCapture screen.png

Другие предложения хороши - вы также можете попробовать MiniCap, который является бесплатным и имеет некоторые другие функции, такие как гибкое именование файлов и несколько различных режимов захвата: http://www.donationcoder.com/Software/Mouser/MiniCap/index.html

(отказ от ответственности: я автор MiniCap).

Попробуйте IrfanView.

Вы можете запустить его через командную строку. Вы можете указать, какое окно захватывать - например, целое окно или только текущее / активное окно - и вы также можете выполнять некоторые основные операции редактирования, такие как повышение резкости, обрезка или изменение размера изображений.

Вот параметры командной строки, особенно интересно это

i_view32 /capture=0 /convert=wholescreen.png

Screenshot-cmd делает снимок экрана рабочего стола или любого окна, выбранного по заголовку окна. Также можно выбрать прямоугольник для захвата. Результат сохраняется в виде файла png. (последнее обновление в 2011 году)

ОПЦИИ:
    -wt WINDOW_TITLE Выбрать окно с этим заголовком. Заголовок не должен содержать пробел (" ").
    -wh WINDOW_HANDLE Выбрать окно по его дескриптору (представленное в виде шестнадцатеричной строки - например, "0012079E") 
    -rc ВЛЕВО ВЕРХНЯЯ ПРАВО ДНО Источник обрезки. Если WINDOW_TITLE не указан (0,0), то левый верхний угол рабочего стола, в противном случае, если WINDOW_TITLE соответствует окну рабочего стола (0,0), это его левый верхний угол.
    -o FILENAME Вывести имя файла, если его нет, изображение будет сохранено как "screenshot.png" в текущем рабочем каталоге. -h Показывает эту справочную информацию.

Вдохновлено: http://blog.mozilla.com/ted/2009/02/05/command-line-screenshot-tool-for-windows/

Вы можете попробовать инструмент boxcutter:

usage: boxcutter [OPTIONS] [OUTPUT_FILENAME]

Saves a bitmap screenshot to 'OUTPUT_FILENAME' if given.  Otherwise, 
screenshot is stored on clipboard by default.

OPTIONS
  -c, --coords X1,Y1,X2,Y2    capture the rectange (X1,Y1)-(X2,Y2)
  -f, --fullscreen            fullscreen screenshot
  -v, --version               display version information
  -h, --help                  display help message

Вы можете использовать код PowerShell, найденный здесь :

      [Reflection.Assembly]::LoadWithPartialName("System.Drawing")
function screenshot([Drawing.Rectangle]$bounds, $path) {
   $bmp = New-Object Drawing.Bitmap $bounds.width, >$bounds.height
   $graphics = [Drawing.Graphics]::FromImage($bmp)

   $graphics.CopyFromScreen($bounds.Location, [Drawing.Point]::Empty, $bounds.size)

   $bmp.Save($path)

   $graphics.Dispose()
   $bmp.Dispose()
}

$bounds = [Drawing.Rectangle]::FromLTRB(0, 0, 1000, 900)
screenshot $bounds "C:\screenshot.png"

Вы можете использовать Pillow библиотека python для снимков экрана основного монитора

Шаг 1: установить подушку:

pip install -user pillow

Шаг 2: Сделайте скриншоты со следующим кодом:

from PIL import ImageGrab
img = ImageGrab.grab()
img.save('screenshot.bmp')

Вы можете использовать коммерческий снимок продукта, чтобы делать потрясающие снимки экрана из командной строки.

В Windows мне удалось воспользоваться советом @zacharyliu. Для непрофессионалов и для любителей портативных вещей я легко сделал это с помощью Cmder.

1. Загрузите Cmder. Я использую портативную версию с полной установкой

2. Извлечь команду

3. Откройте папку и войдите в папку bin (в той же папке, что и исполняемый файл, если нет, создайте ее)

4. Загрузите файлы NirCmd (ссылка внизу страницы)

5. Поместите файлы NirCmd в папку bin.

6. Откройте Cmder (если он открыт, перезапустите его)

7. Используйте следующий код (сохраняет скриншоты.png каждые 3 секунды 5 раз вC:\screenshots\MONTH-DAY-YEAR\папка сHOURS-MINUTES-SECONDS.pngимя):

           cd C:\ && ([ -d screenshots ] || mkdir screenshots) && "nircmdc.exe" loop 5 3000 execmd "cd C:\screenshots\ && ([ -d ~$currdate.MM-dd-yyyy$ ] || mkdir ~$currdate.MM-dd-yyyy$) && nircmdc.exe savescreenshot C:\screenshots\~$currdate.MM-dd-yyyy$\screenshot-~$currtime.HH-mm-ss$.png"
   

8. Наслаждаться!

Как это работает, какие форматы дат поддерживаются, какие форматы изображений поддерживаются и другие подробности:

• Справочник по командам NirCmd – сохранить скриншот
• Справочник команд NirCmd — execmd
• StackOverflow – только mkdir, если он не существует

Мне очень не нравятся ответы, основанные на стороннем программном обеспечении, я потратил немного времени на поиск решения моей проблемы, поэтому опубликую его здесь на случай, если оно кому-нибудь еще понадобится.

Я объединил этот ответ с частью своей собственной реализации, чтобы захватить только окно PowerShell:

      add-type -namespace native -name winapi @"
[DllImport("user32.dll")]
public static extern int GetWindowRect(IntPtr hwnd, out System.Management.Automation.Host.Rectangle rect);

[DllImport("user32.dll")]
public static extern bool SetProcessDPIAware();
"@

# necessary, otherwise the dimensions are wrong with different DPIs
[native.winapi]::SetProcessDPIAware()

$rect = [System.Management.Automation.Host.Rectangle]::new(0,0,0,0)
$pshwnd = ([System.Diagnostics.Process]::GetCurrentProcess() | Get-Process).MainWindowHandle
[native.winapi]::GetWindowRect($pshwnd, [ref] $rect)

[Reflection.Assembly]::LoadWithPartialName("System.Drawing")
function screenshot([Drawing.Rectangle]$bounds, $path) {
   $bmp = New-Object Drawing.Bitmap $bounds.width, $bounds.height
   $graphics = [Drawing.Graphics]::FromImage($bmp)

   $graphics.CopyFromScreen($bounds.Location, [Drawing.Point]::Empty, $bounds.size)

   $bmp.Save($path)

   $graphics.Dispose()
   $bmp.Dispose()
}
$bounds = [Drawing.Rectangle]::FromLTRB($rect.Left, $rect.Top, $rect.Right, $rect.Bottom)
screenshot $bounds "screenshot.png"

Вот модификация скрипта @npocmaka , который делает полный снимок экрана на всех мониторах. Использование остается прежним.

      // 2>nul||@goto :batch
/*
:batch
@echo off
setlocal

:: find csc.exe
set "csc="
for /r "%SystemRoot%\Microsoft.NET\Framework\" %%# in ("*csc.exe") do  set "csc=%%#"

if not exist "%csc%" (
   echo no .net framework installed
   exit /b 10
)

if not exist "%~n0.exe" (
   call %csc% /nologo /r:"Microsoft.VisualBasic.dll" /out:"%~n0.exe" "%~dpsfnx0" || (
      exit /b %errorlevel% 
   )
)
%~n0.exe %*
endlocal & exit /b %errorlevel%

*/

// reference  
// https://gallery.technet.microsoft.com/scriptcenter/eeff544a-f690-4f6b-a586-11eea6fc5eb8

using System;
using System.Runtime.InteropServices;
using System.Drawing;
using System.Drawing.Imaging;
using System.Collections.Generic;
using Microsoft.VisualBasic;

using System.Windows;
using System.Windows.Forms;   // also requires a reference to this assembly
using System.Threading;

/// Provides functions to capture the entire screen, or a particular window, and save it to a file. 

public class ScreenCapture
{

    /// Creates an Image object containing a screen shot the active window 

    public Image CaptureActiveWindow()
    {
        return CaptureWindow(User32.GetForegroundWindow());
    }

    /// Creates an Image object containing a screen shot of the entire desktop 

    public Image CaptureScreen()
    {
        return CaptureWindow(User32.GetDesktopWindow());
    }

    /// Creates an Image object containing a screen shot of a specific window 

    private Image CaptureWindow(IntPtr handle)
    {
        // get te hDC of the target window 
        IntPtr hdcSrc = User32.GetWindowDC(handle);
        // get the size 
        User32.RECT windowRect = new User32.RECT();
        User32.GetWindowRect(handle, ref windowRect);
        int width = windowRect.right - windowRect.left;
        int height = windowRect.bottom - windowRect.top;
        // create a device context we can copy to 
        IntPtr hdcDest = GDI32.CreateCompatibleDC(hdcSrc);
        // create a bitmap we can copy it to, 
        // using GetDeviceCaps to get the width/height 
        IntPtr hBitmap = GDI32.CreateCompatibleBitmap(hdcSrc, width, height);
        // select the bitmap object 
        IntPtr hOld = GDI32.SelectObject(hdcDest, hBitmap);
        // bitblt over 
        GDI32.BitBlt(hdcDest, 0, 0, width, height, hdcSrc, 0, 0, GDI32.SRCCOPY);
        // restore selection 
        GDI32.SelectObject(hdcDest, hOld);
        // clean up 
        GDI32.DeleteDC(hdcDest);
        User32.ReleaseDC(handle, hdcSrc);
        // get a .NET image object for it 
        Image img = Image.FromHbitmap(hBitmap);
        // free up the Bitmap object 
        GDI32.DeleteObject(hBitmap);
        return img;
    }

    public void CaptureActiveWindowToFile(string filename, ImageFormat format)
    {
        Image img = CaptureActiveWindow();
        img.Save(filename, format);
    }

    public void CaptureScreenToFile(string filename, ImageFormat format)
    {
        //Image img = CaptureScreen();
        //img.Save(filename, format);
        
        // Create a new thread for demonstration purposes.
        Thread thread = new Thread(() =>
        {
            // Determine the size of the "virtual screen", which includes all monitors.
            int screenLeft   = SystemInformation.VirtualScreen.Left;
            int screenTop    = SystemInformation.VirtualScreen.Top;
            int screenWidth  = SystemInformation.VirtualScreen.Width;
            int screenHeight = SystemInformation.VirtualScreen.Height;

            // Create a bitmap of the appropriate size to receive the screenshot.
            using (Bitmap bmp = new Bitmap(screenWidth, screenHeight))
            {
                // Draw the screenshot into our bitmap.
                using (Graphics g = Graphics.FromImage(bmp))
                {
                    g.CopyFromScreen(screenLeft, screenTop, 0, 0, bmp.Size);
                }

                // Do something with the Bitmap here, like save it to a file:
                bmp.Save(filename, format);
            }
        });
        thread.SetApartmentState(ApartmentState.STA);
        thread.Start();
    }

    static bool fullscreen = true;
    static String file = "screenshot.bmp";
    static System.Drawing.Imaging.ImageFormat format = System.Drawing.Imaging.ImageFormat.Bmp;
    static String windowTitle = "";

    static void parseArguments()
    {
        String[] arguments = Environment.GetCommandLineArgs();
        if (arguments.Length == 1)
        {
            printHelp();
            Environment.Exit(0);
        }
        if (arguments[1].ToLower().Equals("/h") || arguments[1].ToLower().Equals("/help"))
        {
            printHelp();
            Environment.Exit(0);
        }

        file = arguments[1];
        Dictionary<String, System.Drawing.Imaging.ImageFormat> formats =
        new Dictionary<String, System.Drawing.Imaging.ImageFormat>();

        formats.Add("bmp", System.Drawing.Imaging.ImageFormat.Bmp);
        formats.Add("emf", System.Drawing.Imaging.ImageFormat.Emf);
        formats.Add("exif", System.Drawing.Imaging.ImageFormat.Exif);
        formats.Add("jpg", System.Drawing.Imaging.ImageFormat.Jpeg);
        formats.Add("jpeg", System.Drawing.Imaging.ImageFormat.Jpeg);
        formats.Add("gif", System.Drawing.Imaging.ImageFormat.Gif);
        formats.Add("png", System.Drawing.Imaging.ImageFormat.Png);
        formats.Add("tiff", System.Drawing.Imaging.ImageFormat.Tiff);
        formats.Add("wmf", System.Drawing.Imaging.ImageFormat.Wmf);


        String ext = "";
        if (file.LastIndexOf('.') > -1)
        {
            ext = file.ToLower().Substring(file.LastIndexOf('.') + 1, file.Length - file.LastIndexOf('.') - 1);
        }
        else
        {
            Console.WriteLine("Invalid file name - no extension");
            Environment.Exit(7);
        }

        try
        {
            format = formats[ext];
        }
        catch (Exception e)
        {
            Console.WriteLine("Probably wrong file format:" + ext);
            Console.WriteLine(e.ToString());
            Environment.Exit(8);
        }


        if (arguments.Length > 2)
        {
            windowTitle = arguments[2];
            fullscreen = false;
        }

    }

    static void printHelp()
    {
        //clears the extension from the script name
        String scriptName = Environment.GetCommandLineArgs()[0];
        scriptName = scriptName.Substring(0, scriptName.Length);
        Console.WriteLine(scriptName + " captures the screen or the active window and saves it to a file.");
        Console.WriteLine("");
        Console.WriteLine("Usage:");
        Console.WriteLine(" " + scriptName + " filename  [WindowTitle]");
        Console.WriteLine("");
        Console.WriteLine("filename - the file where the screen capture will be saved");
        Console.WriteLine("     allowed file extensions are - Bmp,Emf,Exif,Gif,Icon,Jpeg,Png,Tiff,Wmf.");
        Console.WriteLine("WindowTitle - instead of capture whole screen you can point to a window ");
        Console.WriteLine("     with a title which will put on focus and captuted.");
        Console.WriteLine("     For WindowTitle you can pass only the first few characters.");
        Console.WriteLine("     If don't want to change the current active window pass only \"\"");
    }

    public static void Main()
    {
        User32.SetProcessDPIAware();
        
        parseArguments();
        ScreenCapture sc = new ScreenCapture();
        if (!fullscreen && !windowTitle.Equals(""))
        {
            try
            {

                Interaction.AppActivate(windowTitle);
                Console.WriteLine("setting " + windowTitle + " on focus");
            }
            catch (Exception e)
            {
                Console.WriteLine("Probably there's no window like " + windowTitle);
                Console.WriteLine(e.ToString());
                Environment.Exit(9);
            }


        }
        try
        {
            if (fullscreen)
            {
                Console.WriteLine("Taking a capture of the whole screen to " + file);
                sc.CaptureScreenToFile(file, format);
            }
            else
            {
                Console.WriteLine("Taking a capture of the active window to " + file);
                sc.CaptureActiveWindowToFile(file, format);
            }
        }
        catch (Exception e)
        {
            Console.WriteLine("Check if file path is valid " + file);
            Console.WriteLine(e.ToString());
        }
    }

    /// Helper class containing Gdi32 API functions 

    private class GDI32
    {

        public const int SRCCOPY = 0x00CC0020; // BitBlt dwRop parameter 
        [DllImport("gdi32.dll")]
        public static extern bool BitBlt(IntPtr hObject, int nXDest, int nYDest,
          int nWidth, int nHeight, IntPtr hObjectSource,
          int nXSrc, int nYSrc, int dwRop);
        [DllImport("gdi32.dll")]
        public static extern IntPtr CreateCompatibleBitmap(IntPtr hDC, int nWidth,
          int nHeight);
        [DllImport("gdi32.dll")]
        public static extern IntPtr CreateCompatibleDC(IntPtr hDC);
        [DllImport("gdi32.dll")]
        public static extern bool DeleteDC(IntPtr hDC);
        [DllImport("gdi32.dll")]
        public static extern bool DeleteObject(IntPtr hObject);
        [DllImport("gdi32.dll")]
        public static extern IntPtr SelectObject(IntPtr hDC, IntPtr hObject);
    }


    /// Helper class containing User32 API functions 

    private class User32
    {
        [StructLayout(LayoutKind.Sequential)]
        public struct RECT
        {
            public int left;
            public int top;
            public int right;
            public int bottom;
        }
        [DllImport("user32.dll")]
        public static extern IntPtr GetDesktopWindow();
        [DllImport("user32.dll")]
        public static extern IntPtr GetWindowDC(IntPtr hWnd);
        [DllImport("user32.dll")]
        public static extern IntPtr ReleaseDC(IntPtr hWnd, IntPtr hDC);
        [DllImport("user32.dll")]
        public static extern IntPtr GetWindowRect(IntPtr hWnd, ref RECT rect);
        [DllImport("user32.dll")]
        public static extern IntPtr GetForegroundWindow();
        [DllImport("user32.dll")]
        public static extern int SetProcessDPIAware();
    }
}