Join FlipAndroid.COM Telegram Group: https://t.me/joinchat/F_aqThGkhwcLzmI49vKAiw


Imagen de la cámara a Bitmap resultados en desordenado imagen

Este es mi código que utilizo para guardar la imagen en un Bitmap . Este pedazo de código se basa en el código de CyanogenMod cámara de aplicación por lo que supongo que funcionaría correctamente, pero no. Lo más importante de este problema es que cuando se probó en un Nexus 4 el Bitmap se estaba creando correctamente para las fotos tomadas con la cámara de frente hacia atrás, pero utilizando la cámara frente a frente dio lugar a lo que se puede ver a continuación.

El código que estoy usando para crear Bitmap :

  • ¿Puedo abrir la cámara en la vista web?
  • Android MediaRecorder setOutPutFile () para transmitir utilizando Socket
  • ¿Cómo detectar la presencia del usuario en android?
  • Modo de enfoque de la cámara Android
  • Android - utiliza la cámara sin vista de superficie o textureview
  • Llamar a la cámara desde una actividad, capturar una imagen y cargarla en un servidor
  •  private class XyzPictureCallback implements Camera.PictureCallback { @Override public void onPictureTaken (byte [] data, Camera camera) { Options options = new Options(); options.inDither = false; options.inPreferredConfig = Bitmap.Config.ARGB_8888; Bitmap image = BitmapFactory.decodeByteArray(data, 0, data.length, options); } } 

    Traté de usar diferentes Options (y ninguna), pero no ayudó. Puede ser algo con el formato de píxel devuelto por las dos cámaras diferentes, pero cuando corrí getSupportedPictureFormats() ambos regresaron ImageFormat.JPEG

    Me estoy quedando sin ideas …

    Probablemente también debería mencionar que guardar los data directamente usando un FileOutputStream fue crear una imagen JPEG adecuada. Así que el problema debe ser con el BitmapFactory y la forma en que crear el Bitmap .

    Este es el mapa de bits que produce este código:

    Imagen rota

    EDIT (24.03.2013):

    Después de pasar varias horas tratando de arreglar esto todavía no tengo ninguna solución real a esto. Todo lo que he descubierto es que el problema sólo se produce cuando establezco el tamaño de la imagen (usando Camera.Parameters.setPictureSize(int width, int height) ) a la resolución más alta posible que está disponible para la cámara frente a frente que he Camera.Parameters.getSupportedPictureSizes() llamando a Camera.Parameters.getSupportedPictureSizes() .

    La resolución que está causando el problema es 1280×960. Como he mencionado antes es la resolución más alta. El segundo más alto es 1280×720 y cuando uso este el cuadro de la salida está muy bien. Comprobé el formato que la cámara escupe y es ImageFormat.JPEG todo el tiempo así que no creo que el formato de píxeles sea el problema aquí …

    EDIT (08.03.2013): Llamada a tomarFoto:

     private class XyzAutoFocusCallback implements Camera.AutoFocusCallback { @Override public void onAutoFocus(boolean success, Camera camera) { if (takingPicture) { camera.takePicture(null, null, myPictureCallback); } else { ... } } 

  • Desbordamiento en restauración en android 4.3
  • ¿Cómo configurar el color / estilo personalizado de ActionBar?
  • Estilo del botón de google maps de Android
  • Java.lang.IndexOutOfBoundsException: Invalid index 2, size is 2
  • Cómo convertir `content: // media / external / images / media / Y` a` file: /// storage / sdcard0 / Pictures / X.jpg` en android?
  • Cómo almacenar la imagen como blob en Sqlite y cómo recuperarlo?
  • 7 Solutions collect form web for “Imagen de la cámara a Bitmap resultados en desordenado imagen”

    La altura y el ancho no son compatibles con esa cámara. Es por eso que parece así y por qué funciona el ajuste 1280×720. Es lo mismo que si configuras tu starcraft para que funcione con una resolución que no es compatible con tu monitor.

    Prueba esto

     Bitmap bmp = BitmapFactory.decodeByteArray(data, 0, data.length); imv.setImageBitmap(bmp); ByteArrayOutputStream bos = new ByteArrayOutputStream(); bmp.compress(CompressFormat.JPEG, 70, bos); 

    ¿Intentaste poner null en tus Opciones? Trata eso:

     @Override public void onPictureTaken(final byte[] data, Camera camera) { Bitmap bm = BitmapFactory.decodeByteArray(data, 0, data.length, null); try { FileOutputStream out = new FileOutputStream(Environment.getExternalStorageDirectory().getAbsolutePath()+"/image.jpg"); bm.compress(Bitmap.CompressFormat.JPEG, 95, out); out.close(); } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } } 

    Yo sugeriría no establecer el tamaño de la imagen en el código y dejar que la cámara devuelva la mejor imagen que puede capturar. Compruebe el código dado en la respuesta aquí. https://stackoverflow.com/a/9745780/2107118

    ¿Está configurando los parámetros de la cámara trasera a la cámara frontal? Otra cosa a probar es para la cámara delantera, intente primero no fijar cualquier parámetro, apenas utilice los ajustes del defecto para ver si trabajará. Me encontré con problemas similares en los dispositivos Samsung, pero que era para la cámara de atrás. También es posible que tenga que girar las imágenes tomadas con la cámara frontal (para los dispositivos Samsung cámara trasera que también)

     public static Bitmap rotate(Bitmap bitmap, int degree) { int w = bitmap.getWidth(); int h = bitmap.getHeight(); Matrix mtx = new Matrix(); mtx.postRotate(degree); return Bitmap.createBitmap(bitmap, 0, 0, w, h, mtx, true); } 

    Probablemente también debería mencionar que guardar los datos directamente usando un FileOutputStream fue crear una imagen JPEG adecuada. Así que el problema debe ser con el BitmapFactory y la forma en que crear el mapa de bits.

    La cámara emite datos JPEG completamente procesados ​​(con suerte), y puede escribirlo en el disco. Ahora lo que debe probar:

    1. Volcado archivo en disco.
    2. Compruebe ese archivo utilizando una herramienta de validación , o algún editor de imágenes en la PC.
    3. Si el Editor de imágenes abre la imagen, guarde una copia de ese Editor de imágenes, utilizando el perfil JPEG estándar.
    4. Haga que BitmapFactory procese el archivo original y el archivo guardado por Image Editor, vea si obtiene un bitmap malo en ambos.

    Si la imagen es válida JPEG y BitmapFactory todavía produce mapa de bits erróneo, el problema es con BitmapFactory (menos probable), si el archivo de salida de la cámara es JPEG no válido, el problema es con la cámara (más probable).

    Este es mi código, que utilizo para tomar fotos, y guardarlas en una base de datos, sin cambiar su calidad.

    Primero necesitas estas variables:

      private static final int CAMERA_PIC_REQUEST = 2500; private Rect Padding = new Rect(-1,-1,-1,-1); private Matrix matrix = new Matrix(); private Bitmap rotatedBitmap = null; private Bitmap bm = null; private Bitmap scaledBitmap= null; private ExifInterface exif ; private int rotation=0; private final BitmapFactory.Options options = new BitmapFactory.Options(); 

    A continuación, establezca la solicitud, de un botón, actividad o fragmento, dependiendo de su aplicación (Mine utiliza un botón)

     btn_camera.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View view) { Intent cameraIntent = new Intent(android.provider.MediaStore.ACTION_IMAGE_CAPTURE); startActivityForResult(cameraIntent, CAMERA_PIC_REQUEST); } } ); 

    Ahora como estoy solicitando la CAMARA _PIC_REQUEST de un Fragmento i implementar este código en el OnActivityResult ()

     @Override public void onActivityResult(int requestCode, int resultCode, Intent data) { if (requestCode == CAMERA_PIC_REQUEST) if (data != null) { imageuri = data.getData(); //Bitmap image = (Bitmap) data.getExtras().get("data"); try { options.inSampleSize = 2; exif = new ExifInterface(getRealPathFromURI(imageuri)); rotation = exif.getAttributeInt(ExifInterface.TAG_ORIENTATION, ExifInterface.ORIENTATION_NORMAL); rotation = exifToDegrees(rotation); bm = BitmapFactory.decodeStream( getActivity().getContentResolver().openInputStream(imageuri),Padding,options); scaledBitmap = Bitmap.createScaledBitmap(bm, 400,400, true); if (rotation != 0) {matrix.postRotate(rotation);} //matrix.postRotate(180); rotatedBitmap = Bitmap.createBitmap(scaledBitmap , 0, 0, scaledBitmap .getWidth(), scaledBitmap .getHeight(), matrix, true); } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } mIvFoto.setImageBitmap(rotatedBitmap); } } 

    La rotación y la matriz son para escalar la imagen tomada, a un ImageView, por lo que puedo tomar una vista previa de la foto, antes de guardarlo. Eso no afecta la calidad de la imagen. Es sólo para el mapa de bits de vista previa. Así que en la variable ScaledBitmap como se puede ver, al crearScaledBitmap, pongo las dimensiones de la imagen, a 400.400 puede colocar las dimensiones de la imagen que desea obtener, asegúrese de girar el mapa de bits, para que pueda obtener la imagen a la derecha , Incluso si toma la foto en modo retrato.

    Por último, los métodos para girar y obtener la imagen desde el Camino que la cámara lo guarda.

     private static int exifToDegrees(int exifOrientation) { if (exifOrientation == ExifInterface.ORIENTATION_ROTATE_90) { return 90; } else if (exifOrientation == ExifInterface.ORIENTATION_ROTATE_180) { return 180; } else if (exifOrientation == ExifInterface.ORIENTATION_ROTATE_270) { return 270; } return 0; } private String getRealPathFromURI(Uri contentURI) { String result; Cursor cursor =getActivity().getContentResolver().query(contentURI, null, null, null, null); if (cursor == null) { // Source is Dropbox or other similar local file path result = contentURI.getPath(); } else { cursor.moveToFirst(); int idx = cursor.getColumnIndex(MediaStore.Images.ImageColumns.DATA); result = cursor.getString(idx); cursor.close(); } return result; } 

    Espero que esto pueda ayudarte.

    FlipAndroid es un fan de Google para Android, Todo sobre Android Phones, Android Wear, Android Dev y Aplicaciones para Android Aplicaciones.