Cómo tomar capturas de pantalla rápidamente en Java?

Question

Estoy implementando un rastreador de ojos simple, que requiere captura de pantalla rápida de lo que está sucediendo en la pantalla simultáneamente con la captura del video de la cámara web.

La cosa es que la manera de hacerlo con Robot, mencionado aquí: https://stackoverflow.com/questions/2475303/java-library-for-capturing-active-window-screenshot es extremadamente lento.

Por cierto, la recuperación del video de una cámara web funciona mucho más rápido y devuelve la matriz de bytes, que es muy rápida de procesar.

¿Alguien conoce una solución más rápida? Las bibliotecas C++, que pueden vincularse a Java para hacer esto, también pueden ser útiles.

Gracias!

ACTUALIZACIÓN: decidió cambiar a OpenCV, ahora está buscando la manera de hacer captura de pantalla con él :)

Answer 1

u debe definitivamente dar un tiro a OpenCV

Answer 2

puede ser usted puede hacer uso de JMF .. Pedido del Screen Grabber code @ Oracle's site. Creo que te ayudará a resolver tu problema.

Answer 3

La llamada robot.createScreenCapture(captureSize); tarda aproximadamente 20ms para mí.

Answer 4

Aquí hay una versión específica de Windows usando JNA que estoy usando en uno de mis proyectos.

He encontrado que es una orden de magnitud más rápida que Robot, incluso con la sobrecarga de llamada nativa.

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