精华内容
下载资源
问答
  • 文章来自我的博客:打开1、图像的读取:cv2.imread(filename,flags=None)filename : 文件夹的路径flags : 读取模式cv2.IMREAD_COLOR 加载三通道彩色图像,忽略透明度cv2.IMREAD_GRAYSCALE 灰度模式加载图像cv2....

    af287e19e0b9ccf021ca52f924b0f242.png

    文章来自我的博客:打开

    1、图像的读取:

    cv2.imread(filename,flags=None)

    filename : 文件夹的路径

    flags : 读取模式

    cv2.IMREAD_COLOR 加载三通道彩色图像,忽略透明度

    cv2.IMREAD_GRAYSCALE 灰度模式加载图像

    cv2.IMREAD_UNCHANGED 使用alpha通道加载图像,显示图像的透明度和半透明度(4通道)

    阿尔法通道:是指一张图片的透明和半透明度。一个使用32位存储的图片,每8位表示红绿蓝,和阿尔法通道。在这种情况下,就不光可以表示透明还是不透明,阿尔法通道还可以表示256级的半透明度。

    2、图像的显示:

    cv2.imshow(winname,mat)

    winname :图像显示的窗口名

    mat :需要显示的图片的对象名

    等待任意按键:

    cv2.waitKey(delay=None)

    delay : 延时的时间

    当 dalay = 0 :表示 forever 永不退出

    dalay 的单位为: 毫秒

    ord(c ) c:字符 。 转换为 Unicode 值

    7ef192cbc476874f2463ace7628e5635.png

    ESC键的 ASCLL 值为 27

    #图像等待 delay>0: 延时 单位为毫秒 delay<=0: 无限等待键盘输入

    关闭所有窗口:

    cv2.destroyAllWindows()

    关闭指定窗口:

    destroyWindows(wname)

    3、图像的保存:

    cv2.imwrite(filename,img,params=None)

    params:此参数针对特定的图片格式

    对于JPEG,其表示的是图像的质量,用0-100的整数表示,默认为95。 注意,cv2.IMWRITE_JPEG_QUALITY类型为Long,必须转换成int

    PNG,第三个参数表示的是压缩级别。cv2.IMWRITE_PNG_COMPRESSION,从0到9,压缩级别越高,图像尺寸越小。默认级别为3:

    import cv2
    img1 = cv2.imread("first.jpg")
    cv2.imshow("windowsimg1",img1)
    print(chr(27))
    k = cv2.waitKey()
    if k == 27 :
        print("1")
        cv2.destroyAllWindows()
    elif k == ord('s'):
        cv2.imwrite("second.jpg",img1)
        cv2.destroyAllWindows()import cv2
    img1 = cv2.imread("first.jpg")
    cv2.imshow("windowsimg1",img1)
    print(chr(27))
    k = cv2.waitKey()
    if k == 27 :
        print("1")
        cv2.destroyAllWindows()
    elif k == ord('s'):
        cv2.imwrite("second.jpg",img1)
        cv2.destroyAllWindows()

    4、图像通道的分离与合并:

    一般情况下图片通道的排序为:RGB 。 但是在OpenCV中默认的排序为 BGR

    分离通道:

    cv2.split(m,mv=None)

    m:需要分离通道的图像对象

    import cv2
    img = cv2.imread("first.jpg",cv2.IMREAD_UNCHANGED)
    b,g,r = cv2.split(img) #彩色图像三通道,灰度图像单通道
    cv2.imshow("b",b)
    cv2.imshow("g",g)
    cv2.imshow("r",r)
    cv2.waitKey()
    cv2.destroyAllWindows()

    获取图像属性:

    image.shape

    (行数,列数,通道数)

    image.size

    输出图像像素总和

    import cv2
    img = cv2.imread("first.jpg",cv2.IMREAD_UNCHANGED)
    print(img.shape)
    print(img.size)

    生成全0数组:

    np.zeros(shape,dtype=float,order='c')

    shape:数组的属性

    dtype:类型

    cv2.merge(mv,dst=None)

    mv:合并的通道

    import cv2
    import numpy as np
    img = cv2.imread("first.jpg",cv2.IMREAD_UNCHANGED)
    zreo = np.zeros(img.shape[:2],dtype="uint8") #大小与img图像相同的生成二阶全0数组
    #格式为uint8否则imshow不能显示
    b,g,r = cv2.split(img)
    cv2.imshow("blue",cv2.merge([b,zreo,zreo]))
    cv2.imshow("green",cv2.merge([zreo,g,zreo]))
    cv2.imshow("red",cv2.merge([zreo,zreo,r]))
    cv2.waitKey()
    cv2.destroyAllWindows()

    5、ROI感兴趣区域:

    简单来说就是进行图像数组切片,获取感兴趣区域

    import cv2
    img = cv2.imread("first.jpg")
    imgROI = img[123:412,234:879] #设置感兴趣区域
    cv2.imshow("ROI",imgROI)
    cv2.waitKey()
    cv2.destroyAllWindows()

    练习题:

    分别以彩色模式和灰度模型读取一幅图像,分离出彩色图像的RGB通道得到3副图像,然后依次显示出4副图像,显示图像时按s保存图像,图像名称为该图像的颜色,最后合成通道显示彩色图像,按 “q”键关闭后,然后显示你感兴趣的RIO区域,按ESC键关闭。最后输出图像的属性。

    评论出你的答案

    展开全文
  • OpenCv-Mat

    2020-07-18 21:28:07
    MatOpenCv 中用来存储图像信息的 内存对象。Bitmap是Android 提供的图像对象 Mat 相关Api // 加载Mat,第二个参数表示加载图像类型 IMREAD_UNCHANGED=-1,表示不改变加载图像类型,可以包含透明通道 IMREAD_...

    Mat 与Bitmap 区别

    Mat 是OpenCv 中用来存储图像信息的 内存对象。Bitmap是Android 提供的图像对象

    Mat 相关Api

    // 加载Mat,第二个参数表示加载图像类型
    IMREAD_UNCHANGED=-1,表示不改变加载图像类型,可以包含透明通道
    IMREAD_GRAYSCALE=0, 表示加载图像为灰色图像
    IMREAD_COLOR=1,加载图像为彩色图像
    Mat src=Imgcodecs.imread(path,Imgcodesc.IMREAD_COLOR)
    
    int width=src.cols();
    int height=src.rows()
    int dims=src.dims()
    int channels = src.channels()
    int depth=src.depth()
    int type=src.type()
    
    保存文件
    Imgcodes.imwrite(path,src)
    
    //Mat 绘制几何形状与文本
            Mat src=Mat.zeros(500,500, CvType.CV_8UC3);
            //椭圆或者弧长
            Imgproc.ellipse(src,new Point(250,250),new Size(100,50),360,0,
                    0,new Scalar(0,0,255),2,8,0);
    
            //文本
            Imgproc.putText(src,"测试",new Point(20,20), Core.FONT_HERSHEY_PLAIN,1.0,new Scalar(255,0,0),2);
    
            Rect rect = new Rect();
            rect.x=50;
            rect.y=50;
            rect.width=100;
            rect.height=100;
            //矩形
            Imgproc.rectangle(src,rect.tl(),rect.br(),new Scalar(255,0,0),2,8,0);
            //圆形
            Imgproc.circle(src,new Point(400,400),50,new Scalar(0,255,0),2,8,0);
    
            //线
            Imgproc.line(src,new Point(10,10),new Point(490,490),new Scalar(0,255,0),2,8,0);
            Imgproc.line(src,new Point(10,490),new Point(490,10),new Scalar(255,0,0),2,8,0);
    
    

    Bitmap和Mat 互转

    Mat src=Imgcodes.imread(path)
    int width=src.cols();
    int height =src.rows();
    Bitmap bm=Bitmap.createBitmap(width.height,Bitmap.Config.ARGB_8888);
    Mat dst=new Mat();
    Imgproc.cvtColor(src,dst,Imgproc.COLOR_BGR2RGBA);
    Utils.matToBitmap(dst,bm);
    
     Bitmap bitmap = Bitmap.createBitmap(500, 500, Bitmap.Config.ARGB_8888);
            Mat mat = new Mat();
            //bitmap转mat
            Utils.bitmapToMat(bitmap,mat);
            Imgproc.circle(mat,new Point(mat.cols()/2,mat.rows()/2),50,new Scalar(255,0,0,255),2,8,0);
            //mat 转bitmap
            Utils.matToBitmap(mat,bitmap);
            imageView.setImageBitmap(bitmap);
    

    Mat 像素操作

             Bitmap bitmap = BitmapFactory.decodeResource(MainActivity.this.getResources(), R.mipmap.baidu);
            Mat src = new Mat();
            Utils.bitmapToMat(bitmap,src);
            // 从mat中每次读取一个像素点 
    //        byte[] data = new byte[src.channels()];
    //        int b=0,g=0,r=0;
    //        for (int row=0;row<src.rows();row++){
    //            for (int col=0;col<src.cols();col++){
    //                src.get(row,col,data);
    //                b=data[0]&0xff;
    //                g=data[1]&0xff;
    //                r=data[2]&0xff;
    //                b=255-b;
    //                g=255-g;
    //                r=255-r;
    //                data[0]=(byte)b;
    //                data[1]=(byte)g;
    //                data[2]=(byte)r;
    //                src.put(row,col,data);
    //            }
    //        }
    
    
    //        // 每次读取一行像素
    //        byte[] data=new byte[src.channels()*src.cols()];
    //        int b=0,g=0,r=0;
    //        int pv=0;
    //        for (int row=0;row<src.rows();row++){
    //            src.get(row,0,data);
    //            for (int col=0;col<data.length;col++){
    //                pv=data[col]&0xff;
    //                pv=255-pv;
    //                data[col]=(byte)pv;
    //            }
    //            src.put(row,0,data);
    //        }
    //        //一次读取全部像素
    //        int pv=0;
    //        byte[] data=new byte[src.channels()*src.cols()*src.rows()];
    //        src.get(0,0,data);
    //        for (int i=0;i<data.length;i++){
    //            pv=data[i]&0xff;
    //            pv=255-pv;
    //            data[i]=(byte)pv;
    //        }
    //        src.put(0,0,data);
            Utils.matToBitmap(src,bitmap);
            imageView.setImageBitmap(bitmap);
            src.release();
    

    特点

    1. 第一张因为频繁访问jni调用效率低,但是内存需求少
    2. 第二种相对第一张读取速度提高,但是内存需求相对第一种大
    3. 第三章效率处理最高,但是内存消耗也是最大的

    通道分离和合并

    public void channelsAndPixels() {
            Mat src = Imgcodecs.imread(fileUri.getPath());
            if(src.empty()){
                return;
            }
    
            List<Mat> mv = new ArrayList<>();
            Core.split(src, mv);
            for(Mat m : mv) {
                int pv = 0;
                int channels = m.channels();
                int width = m.cols();
                int height = m.rows();
                byte[] data = new byte[channels*width*height];
                m.get(0, 0, data);
                for(int i=0; i<data.length; i++) {
                    pv = data[i]&0xff;
                    pv = 255-pv;
                    data[i] = (byte)pv;
                }
                m.put(0, 0, data);
            }
            Core.merge(mv, src);
    
            Bitmap bm = Bitmap.createBitmap(src.cols(), src.rows(), Bitmap.Config.ARGB_8888);
            Mat dst = new Mat();
            Imgproc.cvtColor(src, dst, Imgproc.COLOR_BGR2RGBA);
            Utils.matToBitmap(dst, bm);
            ImageView iv = (ImageView)this.findViewById(R.id.chapter3_imageView);
            iv.setImageBitmap(bm);
            dst.release();
            src.release();
        }
    

    在这里插入图片描述

    计算均值和标准方差

    meanStdDev(Mat src,MatOfDoubble mean,MatofDouble stddev);
    src:输入Mat图像
    mean:计算各个通道的均值
    stddev:计算各个通道的标准方差
    
    

    二值图像切割

    public void meanAndDev() {
            // 加载图像
            Mat src = Imgcodecs.imread(fileUri.getPath());
            if(src.empty()){
                return;
            }
            // 转为灰度图像
            Mat gray = new Mat();
            Imgproc.cvtColor(src, gray, Imgproc.COLOR_BGR2GRAY);
    
            // 计算均值与标准方差
            MatOfDouble means = new MatOfDouble();
            MatOfDouble stddevs = new MatOfDouble();
            Core.meanStdDev(gray, means, stddevs);
    
            // 显示均值与标准方差
            double[] mean = means.toArray();
            double[] stddev = stddevs.toArray();
            Log.i(TAG, "gray image means : " + mean[0]);
            Log.i(TAG, "gray image stddev : " + stddev[0]);
    
            // 读取像素数组
            int width = gray.cols();
            int height = gray.rows();
            byte[] data = new byte[width*height];
            gray.get(0, 0, data);
            int pv = 0;
    
            // 根据均值,二值分割
            int t = (int)mean[0];
            for(int i=0; i<data.length; i++) {
                pv = data[i]&0xff;
                if(pv > t) {
                    data[i] = (byte)255;
                } else {
                    data[i] = (byte)0;
                }
            }
            gray.put(0, 0, data);
    
            Bitmap bm = Bitmap.createBitmap(gray.cols(), gray.rows(), Bitmap.Config.ARGB_8888);
            Mat dst = new Mat();
            Imgproc.cvtColor(gray, dst, Imgproc.COLOR_GRAY2RGBA);
            Utils.matToBitmap(dst, bm);
            ImageView iv = (ImageView)this.findViewById(R.id.chapter3_imageView);
            iv.setImageBitmap(bm);
            dst.release();
            gray.release();
            src.release();
        }
    
    

    在这里插入图片描述

    创建随机浮点数图像

     public void normAndAbs() {
            // 创建随机浮点数图像
            Mat src = Mat.zeros(400, 400, CvType.CV_32FC3);
            float[] data = new float[400*400*3];
            Random random = new Random();
            for(int i=0; i<data.length; i++) {
                data[i] = (float)random.nextGaussian();
            }
            src.put(0, 0, data);
    
            // 归一化值到0~255之间
            Mat dst = new Mat();
            Core.normalize(src, dst, 0, 255, Core.NORM_MINMAX, -1, new Mat());
    
    
            // 类型转换
            Mat dst8u = new Mat();
            dst.convertTo(dst8u, CvType.CV_8UC3);
    
            // 转换为Bitmap,显示
            Bitmap bm = Bitmap.createBitmap(dst.cols(), dst.rows(), Bitmap.Config.ARGB_8888);
            Mat result = new Mat();
            Imgproc.cvtColor(dst8u, result, Imgproc.COLOR_BGR2RGBA);
            Utils.matToBitmap(result, bm);
    
            // show
            ImageView iv = (ImageView)this.findViewById(R.id.chapter3_imageView);
            iv.setImageBitmap(bm);
        }
    

    在这里插入图片描述

    Mat的加减乘除

    add(Mat src1,Mat src2,Mat dst)
    subtract(Mat src1,Mat src2,Mat dst)
    multiply(Mat src1,Mat src2,Mat dst)
    divide(Mat src1,Mat src2,Mat dst)
    
    src:输入第一个Mat对象
    src2:输入第二个Mat对象
    dst:输出Mat对象
    
    // 图像权重叠加
    addWeighted(Mat src1,double alpha,Mat src2,double beta,double gamma,Mat dst)
    
    src:第一个图像
    alpha:混合第一个Mat所占的比重
    src2:第二个图像
    beta:第二个所占比重
    gamma:混合后是否进行亮度矫正(提示或降低)
    dst:输出叠加
    
    dst=src*alpha+src2*beta+gamma
    
    bitwise_not(Mat src,Mat dst)//取反
    bitwise_and(Mat src1,Mat src2,Mat dst)//与操作
    bitwise_or(Mat src1,Mat src2,Mat dst)//或操作
    bitwise_xor(Mat src1,Mat src2,Mat dst)异或操作
    
    converScaleAbs(Mat src,Mat dst)//线性绝对值缩放变换
    //归一化
    normalize(Mat src,Mat dst,double alpha,double beta, int norm_type ,int dttype,Mat mask)
    beta:归一化到指定范围的高值
    alpha:归一化到指定范围的低值
    dytpe:表示输出的dst图像类型,默认-1,表示类型和src相同
    mask,表示遮罩层,默认Mat()
    

    案例

     public void logicOperator() {
            Mat src1 = Mat.zeros(400, 400, CvType.CV_8UC3);
            Mat src2 = new Mat(400, 400, CvType.CV_8UC3);
            src2.setTo(new Scalar(255, 255, 255));
    
            Rect rect = new Rect();
            rect.x=100;
            rect.y=100;
            rect.width = 200;
            rect.height = 200;
            Imgproc.rectangle(src1, rect.tl(), rect.br(), new Scalar(0, 255, 0), -1);
    
            rect.x=10;
            rect.y=10;
            Imgproc.rectangle(src2, rect.tl(), rect.br(), new Scalar(255, 255, 0), -1);
    
            Mat dst1 = new Mat();
            Mat dst2 = new Mat();
            Mat dst3 = new Mat();
            Core.bitwise_and(src1, src2, dst1);
            Core.bitwise_or(src1, src2, dst2);
            Core.bitwise_xor(src1, src2, dst3);
    
            Mat dst = Mat.zeros(400, 1200, CvType.CV_8UC3);
            rect.x=0;
            rect.y=0;
            rect.width=400;
            rect.height=400;
            dst1.copyTo(dst.submat(rect));
            rect.x=400;
            dst2.copyTo(dst.submat(rect));
            rect.x=800;
            dst3.copyTo(dst.submat(rect));
            dst1.release();
            dst2.release();
            dst3.release();
    
            // 转换为Bitmap,显示
            Bitmap bm = Bitmap.createBitmap(dst.cols(), dst.rows(), Bitmap.Config.ARGB_8888);
            Mat result = new Mat();
            Imgproc.cvtColor(dst, result, Imgproc.COLOR_BGR2RGBA);
            Utils.matToBitmap(result, bm);
    
            // show
            ImageView iv = (ImageView)this.findViewById(R.id.chapter3_imageView);
            iv.setImageBitmap(bm);
    
        }
    
    

    在这里插入图片描述

    public void matArithmeticDemo() {
            // 输入图像src1
            Mat src = Imgcodecs.imread(fileUri.getPath());
            if(src.empty()){
                return;
            }
            // 输入图像src2
            Mat moon = Mat.zeros(src.rows(), src.cols(), src.type());
            int cx = src.cols() - 60;
            int cy = 60;
            Imgproc.circle(moon, new Point(cx, cy), 50, new Scalar(90,95,234), -1, 8, 0);
    
            // 加法运算
            Mat dst = new Mat();
            Core.add(src, moon, dst);
    
            Bitmap bm = Bitmap.createBitmap(src.cols(), src.rows(), Bitmap.Config.ARGB_8888);
            Mat result = new Mat();
            Imgproc.cvtColor(dst, result, Imgproc.COLOR_BGR2RGBA);
            Utils.matToBitmap(result, bm);
            ImageView iv = (ImageView)this.findViewById(R.id.chapter3_imageView);
            iv.setImageBitmap(bm);
        }
    

    在这里插入图片描述

    在算术运算中,src1和src2 他们的大小和类型必须一致,默认的输出图像类型也一致

     Bitmap bitmap = BitmapFactory.decodeResource(MainActivity.this.getResources(), R.mipmap.timg);
            Mat src = new Mat();
            Utils.bitmapToMat(bitmap, src);
            Mat moon =Mat.zeros(src.rows(),src.cols(),src.type());
            int cx=src.cols()-60;
            int cy=60;
            Imgproc.circle(moon,new Point(cx,cy),50,new Scalar(90,95,234),-1,8,0);
            Mat dst=new Mat();
            Core.add(src,moon,dst);
            Utils.matToBitmap(dst, bitmap);
            imageView.setImageBitmap(bitmap);
            src.release();
    

    提高图像对比度和亮度

    1. 对于RGB色彩图像,亮度越高,像素点对应的RGB值越大越接近255,反正越低
    2. 对比度主要用来描述图像颜色与亮度差异感知,对比度越大,图像对每个像素与周围的差异性越大,整个图像细节越显著
      public void adjustBrightAndContrast(int b, float c) {
            // 输入图像src1
            Mat src = Imgcodecs.imread(fileUri.getPath());
            if(src.empty()){
                return;
            }
    
            // 调整亮度
            Mat dst1 = new Mat();
            Core.add(src, new Scalar(b, b, b), dst1);
    
            // 调整对比度
            Mat dst2 = new Mat();
            Core.multiply(dst1, new Scalar(c, c, c), dst2);
    
            // 转换为Bitmap,显示
            Bitmap bm = Bitmap.createBitmap(src.cols(), src.rows(), Bitmap.Config.ARGB_8888);
            Mat result = new Mat();
            Imgproc.cvtColor(dst2, result, Imgproc.COLOR_BGR2RGBA);
            Utils.matToBitmap(result, bm);
    
            // show
            ImageView iv = (ImageView)this.findViewById(R.id.chapter3_imageView);
            iv.setImageBitmap(bm);
        }
    

    在这里插入图片描述

    原文:OpenCv Android 开发实战

    展开全文
  • OpenCVopencv处理透明图片

    千次阅读 2017-01-19 16:16:53
    OpenCV处理透明图片,主要是考虑图片的叠加。 //主函数操作 Mat dest,srcAlpha; //-1表示读取带有alpha通道的图片 srcAlpha = imread("1.png",-1); dest= imread("2.png"); //(0,0)设置对...

     

     

    OpenCV处理透明图片,主要是考虑图片的叠加。

    //主函数操作
    Mat dest,srcAlpha;
    
    //-1表示读取带有alpha通道的图片
    srcAlpha = imread("1.png",-1);
    dest= imread("2.png");
    
    //(0,0)设置对srcAlpha的叠加
    mapToMat(srcAlpha, dest, 0, 0);
    
    void mapToMat(const cv::Mat &srcAlpha, cv::Mat &dest, int x, int y)
    {
        int nc = 3;
        int alpha = 0;
    
        for (int j = 0; j < srcAlpha.rows; j++)
        {
            for (int i = 0; i < srcAlpha.cols*3; i += 3)
            {
                // 目的图片为三通道,所以是三通道的遍历、四通道的源图
                // i/3*4表示第i/3个像素的位置 
                // i/3*4 + 3表示本像素的alpha通道的值
                alpha = srcAlpha.ptr<uchar>(j)[i / 3*4 + 3];
                //alpha = 255-alpha;
                if(alpha != 0) //4通道图像的alpha判断
                {
                    for (int k = 0; k < 3; k++)
                    {
                        // if (src1.ptr<uchar>(j)[i / nc*nc + k] != 0)
                        if( (j+y < dest.rows) && (j+y>=0) &&
                            ((i+x*3) / 3*3 + k < dest.cols*3) && ((i+x*3) / 3*3 + k >= 0) &&
                            (i/nc*4 + k < srcAlpha.cols*4) && (i/nc*4 + k >=0) )
                        {
                            dest.ptr<uchar>(j+y)[(i+x*nc) / nc*nc + k] = srcAlpha.ptr<uchar>(j)[(i) / nc*4 + k];
                        }
                    }
                }
            }
        }
    }

     

    合并两张图片

     

    ///
    			Mat img_left = imread("02.jpg");
    			Mat img_right = imread("testface.png");
    
    			Size size(img_left.cols + img_right.cols, MAX(img_left.rows, img_right.rows));
    
    			Mat img_merge;
    			Mat outImg_left, outImg_right;
    
    			img_merge.create(size, CV_8UC3);
    			img_merge = Scalar::all(0);
    			outImg_left = img_merge(Rect(0, 0, img_left.cols, img_left.rows));
    			outImg_right = img_merge(Rect(img_left.cols, 0, img_right.cols, img_right.rows));
    
    
    			img_left.copyTo(outImg_left);
    			img_right.copyTo(outImg_right);
    			imshow("merge", img_merge);

    Taily老段的微信公众号,欢迎交流学习

    https://blog.csdn.net/taily_duan/article/details/81214815


     

     

     

    展开全文
  • opencv处理透明图片

    万次阅读 2015-12-23 18:39:40
    opencv处理透明图片opencv处理透明图片,主要是考虑图片的叠加。//主函数操作 ... Mat dest,srcAlpha;// imread后一个参数为-1表示读取带有alpha通道的图片 srcAlpha = imread("C:\\Users\\Administrator\\Desktop\\...

    opencv处理透明图片

    本文由 @lonelyrains出品,转载请注明出处。
    文章链接: http://blog.csdn.net/lonelyrains/article/details/50389034

    opencv处理透明图片,主要是考虑图片的叠加。

    //主函数操作
    ...
    Mat dest,srcAlpha;
    
    // imread后一个参数为-1表示读取带有alpha通道的图片
    srcAlpha = imread("C:\\Users\\Administrator\\Desktop\\1.png",-1);
    dest= imread("C:\\Users\\Administrator\\Desktop\\1.png");
    
    // 表示从dest的第(50,100)设置对srcAlpha的叠加
    mapToMat(srcAlpha, dest, 50, 100);
    ...
    
    void mapToMat(const cv::Mat &srcAlpha, cv::Mat &dest, int x, int y)
    {
        int nc = 3;
        int alpha = 0;
    
        for (int j = 0; j < srcAlpha.rows; j++)
        {
            for (int i = 0; i < srcAlpha.cols*3; i += 3)
            {
                // 目的图片为三通道,所以是三通道的遍历、四通道的源图
                // i/3*4表示第i/3个像素的位置 
                // i/3*4 + 3表示本像素的alpha通道的值
                alpha = srcAlpha.ptr<uchar>(j)[i / 3*4 + 3];
                //alpha = 255-alpha;
                if(alpha != 0) //4通道图像的alpha判断
                {
                    for (int k = 0; k < 3; k++)
                    {
                        // if (src1.ptr<uchar>(j)[i / nc*nc + k] != 0)
                        if( (j+y < dest.rows) && (j+y>=0) &&
                            ((i+x*3) / 3*3 + k < dest.cols*3) && ((i+x*3) / 3*3 + k >= 0) &&
                            (i/nc*4 + k < srcAlpha.cols*4) && (i/nc*4 + k >=0) )
                        {
                            dest.ptr<uchar>(j+y)[(i+x*nc) / nc*nc + k] = srcAlpha.ptr<uchar>(j)[(i) / nc*4 + k];
                        }
                    }
                }
            }
        }
    }

    处理前
    这里写图片描述

    处理后这里写图片描述

    本代码段所在的完整工程见另一篇博客 大家一起过圣诞

    展开全文
  • 1 图片 1.1 读取图片使用函数:cv2.imread(filename,flags)读取图像。...图像的透明度会被忽略,这是默认参数当flags=0时,cv2.IMREAD_GRAYSCALE:以灰度模式读入图像当flags<0时,cv2.IMREAD_...
  • 1.OPENCV对于有阿尔法通道的透明背景图片的读取和图片叠加 https://blog.csdn.net/wi162yyxq/article/details/53259404 “混合算法目前在游戏上常用到的算法是AlphaBlend。计算公式如下假设一幅图象是A,另一幅...
  • OpenCV中的Mat对象

    2020-03-17 21:41:17
    MatOpenCV中用来存储图像信息的内存对象,可以理解为一个包含所有强度值的像素点矩阵,另外包含图像的宽、高、类型、纬度、大小、深度等信息。 通道常见的通道有1、3、4 其中4包含透明通道图像深度每一个像素的...
  • opencv3|生成透明图像

    2021-03-16 10:35:49
    opencv2/opencv.hpp> //头文件 #include <opencv2/highgui/highgui.hpp> #include <opencv2/imgproc/imgproc.hpp> using namespace cv; //包含cv命名空间 void createAlphaMat(Mat &mat) { for...
  • opencv透明PNG图片填充为白色背景

    千次阅读 2018-05-30 09:59:23
    本篇博客介绍使用两种方式来实现将透明PNG图片填充为白色背景。 第一种方法: 代码: #include<opencv2/imgproc/imgproc.hpp> #include<opencv2/highgui/highgui.hpp> using namespace cv; int i...
  • 在 Android OpenCv中给我们返回的 type 直接是CV_8UC4 但是,在 C++ 中返回的是 16 等这些整型,所以,我找了个对照表 表头的 C1, C2, C3, C4 指的是通道(Channel)数,比如灰度图像只有 1 个通道,是 C1;JPEG格式...
  • ForegroundImg = new Mat(backgroundImg.Size(), MatType.CV_8UC4, new Scalar(0,0,0,255)); 初始化,4通道的 Mat 图。CV_8UC4 意思是: 每个像素点 ...Scalar(B,G,R,A) 其中 A 为透明度。255为不透明,0为全透。 ...
  • opencv做拍照 可是抓取图像之后不能转为bitmap在imageview中显示 Utils.matToBitmap(mTmp,bit); 一直卡在这一句 跪求大大们指点 不知道代码有没有用 贴上来再说 顺便求问一下我的cameraview旋转之后没有全屏 ...
  • Opencv--Mat笔记

    2017-07-23 19:53:02
    一:Mat Image(20,10,CV_8UC3,Scalar(0,255,0)); //1.创建20行10列的矩阵 //2.CV_8UC3 8表示8位 UC表示unsiged char类型 3表示3通道//注:若为1通道则为灰度值 //3.Scalar(0,255,0) 表示B,G,R对应数值//注Scalar是...
  • 图像有若干个通道,灰度图像只有一个通道,而彩色具有红,绿,蓝组成,但是OpenCv以逆序的方式来存储三个分量,还可以使用第四个透明度(alpha),可以使用img.channels()获取图像通道个数。 使用若干个位存储一副...
  • OpenCV里,正常是读取图像和写入图像默认都是忽略透明通道的,如果想要读取原图像中的透明通道,则在使用imread()函数时,后面的参数要使用CV_LOAD_IMAGE_UNCHANGED参数. int main() { Mat src = imread("C:\\...
  • opencv 实现PNG的透明背景

    千次阅读 2017-12-08 13:08:36
    转自:http://www.opencv.org.cn/forum.php?mod=viewthread&tid=32871 void overlayImage(const cv::Mat &background, const cv::Mat &foreground,  cv::Mat &output, cv::Point2i location) {  background....
  • using OpenCvSharp; Mat outputImage = new Mat(2000, 2000, MatType.CV_8UC4,new Scalar(200,100,100,200)); Cv2.ImShow("img", outputImage); Cv2.WaitKey(0); outputImage.ImWrite("haha.png"); Mat(width,...
  • Opencv将.jpg背景透明

    千次阅读 2018-07-06 11:11:10
    直接代码,可用 #include&...opencv.hpp&gt; using namespace cv; using namespace std; Mat createAlpha(cv::Mat&amp; src) { cv::Mat alpha = cv::Mat::zeros(src.rows, src.cols, CV_8UC1...
  • 题目:在opencv中生成透明图形的方法 程序: #include #include #include using namespace cv; using namespace std; // 描述:创建带alpha通道的Mat void createAlphaMat(Mat &mat) { for (int i = 0; i < mat....
  • OpenCV经常用到的几个Mat的属性,但是每次用到都要查一下,今天直接弄清楚些。 首先要明白几个计算机基础的基本概念: Bit意为“位”或“比特”,是计算机运算的基础,属于二进制的范筹;   Byte意为“字节”,...
  • 形态学-腐蚀操作和膨胀操作:腐蚀操作和膨胀操作类似于一个卷积过程,假设有图像矩阵A以及结构元素B(B本质上就是一个Mat实例,B的形状和尺寸没有限制),B依次在矩阵A上移动,对于腐蚀操作来说,使用每个位置上B所...
  • ubuntu几种编译opencv方式 CMake与Make最简单直接的区别 图像数据类型 CV_[bit][U/S/F]C[channels] bit:位数 U|S|F:无符号整形|有符号整形|float 浮点类型 C:图像通道数,1通道为灰度 2通道为RGB555和RGB565 3通道...
  • 环境: win + opencv4.2 + visual studio 2017 先看效果图,旋转后四个角多余部分为透明状态: 方法1: 计算旋转后的图片的宽高,然后遍历原图像素点拷贝到旋转后的图相应位置。注意:imread的最后一个参数IMREAD_...
  • #include<opencv2> using namespace cv; //PNG透明图片叠加到视频 int main() { Mat frame; VideoCapture capture; capture.open(0); if(!capture.isOpened()) { printf("can not open the camear......\n"); ...
  • opencv3/C++视频中叠加透明图片

    千次阅读 2018-01-02 21:53:48
    大致思路:获取摄像头画面后,通过在图像上循环叠加一组背景...#include<opencv2/opencv.hpp> using namespace cv;//PNG透明图片叠加到视频 int main() { Mat frame; VideoCapture capture; capture.open(0); if(!c
  • PNG格式的图像是有透明通道,用PS打开的时候,透明的地方是没有像素的,可以的下面在ps里面显示的效果: 黑色背景: 白色背景: 透明背景: 把指定颜色变成透明 代码: void toPng(cv::Mat &src, cv::Mat &...
  • Mat src = imread("1.jpg"); Mat bgra; cvtColor(src, bgra, COLOR_BGR2BGRA); for (size_t i = 0; i < src.rows; i++) { for (size_t j = 0; j < src.cols; j++) { if (src.at<Vec3b>(i, j...
  • opencv实现png图片叠加边缘透明问题

    千次阅读 2018-10-26 15:03:27
    原图: png图: 结果: 实现代码如下: void main() { cv::Mat srcImg=cv::imread("E://srcImg.jpg"); cv::namedWindow("srcImg"); cv::imshow("... cv::Mat logo=cv:...
  • Mat对象MatOpenCV中用来存储图像信息的内存对象。Mat对象存储图片的像素信息,以及宽、高、类型、维度、大小、深度等属性。比如下面这张26*24 三通道图片,实际的像素存储内容如下对应的部分信息为26x24x3 uint8,...
  • OPENCV对于有alpha通道的透明背景图片的读取和图片叠加 Mat inimg = imread("dog.png", CV_LOAD_IMAGE_UNCHANGED); // 读取透明通道 // 输出RGBA数值 cout (0,0)[0] (0,0)[1] (0,0)[2] (0,0)[3]

空空如也

空空如也

1 2 3 4
收藏数 62
精华内容 24
关键字:

matopencv透明