Çıkışı dönüştür

CameraX kullanım alanının sonucu iki yönlüdür: arabellek ve dönüşüm bilgileri. Tampon bir bayt dizisidir ve dönüştürme bilgileri arabelleğin son kullanıcılara gösterilmeden önce nasıl kırpılıp döndürüleceğiyle ilgilidir. Dönüşümün nasıl uygulanacağı tamponun biçimine bağlıdır.

Resim Yakalama

ImageCapture kullanım alanında, kırpma dikdörtgen arabelleği diske kaydetmeden önce uygulanır ve rotasyon EXif verilerine kaydedilir. Uygulamanın başka bir işlem yapmasına gerek yoktur.

Önizleme

Preview kullanım alanı için dönüştürme bilgilerini SurfaceRequest.setTransformationInfoListener() yöntemini çağırarak alabilirsiniz. Dönüşüm her güncellendiğinde, çağrıyı yapan kişi yeni bir SurfaceRequest.TransformationInfo nesnesi alır.

Dönüşüm bilgilerinin nasıl uygulanacağı Surface kaynağına bağlı olarak değişiklik gösterir ve genellikle önemsiz değildir. Amaç sadece önizlemeyi görüntülemekse PreviewView işlevini kullanın. PreviewView, dönüşümü otomatik olarak işleyen özel bir görünümdür. İleri düzey kullanımlarda, önizleme akışını düzenlemeniz gerektiğinde (ör. OpenGL ile), KameraX temel test uygulamasındaki kod örneğine bakın.

Koordinatları dönüştürme

Yaygın olarak kullanılan bir başka görev de önizlemede algılanan yüzün etrafına bir kutu çizmek gibi tampon yerine koordinatlarla çalışmaktır. Bu gibi durumlarda, algılanan yüzün koordinatlarını görüntü analizinden önizlemeye dönüştürmeniz gerekir.

Aşağıdaki kod snippet'i, resim analizi koordinatlarından PreviewView koordinatlarına eşlenen bir matris oluşturur. (x, y) koordinatlarını Matrix ile dönüştürmek için Matrix.mapPoints() sayfasını inceleyin.

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