Wie nehmen screenshots schnell in Java?

Ich bin die Implementierung einer einfachen eye-tracker, die erfordert schnelle screenshoting, was auf dem Bildschirm passiert gleichzeitig mit der Aufnahme das video von webcam.

Die Sache ist, dass die Art und Weise, es zu tun mit Roboter, die hier erwähnt werden: https://stackoverflow.com/questions/2475303/java-library-for-capturing-active-window-screenshot
ist extrem langsam.

Durch die Art und Weise, das abrufen von video von einer webcam funktioniert viel schneller und gibt den byte-array, die sehr schnell verarbeitet werden.

Weiß jemand eine schnellere Lösung? C++ - Bibliotheken, die verknüpft werden können, um Java, dies zu tun kann helfen, wie gut.

Danke!

UPDATE:
Beschlossen, zu wechseln, OpenCV, sucht nun den Weg zu machen, screenshot mit ihm 🙂

  • Die Antworten auf die verwiesen wird, Frage sind zwei völlig verschiedene Arten der Nutzung von Robot. Was hast du Profil?
  • Fügte hinzu, es zu dem post weiter unten
  • Check out nircmd.Es hat eine eingebaute Funktion, um dies zu tun nircmd.exe cmdwait 0 savescreenshot "f:\temp\shot.png" .Setzen Sie dieses Programm in Ihr Projekt und führen Sie es mit Laufzeit()
InformationsquelleAutor lyuba | 2010-05-26
  1. 0

    u sollten auf jeden Fall geben einen Schuss auf OpenCV

    • Gibt es eine Möglichkeit, link OpenCV Java? Ich habe gehört, OpenCV, aber jetzt möchte ich versuchen, Java für diese Aufgabe, und wechseln Sie zu C++ nur wenn es wirklich notwendig ist.
    • Hier ist der Weg, es zu tun: ubaa.net/shared/processing/opencv Allerdings habe ich beschlossen, zu versuchen, C++, danke für die inspiration!
    • oh danke für das java-api, ich war eigentlich auf der Suche für Sie zu!
    • Hier ist auch eine bessere API: code.google.com/p/javacv
    InformationsquelleAutor Elijah Saounkine
  2. 11

    Hier ist eine Windows-spezifische version mit JNA, die ich benutze in einem meiner Projekte.

    Habe ich festgestellt, dass es eine Größenordnung schneller als Robot auch mit der systemeigenen Aufruf-overhead.

    import java.awt.Rectangle;
import java.awt.image.BufferedImage;
import java.awt.image.ColorModel;
import java.awt.image.DataBuffer;
import java.awt.image.DataBufferInt;
import java.awt.image.DataBufferUShort;
import java.awt.image.DirectColorModel;
import java.awt.image.Raster;
import java.awt.image.WritableRaster;

import com.sun.jna.Native;
import com.sun.jna.platform.win32.W32API;
import com.sun.jna.win32.W32APIOptions;

public class JNAScreenShot {

    public static BufferedImage getScreenshot(Rectangle bounds) {
        W32API.HDC windowDC = GDI.GetDC(USER.GetDesktopWindow());
        W32API.HBITMAP outputBitmap =
            GDI.CreateCompatibleBitmap(windowDC,
                                       bounds.width, bounds.height);
        try {
            W32API.HDC blitDC = GDI.CreateCompatibleDC(windowDC);
            try {
                W32API.HANDLE oldBitmap =
                    GDI.SelectObject(blitDC, outputBitmap);
                try {
                    GDI.BitBlt(blitDC,
                               0, 0, bounds.width, bounds.height,
                               windowDC,
                               bounds.x, bounds.y,
                               GDI32.SRCCOPY);
                } finally {
                    GDI.SelectObject(blitDC, oldBitmap);
                }
                GDI32.BITMAPINFO bi = new GDI32.BITMAPINFO(40);
                bi.bmiHeader.biSize = 40;
                boolean ok =
                    GDI.GetDIBits(blitDC, outputBitmap, 0, bounds.height,
                                  (byte[]) null, bi, GDI32.DIB_RGB_COLORS);
                if (ok) {
                    GDI32.BITMAPINFOHEADER bih = bi.bmiHeader;
                    bih.biHeight = - Math.abs(bih.biHeight);
                    bi.bmiHeader.biCompression = 0;
                    return bufferedImageFromBitmap(blitDC, outputBitmap, bi);
                } else {
                    return null;
                }
            } finally {
                GDI.DeleteObject(blitDC);
            }
        } finally {
            GDI.DeleteObject(outputBitmap);
        }
    }

