audiomotion-analyzer 4.0.0-beta.0 → 4.0.0-beta.1

package/README.md

@@ -158,6 +158,7 @@ options = {<br>
 &emsp;&emsp;[stereo](#stereo-boolean): **false**,<br>
 &emsp;&emsp;[useCanvas](#usecanvas-boolean): **true**,<br>
 &emsp;&emsp;[volume](#volume-number): **1**,<br>
+&emsp;&emsp;[weightingFilter](#weightingFilter-string): **''**<br>
 &emsp;&emsp;[width](#width-number): *undefined*<br>
 }
 
@@ -450,11 +451,24 @@ Defaults to **false**.
 
 *Available since v4.0.0*
 
-When set to *true* uses linear values, instead of decibels, for displaying bars' amplitudes.
+When set to *true*, spectrum amplitudes are represented in linear scale instead of decibels (logarithmic).
+
 This may improve the visualization of predominant tones, especially at higher frequencies, but it will make the entire spectrum look much quieter.
 
+See also [`linearBoost`](#linearboost-number).
+
 Defaults to **false**.
 
+### `linearBoost` *number*
+
+*Available since v4.0.0*
+
+Performs an *n*th-root to amplify low energy values when using linear scale for the amplitude.
+
+It should be a number >= 1, while 1 means no boosting. Only effective when [`linearAmplitude`](#linearamplitude-boolean) is set to *true*.
+
+Defaults to **1**.
+
 ### `lineWidth` *number*
 
 *Available since v2.0.0*
@@ -514,7 +528,8 @@ Highest and lowest frequencies represented in the X-axis of the analyzer. Values
 
 The minimum allowed value is **1**. Trying to set a lower value will throw an `ERR_FREQUENCY_TOO_LOW` [error](#custom-errors).
 
-The maximum practical value is half the sampling rate ([`audioCtx.sampleRate`](#audioctx-audiocontext-object-read-only)), although this is not enforced by **audioMotion-analyzer**.
+The maximum allowed value is half the sampling rate ([`audioCtx.sampleRate`](#audioctx-audiocontext-object-read-only)), known as the [Nyquist frequency](https://en.wikipedia.org/wiki/Nyquist_frequency).
+Values higher than that will be capped.
 
 It is preferable to use the [`setFreqRange()`](#setfreqrange-minfreq-maxfreq-) method and set both values at once, to prevent `minFreq` being higher than the current `maxFreq` or vice-versa at a given moment.
 
@@ -783,6 +798,30 @@ Please note that changing the audio element volume directly will affect the ampl
 
 Defaults to **1**.
 
+### `weightingFilter` *string*
+
+*Available since v4.0.0*
+
+Select a [weighting filter](https://en.wikipedia.org/wiki/Weighting_filter) for spectrum visualization.
+
+Each filter applies a different curve of gain/attenuation to specific frequency ranges, but the general idea is to adjust the
+visualization of frequencies to which the human ear is more or less sensitive.
+Refer to the [weighting filters viewer tool](/tools/weighting-filters.html) for curves and response tables.
+
+?> Selecting a weighting filter **does NOT** affect the audio output, only the visualization.
+
+weightingFilter | description
+------|------------------------------
+'' (empty string) | No weighting applied (default)
+'A'   | A-weighting
+'B'   | B-weighting
+'C'   | C-weighting
+'D'   | D-weighting
+'468' | ITU-R 468 weighting
+
+Defaults to **''**.
+
+
 ## Static properties
 
 ### `AudioMotionAnalyzer.version` *string* *(Read only)*
@@ -925,8 +964,9 @@ Returns an array with current data for each analyzer bar. Each array element is
 ```js
 {
 	posX: <number>,   // horizontal position of this bar on the canvas
-	freqLo: <number>, // starting frequency for this bar
-	freqHi: <number>, // ending frequency for this bar
+	freq: <number>,   // center frequency for this bar (added in v4.0.0)
+	freqLo: <number>, // lower edge frequency
+	freqHi: <number>, // upper edge frequency
 	peak: <array>,    // peak values for left and right channels
 	hold: <array>,    // peak hold frames for left and right channels - values < 0 mean the peak is falling down
 	value: <array>    // current amplitude on left and right channels
@@ -970,7 +1010,8 @@ Use this method inside your callback function to create additional visual effect
 
 Registers a custom color gradient.
 
-`name` must be a non-empty *string* that will be used when setting the [`gradient`](#gradient-string) property. `options` must be an object as shown below:
+`name` must be a non-empty *string* that will be used to select this gradient, via the [`gradient`](#gradient-string) property.
+`options` must be an object as shown below:
 
 ```js
 const options = {
@@ -978,12 +1019,21 @@ const options = {
     dir: 'h',           // add this property to create a horizontal gradient (optional)
     colorStops: [       // list your gradient colors in this array (at least 2 entries are required)
         'red',                      // colors may be defined in any valid CSS format
-        { pos: .6, color: '#ff0' }, // use an object to adjust the position (0 to 1) of a color
+        { pos: .6, color: '#ff0' }, // use an object to adjust the offset (0 to 1) of a colorStop
         'hsl( 120, 100%, 50% )'     // colors may be defined in any valid CSS format
     ]
 }
 
-audioMotion.registerGradient( 'my-grad', options );
+audioMotion.registerGradient( 'myGradient', options );
+```
+
+!> In TypeScript projects make sure to import the `GradientOptions` definition and use it as the type of your object, like so:
+
+```js
+import AudioMotionAnalyzer, { GradientOptions } from 'audiomotion-analyzer'
+
+const options: GradientOptions = {
+	⋮
 ```
 
 Additional information about [gradient color-stops](https://developer.mozilla.org/en-US/docs/Web/API/CanvasGradient/addColorStop).
@@ -996,11 +1046,13 @@ Sets the analyzer nominal dimensions in pixels. See [`height`](#height-number) a
 
 Sets the desired frequency range. Values are expressed in Hz (Hertz).
 
+See [`minFreq` and `maxFreq`](#minfreq-number) for lower and upper limit values.
+
 ### `setLedParams( [params] )`
 
 *Available since v3.2.0*
 
-Customize parameters used to create the [LEDs display effect](#ledbars-boolean).
+Customize parameters used to create the [`ledBars`](#ledbars-boolean) effect.
 
 `params` should be an object with the following structure:
 
@@ -1014,9 +1066,9 @@ const params = {
 
 property  | description
 ----------|-------------
-`maxLeds` | maximum desired number of LED elements per analyzer bar
+`maxLeds` | **maximum** desired number of LED elements per analyzer bar
 `spaceV`  | vertical spacing ratio, relative to the LED height (**1** means spacing is the same as the LED height)
-`spaceH`  | **minimum** horizontal spacing ratio, relative to the available width (**0.5** means half of the width is used for spacing and half for the LED); behaves exactly like [barSpace](#barspace-number) (values >= 1 are considered as literal pixel values) and will override it if larger
+`spaceH`  | **minimum** horizontal spacing ratio, relative to the available width for each band, or a literal pixel value if **>= 1**;<br>this behaves exactly like [`barSpace`](#barspace-number) and the largest spacing (resulting from either `barSpace` or `spaceH`) will prevail.
 
 The available canvas height is initially divided by `maxLeds` and vertical spacing is calculated observing the `spaceV` ratio;
 if necessary, the led count is decreased until both the led segment and the vertical spacing are at least 2px tall.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "audiomotion-analyzer",
   "description": "High-resolution real-time graphic audio spectrum analyzer JavaScript module with no dependencies.",
-  "version": "4.0.0-beta.0",
+  "version": "4.0.0-beta.1",
   "main": "./src/audioMotion-analyzer.js",
   "module": "./src/audioMotion-analyzer.js",
   "types": "./src/index.d.ts",

package/src/audioMotion-analyzer.js

@@ -2,12 +2,12 @@
  * audioMotion-analyzer
  * High-resolution real-time graphic audio spectrum analyzer JS module
  *
- * @version 4.0.0-beta.0
+ * @version 4.0.0-beta.1
  * @author  Henrique Avila Vianna <hvianna@gmail.com> <https://henriquevianna.com>
  * @license AGPL-3.0-or-later
  */
 
-const VERSION = '4.0.0-beta.0';
+const VERSION = '4.0.0-beta.1';
 
 // internal constants
 const TAU     = 2 * Math.PI,
@@ -24,7 +24,8 @@ const CANVAS_BACKGROUND_COLOR  = '#000',
 	  SCALEX_LABEL_COLOR       = '#fff',
 	  SCALEX_HIGHLIGHT_COLOR   = '#4f4',
 	  SCALEY_LABEL_COLOR       = '#888',
-	  SCALEY_MIDLINE_COLOR     = '#555';
+	  SCALEY_MIDLINE_COLOR     = '#555',
+	  WEIGHTING_FILTERS        = [ '', 'A', 'B', 'C', 'D', '468' ];
 
 // custom error messages
 const ERR_AUDIO_CONTEXT_FAIL     = [ 'ERR_AUDIO_CONTEXT_FAIL', 'Could not create audio context. Web Audio API not supported?' ],
@@ -295,7 +296,7 @@ export default class AudioMotionAnalyzer {
 		for ( const i of [0,1] )
 			this._analyzer[ i ].fftSize = value;
 		const binCount = this._analyzer[0].frequencyBinCount;
-		this._fftData = [ new Uint8Array( binCount ), new Uint8Array( binCount ) ];
+		this._fftData = [ new Float32Array( binCount ), new Float32Array( binCount ) ];
 		this._calcBars();
 	}
 
@@ -326,6 +327,20 @@ export default class AudioMotionAnalyzer {
 		this._calcAux();
 	}
 
+	get linearAmplitude() {
+		return this._linearAmplitude;
+	}
+	set linearAmplitude( value ) {
+		this._linearAmplitude = !! value;
+	}
+
+	get linearBoost() {
+		return this._linearBoost;
+	}
+	set linearBoost( value ) {
+		this._linearBoost = value >= 1 ? +value : 1;
+	}
+
 	get loRes() {
 		return this._loRes;
 	}
@@ -503,6 +518,13 @@ export default class AudioMotionAnalyzer {
 		this._output.gain.value = value;
 	}
 
+	get weightingFilter() {
+		return this._weightingFilter;
+	}
+	set weightingFilter( value ) {
+		this._weightingFilter = WEIGHTING_FILTERS[ Math.max( 0, WEIGHTING_FILTERS.indexOf( ( '' + value ).toUpperCase() ) ) ];
+	}
+
 	get width() {
 		return this._width;
 	}
@@ -701,10 +723,10 @@ export default class AudioMotionAnalyzer {
 		let energy = 0;
 		for ( let channel = 0; channel < chnCount; channel++ ) {
 			for ( let i = startBin; i <= endBin; i++ )
-				energy += this._fftData[ channel ][ i ];
+				energy += this._normalizedB( this._fftData[ channel ][ i ] );
 		}
 
-		return energy / ( endBin - startBin + 1 ) / chnCount / 255;
+		return energy / ( endBin - startBin + 1 ) / chnCount;
 	}
 
 	/**
@@ -855,6 +877,13 @@ export default class AudioMotionAnalyzer {
 	 * ==========================================================================
 	 */
 
+	/**
+	 * Return the frequency (in Hz) for a given FFT bin
+	 */
+	_binToFreq( bin ) {
+		return bin * this.audioCtx.sampleRate / this.fftSize || 1; // returns 1 for bin 0
+	}
+
 	/**
 	 * Calculate auxiliary values and flags
 	 */
@@ -911,10 +940,9 @@ export default class AudioMotionAnalyzer {
 		if ( ! this._ready )
 			return;
 
-		// helper functions
-		const binToFreq = bin => bin * this.audioCtx.sampleRate / this.fftSize || 1; // returns 1 for bin 0
-		const barsPush  = args => bars.push( { ...args, peak: [0,0], hold: [0], value: [0] } );
+		// helper function
 		// bar object: { posX, freq, freqLo, freqHi, binLo, binHi, ratioLo, ratioHi, peak, hold, value }
+		const barsPush  = args => bars.push( { ...args, peak: [0,0], hold: [0], value: [0] } );
 
 		const analyzerWidth = this._analyzerWidth,
 			  initialX      = this._initialX,
@@ -949,8 +977,8 @@ export default class AudioMotionAnalyzer {
 			// helper function to calculate FFT bin and interpolation ratio for a given frequency
 			const calcRatio = freq => {
 				const bin   = this._freqToBin( freq, 'floor' ), // find closest FFT bin
-					  lower = binToFreq( bin ),
-					  upper = binToFreq( bin + 1 ),
+					  lower = this._binToFreq( bin ),
+					  upper = this._binToFreq( bin + 1 ),
 					  ratio = Math.log2( freq / lower ) / Math.log2( upper / lower );
 
 				return [ bin, ratio ];
@@ -1047,7 +1075,7 @@ export default class AudioMotionAnalyzer {
 	 		let lastPos = -999;
 
 			for ( let i = minIndex; i <= maxIndex; i++ ) {
-				const freq = binToFreq( i ), // frequency represented by this index
+				const freq = this._binToFreq( i ), // frequency represented by this index
 					  posX = initialX + Math.round( logWidth * ( Math.log10( freq ) - minLog ) ); // avoid fractionary pixel values
 
 				// if it's on a different X-coordinate, create a new bar for this frequency
@@ -1251,7 +1279,7 @@ export default class AudioMotionAnalyzer {
 			  mode           = this._mode,
 			  isAlphaBars    = this._isAlphaBars,
 			  isLedDisplay   = this._isLedDisplay,
-			  isLinearAmplitude = this.linearAmplitude,
+			  isLinear       = this._linearAmplitude,
 			  isLumiBars     = this._isLumiBars,
 			  isOctaveBands  = this._isOctaveBands,
 			  isOutline      = this._isOutline,
@@ -1271,12 +1299,51 @@ export default class AudioMotionAnalyzer {
 			  maxBarHeight   = isRadial ? Math.min( centerX, centerY ) - radius : analyzerHeight,
 			  maxdB			 = this.maxDecibels,
 			  mindB			 = this.minDecibels,
-			  deltadB 		 = ( maxdB - mindB ) / -20,
-			  useCanvas      = this.useCanvas;
+			  dbRange 		 = maxdB - mindB,
+			  useCanvas      = this.useCanvas,
+			  weightingFilter= this._weightingFilter;
 
 		if ( energy.val > 0 )
 			this._spinAngle += this._spinSpeed * RPM;
 
+		// helper function - apply the selected weighting filter and return dB gain for a given frequency
+		const weightingdB = freq => {
+			const f2 = freq ** 2,
+				  SQ20_6  = 424.36,
+				  SQ107_7 = 11599.29,
+				  SQ158_5 = 25122.25,
+				  SQ737_9 = 544496.41,
+				  SQ12194 = 148693636,
+				  linearTodB = value => 20 * Math.log10( value );
+
+			switch ( weightingFilter ) {
+				case 'A' : // A-weighting https://en.wikipedia.org/wiki/A-weighting
+					const rA = ( SQ12194 * f2 ** 2 ) / ( ( f2 + SQ20_6 ) * Math.sqrt( ( f2 + SQ107_7 ) * ( f2 + SQ737_9 ) ) * ( f2 + SQ12194 ) );
+					return 2 + linearTodB( rA );
+
+				case 'B' :
+					const rB = ( SQ12194 * f2 * freq ) / ( ( f2 + SQ20_6 ) * Math.sqrt( f2 + SQ158_5 ) * ( f2 + SQ12194 ) );
+					return .17 + linearTodB( rB );
+
+				case 'C' :
+					const rC = ( SQ12194 * f2 ) / ( ( f2 + SQ20_6 ) * ( f2 + SQ12194 ) );
+					return .06 + linearTodB( rC );
+
+				case 'D' :
+					const h = ( ( 1037918.48 - f2 ) ** 2 + 1080768.16 * f2 ) / ( ( 9837328 - f2 ) ** 2 + 11723776 * f2 ),
+						  rD = ( freq / 6.8966888496476e-5 ) * Math.sqrt( h / ( ( f2 + 79919.29 ) * ( f2 + 1345600 ) ) );
+					return linearTodB( rD );
+
+				case '468' : // ITU-R 468 https://en.wikipedia.org/wiki/ITU-R_468_noise_weighting
+					const h1 = -4.737338981378384e-24 * freq ** 6 + 2.043828333606125e-15 * freq ** 4 - 1.363894795463638e-7 * f2 + 1,
+						  h2 = 1.306612257412824e-19 * freq ** 5 - 2.118150887518656e-11 * freq ** 3 + 5.559488023498642e-4 * freq,
+						  rI = 1.246332637532143e-4 * freq / Math.hypot( h1, h2 );
+					return 18.2 + linearTodB( rI );
+			}
+
+			return 0; // unknown filter
+		}
+
 		const strokeIf = flag => {
 			if ( flag && lineWidth ) {
 				const alpha = ctx.globalAlpha;
@@ -1357,9 +1424,9 @@ export default class AudioMotionAnalyzer {
 				if ( this.showScaleY && ! isLumiBars && ! isRadial ) {
 					const scaleWidth = canvasX.height,
 						  fontSize   = scaleWidth >> 1,
-						  max        = isLinearAmplitude ? 100 : maxdB,
-						  min        = isLinearAmplitude ? 0 : mindB,
-						  incr       = isLinearAmplitude ? 20 : 5,
+						  max        = isLinear ? 100 : maxdB,
+						  min        = isLinear ? 0 : mindB,
+						  incr       = isLinear ? 20 : 5,
 						  interval   = analyzerHeight / ( max - min );
 
 					ctx.fillStyle = SCALEY_LABEL_COLOR;
@@ -1410,12 +1477,16 @@ export default class AudioMotionAnalyzer {
 			} // if ( useCanvas )
 
 			// get a new array of data from the FFT
-			const fftData = this._fftData[ channel ],
-				  lastBin = fftData.length - 1;
-			this._analyzer[ channel ].getByteFrequencyData( fftData );
+			let fftData = this._fftData[ channel ];
+			this._analyzer[ channel ].getFloatFrequencyData( fftData );
+
+			// apply weighting
+			if ( weightingFilter )
+				fftData = fftData.map( ( val, idx ) => val + weightingdB( this._binToFreq( idx ) ) );
 
 			// helper function for FFT data interpolation
-			const interpolate = ( bin, ratio ) => fftData[ bin ] + ( bin < lastBin ? ( fftData[ bin + 1 ] - fftData[ bin ] ) * ratio : 0 );
+			const lastBin = fftData.length - 1,
+				  interpolate = ( bin, ratio ) => fftData[ bin ] + ( bin < lastBin ? ( fftData[ bin + 1 ] - fftData[ bin ] ) * ratio : 0 );
 
 			// start drawing path (for mode 10)
 			ctx.beginPath();
@@ -1428,7 +1499,7 @@ export default class AudioMotionAnalyzer {
 			for ( let i = 0; i < nBars; i++ ) {
 
 				const bar = this._bars[ i ],
-					  { binLo, binHi, ratioLo, ratioHi } = bar;
+					  { freq, binLo, binHi, ratioLo, ratioHi } = bar;
 
 				let barHeight = Math.max( interpolate( binLo, ratioLo ), interpolate( binHi, ratioHi ) );
 
@@ -1438,9 +1509,9 @@ export default class AudioMotionAnalyzer {
 						barHeight = fftData[ j ];
 				}
 
-				barHeight /= 255;
-				if ( isLinearAmplitude && barHeight ) // avoid residual amplitude if bar value is 0
-					barHeight = 10 ** ( ( 1 - barHeight ) * deltadB );
+				// normalize bar amplitude in [0;1] range
+				barHeight = this._normalizedB( barHeight );
+
 				bar.value[ channel ] = barHeight;
 				currentEnergy += barHeight;
 
@@ -1830,6 +1901,27 @@ export default class AudioMotionAnalyzer {
 		this._canvasGradient = grad;
 	}
 
+	/**
+	 * Normalize a dB value in the [0;1] range
+	 */
+	_normalizedB( value ) {
+		const isLinear   = this._linearAmplitude,
+			  boost      = isLinear ? 1 / this._linearBoost : 1,
+			  clamp      = ( val, min, max ) => val <= min ? min : val >= max ? max : val,
+			  dBToLinear = val => 10 ** ( val / 20 );
+
+		let maxValue = this.maxDecibels,
+			minValue = this.minDecibels;
+
+		if ( isLinear ) {
+			maxValue = dBToLinear( maxValue );
+			minValue = dBToLinear( minValue );
+			value = dBToLinear( value ) ** boost;
+		}
+
+		return clamp( ( value - minValue ) / ( maxValue - minValue ) ** boost, 0, 1 );
+	}
+
 	/**
 	 * Internal function to change canvas dimensions on demand
 	 */
@@ -1907,44 +1999,46 @@ export default class AudioMotionAnalyzer {
 
 		// settings defaults
 		const defaults = {
-			alphaBars    : false,
-			ansiBands    : false,
-			barSpace     : 0.1,
-			bgAlpha      : 0.7,
-			fftSize      : 8192,
-			fillAlpha    : 1,
-			gradient     : 'classic',
-			ledBars      : false,
+			alphaBars      : false,
+			ansiBands      : false,
+			barSpace       : 0.1,
+			bgAlpha        : 0.7,
+			fftSize        : 8192,
+			fillAlpha      : 1,
+			gradient       : 'classic',
+			ledBars        : false,
 			linearAmplitude: false,
-			lineWidth    : 0,
-			loRes        : false,
-			lumiBars     : false,
-			maxDecibels  : -25,
-			maxFreq      : 22000,
-			minDecibels  : -85,
-			minFreq      : 20,
-			mirror       : 0,
-			mode         : 0,
-			noteLabels   : false,
-			outlineBars  : false,
-			overlay      : false,
-			radial		 : false,
-			reflexAlpha  : 0.15,
-			reflexBright : 1,
-			reflexFit    : true,
-			reflexRatio  : 0,
-			showBgColor  : true,
-			showFPS      : false,
-			showPeaks    : true,
-			showScaleX   : true,
-			showScaleY   : false,
-			smoothing    : 0.5,
-			spinSpeed    : 0,
-			splitGradient: false,
-			start        : true,
-			stereo       : false,
-			useCanvas    : true,
-			volume       : 1,
+			linearBoost    : 1,
+			lineWidth      : 0,
+			loRes          : false,
+			lumiBars       : false,
+			maxDecibels    : -25,
+			maxFreq        : 22000,
+			minDecibels    : -85,
+			minFreq        : 20,
+			mirror         : 0,
+			mode           : 0,
+			noteLabels     : false,
+			outlineBars    : false,
+			overlay        : false,
+			radial		   : false,
+			reflexAlpha    : 0.15,
+			reflexBright   : 1,
+			reflexFit      : true,
+			reflexRatio    : 0,
+			showBgColor    : true,
+			showFPS        : false,
+			showPeaks      : true,
+			showScaleX     : true,
+			showScaleY     : false,
+			smoothing      : 0.5,
+			spinSpeed      : 0,
+			splitGradient  : false,
+			start          : true,
+			stereo         : false,
+			useCanvas      : true,
+			volume         : 1,
+			weightingFilter: ''
 		};
 
 		// callback functions properties

package/src/index.d.ts

@@ -17,6 +17,7 @@ export interface Options {
   height?: number;
   ledBars?: boolean;
   linearAmplitude?: boolean;
+  linearBoost?: boolean;
   lineWidth?: number;
   loRes?: boolean;
   lumiBars?: boolean;
@@ -48,6 +49,7 @@ export interface Options {
   stereo?: boolean;
   useCanvas?: boolean;
   volume?: number;
+  weightingFilter?: WeightingFilter;
   width?: number;
 }
 
@@ -72,6 +74,8 @@ type EnergyPreset = "peak" | "bass" | "lowMid" | "mid" | "highMid" | "treble";
 
 type GradientColorStop = string | { pos: number; color: string };
 
+type WeightingFilter = "" | "A" | "B" | "C" | "D" | "468";
+
 type ArrayTwoOrMore<T> = {
   0: T
   1: T
@@ -85,8 +89,8 @@ export interface GradientOptions {
 
 export interface LedParameters {
   maxLeds: number;
-  spaceVRatio: number;
-  spaceHRatio: number;
+  spaceV: number;
+  spaceH: number;
 }
 
 declare class AudioMotionAnalyzer {
@@ -141,7 +145,12 @@ declare class AudioMotionAnalyzer {
   get ledBars(): boolean;
   set ledBars(value: boolean);
 
-  public linearAmplitude: boolean;
+  get linearAmplitude(): boolean;
+  set linearAmplitude(value: boolean);
+
+  get linearBoost(): number;
+  set linearBoost(value: number);
+
   public lineWidth: number;
 
   get loRes(): boolean;
@@ -211,6 +220,9 @@ declare class AudioMotionAnalyzer {
   get volume(): number;
   set volume(value: number);
 
+  get weightingFilter(): WeightingFilter;
+  set weightingFilter(value: WeightingFilter);
+
   static get version(): string;
 
   public onCanvasDraw: OnCanvasDrawFunction | undefined;