JAVA-基于SVM+HOG的对象检测

最新推荐文章于 2025-05-20 15:18:02 发布

wang_feng0

最新推荐文章于 2025-05-20 15:18:02 发布

阅读量1.6k

点赞数 3

CC 4.0 BY-SA版权

分类专栏：机器学习文章标签： JAVA SVM HOG

本文链接：https://blog.csdn.net/wang_feng0/article/details/81368363

机器学习专栏收录该内容

1 篇文章

订阅专栏

本文分享了一个使用Java实现行人及人脸检测的项目经验。利用OpenCV中的SVM和HOG技术，通过训练模型并应用到图像上进行目标检测。文章详细介绍了训练和预测过程，并展示了部分检测效果。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

这是我的毕设，因为在实现过程中发现网上关于JAVA实现的代码较少所以想在这里分享一下经验。

实现所采用的技术主要是opencv中的svm，hog，语言采用的是JAVA（实现的时候发现选的不好。。），一开始的时候不清楚数据集的影响，就自己做了杯子的数据集，但效果不好。后来使用的是INRIA和MIT的行人数据集，FDDB的人脸数据集（我这里是对象检测，所以测试了不同对象）。

下面贴代码：

1）：训练

public class Svm_train {
   /**
   * SVM训练
   */
   public void svm_train(){
Integer ITERATION_NUM = 3000;
String traintxt = "E:\\biyesheji\\image\\traindata.txt";//行人
//String traintxt = "E:\\biyesheji\\image\\traindata2.txt";//人脸
ArrayList<String> img_path = new ArrayList<String>();
ArrayList<Float> img_label = new ArrayList<Float>();
//System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
System.load("E:\\biyesheji\\opencv\\build\\java\\x64\\opencv_java330.dll");
System.out.println("类库加载成功·");

try {
BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(new File(traintxt)),
"UTF-8"));
//System.out.println("读取文件");
String linetxt = null;
Integer nline = 0;
while((linetxt = br.readLine()) !=null){
nline++;
String []path_label = linetxt.split("\t");
//System.out.println(path_label[0] + ' ' + path_label[1]);
img_path.add(path_label[0]);
img_label.add(Float.valueOf(path_label[1]).floatValue());
}
br.close();
//一个block内有4个cell，每个cell含9维特征向量，故每个block就由4x9=36维特征向量来表征
//128x64（高128，宽64），即有(128÷8)x(64÷8)=16x8个cell，也即有15x7个block
//在提取每个窗口的HOG特征，则可得到105x36=3780维HOG特征向量
Integer SAMPLE_COUNT = nline; //样本数
Integer PICTURE_FEATURE_DIM = 3780;//图片特征维数,64*64(1764),64*128(3780),128*128(8100)
//Integer PICTURE_FEATURE_DIM = 1764;//人脸
Mat data_mat = new Mat(SAMPLE_COUNT, PICTURE_FEATURE_DIM, CvType.CV_32FC1);//行，列，类型
Mat res_mat = new Mat(SAMPLE_COUNT, 1, CvType.CV_32SC1);

//svm descriptors
ArrayList<float[]> descriptors = new ArrayList<float[]>();
for (Integer i=0;i<img_path.size();i++){
System.out.println("GetHog:"+img_path.get(i));
Mat src = Imgcodecs.imread(img_path.get(i));

if(src.empty()){
System.out.println(img_path.get(i));
throw new Exception("no such picture");
}
if(img_label.get(i)==1)
{
   if(src.cols()>64 || src.rows()>128)//行人128
   {
       //去掉上下左右16个像素
       Rect Roi=new Rect(new Point(16,16),new Size(64,128));//行人128
       Mat image= src.submat(Roi);//子图
       HOGDescriptor hog = new HOGDescriptor(new Size(64, 128), new Size(16, 16), new Size(8, 8), new Size(8, 8), 9);//行人128
       MatOfFloat descriptorsOfMat = new MatOfFloat();
       hog.compute(image, descriptorsOfMat);//调用计算函数
       float[] descriptor = descriptorsOfMat.toArray();//一列
       descriptors.add(descriptor);
   }else{
       HOGDescriptor hog = new HOGDescriptor(new Size(64, 128), new Size(16, 16), new Size(8, 8), new Size(8, 8), 9);//行人
       //HOGDescriptor hog = new HOGDescriptor(new Size(64, 64), new Size(16, 16), new Size(8, 8), new Size(8, 8), 9);//人脸
       MatOfFloat descriptorsOfMat = new MatOfFloat();
       hog.compute(src, descriptorsOfMat);//调用计算函数
       float[] descriptor = descriptorsOfMat.toArray();//一列
       descriptors.add(descriptor);
   }

}else if(img_label.get(i)==0){
   //Hog特征，窗口大小(宽，高)，块大小，块滑动增量，胞元大小，梯度方向数
   HOGDescriptor hog = new HOGDescriptor(new Size(64, 128), new Size(16, 16), new Size(8, 8), new Size(8, 8), 9);//行人128
   MatOfFloat descriptorsOfMat = new MatOfFloat();
   hog.compute(src, descriptorsOfMat);//调用计算函数
   float[] descriptor = descriptorsOfMat.toArray();//一列
   descriptors.add(descriptor);
}
}

for (Integer m = 0; m < descriptors.size(); m++) {
for (int n = 0; n < descriptors.get(m).length; n++) {
data_mat.put(m, n, descriptors.get(m)[n]);//按行存储
}
res_mat.put(m, 0, img_label.get(m));//一列向量
}

System.out.println("开始训练。。。。。");
SVM svm = SVM.create();
svm.setType(SVM.C_SVC);
svm.setKernel(SVM.LINEAR);//线性,HogDescriptor检测函数只支持线性检测
svm.setC(0.01);
svm.setGamma(0.5);
svm.setTermCriteria(new TermCriteria(TermCriteria.MAX_ITER, ITERATION_NUM, 1e-6));
svm.train(data_mat, Ml.ROW_SAMPLE, res_mat);

svm.save("E:\\biyesheji\\image\\svm_java");//行人
//svm.save("E:\\biyesheji\\image\\svm_java2");//人脸

System.out.println("保存模型。。");
}catch (Exception e){
System.err.println("read err:" + e);
}
}


   //自定义检测器
   public Mat myDetector()
   {
       System.loadLibrary(Core.NATIVE_LIBRARY_NAME);

       //SVM svm = SVM.load("E:\\biyesheji\\image\\svm_java2");//人脸
       SVM svm = SVM.load("E:\\biyesheji\\image\\svm_java");//行人
       //获取支持向量
       Mat svecsmat = svm.getSupportVectors();
       int numofsv = svecsmat.rows();//支持向量个数
       System.out.println("支持向量个数："+numofsv);
       int svdim = svm.getVarCount();//特征向量维数,即HOG描述子的维数
       System.out.println("特征向量维数："+svdim);

       //初始化alphamat和svindex
       Mat alphaMat = Mat.zeros(1, numofsv, CvType.CV_32F);
       Mat supportVectorMat = Mat.zeros(numofsv, svdim, CvType.CV_32FC1);
       Mat resultMat = Mat.zeros(1, svdim, CvType.CV_32FC1);
       Mat svidx = Mat.zeros(1, numofsv, CvType.CV_32F);
       //获得模型中的rho
       double rho = svm.getDecisionFunction(0, alphaMat, svidx);
       System.out.println("rho:"+rho);
       alphaMat.convertTo(alphaMat, CvType.CV_32F);
       //System.out.println(alphaMat.rows()+","+alphaMat.cols());
       //将支持向量和alpha复制到对应Mat中
       supportVectorMat = svecsmat;
       //alpha*src1*src2 + beta*src3,-1 * alphamat * supportVectorMat,点乘
       Core.gemm(alphaMat, supportVectorMat, -1, new Mat(), 0, resultMat);

       //定义一个大一维的向量，便于后面添加rho
       Mat myDetector = new Mat(1, svdim+1, CvType.CV_32FC1);
       for(int j=0;j<svdim;j++)
       {
           double[] value2 = resultMat.get(0, j);
           myDetector.put(0, j, value2[0]);
       }
       //添加rho
       myDetector.put(0, svdim, rho);
       System.out.println("rho:"+myDetector.get(0, svdim)[0]);

       return myDetector;
       //开始检测

   }
}

