文章来自我的博客：打开
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 值
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键关闭。最后输出图像的属性。
评论出你的答案

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

特点

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

通道分离和合并
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();

提高图像对比度和亮度

对于RGB色彩图像，亮度越高，像素点对应的RGB值越大越接近255，反正越低
对比度主要用来描述图像颜色与亮度差异感知，对比度越大，图像对每个像素与周围的差异性越大，整个图像细节越显著

  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 开发实战

 

 

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处理透明图片

本文由 @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];
                    }
                }
            }
        }
    }
}

处理前 


处理后

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