java+opencv 얼굴 인식 기능 구현

배경:최근 에 얼굴 인식 이 필요 하지만 돈 을 쓰 지 않 고 기 존의 제3자 얼굴 인식 인 터 페 이 스 를 사용 합 니 다.이 를 위해 opencv 를 자바 와 결합 하여 얼굴 인식 을 합 니 다(ps:opencv 는 오픈 소스 입 니 다.이 를 사용 하여 얼굴 인식 에 어느 정도 오차 가 있 고 효과 가 보통 입 니 다).
1.opencv 설치
홈 페이지 주소:https://opencv.org/홈 페이지 다운로드 속도 가 정말 느 리 기 때 문 입 니 다.
바 이 두 네트워크:
링크:https://pan.baidu.com/s/1RpsP-I7v8pP2dkqALDw7FQ
추출 코드:pq7v
홈 페이지 다운로드 라면 뇌 없 이 설치 하면 됩 니 다.설치 가 끝나 면.
그림 1 의 두 파일 을 그림 2 에 복사 합 니 다.


내 네트워크 에서 다운로드 한 것 은 이것 을 무시 합 니 다.
2.프로젝트 에 pom 의존 도입

<!-- opencv + javacv + ffmpeg-->
        <dependency>
            <groupId>org.bytedeco.javacpp-presets</groupId>
            <artifactId>ffmpeg</artifactId>
            <version>4.1-1.4.4</version>
        </dependency>
        <dependency>
            <groupId>org.bytedeco</groupId>
            <artifactId>javacv</artifactId>
            <version>1.4.4</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.bytedeco.javacpp-presets/ffmpeg-platform -->
        <dependency>
            <groupId>org.bytedeco.javacpp-presets</groupId>
            <artifactId>ffmpeg-platform</artifactId>
            <version>4.1-1.4.4</version>
        </dependency>

        <!--       -->
        <!-- https://mvnrepository.com/artifact/org.bytedeco/javacv-platform -->
        <dependency>
            <groupId>org.bytedeco</groupId>
            <artifactId>javacv-platform</artifactId>
            <version>1.4.4</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.bytedeco.javacpp-presets/opencv-platform -->
        <dependency>
            <groupId>org.bytedeco.javacpp-presets</groupId>
            <artifactId>opencv-platform</artifactId>
            <version>4.0.1-1.4.4</version>
        </dependency>

1.라 이브 러 리 의존 도 가 져 오기
File-->Project Structure,Modules 를 누 르 고 opencv.jar 를 사용 해 야 할 항목 을 선택 하 십시오.


직접 opencv 설치 경 로 를 선택 하 십시오.


2.자바 코드 데모

package org.Litluecat.utils;

import org.apache.commons.lang.StringUtils;
import org.opencv.core.*;
import org.opencv.highgui.HighGui;
import org.opencv.highgui.ImageWindow;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;
import org.opencv.objdetect.CascadeClassifier;
import org.opencv.videoio.VideoCapture;
import org.opencv.videoio.VideoWriter;
import org.opencv.videoio.Videoio;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.Arrays;

/**
 *        
 * @author Litluecat
 * @Title: Opencv       、         
**/
public class FaceVideo {

    private static final Logger log = LoggerFactory.getLogger(FaceVideo.class);

    private static final String endImgUrl = "C:\\Users\\lenovo\\Desktop\\";
    /**
     * opencv     xml    
     */
    private static final String faceDetectorXML2URL = "D:\\Sofeware\\opencv\\sources\\data\\haarcascades\\haarcascade_frontalface_alt.xml";
    /**
     * opencv     xml    
     */
    private static final String eyeDetectorXML2URL = "D:\\Sofeware\\opencv\\sources\\data\\haarcascades\\haarcascade_eye.xml";
    /**
     *      ，      ，    
     */
    private static int Matching_Accuracy = 100000;
    /**
     *         
     */
    private static CascadeClassifier faceDetector;
    /**
     *         
     */
    private static CascadeClassifier eyeDetector;

    private static int i=0;

    static {
        System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
        faceDetector = new CascadeClassifier(faceDetectorXML2URL);
        eyeDetector = new CascadeClassifier(eyeDetectorXML2URL);
    }

    public static void main(String[] args) {
        log.info("      ");
        long begin = System.currentTimeMillis();
        // 1-           ，           
        try{
            getVideoFromCamera(endImgUrl + "2.jpg");
            //        ，    GUI  
            Thread.sleep(1000);
            int err = 1/0;
     
            // 2-     2         （   1   ）
//            double compareHist = FaceVideo.compare_image(endImgUrl + "test1.jpg" , endImgUrl + "face.jpg");
//            log.info("   ：{}",compareHist);
//            if (compareHist > 0.72) {
//                log.info("    ");
//            } else {
//                log.info("     ");
//            }

        }catch (Exception e){
            log.info("      ");
            log.info("      ，   ：{}ms",(System.currentTimeMillis()-begin));
            System.exit(0);
        }
    }


    /**
     * OpenCV-4.1.1         
     * @param targetImgUrl        
     * @return: void
     * @date: 2019 8 19  17:20:13
     */
    public static void getVideoFromCamera(String targetImgUrl) {
        //1                 VideoCapture        0
        VideoCapture capture = new VideoCapture(0);
        Mat video = new Mat();
        int index = 0;
        if (capture.isOpened()) {
            while(i<3) {
                //     3   
                capture.read(video);
                HighGui.imshow("      ", getFace(video, targetImgUrl));
                //      100ms，      
                index = HighGui.waitKey(100);
                //      Esc ，    
                if (index == 27) {
                    break;
                }
            }
        }else{
            log.info("      ");
        }
        //        ，       
        HighGui.destroyAllWindows();
        capture.release();
        return;
    }

