Trasforma output

L'output di un caso d'uso di CameraX è duplice: il buffer e la trasformazione informazioni. Il buffer è un array di byte e le informazioni sulla trasformazione sono il modo in cui il buffer devono essere ritagliati e ruotati prima di essere mostrati agli utenti finali. Come applicare le la trasformazione dipende dal formato del buffer.

Acquisizione di immagini

Per il caso d'uso ImageCapture, il buffer rettangolo di ritaglio viene applicato prima del salvataggio su disco e la rotazione viene salvata nei dati EXIF. Non sono richieste dell'azione richiesta dall'app.

Anteprima

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

Il modo in cui applicare le informazioni sulla trasformazione dipende dall'origine del Surface e di solito non sono banali. Se l'obiettivo è semplicemente visualizzare visualizza l'anteprima, utilizza PreviewView. PreviewView è una visualizzazione personalizzata che automaticamente per gestire la trasformazione. Per utilizzi avanzati, quando devi modificare l'anteprima come con OpenGL, guarda l'esempio di codice nel test del core di CameraX Google Cloud.

Trasformare le coordinate

Un'altra attività comune è lavorare con le coordinate anziché con il buffer, come un riquadro attorno al volto rilevato nell'anteprima. In questi casi, devono trasformare le coordinate del volto rilevato dall'analisi dell'immagine l'anteprima.

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

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
}

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