記一次Java獲取本地攝像頭（基于OpenCV）-有解無憂

OpenCV官網下載地址(下載安裝后，在安裝目錄可以找到元件和OpenCv.jar)

https://opencv.org/releases/

安裝完成后，這是我的安裝目錄

maven 依賴（這個是安裝完成后我把jar放到maven本地倉庫中，然后在maven中就可以直接參考了）

　　　　　　　　　 <!-- opencv依賴 -->
		<dependency>
			<groupId>org.opencv</groupId>
			<artifactId>opencv</artifactId>
			<version>440</version>
		</dependency>

1.配置OpenCV環境

新建本地依賴

自己定義依賴庫的名稱

選擇元件dll檔案的目錄

選擇OpenCV的安裝目錄

這個是根據你的JDK來選擇，如果你的JDK是64位的就選擇x64

2.攝像頭獲取類

package com.crow.safeBoxHardware;

import java.awt.FlowLayout;
import java.awt.event.WindowEvent;
import java.awt.event.WindowListener;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;

import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.WindowConstants;

import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.core.MatOfRect;
import org.opencv.core.Rect;
import org.opencv.core.Size;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;
import org.opencv.objdetect.CascadeClassifier;
import org.opencv.videoio.VideoCapture;
import org.opencv.videoio.Videoio;
import org.springframework.core.io.ClassPathResource;
import org.springframework.stereotype.Component;

import com.crow.safeBoxHardware.components.exception.BizErrorCode;
import com.crow.safeBoxHardware.components.exception.BizException;
import com.crow.safeBoxHardware.util.FileUtil;

import lombok.extern.log4j.Log4j2;

@Log4j2
@Component
public class Test2 {

    // 從組態檔lbpcascade_frontalface.xml中創建一個人臉識別器，該檔案位于opencv安裝目錄中
    private CascadeClassifier faceDetector;

    // 從組態檔lbpcascade_frontalface.xml中創建一個人眼識別器，該檔案位于opencv安裝目錄中
    private CascadeClassifier eyeDetector;

    private JFrame cameraFrame;

    public CamarePanel panelCamera;

    // 是否打開攝像頭
    private boolean open = false;

    // 相機
    public VideoCapture capture;

    // 人臉影像
    public Mat faceMat;

    // 攝像頭讀取的幀
    public Mat capImg;

    public Test2() {
        // 初始化人臉檢測器
//        faceDetector = new CascadeClassifier(
//                "C:\\worksplace\\safeBoxHardware\\src\\main\\resources\\native\\face\\xml\\haarcascade_frontalface_alt.xml");
//
//        eyeDetector = new CascadeClassifier(
//                "C:\\worksplace\\safeBoxHardware\\src\\main\\resources\\native\\face\\xml\\haarcascade_eye.xml");

        capture = new VideoCapture();
    }

    /**
     * 打開攝像頭
     * 
     * @param x
     * @param y
     */
    public void open(int x, int y) {

        capImg = new Mat();

        faceMat = new Mat();

        cameraFrame = new JFrame("camare");

        panelCamera = new CamarePanel();

        // 打開相機
        capture.open(0);

        boolean grab = capture.grab();

        if (!grab) {
            throw new BizException(BizErrorCode.CAMARE_OPEN_ERROE);
        }

        // 打開攝像頭
        open = true;

        // 設定解析度
        capture.set(Videoio.CAP_PROP_FRAME_WIDTH, 1280);
        capture.set(Videoio.CAP_PROP_FRAME_HEIGHT, 720);
        // 設定幀率
        capture.set(Videoio.CAP_PROP_FPS, 30);

        // 添加到Frame
        cameraFrame.setContentPane(panelCamera);

        // 設定去掉邊框
        cameraFrame.setUndecorated(true);

        // 是否顯示視窗
        cameraFrame.setVisible(true);

        // 設定在最頂層
        cameraFrame.setAlwaysOnTop(true);

        // 設定關閉
        cameraFrame.setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);

