TypeScript extension.IMeasureTask类代码示例

export default function(task: IMeasureTask) {
    let numSamples = Math.min(
        Math.pow(2, Math.floor(Math.log(task.xNumSamples) / Math.log(2))),
        1024 * 1024
    );

    var real = new Float64Array(numSamples);
    var imag = new Float64Array(numSamples).fill(0);

    for (let i = 0; i < numSamples; ++i) {
        real[i] = task.getSampleValueAtIndex(
            task.xStartIndex + Math.floor((i * task.xNumSamples) / numSamples)
        );
    }

    transform(real, imag);

    // Ignore 0 frequency part when trying to get frequency. Offset can be bigger than wave amplitude and cause issues.
    var maxMag = real[1] * real[1] + imag[1] * imag[1];
    var indexMax = 1;
    for (var i = 2; i < real.length / 2; i++) {
        var magnitude = real[i] * real[i] + imag[i] * imag[i];
        if (magnitude > maxMag) {
            maxMag = magnitude;
            indexMax = i;
        }
    }
    var step = task.samplingRate / task.xNumSamples;
    var frequency = indexMax * step;

    task.result = frequency;
    task.resultUnit = "frequency";
}

export default function(task: IMeasureTask) {
    let result = Number.MAX_VALUE;

    const xEndIndex = task.xStartIndex + task.xNumSamples;
    for (let i = task.xStartIndex; i < xEndIndex; ++i) {
        const y = task.getSampleValueAtIndex(i);
        if (y < result) {
            result = y;
        }
    }

    task.result = result;
}

export default function(task: IMeasureTask) {
    let sum = 0;

    const xEndIndex = task.xStartIndex + task.xNumSamples;
    for (let i = task.xStartIndex; i < xEndIndex; ++i) {
        const sample = task.getSampleValueAtIndex(i);
        if (!isNaN(sample)) {
            sum += sample;
        }
    }

    task.result = sum / task.xNumSamples;
}

export default function(task: IMeasureTask) {
    let min = Number.MAX_VALUE;
    let max = Number.MIN_VALUE;

    const xEndIndex = task.xStartIndex + task.xNumSamples;
    for (let i = task.xStartIndex; i < xEndIndex; ++i) {
        const y = task.getSampleValueAtIndex(i);
        if (y < min) {
            min = y;
        }
        if (y > max) {
            max = y;
        }
    }

    task.result = max - min;
}

export default function(task: IMeasureTask) {
    //
    let numSamples = Math.pow(2, Math.floor(Math.log2(task.xNumSamples)));

    let F = task.xNumSamples / numSamples;

    let halfNumSamples = Math.floor(numSamples / 2);

    //
    const real = new Float64Array(numSamples);

    real[0] = task.getSampleValueAtIndex(task.xStartIndex + 0);
    for (let i = 1; i < numSamples; ++i) {
        real[i] = task.getSampleValueAtIndex(task.xStartIndex + Math.round(i * F));
    }

    const imag = new Float64Array(numSamples).fill(0);

    //
    transform(real, imag);

    //
    const yAxisInDecibels =
        !task.parameters || !task.parameters.yAxis || task.parameters.yAxis !== "linear";

    function toDecibels(i: number) {
        const re = real[i];
        const im = imag[i];
        const pow_dB = 10 * Math.log10((re * re + im * im) / (numSamples * numSamples));
        return Math.max(pow_dB, -110);
    }

    function getLinearYValue(i: number) {
        const re = real[i];
        const im = imag[i];
        return Math.sqrt(re * re + im * im) / numSamples;
    }

    const getYValue = yAxisInDecibels ? toDecibels : getLinearYValue;

    const data = new Array(halfNumSamples);
    let minValue, maxValue;
    minValue = maxValue = data[0] = getYValue(0);
    for (let i = 1; i < halfNumSamples; ++i) {
        data[i] = getYValue(i);
        if (data[i] < minValue) {
            minValue = data[i];
        } else if (data[i] > maxValue) {
            maxValue = data[i];
        }
    }

    //
    task.result = {
        data,
        samplingRate: numSamples / (task.samplingRate / F),
        xAxes: {
            unit: "frequency",
            logarithmic:
                !task.parameters || !task.parameters.xAxis || task.parameters.xAxis !== "linear"
        },
        yAxes: {
            unit: yAxisInDecibels ? "decibel" : task.valueUnit,
            minValue,
            maxValue
        }
    };
}