Procesamiento de imagen de la cámara

Question

Básicamente tengo un chip de cámara (módulo de cámara: C3038, usa el sensor de imagen CMOS de OmniVision OV6630) conectado a una PC a través de un enlace RS232. Quiero leer datos de imagen en un programa Java que está en este formato (de acuerdo con las especificaciones de la cámara): formato de

datos - YUV 4: 2: 2, PSG 4: 2: 2, RGB datos brutos

¿Alguna pista sobre cómo hacerlo?

Mi aplicación:

import gnu.io.CommPortIdentifier; 
import gnu.io.PortInUseException; 
import gnu.io.SerialPort; 
import gnu.io.SerialPortEvent; 
import gnu.io.SerialPortEventListener; 
import gnu.io.UnsupportedCommOperationException; 

import java.awt.*; 
import java.awt.image.*; 
import java.io.*; 
import java.util.*; 
import javax.swing.*; 
import javax.imageio.*; 

public class SimpleRead1 implements Runnable, SerialPortEventListener { 
static CommPortIdentifier portId; 
static Enumeration portList; 

InputStream inputStream; 
SerialPort serialPort; 
Thread readThread; 
byte [] readBuffer; 
static byte [] storeBuffer; 

public SimpleRead1() { 
    try { 
     serialPort = (SerialPort) portId.open("SimpleReadApp", 2000); 
    }catch (PortInUseException e) {System.out.println(e);} 

    try { 
     inputStream = serialPort.getInputStream(); 
    }catch (IOException e) {System.out.println(e);} 

    try { 
     serialPort.addEventListener(this); 
    } catch (TooManyListenersException e) {System.out.println(e);} 

    serialPort.notifyOnDataAvailable(true); 

    try { 
     serialPort.setSerialPortParams(9600, 
      SerialPort.DATABITS_8, 
      SerialPort.STOPBITS_1, 
      SerialPort.PARITY_NONE); 
    } catch (UnsupportedCommOperationException e) {System.out.println(e);} 

    readThread = new Thread(this); 
    readThread.start(); 
} 

public void run() { 
    try { 
     Thread.sleep(20000); 
    } catch (InterruptedException e) {System.out.println(e);} 
} 

@Override 
public void serialEvent(SerialPortEvent event){ 
    switch(event.getEventType()) { 
    case SerialPortEvent.BI: 
    case SerialPortEvent.OE: 
    case SerialPortEvent.FE: 
    case SerialPortEvent.PE: 
    case SerialPortEvent.CD: 
    case SerialPortEvent.CTS: 
    case SerialPortEvent.DSR: 
    case SerialPortEvent.RI: 
    case SerialPortEvent.OUTPUT_BUFFER_EMPTY: 
     break; 
    case SerialPortEvent.DATA_AVAILABLE: 
     readBuffer = new byte[Integer.MAX_VALUE]; 

     try { 
      while (inputStream.available() > 0) { 

       int numBytes = inputStream.read(readBuffer); 
       System.out.print(new String(readBuffer)); 
      } 
      } catch (IOException e) {e.printStackTrace();} 

     InputStream in = new ByteArrayInputStream(readBuffer); 
     BufferedImage image = null; 

     try { 
      image = ImageIO.read(in); 
     } catch (IOException e) {e.printStackTrace();} 

     //GUI for displaying image 
     ImageIcon imageIcon = new ImageIcon(image); 
     JLabel label = new JLabel(); 
     label.setIcon(imageIcon); 
     JFrame frame = new JFrame("image display"); 
     frame.getContentPane().add(label,BorderLayout.CENTER); 
     frame.pack(); 
     frame.setLocationRelativeTo(null); 
     frame.setVisible(true);      
     break; 
    } 
} 

public static void main(String[] args) throws Exception { 
    portList = CommPortIdentifier.getPortIdentifiers(); 

    while (portList.hasMoreElements()) { 
     portId = (CommPortIdentifier) portList.nextElement(); 
     if (portId.getPortType() == CommPortIdentifier.PORT_SERIAL) { 
      if (portId.getName().equals("COM7")) { 
     //    if (portId.getName().equals("/dev/term/a")) { 
       SimpleRead1 reader = new SimpleRead1(); 
      } 
     } 
    } 
} 
} 

Answer 1

La pregunta es una especie de amplia por lo que no sabe la cantidad de experiencia que tiene, pero para RS-232 que va a tener que utilizar un SerialPort. Here es un ejemplo simple para comenzar a leer desde un puerto COM.

Answer 2

Desafortunadamente, Java no admite puertos serie por sí mismo; para eso necesita una biblioteca externa. Sugiero echar un vistazo a the RXTX library, que parece ser un estándar de hecho en estos días.

Los chips de sensores de video generalmente tienen interfaces de comunicación relativamente simples por sí solos (es decir, sin un chip de puente). Por lo general, se reduce a establecer los parámetros de la imagen, iniciar la transferencia de datos de la imagen real y luego leer una cantidad de bytes en un búfer. En ocasiones puede estar involucrada una firma de inicio o fin de datos de imagen, pero eso es todo.

No debe ser demasiado difícil si usted tiene toda la documentación para que en fichas en la mano - lo que he hecho de vez en cuando algo similar en C sin ninguna documentación ...

EDIT:

Una vez que haya leído la imagen en una matriz de bytes, es posible que pueda usar the BufferedImage class para que sea utilizable para Java. Dicho esto, no he podido determinar si Java admite algo más que variaciones de ARGB: puede que tenga que hacer la conversión de espacio de color por su cuenta (o a través de una biblioteca de terceros, supongo) si desea utilizar un dispositivo que no sea - Modo RGB en tu sensor.