使用Java和OpenCV调用YOLOv3完成实施目标检测
作者：互联网
使用Java和OpenCV调用YOLOv3完成实施目标检测，识别到目标就将包含目标的图片保存下来，没有目标就不保存。详细代码以及步骤。
第一步:在IDEA中完成对OpenCV包的导入
从官网上下载OpenCV：Releases - OpenCV。选择window版本下载，解压之后
把 opencv\build\目录下的java文件整个复制到项目文件下，名字随意。
File>Project Structure>Libraries ，选择+号，选择java，之后选择jar包位置。导入即可。
这里我已经导入过了。最后再配置dll
Run>Edit Configurations ，选中你所要配置的java文件，填入以下内容：
-Djava.library.path=$PROJECT_DIR$\opencv\x64 （64位选x64,32位选x86）
第二步：完成目标检测
首先下载darknet:GitHub - pjreddie/darknet: Convolutional Neural Networks
为了方便操作，这里只需要将darknet的路径以及保存的图片路径修改为自己的即可。下边直接上代码。当然你也可以训练自己的YOLOv3模型来完成相关的操作。
主程序
import org.opencv.core.*;
import org.opencv.core.Point;
import org.opencv.dnn.Dnn;
import org.opencv.dnn.Net;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.videoio.VideoCapture;
import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.io.*;
import java.util.ArrayList;
import java.util.List;
import static org.opencv.dnn.Dnn.NMSBoxes;
import static org.opencv.highgui.HighGui.*;
import static org.opencv.highgui.HighGui.waitKey;
import static org.opencv.imgproc.Imgproc.*;
import static org.opencv.imgproc.Imgproc.FONT_HERSHEY_SIMPLEX;
public class VideoDet{
final static String ROOTDIR = "E:\\ZxxProject\\darknet-master"; // 根路径
final static float CONTHRES = 0.8f; // 置信度阈值
final static float NMSTHRES = 0.8f; // iou阈值
final static List<String> CLASSES = new ArrayList<>(); // 存放类别的列表集合（这里直接用的原模型，所以是80类）
public static int count=0;//标记，用来间隔多少次来保存图片
public static boolean judge=true;
public static void main(String[] args) {
System.loadLibrary(Core.NATIVE_LIBRARY_NAME);//必须要加，不然程序不可执行
//配置 权重 图片路径 类别文件
String modelConfiguration = ROOTDIR + "\\cfg\\yolov3.cfg"; // 模型配置文件
String modelWeights = ROOTDIR + "\\yolov3.weights"; // 模型权重文件
String classesFile = ROOTDIR + "\\data\\coco.names"; // 模型可识别类别的标签文件
// 进入识别图片的方法
try {
detect_image(modelWeights, modelConfiguration, classesFile);
} catch (Exception e) {
e.printStackTrace();
}
}
启动摄像头
public static void detect_image(String modelWeights, String modelConfiguration, String classesFile) throws Exception {
// 使用字节输入流读取classesFile路径的文件(从硬盘读取数据到内存)
InputStream inputStream = new FileInputStream(classesFile);
int allByte = inputStream.available();
byte[] bytes = new byte[allByte]; //通过调节allByte的值来完成每次读取多少字节，这里直接读完
inputStream.read(bytes);
String allContent = new String(bytes); // 文件中的所有内容
String[] tempContent = allContent.trim().split("\n"); // allContent去除首尾空格，再按换行符分割。
// 遍历tempContent，添加到保存类别名的列表classes里。
for(int i=0; i<tempContent.length; i++){
CLASSES.add(tempContent[i]);
}
System.out.println(CLASSES.size());
Net net = Dnn.readNetFromDarknet(modelConfiguration, modelWeights);
//打开摄像头
VideoCapture cameraCapture = new VideoCapture(0);
namedWindow("实时检测");
int frame_width = (int) cameraCapture.get(3);
int frame_height = (int) cameraCapture.get(4);
Mat frame = new Mat();
Size sz1 = new Size(frame_width, frame_height);
while (judge) {
cameraCapture.read(frame);
count=count+1;
System.out.println("-----------第"+count+"轮----------------");
Mat blobImg = Dnn.blobFromImage(frame, 1.0F / 255.0F, sz1);
net.setInput(blobImg);
// 获取网络输出层信息（所有输出层的名字），设定并前向传播
List<String> ln = net.getLayerNames(); // 获得YOLO各层的名字
List<String> x = new ArrayList<>();
List<List<Integer>> out = new ArrayList<>();
List<Integer> temp = net.getUnconnectedOutLayers().toList(); // 获得未连接的输出层的索引列表
out.add(temp);
// out中存放的是一个List ,get(0)得到的就是list i 索引列表
List<Integer> i = out.get(0);
System.out.println(i.size()); // 3
for (int a = 0; a < i.size(); a++) {
String n = ln.get(i.get(a) - 1); // 输出层的名字
x.add(n); // 找到所有的输出层
}
ln = x; // 给ln重新赋值
// 矩阵列表 [Mat[...], Mat[...], Mat[...]]
List<Mat> outs = new ArrayList<Mat>();
net.forward(outs, ln); // ln此时为输出层的名字列表，向前传播，将得到的检测结果传入outs
// 检测识别
detection(frame, outs);
}
}
检测摄像头中的目标
public static void detection(Mat frame, List<Mat> outs) {
System.out.println("检测过程开始");
List<Rect2d> boxes = new ArrayList<>(); // 矩形框列表
List<Integer> classIds = new ArrayList<>(); // 类的序号列表
List<Float> confidences = new ArrayList<>(); // 置信度列表
List<Integer> indices = new ArrayList<>(); //数量标记
MatOfRect2d newbox = new MatOfRect2d();
MatOfFloat newconf = new MatOfFloat();
MatOfInt ind = new MatOfInt();
ind.fromList(indices);
//TODO
for (int i = 0; i < outs.size(); i++) {
Mat mat = outs.get(i);
// 循环每一个mat对象
for (int j = 0; j < mat.rows(); j++) {
int probaility_index = 5; // [x,y,h,w,c,class1,class2] 所以是标号5
int size = (mat.cols() * mat.channels());
float[] data = new float[size];
mat.get(j, 0, data);
float confidence = -1;//初始值设为-1，
int classId = -1;
// 按列循环
for (int k = 0; k < mat.cols(); k++) {
if (k >= probaility_index && confidence < data[k]) {
confidence = data[k]; // 最大值付给confidence
classId = k - probaility_index; // 得到检测的类别索引
}
}
// 过滤掉置信度较小的检测结果
if (confidence > 0.6) {
System.out.println("Result Object:" + j);
for (int k = 0; k < mat.cols(); k++) {
if (data[k] > 0) {
System.out.println(" " + k + ":" + data[k]);
}
}
float x = data[0]; // centerX 矩形中心点的X坐标
float y = data[1]; // centerY 矩形中心点的Y坐标
float width = data[2]; // 矩形框的宽
float height = data[3]; //矩形框的高
float xLeftBottom = (x - width / 2) * frame.cols(); // 矩形左下角点的X坐标
float yLeftBottom = (y - height / 2) * frame.rows(); // 矩形左下角点的Y坐标
float xRightTop = (x + width / 2) * frame.cols(); // 矩形右上角点的X坐标
float yRightTop = (y + height / 2) * frame.rows(); // 矩形右上角点的Y坐标
// boxes主要包括左下角坐标与右上角坐标
boxes.add(new Rect2d(new Point(xLeftBottom, yLeftBottom), new Point(xRightTop, yRightTop)));
newbox.fromList(boxes);
confidences.add(confidence);
newconf.fromList(confidences);
classIds.add(classId);
}
}
}
//使用OpenCV的非极大抑制
NMSBoxes(newbox, newconf, CONTHRES, NMSTHRES, ind);
//当摄像头中无出现目标的时候，newbox/newconf.cols()==0，有目标则是1。
if (newbox.cols() == 0 && newconf.cols() == 0) {
imshow("实时检测", frame);
waitKey(-1);
return;
}
List<Integer> indices1 = ind.toList();
List<Rect2d> bboxs1 = newbox.toList();
List<Float> conf1 = newconf.toList();
List<Mat> cutImages = new ArrayList<>();
int a = 0;
if (indices1.size() > 0) {
for (int b = 0; b < indices1.size(); b++) {
a = a + 1;
Rect2d box = bboxs1.get(indices1.get(b));
Point p1 = box.tl(); // 获得左 上角点
Point p2 = box.br(); // 获得右下角点
int classId = classIds.get(a - 1); // 得到类别序号
float confidence = conf1.get(a - 1); // 得到置信度值
// 在原图上绘制目标边框
drawPic(classId, confidence, frame, p1, p2);
cutImages.add(frame);
}
}
System.out.println("cutImages" + cutImages);
// 将含有目标的图片存入本地路径，无目标不保存
String outputFilePath = "E:\\ZxxProject\\darknet-master\\imgRes";
for (int i = 0; i < cutImages.size(); i++) {
Mat mat = cutImages.get(i);
//显示图片
imshow("实时检测", mat); // 显示图片
waitKey(-1);
if (count % 10 == 0) {
MatOfByte mob = new MatOfByte();
Imgcodecs.imencode(".jpg", mat, mob);
byte[] byteArray = mob.toArray();
ByteArrayInputStream in = new ByteArrayInputStream(byteArray);
try {
BufferedImage image = ImageIO.read(in);
OutputStream bOut = new FileOutputStream(outputFilePath + "/" + count + ".jpg");
ImageIO.write(image, "jpg", bOut);
} catch (IOException e) {
e.printStackTrace();
}
}
}
}绘制边框程序
public static void drawPic(int classId, float confidence, Mat im, Point p1, Point p2){
String text;
double x = p1.x; // p1 的 x 坐标
double y = p1.y; // p1 的 y 坐标
if(classId == 0){
System.out.println("1");
rectangle(im, p1, p2, new Scalar(0, 0, 255), 1);
text = CLASSES.get(classId) + ":" + confidence;
putText(im, text, new Point(x, y-5), FONT_HERSHEY_SIMPLEX, 0.3, new Scalar(0, 255, 0), 1);
}else {
System.out.println("2");
rectangle(im, p1, p2, new Scalar(0, 255, 0), 1); // 画框
text = String.format("%s %f", CLASSES.get(classId), confidence); // 标签内容
System.out.println(text);
putText(im, text, new Point(x, y-5), FONT_HERSHEY_SIMPLEX, 0.5, new Scalar(0, 0, 255), 1);
}
}
}第三步：结果
结果中可能出现的绘制的框过多的现象，代码还有许多优化的地方，可以在评论中留言。
参考文章
[1] opencv调用yolov3模型进行深度学习目标检测（Java版）_w112112_的博客-CSDN博客
[2] 使用python+opencv+yolov3实现实时目标检测_Lz~ryeom的博客-CSDN博客
标签：YOLOv3,opencv,int,List,OpenCV,Java,static,new,import 来源： https://blog.csdn.net/qq_50087672/article/details/120903653