OpenCV में घुमाएँ VideoCapture एंड्रॉयड

Question

कैसे जब OpenCV पर वर्ग VideoCapture का उपयोग कर कैमरा बारी बारी से करने पर? (एंड्रॉइड पर नमूना चेहरा पहचान)।

if (getResources().getConfiguration().orientation == Configuration.ORIENTATION_PORTRAIT) 
{ 
    Matrix matrix = new Matrix(); 
    matrix.preTranslate(
    (canvas.getWidth() - bmp.getWidth())/2, 
    (canvas.getHeight() - bmp.getHeight())/2); 
    matrix.postRotate(270f, (canvas.getWidth())/2, 
    (canvas.getHeight())/2); 
    canvas.drawBitmap(bmp, matrix, null); 
} 

लेकिन कैमरा से छवि को घुमाने नहीं है: मैं साथ कैनवास घूर्णन कर रहा हूँ पता लगाने का काम चेहरा न।

कैमरा निम्नलिखित से धारा प्राप्त करता है:

@Override 
    protected Bitmap processFrame(VideoCapture capture) { 

    if (getResources().getConfiguration().orientation == Configuration.ORIENTATION_PORTRAIT) { 
     Core.flip(mRgba.t(), mRgba, 0); 
    } 

    else { 
    } 
    capture.retrieve(mRgba, Highgui.CV_CAP_ANDROID_COLOR_FRAME_RGBA); 
    capture.retrieve(mDetect_thread.mGray, 
      Highgui.CV_CAP_ANDROID_GREY_FRAME); 

लेकिन न काम है:

protected Bitmap processFrame(VideoCapture capture) { 

    capture.retrieve(mRgba, Highgui.CV_CAP_ANDROID_COLOR_FRAME_RGBA); 

    capture.retrieve(mGray, 
    Highgui.CV_CAP_ANDROID_GREY_FRAME); 

अद्यतन मैं निम्नलिखित किया था। जब मैं (Android डिवाइस पर) portret अभिविन्यास में कार्यक्रम चलाने - कार्यक्रम शुरू नहीं है जब मैं लैंडस्केप ओरिएंटेशन में rogram चलाने - programm काम करते हैं, लेकिन जब मैं प्रदर्शन पर उपकरण, कार्यक्रम काम करते हैं, लेकिन छवि रोटेशन रोटेशन न

Answer 1

आपका प्रश्न ज्यादातर एक duplicate of this, सिवाय इसके कि आप देख रहे हैं Android संस्करण के लिए है। यह काफी समान है, लेकिन यहाँ यह 90 डिग्री रोटेशन transposing और फिर flipping छवि द्वारा प्राप्त किया जा सकता है,:

# rotate 90º counter-clockwise 
Core.flip(mRgba.t(), mRgba, 0); //mRgba.t() is the transpose 

# rotate 90º clockwise 
Core.flip(mRgba.t(), mRgba, 1); 

अन्य रोटेशन के लिए आप warpAffine उपयोग कर सकते हैं:

Point center = new Point(x,y); 
double angle = 90; 
double scale = 1.0; 

Mat mapMatrix = Imgproc.getRotationMatrix2D(center, angle, scale); 
Imgproc.warpAffine(srcMat, dstMat, mapMatrix, Imgproc.INTER_LINEAR); 

संपादित करें - अधिक पूरा उदाहरणों का पालन करें:

/** 
    * Image is first resized-to-fit the dst Mat and then rotated. 
    * mRgba is the source image, mIntermediateMat should have the same type. 
    */ 
    private void rotationTutorial(){ 
     double ratio = mRgba.height()/(double) mRgba.width(); 

     int rotatedHeight = mRgba.height();  
     int rotatedWidth = (int) Math.round(mRgba.height() * ratio); 

     Imgproc.resize(mRgba, mIntermediateMat, new Size(rotatedHeight, rotatedWidth)); 

     Core.flip(mIntermediateMat.t(), mIntermediateMat, 0); 

     Mat ROI = mRgba.submat(0, mIntermediateMat.rows(), 0, mIntermediateMat.cols()); 

     mIntermediateMat.copyTo(ROI);  
    } 


    /** 
    * Image is rotated - cropped-to-fit dst Mat. 
    * 
    */ 
    private void rotationAffineTutorial(){ 
     // assuming source image's with and height are a pair value: 
     int centerX = Math.round(mRgba.width()/2); 
     int centerY = Math.round(mRgba.height()/2); 

     Point center = new Point(centerY,centerX); 
     double angle = 90; 
     double scale = 1.0; 

     double ratio = mRgba.height()/(double) mRgba.width(); 

     int rotatedHeight = (int) Math.round(mRgba.height());  
     int rotatedWidth = (int) Math.round(mRgba.height() * ratio); 

     Mat mapMatrix = Imgproc.getRotationMatrix2D(center, angle, scale); 

     Size rotatedSize = new Size(rotatedWidth, rotatedHeight); 
     mIntermediateMat = new Mat(rotatedSize, mRgba.type()); 

     Imgproc.warpAffine(mRgba, mIntermediateMat, mapMatrix, mIntermediateMat.size(), Imgproc.INTER_LINEAR); 

     Mat ROI = mRgba.submat(0, mIntermediateMat.rows(), 0, mIntermediateMat.cols()); 

     mIntermediateMat.copyTo(ROI); 
    } 

नोट:

• इन उदाहरणों उन्मुखीकरण विशिष्ट हो सकता है, मैं उन्हें लैंडस्केप ओरिएंटेशन के लिए बनाया है।
• आप प्रत्येक वीडियो फ्रेम के लिए इन उदाहरणों से कोड फोन नहीं करना चाहिए। कुछ कोड केवल एक बार चलाना चाहिए।

Answer 2

यदि आपको केवल 90, 180, या 270 डिग्री रोटेशन (जो आपका मामला प्रतीत होता है) करने की आवश्यकता है तो आप बेहतर Core.flip() का उपयोग करें जो तेज़ी से है। यहां एक विधि के नीचे है जो आपके लिए करता है:

public static Mat rotate(Mat src, double angle) 
{ 
    Mat dst = new Mat(); 
    if(angle == 180 || angle == -180) { 
     Core.flip(src, dst, -1); 
    } else if(angle == 90 || angle == -270) { 
     Core.flip(src.t(), dst, 1); 
    } else if(angle == 270 || angle == -90) { 
     Core.flip(src.t(), dst, 0); 
    } 

    return dst; 
}