src/nodes/processing/dsp/FilterProcessingNode.ts
import { DataFrame, DataObject } from '../../../data';
import { TimeService } from '../../../service/TimeService';
import { ObjectProcessingNode, ObjectProcessingNodeOptions } from '../../ObjectProcessingNode';
/**
* @category Processing node
*/
export abstract class FilterProcessingNode<InOut extends DataFrame> extends ObjectProcessingNode<InOut> {
protected options: FilterProcessingOptions;
constructor(options?: FilterProcessingOptions) {
super(options);
}
processObject(object: DataObject, frame: InOut): Promise<DataObject> {
return new Promise((resolve, reject) => {
// Get existing filter data
this.getNodeData(object)
.then(async (nodeData) => {
if (nodeData === undefined) {
nodeData = {
timestamp: TimeService.now(),
...(await this.initFilter(object, frame, this.options)),
};
} else if (nodeData['timestamp']) {
if (nodeData.timestamp + this.options.expire < TimeService.now()) {
nodeData = {
timestamp: TimeService.now(),
...(await this.initFilter(object, frame, this.options)),
};
}
} else {
nodeData = {
timestamp: TimeService.now(),
...nodeData,
};
}
this.filter(object, frame, nodeData, this.options)
.then((result) => {
resolve(result);
})
.catch(reject)
.finally(() => {
this.setNodeData(object, nodeData)
.then(() => {
resolve(undefined);
})
.catch(reject);
});
})
.catch(reject);
});
}
abstract initFilter(object: DataObject, frame: InOut, options?: FilterProcessingOptions): Promise<any>;
abstract filter(
object: DataObject,
frame: InOut,
filter: any,
options?: FilterProcessingOptions,
): Promise<DataObject>;
}
export interface FilterProcessingOptions extends ObjectProcessingNodeOptions {
expire?: number;
}