Change velocity-difference threshold calculation method and misc small non-functional changes (reverted from commit bb18055c66)

src/interpolation/interpolationPivots.js

@@ -1,98 +1,287 @@
-import {pointOnCircle, takeSampleFrom} from "./helpers";
+export default function(sampleSet, remainderSet, interpSubset, nPivots, distanceFunction) {
-import {placeNearToNearestNeighbour} from "./interpCommon";
+  var distance = distanceFunction;
 
-export default function(sampleSet, remainderSet, numPivots, distanceFn) {
   // Pivot based parent finding
-  let numBuckets = Math.floor(Math.sqrt(sampleSet.length));
-  let pivots = takeSampleFrom(sampleSet, numPivots);
-  console.log("Pivots", pivots);
-  // Common temporary variables
-  let i, j, pivot, sample, bucketWidth; // Temp var, declared seperately to avoid GC
 
-  let pivotsBuckets = []; // [ For each Pivot:[For each bucket:[each point in bucket]] ]
+  var numBuckets = Math.floor(Math.sqrt(sampleSet.length)),
+    numPivots = nPivots,
+    parents = [],
+    maxDists = [],
+    bucketWidths = [],
+    pivotsBuckets = [];
 
-  for (i = 0; i < numPivots; i++) {
+  console.log("Parents, pivots=", numPivots);
+
+  var pivots = createRandomSample(sampleSet.concat(remainderSet), sampleSet.length, numPivots);
+
+  for (var i = 0; i < numPivots; i++) {
     pivotsBuckets[i] = [];
-    for (j = 0; j < numBuckets; j++) {
+    for (var j = 0; j < numBuckets; j++) {
       pivotsBuckets[i][j] = [];
     }
   }
 
-  // Pre-calculate distance between each sample to each pivot
+  // Pre-processing
-  let distCache = [], // [ For each Sample:[For each Pivot: distance] ]
+  var fullDists = []
-    bucketWidths = []; // [ For each Pivot: width of each bucket ]
+  for (var i = 0; i < sampleSet.length; i++) {
+    fullDists[i] = [];
+  }
 
-  for (i = 0; i < sampleSet.length; i++)
+  for (var j = 0, maxDist = -1; j < numPivots; j++) {
-    distCache[i] = [];
+    var c1 = pivots[j];
-
+    for (var i = 0; i < sampleSet.length; i++) {
-  for (j = 0; j < numPivots; j++) {
+      var c2 = sampleSet[i];
-    pivot = pivots[j],
+      if (c1 !== c2) {
-      maxDist = -1;
+        var dist = distance(c1, c2, props, norm);
-
+        // console.log(dist, c1, c2);
-    for (i = 0; i < sampleSet.length; i++) {
+        if (dist > maxDist) {
-      sample = sampleSet[i];
+          maxDist = dist;
-      if (pivot !== sample) {
+        }
-        distCache[i][j] = distanceFn(pivot, sample);
+        fullDists[i][j] = dist;
-        if (distCache[i][j] > maxDist)
-          maxDist = distCache[i][j];
       } else {
-        distCache[i][j] = 0;
+        fullDists[i][j] = 0.0001;
       }
     }
-
+    maxDists.push(maxDist);
     bucketWidths.push(maxDist / numBuckets);
   }
 
-  // console.log(distCaches);
+  // console.log(fullDists);
 
-  // Put samples (pivot included) into buckets
+  for (var j = 0; j < numPivots; j++) {
-  for (j = 0; j < numPivots; j++) {
+    var bucketWidth = bucketWidths[j];
-    bucketWidth = bucketWidths[j];
+    for (var i = 0; i < sampleSet.length; i++) {
-    for (i = 0; i < sampleSet.length; i++) {
+      var tmp = pivotsBuckets[j][Math.floor((fullDists[i][j] - 0.0001) / bucketWidth)];
-      sample = sampleSet[i];
+      // pivotsBuckets[j][Math.floor((fullDists[i][j] - 0.0001) / bucketWidth)].push(sampleSet[i]);
-      pivotsBuckets[j][Math.floor(distCache[i][j] / bucketWidth)].push(sample);
+      // console.log(tmp, i, j, bucketWidth, Math.floor((fullDists[i][j] - 0.0001) / bucketWidth));
+      tmp.push(sampleSet[i]);
     }
   }
 
-
+  for (var i = 0; i < remainderSet.length; i++) {
-  //Plot each of the remainder nodes
+    var node = remainderSet[i],
-  for (let node of remainderSet) {
+      minNode = sampleSet[0],
-    let sampleSubsetDistanceCache = [],
+      minDist = 0,
-      sampleSubset = takeSampleFrom(sampleSet, Math.sqrt(sampleSet.length)).sample;
+      sampleCache = [];
 
     // Pivot based parent search
-    for (let p = 0; p < numPivots; p++) {
-      let pivot = pivots[p];
-      let bucketWidth = bucketWidths[p];
 
-      let dist = distanceFn(node, pivot);
+    var node = remainderSet[i];
-      let index = sampleSubset.indexOf(pivot);
+    var clDist = Number.MAX_VALUE;
-      if (index !== -1)
+    for (var p = 0; p < numPivots; p++) {
-        sampleSubsetDistanceCache[index] = dist;
+      var comp = pivots[p];
-
+      var bucketWidth = bucketWidths[p];
-      let bucketNumber = Math.floor(dist / bucketWidth);
+      if (node !== comp) {
-      if (bucketNumber >= numBuckets) {
+        var dist = distance(node, comp, props, norm);
-        bucketNumber = numBuckets - 1;
+        var bNum = Math.floor((dist - 0.0001) / bucketWidth);
-      } else if (bucketNumber < 0) {  // Should never be negative anyway
+        if (bNum >= numBuckets) {
-        bucketNumber = 0;
+          bNum = numBuckets - 1;
-      }
+        } else if (bNum < 0) {
-
+          bNum = 0;
-      let clDist, minNode;
+        }
-      for (let candidateNode of pivotsBuckets[p][bucketNumber]) {
+        var bucketContents = pivotsBuckets[p][bNum];
-
+        for (var w = 0; w < bucketContents.length; w++) {
-        dist = distanceFn(candidateNode, node);
+          var c1 = bucketContents[w];
-        if (candidateNode <= clDist) {
+          if (c1 != node) {
-          clDist = candidateNode;
+            dist = distance(c1, node, props, norm);
-          minNode = bucketContents[w];
+            if (dist <= clDist) {
+              clDist = dist;
+              minNode = bucketContents[w];
+            }
+          }
         }
       }
     }
 
-    for (let k = 0; k < sampleSubset.length; k++) {
+
-      if (sampleSubsetDistanceCache[k] !== undefined)
+    for (var k = 0; k < interpSubset.length; k++) {
-        sampleSubsetDistanceCache[k] = distanceFn(node, sampleSubset[k]);
+      sampleCache[k] = distance(node, interpSubset[k], props, norm);
     }
-    let radius = distanceFn(node, minNode);
+    var radius = distance(node, minNode, props, norm);
-    placeNearToNearestNeighbour(node, minNode, radius, sampleSubset, sampleSubsetDistanceCache);
+    placeNearToNearestNeighbour(node, minNode, interpSubset, sampleCache, radius);
   }
 }
+
+
+function placeNearToNearestNeighbour(node, minNode, sample, sampleCache, radius) {
+  var
+    dist0 = 0.0,
+    dist90 = 0.0,
+    dist180 = 0.0,
+    dist270 = 0.0,
+    lowBound = 0.0,
+    highBound = 0.0;
+
+  dist0 = sumDistToSample(node, centerPoint(0, radius, minNode.x, minNode.y), sample, sampleCache);
+  dist90 = sumDistToSample(node, centerPoint(90, radius, minNode.x, minNode.y), sample, sampleCache);
+  dist180 = sumDistToSample(node, centerPoint(180, radius, minNode.x, minNode.y), sample, sampleCache);
+  dist270 = sumDistToSample(node, centerPoint(270, radius, minNode.x, minNode.y), sample, sampleCache);
+
+  // console.log(dist0, dist90, dist180, dist270);
+
+  // Determine the closest quadrant
+
+  if (dist0 == dist180) {
+    if (dist90 > dist270)
+      lowBound = highBound = 270;
+    else
+      lowBound = highBound = 90;
+
+  } else if (dist90 == dist270) {
+    if (dist0 > dist180)
+      lowBound = highBound = 180;
+    else
+      lowBound = highBound = 0;
+  } else if (dist0 > dist180) {
+    if (dist90 > dist270) {
+      lowBound = 180;
+      highBound = 270;
+    } else {
+      lowBound = 90;
+      highBound = 180;
+    }
+  } else {
+    if (dist90 > dist270) {
+      lowBound = 270;
+      highBound = 360;
+    } else {
+      lowBound = 0;
+      highBound = 90;
+    }
+  }
+
+  var angle = binarySearch(lowBound, highBound, minNode.x, minNode.y, radius, node, sample, sampleCache);
+  var newPoint = centerPoint(angle, radius, minNode.x, minNode.y);
+
+  // console.log(newPoint);
+  node.x = newPoint.x;
+  node.y = newPoint.y;
+
+  // for (var i = 0; i < 20; i++) {
+  //   var forces = sumForcesToSample(node, sample, sampleCache);
+  //   // console.log(forces);
+  //   node.x += forces.x;
+  //   node.y += forces.y;
+  // }
+
+}
+
+
+function centerPoint(angle, radius, posX, posY) {
+  var x = posX + Math.cos(toRadians(angle) * radius);
+  var y = posY + Math.sin(toRadians(angle) * radius);
+
+  return {
+    x: x,
+    y: y
+  };
+}
+
+function toRadians(degrees) {
+  return degrees * (Math.PI / 180);
+}
+
+function sumDistToSample(node, point, sample, sampleCache) {
+  var total = 0.0;
+  // console.log(total, sample);
+
+  for (var i = 0; i < sample.length; i++) {
+    var s = sample[i];
+    var realDist = Math.hypot(s.x - point.x, s.y - point.y);
+    var desDist = sampleCache[i];
+    total += Math.abs(realDist - desDist);
+  }
+
+  return total;
+}
+
+
+function sumForcesToSample(node, sample, sampleCache) {
+  var x = 0,
+    y = 0,
+    // len = 0,
+    dist = 0,
+    force,
+    SPRING_FORCE = 0.7;
+
+  for (var i = 0, unitX, unitY; i < sample.length; i++) {
+    var s = sample[i];
+    if (s !== node) {
+      unitX = s.x - node.x;
+      unitY = s.y - node.y;
+
+      // Normalize coordinates
+      len = Math.sqrt(unitX * unitX + unitY * unitY);
+      unitX /= len;
+      unitY /= len;
+
+      console.log(unitX, unitY);
+
+      var realDist = Math.sqrt(unitX * unitX + unitY * unitY);
+      var desDist = sampleCache[i];
+      dist += realDist - desDist;
+      force = (SPRING_FORCE * dist);
+
+      x += unitX * force;
+      y += unitY * force;
+    }
+
+    x *= (1.0 / sample.length);
+    y *= (1.0 / sample.length);
+
+    return {
+      x: x,
+      y: y
+    };
+  }
+}
+
+function createRandomSample(nodes, max, size) {
+  var randElements = [];
+
+  for (var i = 0; i < size; ++i) {
+    // Stop when no new elements can be found.
+    if (randElements.size >= nodes.length) {
+      break;
+    }
+    var rand = Math.floor((Math.random() * max));
+    // If the rand is already in random list or in exclude list
+    // ignore it and get a new value.
+    while (randElements.includes(rand)) {
+      rand = Math.floor((Math.random() * max));
+    }
+    randElements.push(nodes[rand]);
+  }
+
+  return randElements;
+}
+
+
+function binarySearch(lb, hb, x, y, r, node, sample, sampleCache) {
+  while (lb <= hb) {
+    var mid = Math.round((lb + hb) / 2);
+
+    if ((mid === lb) || (mid === hb)) {
+      if (sumDistToSample(node, centerPoint(lb, r, x, y), sample, sampleCache) >=
+        sumDistToSample(node, centerPoint(hb, r, x, y), sample, sampleCache)) {
+        return hb;
+      } else {
+        return lb;
+      }
+    } else {
+      var distMidLeft = sumDistToSample(node, centerPoint(mid + 1, r, x, y), sample, sampleCache);
+      var distMidRight = sumDistToSample(node, centerPoint(mid - 1, r, x, y), sample, sampleCache);
+      var distMid = sumDistToSample(node, centerPoint(mid, r, x, y), sample, sampleCache);
+
+      if (distMid > distMidLeft) {
+        lb = mid + 1;
+      } else if (distMid > distMidRight) {
+        hb = mid - 1;
+      } else {
+        return mid;
+      }
+    }
+  }
+
+  return -1;
+}