java使用openCV处理图像入门教程

最新推荐文章于 2024-09-24 19:15:00 发布
最新推荐文章于 2024-09-24 19:15:00 发布
阅读量1.3w 收藏 76
点赞数 8
分类专栏： 图像处理 文章标签： opencv java配置  java opencv图像去雾 opencv java 对比度 亮度 饱和度调节 opencv 高斯滤波 边缘检测 均值滤波 java opencv java 图像油画化
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_29660153/article/details/80076898
版权

java使用openCV处理图像入门教程

1.第一步下载相应资源:
这里写图片描述
这里写图片描述
外网下载可能较慢,请耐心等待,或者试着挂一个vpn
下载完成进行安装,记住安装时选择的路径
2.导入在java项目中导入opencv的jar包
这里写图片描述
3.编写代码
这里写图片描述
把实现了我们在opencv中声明的native方法的那个library load进来，或者load其他什么动态连接库
4.运行代码
这里写图片描述
配置运行时jvm参数
这里写图片描述
path=自己的相应目录(64系统选择x64,32位系统选择x86),里头有一个dll文件

5.demo代码展示(涉及图像的饱和度,对比度,亮度调节,均值滤波,高斯滤波,图像去雾,图像转置,图像边缘检测,图像油画化):
—-github源代码连接——

package com.example.followwindd.util;

import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.core.Size;
import org.opencv.imgproc.Imgproc;

import static org.opencv.core.Core.BORDER_DEFAULT;
import static org.opencv.core.Core.addWeighted;
import static org.opencv.core.Core.convertScaleAbs;
import static org.opencv.core.CvType.CV_16S;
import static org.opencv.imgproc.Imgproc.Sobel;
import static org.opencv.imgproc.Imgproc.cvtColor;

/**
 * 图像的基本处理函数
 *
 * @author 11633
 * @date 2018/4/20 21:29
 */
public class ImageUtil {


    public static final int MIN_VAL = 0;

    public static final int MAX_VAL = 255;

    public static final int BASE_VAL = (MIN_VAL + MAX_VAL) >>> 1;//大于中间值表示增强效果,小于中间值表示消减效果


    /**
     * 图像处理的基本功能
     */
    public static class Base {

        /**
         * @Description: 图像饱和度调节
         * @Param: Mat 传入的图像矩阵
         * @Param: val 调节系数
         * @Return: 调节完成的图像矩阵
         * @Author: followWindDog
         * @Date: 2018/4/18
         */
        public static Mat shiftSaturability(Mat mat, int val) {
            if (val == BASE_VAL) return mat;
            Mat hsv = new Mat();
            double f;
            boolean flag = false;
            if (val > BASE_VAL) {
                flag = true;
                f = 1.0 * (val - BASE_VAL) / BASE_VAL;
            } else {
                f = 1.0 * val / BASE_VAL;
            }

            Imgproc.cvtColor(mat, hsv, Imgproc.COLOR_BGR2HSV);

            for (int i = 0; i < hsv.height(); i++) {
                for (int j = 0; j < hsv.width(); j++) {
                    double[] vals = hsv.get(i, j);
                    if (flag) {
                        vals[1] = vals[1] + (MAX_VAL - vals[1]) * f;
                    } else {
                        vals[1] = vals[1] * f;
                    }
                    hsv.put(i, j, vals);
                }
            }
            Mat ret = new Mat();
            Imgproc.cvtColor(hsv, ret, Imgproc.COLOR_HSV2BGR);
            return ret;
        }

        /**
         * @Description: 图像的对比度调节
         * @Param: Mat 传入的图像矩阵
         * @Param: val 调节系数
         * @Return: 调节完成的图像矩阵
         * @Author: followWindDog
         * @Date: 2018/4/25
         */
        public static Mat shiftContrast(Mat img, int val) {
            if (val == BASE_VAL) return img;
            Mat ret = new Mat(img.height(), img.width(), img.type());
            double maxx = -1, minn = 300.0;
            for (int i = 0; i < img.height(); i++) {
                for (int j = 0; j < img.width(); j++) {
                    double[] vals = img.get(i, j);
                    for (int k = 0; k < vals.length; k++) {
                        maxx = maxx > vals[k] ? maxx : vals[k];
                        minn = minn < vals[k] ? minn : vals[k];
                    }
                }
            }
            double midd = (maxx + minn) / 2;
            double a;
            if(val>BASE_VAL){
                if(val==MAX_VAL)val--;
                a = BASE_VAL/(1.0*(MAX_VAL-val));
            }else{
                a = (1.0 * val) / BASE_VAL;
            }
            double b = midd * (1 - a);
            for (int i = 0; i < img.height(); i++) {
                for (int j = 0; j < img.width(); j++) {
                    double[] vals = img.get(i, j);
                    for (int k = 0; k < vals.length; k++) {
                        vals[k] = a * vals[k] + b;
                    }
                    ret.put(i, j, vals);
                }
            }
            return ret;
        }