    private static BufferedImage
    bufferedImageFromBitmap(GDI32.HDC        blitDC,
                            GDI32.HBITMAP    outputBitmap,
                            GDI32.BITMAPINFO bi) {
        GDI32.BITMAPINFOHEADER bih = bi.bmiHeader;
        int height = Math.abs(bih.biHeight);
        final ColorModel cm;
        final DataBuffer buffer;
        final WritableRaster raster;
        int strideBits =
            (bih.biWidth * bih.biBitCount);
        int strideBytesAligned =
            (((strideBits - 1) | 0x1F) + 1) >> 3;
        final int strideElementsAligned;
        switch (bih.biBitCount) {
        case 16:
            strideElementsAligned = strideBytesAligned / 2;
            cm = new DirectColorModel(16, 0x7C00, 0x3E0, 0x1F);
            buffer =
                new DataBufferUShort(strideElementsAligned * height);
            raster =
                Raster.createPackedRaster(buffer,
                                          bih.biWidth, height,
                                          strideElementsAligned,
                                          ((DirectColorModel) cm).getMasks(),
                                          null);
            break;
        case 32:
            strideElementsAligned = strideBytesAligned / 4;
            cm = new DirectColorModel(32, 0xFF0000, 0xFF00, 0xFF);
            buffer =
                new DataBufferInt(strideElementsAligned * height);
            raster =
                Raster.createPackedRaster(buffer,
                                          bih.biWidth, height,
                                          strideElementsAligned,
                                          ((DirectColorModel) cm).getMasks(),
                                          null);
            break;
        default:
            throw new IllegalArgumentException("Unsupported bit count: " + bih.biBitCount);
        }
        final boolean ok;
        switch (buffer.getDataType()) {
            case DataBuffer.TYPE_INT:
                {
                    int[] pixels = ((DataBufferInt) buffer).getData();
                    ok = GDI.GetDIBits(blitDC, outputBitmap, 0, raster.getHeight(), pixels, bi, 0);
                }
                break;
            case DataBuffer.TYPE_USHORT:
                {
                    short[] pixels = ((DataBufferUShort) buffer).getData();
                    ok = GDI.GetDIBits(blitDC, outputBitmap, 0, raster.getHeight(), pixels, bi, 0);
                }
                break;
            default:
                throw new AssertionError("Unexpected buffer element type: " + buffer.getDataType());
        }
        if (ok) {
            return new BufferedImage(cm, raster, false, null);
        } else {
            return null;
        }
    }

    private static final User32 USER = User32.INSTANCE;

    private static final GDI32 GDI = GDI32.INSTANCE;

}

interface GDI32 extends com.sun.jna.platform.win32.GDI32 {
    GDI32 INSTANCE =
        (GDI32) Native.loadLibrary(GDI32.class);
    boolean BitBlt(HDC hdcDest,
                   int nXDest,
                   int nYDest,
                   int nWidth,
                   int nHeight,
                   HDC hdcSrc,
                   int nXSrc,
                   int nYSrc,
                   int dwRop);
    HDC GetDC(HWND hWnd);
    boolean GetDIBits(HDC dc, HBITMAP bmp, int startScan, int scanLines,
                      byte[] pixels, BITMAPINFO bi, int usage);
    boolean GetDIBits(HDC dc, HBITMAP bmp, int startScan, int scanLines,
                      short[] pixels, BITMAPINFO bi, int usage);
    boolean GetDIBits(HDC dc, HBITMAP bmp, int startScan, int scanLines,
                      int[] pixels, BITMAPINFO bi, int usage);
    int SRCCOPY = 0xCC0020;
}

