Java 如何高效使用OpenCV_java opencv

Java中使用OpenCV图像处理库，是通过JNI + 动态链接库的方式进行库函数调用的。因此会产生多次native函数调用，而JNI调用会产生额外的性能开销，这将导致图像处理的速度急剧减慢。下面我将演示几个常见的示例：

一、遍历获取图像所有像素的RGB值

错误示例:

 public static void processMat(Mat mat){
    byte[] rgb = new byte[3];
    for(int i = 0;i < mat.rows();i++){
        for(int j = 0;j < mat.cols();j++){
            mat.get(i,j,rgb);
            int r = (rgb[2] & 0xff);
            int g = (rgb[1] & 0xff);
            int b = (rgb[0] & 0xff);
            //处理像素RGB值
                    
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

上面的代码看似十分符合人类的逻辑思维，意图简洁明了，但实际运行的效率时十分低的。测试代码对电脑全屏截图(分辨率1500*1000)后，调用processMat()函数的运行时间如下：

遍历一张全屏截图居然要2秒钟！ 这还玩个P OpenCV啊。

实际上，看似简单的循环遍历代码背后，隐藏着无数次native函数调用，而这些调用存在额外性能开销，例如：查找dll函数入口地址表，Java到C数据类型的内存存储格式转换，参数传递，返回等等。

代码优化

上面的代码中，光是调用Mat.rows()和Mat.cols()就有150万次。经过测试，光执行这样的空循环(1500 * 1000)，就要耗时35ms

for(int i = 0;i < mat.rows();i++){
    for(int j = 0;j < mat.cols();j++){
    }
}
1
2
3
4

显然，rows()和cols()函数属于重复执行相同的功能了。那么就把它们挪到循环外面只执行一次。

int rows = mat.rows();
int cols = mat.cols();
for(int i = 0;i < rows;i++){
    for(int j = 0;j < cols;j++){
    }
}
1
2
3
4
5
6

优化后，执行速度降低到了2ms。

还没完，现在只把代码的运行速度提升了几十毫秒，真正的耗时大头在获取每一个像素的RGB值Mat.get()函数上。

遍历图像时，如果我们每次循环都去调用dll库获取一个图像像素点，那么总共150万个像素点就要调用150万次native函数，每次却只获得一个像素的RGB值，这也太低效了吧。

解决方案已经显而易见了，那就是一次性获取所有像素的RGB值数组到Java中，这样只需要一次数据类型转换开销，效率大大提升。

public static void highSpeed(Mat mat){
    int rows = mat.rows();
    int cols = mat.cols();
    int channels = mat.channels();
    //像素数组大小: 行数 * 列数 * 颜色通道数
    byte[] pixels = new byte[rows * cols * channels];
    //通过一次native调用获取整个图片的像素数组
    mat.get(0,0,pixels);
    //遍历像素数组
    int inner = cols * channels;
    for(int i = 0; i < rows; i++){
        for(int j = 0; j < inner; j += channels){
            int index = i * inner + j;
            int r = (pixels[index + 2] & 0xff);
            int g = (pixels[index + 1] & 0xff);
            int b = (pixels[index] & 0xff);
            //处理RGB值
            
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

使用以下测试代码进行测试：

太好了，150万个像素RGB值获取只用了5毫秒！

二、高效BufferedImage和Mat对象互相转换

BufferedImage时Java中提供的最常用的带缓冲图像处理对象，不仅可以直接对图像的像素数组进行操作，还能使用此类封装的函数对图像进行裁剪，复制，缩放，颜色类型转换和绘画等操作。

此外，Robot类提供的屏幕截图函数返回的也是BufferedImage对象。

提升效率的原理和上面一样，就是将BufferedImage的图像像素数组一次性赋值给OpenCV的Mat对象，千万不要循环一个个获取再赋值！

public static Mat toMat(BufferedImage bi) {
   Mat mat = new Mat(bi.getHeight(), bi.getWidth(), CvType.CV_8UC3);
   mat.put(0, 0, ((DataBufferByte) bi.getRaster().getDataBuffer()).getData());
   return mat;
}
 
public static BufferedImage toBufferedImage(Mat mat){
    int type = BufferedImage.TYPE_BYTE_GRAY;
    if (mat.channels() > 1) {
    	//注意OpenCV的颜色格式是BGR，所以BufferedImage格式也设为BGR
        type = BufferedImage.TYPE_3BYTE_BGR;
    }
    BufferedImage image = new BufferedImage(mat.cols(), mat.rows(), type);
    mat.get(0, 0, ((DataBufferByte)image.getRaster().getDataBuffer()).getData());
    return image;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

这里有个小细节，OpenCV中处理的彩色图像默认格式是BGR格式，但我们用Java从屏幕截图或文件中获取图片时得到的图片格式都是RGB格式，为了保证转换后颜色的正确性，BufferedImage必须先转为BGR格式。

//原始BufferedImage图像
BufferedImage image = 。。。;
//转换成RGB格式
BufferedImage rgb = new BufferedImage(image.getWidth(), image.getHeight(), BufferedImage.TYPE_3BYTE_BGR);
new ColorConvertOp(ColorSpace.getInstance(ColorSpace.CS_sRGB), null).filter(image, rgb);
1
2
3
4
5

三、高效从屏幕截图和图片文件中获取Mat对象

//配合上面的 toMat() 使用: OpenCV.toMat(screenShot(0,0,100,100));
public static BufferedImage screenshot(int x,int y,int width,int height){
    BufferedImage image = robot.createScreenCapture(new Rectangle(x,y,width,height));
    //转换成RGB格式
    BufferedImage rgb = new BufferedImage(image.getWidth(), image.getHeight(), BufferedImage.TYPE_3BYTE_BGR);
    new ColorConvertOp(ColorSpace.getInstance(ColorSpace.CS_sRGB), null).filter(image, rgb);
    return rgb;
}
//配合上面的 toMat() 使用: OpenCV.toMat(readImageFile(""));
public static BufferedImage readImageFile(String path){
    try {
        BufferedImage image =  ImageIO.read(new BufferedInputStream(new FileInputStream(path)));
        //转换成RGB格式
        BufferedImage rgb = new BufferedImage(image.getWidth(), image.getHeight(), BufferedImage.TYPE_3BYTE_BGR);
        new ColorConvertOp(ColorSpace.getInstance(ColorSpace.CS_sRGB), null).filter(image, rgb);
        return rgb;
    } catch (IOException e) {
        e.printStackTrace();
    }
    return null;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

总结

过于抽象的编程让我们的开发效率提高了，但同时使得函数失去了透明性，开发者根本不知道，也根本不用去关心底层函数的实现原理是什么，能跑就完了。例如Python语言，原生循环的运行效率非常低，因为每次循环语句都要被虚拟机动态编译再运行，为了高效处理大批量数据，py提供了Numpy库。在Numpy中进行向量化操作时，实际上是在进行一些底层的操作，这些操作是由C语言实现的，因此它们的执行效率非常高。而我们要做的，就是在底层调用和上层开发效率之间取得一个平衡点，兼顾代码的可维护性和运行效率。