    /**
     * OpenCV-4.1.0     
     * @param image    Mat  (       )
     * @param targetImgUrl          
     * @return       
     */
    public static Mat getFace(Mat image, String targetImgUrl) {
        MatOfRect face = new MatOfRect();
        faceDetector.detectMultiScale(image, face);
        Rect[] rects=face.toArray();
        log.info("    "+rects.length+"    ");
        if(rects != null && rects.length >= 1) {
            i++;
            if(i==3) {
                //        3    
                Imgcodecs.imwrite(endImgUrl + "face.jpg", image);
                FaceVideoThread faceVideoThread = new FaceVideoThread(targetImgUrl , endImgUrl + "face.jpg");
                new Thread(faceVideoThread,"      ").start();
            }
        }
        return image;
    }

    /**
     *     
     * @param img
     * @return
     */
    public static String face2Img(String img) {
        String faceImg = null;
        Mat image0 = Imgcodecs.imread(img);
        Mat image1 = new Mat();
        //    
        Imgproc.cvtColor(image0, image1, Imgproc.COLOR_BGR2GRAY);
        //     
        MatOfRect faceDetections = new MatOfRect();
        faceDetector.detectMultiScale(image1, faceDetections);
        // rect        
        for (Rect rect : faceDetections.toArray()) {
            faceImg = img+"_.jpg";
            //       
            imageCut(img, faceImg, rect.x, rect.y, rect.width, rect.height);
        }
        if(null == faceImg){
            log.info("face2Img           ，img={}",img);
        }
        return faceImg;
    }

    /**
     *     
     * @param img_1
     * @param img_2
     * @return
     */
    public static double compare_image(String img_1, String img_2) {
        Mat mat_1 = conv_Mat(img_1);
        Mat mat_2 = conv_Mat(img_2);
        Mat hist_1 = new Mat();
        Mat hist_2 = new Mat();

        //    
        MatOfFloat ranges = new MatOfFloat(0f, 256f);
        //     ，         (  )
        MatOfInt histSize = new MatOfInt(Matching_Accuracy);

        Imgproc.calcHist(Arrays.asList(mat_1), new MatOfInt(0), new Mat(), hist_1, histSize, ranges);
        Imgproc.calcHist(Arrays.asList(mat_2), new MatOfInt(0), new Mat(), hist_2, histSize, ranges);

        // CORREL     
        double res = Imgproc.compareHist(hist_1, hist_2, Imgproc.CV_COMP_CORREL);
        return res;
    }

    /**
     *      
     * @param img
     * @return
     */
    public static Mat conv_Mat(String img) {
        if(StringUtils.isBlank(img)){
            return null;
        }
        Mat image0 = Imgcodecs.imread(img);
        Mat image1 = new Mat();
        //Mat image2 = new Mat();
        //    
        Imgproc.cvtColor(image0, image1, Imgproc.COLOR_BGR2GRAY);
        //    
        //Imgproc.equalizeHist(image1, image2);

        //     
        MatOfRect faceDetections = new MatOfRect();
        faceDetector.detectMultiScale(image1, faceDetections);

        //    
//        MatOfRect eyeDetections = new MatOfRect();
//        eyeDetector.detectMultiScale(image1, eyeDetections);

        // rect        
        Mat face = null;
        for (Rect rect : faceDetections.toArray()) {

            //          1      2      3                
            //Imgproc.rectangle(image0,rect,new Scalar(0,0,255),2);
            //    
            //Imgcodecs.imwrite(img+"_.jpg",image0);

            face = new Mat(image1, rect);
        }
        if(null == face){
            log.info("conv_Mat           ，img={}",img);
        }
        return face;
    }

}

이쪽 의 얼굴 인식 은 다른 라인 을 비교 한 것 으로 코드 는 다음 과 같다.

package org.Litluecat.utils;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;


public class FaceVideoThread implements Runnable{
    private static final Logger log = LoggerFactory.getLogger(FaceVideoThread.class);

    private String oneImgUrl = null;
    private String otherImgUrl = null;
    public FaceVideoThread(String oneImgUrl, String otherImgUrl){
        this.oneImgUrl = oneImgUrl;
        this.otherImgUrl = otherImgUrl;
    }
    @Override
    public void run() {
        try {
            double compareHist = FaceVideo.compare_image(oneImgUrl , otherImgUrl);
            log.info("   ：{}",compareHist);
            if (compareHist > 0.72) {
                log.info("    ");
            } else {
                log.info("     ");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

알림:이상 이 실행 되면 opencv 의 설치 주 소 를 추가 하 십시오.-Djava.library.path=D:\Sofeware\\opencv\build\java\x64;

결론:자바+opencv 가 얼굴 인식 을 하 는 정밀도 가 부족 합 니 다.저도 배 워 야 합 니 다.여러분 이 더 좋 은 방식 이 있다 면 opencv 를 더욱 잘 보 여 주 고 더욱 정확 한 얼굴 인식 에 이 를 수 있 습 니 다.저 에 게 공유 해 주 십시오.감사합니다.
자바+opencv 의 얼굴 인식 실현 에 관 한 이 글 은 여기까지 소개 되 었 습 니 다.더 많은 자바 opencv 의 얼굴 인식 내용 은 우리 의 이전 글 을 검색 하거나 아래 의 관련 글 을 계속 조회 하 시기 바 랍 니 다.앞으로 많은 응원 바 랍 니 다!