Java 如何使用opencv检测颈部、手腕和耳朵？

我是一个新使用opencv来检测身体不同部位的人，比如耳朵、脖子、手腕、脸等等

面部和耳朵可以通过摄像头检测到，但我需要检测身体的其余部分

如何检测它们

我尝试了所有给定的haarcascade_XXX.xml文件，但我找不到任何haarcascade_neck.xml或haarcascade_手腕.xml文件，尽管我可以检测到它们

我不知道该怎么办请帮帮我

---

提前感谢…

我已经试过了，在这里，OpenCV能够检测眼睛，并尝试将对象放置在检测到的位置

但这还不够我还要检测脖子和手腕

import java.awt.Graphics;
import java.awt.Image;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;

import javax.imageio.ImageIO;
import javax.swing.ImageIcon;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;

import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.core.MatOfRect;
import org.opencv.core.Point;
import org.opencv.core.Rect;
import org.opencv.highgui.VideoCapture;
import org.opencv.imgproc.Imgproc;
import org.opencv.objdetect.CascadeClassifier;

class My_Panel extends JPanel {
private static final long serialVersionUID = 1L;
private BufferedImage image;
private CascadeClassifier face_cascade;
private Point center;
private JLabel label;

public My_Panel() {
    super();


    Image scalledItemImage = null;
    try {
        scalledItemImage = ImageIO.read(new File("5.png"));
        scalledItemImage= scalledItemImage.getScaledInstance(100,100,Image.SCALE_FAST);
    } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
    label = new JLabel(new ImageIcon(scalledItemImage ));
    add(label);
    face_cascade = new CascadeClassifier(
            "haarcascade_mcs_eyepair_big.xml");
    if (face_cascade.empty()) {
        System.out.println("--(!)Error loading A\n");
        return;
    } else {
        System.out.println("Face classifier loooaaaaaded up");
    }
}

private BufferedImage getimage() {

    return image;
}

public void setimage(BufferedImage newimage) {
    image = newimage;
    return;
}

public BufferedImage matToBufferedImage(Mat matrix) {
    int cols = matrix.cols();
    int rows = matrix.rows();
    int elemSize = (int) matrix.elemSize();
    byte[] data = new byte[cols * rows * elemSize];
    int type;
    matrix.get(0, 0, data);
    switch (matrix.channels()) {
    case 1:
        type = BufferedImage.TYPE_BYTE_GRAY;
        break;
    case 3:
        type = BufferedImage.TYPE_3BYTE_BGR;
        // bgr to rgb
        byte b;
        for (int i = 0; i < data.length; i = i + 3) {
            b = data[i];
            data[i] = data[i + 2];
            data[i + 2] = b;
        }
        break;
    default:
        return null;
    }
    BufferedImage image2 = new BufferedImage(cols, rows, type);
    image2.getRaster().setDataElements(0, 0, cols, rows, data);
    return image2;
}

public void paintComponent(Graphics g) {
    BufferedImage temp = getimage();
    g.drawImage(temp, 10, 10, temp.getWidth(), temp.getHeight(), this);
}

public Mat detect(Mat inputframe) {
    Mat mRgba = new Mat();
    Mat mGrey = new Mat();
    MatOfRect faces = new MatOfRect();
    inputframe.copyTo(mRgba);
    inputframe.copyTo(mGrey);
    Imgproc.cvtColor(mRgba, mGrey, Imgproc.COLOR_BGR2GRAY);
    Imgproc.equalizeHist(mGrey, mGrey);
    face_cascade.detectMultiScale(mGrey, faces);
    System.out.println(String.format("Detected %s faces",
            faces.toArray().length));
    for (Rect rect : faces.toArray()) {
        center = new Point(rect.x + rect.width * 0.5, rect.y + rect.height
                * 0.5);
        // Core.ellipse(mRgba, center, new Size(rect.width * 0.5,
        // rect.height * 0.5), 0, 0, 360, new Scalar(255, 0, 255), 4,
        // 8, 0);
        // Core.rectangle(mRgba, center, new Point(rect.width * 0.5,
        // rect.height * 0.5), new Scalar(25, 0, 25),2);
        label.setLocation((int) center.x, (int) center.y);

        setVisible(true);
        repaint();
    }
    return mRgba;
}
}