        // 視窗關閉事件
        cameraFrame.addWindowListener(new WindowListener() {

            @Override
            public void windowOpened(WindowEvent e) {

            }

            @Override
            public void windowIconified(WindowEvent e) {

            }

            @Override
            public void windowDeiconified(WindowEvent e) {

            }

            @Override
            public void windowDeactivated(WindowEvent e) {

            }

            @Override
            public void windowClosing(WindowEvent e) {
                close();
            }

            @Override
            public void windowClosed(WindowEvent e) {

            }

            @Override
            public void windowActivated(WindowEvent e) {

            }
        });

        // 設定位置
        if (x > 0 && y > 0) {
            cameraFrame.setBounds(x, y, 400, 600);
        } else {
            // 設定大小
            cameraFrame.setSize(400, 600);
            // 居中顯示
            cameraFrame.setLocationRelativeTo(null);
        }

        while (open) {
            capture.read(capImg);
            if (!capImg.empty()) {
                // 轉換成BufferImage并繪制到Panel
                panelCamera.setImageWithMat(capImg);
                // 重新繪制
                cameraFrame.repaint();
                
                //檢測人臉并保存
                //detectFace(capImg, "C:\\Users\\Crow\\Desktop\\"+System.currentTimeMillis()+".png");
            }
        }
        log.info("相機已關閉......");
    }

    /**
     * 關閉視窗和攝像頭釋放資源
     */
    public void close() {
        // 關倍訓圈
        open = false;

        if (cameraFrame != null) {
            // 關閉視窗
            cameraFrame.dispose();
            cameraFrame = null;
        }

        if (panelCamera != null) {
            // 清空
            panelCamera = null;
        }

        if (capture != null && capture.isOpened()) {
            // 關閉視頻檔案或捕獲設備,并釋放資源
            capture.release();
        }

        log.warn("關閉相機...........................");
    }

    /**
     * 檢測人臉，并保存
     * 
     * @param videoMat
     * @param savePath
     * @return
     */
    public Mat detectFace(Mat videoMat, String savePath) {

        File file = new File(savePath);

        // 驗證父目錄是否存在，不存在則新建
        if (!file.getParentFile().exists()) {
            file.getParentFile().mkdirs();
        }

        // 創建用來裝檢測出來的人臉的容器
        MatOfRect faces = new MatOfRect();
        // 檢測人臉，videoMat為要檢測的圖片，faces用來存放檢測結果
        faceDetector.detectMultiScale(videoMat, faces);
        Rect[] facesArray = faces.toArray();

        // 創建用來裝檢測出來的人眼的容器
        MatOfRect eyes = new MatOfRect();
        // 檢測人眼，videoMat為要檢測的圖片，faces用來存放檢測結果
        eyeDetector.detectMultiScale(videoMat, eyes);
        Rect[] eyesArray = eyes.toArray();

        if (facesArray.length > 0 && eyesArray.length > 0) {
            for (int i = 0; i < facesArray.length; i++) {
                Rect rect = facesArray[i];
                // 只獲取人臉行和人臉列
                Mat faceImage = videoMat.rowRange(rect.y, rect.y + rect.height).colRange(rect.x, rect.x + rect.width);

                // 設定大小
                Size size = new Size(400, 600);
                // 調整影像
                Imgproc.resize(faceImage, faceMat, size);
                // 保存
                Imgcodecs.imwrite(savePath, faceMat);
            }
        }
        return faceMat;
    }

    public boolean isOpen() {
        return open;
    }

    public void setOpen(boolean open) {
        this.open = open;
    }

    public CamarePanel getPanelCamera() {
        return panelCamera;
    }

    public Mat getFaceMat() {
        return faceMat;
    }

    public static void main(String[] args) {
        //加載opencv元件
        System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
        //打開攝像頭，并設定位置
        new Test2().open(298, 81);
    }

}

3.影像顯示Panel容器

package com.crow.safeBoxHardware.components.hardware.camare;

import java.awt.Graphics;
import java.awt.GraphicsConfiguration;
import java.awt.GraphicsDevice;
import java.awt.GraphicsEnvironment;
import java.awt.HeadlessException;
import java.awt.Image;
import java.awt.Transparency;
import java.awt.image.BufferedImage;