        /**
         * @Description: 图像亮度调节
         * @Param: Mat 传入的图像矩阵
         * @Param: val 调节系数
         * @Return: 调节完成的图像矩阵
         * @Author: followWindDog
         * @Date: 2018/4/25
         */
        public static Mat shiftBrightness(Mat img, int val) {
            if (val == BASE_VAL)
                return img;
            Mat ret = new Mat(img.height(), img.width(), img.type());
            int hei = img.height();
            int wid = img.width();
            double f;
            boolean flag = false;
            if (val > BASE_VAL) {
                flag = true;
                f = 1.0 * (MAX_VAL - val) / BASE_VAL;
            } else {
                f = 1.0 * val / BASE_VAL;
            }
            for (int i = 0; i < hei; i++) {
                for (int j = 0; j < wid; j++) {
                    double[] vals = img.get(i, j);
                    for (int k = 0; k < vals.length; k++) {
                        if (flag) {
                            vals[k] = 255 - (vals[k] * f);
                        } else {
                            vals[k] = vals[k] * f;
                        }
                    }
                    ret.put(i, j, vals);
                }
            }
            return ret;
        }

        /**
         * @Description: 将矩阵进行转置
         * @Param: mat 要转置的图像矩阵
         * @Return: 转置过后的图像矩阵
         * @Author: followWindDog
         * @Date: 2018/4/18
         */
        public static Mat transposition(Mat mat) {
            Mat ret = new Mat(mat.width(), mat.height(), mat.type());
            for (int i = 0; i < mat.height(); i++) {
                for (int j = 0; j < mat.width(); j++) {
                    double[] vals = mat.get(i, j);
                    ret.put(j, i, vals);
                }
            }
            return ret;
        }
    }

    public static class Filter {

        private static int standardizeCellSize(int cellSize) {
            return cellSize % 2 == 0 ? cellSize + 1 : cellSize;
        }


        /**
         * @Description: 高斯函数
         * @Param: x 到达中心的x方向距离
         * @Param: y 到达中心的y方向距离
         * @Param: y 到达中心的y方向距离
         * @Return: variance 方差
         * @Author: followWindDog
         * @Date: 2018/4/20
         */
        private static double gaussianFunction(double x, double y, double variance) {
            return 1.0 / (2 * Math.PI * variance * variance) * Math.exp((-x * x - y * y) / (2 * variance * variance));
        }

        private static boolean chackRange(int i, int j, int hei, int wid) {
            return i >= 0 && i < hei && j >= 0 && j < wid;
        }

        private static Mat filtering(Mat mat, double[][] weightMatrix) {
            Mat ret = new Mat(mat.height(), mat.width(), mat.type());
            double[][][] m = new double[mat.height()][mat.width()][mat.get(0, 0).length];
            for (int i = 0; i < mat.height(); i++) {
                for (int j = 0; j < mat.width(); j++) {
                    m[i][j] = mat.get(i, j);
                }
            }

            int halfCellSize = weightMatrix.length >>> 1;
            int hei = mat.height();
            int wid = mat.width();
            for (int i = 0; i < hei; i++) {
                for (int j = 0; j < wid; j++) {
                    double[] suma = new double[3];
                    double sumb = 0;
                    for (int k = 0; k < weightMatrix.length; k++) {
                        for (int l = 0; l < weightMatrix.length; l++) {
                            int loci = i - (halfCellSize - k);
                            int locj = j - (halfCellSize - l);
                            if (chackRange(loci, locj, mat.height(), mat.width())) {
                                sumb += weightMatrix[k][l];
                                for (int n = 0; n < suma.length; n++) {
                                    suma[n] += weightMatrix[k][l] * m[loci][locj][n];
                                }
                            }
                        }
                    }
                    for (int k = 0; k < suma.length; k++) {
                        suma[k] /= sumb;
                    }
                    ret.put(i, j, suma);
                }
            }
            return ret;
        }

