精华内容
下载资源
问答
  • opencv学习——左右翻转摄像头 VideoCapture video; video.open(0); 一般我们使用上面的代码打开摄像头后,屏幕里的视频图像不是镜像的,为了实现镜像的效果,可以使用下面的方法,将每一帧的图像左右翻转过来 //...

    opencv学习——左右翻转摄像头

    VideoCapture video;
    video.open(0);
    

    一般我们使用上面的代码打开摄像头后,屏幕里的视频图像不是镜像的,为了实现镜像的效果,可以使用下面的方法,将每一帧的图像左右翻转过来

    //左右翻转图像
    Point2f triangleA[3];
    Point2f triangleB[3];
    
    triangleA[0] = Point2f(0, 0);
    triangleA[1] = Point2f(1, 0);
    triangleA[2] = Point2f(0, 1);
    
    triangleB[0] = Point2f(1, 0);
    triangleB[1] = Point2f(0, 0);
    triangleB[2] = Point2f(1, 1);
    
    Mat affineMat = getAffineTransform(triangleA, triangleB);
    
    warpAffine(beforeFrame,
              frame,
              affineMat,
              beforeFrame.size(),
              INTER_CUBIC,
              BORDER_WRAP);
    

    warpAffin()函数可用于执行仿射变换。使用时需要为该函数提供一个适当的变换矩阵,该矩阵通过getAffineTransform()函数获得。原理如下图所示
    在这里插入图片描述

    展开全文
  • Android 自定义Camera翻转摄像头 前言 Android camera开发中常常会涉及到 翻转摄像头,这篇问篇文章会为大家讲解如何翻转摄像头。 官方api open和open(int arg)的关系 在之前的文章中,我们使用open()成功获取...

    Android 自定义Camera翻转摄像头

    前言

    Android camera开发中常常会涉及到 翻转摄像头,这篇问篇文章会为大家讲解如何翻转摄像头。

    官方api

    在这里插入图片描述
    在这里插入图片描述

    open和open(int arg)的关系

    在之前的文章中,我们使用open()成功获取到了后置摄像头,大家有没有好奇,为什么是后置摄像头而不是前置呢,我们一起看一下open()的实现
    在这里插入图片描述
    解释一下:
    第一步,获取到设备的硬件层的摄像头数量
    在这里插入图片描述
    第二部,创建一个Info容器
    第三步,遍历摄像头
    为info赋值,如果info的id == CAMERA_FACING_BACK则返回Camera对象,否则return null.
    在这里插入图片描述在这里插入图片描述
    open(int org)的实现
    在这里插入图片描述
    可以看到open(int org),省略了open()类的遍历判断,完全信任了调用者的传参。
    思考一下:
    首先,Camera为我们定义了CAMERA_FACING_BACK,CAMERA_FACING_FRONT,后置摄像头和前置摄像头的ID,那么系统为什么要遍历所有摄像头呢,
    这说明了硬件层可能不包含任何摄像头,所以在操作open(int arg)时需要提前判断,硬件层面是否包含前置或者后置摄像头。
    感兴趣的朋友可以看一下华为荣耀i7(单摄像头设备)

    切换摄像头的具体实现

    第一步,定义一个全局变量来记录当前的相机ID

        private int cameraType = Camera.CameraInfo.CAMERA_FACING_BACK;
    

    第二步,定义一个函数用来获取摄像头

    public static Camera getCamera(int cameraType) {
            int numberOfCameras = Camera.getNumberOfCameras();
            Camera.CameraInfo cameraInfo = new Camera.CameraInfo();
            for (int i = 0; i < numberOfCameras; i++) {
                getCameraInfo(i, cameraInfo);
                if (cameraInfo.facing == cameraType) {
                    return Camera.open(i);
                }
            }
            return null;
        }
    

    第二部,在点击按钮的响应

    /**
                     * 判断Camera状态,为空则重新初始化
                     */
                    if(null != mCamera) {
                        /**
                         * 实例化新Camera之前需要释放掉之前实例化的Camera,否则会出现异常,
                         * 但并不是所有的设备都会出现异常
                         */
                        mCamera.stopPreview();
                        mCamera.release();
                        mCamera = null;
                        Camera camera = getCamera(cameraType == Camera.CameraInfo.CAMERA_FACING_BACK
                        ? Camera.CameraInfo.CAMERA_FACING_FRONT
                                :Camera.CameraInfo.CAMERA_FACING_BACK);
                        if(null != camera) {
                            cameraType = cameraType == Camera.CameraInfo.CAMERA_FACING_BACK
                                    ? Camera.CameraInfo.CAMERA_FACING_FRONT
                                    :Camera.CameraInfo.CAMERA_FACING_BACK;
                            mCamera = camera;
    
                            mCamera.setDisplayOrientation(90);
                            setCameraSize(mCamera,
                                    ScreenUtils.getScreenHeight(this)
                                    , ScreenUtils.getScreenWidth(this));
                            try {
                                mCamera.setPreviewDisplay(mPreview.getHolder());
                            } catch (IOException e) {
                                e.printStackTrace();
                            }
                            mCamera.startPreview();
                        } else {
                            initCamera();
                            try {
                                mCamera.setPreviewDisplay(mPreview.getHolder());
                            } catch (IOException e) {
                                e.printStackTrace();
                            }
                            mCamera.startPreview();
                        }
                    } else {
                        initCamera();
                    }
    
    展开全文
  • 因为自拍的时候一般都习惯性的左右翻转摄像头,这样人往左移,图像中的人脸也会往左移,往右同理。 遇到问题,想到两个方案: 方案一:直接软件处理,使用程序将图像翻转过来。这样简单粗暴,但是会更多的耗费FPGA...

    项目中用到的是ov5640摄像头,因为是对着自己的人脸进行拍摄,所以使用别人给的例程里面的驱动程序会有些别扭。因为自拍的时候一般都习惯性的左右翻转摄像头,这样人往左移,图像中的人脸也会往左移,往右同理。

    遇到问题,想到两个方案:

    方案一:直接软件处理,使用程序将图像翻转过来。这样简单粗暴,但是会更多的耗费FPGA资源或者程序处理的时间。所以否决。

    方案二:查找摄像头的相关资料,看能否直接硬件翻转。

    找到《OV5640_自动对焦照相模组应用指南(DVP_接口)__R2.13C》,里面说的很明白:

     可以看出来,只是两个寄存器:0x3820控制上下翻转,0x3821控制左右翻转。但是具体设置什么数值没有直接写出。继续往下看关于这两个寄存器的配置:

    0x3820,给数值0x41就是上下翻转,0x3821,给数值0x07就是左右翻转。再看具体程序驱动中的配置:

    可以看出,寄存器0x3821给的数值是0x01,所以将其改成0x07应该能实现左右翻转。改完之后,发现果真已经可以了。

     

    { 0x3820, 0x43 },  //上下镜像:0x43正常;0x41上下翻转
    { 0x3821, 0x07 },  //左右翻转,0x01正常,0x07上下翻转

     

    展开全文
  • camera前置摄像头左右镜像问题

    万次阅读 2019-03-19 10:00:28
    //重点--->前置摄像头生成图片 左右镜像问题 matrix.postScale(-1, 1); return Bitmap.createBitmap(bmp, 0, 0, bmp.getWidth(), bmp .getHeight(), matrix, true); 镜像上下颠倒,需要设置相机预览的显示...

    需求:使用虹软活体检测时,需要截取检测框中的人脸

    Camera.PreviewCallback中onPreviewFrame(byte[] data, Camera camera)返回的data字节数组不是bitmap 的编码,需要转移一下:
    下面列出几种方法:
    1.有可能发生内存溢出:

           YuvImage image = new YuvImage(bytes, ImageFormat.NV21, width, height, null);
            ByteArrayOutputStream os = new ByteArrayOutputStream(bytes.length);
            if (!image.compressToJpeg(rect, 100, os)) {
                return null;
            }
            byte[] tmp = os.toByteArray();
            Bitmap bmp = BitmapFactory.decodeByteArray(tmp, 0, tmp.length);
    

    2.转码:

     //YCbCr_420_SP-->(解码,yuv420sp转为RGB格式 )
        static public void decodeYUV420SP(int[] rgb, byte[] yuv420sp, int width,
                                          int height) {
            final int frameSize = width * height;
    
            for (int j = 0, yp = 0; j < height; j++) {
                int uvp = frameSize + (j >> 1) * width, u = 0, v = 0;
                for (int i = 0; i < width; i++, yp++) {
                    int y = (0xff & ((int) yuv420sp[yp])) - 16;
                    if (y < 0)
                        y = 0;
                    if ((i & 1) == 0) {
                        v = (0xff & yuv420sp[uvp++]) - 128;
                        u = (0xff & yuv420sp[uvp++]) - 128;
                    }
    
                    int y1192 = 1192 * y;
                    int r = (y1192 + 1634 * v);
                    int g = (y1192 - 833 * v - 400 * u);
                    int b = (y1192 + 2066 * u);
    
                    if (r < 0)
                        r = 0;
                    else if (r > 262143)
                        r = 262143;
                    if (g < 0)
                        g = 0;
                    else if (g > 262143)
                        g = 262143;
                    if (b < 0)
                        b = 0;
                    else if (b > 262143)
                        b = 262143;
    
                    rgb[yp] = 0xff000000 | ((r << 6) & 0xff0000)
                            | ((g >> 2) & 0xff00) | ((b >> 10) & 0xff);
                }
            }
        }
    

    或者

     //图片字节转换
        public static Bitmap rawByteArray2RGBABitmap2(byte[] data, int width, int height) {
    
            int frameSize = width * height;
            int[] rgba = new int[frameSize];
            for (int i = 0; i < height; i++)
                for (int j = 0; j < width; j++) {
                    int y = (0xff & ((int) data[i * width + j]));
                    int u = (0xff & ((int) data[frameSize + (i >> 1) * width + (j & ~1)]));
                    int v = (0xff & ((int) data[frameSize + (i >> 1) * width + (j & ~1) + 1]));
                    y = y < 16 ? 16 : y;
                    int r = Math.round(1.164f * (y - 16) + 1.596f * (v - 128));
                    int g = Math.round(1.164f * (y - 16) - 0.813f * (v - 128) - 0.391f * (u - 128));
                    int b = Math.round(1.164f * (y - 16) + 2.018f * (u - 128));
                    r = r < 0 ? 0 : (r > 255 ? 255 : r);
                    g = g < 0 ? 0 : (g > 255 ? 255 : g);
                    b = b < 0 ? 0 : (b > 255 ? 255 : b);
    
                    rgba[i * width + j] = 0xff000000 + (b << 16) + (g << 8) + r;
                }
    
            Bitmap bmp = Bitmap.createBitmap(width, height, Bitmap.Config.RGB_565);
    
            bmp.setPixels(rgba, 0, width, 0, 0, width, height);
    
            return bmp;
    
        }
    

    3.这种需要sdk 17以上

        public Bitmap convertYUVtoRGB(byte[] yuvData, int width, int height) {
            if (yuvType == null) {
                yuvType = new Type.Builder(rs, Element.U8(rs)).setX(yuvData.length);
                in = Allocation.createTyped(rs, yuvType.create(), Allocation.USAGE_SCRIPT);
    
                Type.Builder rgbaType = new Type.Builder(rs, Element.RGBA_8888(rs)).setX(width).setY(height);
                out = Allocation.createTyped(rs, rgbaType.create(), Allocation.USAGE_SCRIPT);
            }
            in.copyFrom(yuvData);
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
                yuvToRgbIntrinsic.setInput(in);
                yuvToRgbIntrinsic.forEach(out);
                Bitmap bmpout = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);
                out.copyTo(bmpout);
                return bmpout;
            }
            return null;
    
        }
    其中的对象初始化:
       RenderScript rs = RenderScript.create(this);
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
              ScriptIntrinsicYuvToRGB=  yuvToRgbIntrinsic = ScriptIntrinsicYuvToRGB.create(rs, Element.U8_4(rs));
            }
    
    

    现在说正题了:
    前置左右镜像问题:

           final YuvImage image = new YuvImage(bytes, ImageFormat.NV21, width, height, null);
            ByteArrayOutputStream os = new ByteArrayOutputStream(bytes.length);
            if (!image.compressToJpeg(rect, 100, os)) {
                return null;
            }
            byte[] tmp = os.toByteArray();
            Bitmap bmp = BitmapFactory.decodeByteArray(tmp, 0, tmp.length);
            Matrix matrix = new Matrix();
    
            Log.i(TAG, "getBitmapFromByte: displayOrientation-->" + displayOrientation);
            matrix.preRotate(360 - displayOrientation);
            //重点--->前置摄像头生成图片 左右镜像问题
            matrix.postScale(-1, 1);
            return Bitmap.createBitmap(bmp, 0, 0, bmp.getWidth(), bmp
                    .getHeight(), matrix, true);
    

    镜像上下颠倒,需要设置相机预览的显示方向

     public static void setCameraDisplayOrientation(Activity activity,
                                                       int cameraId, android.hardware.Camera camera) {
            try {
                android.hardware.Camera.CameraInfo info = new android.hardware.Camera.CameraInfo();
                android.hardware.Camera.getCameraInfo(cameraId, info);
                int rotation = activity.getWindowManager().getDefaultDisplay().getRotation();
                int degrees = 0;
                switch (rotation) {
                    case Surface.ROTATION_0:
                        degrees = 0;
                        break;
                    case Surface.ROTATION_90:
                        degrees = 90;
                        break;
                    case Surface.ROTATION_180:
                        degrees = 180;
                        break;
                    case Surface.ROTATION_270:
                        degrees = 270;
                        break;
                }
     
                int result;
                if (info.facing == Camera.CameraInfo.CAMERA_FACING_FRONT) {
                    result = (info.orientation + degrees) % 360;
                    result = (360 - result) % 360;  // compensate the mirror
                } else {  // back-facing
                    result = (info.orientation - degrees + 360) % 360;
                }
                camera.setDisplayOrientation(result);
            } catch (Exception e) {
                CommonUtil.printStackTrace(e);
            }
     
        }
    
    

    之后做旋转:

          Matrix matrix = new Matrix();
          matrix.postRotate(CamParaUtil.getCameraDisplayOrientation(StickerMakeActivity.this, mCameraId, mCamera));
          matrix.postScale(scale, isCameraFront() ? -scale : scale);
          Bitmap cropRotateScaled = Bitmap.createBitmap(origin, (int) resultRect.left, (int) resultRect.top, (int) resultRect.width(), (int) resultRect.height(), matrix, true);
    
    

    其中用到的方法:

    public static int getCameraDisplayOrientation(Activity activity,
                                                      int cameraId, android.hardware.Camera camera) {
            int result = 90;
            try {
                android.hardware.Camera.CameraInfo info = new android.hardware.Camera.CameraInfo();
                android.hardware.Camera.getCameraInfo(cameraId, info);
                int rotation = activity.getWindowManager().getDefaultDisplay().getRotation();
                int degrees = 0;
                switch (rotation) {
                    case Surface.ROTATION_0:
                        degrees = 0;
                        break;
                    case Surface.ROTATION_90:
                        degrees = 90;
                        break;
                    case Surface.ROTATION_180:
                        degrees = 180;
                        break;
                    case Surface.ROTATION_270:
                        degrees = 270;
                        break;
                }
     
                if (info.facing == Camera.CameraInfo.CAMERA_FACING_FRONT) {
                    result = (info.orientation + degrees) % 360;
                    result = (360 - result) % 360;  // compensate the mirror
                } else {  // back-facing
                    result = (info.orientation - degrees + 360) % 360;
                }
            } catch (Exception e) {
                CommonUtil.printStackTrace(e);
            }
            return result;
     
        }
    
    

    镜像来自自android开发步步为营之112:关于Camera镜像上下左右颠倒问题的解决办法

    展开全文
  • 之前的项目需要镜像翻转摄像头视频,使用Aforge.Net来处理视频。 一开始考虑直接从Aforge.Net读取没一帧视频图片,然后复制给WPF的Image控件,这种方法基本很卡,所以放弃了。 考虑到Aforge.net 返回的图片是...
  • iOS系统下前置摄像头拍照/录像默认是会沿中间镜像翻转的, 项目用到AVCaptureSession拍照/录像, 需求要使用前置摄像头时不要左右镜像效果, 研究了好久, 谷歌到的都是旋转的, 看到UIImagePicker可以使用transform进行...
  • Qt摄像头翻转

    千次阅读 2014-11-24 18:38:16
    最近在研究Qt摄像头, Qt5.2.0 支持的分辨率只有 640*480
  • 这几天在改前置摄像头,刚才看了csdn上关于此问题的热烈讨论,未得出最终结论。我觉得此问题还是有最优解的。csdn android版主yiyaaixuexi 认为,前置camera要求: 缩略图和照片一致,并且与取景相反。 也就是在照相...
  • Android应用默认开启前置摄像头,预览镜像与人物应保持一致 问题描述: 预览镜像与任务动作相反 原因分析: 设置预览镜像坐标未设置正确导致的。 解决方案: 参考文献:显示摄像头 解决方案:首先绘制自己的...
  • ``` <!DOCTYPE HTML > <title>cam.html</title> ; charset=UTF-8"> ;height:400px'> 拍照</button> <canvas id="canvas" width="600" height="400"></canvas> ...
  • 一、图像上下翻转 importcv2 importnumpy as np # 上下翻转 defRotateClockWise180(img): new_img=np.zeros_like(img) ...h,w=img.shape[0],img.shape[1] ...# 调用usb摄像头 camera_id=0 cap...
  • canvas实现摄像头的画面水平翻转问题 1.video现实反转,直接css: -moz-transform:scaleX(-1); -webkit-transform:scaleX(-1); -o-transform:scaleX(-1); transform:scaleX(-1); /IE/ filter:FlipH; 2.canvas画布的...
  • 本代码模拟实现手势控制摄像头的上下左右移动及缩放,并在实际项目中应用效果良好。
  • 大佬们,今日小弟在实现安卓前置摄像头录制视频时,发现将录制后的视频保存后在本地播放时呈现镜像翻转,具体效果如下: ![图片说明](https://img-ask.csdn.net/upload/201906/25/1561451270_561379.png) 我使用...
  • **opencv + python实现从摄像头获取视频后,以镜像/水平翻转输出 笔者的配置如下: opencv 4.2.0 python 3.7.6 如图,处理前的 摄像头获取并输出的都是翻转后的视频 处理后的 代码如下: import cv2 import numpy...
  • opencv + python实现从摄像头获取视频后,以镜像/水平翻转输出 笔者的配置如下: opencv 4.2.0 python 3.7.6 如图,处理前的 摄像头获取并输出的都是翻转后的视频 处理后的 代码如下: import cv2 import numpy ...
  • 因项目预研需要,采用android camera2进行前置、后置摄像头拍照、拍视频,在用前置摄像头进行拍照时,照片预览是正的,保存本地照片也是正的,只不过照片里的内容进行了左右镜像,现在需要将照片里的内容再左右镜像...
  • 通常,镜面的“左右反”被描述为:你在镜子前用右手写字,而镜子中的你正在用左手写字。为什么镜面成像给人感觉...这两天在调试android前置摄像头,今天基本完成,期间想到了这个问题,昨晚终于搞懂……现在努力把思...
  • MTK Camera广角左右翻转

    2019-09-04 10:57:39
    mtk camera 4:3的预览反向,其他比例正常,发现是camera的预览分辨率没有配置APK设置的分辨率。 MTK android 9.0分辨率... 版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接...
  • 如何选择摄像头

    千次阅读 2015-03-27 10:32:16
    市面上的摄像头有很多种,规格,价格也是千差万别,如何选择一款适应当前应用系统的摄像头是一个很关键的问题。 影响摄像头性能的参数主要有以下几种: 1. 分辨率:一般是说摄像头能支持到的最大图像大小,如640x480...
  • 摘要:许多情况下我们需要用到摄像头获取图像,进而处理图像,这篇博文介绍利用pyqt5、OpenCV实现用电脑上连接的摄像头拍照并保存照片。为了使用和后续开发方便,这里利用pyqt5设计了个相机界面,后面将介绍如何实现...
  • 摄像头相关

    2013-09-28 11:00:34
    摄像头名称 I2C地址 stby gt2005 0x78 0 gc2015
  • opencv旋转摄像头

    2020-05-29 14:54:10
    opencv旋转摄像头打开摄像头顺时针旋转90°顺时针旋转180°顺时针旋转270° 打开摄像头 VideoCapture capture(cameraID); if (!capture.isOpened()) { return S_FALSE; } capture >> frame; imwrite("src.jpg...
  • 摄像头常见参数解释

    千次阅读 2017-10-17 11:34:04
    市面上的摄像头有很多种,规格,价格也是千差万别,如何选择一款适应当前应用系统的摄像头是一个很关键的问题。 影响摄像头性能的参数主要有以下几种: 1. 分辨率:一般是说摄像头能支持到的最大图像大小,如640...
  • 体验旋转摄像头

    2015-12-01 17:42:27
    备忘录 今天体验了N3,小结如下: ...2,机器不知道当前摄像头所处的角度位置。 掰开一定角度再快速翻转,能明显听出马达受阻。估计N3就是直接转个全角度。 慢速翻转不松手,角度到底后,能听到咔咔声一
  • opencv 打开摄像头

    2019-10-21 14:08:31
    VideoCapture capture(0); //打开摄像头 string window_name="video"; namedWindow(window_name,CV_WINDOW_NORMAL); if(!capture.isOpened()) { cout <...
  • 树莓派摄像头测试

    2018-05-28 21:09:00
    打开摄像头预览: # -*- coding: utf-8 -*- from time import sleep from picamera import PiCamera def open_preview(): with PiCamera() as camera: camera.resolution = (320, 240) c...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,140
精华内容 856
关键字:

如何翻转摄像头左右