node-red-contrib-tak-registration 0.16.1 → 0.16.3

package/node_modules/marchingsquares/src/isolines.js

@@ -1,638 +0,0 @@
-/* eslint no-console: ["error", { allow: ["log"] }] */
-/* eslint-env browser,node */
-
-import {isoLineOptions} from './options.js';
-import {cell2Polygons, traceLinePaths} from './polygons.js';
-import {QuadTree} from './quadtree.js';
-
-
-/*
- * Compute the iso lines for a scalar 2D field given
- * a certain threshold by applying the Marching Squares
- * Algorithm. The function returns a list of path coordinates
- */
-
-function isoLines(input, threshold, options) {
-  var settings,
-    i,
-    j,
-    useQuadTree   = false,
-    multiLine     = false,
-    tree          = null,
-    root          = null,
-    data          = null,
-    cellGrid      = null,
-    linePolygons  = null,
-    ret           = [];
-
-  /* validation */
-  if (!input) throw new Error('data is required');
-  if (threshold === undefined || threshold === null) throw new Error('threshold is required');
-  if ((!!options) && (typeof options !== 'object')) throw new Error('options must be an object');
-
-  /* process options */
-  settings = isoLineOptions(options);
-
-  /* check for input data */
-  if (input instanceof QuadTree) {
-    tree = input;
-    root = input.root;
-    data = input.data;
-    if (!settings.noQuadTree)
-      useQuadTree = true;
-  } else if (Array.isArray(input) && Array.isArray(input[0])) {
-    data = input;
-  } else {
-    throw new Error('input is neither array of arrays nor object retrieved from \'QuadTree()\'');
-  }
-
-  /* check and prepare input threshold(s) */
-  if (Array.isArray(threshold)) {
-    multiLine = true;
-
-    /* activate QuadTree optimization if not explicitly forbidden by user settings */
-    if (!settings.noQuadTree)
-      useQuadTree = true;
-
-    /* check if all minV are numbers */
-    for (i = 0; i < threshold.length; i++)
-      if (isNaN(+threshold[i]))
-        throw new Error('threshold[' + i + '] is not a number');
-  } else {
-    if (isNaN(+threshold))
-      throw new Error('threshold must be a number or array of numbers');
-
-    threshold = [ threshold ];
-  }
-
-  /* create QuadTree root node if not already present */
-  if ((useQuadTree) && (!root)) {
-    tree = new QuadTree(data);
-    root = tree.root;
-    data = tree.data;
-  }
-
-  if (settings.verbose) {
-    if(settings.polygons)
-      console.log('MarchingSquaresJS-isoLines: returning single lines (polygons) for each grid cell');
-    else
-      console.log('MarchingSquaresJS-isoLines: returning line paths (polygons) for entire data grid');
-
-    if (multiLine)
-      console.log('MarchingSquaresJS-isoLines: multiple lines requested, returning array of line paths instead of lines for a single threshold');
-  }
-
-  /* Done with all input validation, now let's start computing stuff */
-
-  /* loop over all threhsold values */
-  threshold.forEach(function(t, i) {
-    linePolygons = [];
-
-    /* store bounds for current computation in settings object */
-    settings.threshold = t;
-
-    if(settings.verbose)
-      console.log('MarchingSquaresJS-isoLines: computing iso lines for threshold ' + t);
-
-    if (settings.polygons) {
-      /* compose list of polygons for each single cell */
-      if (useQuadTree) {
-        /* go through list of cells retrieved from QuadTree */
-        root
-          .cellsBelowThreshold(settings.threshold, true)
-          .forEach(function(c) {
-            linePolygons  = linePolygons.concat(
-              cell2Polygons(
-                prepareCell(data,
-                  c.x,
-                  c.y,
-                  settings),
-                c.x,
-                c.y,
-                settings
-              ));
-          });
-      } else {
-        /* go through entire array of input data */
-        for (j = 0; j < data.length - 1; ++j) {
-          for (i = 0; i < data[0].length - 1; ++i)
-            linePolygons  = linePolygons.concat(
-              cell2Polygons(
-                prepareCell(data,
-                  i,
-                  j,
-                  settings),
-                i,
-                j,
-                settings
-              ));
-        }
-      }
-    } else {
-      /* sparse grid of input data cells */
-      cellGrid = [];
-      for (i = 0; i < data[0].length - 1; ++i)
-        cellGrid[i] = [];
-
-      /* compose list of polygons for entire input grid */
-      if (useQuadTree) {
-        /* collect the cells */
-        root
-          .cellsBelowThreshold(settings.threshold, false)
-          .forEach(function(c) {
-            cellGrid[c.x][c.y] = prepareCell(data,
-              c.x,
-              c.y,
-              settings);
-          });
-      } else {
-        /* prepare cells */
-        for (i = 0; i < data[0].length - 1; ++i) {
-          for (j = 0; j < data.length - 1; ++j) {
-            cellGrid[i][j]  = prepareCell(data,
-              i,
-              j,
-              settings);
-          }
-        }
-      }
-
-      linePolygons = traceLinePaths(data, cellGrid, settings);
-    }
-
-    /* finally, add polygons to output array */
-    if (multiLine)
-      ret.push(linePolygons);
-    else
-      ret = linePolygons;
-
-    if(typeof settings.successCallback === 'function')
-      settings.successCallback(ret, t);
-
-  });
-
-  return ret;
-}
-
-/*
- * Thats all for the public interface, below follows the actual
- * implementation
- */
-
-/*
- * ################################
- * Isocontour implementation below
- * ################################
- */
-
-function prepareCell(grid, x, y, settings) {
-  var left,
-    right,
-    top,
-    bottom,
-    average,
-    cell;
-
-  var cval      = 0;
-  var x3        = grid[y + 1][x];
-  var x2        = grid[y + 1][x + 1];
-  var x1        = grid[y][x + 1];
-  var x0        = grid[y][x];
-  var threshold = settings.threshold;
-
-  /*
-   * Note that missing data within the grid will result
-   * in horribly failing to trace full polygon paths
-   */
-  if(isNaN(x0) || isNaN(x1) || isNaN(x2) || isNaN(x3)) {
-    return;
-  }
-
-  /*
-   * Here we detect the type of the cell
-   *
-   * x3 ---- x2
-   * |      |
-   * |      |
-   * x0 ---- x1
-   *
-   * with edge points
-   *
-   * x0 = (x,y),
-   * x1 = (x + 1, y),
-   * x2 = (x + 1, y + 1), and
-   * x3 = (x, y + 1)
-   *
-   * and compute the polygon intersections with the edges
-   * of the cell. Each edge value may be (i) smaller, or (ii)
-   * greater or equal to the iso line threshold. We encode
-   * this property using 1 bit of information, where
-   *
-   * 0 ... below,
-   * 1 ... above or equal
-   *
-   * Then we store the cells value as vector
-   *
-   * cval = (x0, x1, x2, x3)
-   *
-   * where x0 is the least significant bit (0th),
-   * x1 the 2nd bit, and so on. This essentially
-   * enables us to work with a single integer number
-   */
-
-  cval |= ((x3 >= threshold) ? 8 : 0);
-  cval |= ((x2 >= threshold) ? 4 : 0);
-  cval |= ((x1 >= threshold) ? 2 : 0);
-  cval |= ((x0 >= threshold) ? 1 : 0);
-
-  /* make sure cval is a number */
-  cval = +cval;
-
-  /* compose the cell object */
-  cell = {
-    cval:         cval,
-    polygons:     [],
-    edges:        {},
-    x0:           x0,
-    x1:           x1,
-    x2:           x2,
-    x3:           x3
-  };
-
-  /*
-   * Compute interpolated intersections of the polygon(s)
-   * with the cell borders and (i) add edges for polygon
-   * trace-back, or (ii) a list of small closed polygons
-   */
-  switch (cval) {
-  case 0:
-    if (settings.polygons)
-      cell.polygons.push([ [0, 0], [0, 1], [1, 1], [1, 0] ]);
-
-    break;
-
-  case 15:
-    /* cell is outside (above) threshold, no polygons */
-    break;
-
-  case 14: /* 1110 */
-    left    = settings.interpolate(x0, x3, threshold);
-    bottom  = settings.interpolate(x0, x1, threshold);
-
-    if (settings.polygons_full) {
-      cell.edges.left = {
-        path: [ [0, left], [bottom, 0] ],
-        move: {
-          x:      0,
-          y:      -1,
-          enter:  'top'
-        }
-      };
-    }
-
-    if (settings.polygons)
-      cell.polygons.push([ [0, 0], [0, left], [bottom, 0] ]);
-
-    break;
-
-  case 13: /* 1101 */
-    bottom  = settings.interpolate(x0, x1, threshold);
-    right   = settings.interpolate(x1, x2, threshold);
-
-    if (settings.polygons_full) {
-      cell.edges.bottom = {
-        path: [ [bottom, 0], [1, right] ],
-        move: {
-          x:      1,
-          y:      0,
-          enter:  'left'
-        }
-      };
-    }
-
-    if (settings.polygons)
-      cell.polygons.push([ [bottom, 0], [1, right], [1, 0] ]);
-
-    break;
-
-  case 11: /* 1011 */
-    right = settings.interpolate(x1, x2, threshold);
-    top   = settings.interpolate(x3, x2, threshold);
-
-    if (settings.polygons_full) {
-      cell.edges.right = {
-        path: [ [1, right], [top, 1] ],
-        move: {
-          x:      0,
-          y:      1,
-          enter:  'bottom'
-        }
-      };
-    }
-
-    if (settings.polygons)
-      cell.polygons.push([ [1, right], [top, 1], [1, 1] ]);
-
-    break;
-
-  case 7: /* 0111 */
-    left  = settings.interpolate(x0, x3, threshold);
-    top   = settings.interpolate(x3, x2, threshold);
-
-    if (settings.polygons_full) {
-      cell.edges.top = {
-        path: [ [top, 1], [0, left] ],
-        move: {
-          x:      -1,
-          y:      0,
-          enter:  'right'
-        }
-      };
-    }
-
-    if (settings.polygons)
-      cell.polygons.push([ [top, 1], [0, left], [0, 1] ]);
-
-    break;
-
-  case 1: /* 0001 */
-    left    = settings.interpolate(x0, x3, threshold);
-    bottom  = settings.interpolate(x0, x1, threshold);
-
-    if (settings.polygons_full) {
-      cell.edges.bottom = {
-        path: [ [bottom, 0], [0, left] ],
-        move: {
-          x:      -1,
-          y:      0,
-          enter:  'right'
-        }
-      };
-    }
-
-    if (settings.polygons)
-      cell.polygons.push([ [bottom, 0], [0, left], [0, 1], [1, 1], [1, 0] ]);
-
-    break;
-
-  case 2: /* 0010 */
-    bottom  = settings.interpolate(x0, x1, threshold);
-    right   = settings.interpolate(x1, x2, threshold);
-
-    if (settings.polygons_full) {
-      cell.edges.right = {
-        path: [ [1, right], [bottom, 0] ],
-        move: {
-          x:      0,
-          y:      -1,
-          enter:  'top'
-        }
-      };
-    }
-
-    if (settings.polygons)
-      cell.polygons.push([ [0, 0], [0, 1], [1, 1], [1, right], [bottom, 0] ]);
-
-    break;
-
-  case 4: /* 0100 */
-    right = settings.interpolate(x1, x2, threshold);
-    top   = settings.interpolate(x3, x2, threshold);
-
-    if (settings.polygons_full) {
-      cell.edges.top = {
-        path: [ [top, 1], [1, right] ],
-        move: {
-          x:      1,
-          y:      0,
-          enter:  'left'
-        }
-      };
-    }
-
-    if (settings.polygons)
-      cell.polygons.push([ [0, 0], [0, 1], [top, 1], [1, right], [1, 0] ]);
-
-    break;
-
-  case 8: /* 1000 */
-    left  = settings.interpolate(x0, x3, threshold);
-    top   = settings.interpolate(x3, x2, threshold);
-
-    if (settings.polygons_full) {
-      cell.edges.left = {
-        path: [ [0, left], [top, 1] ],
-        move: {
-          x:      0,
-          y:      1,
-          enter:  'bottom'
-        }
-      };
-    }
-
-    if (settings.polygons)
-      cell.polygons.push([ [0, 0], [0, left], [top, 1], [1, 1], [1, 0] ]);
-
-    break;
-
-  case 12: /* 1100 */
-    left  = settings.interpolate(x0, x3, threshold);
-    right = settings.interpolate(x1, x2, threshold);
-
-    if (settings.polygons_full) {
-      cell.edges.left = {
-        path: [ [0, left], [1, right] ],
-        move: {
-          x:      1,
-          y:      0,
-          enter:  'left'
-        }
-      };
-    }
-
-    if (settings.polygons)
-      cell.polygons.push([ [0, 0], [0, left], [1, right], [1, 0] ]);
-
-    break;
-
-  case 9: /* 1001 */
-    bottom  = settings.interpolate(x0, x1, threshold);
-    top     = settings.interpolate(x3, x2, threshold);
-
-    if (settings.polygons_full) {
-      cell.edges.bottom = {
-        path: [ [bottom, 0], [top, 1] ],
-        move: {
-          x:      0,
-          y:      1,
-          enter:  'bottom'
-        }
-      };
-    }
-
-    if (settings.polygons)
-      cell.polygons.push([ [bottom, 0], [top, 1], [1, 1], [1, 0] ]);
-
-    break;
-
-  case 3: /* 0011 */
-    left  = settings.interpolate(x0, x3, threshold);
-    right = settings.interpolate(x1, x2, threshold);
-
-    if (settings.polygons_full) {
-      cell.edges.right = {
-        path: [ [1, right], [0, left] ],
-        move: {
-          x:      -1,
-          y:      0,
-          enter:  'right'
-        }
-      };
-    }
-
-    if (settings.polygons)
-      cell.polygons.push([ [0, left], [0, 1], [1, 1], [1, right] ]);
-
-    break;
-
-  case 6: /* 0110 */
-    bottom  = settings.interpolate(x0, x1, threshold);
-    top     = settings.interpolate(x3, x2, threshold);
-
-    if (settings.polygons_full) {
-      cell.edges.top = {
-        path: [ [top, 1], [bottom, 0] ],
-        move: {
-          x:      0,
-          y:      -1,
-          enter:  'top'
-        }
-      };
-    }
-
-    if (settings.polygons)
-      cell.polygons.push([ [0, 0], [0, 1], [top, 1], [bottom, 0] ]);
-
-    break;
-
-  case 10: /* 1010 */
-    left    = settings.interpolate(x0, x3, threshold);
-    right   = settings.interpolate(x1, x2, threshold);
-    bottom  = settings.interpolate(x0, x1, threshold);
-    top     = settings.interpolate(x3, x2, threshold);
-    average = (x0 + x1 + x2 + x3) / 4;
-
-    if (settings.polygons_full) {
-      if (average < threshold) {
-        cell.edges.left = {
-          path: [ [0, left], [top, 1] ],
-          move: {
-            x:      0,
-            y:      1,
-            enter:  'bottom'
-          }
-        };
-        cell.edges.right = {
-          path: [ [1, right], [bottom, 0] ],
-          move: {
-            x:      0,
-            y:      -1,
-            enter:  'top'
-          }
-        };
-      } else {
-        cell.edges.right = {
-          path: [ [1, right], [top, 1] ],
-          move: {
-            x:      0,
-            y:      1,
-            enter:  'bottom'
-          }
-        };
-        cell.edges.left = {
-          path: [ [0, left], [bottom, 0] ],
-          move: {
-            x:      0,
-            y:      -1,
-            enter:  'top'
-          }
-        };
-      }
-    }
-
-    if (settings.polygons) {
-      if (average < threshold) {
-        cell.polygons.push([ [0, 0], [0, left], [top, 1], [1, 1], [1, right], [bottom, 0] ]);
-      } else {
-        cell.polygons.push([ [0, 0], [0, left], [bottom, 0] ]);
-        cell.polygons.push([ [top, 1], [1, 1], [1, right] ]);
-      }
-    }
-
-    break;
-
-  case 5: /* 0101 */
-    left    = settings.interpolate(x0, x3, threshold);
-    right   = settings.interpolate(x1, x2, threshold);
-    bottom  = settings.interpolate(x0, x1, threshold);
-    top     = settings.interpolate(x3, x2, threshold);
-    average = (x0 + x1 + x2 + x3) / 4;
-
-    if (settings.polygons_full) {
-      if (average < threshold) {
-        cell.edges.bottom = {
-          path: [ [bottom, 0], [0, left] ],
-          move: {
-            x:      -1,
-            y:      0,
-            enter:  'right'
-          }
-        };
-        cell.edges.top = {
-          path: [ [top, 1], [1, right] ],
-          move: {
-            x:      1,
-            y:      0,
-            enter:  'left'
-          }
-        };
-      } else {
-        cell.edges.top = {
-          path: [ [top, 1], [0, left] ],
-          move: {
-            x:      -1,
-            y:      0,
-            enter:  'right'
-          }
-        };
-        cell.edges.bottom = {
-          path: [ [bottom, 0], [1, right] ],
-          move: {
-            x:      1,
-            y:      0,
-            enter:  'left'
-          }
-        };
-      }
-    }
-
-    if (settings.polygons) {
-      if (average < threshold) {
-        cell.polygons.push([ [0, left], [0, 1], [top, 1], [1, right], [1, 0], [bottom, 0] ]);
-      } else {
-        cell.polygons.push([ [0, left], [0, 1], [top, 1] ]);
-        cell.polygons.push([ [bottom, 0], [1, right], [1, 0] ]);
-      }
-    }
-
-    break;
-  }
-
-  return cell;
-}
-
-
-export {
-  isoLines,
-  isoLines as isoContours
-};