        public static Mat gaussianFiltering(Mat mat, int cellSize, double variance) {
            //通过高斯函数计算每一个格子的权值
            cellSize = standardizeCellSize(cellSize);
            int hCellSize = cellSize >>> 1;
            double[][] tCell = new double[cellSize][cellSize];
            double sum = 0;
            for (int i = 0; i < tCell.length; i++) {
                for (int j = 0; j < tCell[i].length; j++) {
                    tCell[i][j] = gaussianFunction(hCellSize - i, hCellSize - j, variance);
                    sum += tCell[i][j];
                }
            }
            for (int i = 0; i < tCell.length; i++) {
                for (int j = 0; j < tCell[i].length; j++) {
                    tCell[i][j] = tCell[i][j] * 100 / sum;
                }
            }
            return filtering(mat, tCell);
        }

        /**
         * @Description: 最普通的均值滤波
         * @Param: mat 要滤波的图像矩阵
         * @Param: cellSize 滤波方框的大小
         * @Return: 滤波完成后的矩阵
         * @Author: followWindDog
         * @Date: 2018/4/20
         */
        public static Mat averageFiltering(Mat mat, int cellSize) {
            //TODO 性能优化
            Mat ret = new Mat(mat.height(), mat.width(), mat.type());
            double[][][] mm = new double[mat.height()][mat.width()][mat.get(0, 0).length];
            for (int i = 0; i < mat.height(); i++) {
                for (int j = 0; j < mat.width(); j++) {
                    mm[i][j] = mat.get(i, j);
                }
            }
            cellSize = standardizeCellSize(cellSize);
            int halfCellSiz = cellSize >> 1;
            for (int i = 0; i < mat.height(); i++) {
                for (int j = 0; j < mat.width(); j++) {
                    double[] to = new double[3];
                    int fi = i - halfCellSiz, ti = i + halfCellSiz, fj = j - halfCellSiz, tj = j + halfCellSiz;
                    for (int k = 0; k < to.length; k++) {
                        double sum = 0;
                        int cnt = 0;
                        for (int l = fi; l <= ti; l++) {
                            for (int m = fj; m <= tj; m++) {
                                if (l >= 0 && l < mat.height() && m >= 0 && m < mat.width()) {
                                    sum += mm[l][m][k];
                                    cnt++;
                                }
                            }
                        }
                        to[k] = sum / cnt;
                    }
                    ret.put(i, j, to);
                }
            }
            return ret;
        }

        /**
         * @Description: 将图片进行锐化
         * @Param: mat 传入的图像矩阵
         * @Param: cellSize 滤波使用的方框大小
         * @Param: factor 锐化强度
         * @Return: 锐化过后的矩阵
         * @Author: followWindDog
         * @Date: 2018/4/18
         */
        public static Mat sharpen(Mat mat, int cellSize, int factor) {
            Mat filter = averageFiltering(mat, cellSize);
            Mat ret = new Mat(mat.height(), mat.width(), mat.type());
            for (int i = 0; i < ret.height(); i++) {
                for (int j = 0; j < ret.width(); j++) {
                    double[] rgb = mat.get(i, j);
                    double[] frgb = filter.get(i, j);
                    for (int k = 0; k < rgb.length; k++) {
                        rgb[k] += factor * (rgb[k] - frgb[k]);
                    }
                    ret.put(i, j, rgb);
                }
            }
            return ret;
        }

        /*
        * 求图像的暗通道
        * */
        private static double[][] getDarkChannel(Mat mat, int cellSize) {
            if (cellSize % 2 == 0)
                cellSize++;
            int hcellSize = cellSize >>> 1;
            double[][] doubles = new double[mat.height()][mat.width()];
            for (int i = 0; i < mat.height(); i++) {
                for (int j = 0; j < mat.width(); j++) {
                    double[] vals = mat.get(i, j);
                    doubles[i][j] = vals[0];
                    for (int k = 1; k < vals.length; k++) {
                        doubles[i][j] = (doubles[i][j] < vals[k]) ? doubles[i][j] : vals[k];
                    }
                }
            }

            double[][] ret = new double[mat.height()][mat.width()];
            for (int i = 0; i < mat.height(); i++) {
                for (int j = 0; j < mat.width(); j++) {
                    double maxx = 300;
                    for (int k = 0; k < cellSize; k++) {
                        for (int l = 0; l < cellSize; l++) {
                            int locx = i + (k - hcellSize);
                            int locy = j + (l - hcellSize);
                            if (locx >= 0 && locx < ret.length && locy >= 0 && locy < ret[locx].length)
                                maxx = (maxx < doubles[locx][locy]) ? maxx : doubles[locx][locy];
                        }
                    }
                    ret[i][j] = maxx;
                }
            }
            return ret;
        }



