簡體   English   中英

如何在 Android 應用程序中使用 OpenCV 在人像模式下打開相機

[英]How to open Camera in Portrait Mode using OpenCV in Android Application

我正在使用OpveCV 2.4.7 庫當我在 Android 應用程序中使用OpenCV來打開相機時,它會以橫向模式顯示相機。 我嘗試將 Activity Orientation 設置為縱向模式,但仍然沒有以全屏方式顯示相機,他們是否可以使用 OpenCV 庫在 Android 中以縱向模式打開相機

目前我正在使用 OpvenCV 庫在 android 中獲得以下屏幕默認值

這是Android中活動橫向模式下默認相機視圖的屏幕截圖

我需要人像模式下的全屏相機視圖,但我得到了這個

這是Android中活動縱向模式下默認相機視圖的屏幕截圖

我嘗試過矩陣轉換,但我需要設置本機相機參數,我使用 OpenCV 打開相機,所以我無法直接訪問相機。 我使用了以下代碼

    mOpenCvCameraView=(CameraBridgeViewBase) findViewById(R.id.image_manipulations_activity_surface_view);
    mOpenCvCameraView.setCvCameraViewListener(this);

我認為這是不可能的,因為 openCV deos 不為您提供直接的相機控制,您需要修改opven CV 庫類CameraBridgeViewBase