public class MyWindow {
public static void main(String arg[]) {
    // Load the native library.
    BufferedImage temp;
    System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
    String window_name = "Capture - Face detection";
    JFrame frame = new JFrame(window_name);
    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    frame.setSize(400, 400);
    My_Panel my_panel = new My_Panel();
    frame.setContentPane(my_panel);
    frame.setVisible(true);

    Mat webcam_image = new Mat();
    VideoCapture capture = new VideoCapture(0);
    if (capture.isOpened()) {
        while (true) {
            capture.read(webcam_image);

            if (!webcam_image.empty()) {
                frame.setSize(webcam_image.width() + 40,
                        webcam_image.height() + 60);
                webcam_image = my_panel.detect(webcam_image);
                temp = my_panel.matToBufferedImage(webcam_image);
                my_panel.setimage(temp);
                my_panel.repaint();
            } else {
                System.out.println(" --(!) No captured frame -- Break!");
                break;
            }
        }
    }
    return;
}
}

导入java.awt.Graphics；
导入java.awt.Image；
导入java.awt.image.buffereImage；
导入java.io.File；
导入java.io.IOException；
导入javax.imageio.imageio；
导入javax.swing.ImageIcon；
导入javax.swing.JFrame；
导入javax.swing.JLabel；
导入javax.swing.JPanel；
导入org.opencv.core.core；
导入org.opencv.core.Mat；
导入org.opencv.core.MatOfRect；
导入org.opencv.core.Point；
导入org.opencv.core.Rect；
导入org.opencv.highgui.VideoCapture；
导入org.opencv.imgproc.imgproc；
导入org.opencv.objdetect.CascadeClassifier；
类My_面板扩展了JPanel{
私有静态最终长serialVersionUID=1L；
私有缓冲图像；
私有级联；
私人点中心；
私人标签；
公共My_面板（）{
超级（）；
Image scalledItemImage=null；
试一试{
scalledItemImage=ImageIO.read（新文件（“5.png”）；
scalledItemImage=scalledItemImage.getScaledInstance（100100，Image.SCALE\u FAST）；
}捕获（IOE异常）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}
标签=新JLabel（新图像图标（scalledItemImage））；
添加（标签）；
面_级联=新级联分类器(
“haarcascade_mcs_eyepair_big.xml”）；
if（面_cascade.empty（））{
System.out.println（“-（！）加载错误\n”）；
返回；
}否则{
System.out.println（“面分类器LoooaaaadUp”）；
}
}
私有缓冲区映像getimage（）{
返回图像；
}
public void setimage（BufferedImage newimage）{
图像=新图像；
返回；
}
公共缓冲区映像MATTOBUFFERIDIMAGE（Mat矩阵）{
int cols=matrix.cols（）；
int rows=matrix.rows（）；
int elemSize=（int）matrix.elemSize（）；
字节[]数据=新字节[cols*行*elemSize]；
int型；
得到（0，0，数据）；
开关（matrix.channels（））{
案例1：
type=buffereImage.type\u BYTE\u GRAY；
打破
案例3：
type=buffereImage.type\u 3BYTE\u BGR；
//bgr到rgb
字节b；
对于（int i=0；i

我也遇到了类似的问题..尝试了很多方法，但仍然不准确。 我尝试过的解决方案 1> 从ASM检测器（使用MUCT数据库）中获取下巴点以检测下巴点，通过生物特征计算，只需将从脸的Haarcascade检测到的矩形的半高相加即可。 2> 训练你自己的ASM进行颈部检测。你需要收集图像样本并进行训练。使用Haarcasade进行上半身检测。有很多教程可用于训练ASM

但我要提醒你们两个都是近似的解决方案，在大多数情况下都可能失败。

嗨，不是那个原因