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

CameraX kullanım alanının iki sonucu vardır: tampon ve dönüşüm bilgisi. Arabellek bir bayt dizisidir; dönüştürme bilgisi ise arabelleğin son kullanıcılara gösterilmeden önce kırpılıp döndürülmelidir. Nasıl uygulanır? tamponun biçimine bağlıdır.

Resim Yakalama

ImageCapture kullanım alanı için kırpma dikdörtgeni arabelleği kaydedilmeden önce uygulanır eklenir ve rotasyon EXIF verilerine kaydedilir. Ek ödeme aracı Uygulamada işlem gerekiyor.

Önizle

Preview kullanım alanı için dönüşüm bilgilerini şu şekilde alabilirsiniz: arama SurfaceRequest.setTransformationInfoListener() Dönüşüm her güncellendiğinde, arayan, yeni bir SurfaceRequest.TransformationInfo nesnesini tanımlayın.

Dönüştürme bilgilerinin nasıl uygulanacağı, Surface ve genellikle önemsizdir. Hedef, yalnızca Önizleme için 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 gösterilir.

Koordinatları dönüştürme

Sık yapılan bir diğer görev ise tampon yerine koordinatlarla çalışmaktır. böylece önizlemede algılanan yüzün etrafına bir kutu çizebilirsiniz. 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().

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