        /**
         * @Description: 图像进行去雾处理(何凯铭去雾)
         * @Param: mat 等待去雾的图像
         * @Param: cellSize 去雾时使用的方框大小
         * @Return: 去雾完成的图像
         * @Author: followWindDog
         * @Date: 2018/4/25
         */
        public static Mat disFog(Mat mat, int cellSize) {
            double[][] dackCha = getDarkChannel(mat, cellSize);
            Mat ret = new Mat(mat.height(), mat.width(), mat.type());

            for (int i = 0; i < ret.height(); i++) {
                for (int j = 0; j < ret.width(); j++) {
                    double[] valsTo = new double[3];
                    double[] valsFrom = mat.get(i, j);
                    double f = dackCha[i][j] / 255;
                    for (int k = 0; k < valsFrom.length; k++) {
                        valsTo[k] = (valsFrom[k] - 127 * f) / (1 - f);
                    }
                    ret.put(i, j, valsTo);
                }
            }
            return ret;
        }



        /**
         * @Description: 为图像进行边缘检测
         * @Param: img 等待边缘检测的图像矩阵
         * @Return: 表示图像边缘的矩阵
         * @Author: followWindDog
         * @Date: 2018/4/25
         */
        public static Mat edgeDetection(Mat img) {
            Mat clone = img.clone();
            int sizex = 5, sizey = 5;
            double dx = 0, dy = 0;
            Imgproc.GaussianBlur(clone, clone, new Size(sizex, sizey), dx, dy, BORDER_DEFAULT);
            Mat grad_x = new Mat(), grad_y = new Mat(), src_gray = new Mat();
            Mat abs_grad_x = new Mat(), abs_grad_y = new Mat();
            cvtColor(clone, src_gray, Imgproc.COLOR_BGR2GRAY);
            int scale = 1;
            int delta = 0;
            int ddepth = CV_16S;
            Sobel(src_gray, grad_x, ddepth, 1, 0, 3, scale, delta, BORDER_DEFAULT);
            convertScaleAbs(grad_x, abs_grad_x);

            Sobel(src_gray, grad_y, ddepth, 0, 1, 3, scale, delta, BORDER_DEFAULT);
            convertScaleAbs(grad_y, abs_grad_y);
            Mat ret = new Mat();
            addWeighted(abs_grad_x, 0.5, abs_grad_y, 0.5, 0, ret);
            return ret;
        }



        /**
         * @Description: 为图像添加类似油画的效果
         * @Param: img 等待处理的图像
         * @Return: 经过油画处理的图像
         * @Author: followWindDog
         * @Date: 2018/4/25
         */
        public static Mat oilPainting(Mat img) {

            Mat mat1 = edgeDetection(img);
            Imgproc.GaussianBlur(img, img, new Size(11, 11), 20, 20, Core.BORDER_DEFAULT);
            for (int i = 0; i < img.height(); i++) {
                for (int j = 0; j < img.width(); j++) {
                    double[] doubles = img.get(i, j);
                    double[] doubles1 = mat1.get(i, j);
                    for (int k = 0; k < doubles.length; k++) {
                        doubles[k] -= 1 * doubles1[0];
                    }
                    img.put(i, j, doubles);
                }
            }
            return img;
        }

    }
}

测试代码

package com.example.followwindd.test;

import com.example.followwindd.util.ImageUtil;
import org.junit.Test;
import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.highgui.HighGui;
import org.opencv.imgcodecs.Imgcodecs;


/**
 * @author 11633
 * @date 2018/4/21 8:46
 */
public class TestImageUtil {
    static {
        System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
    }

    private static Mat imread = Imgcodecs.imread("./photo/00005.jpg");

    public static void showImg(Mat imread, int len) {
        HighGui.namedWindow("test", HighGui.WINDOW_AUTOSIZE);
        HighGui.imshow("test", imread);
        HighGui.waitKey(len);
    }