import javax.swing.ImageIcon;
import javax.swing.JPanel;
import org.opencv.core.Mat;

/**
 * <p>
 * 用于在面板上顯示和拍攝
 * </p>
 * 
 * @author Crow
 * @version 0.0.1
 * @since 2020-9-158:54:36
 */
public class CamarePanel extends JPanel {
    private static final long serialVersionUID = 1L;
    
    //攝像頭獲取的原始影像
    private BufferedImage image;
    
    //裁剪修正后的影像
    private BufferedImage updateImage;

    public CamarePanel() {
        super();
    }

    private BufferedImage getimage() {
        return image;
    }

    /**
     * 裁剪修正后的影像
     * @return
     */
    public BufferedImage getUpdateImage() {
        return updateImage;
    }

    public void setUpdateImage(BufferedImage updateImage) {
        this.updateImage = updateImage;
    }

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

    public void setImageWithMat(Mat newimage) {
        image = this.ConvertImage(newimage);
        return;
    }

    /*
     * 將物件轉換為BufferedImage，以在幀內顯示它
     */
    public BufferedImage ConvertImage(Mat matrix) {
        // 列和緩沖區影像物件的物件大小
        int cols = matrix.cols();
        int rows = matrix.rows();
        int elemSize = (int) matrix.elemSize();
        byte[] data = https://www.cnblogs.com/crow9527/archive/2020/09/24/new byte[cols * rows * elemSize];
        int type;
        matrix.get(0, 0, data);
        // 在顏色空間中顯示物件的通道數，
        switch (matrix.channels()) {
        // 單通道使用灰色矩陣
        case 1:
            type = BufferedImage.TYPE_BYTE_GRAY;
            break;
        // 如果有3個通道
        case 3:
            type = BufferedImage.TYPE_3BYTE_BGR;
            /*
             * 由于 opencv 將 rgb 顏色空間保留為 bgr， 因此我們將它轉換為 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 bufferedImage = new BufferedImage(cols, rows, type);
        bufferedImage.getRaster().setDataElements(0, 0, cols, rows, data);
        return bufferedImage;
    }

    @Override
    protected void paintComponent(Graphics g) {
        super.paintComponent(g);

        BufferedImage temp = getimage();

        if (temp != null) {
            // 縮放
            Image scaledInstance = temp.getScaledInstance(1000, 600, Image.SCALE_SMOOTH);
            // 轉換
            updateImage = toBufferedImage(scaledInstance);
            // 裁剪
            updateImage = updateImage.getSubimage(300, 0, 400, 600);
            // 繪制
            g.drawImage(updateImage, 0, 0, 400, 600, this);
            
　　　　　　　//g.drawImage(temp, 0, 0, 1280, 720, this);
        }
    }

    /**
     * 將image物件 轉成 BufferedImage
     *
     * @param image
     * @return
     */
    private BufferedImage toBufferedImage(Image image) {
        if (image instanceof BufferedImage) {
            return (BufferedImage) image;
        }
        image = new ImageIcon(image).getImage();
        BufferedImage bimage = null;
        GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
        try {
            int transparency = Transparency.OPAQUE;
            GraphicsDevice gs = ge.getDefaultScreenDevice();
            GraphicsConfiguration gc = gs.getDefaultConfiguration();
            bimage = gc.createCompatibleImage(image.getWidth(null), image.getHeight(null), transparency);
        } catch (HeadlessException e) {

        }

        if (bimage == null) {
            int type = BufferedImage.TYPE_INT_RGB;
            bimage = new BufferedImage(image.getWidth(null), image.getHeight(null), type);
        }
        Graphics g = bimage.createGraphics();

        g.drawImage(image, 0, 0, null);
        g.dispose();

        return bimage;

    }

}

攝像頭像素較差（百度的度目攝像頭）
效果圖(本人就不上鏡了)

OK，搞定

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/119180.html

標籤：其他

上一篇：linux 下java 呼叫 mono 生成的dll 問題

下一篇：2020更新版 Spring Boot雙版本(1.52.1) 打造企業級微信點餐系統