Trasforma output

L'output di un caso d'uso di CameraX è duplice: il buffer e le informazioni di trasformazione. Il buffer è un array di byte e le informazioni di trasformazione indicano come il buffer deve essere ritagliato e ruotato prima di essere mostrato agli utenti finali. La modalità di applicazione della trasformazione dipende dal formato del buffer.

ImageCapture

Per il caso d'uso ImageCapture, il buffer del rettangolo di ritaglio viene applicato prima del salvataggio su disco e la rotazione viene salvata nei dati Exif. L'app non deve eseguire alcuna azione aggiuntiva.

Preview

Per il caso d'uso Preview, puoi ottenere le informazioni di trasformazione chiamando SurfaceRequest.setTransformationInfoListener(). Ogni volta che la trasformazione viene aggiornata, il chiamante riceve un nuovo SurfaceRequest.TransformationInfo oggetto.

La modalità di applicazione delle informazioni di trasformazione dipende dall'origine di Surface e in genere non è banale. Se l'obiettivo è semplicemente visualizzare l' anteprima, utilizza PreviewView. PreviewView è una visualizzazione personalizzata che gestisce automaticamente la trasformazione. Per usi avanzati, quando devi modificare lo stream di anteprima, ad esempio con OpenGL, consulta l'esempio di codice nell'appdi test principale di CameraX.

Trasformare le coordinate

Un'altra attività comune è lavorare con le coordinate anziché con il buffer, ad esempio disegnare un riquadro attorno al volto rilevato nell'anteprima. In questi casi, devi trasformare le coordinate del volto rilevato dall'analisi delle immagini in anteprima.

Il seguente snippet di codice crea una matrice che esegue il mapping dalle coordinate di analisi delle immagini alle coordinate PreviewView. Per trasformare le coordinate (x, y) con una Matrix, consulta Matrix.mapPoints().

Kotlin

fun getCorrectionMatrix(imageProxy: ImageProxy, previewView: PreviewView) : Matrix {
   val cropRect = imageProxy.cropRect
   val rotationDegrees = imageProxy.imageInfo.rotationDegrees
   val matrix = Matrix()

   // A float array of the source vertices (crop rect) in clockwise order.
   val source = floatArrayOf(
       cropRect.left.toFloat(),
       cropRect.top.toFloat(),
       cropRect.right.toFloat(),
       cropRect.top.toFloat(),
       cropRect.right.toFloat(),
       cropRect.bottom.toFloat(),
       cropRect.left.toFloat(),
       cropRect.bottom.toFloat()
   )

   // A float array of the destination vertices in clockwise order.
   val destination = floatArrayOf(
       0f,
       0f,
       previewView.width.toFloat(),
       0f,
       previewView.width.toFloat(),
       previewView.height.toFloat(),
       0f,
       previewView.height.toFloat()
   )

   // The destination vertexes need to be shifted based on rotation degrees. The
   // rotation degree represents the clockwise rotation needed to correct the image.

   // Each vertex is represented by 2 float numbers in the vertices array.
   val vertexSize = 2
   // The destination needs to be shifted 1 vertex for every 90° rotation.
   val shiftOffset = rotationDegrees / 90 * vertexSize;
   val tempArray = destination.clone()
   for (toIndex in source.indices) {
       val fromIndex = (toIndex + shiftOffset) % source.size
       destination[toIndex] = tempArray[fromIndex]
   }
   matrix.setPolyToPoly(source, 0, destination, 0, 4)
   return matrix
}

Java

Matrix getMappingMatrix(ImageProxy imageProxy, PreviewView previewView) {
   Rect cropRect = imageProxy.getCropRect();
   int rotationDegrees = imageProxy.getImageInfo().getRotationDegrees();
   Matrix matrix = new Matrix();

   // A float array of the source vertices (crop rect) in clockwise order.
   float[] source = {
       cropRect.left,
       cropRect.top,
       cropRect.right,
       cropRect.top,
       cropRect.right,
       cropRect.bottom,
       cropRect.left,
       cropRect.bottom
   };

   // A float array of the destination vertices in clockwise order.
   float[] destination = {
       0f,
       0f,
       previewView.getWidth(),
       0f,
       previewView.getWidth(),
       previewView.getHeight(),
       0f,
       previewView.getHeight()
   };

   // The destination vertexes need to be shifted based on rotation degrees.
   // The rotation degree represents the clockwise rotation needed to correct
   // the image.

   // Each vertex is represented by 2 float numbers in the vertices array.
   int vertexSize = 2;
   // The destination needs to be shifted 1 vertex for every 90° rotation.
   int shiftOffset = rotationDegrees / 90 * vertexSize;
   float[] tempArray = destination.clone();
   for (int toIndex = 0; toIndex < source.length; toIndex++) {
       int fromIndex = (toIndex + shiftOffset) % source.length;
       destination[toIndex] = tempArray[fromIndex];
   }
   matrix.setPolyToPoly(source, 0, destination, 0, 4);
   return matrix;
}