আউটপুট রূপান্তর

একটি CameraX ব্যবহারের ক্ষেত্রে আউটপুট দ্বিগুণ হয়: বাফার এবং রূপান্তর তথ্য। বাফার হল একটি বাইট অ্যারে এবং রূপান্তর তথ্য হল কিভাবে বাফার ক্রপ করা এবং শেষ ব্যবহারকারীদের দেখানোর আগে ঘোরানো উচিত। রূপান্তরটি কীভাবে প্রয়োগ করবেন তা নির্ভর করে বাফারের বিন্যাসের উপর।

ইমেজ ক্যাপচার

ImageCapture ব্যবহারের ক্ষেত্রে, ডিস্কে সংরক্ষণ করার আগে ক্রপ রেক্ট বাফার প্রয়োগ করা হয় এবং ঘূর্ণনটি Exif ডেটাতে সংরক্ষণ করা হয়। অ্যাপ থেকে কোনো অতিরিক্ত পদক্ষেপের প্রয়োজন নেই।

পূর্বরূপ

Preview ব্যবহারের ক্ষেত্রে, আপনি SurfaceRequest.setTransformationInfoListener() কল করে রূপান্তরের তথ্য পেতে পারেন। প্রতিবার রূপান্তর আপডেট করা হয়, কলকারী একটি নতুন SurfaceRequest.TransformationInfo অবজেক্ট পায়।

কিভাবে রূপান্তর তথ্য প্রয়োগ করতে হয় Surface উৎসের উপর নির্ভর করে, এবং সাধারণত অ-তুচ্ছ। যদি লক্ষ্যটি কেবল প্রাকদর্শন প্রদর্শন করা হয়, PreviewView ব্যবহার করুন। PreviewView হল একটি কাস্টম ভিউ যা স্বয়ংক্রিয়ভাবে রূপান্তর পরিচালনা করে। উন্নত ব্যবহারের জন্য, যখন আপনাকে প্রাকদর্শন স্ট্রীম সম্পাদনা করতে হবে, যেমন OpenGL এর সাথে, CameraX কোর পরীক্ষা অ্যাপে কোড নমুনা দেখুন।

স্থানাঙ্ক রূপান্তর করুন

আরেকটি সাধারণ কাজ হল বাফারের পরিবর্তে স্থানাঙ্কগুলির সাথে কাজ করা, যেমন পূর্বরূপে সনাক্ত করা মুখের চারপাশে একটি বাক্স আঁকা। এই ধরনের ক্ষেত্রে, আপনাকে সনাক্ত করা মুখের স্থানাঙ্কগুলিকে চিত্র বিশ্লেষণ থেকে প্রিভিউতে রূপান্তর করতে হবে।

নিম্নলিখিত কোড স্নিপেট একটি ম্যাট্রিক্স তৈরি করে যা চিত্র বিশ্লেষণ স্থানাঙ্ক থেকে PreviewView স্থানাঙ্কে ম্যাপ করে। একটি Matrix সাথে (x, y) স্থানাঙ্কগুলিকে রূপান্তর করতে, 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;
}