/
LPFilterNode.ts
60 lines (55 loc) · 1.96 KB
/
LPFilterNode.ts
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
import { PropertyFilterProcessingNode, PropertyModifier, PropertySelector } from './PropertyFilterProcessingNode';
import { DataFrame, DataObject } from '../../../data';
import { Vector2, Vector3 } from '../../../utils';
import { FilterProcessingOptions } from './FilterProcessingNode';
/**
* @category Processing node
*/
export class LPFilterNode<InOut extends DataFrame> extends PropertyFilterProcessingNode<InOut> {
constructor(
propertySelector: PropertySelector<InOut>,
propertyModifier: PropertyModifier<InOut>,
options: LPFilterOptions,
) {
super(propertySelector, propertyModifier, options);
}
initFilter<T extends number | Vector2 | Vector3>(
object: DataObject,
value: T,
options: LPFilterOptions,
): Promise<any> {
return new Promise<any>((resolve) => {
let alpha = options.alpha;
if (alpha === undefined) {
const rc = 1.0 / (options.cutOff * 2 * Math.PI);
const dt = 1.0 / options.sampleRate;
alpha = dt / (rc + dt);
}
resolve({
x: value,
alpha,
});
});
}
filter<T extends number | Vector2 | Vector3>(
object: DataObject,
value: T,
filter: { x: any; alpha: number },
): Promise<T> {
return new Promise<T>((resolve) => {
if (typeof value === 'number') {
filter.x = filter.x + filter.alpha * (value - filter.x);
} else {
const vector = (value as Vector2 | Vector3).clone();
const filterVector = filter.x as Vector2 | Vector3;
filter.x = filterVector.add(vector.sub(filter.x).multiplyScalar(filter.alpha) as Vector2 & Vector3);
}
resolve(filter.x);
});
}
}
export interface LPFilterOptions extends FilterProcessingOptions {
sampleRate: number;
cutOff: number;
alpha?: number;
}