554 lines
17 KiB
JavaScript
554 lines
17 KiB
JavaScript
/*
|
|
Copyright (c) 2023-forever Douglas Malnati. All rights reserved.
|
|
|
|
See the /faq/tos page for details.
|
|
|
|
(If this generated header is stamped on a file which is a 3rd party file or under a different license or copyright, then ignore this copyright statement and use that file's terms.)
|
|
*/
|
|
|
|
import { CandidateFilterBase } from './CandidateFilterBase.js';
|
|
import { NonRejectedOnlyFilter } from './WsprMessageCandidate.js';
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
// Candidate Filter - Fingerprinting
|
|
//
|
|
// Identify messages that appear to be yours by matching frequencies
|
|
// to data you believe in. Reject everything else.
|
|
///////////////////////////////////////////////////////////////////////////
|
|
|
|
export class CandidateFilterByFingerprinting
|
|
extends CandidateFilterBase
|
|
{
|
|
constructor(t)
|
|
{
|
|
super("ByFingerprinting", t);
|
|
}
|
|
|
|
OnFilterStart()
|
|
{
|
|
this.t.Event(`CandidateFilterByFingerprinting Start`);
|
|
this.windowDataSet = new Set();
|
|
}
|
|
|
|
OnFilterEnd()
|
|
{
|
|
for (const windowData of this.windowDataSet)
|
|
{
|
|
if (windowData?.fingerprintingData)
|
|
{
|
|
windowData.fingerprintingData.winFreqDrift = this.EstimateWindowFreqDrift(windowData);
|
|
}
|
|
}
|
|
|
|
this.t.Event(`CandidateFilterByFingerprinting End`);
|
|
}
|
|
|
|
FilterWindowAlgorithm(msgListList)
|
|
{
|
|
this.FingerprintAlgorithm_ByReference(msgListList);
|
|
}
|
|
|
|
|
|
// private
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
// ByReference Algorithm
|
|
//
|
|
// If you can find a reference message you believe to be yours, match up
|
|
// messages in the other slots by frequency to that reference frequency,
|
|
// then reject all others.
|
|
///////////////////////////////////////////////////////////////////////////
|
|
|
|
FingerprintAlgorithm_ByReference(msgListList)
|
|
{
|
|
let windowData = this.GetWindowDataFromMsgListList(msgListList);
|
|
if (windowData)
|
|
{
|
|
this.windowDataSet.add(windowData);
|
|
|
|
if (windowData.fingerprintingData)
|
|
{
|
|
windowData.fingerprintingData.winFreqDrift = null;
|
|
}
|
|
}
|
|
|
|
let reference = this.FindNearestReference(msgListList);
|
|
if (!reference.ok)
|
|
{
|
|
for (let msgList of msgListList)
|
|
{
|
|
let msgListCandidate = NonRejectedOnlyFilter(msgList);
|
|
this.RejectAllInList(msgListCandidate, reference.reason);
|
|
}
|
|
|
|
if (windowData?.fingerprintingData)
|
|
{
|
|
windowData.fingerprintingData.referenceAudit = this.CreateReferenceAuditData(null, null, reference.source, reference.reason);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
let referenceMsg = reference.msg;
|
|
let referenceSlot = reference.slot;
|
|
windowData = referenceMsg.windowShortcut;
|
|
let referenceAudit = this.CreateReferenceAuditData(referenceMsg, referenceSlot, reference.source, reference.reason);
|
|
if (windowData?.fingerprintingData)
|
|
{
|
|
windowData.fingerprintingData.referenceAudit = referenceAudit;
|
|
}
|
|
|
|
for (let slot = 0; slot < 5; ++slot)
|
|
{
|
|
if (slot == referenceSlot)
|
|
{
|
|
referenceAudit.slotAuditList[slot] = this.CreateSlotAuditData(slot, [referenceMsg], referenceMsg, referenceAudit);
|
|
referenceAudit.slotAuditList[slot].outcome = "reference";
|
|
referenceAudit.slotAuditList[slot].msgMatched = referenceMsg;
|
|
referenceAudit.slotAuditList[slot].msgMatchList = [referenceMsg];
|
|
continue;
|
|
}
|
|
|
|
let msgCandidateList = NonRejectedOnlyFilter(msgListList[slot]);
|
|
|
|
let msgMatchList = [];
|
|
let freqHzDiffMatch = 0;
|
|
const FREQ_HZ_PLUS_MINUS_THRESHOLD = 5; // it's +/- this number, so 10Hz
|
|
let slotAudit = this.CreateSlotAuditData(slot, msgCandidateList, referenceMsg, referenceAudit);
|
|
referenceAudit.slotAuditList[slot] = slotAudit;
|
|
if (msgCandidateList.length)
|
|
{
|
|
slotAudit.msgAuditList = this.GetMsgFingerprintAuditList(referenceMsg, msgCandidateList, referenceAudit.referenceRxCall__rxRecordListMap);
|
|
|
|
let matchResult = this.GetWithinThresholdMatchResult(slotAudit.msgAuditList, FREQ_HZ_PLUS_MINUS_THRESHOLD);
|
|
msgMatchList = matchResult.msgMatchList;
|
|
freqHzDiffMatch = matchResult.freqHzDiffMatch;
|
|
slotAudit.matchThresholdHz = matchResult.matchThresholdHz;
|
|
}
|
|
|
|
if (msgMatchList.length == 0)
|
|
{
|
|
this.RejectAllInList(msgCandidateList, `Fingerprint match fail, exceeded ${FREQ_HZ_PLUS_MINUS_THRESHOLD} threshold.`);
|
|
slotAudit.outcome = "no_match";
|
|
}
|
|
else if (msgMatchList.length == 1)
|
|
{
|
|
this.RejectAllInListExcept(msgCandidateList, msgMatchList[0], `Fingerprint matched other message`);
|
|
slotAudit.outcome = "single_match";
|
|
slotAudit.msgMatched = msgMatchList[0];
|
|
}
|
|
else
|
|
{
|
|
slotAudit.outcome = "multi_match";
|
|
}
|
|
|
|
slotAudit.msgMatchList = msgMatchList;
|
|
slotAudit.thresholdHzTriedMax = msgCandidateList.length ? freqHzDiffMatch : null;
|
|
}
|
|
}
|
|
|
|
FindNearestReference(msgListList)
|
|
{
|
|
let slot0List = NonRejectedOnlyFilter(msgListList[0]);
|
|
if (slot0List.length == 1)
|
|
{
|
|
return {
|
|
ok: true,
|
|
msg: slot0List[0],
|
|
slot: 0,
|
|
source: "slot0",
|
|
reason: "Using unique slot 0 message as fingerprint reference.",
|
|
};
|
|
}
|
|
|
|
for (let slot = 0; slot < 5; ++slot)
|
|
{
|
|
let msgConfirmedList = NonRejectedOnlyFilter(msgListList[slot]).filter(msg => msg.IsConfirmed());
|
|
if (msgConfirmedList.length == 1)
|
|
{
|
|
return {
|
|
ok: true,
|
|
msg: msgConfirmedList[0],
|
|
slot: slot,
|
|
source: "borrowed_confirmed_within_window",
|
|
reason: `Borrowed fingerprint reference from earliest confirmed message in slot ${slot}.`,
|
|
};
|
|
}
|
|
}
|
|
|
|
if (slot0List.length == 0)
|
|
{
|
|
return {
|
|
ok: false,
|
|
msg: null,
|
|
slot: null,
|
|
source: "none",
|
|
reason: `No anchor frequency message in slot 0, and no confirmed message available to borrow within the window.`,
|
|
};
|
|
}
|
|
|
|
return {
|
|
ok: false,
|
|
msg: null,
|
|
slot: null,
|
|
source: "none",
|
|
reason: `Too many candidates (${slot0List.length}) in slot 0, and no unique confirmed message available to borrow within the window.`,
|
|
};
|
|
}
|
|
|
|
GetWindowDataFromMsgListList(msgListList)
|
|
{
|
|
for (const msgList of msgListList)
|
|
{
|
|
for (const msg of msgList)
|
|
{
|
|
if (msg?.windowShortcut)
|
|
{
|
|
return msg.windowShortcut;
|
|
}
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
CreateReferenceAuditData(referenceMsg, referenceSlot, referenceSource, referenceReason)
|
|
{
|
|
return {
|
|
referenceMsg: referenceMsg,
|
|
referenceSlot: referenceSlot,
|
|
referenceSource: referenceSource,
|
|
referenceReason: referenceReason,
|
|
referenceRxCall__rxRecordListMap: referenceMsg ? this.MakeRxCallToRxRecordListMap(referenceMsg) : new Map(),
|
|
slotAuditList: [null, null, null, null, null],
|
|
};
|
|
}
|
|
|
|
CreateSlotAuditData(slot, msgCandidateList, referenceMsg, referenceAudit)
|
|
{
|
|
return {
|
|
slot: slot,
|
|
referenceMsg: referenceMsg,
|
|
referenceSlot: referenceAudit.referenceSlot,
|
|
referenceRxCall__rxRecordListMap: referenceAudit.referenceRxCall__rxRecordListMap,
|
|
msgCandidateList: msgCandidateList,
|
|
msgAuditList: [],
|
|
msgMatchList: [],
|
|
msgMatched: null,
|
|
matchThresholdHz: null,
|
|
thresholdHzTriedMax: null,
|
|
outcome: msgCandidateList.length ? "pending" : "no_candidates",
|
|
};
|
|
}
|
|
|
|
GetMsgFingerprintAuditList(msgA, msgBList, rxCall__rxRecordListAMap)
|
|
{
|
|
let msgAuditList = [];
|
|
|
|
for (let msgB of msgBList)
|
|
{
|
|
let diffData = this.GetMinFreqDiffData(msgA, msgB, rxCall__rxRecordListAMap);
|
|
msgAuditList.push({
|
|
msg: msgB,
|
|
minFreqDiff: diffData.minDiff,
|
|
rxCallMatchList: diffData.rxCallMatchList,
|
|
candidateRxCall__rxRecordListMap: diffData.rxCall__rxRecordListB,
|
|
});
|
|
}
|
|
|
|
return msgAuditList;
|
|
}
|
|
|
|
GetWithinThresholdMatchResult(msgAuditList, thresholdMax)
|
|
{
|
|
let msgMatchList = [];
|
|
let freqHzDiffMatch = thresholdMax;
|
|
let matchThresholdHz = null;
|
|
|
|
for (freqHzDiffMatch = 0; freqHzDiffMatch <= thresholdMax; ++freqHzDiffMatch)
|
|
{
|
|
msgMatchList = msgAuditList
|
|
.filter(msgAudit => msgAudit.minFreqDiff != null && msgAudit.minFreqDiff <= freqHzDiffMatch)
|
|
.map(msgAudit => msgAudit.msg);
|
|
|
|
if (msgMatchList.length != 0)
|
|
{
|
|
matchThresholdHz = freqHzDiffMatch;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return {
|
|
msgMatchList,
|
|
freqHzDiffMatch,
|
|
matchThresholdHz,
|
|
};
|
|
}
|
|
|
|
// Return the set of msgBList elements which fall within the threshold difference
|
|
// of frequency when compared to msgA.
|
|
GetWithinThresholdList(msgA, msgBList, threshold)
|
|
{
|
|
let msgListWithinThreshold = [];
|
|
|
|
// calculate minimum frequency diff between msgA and this
|
|
// message of this slot
|
|
let msg__minFreqDiff = new Map();
|
|
for (let msgB of msgBList)
|
|
{
|
|
msg__minFreqDiff.set(msgB, this.GetMinFreqDiff(msgA, msgB));
|
|
}
|
|
|
|
// find out which messages fall within tolerance
|
|
for (let [msgB, freqDiff] of msg__minFreqDiff)
|
|
{
|
|
if (freqDiff != null && freqDiff <= threshold)
|
|
{
|
|
msgListWithinThreshold.push(msgB);
|
|
}
|
|
}
|
|
|
|
return msgListWithinThreshold;
|
|
}
|
|
|
|
MakeRxCallToRxRecordListMap(msg, limitBySet)
|
|
{
|
|
limitBySet = limitBySet ?? null;
|
|
|
|
let rxCall__recordMap = new Map();
|
|
|
|
for (let rxRecord of msg.rxRecordList)
|
|
{
|
|
let rxCall = rxRecord.rxCallsign;
|
|
|
|
if (limitBySet == null || limitBySet.has(rxCall))
|
|
{
|
|
if (rxCall__recordMap.has(rxCall) == false)
|
|
{
|
|
rxCall__recordMap.set(rxCall, []);
|
|
}
|
|
|
|
rxCall__recordMap.get(rxCall).push(rxRecord);
|
|
}
|
|
}
|
|
|
|
return rxCall__recordMap;
|
|
}
|
|
|
|
// Find min diff of entries in B compared to looked up in A.
|
|
// Only compare equal rxCallsigns.
|
|
// So, we're looking at:
|
|
// - for any common rxCallsign
|
|
// - across all frequencies reported by that rxCallsign
|
|
// - what is the minimum difference in frequency seen?
|
|
GetMinFreqDiff(msgA, msgB)
|
|
{
|
|
return this.GetMinFreqDiffData(msgA, msgB).minDiff;
|
|
}
|
|
|
|
GetMinFreqDiffData(msgA, msgB, rxCall__rxRecordListAMap)
|
|
{
|
|
let rxCall__rxRecordListA = rxCall__rxRecordListAMap ?? this.MakeRxCallToRxRecordListMap(msgA);
|
|
let rxCall__rxRecordListB = this.MakeRxCallToRxRecordListMap(msgB, rxCall__rxRecordListA);
|
|
|
|
let minDiff = null;
|
|
let rxCallMatchList = [];
|
|
for (let [rxCall, rxRecordListB] of rxCall__rxRecordListB)
|
|
{
|
|
let rxRecordListA = rxCall__rxRecordListA.get(rxCall);
|
|
|
|
// unavoidable(?) M*N operation here, hopefully M and N are small
|
|
let diff = this.GetMinFreqDiffRxRecordList(rxRecordListA, rxRecordListB);
|
|
|
|
rxCallMatchList.push({
|
|
rxCall,
|
|
rxRecordListA,
|
|
rxRecordListB,
|
|
minFreqDiff: diff,
|
|
});
|
|
|
|
if (minDiff == null || diff < minDiff)
|
|
{
|
|
minDiff = diff;
|
|
}
|
|
}
|
|
|
|
return {
|
|
minDiff,
|
|
rxCall__rxRecordListA,
|
|
rxCall__rxRecordListB,
|
|
rxCallMatchList,
|
|
};
|
|
}
|
|
|
|
// Returns the smallest absolute difference between frequencies found in the two
|
|
// supplied record lists. This is an M*N operation.
|
|
//
|
|
// This function has no knowledge or assumptions about the contents of the
|
|
// two lists (ie whether the callsigns are the same).
|
|
//
|
|
// This is simply a function broken out to keep calling code simpler.
|
|
GetMinFreqDiffRxRecordList(rxRecordListA, rxRecordListB)
|
|
{
|
|
let minDiff = null;
|
|
|
|
for (let rxRecordA of rxRecordListA)
|
|
{
|
|
for (let rxRecordB of rxRecordListB)
|
|
{
|
|
let diff = Math.abs(rxRecordA.frequency - rxRecordB.frequency);
|
|
|
|
if (minDiff == null || diff < minDiff)
|
|
{
|
|
minDiff = diff;
|
|
}
|
|
}
|
|
}
|
|
|
|
return minDiff;
|
|
}
|
|
|
|
EstimateWindowFreqDrift(windowData)
|
|
{
|
|
let referenceAudit = windowData?.fingerprintingData?.referenceAudit;
|
|
if (!referenceAudit?.referenceMsg)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
let slotEstimateList = [];
|
|
for (let slot = (referenceAudit.referenceSlot + 1); slot < 5; ++slot)
|
|
{
|
|
let slotAudit = referenceAudit.slotAuditList?.[slot];
|
|
let slotDelta = this.EstimateWindowFreqDriftForSlot(slotAudit);
|
|
if (slotDelta == null)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
slotEstimateList.push({
|
|
deltaHz: slotDelta,
|
|
weight: slot - referenceAudit.referenceSlot,
|
|
});
|
|
}
|
|
|
|
if (slotEstimateList.length == 0)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
let weightedSum = 0;
|
|
let weightSum = 0;
|
|
for (const estimate of slotEstimateList)
|
|
{
|
|
weightedSum += estimate.deltaHz * estimate.weight;
|
|
weightSum += estimate.weight;
|
|
}
|
|
|
|
if (weightSum == 0)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
return Math.round(weightedSum / weightSum);
|
|
}
|
|
|
|
EstimateWindowFreqDriftForSlot(slotAudit)
|
|
{
|
|
if (!slotAudit?.msgAuditList?.length || !slotAudit?.msgMatchList?.length)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
let msgMatchSet = new Set(slotAudit.msgMatchList);
|
|
let rxCall__bestDelta = new Map();
|
|
|
|
for (const msgAudit of slotAudit.msgAuditList)
|
|
{
|
|
if (!msgMatchSet.has(msgAudit.msg))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
for (const rxCallMatch of msgAudit.rxCallMatchList || [])
|
|
{
|
|
let bestSignedDelta = this.GetBestSignedFreqDelta(rxCallMatch.rxRecordListA, rxCallMatch.rxRecordListB);
|
|
if (bestSignedDelta == null)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
let rxCall = rxCallMatch.rxCall;
|
|
if (!rxCall__bestDelta.has(rxCall))
|
|
{
|
|
rxCall__bestDelta.set(rxCall, bestSignedDelta);
|
|
continue;
|
|
}
|
|
|
|
let cur = rxCall__bestDelta.get(rxCall);
|
|
if (Math.abs(bestSignedDelta) < Math.abs(cur))
|
|
{
|
|
rxCall__bestDelta.set(rxCall, bestSignedDelta);
|
|
}
|
|
}
|
|
}
|
|
|
|
let deltaList = Array.from(rxCall__bestDelta.values());
|
|
if (deltaList.length == 0)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
return this.GetMedian(deltaList);
|
|
}
|
|
|
|
GetBestSignedFreqDelta(rxRecordListA, rxRecordListB)
|
|
{
|
|
if (!Array.isArray(rxRecordListA) || !Array.isArray(rxRecordListB))
|
|
{
|
|
return null;
|
|
}
|
|
|
|
let bestSignedDelta = null;
|
|
for (const rxRecordA of rxRecordListA)
|
|
{
|
|
for (const rxRecordB of rxRecordListB)
|
|
{
|
|
let freqA = Number(rxRecordA?.frequency);
|
|
let freqB = Number(rxRecordB?.frequency);
|
|
if (!Number.isFinite(freqA) || !Number.isFinite(freqB))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
let signedDelta = freqB - freqA;
|
|
if (bestSignedDelta == null || Math.abs(signedDelta) < Math.abs(bestSignedDelta))
|
|
{
|
|
bestSignedDelta = signedDelta;
|
|
}
|
|
}
|
|
}
|
|
|
|
return bestSignedDelta;
|
|
}
|
|
|
|
GetMedian(numList)
|
|
{
|
|
if (!numList || numList.length == 0)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
let list = [...numList].sort((a, b) => a - b);
|
|
let idxMid = Math.floor(list.length / 2);
|
|
if (list.length % 2 == 1)
|
|
{
|
|
return list[idxMid];
|
|
}
|
|
|
|
return (list[idxMid - 1] + list[idxMid]) / 2;
|
|
}
|
|
}
|