@rfkit/spectrum-analyzer/core/SpectrumAnalyzer/index.d.ts

A high-performance spectrum analyzer library for RF signal processing, supporting real-time spectrum analysis, waterfall display, and multi-segment frequency scanning

import type { ExtraDataOptions, isValidFloat32Array, ProcessInput, ProcessingOptions, ScanSegment, SpectrumConfig, SpectrumOutputData, TemplateOverData, ThresholdDataOptions, TimestampedFloat32Array } from './types';
import { ExtraDataMode } from './types';
export default class SpectrumAnalyzer {
    config: Required<Omit<SpectrumConfig, 'segments' | 'bandwidthConfig' | 'onSpectrumUpdate'>>;
    private segments;
    antennaFactorData: Float32Array;
    antennaFactorSwitch: boolean;
    protected realData: TimestampedFloat32Array;
    protected maxData: isValidFloat32Array;
    protected minData: isValidFloat32Array;
    protected avgData: isValidFloat32Array;
    protected templateData: Float32Array;
    protected occupancyData: Float32Array;
    protected backgroundNoiseData: Float32Array;
    protected thresholdData: Float32Array;
    protected waterfallData: TimestampedFloat32Array[];
    srcIndexCache: Uint32Array;
    protected realOutputData: Float32Array;
    protected maxOutputData: Float32Array;
    protected minOutputData: Float32Array;
    protected avgOutputData: Float32Array;
    protected templateOutputData: Float32Array;
    protected occupancyOutputData: Float32Array;
    protected backgroundNoiseOutputData: Float32Array;
    protected thresholdOutputData: Float32Array;
    protected waterfallOutputData: TimestampedFloat32Array[];
    protected scanProgress: number;
    protected lastIndex: number;
    protected processTimes: number;
    protected lastProcessTime: number;
    protected cachedExceedingDatas: TemplateOverData[];
    protected fluorescenceData: Uint32Array;
    protected fluorescenceMaxCount: number;
    protected fluorescenceUpdateCounter: number;
    extraData: Record<string, Float32Array>;
    protected extraOutputData: Record<string, Float32Array>;
    private pendingDataFlags;
    private hasPendingData;
    private hasProcessedData;
    private isProcessing;
    private readonly onSpectrumUpdate?;
    constructor(config: Partial<SpectrumConfig>);
    process({ data, timestamp, segmentOffset, offset, fluorescenceData, fluorescenceMaxCount }: ProcessInput): void;
    initializeSegments(segments: ScanSegment[]): void;
    setAntennaFactor(d: Float32Array | number[]): void;
    setAntennaFactorSwitch(newAntennaFactorSwitch: boolean): void;
    updateProcessing(next: Partial<ProcessingOptions>): void;
    clearMetricsData(): void;
    private allocateMetricsBuffers;
    private clearMetricsBuffers;
    setWaterfallData(newWaterfallData: TimestampedFloat32Array[]): void;
    setFluorescenceData(fluorescenceData: Uint32Array, fluorescenceMaxCount: number): void;
    setRealData(data: TimestampedFloat32Array): void;
    setMaxData(data: Float32Array): void;
    setMinData(data: Float32Array): void;
    setAvgData(data: Float32Array): void;
    setOccupancyData(data?: Float32Array | number[]): void;
    setExtraData(data: Record<string, Float32Array | number[]> | null, mode?: ExtraDataMode, options?: ExtraDataOptions): void;
    reset(preserveProcessedFlag?: boolean): void;
    getPerformanceMetrics(): Readonly<Record<string, number | boolean>>;
    getPeakStats(): import('./types').PeakStats | undefined;
    updateSamplingRange(start: number, end: number): Uint32Array;
    setTemplateData(data?: Float32Array | number[], templateTolerance?: number): void;
    setBackgroundNoiseData(data?: Float32Array | number[]): void;
    setThresholdData(data?: Float32Array | number[], options?: ThresholdDataOptions): void;
    private updateTemplateOverData;
    private resolveGlobalIndex;
    private clearThresholdDataState;
    protected resampleDataSeries(): Partial<SpectrumOutputData>;
    protected resampleWaterfallOutputData(): void;
    protected updateWaterfallData(data: TimestampedFloat32Array, outputData: TimestampedFloat32Array): void;
    protected updateMaxPoints(maxPoints: number, preserveProcessedFlag?: boolean): void;
    protected validateInput(data: Float32Array, index: number): void;
    private processDataPoints;
    private updateFluorescenceStats;
    private setPendingFlag;
    private resampleSingleData;
    private processPendingData;
    private notifySpectrumUpdate;
    private calculateMemoryUsage;
    private getOutputData;
    private getFluorescenceOutputData;
    getAllRawData(left?: number): Readonly<SpectrumOutputData>;
}