package/node_modules/marchingsquares/src/main.js

@@ -1,4 +0,0 @@
-
-export * from './isolines.js';
-export * from './isobands.js';
-export * from './quadtree.js';

package/node_modules/marchingsquares/src/options.js

@@ -1,80 +0,0 @@
-
-import * as interpolate from './interpolation';
-
-
-function Options() {
-  /* Settings common to all implemented algorithms */
-  this.successCallback  = null;
-  this.verbose          = false;
-  this.polygons         = false;
-  this.polygons_full    = false;
-  this.linearRing       = true;
-  this.noQuadTree       = false;
-  this.noFrame          = false;
-}
-
-
-/* Compose settings specific to IsoBands algorithm */
-function isoBandOptions(userSettings) {
-  var i,
-    key,
-    val,
-    bandOptions,
-    optionKeys;
-
-  bandOptions   = new Options();
-  userSettings  = userSettings ? userSettings : {};
-  optionKeys    = Object.keys(bandOptions);
-
-  for(i = 0; i < optionKeys.length; i++) {
-    key = optionKeys[i];
-    val = userSettings[key];
-    if ((typeof val !== 'undefined') && (val !== null))
-      bandOptions[key] = val;
-  }
-
-  /* restore compatibility */
-  bandOptions.polygons_full  = !bandOptions.polygons;
-
-  /* add interpolation functions (not yet user customizable) */
-  bandOptions.interpolate   = interpolate.linear_ab;
-  bandOptions.interpolate_a = interpolate.linear_a;
-  bandOptions.interpolate_b = interpolate.linear_b;
-
-  return bandOptions;
-}
-
-
-/* Compose settings specific to IsoLines algorithm */
-function isoLineOptions(userSettings) {
-  var i,
-    key,
-    val,
-    lineOptions,
-    optionKeys;
-
-  lineOptions   = new Options();
-  userSettings  = userSettings ? userSettings : {};
-  optionKeys    = Object.keys(lineOptions);
-
-  for(i = 0; i < optionKeys.length; i++) {
-    key = optionKeys[i];
-    val = userSettings[key];
-    if ((typeof val !== 'undefined') && (val !== null))
-      lineOptions[key] = val;
-  }
-
-  /* restore compatibility */
-  lineOptions.polygons_full  = !lineOptions.polygons;
-
-  /* add interpolation functions (not yet user customizable) */
-  lineOptions.interpolate   = interpolate.linear;
-
-  return lineOptions;
-}
-
-
-export {
-  isoBandOptions,
-  isoLineOptions
-};