133 lines
5.0 KiB
JavaScript
133 lines
5.0 KiB
JavaScript
import {pointOnCircle, takeSampleFrom} from "./helpers";
|
|
import {placeNearToNearestNeighbour} from "./interpCommon";
|
|
|
|
/**
|
|
* Perform interpolation where the near neighbour is estimated by pivot-based searching.
|
|
* - Pre-processing: assign random samples as pivots,
|
|
* put the others in each pivot's bucket.
|
|
* ie. non-pivot sample X may be in
|
|
* - bucket 3 of pivot A,
|
|
* - bucket 1 of pivot B,
|
|
* - bucket 5 of pivot C,
|
|
* all at the same time
|
|
* For each point to be interpolated:
|
|
* - Phase 1: for each pivot: compare distance against the pivot
|
|
* compare against other points in the same bucket of that pivot
|
|
* note down the nearest neighbour found
|
|
* - Phase 2 and 3 are passed onto placeNearToNearestNeighbour
|
|
* @param {list} sampleSet - nodes already plotted on the 2D graph
|
|
* @param {list} remainderSet - nodes to be interpolated onto the graph
|
|
* @param {function} distanceFn - f(nodex, nodey) that calculate high-dimensional
|
|
* distance between 2 nodes
|
|
* @param {number} endingIts - for phase 3, how many iterations to refine the
|
|
* placement of each interpolated point
|
|
*/
|
|
export default function(sampleSet, remainderSet, numPivots, distanceFn, endingIts) {
|
|
// Pivot based parent finding
|
|
let numBuckets = Math.floor(Math.sqrt(sampleSet.length));
|
|
let numNonPivots = sampleSet.length - numPivots;
|
|
let sets = takeSampleFrom(sampleSet, numPivots);
|
|
let pivots = sets.sample;
|
|
let nonPivotSamples = sets.remainder;
|
|
|
|
let pivotsBuckets = []; // [ For each Pivot:[For each bucket:[each point in bucket]] ]
|
|
for (let i = 0; i < numPivots; i++) {
|
|
pivotsBuckets[i] = [];
|
|
for (let j = 0; j < numBuckets; j++) {
|
|
pivotsBuckets[i][j] = [];
|
|
}
|
|
}
|
|
|
|
// Pre-calculate distance between each non-pivot sample to each pivot
|
|
// At the same time, determine the bucket width for each pivot based on furthest non-pivot sample
|
|
let distCache = []; // [ For each non-pivot sample:[For each Pivot: distance] ]
|
|
let bucketWidths = []; // [ For each Pivot: width of each bucket ]
|
|
|
|
for (let i = 0; i < nonPivotSamples.length; i++)
|
|
distCache[i] = [];
|
|
|
|
for (let j = 0; j < numPivots; j++) {
|
|
let pivot = pivots[j];
|
|
let maxDist = -1;
|
|
|
|
for (let i = 0; i < numNonPivots; i++) {
|
|
let sample = nonPivotSamples[i];
|
|
distCache[i][j] = distanceFn(pivot, sample);
|
|
if (distCache[i][j] > maxDist)
|
|
maxDist = distCache[i][j];
|
|
}
|
|
|
|
bucketWidths.push(maxDist / numBuckets);
|
|
}
|
|
|
|
// Put samples (pivot not included) into buckets
|
|
for (let j = 0; j < numPivots; j++) {
|
|
let bucketWidth = bucketWidths[j];
|
|
for (let i = 0; i < numNonPivots; i++) {
|
|
let sample = nonPivotSamples[i];
|
|
let bucketNumber = Math.floor(distCache[i][j] / bucketWidth);
|
|
if (bucketNumber >= numBuckets) {
|
|
bucketNumber = numBuckets - 1;
|
|
} else if (bucketNumber < 0) { // Should never be negative anyway
|
|
bucketNumber = 0;
|
|
}
|
|
pivotsBuckets[j][bucketNumber].push(sample);
|
|
}
|
|
}
|
|
// ---------------------------------------------------------------------
|
|
|
|
|
|
let sampleSubset = takeSampleFrom(sampleSet, Math.sqrt(sampleSet.length)).sample;
|
|
//Plot each of the remainder nodes
|
|
for (let node of remainderSet) {
|
|
let sampleSubsetDistanceCache = [],
|
|
minDist, nearSample;
|
|
|
|
// Pivot based parent search
|
|
for (let p = 0; p < numPivots; p++) {
|
|
let pivot = pivots[p];
|
|
let bucketWidth = bucketWidths[p];
|
|
|
|
let dist = distanceFn(node, pivot);
|
|
let index = sampleSubset.indexOf(pivot);
|
|
if (index !== -1) {
|
|
sampleSubsetDistanceCache[index] = dist;
|
|
}
|
|
if (minDist === undefined || dist < minDist){
|
|
minDist = dist;
|
|
nearSample = pivot;
|
|
}
|
|
|
|
let bucketNumber = Math.floor(dist / bucketWidth);
|
|
if (bucketNumber >= numBuckets) {
|
|
bucketNumber = numBuckets - 1;
|
|
} else if (bucketNumber < 0) { // Should never be negative anyway
|
|
bucketNumber = 0;
|
|
}
|
|
|
|
for (let candidateNode of pivotsBuckets[p][bucketNumber]) {
|
|
let index = sampleSubset.indexOf(candidateNode);
|
|
if (index !== -1 && sampleSubsetDistanceCache[index] !== undefined)
|
|
dist = sampleSubsetDistanceCache[index]
|
|
else {
|
|
dist = distanceFn(candidateNode, node);
|
|
if (index !== -1)
|
|
sampleSubsetDistanceCache[index] = dist;
|
|
}
|
|
|
|
if (dist < minDist){
|
|
minDist = dist;
|
|
nearSample = candidateNode;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Fill in holes in cache
|
|
for (let k = 0; k < sampleSubset.length; k++) {
|
|
if (sampleSubsetDistanceCache[k] === undefined)
|
|
sampleSubsetDistanceCache[k] = distanceFn(node, sampleSubset[k]);
|
|
}
|
|
placeNearToNearestNeighbour(node, nearSample, minDist, sampleSubset, sampleSubsetDistanceCache, endingIts);
|
|
}
|
|
}
|