你可以這樣做。 創建一個 JavaCamResView 類,它擴展了 OPENCV 的 JavaCameraView。 你得到相機控制。 導入 java.lang.reflect.InvocationTargetException; 導入 java.lang.reflect.Method; 導入 java.util.List;

            import org.opencv.android.JavaCameraView;
            import org.opencv.core.Size;


            import android.content.Context;
            import android.hardware.Camera;
            import android.util.AttributeSet;
            import android.util.Log;
            import android.view.MenuItem;
            import android.widget.Toast;

            public class JavaCamResView extends JavaCameraView {

                public JavaCamResView(Context context, AttributeSet attrs) {
                    super(context, attrs);

                }

                public List<Camera.Size> getResolutionList() {
                    return  mCamera.getParameters().getSupportedPreviewSizes();
                }

                public void setResolution(Camera.Size resolution) {
                    disconnectCamera();
                    connectCamera((int)resolution.width, (int)resolution.height);
                }

                public void setFocusMode (Context item, int type){

                    Camera.Parameters params = mCamera.getParameters();

                    List<String> FocusModes = params.getSupportedFocusModes();

                    switch (type){
                        case 0:
                            if (FocusModes.contains(Camera.Parameters.FOCUS_MODE_AUTO))
                                params.setFocusMode(Camera.Parameters.FOCUS_MODE_AUTO);
                            else
                                Toast.makeText(item, "Auto Mode not supported", Toast.LENGTH_SHORT).show();
                            break;
                        case 1:
                            if (FocusModes.contains(Camera.Parameters.FOCUS_MODE_CONTINUOUS_VIDEO))
                                params.setFocusMode(Camera.Parameters.FOCUS_MODE_CONTINUOUS_VIDEO);
                            else
                                Toast.makeText(item, "Continuous Mode not supported", Toast.LENGTH_SHORT).show();
                            break;
                        case 2:
                            if (FocusModes.contains(Camera.Parameters.FOCUS_MODE_EDOF))
                                params.setFocusMode(Camera.Parameters.FOCUS_MODE_EDOF);
                            else
                                Toast.makeText(item, "EDOF Mode not supported", Toast.LENGTH_SHORT).show();
                            break;
                        case 3:
                            if (FocusModes.contains(Camera.Parameters.FOCUS_MODE_FIXED))
                                params.setFocusMode(Camera.Parameters.FOCUS_MODE_FIXED);
                            else
                                Toast.makeText(item, "Fixed Mode not supported", Toast.LENGTH_SHORT).show();
                            break;
                        case 4:
                            if (FocusModes.contains(Camera.Parameters.FOCUS_MODE_INFINITY))
                                params.setFocusMode(Camera.Parameters.FOCUS_MODE_INFINITY);
                            else
                                Toast.makeText(item, "Infinity Mode not supported", Toast.LENGTH_SHORT).show();
                            break;
                        case 5:
                            if (FocusModes.contains(Camera.Parameters.FOCUS_MODE_MACRO))
                                params.setFocusMode(Camera.Parameters.FOCUS_MODE_MACRO);
                            else
                                Toast.makeText(item, "Macro Mode not supported", Toast.LENGTH_SHORT).show();
                            break;
                    }

                    mCamera.setParameters(params);
                }

                public void setFlashMode (Context item, int type){

                    Camera.Parameters params = mCamera.getParameters();
                    List<String> FlashModes = params.getSupportedFlashModes();

                    switch (type){
                        case 0:
                            if (FlashModes.contains(Camera.Parameters.FLASH_MODE_AUTO))
                                params.setFlashMode(Camera.Parameters.FLASH_MODE_AUTO);
                            else
                                Toast.makeText(item, "Auto Mode not supported", Toast.LENGTH_SHORT).show();
                            break;
                        case 1:
                            if (FlashModes.contains(Camera.Parameters.FLASH_MODE_OFF))
                                params.setFlashMode(Camera.Parameters.FLASH_MODE_OFF);
                            else
                                Toast.makeText(item, "Off Mode not supported", Toast.LENGTH_SHORT).show();
                            break;
                        case 2:
                            if (FlashModes.contains(Camera.Parameters.FLASH_MODE_ON))
                                params.setFlashMode(Camera.Parameters.FLASH_MODE_ON);
                            else
                                Toast.makeText(item, "On Mode not supported", Toast.LENGTH_SHORT).show();
                            break;
                        case 3:
                            if (FlashModes.contains(Camera.Parameters.FLASH_MODE_RED_EYE))
                                params.setFlashMode(Camera.Parameters.FLASH_MODE_RED_EYE);
                            else
                                Toast.makeText(item, "Red Eye Mode not supported", Toast.LENGTH_SHORT).show();
                            break;
                        case 4:
                            if (FlashModes.contains(Camera.Parameters.FLASH_MODE_TORCH))
                                params.setFlashMode(Camera.Parameters.FLASH_MODE_TORCH);
                            else
                                Toast.makeText(item, "Torch Mode not supported", Toast.LENGTH_SHORT).show();
                            break;
                    }

                    mCamera.setParameters(params);
                }

                public Camera.Size getResolution() {

                    Camera.Parameters params = mCamera.getParameters();

                    Camera.Size s = params.getPreviewSize();
                    return s;
                }

                public void zoomIn()
                {

                    Camera.Parameters params = mCamera.getParameters();
                    if (params.isZoomSupported()) {
                        final int maxZoomLevel = params.getMaxZoom();
                        int currentZoomLevel = params.getZoom();
                        Log.i("max ZOOM ", "is " + maxZoomLevel);
                        Log.i("current ZOOM ", "is " + currentZoomLevel);

                        if(currentZoomLevel < maxZoomLevel){
                            currentZoomLevel++;
                            params.setZoom(currentZoomLevel);
                            mCamera.setParameters(params);

                        }

                    }
                    else
                    {
                        Log.i("ZOOM " , "NOT Supported");

                    }

                }

                public int getExposure()
                {
                    Camera.Parameters params = mCamera.getParameters();
                    return params.getExposureCompensation();
                }
                public int getMinExposure()
                {
                    Camera.Parameters params = mCamera.getParameters();
                    return params.getMinExposureCompensation();
                }
                public int getMaxExposure()
                {
                    Camera.Parameters params = mCamera.getParameters();
                    return params.getMaxExposureCompensation();
                }
                public void setExposure(int exposure)
                {
                        Camera.Parameters params = mCamera.getParameters();
                        params.setExposureCompensation(exposure);
                        mCamera.setParameters(params);

                    }

                public void setZoom(int zoom_value)
                {

                    Camera.Parameters params = mCamera.getParameters();
                    if (params.isZoomSupported()) {
                        final int maxZoomLevel = params.getMaxZoom();
                        int currentZoomLevel = params.getZoom();


                      //  Log.i("CAMERA_SETTING", "Exposure setting = " + params.get("exposure"));
                        Log.i("CAMERA_SETTING", "Current Exposure Compansation = " + params.getExposureCompensation());
                        Log.i("CAMERA_SETTING", "min Exposure Compansation = " + params.getMinExposureCompensation());
                        Log.i("CAMERA_SETTING", "Max Exposure Compansation = " + params.getMaxExposureCompensation());
                        Log.i("CAMERA_SETTING", "White Balance setting = " + params.get("whitebalance"));
                        Log.i("CAMERA_SETTING", "Supported White Balance Modes:" + params.get("whitebalance-values"));
                        if(zoom_value < maxZoomLevel){
                            params.setZoom(zoom_value);
                            mCamera.setParameters(params);

                        }

                    }
                    else
                    {
                        Log.i("ZOOM " , "NOT Supported");

                    }

                }
                public void zoomOut()
                {

                    Camera.Parameters params = mCamera.getParameters();
                    if (params.isZoomSupported()) {

                        int currentZoomLevel = params.getZoom();
                        Log.i("current ZOOM ", "is " + currentZoomLevel);

                        if(currentZoomLevel > 0 ){
                            currentZoomLevel--;
                            params.setZoom(currentZoomLevel);
                            mCamera.setParameters(params);

                        }

                    }
                    else
                    {
                        Log.i("ZOOM " , "NOT Supported");

                    }

                }

                public void getPictureSize()
                {
                    Camera.Parameters params = mCamera.getParameters();
                    List<Camera.Size> sizes = params.getSupportedPreviewSizes();
                    Camera.Size mSize;
                    for (Camera.Size size : sizes) {
                        Log.i("CAMERA_SIZE", "Available resolution: "+size.width+" "+size.height);
                        mSize = size;
                    }
                    params.setPictureSize(1280 , 768);
                    mCamera.setParameters(params);
                }

                public void getOptimalPreviewSize( int w, int h) {
                    final double ASPECT_TOLERANCE = 0.1;
                    double targetRatio=(double)h / w;

                    Camera.Parameters params = mCamera.getParameters();
                    List<Camera.Size> sizes = params.getSupportedPreviewSizes();

                    if (sizes == null) return;

                    Camera.Size optimalSize = null;
                    double minDiff = Double.MAX_VALUE;

                    int targetHeight = h;

                    for (Camera.Size size : sizes) {
                        double ratio = (double) size.width / size.height;
                        if (Math.abs(ratio - targetRatio) > ASPECT_TOLERANCE) continue;
                        if (Math.abs(size.height - targetHeight) < minDiff) {
                            optimalSize = size;
                            minDiff = Math.abs(size.height - targetHeight);
                        }
                    }

                    if (optimalSize == null) {
                        minDiff = Double.MAX_VALUE;
                        for (Camera.Size size : sizes) {
                            if (Math.abs(size.height - targetHeight) < minDiff) {
                                optimalSize = size;
                                minDiff = Math.abs(size.height - targetHeight);
                            }
                        }
                    }
                    Log.i("CAMERA_SIZE", "Optimal Size: "+optimalSize.width+" "+optimalSize.height);
                }

                public void changeOrientation() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
                    Method rotateMethod;
                    rotateMethod = android.hardware.Camera.class.getMethod("setDisplayOrientation", int.class);
                    rotateMethod.invoke(mCamera, 90);
                }




            }

在您的公共 Mat onCameraFrame(CvCameraViewFrame inputFrame) { } 添加以下幾行:

   // 3 statements to rotate camera
    Mat rotImage = Imgproc.getRotationMatrix2D(new Point(mRgba.cols() / 2,
            mRgba.rows() / 2), 270, 1.0);
    Imgproc.warpAffine(mRgba, mRgba, rotImage, mRgba.size());
    Imgproc.warpAffine(mGray, mGray, rotImage, mRgba.size());

暫無
暫無

聲明:本站的技術帖子網頁,遵循CC BY-SA 4.0協議,如果您需要轉載,請注明本站網址或者原文地址。任何問題請咨詢:yoyou2525@163.com.

 
粵ICP備18138465號  © 2020-2024 STACKOOM.COM