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

CameraX kullanım alanının sonucu iki yönlüdür: tampon ve dönüşüm bilgisi. Tampon bir bayt dizisidir. Dönüşüm bilgisi ise son kullanıcılara gösterilmeden önce arabelleğin nasıl kırpılıp döndürülmesi gerektiğini belirler. Dönüşümün nasıl uygulanacağı tamponun biçimine bağlıdır.

Resim Yakalama

ImageCapture kullanım alanında, kırpma dikdörtgeni arabelleği diske kaydedilmeden önce uygulanır ve döndürme EXIF verilerine kaydedilir. Uygulamanın herhangi bir başka işlem yapması gerekmez.

Önizle

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

Dönüşüm bilgilerinin nasıl uygulanacağı, Surface kaynağına bağlıdır ve genellikle önemsizdir. Hedef yalnızca önizlemeyi görüntülemekse PreviewView öğesini kullanın. PreviewView, dönüşümü otomatik olarak işleyen özel bir görünümdür. Gelişmiş kullanımlar için, OpenGL'de olduğu gibi önizleme akışını düzenlemeniz gerektiğinde KameraX temel test uygulamasındaki kod örneğine bakın.

Koordinatları dönüştürme

Yaygın olarak yapılan bir diğer görev ise arabellek yerine koordinatlarla çalışmaktır. Örneğin, önizlemede algılanan yüzün etrafına bir kutu çizebilirsiniz. Bu gibi durumlarda, algılanan yüzün koordinatlarını resim analizinden önizlemeye dönüştürmeniz gerekir.

Aşağıdaki kod snippet'i, görüntü analizi koordinatlarından PreviewView koordinatlarıyla eşlenen bir matris oluşturur. (x, y) koordinatlarını Matrix ile dönüştürmek için Matrix.mapPoints() bölümüne bakın.

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