Ruota VideoCapture in OpenCV su Android

Question

Come ruotare la fotocamera quando si utilizza classe VideoCapture su OpenCV? (Rilevamento dei volti del campione su Android). che sto ruotando la tela con:

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

ma l'immagine da fotocamera non gira: Rilevam.viso non funzionano.

La fotocamera riceve il flusso dal seguente:

protected Bitmap processFrame(VideoCapture capture) { 

    capture.retrieve(mRgba, Highgui.CV_CAP_ANDROID_COLOR_FRAME_RGBA); 

    capture.retrieve(mGray, 
    Highgui.CV_CAP_ANDROID_GREY_FRAME); 

UPDATE Ho fatto la seguente:

@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); 

Ma è non funzionano. Quando eseguo il programma con orientamento ritratto (sul dispositivo Android) - Programma di non iniziare quando ho eseguito il rogramma in orientamento orizzontale - lavoro programma, ma quando ho la rotazione del dispositivo, programma di lavoro, ma l'immagine in mostra dont rotazione

Answer 1

La tua domanda è principalmente una duplicate of this, tranne per il fatto che stai cercando la versione per Android. E 'abbastanza simile, ma qui è, 90 ° di rotazione può essere ottenuto recepimento e quindi è necessario capovolgere l'immagine:

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

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

Per le altre rotazioni è possibile utilizzare 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); 

EDIT - più seguono esempi completi:

/** 
    * 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); 
    } 

Nota:

• Questi esempi potrebbero essere specifici dell'orientamento, li ho creati per l'orientamento orizzontale.
• Non si dovrebbe chiamare il codice da questi esempi per ogni frame video. Alcuni del codice dovrebbero essere eseguiti una sola volta.

Answer 2

Se hai solo bisogno di fare 90, 180 o 270 gradi di rotazione (che sembra essere il tuo caso) è meglio utilizzare Core.flip() che è più veloce. Qui di seguito un metodo che fa al caso tuo:

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