píxeles de la cámara girados

Question

Quiero hacer algunos procesamientos de imágenes a los píxeles obtenidos de la cámara.

El problema es que los píxeles de la cámara se giran 90 grados.

Im que consigue los píxeles dentro del método onPreviewFrame(byte[] data, Camera camera)

me trató camera.setDisplayOrientation(90); y se muestra el vídeo en la orientación correcta, pero todavía estoy recibiendo los píxeles rotados como se indica en la documentación:

Esto hace no afecta el orden de la matriz de bytes pasada en Android.Hardware.Camera.IPreviewCallback.OnPreviewFrame (Byte [], Android.Hardware.Camera), imágenes JPEG o videos grabados.

También probé:

parameters.setRotation(90); 
camera.setParameters(parameters); 

pero que no funcionó.

estoy usando androide 2,2

imagen superior muestra el SurfaceView utilizando camera.setDisplayOrientation(90);

La segunda imagen se incorpora dentro de onPreviewFrame(byte[] data, Camera camera) de la matriz data. Como puede ver, la matriz data se gira.

Answer 1

Tal vez pueda realizar el procesamiento de imágenes en el marco lateral, y solo se preocupe por la rotación cuando lo muestre (lo que ya ha hecho). Si no es así, debe girar el marco de la manera antigua. He encontrado algo de código en algún lugar (con una pequeña modificación) que podría ayudar:

// load the origial bitmap 
Bitmap bitmap = BitmapFactory.decodeResource(getResources(), 
     R.drawable.android); 

int width = bitmap.width(); 
int height = bitmap.height(); 

// create a matrix for the manipulation 
Matrix matrix = new Matrix(); 
// rotate the Bitmap 90 degrees (counterclockwise) 
matrix.postRotate(90); 

// recreate the new Bitmap, swap width and height and apply transform 
Bitmap rotatedBitmap = Bitmap.createBitmap(bitmap, 0, 0, 
        width, height, matrix, true); 

Esto es fácil porque el método CreateBitmap soporta una transformación de matriz: http://developer.android.com/reference/android/graphics/Bitmap.html#createBitmap(android.graphics.Bitmap, int, int, int, int, android.graphics.Matrix, boolean)

Answer 2

Puede rotar los datos en bruto de la siguiente manera:

// Rotate the data for Portait Mode 
byte[] rotatedData = new byte[data.length]; 
for (int y = 0; y < height; y++) { 
    for (int x = 0; x < width; x++) 
     rotatedData[x * height + height - y - 1] = data[x + y * width]; 
} 

Donde 'ancho' y 'altura' son los tamaños preestablecidos para su imagen de vista previa usando:

Camera.Parameters parameters = camera.getParameters(); 
parameters.setPreviewSize(width, height); 
camera.setParameters(parameters); 

A continuación, puede utilizar los datos girados en consecuencia.

Solo he usado este método para escanear códigos QR y parece funcionar perfectamente. No estoy seguro de cómo podría afectar otras aplicaciones.

Answer 3

Si recibe una matriz de bytes YUV420, el siguiente método puede girar esto en 90 grados.

private byte[] rotateYUV420Degree90(byte[] data, int imageWidth, int imageHeight) 
{ 
    byte [] yuv = new byte[imageWidth*imageHeight*3/2]; 
    // Rotate the Y luma 
    int i = 0; 
    for(int x = 0;x < imageWidth;x++) 
    { 
     for(int y = imageHeight-1;y >= 0;y--)        
     { 
      yuv[i] = data[y*imageWidth+x]; 
      i++; 
     } 
    } 
    // Rotate the U and V color components 
    i = imageWidth*imageHeight*3/2-1; 
    for(int x = imageWidth-1;x > 0;x=x-2) 
    { 
     for(int y = 0;y < imageHeight/2;y++)         
     { 
      yuv[i] = data[(imageWidth*imageHeight)+(y*imageWidth)+x]; 
      i--; 
      yuv[i] = data[(imageWidth*imageHeight)+(y*imageWidth)+(x-1)]; 
      i--; 
     } 
    } 
    return yuv; 
} 

(Tenga en cuenta que esto sólo podría funcionar si el ancho y la altura es un factor de 4)

Answer 4

Aunque estoy un poco tarde a la fiesta, aquí está un método escribí que otros podrían serle de utilidad para girar una imagen YUV420sp (NV21).Ninguno de los otros métodos que vi en SO parecía realmente hacerlo.

public static byte[] rotateNV21(final byte[] yuv, 
           final int width, 
           final int height, 
           final int rotation) 
{ 
    if (rotation == 0) return yuv; 
    if (rotation % 90 != 0 || rotation < 0 || rotation > 270) { 
    throw new IllegalArgumentException("0 <= rotation < 360, rotation % 90 == 0"); 
    } 

    final byte[] output = new byte[yuv.length]; 
    final int  frameSize = width * height; 
    final boolean swap  = rotation % 180 != 0; 
    final boolean xflip  = rotation % 270 != 0; 
    final boolean yflip  = rotation >= 180; 

    for (int j = 0; j < height; j++) { 
    for (int i = 0; i < width; i++) { 
     final int yIn = j * width + i; 
     final int uIn = frameSize + (j >> 1) * width + (i & ~1); 
     final int vIn = uIn  + 1; 

     final int wOut  = swap ? height    : width; 
     final int hOut  = swap ? width    : height; 
     final int iSwapped = swap ? j     : i; 
     final int jSwapped = swap ? i     : j; 
     final int iOut  = xflip ? wOut - iSwapped - 1 : iSwapped; 
     final int jOut  = yflip ? hOut - jSwapped - 1 : jSwapped; 

     final int yOut = jOut * wOut + iOut; 
     final int uOut = frameSize + (jOut >> 1) * wOut + (iOut & ~1); 
     final int vOut = uOut + 1; 

     output[yOut] = (byte)(0xff & yuv[yIn]); 
     output[uOut] = (byte)(0xff & yuv[uIn]); 
     output[vOut] = (byte)(0xff & yuv[vIn]); 
    } 
    } 
    return output; 
}