2）：预测

public class Svm_predict {
   public void svm_predict() {
       //The winSize should match the dimensions of your training images.
       //In my case I used 32x64 images (for training) and so I needed to use a winSize=(32x64).
       Mat myDetector = new Svm_train().myDetector();
       HOGDescriptor hog = new HOGDescriptor(new Size(64, 128), new Size(16, 16), new Size(8, 8), new Size(8, 8), 9);//行人128
       hog.setSVMDetector(myDetector);

       //String testtxt = "E:\\biyesheji\\image\\traindata_cc2.txt";//人脸
       String testtxt = "E:\\biyesheji\\image\\traindata_cc.txt";//行人
       ArrayList<String> img_path = new ArrayList<String>();


       try {
           BufferedReader br = new BufferedReader(new InputStreamReader(
                   new FileInputStream(new File(testtxt)), "UTF-8"));
           String linetxt = null;
           Integer nline = 0;
           while ((linetxt = br.readLine()) != null) {
               nline++;
               String[] path_label = linetxt.split("\t");
               System.out.println(path_label[0] + ' ');
               img_path.add(path_label[0]);
           }
           br.close();

           for (Integer i = 0; i < img_path.size(); i++) {
               Mat src_test = Imgcodecs.imread(img_path.get(i));// 读取一张图片
               if (src_test.empty()) {
                   throw new Exception("no such picture");
               }

               MatOfRect mor = new MatOfRect(); // 检测完毕后会储存在这里
       MatOfDouble mod = new MatOfDouble();
       // System.out.println("正在检测...");
       /* 参数解读：
       * Mat img 待检测的图像，Mat类型，
       * MatOfRect foundLocations 用于储存检测后的序列（或者叫做矩阵）
       * MatOfDouble foundWeights 检测窗口得分，不清楚是什么东西
       * double hitThreshold 命中阈值，0
       * Size winStride 检测步长，网上大多的步长参数为（8,8），用的是（4,4），原因是（8,8）的步长对于INRIA数据集中的图片不能很好的检测，而（4,4）可以
       * Size padding 这个参数没有过多了解，理解为：block的大小。大多代码推荐（16,16）,这里用（8,8）
       * 常见的pad size 有(8, 8), (16, 16), (24, 24), (32, 32).
       * double scale 比例,1.05,通常scale在1.01-1.5这个区间
       * double finalThreshold 最终阈值,2
       * boolean useMeanshiftGrouping 使用均值移位分组，false的效果比true的好
       * winStride和scale都是比较重要的参数，需要合理的设置。一个合适参数能够大大提升检测精确度，同时也不会使检测时间太长。
       */
       //hog.detectMultiScale(src_test, mor, mod);
       hog.detectMultiScale(src_test, mor, mod, 0, new Size(4, 4), new Size(8, 8), 1.05, 2, false); // 调用方法进行检测
       //System.out.println("检测完毕！画出矩形...");
       if(mor.toArray().length > 0){ //判断是否检测到目标对象，如果有就画矩形，没有就执行下一步
           //找出所有没有嵌套的矩形框r,并放入found_filtered中,如果有嵌套的话,则取外面最大的那个矩形框放入found_filtered中
           Rect[] found = mor.toArray();
           List<Rect> found_filtered = new ArrayList<Rect>();
           //先判断是否有嵌套
           for(int m=0;m<found.length;m++)
           {
               Rect r = found[m];
               int area = r.width*r.height;
               //System.out.println(r.x+","+r.y+";"+r.width+","+r.height);
               int n=0;
               for(;n<found.length;n++)
               {
                   if(n!=m && getOverLappingArea(r, found[n])==area)//且found[n]在r内
                       break;
               }
               if(n==found.length)
               {
                   found_filtered.add(r);
               }
           }

           for(int j=0;j<found_filtered.size();j++)
           {
               Rect r = found_filtered.get(j);
               Imgproc.rectangle(src_test, new Point(r.x, r.y), new Point(r.x + r.width, r.y + r.height),new Scalar(0, 0, 255), 2);
           }

       System.out.println("矩形绘制完毕！正在输出...");
       }else{
       System.out.println("未检测到目标！绘制矩形失败！输出原文件！");
       }
                   // 获取图片名
                   String fname = img_path.get(i).trim();
                   String fileName = fname
                           .substring(fname.lastIndexOf("\\") + 1);
                   String filename = "E:\\biyesheji\\image\\detectImage\\"
                           + fileName;//行人
                   //String filename = "E:\\biyesheji\\image\\facedetectImage\\"
                           //+ fileName;//人脸

                   System.out.println(String.format("Writing %s", filename));
                   Imgcodecs.imwrite(filename, src_test);
           }

       } catch (Exception e) {
           System.err.println("read err:" + e);
       }
   }
   /**
   * 判断两个矩形的重叠面积
   * @param a
   * @param b
   * @return
   */
   public int getOverLappingArea(Rect a,Rect b)
{
int overLappingArea = 0;

int startX = Math.min(a.x,b.x);
int endX = Math.max(a.x + a.width, b.x + b.width);
int overLappingWidth = a.width + b.width - (endX - startX);

int startY = Math.min(a.y, b.y);
int endY = Math.max(a.y + a.height, b.y + b.height);
int overLappingHeight = a.height + b.height - (endY - startY);

if(overLappingWidth <= 0 || overLappingHeight <= 0)
{
overLappingArea = 0;
}
else
{
overLappingArea = overLappingWidth * overLappingHeight;
}
return overLappingArea;

}