JAVA实现频谱分析_fastfouriertransformer fft = new fastfouriertransf

package com.runlion.fourier.demo.waveform;

import java.awt.*;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

import javax.swing.*;

/**
 * 波形图绘制 情景分析： 数据从socket接收，一个包200数据，根据给的数据绘制波形图
 *
 * @author fanyuanhang
 * @date 2020年05月28日 13:44:24
 */
public class DrawWaveForm extends JPanel {

    private static final long serialVersionUID = 8893226355968026163L;

    public static void main(String[] args) {
        createGuiAndShow();
    }

    /**
     * 接收数据的容器
     */
    private List<Double> collect;

    /**
     * 周期采样点数
     */
    private static final Integer SAMPLE_COUNT = 64;

    /**
     * 最多保存的数据个数
     */
    private static final Integer MAX_COUNT_OF_SIZE = 65;

    private DrawWaveForm() {
        this.collect = Collections.synchronizedList(new ArrayList<>());

        // 使用一个线程模拟正弦波数据生产
        ExecutorService executor = Executors.newSingleThreadExecutor();
        executor.submit(() -> {
            for (int i = 0; i <= SAMPLE_COUNT; i++) {
                double sinValue = getSinValue(i);
                System.out.println("第" + i + "次 : " + sinValue);
                addValue(sinValue);
            }
        });
    }

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

        Graphics2D g2d = (Graphics2D) g;
        g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);

        int w = getWidth();
        int h = getHeight();

        int xDelta = w / MAX_COUNT_OF_SIZE;
        int length = collect.size();

        // 横坐标
        g2d.drawLine(0, h / 2, w, h / 2);

        for (int i = 0; i < length - 1; ++i) {
            g2d.drawLine(xDelta * (MAX_COUNT_OF_SIZE - length + i),
                    h / 2 + normalizeValueForYAxis(collect.get(i), h),
                    xDelta * (MAX_COUNT_OF_SIZE - length + i + 1),
                    h / 2 + normalizeValueForYAxis(collect.get(i + 1), h));
        }

    }

    private static void createGuiAndShow() {
        JFrame frame = new JFrame("测试波形图");

        frame.getContentPane().add(new DrawWaveForm());

        // Set frame's close operation and location in the screen.
        frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
        frame.setSize(500, 500);
        frame.setLocationRelativeTo(null);
        frame.setVisible(true);
    }

    /**
     * 规一化y轴方向的值. 使得value在y轴的值为[0, height]之间.
     *
     * @param value y坐标
     * @param height 高度
     * @return 归一化后结果
     */
    private int normalizeValueForYAxis(double value, int height) {
        return BigDecimal.valueOf(0.5 * height * value).setScale(0, BigDecimal.ROUND_HALF_UP)
                .intValue();
    }

    /**
     * 添加元素
     *
     * @param element 元素
     */
    private void addValue(double element) {
        // 循环使用一个接收数据的空间，最好是一个循环数组所以这里我采用有界
        if (collect.size() > MAX_COUNT_OF_SIZE) {
            collect.remove(0);
        }

        collect.add(element);
    }

    /**
     * 计算正弦值
     *
     * @param i 采样点数
     * @return 对应的幅度值
     */
    private double getSinValue(int i) {
        double sin = Math.sin(i * 2 * Math.PI / SAMPLE_COUNT);
        if (BigDecimal.valueOf(sin).abs().compareTo(BigDecimal.valueOf(0.01D)) <= 0) {
            return 0D;
        }
        // 因为上面是0点，所以反向输出
        return -sin;
    }
}

package com.runlion.fourier.demo.spectrum;

import com.runlion.fourier.demo.util.SampleNumberUtils;
import org.apache.commons.math3.complex.Complex;
import org.apache.commons.math3.transform.DftNormalization;
import org.apache.commons.math3.transform.FastFourierTransformer;
import org.apache.commons.math3.transform.TransformType;

import javax.swing.*;
import java.awt.*;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * 频谱生成 功能： 根据波形的离散采样生成对应的频谱波形
 *
 * @author fanyuanhang
 * @date 2020年05月28日 17:08:27
 */
public class DrawSpectrumForm extends JPanel {

    private static final long serialVersionUID = 8578537190471097637L;

    public static void main(String[] args) {
        createGuiAndShow();
    }

    /**
     * 接收数据的容器
     */
    private List<Double> collect;

    /**
     * FFT的容器
     */
    private List<Double> fftCollect;

    /**
     * 周期采样点数
     */
    private static final Integer SAMPLE_COUNT = 64;

    /**
     * 最多保存的数据个数
     */
    private static final Integer MAX_COUNT_OF_SIZE = 64;