    public static class TestBase {
        @Test
        public void testShiftSaturability() {
            for (int i = 0; i <= 255; i += 50)
                showImg(ImageUtil.Base.shiftSaturability(imread, i), 1000);
        }

        @Test
        public void testShiftContrast() {
            for (int i = 0; i <= 255; i += 50)
                showImg(ImageUtil.Base.shiftContrast(imread, i), 1000);
        }

        @Test
        public void testShiftBrightness() {
            for (int i = 0; i <= 255; i += 50) {
                showImg(ImageUtil.Base.shiftBrightness(imread, i), 1000);
            }
        }

        @Test
        public void testTransposition() {
            showImg(ImageUtil.Base.transposition(imread), 0);
        }
    }


    public static class TestFilter {
        @Test
        public void testGaussianFiltering() {
            for (int i = 3; i < 20; i += 2) {
                showImg(ImageUtil.Filter.gaussianFiltering(imread, i, 100), 100);
                System.out.println(i);
            }
        }


        @Test
        public void testAverageFiltering() {
            for (int i = 3; i < 20; i += 2) {
                showImg(ImageUtil.Filter.averageFiltering(imread, i), 100);
                System.out.println(i);
            }
        }

        @Test
        public void testSharpen() {
            for (int i = 3; i < 20; i += 2) {
                showImg(ImageUtil.Filter.sharpen(imread, i, 2), 100);
                System.out.println(i);
            }
        }

        @Test
        public void testDisFog() {
            showImg(ImageUtil.Filter.disFog(imread, 20), 0);
        }

        @Test
        public void testEdgeDetection() {
            showImg(ImageUtil.Filter.edgeDetection(imread), 0);
        }