interface User32 extends com.sun.jna.platform.win32.User32 {
    User32 INSTANCE =
        (User32) Native.loadLibrary(User32.class,
                                    W32APIOptions.UNICODE_OPTIONS);
    HWND GetDesktopWindow();
}
    • Welche version von JNA nicht diese verwenden? Ich bin nicht in der Lage, um es zu kompilieren, die in keiner der Versionen die ich gefunden habe. Die neuesten 3.3.0 aufgeteilt hat, com.Sonne.jna.- Plattform.win32.W32API in Stücke, und die älteren Versionen nicht finden können com.Sonne.jna.- Plattform.win32. Ich habe versucht, 3.2.3, 3.2.5, 3.2.7 und 3.3.0.
    • hey gibt es eine Möglichkeit zu speichern, den Inhalt einer HDC? Ich verstehe, wie Sie speichern Sie Sie als JPEG-Dateien, aber ich Frage mich, ob es auch eine wirklich schnelle Weg zu speichern, den Inhalt einer HDC-so kann ich später resue, die Ihnen die Erstellung von jpegs
    • konnte es nicht zu funktionieren. Welche version von JNA hast du @finnw ?
    • sorry, ich kann mich nicht erinnern, und haben keinen Zugang zu, dass die Codebasis im moment, aber ich glaube, es war die neueste version, wenn ich es installiert (um den Juni 2009.)
    • für alle, die sich bei einer neueren version von diesem code : stackoverflow.com/questions/6998438/...
    • Funktioniert der code funktioniert auf Linux?
    • Nein, aber ich zurückgreifen, um die Robot version in diesem Fall
    • ist der Roboter zu langsam über 0,5 Sekunden;

    InformationsquelleAutor finnw
  3. 6

    Den robot.createScreenCapture(captureSize); Anruf dauert etwa 20ms für mich.

    • Ich denke, dass die Geschwindigkeit abhängig wäre von der framerate/Treiber von der webcam in Frage.
    • Ich habe nicht viel Erfahrung in der Arbeit mit Daten von webcams, aber ich dachte, Sie würde liefern viel geringere Auflösung, und pre-komprimierte streams.
    • Du hast Recht: ich habe die reguläre Logitek C300 webcam, so gibt es 480*640 Bilder. Ich benutze die Video-lib für Linux mit video, es ' s geschrieben auf C und läuft perfekt schnell. Diejenigen, die ich versuche zu fangen, der screenshot mit der gleichen Geschwindigkeit in Echtzeit - sofort verlangsamt den Prozess. Ich halte es wie BufferedImage screenshot = Roboter.createScreenCapture( new Rectangle(Toolkit.getDefaultToolkit().getScreenSize())); Kann es passieren, weil der BurrefedImage? Gibt es eine Möglichkeit, die das bit-array von Roboter?
    • Was ich hinzufügen sollte ist, dass das wichtigste im eye-tracker ist, fangen die Abbildung fast im gleichen Augenblick als jede webcam-Aufnahme. 20ms sein kann, ist eigentlich zu lange. Das wäre auch toll, capture-Bildschirm in der normalen Größe, nicht nur 480*640.
    • Suche an der Quelle der createScreenCapture zeigt, dass ein RobotPeer wird gebeten, bei der byte-array, das dann eingewickelt in eine entsprechende BufferedImage. Es beinhaltet auch sync und restoreLocalAcceleration Anrufe. Allerdings RobotPeer ist nicht in der Lage, direkt verwendet werden.
    InformationsquelleAutor Stephen Denne
  4. 0

    Möglicherweise können Sie Gebrauch machen von JMF.. die Kasse Screen Grabber code @ Oracle-Website. Ich denke, es wird helfen, Ihr problem zu lösen.

    InformationsquelleAutor Abdel Raoof
  5. 0

    Erfassen Vollbild.

    Robot robot = new Robot();
Rectangle screenRect = new Rectangle(Toolkit.getDefaultToolkit().getScreenSize());
BufferedImage screenFullImage = robot.createScreenCapture(screenRect);
ImageIO.write(screenFullImage, format, new File(destination));

    Erfassen partial-Bildschirm.

    Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
Rectangle rect = new Rectangle(0, 0, screenSize.width / 2, screenSize.height / 2);
Robot robot = new Robot();
BufferedImage screenFullImage = robot.createScreenCapture(rect);
ImageIO.write(screenFullImage, format, new File(destination));

    Referenz : link

    InformationsquelleAutor Hari Krishna
Schreibe einen Kommentar