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

CameraX kullanım alanının çıkışı iki bölümden oluşur: arabellek ve dönüştürme bilgileri. Arabellek bir bayt dizisidir ve dönüştürme bilgileri, arabelleğin son kullanıcılara gösterilmeden önce nasıl kırpılması ve döndürülmesi gerektiğini belirtir. Nasıl uygulanır? tamponun biçimine bağlıdır.

ImageCapture

ImageCapture kullanım alanı için kırpma dikdörtgeni arabelleği kaydedilmeden önce uygulanır eklenir ve rotasyon EXIF verilerine kaydedilir. Uygulamanın yapması gereken başka bir işlem yoktur.

Önizle

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

Dönüşüm bilgilerinin nasıl uygulanacağı Surface kaynağına bağlıdır ve genellikle basit değildir. Amaç yalnızca önizlemeyi görüntülemekse PreviewView kullanın. PreviewView, otomatik olarak ve dönüşümü ele alır. Gelişmiş kullanımlar için, önizlemeyi düzenlemeniz gerektiğinde akışını kullanıyorsanız, KameraX çekirdek testindeki kod örneğine uygulamasında bulabilirsiniz.

Koordinatları dönüştürme

Sık karşılaşılan bir diğer görev de, önizlemede algılanan yüzün etrafına kutu çizmek gibi, arabellek yerine koordinatlarla çalışmaktır. Böyle durumlarda algılanan yüzün koordinatlarını resim analizinden yeni bir boyuta önizle.

Aşağıdaki kod snippet'i, resim analizinden eşlenen bir matris oluşturur koordinatlarını PreviewView koordinatlarına verir. (x, y) koordinatlarını dönüştürmek için Matrix kullanıyorsanız 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;
}