android 使用摄像头测量心率

在Android上使用摄像头测量心率需要使用图像处理技术。这里提供一种基于颜色变化的心率测量方法，步骤如下：

1. 打开摄像头并实时获取预览图像；

2. 将预览图像转换为RGB颜色空间；

3. 将RGB颜色空间转换为YCrCb颜色空间，并提取出亮度分量Y；

4. 对亮度分量Y进行高斯滤波，去除图像中的噪声；

5. 计算每一帧图像中的亮度分量Y的平均值，并将其保存为一个时间序列；

6. 对时间序列进行傅里叶变换，得到频谱图；

7. 从频谱图中找到最大的峰值，对应的频率就是心率。

以下是一个基于这种方法的示例代码：

public class HeartRateMonitorActivity extends AppCompatActivity implements Camera.PreviewCallback {

    private Camera camera;
    private int width, height;
    private int[] pixels;
    private int[] grayValues;
    private double[] yValues;
    private int samplingRate = 30;
    private int[] heartRates;
    private TextView tvHeartRate;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_heart_rate_monitor);

        tvHeartRate = findViewById(R.id.tv_heart_rate);

        // 打开摄像头并设置预览回调
        camera = Camera.open();
        Camera.Parameters parameters = camera.getParameters();
        List<Camera.Size> sizes = parameters.getSupportedPreviewSizes();
        Camera.Size size = sizes.get(0);
        width = size.width;
        height = size.height;
        pixels = new int[width * height];
        grayValues = new int[width * height];
        yValues = new double[width * height];
        camera.setPreviewCallback(this);
        camera.setDisplayOrientation(90);
        camera.startPreview();
    }

    @Override
    public void onPreviewFrame(byte[] data, Camera camera) {
        // 将预览图像转换为RGB颜色空间
        YuvImage yuvImage = new YuvImage(data, ImageFormat.NV21, width, height, null);
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        yuvImage.compressToJpeg(new Rect(0, 0, width, height), 100, baos);
        byte[] imageData = baos.toByteArray();
        Bitmap bitmap = BitmapFactory.decodeByteArray(imageData, 0, imageData.length);
        bitmap.getPixels(pixels, 0, width, 0, 0, width, height);
        for (int i = 0; i < pixels.length; i++) {
            int r = (pixels[i] >> 16) & 0xff;
            int g = (pixels[i] >> 8) & 0xff;
            int b = pixels[i] & 0xff;
            grayValues[i] = (int) (0.299 * r + 0.587 * g + 0.114 * b);
        }
        // 将RGB颜色空间转换为YCrCb颜色空间，并提取出亮度分量Y
        for (int i = 0; i < grayValues.length; i++) {
            int r = (pixels[i] >> 16) & 0xff;
            int g = (pixels[i] >> 8) & 0xff;
            int b = pixels[i] & 0xff;
            yValues[i] = (0.299 * r + 0.587 * g + 0.114 * b) / 255.0;
        }
        // 对亮度分量Y进行高斯滤波
        yValues = gaussianFilter(yValues, 5);
        // 计算每一帧图像中的亮度分量Y的平均值，并将其保存为一个时间序列
        double yMean = 0;
        for (int i = 0; i < yValues.length; i++) {
            yMean += yValues[i];
        }
        yMean /= yValues.length;
        double[] timeSeries = new double[samplingRate];
        for (int i = 0; i < samplingRate; i++) {
            timeSeries[i] = yMean;
        }
        // 对时间序列进行傅里叶变换，得到频谱图
        double[] spectrum = FFT.fft(timeSeries);
        // 从频谱图中找到最大的峰值，对应的频率就是心率
        int heartRate = findPeak(spectrum, 0.8, samplingRate);
        if (heartRate > 0) {
            heartRates[heartRate % heartRates.length] = heartRate;
            int averageHeartRate = 0;
            for (int i = 0; i < heartRates.length; i++) {
                averageHeartRate += heartRates[i];
            }
            averageHeartRate /= heartRates.length;
            tvHeartRate.setText("Heart rate: " + averageHeartRate);
        }
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        camera.setPreviewCallback(null);
        camera.stopPreview();
        camera.release();
    }

    // 高斯滤波
    private double[] gaussianFilter(double[] data, int windowSize) {
        double[] result = new double[data.length];
        double[] window = new double[windowSize];
        double sigma = windowSize / 6.0;
        for (int i = 0; i < windowSize; i++) {
            window[i] = Math.exp(-(i - windowSize / 2) * (i - windowSize / 2) / (2 * sigma * sigma));
        }
        double sum = 0;
        for (int i = 0; i < windowSize; i++) {
            sum += window[i];
        }
        for (int i = 0; i < data.length; i++) {
            double weightedSum = 0;
            for (int j = 0; j < windowSize; j++) {
                int index = i - windowSize / 2 + j;
                if (index < 0) {
                    index = 0;
                }
                if (index >= data.length) {
                    index = data.length - 1;
                }
                weightedSum += window[j] * data[index];
            }
            result[i] = weightedSum / sum;
        }
        return result;
    }

    // 从频谱图中找到最大的峰值，对应的频率就是心率
    private int findPeak(double[] spectrum, double threshold, int samplingRate) {
        int maxIndex = -1;
        double maxValue = 0;
        for (int i = 0; i < spectrum.length / 2; i++) {
            if (spectrum[i] > maxValue) {
                maxValue = spectrum[i];
                maxIndex = i;
            }
        }
        if (maxValue > threshold * spectrum[0]) {
            return maxIndex * samplingRate / spectrum.length;
        } else {
            return -1;
        }
    }
}

这种方法的精度不如专业的心率测量设备，但可以提供一个相对准确的心率测量结果。