        @Test
        public void testOilPainting() {
            showImg(ImageUtil.Filter.oilPainting(imread), 0);
        }
    }
}
Java使用OpenCV进行图像操作
积跬步，至千里。
06-15 2万+
OpenCV是一个开源的计算机视觉库，它提供了一系列丰富的图像处理和计算机视觉算法，包括图像读取、显示、滤波、特征检测、目标跟踪等功能。
Java Opencv 图片融合
取名为猫的狗的博客
09-20 1004
融合的图片大小相同： OpenCV的addWeighted()进行图片融合addWeighted使用方法 把一张小图片融合进大图片的区域 import org.opencv.core.*; import org.opencv.imgcodecs.Imgcodecs; public class OpenCVTest { static{ System.loadLibrary(Core....
【Python】PyCharm: 强大的 Python 开发环境
最新发布
技术无疆
09-24 1832
在众多的 Python 集成开发环境（IDE）中，PyCharm 以其强大的功能和用户友好的界面脱颖而出。由 JetBrains 开发的 PyCharm，专为 Python 编程语言设计，提供了一整套开发工具，旨在提高开发效率和简化编程流程。
java基于OpenCv图像处理_读取_保存图片
ferryMan的博客
10-28 4021
java基于openCv图像处理 本文使用javaCV封装后的OpenCv <dependency> <groupId>org.bytedeco</groupId> <artifactId>javacv-platform</artifactId> <version>1.5.5</version> </dependency> 1、图片读取、保存 在openCv中有一函数用于读取图片 imr
【OpenCV & Java 教程02】图像处理基本操作
WLP_China的博客
12-16 1389
简单介绍读取图像、显示图像、保存图像这几项基本操作。
JavaCV图片清晰处理示例
weixin_42390873的博客
07-07 79
CV相关视频讲解：AIGC与NLP大模型实战-经典CV与NLP大模型及其下游应用任务实现如何实现JavaCV图片清晰处理示例 流程图 #render_6_2506642084-svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fi...
Java使用OpenCV3.2实现视频读取与播放
08-25
Java使用OpenCV3.2实现视频读取与播放 OpenCV是一个计算机视觉库，提供了丰富的计算机视觉功能，包括图像处理、特征检测、目标跟踪、视频分析等。Java是最流行的编程语言之一，OpenCV提供了Java语言的SDK，允许Java...
Java+OpenCV+OCR 图像字符处理
12-14
本项目“Java+OpenCV+OCR 图像字符处理”聚焦于利用Java编程语言结合OpenCV库和OCR（Optical Character Recognition，光学字符识别）技术来实现这一功能。下面我们将深入探讨这些知识点。 首先，OpenCV是一个开源的...
OpenCV 图像处理教程基础教程培训PPT文档+课程配套源代码.zip
05-04
OpenCV 图像处理教程基础教程培训PPT文档+课程配套源代码 OpenCV是计算机视觉开源库，主要算法涉及图像处理和机器学习相关方法。 是Intel公司贡献出来的，俄罗斯工程师贡献大部分C/C++带代码。 在多数图像处理相关的...
OpenCV图像处理入门
06-20
总的来说，“OpenCV图像处理入门”课程是一门综合性的课程，它不仅教授了OpenCV的基本操作，还涵盖了图像处理、计算机视觉和深度学习的基础知识，为学习者在人工智能领域的发展打下了坚实的基础。通过学习和实践，...
基于java+OpenCV人脸识别+图片相似度检测+源码+开发文档说明+代码解说（毕业设计&课程设计&项目开发）
04-09
基于java+OpenCV人脸识别+图片相似度检测+源码+开发文档说明+代码解说，适合毕业设计、课程设计、项目开发。项目源码已经过严格测试，可以放心参考并在此基础上延申使用~ 项目简介： 检测任意两张图片的相似度思路 ...
java+opencv截取图片中的印章
11-28
java调用opencv利用霍夫圆定位查找印章，并返回质心坐标和半径以达到截取印章的目的
OpenCV+Java+拍照+保存
02-25
在eclipse中配置好OpenCV后，利用Java调用OpenCV库函数实现本地摄像头的拍照功能并保存到本地。
OpenCV Java教程
06-12
OpenCV提供的视觉处理算法非常丰富，并且它部分以C语言编写，加上其开源的特性，处理得当，不需要添加新的外部支持也可以完整的编译链接生成执行程序。应用领域：人机互动、物体识别、图像分割、人脸识别、动作识别、运动跟踪、机器人、运动分析、机器视觉、结构分析、汽车安全驾驶
OpenCV使用教程
04-04
https://blog.csdn.net/u012706811/article/details/52779271 OpenCV使用教程 并且更新相关的志愿队用法
基于OpenCV对图片清晰度、色偏和亮度的检测（java版）
热门推荐
Janche的博客
02-27 1万+
由来：近期项目需要检测图片的亮度和色偏，但网上大多为用C实现的，没有java版本的，此篇为java版本对opencv的调用，谨以此献给CSDN的广大用户。 一. 导入OpenCV所需依赖 OpenCV运行环境下载(包含jar包和dll依赖库) 在IDEA的项目模块下新建一个libs目录，将opencv-343.jar放进去，将opencv_java343.dll放到项目下。 如图： 注意：o...
使用Java和OpenCV进行图像处理
EiyMobile的博客
09-21 161
您可以通过安装OpenCV库并导入必要的库来开始使用OpenCV。然后，您可以加载和显示图像，并使用OpenCV提供的各种功能和算法进行图像处理。图像处理是计算机视觉领域中的重要任务之一，而OpenCV是一个强大的开源计算机视觉库，它提供了许多功能和算法，可用于处理图像和视频。本文将介绍如何在Java中使用OpenCV进行图像处理，并提供相应的源代码示例。将下载的库文件（如opencv-4.5.3.jar）添加到Java项目的类路径中。要在Java中使用OpenCV，需要导入相应的库。
基于OPENCV的图像识别（JAVA版本）
riihiq000的博客
10-16 9049
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、使用方法二、使用步骤1.废话不多说，直接上代码转载地址 前言 前几天需要开发一款自动化测试工具，需要用到图像识别 但从未接触过图像算法相关知识，无奈只能找轮子 功夫不负有心人，找到大神分享的一遍文章 现分享给大家 一、使用方法 示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。 二、使用步骤 1.废话不多说，直接上代码 代码如下（示例）： public class ImageRecog
OpenCV4.2 Java 图像模糊处理
梦里蓝天
01-07 1212
package com.opencv; import org.opencv.core.Core; import org.opencv.core.Mat; import org.opencv.core.Point; import org.opencv.core.Size; import org.opencv.highgui.HighGui; import org.opencv.imgcodecs....
使用OpenCV实现图像分块处理的教程
资源摘要信息: "图像分块操作及其在OpenCV中的实现方法" 图像处理技术是计算机视觉和机器学习等领域中不可或缺的一...通过使用OpenCV这一强大的库，可以方便地实现图像分块，并在此基础上进行各种图像处理和分析工作。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值