    private DrawSpectrumForm() {
        this.collect = Collections.synchronizedList(new ArrayList<>());

        // 使用一个线程模拟正弦波数据生产
        ExecutorService executor = Executors.newSingleThreadExecutor();
        executor.submit(() -> {
            for (int i = 0; i < SAMPLE_COUNT; i++) {
                double sinValue = getSinValue(i);
                addValue(sinValue);
            }
            fftCalculate();
        });
    }

    /**
     * FFT 计算
     */
    private void fftCalculate() {
        fftCollect = Collections.synchronizedList(new ArrayList<>());

        double[] dataArray = SampleNumberUtils.normalizeSampleList(collect);

        System.out.println("FFT数组 初始化完成");

        // 创建傅里叶方法实例
        FastFourierTransformer fft = new FastFourierTransformer(DftNormalization.STANDARD);
        Complex[] result = fft.transform(dataArray, TransformType.FORWARD);
        // 将傅里叶变换前数据和变换后数据打印出来，显示前200
        for (Complex complex : result) {
            // 频谱幅度值
            double abs = complex.abs() * 2 / SAMPLE_COUNT;
            System.out.println(abs);
            fftCollect.add(abs);
        }

        fftCollect.remove(fftCollect.size() - 1);
    }

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

        Graphics2D g2d = (Graphics2D) g;
        g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);

        int w = getWidth();
        int h = getHeight();

        int xDelta = w / MAX_COUNT_OF_SIZE;
        int length = fftCollect.size();

        // 横坐标
        g2d.drawLine(0, h / 2, w, h / 2);

        for (int i = 0; i < length - 1; ++i) {
            g2d.drawLine(xDelta * (MAX_COUNT_OF_SIZE - length + i),
                    h / 2 - normalizeValueForYAxis(fftCollect.get(i), h),
                    xDelta * (MAX_COUNT_OF_SIZE - length + i + 1),
                    h / 2 - normalizeValueForYAxis(fftCollect.get(i + 1), h));
        }

    }

    private static void createGuiAndShow() {
        JFrame frame = new JFrame("测试频谱图");

        frame.getContentPane().add(new DrawSpectrumForm());

        // Set frame's close operation and location in the screen.
        frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
        frame.setSize(800, 800);
        frame.setLocationRelativeTo(null);
        frame.setVisible(true);
    }

    /**
     * 规一化y轴方向的值. 使得value在y轴的值为[0, height]之间.
     *
     * @param value  y坐标
     * @param height 高度
     * @return 归一化后结果
     */
    private int normalizeValueForYAxis(double value, int height) {
        return BigDecimal.valueOf(0.5 * height * value).setScale(0, BigDecimal.ROUND_HALF_UP)
                .intValue();
    }

    /**
     * 添加元素
     *
     * @param element 元素
     */
    private void addValue(double element) {
        // 循环使用一个接收数据的空间，最好是一个循环数组所以这里我采用有界
        if (collect.size() > MAX_COUNT_OF_SIZE) {
            collect.remove(0);
        }

        collect.add(element);
    }

    /**
     * 计算正弦值
     *
     * @param i 采样点数
     * @return 对应的幅度值
     */
    private double getSinValue(int i) {
        double sin = Math.sin(i * 2 * Math.PI / SAMPLE_COUNT);
        if (BigDecimal.valueOf(sin).abs().compareTo(BigDecimal.valueOf(0.01D)) <= 0) {
            return 0D;
        }
        return -sin;
    }

}

package com.runlion.fourier.demo.util;

import org.springframework.util.CollectionUtils;

import java.math.BigDecimal;
import java.util.List;

/**
 * 采样数学工具类
 *
 * @author fanyuanhang
 * @date 2020年06月03日 17:14:19
 */
public class SampleNumberUtils {
    /**
     * 补全采样点数为2的整数次幂
     *
     * @param originalList 原始采样数据集合
     * @return 补全后集合
     */
    public static double[] normalizeSampleList(List<Double> originalList) {

        if (CollectionUtils.isEmpty(originalList)) {
            throw new IllegalArgumentException("采样点数不能为空！");
        }

        int size = originalList.size();

        double log = Math.log(size) / Math.log(2);
        double ceil = Math.ceil(log);

        // 求整数次幂
        double pow = Math.pow(2, ceil);

        int diff = BigDecimal.valueOf(pow - size).setScale(2, BigDecimal.ROUND_HALF_UP).intValue();

        // 整数次幂长度
        int newLength = BigDecimal.valueOf(pow).setScale(0, BigDecimal.ROUND_HALF_UP).intValue();

        double[] dataArray = new double[newLength];


        for (int i = 0; i < size; i++) {
            dataArray[i] = originalList.get(i);
        }

        for (int index = 0; index < diff; index++) {
            // 补0
            dataArray[index + size] = 0D;
        }
        return dataArray;
    }
}