node-red-contrib-tak-registration 0.2.1 → 0.3.1

package/node_modules/turf-jsts/src/org/locationtech/jts/util/GeometricShapeFactory.js

@@ -0,0 +1,266 @@
+import GeometryFactory from '../geom/GeometryFactory'
+import Coordinate from '../geom/Coordinate'
+import AffineTransformation from '../geom/util/AffineTransformation'
+import Envelope from '../geom/Envelope'
+
+export default class GeometricShapeFactory {
+  constructor () {
+    this._geomFact = null
+    this._precModel = null
+    this._dim = new Dimensions()
+    this._nPts = 100
+    this._rotationAngle = 0.0
+    if (arguments.length === 0) {
+      GeometricShapeFactory.call(this, new GeometryFactory())
+    } else if (arguments.length === 1) {
+      const geomFact = arguments[0]
+      this._geomFact = geomFact
+      this._precModel = geomFact.getPrecisionModel()
+    }
+  }
+  createSupercircle (power) {
+    const recipPow = 1.0 / power
+    const radius = this._dim.getMinSize() / 2
+    const centre = this._dim.getCentre()
+    const r4 = Math.pow(radius, power)
+    const y0 = radius
+    const xyInt = Math.pow(r4 / 2, recipPow)
+    const nSegsInOct = Math.trunc(this._nPts / 8)
+    const totPts = nSegsInOct * 8 + 1
+    const pts = new Array(totPts).fill(null)
+    const xInc = xyInt / nSegsInOct
+    for (let i = 0; i <= nSegsInOct; i++) {
+      let x = 0.0
+      let y = y0
+      if (i !== 0) {
+        x = xInc * i
+        const x4 = Math.pow(x, power)
+        y = Math.pow(r4 - x4, recipPow)
+      }
+      pts[i] = this.coordTrans(x, y, centre)
+      pts[2 * nSegsInOct - i] = this.coordTrans(y, x, centre)
+      pts[2 * nSegsInOct + i] = this.coordTrans(y, -x, centre)
+      pts[4 * nSegsInOct - i] = this.coordTrans(x, -y, centre)
+      pts[4 * nSegsInOct + i] = this.coordTrans(-x, -y, centre)
+      pts[6 * nSegsInOct - i] = this.coordTrans(-y, -x, centre)
+      pts[6 * nSegsInOct + i] = this.coordTrans(-y, x, centre)
+      pts[8 * nSegsInOct - i] = this.coordTrans(-x, y, centre)
+    }
+    pts[pts.length - 1] = new Coordinate(pts[0])
+    const ring = this._geomFact.createLinearRing(pts)
+    const poly = this._geomFact.createPolygon(ring, null)
+    return this.rotate(poly)
+  }
+  setNumPoints (nPts) {
+    this._nPts = nPts
+  }
+  setBase (base) {
+    this._dim.setBase(base)
+  }
+  setRotation (radians) {
+    this._rotationAngle = radians
+  }
+  setWidth (width) {
+    this._dim.setWidth(width)
+  }
+  createEllipse () {
+    const env = this._dim.getEnvelope()
+    const xRadius = env.getWidth() / 2.0
+    const yRadius = env.getHeight() / 2.0
+    const centreX = env.getMinX() + xRadius
+    const centreY = env.getMinY() + yRadius
+    const pts = new Array(this._nPts + 1).fill(null)
+    let iPt = 0
+    for (let i = 0; i < this._nPts; i++) {
+      const ang = i * (2 * Math.PI / this._nPts)
+      const x = xRadius * Math.cos(ang) + centreX
+      const y = yRadius * Math.sin(ang) + centreY
+      pts[iPt++] = this.coord(x, y)
+    }
+    pts[iPt] = new Coordinate(pts[0])
+    const ring = this._geomFact.createLinearRing(pts)
+    const poly = this._geomFact.createPolygon(ring, null)
+    return this.rotate(poly)
+  }
+  coordTrans (x, y, trans) {
+    return this.coord(x + trans.x, y + trans.y)
+  }
+  createSquircle () {
+    return this.createSupercircle(4)
+  }
+  setEnvelope (env) {
+    this._dim.setEnvelope(env)
+  }
+  setCentre (centre) {
+    this._dim.setCentre(centre)
+  }
+  createArc (startAng, angExtent) {
+    const env = this._dim.getEnvelope()
+    const xRadius = env.getWidth() / 2.0
+    const yRadius = env.getHeight() / 2.0
+    const centreX = env.getMinX() + xRadius
+    const centreY = env.getMinY() + yRadius
+    let angSize = angExtent
+    if (angSize <= 0.0 || angSize > 2 * Math.PI) angSize = 2 * Math.PI
+    const angInc = angSize / (this._nPts - 1)
+    const pts = new Array(this._nPts).fill(null)
+    let iPt = 0
+    for (let i = 0; i < this._nPts; i++) {
+      const ang = startAng + i * angInc
+      const x = xRadius * Math.cos(ang) + centreX
+      const y = yRadius * Math.sin(ang) + centreY
+      pts[iPt++] = this.coord(x, y)
+    }
+    const line = this._geomFact.createLineString(pts)
+    return this.rotate(line)
+  }
+  rotate (geom) {
+    if (this._rotationAngle !== 0.0) {
+      const trans = AffineTransformation.rotationInstance(this._rotationAngle, this._dim.getCentre().x, this._dim.getCentre().y)
+      geom.apply(trans)
+    }
+    return geom
+  }
+  coord (x, y) {
+    const pt = new Coordinate(x, y)
+    this._precModel.makePrecise(pt)
+    return pt
+  }
+  createArcPolygon (startAng, angExtent) {
+    const env = this._dim.getEnvelope()
+    const xRadius = env.getWidth() / 2.0
+    const yRadius = env.getHeight() / 2.0
+    const centreX = env.getMinX() + xRadius
+    const centreY = env.getMinY() + yRadius
+    let angSize = angExtent
+    if (angSize <= 0.0 || angSize > 2 * Math.PI) angSize = 2 * Math.PI
+    const angInc = angSize / (this._nPts - 1)
+    const pts = new Array(this._nPts + 2).fill(null)
+    let iPt = 0
+    pts[iPt++] = this.coord(centreX, centreY)
+    for (let i = 0; i < this._nPts; i++) {
+      const ang = startAng + angInc * i
+      const x = xRadius * Math.cos(ang) + centreX
+      const y = yRadius * Math.sin(ang) + centreY
+      pts[iPt++] = this.coord(x, y)
+    }
+    pts[iPt++] = this.coord(centreX, centreY)
+    const ring = this._geomFact.createLinearRing(pts)
+    const poly = this._geomFact.createPolygon(ring, null)
+    return this.rotate(poly)
+  }
+  createRectangle () {
+    let i = null
+    let ipt = 0
+    let nSide = Math.trunc(this._nPts / 4)
+    if (nSide < 1) nSide = 1
+    const XsegLen = this._dim.getEnvelope().getWidth() / nSide
+    const YsegLen = this._dim.getEnvelope().getHeight() / nSide
+    const pts = new Array(4 * nSide + 1).fill(null)
+    const env = this._dim.getEnvelope()
+    for ((i = 0); i < nSide; i++) {
+      const x = env.getMinX() + i * XsegLen
+      const y = env.getMinY()
+      pts[ipt++] = this.coord(x, y)
+    }
+    for ((i = 0); i < nSide; i++) {
+      const x = env.getMaxX()
+      const y = env.getMinY() + i * YsegLen
+      pts[ipt++] = this.coord(x, y)
+    }
+    for ((i = 0); i < nSide; i++) {
+      const x = env.getMaxX() - i * XsegLen
+      const y = env.getMaxY()
+      pts[ipt++] = this.coord(x, y)
+    }
+    for ((i = 0); i < nSide; i++) {
+      const x = env.getMinX()
+      const y = env.getMaxY() - i * YsegLen
+      pts[ipt++] = this.coord(x, y)
+    }
+    pts[ipt++] = new Coordinate(pts[0])
+    const ring = this._geomFact.createLinearRing(pts)
+    const poly = this._geomFact.createPolygon(ring, null)
+    return this.rotate(poly)
+  }
+  createCircle () {
+    return this.createEllipse()
+  }
+  setHeight (height) {
+    this._dim.setHeight(height)
+  }
+  setSize (size) {
+    this._dim.setSize(size)
+  }
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return GeometricShapeFactory
+  }
+  static get Dimensions () { return Dimensions }
+}
+
+class Dimensions {
+  constructor () {
+    this.base = null
+    this.centre = null
+    this.width = null
+    this.height = null
+  }
+  setBase (base) {
+    this.base = base
+  }
+  setWidth (width) {
+    this.width = width
+  }
+  getBase () {
+    return this.base
+  }
+  getWidth () {
+    return this.width
+  }
+  setEnvelope (env) {
+    this.width = env.getWidth()
+    this.height = env.getHeight()
+    this.base = new Coordinate(env.getMinX(), env.getMinY())
+    this.centre = new Coordinate(env.centre())
+  }
+  setCentre (centre) {
+    this.centre = centre
+  }
+  getMinSize () {
+    return Math.min(this.width, this.height)
+  }
+  getEnvelope () {
+    if (this.base !== null) {
+      return new Envelope(this.base.x, this.base.x + this.width, this.base.y, this.base.y + this.height)
+    }
+    if (this.centre !== null) {
+      return new Envelope(this.centre.x - this.width / 2, this.centre.x + this.width / 2, this.centre.y - this.height / 2, this.centre.y + this.height / 2)
+    }
+    return new Envelope(0, this.width, 0, this.height)
+  }
+  getCentre () {
+    if (this.centre === null) {
+      this.centre = new Coordinate(this.base.x + this.width / 2, this.base.y + this.height / 2)
+    }
+    return this.centre
+  }
+  getHeight () {
+    return this.height
+  }
+  setHeight (height) {
+    this.height = height
+  }
+  setSize (size) {
+    this.height = size
+    this.width = size
+  }
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return Dimensions
+  }
+}

package/node_modules/turf-jsts/src/org/locationtech/jts/util/Memory.js

@@ -0,0 +1,47 @@
+export default class Memory {
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return Memory
+  }
+  static used () {
+    // var runtime = Runtime.getRuntime()
+    // return runtime.totalMemory() - runtime.freeMemory()
+  }
+  static format (mem) {
+    if (mem < 2 * Memory.KB) return mem + ' bytes'
+    if (mem < 2 * Memory.MB) return Memory.round(mem / Memory.KB) + ' KB'
+    if (mem < 2 * Memory.GB) return Memory.round(mem / Memory.MB) + ' MB'
+    return Memory.round(mem / Memory.GB) + ' GB'
+  }
+  static freeString () {
+    return Memory.format(Memory.free())
+  }
+  static total () {
+    // var runtime = Runtime.getRuntime()
+    // return runtime.totalMemory()
+  }
+  static usedTotalString () {
+    return 'Used: ' + Memory.usedString() + '   Total: ' + Memory.totalString()
+  }
+  static usedString () {
+    return Memory.format(Memory.used())
+  }
+  static allString () {
+    return 'Used: ' + Memory.usedString() + '   Free: ' + Memory.freeString() + '   Total: ' + Memory.totalString()
+  }
+  static round (d) {
+    return Math.ceil(d * 100) / 100
+  }
+  static totalString () {
+    return Memory.format(Memory.total())
+  }
+  static free () {
+    // var runtime = Runtime.getRuntime()
+    // return runtime.freeMemory()
+  }
+  static get KB () { return 1024 }
+  static get MB () { return 1048576 }
+  static get GB () { return 1073741824 }
+}

package/node_modules/turf-jsts/src/org/locationtech/jts/util/NumberUtil.js

@@ -0,0 +1,11 @@
+export default class NumberUtil {
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return NumberUtil
+  }
+  equalsWithTolerance (x1, x2, tolerance) {
+    return Math.abs(x1 - x2) <= tolerance
+  }
+};

package/node_modules/turf-jsts/src/org/locationtech/jts/util/ObjectCounter.js

@@ -0,0 +1,44 @@
+import HashMap from '../../../../java/util/HashMap'
+
+export default class ObjectCounter {
+  constructor () {
+    this._counts = new HashMap()
+  }
+  count (o) {
+    var counter = this._counts.get(o)
+    if (counter === null) return 0; else return counter.count()
+  }
+  add (o) {
+    var counter = this._counts.get(o)
+    if (counter === null) this._counts.put(o, new Counter(1)); else counter.increment()
+  }
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return ObjectCounter
+  }
+  static get Counter () { return Counter }
+}
+
+class Counter {
+  constructor () {
+    this.count = 0
+    if (arguments.length === 0) {} else if (arguments.length === 1) {
+      let count = arguments[0]
+      this.count = count
+    }
+  }
+  count () {
+    return this.count
+  }
+  increment () {
+    this.count++
+  }
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return Counter
+  }
+}

package/node_modules/turf-jsts/src/org/locationtech/jts/util/PriorityQueue.js

@@ -0,0 +1,55 @@
+import ArrayList from '../../../../java/util/ArrayList'
+
+export default class PriorityQueue {
+  constructor () {
+    this._size = null
+    this._items = null
+    this._size = 0
+    this._items = new ArrayList()
+    this._items.add(null)
+  }
+  poll () {
+    if (this.isEmpty()) return null
+    const minItem = this._items.get(1)
+    this._items.set(1, this._items.get(this._size))
+    this._size -= 1
+    this.reorder(1)
+    return minItem
+  }
+  size () {
+    return this._size
+  }
+  reorder (hole) {
+    let child = null
+    const tmp = this._items.get(hole)
+    for (; hole * 2 <= this._size; hole = child) {
+      child = hole * 2
+      if (child !== this._size && this._items.get(child + 1).compareTo(this._items.get(child)) < 0) child++
+      if (this._items.get(child).compareTo(tmp) < 0) this._items.set(hole, this._items.get(child)); else break
+    }
+    this._items.set(hole, tmp)
+  }
+  clear () {
+    this._size = 0
+    this._items.clear()
+  }
+  isEmpty () {
+    return this._size === 0
+  }
+  add (x) {
+    this._items.add(null)
+    this._size += 1
+    let hole = this._size
+    this._items.set(0, x)
+    for (; x.compareTo(this._items.get(Math.trunc(hole / 2))) < 0; hole /= 2) {
+      this._items.set(hole, this._items.get(Math.trunc(hole / 2)))
+    }
+    this._items.set(hole, x)
+  }
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return PriorityQueue
+  }
+}

package/node_modules/turf-jsts/src/org/locationtech/jts/util/StringUtil.js

@@ -0,0 +1,79 @@
+import PrintStream from '../../../../java/io/PrintStream'
+import StringReader from '../../../../java/io/StringReader'
+import DecimalFormat from '../../../../java/text/DecimalFormat'
+import System from '../../../../java/lang/System'
+import ArrayList from '../../../../java/util/ArrayList'
+import ByteArrayOutputStream from '../../../../java/io/ByteArrayOutputStream'
+import Assert from './Assert'
+import IOException from '../../../../java/io/IOException'
+import LineNumberReader from '../../../../java/io/LineNumberReader'
+
+export default class StringUtil {
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return StringUtil
+  }
+  static chars (c, n) {
+    const ch = new Array(n).fill(null)
+    for (let i = 0; i < n; i++) {
+      ch[i] = c
+    }
+    return String(ch)
+  };
+  static getStackTrace () {
+    if (arguments.length === 1) {
+      const t = arguments[0]
+      const os = new ByteArrayOutputStream()
+      const ps = new PrintStream(os)
+      t.printStackTrace(ps)
+      return os.toString()
+    } else if (arguments.length === 2) {
+      const t = arguments[0]
+      const depth = arguments[1]
+      let stackTrace = ''
+      const stringReader = new StringReader(StringUtil.getStackTrace(t))
+      const lineNumberReader = new LineNumberReader(stringReader)
+      for (let i = 0; i < depth; i++) {
+        try {
+          stackTrace += lineNumberReader.readLine() + StringUtil.NEWLINE
+        } catch (e) {
+          if (e instanceof IOException) {
+            Assert.shouldNeverReachHere()
+          } else throw e
+        } finally {}
+      }
+      return stackTrace
+    }
+  }
+  static split (s, separator) {
+    const separatorlen = separator.length
+    const tokenList = new ArrayList()
+    let tmpString = '' + s
+    let pos = tmpString.indexOf(separator)
+    while (pos >= 0) {
+      const token = tmpString.substring(0, pos)
+      tokenList.add(token)
+      tmpString = tmpString.substring(pos + separatorlen)
+      pos = tmpString.indexOf(separator)
+    }
+    if (tmpString.length > 0) tokenList.add(tmpString)
+    const res = new Array(tokenList.size()).fill(null)
+    for (let i = 0; i < res.length; i++) {
+      res[i] = tokenList.get(i)
+    }
+    return res
+  }
+  static toString () {
+    if (arguments.length === 1) {
+      const d = arguments[0]
+      return StringUtil.SIMPLE_ORDINATE_FORMAT.format(d)
+    }
+  }
+  static spaces (n) {
+    return StringUtil.chars(' ', n)
+  }
+  static get NEWLINE () { return System.getProperty('line.separator') }
+  static get SIMPLE_ORDINATE_FORMAT () { return new DecimalFormat('0.#') }
+}

package/node_modules/turf-jsts/src/org/locationtech/jts/util/UniqueCoordinateArrayFilter.js

@@ -0,0 +1,33 @@
+import TreeSet from '../../../../java/util/TreeSet'
+import CoordinateFilter from '../geom/CoordinateFilter'
+import ArrayList from '../../../../java/util/ArrayList'
+
+export default class UniqueCoordinateArrayFilter {
+  constructor () {
+    this.treeSet = new TreeSet()
+    this.list = new ArrayList()
+  }
+  filter (coord) {
+    if (!this.treeSet.contains(coord)) {
+      this.list.add(coord)
+      this.treeSet.add(coord)
+    }
+  }
+  getCoordinates () {
+    const coordinates = new Array(this.list.size()).fill(null)
+    return this.list.toArray(coordinates)
+  }
+  interfaces_ () {
+    return [CoordinateFilter]
+  }
+  getClass () {
+    return UniqueCoordinateArrayFilter
+  }
+  static filterCoordinates (coords) {
+    const filter = new UniqueCoordinateArrayFilter()
+    for (let i = 0; i < coords.length; i++) {
+      filter.filter(coords[i])
+    }
+    return filter.getCoordinates()
+  }
+}

package/package.json

@@ -1,32 +1,41 @@
 {
-    "name"          : "node-red-contrib-tak-registration",
-    "version"       : "0.2.1",
-    "description"   : "A Node-RED node to register to TAK and to help wrap files as datapackages to send to TAK",
-    "dependencies"  : {
+    "name": "node-red-contrib-tak-registration",
+    "version": "0.3.1",
+    "description": "A Node-RED node to register to TAK and to help wrap files as datapackages to send to TAK",
+    "dependencies": {
+        "@turf/turf": "^6.5.0",
         "adm-zip": "^0.5.9",
-        "axios": "^0.25.0",
+        "axios": "^0.26.1",
         "form-data": "^4.0.0",
         "uuid": "^8.3.2"
     },
     "bundledDependencies": [
+        "@turf/turf",
         "adm-zip",
         "axios",
         "form-data",
         "uuid"
     ],
-    "repository" : {
-        "type":"git",
-        "url":"https://github.com/dceejay/takreg/tree/master/"
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/dceejay/takreg/tree/master/"
     },
     "license": "Apache-2.0",
-    "keywords": [ "TAK" ],
-    "node-red" : {
-        "nodes" : {
-            "takfiles": "tak-registration.js"
+    "keywords": [
+        "TAK",
+        "node-red"
+    ],
+    "node-red": {
+        "version": ">=2.0.0",
+        "nodes": {
+            "tak registration": "tak-registration.js"
         }
     },
     "author": {
         "name": "Dave Conway-Jones",
         "email": "dceejay@gmail.com"
+    },
+    "engines": {
+        "node": ">=12"
     }
 }

package/tak-registration.html

@@ -64,6 +64,9 @@
         <label for="node-input-name"><i class="fa fa-tag"></i> Name</label>
         <input type="text" id="node-input-name">
     </div>
+    <div class="form-tips" id="pin-tip"><b>Note</b>: This node MUST be used in conjunction with a TCP request node,
+        configured to point to your TAK server tcp address and port (usually 8087 or 8089), set to return strings,
+        <i>keep connection open</i> mode, and split on "&lt;/event&gt;"</div>
 </script>
 <style>
     .inject-time-count {
@@ -122,8 +125,8 @@
 <script type="text/html" data-help-name="tak registration">
     <p>Registers a TAK gateway node and sets up a heartbeat.</p>
     <p>Works in conjunction with a TCP request node, set to point to the TAK server tcp address and port
-        (usually 8087 or 8089), set to return strings, <i>keep connection open</i> mode, and split on <code>&lt;event/&gt;</code>.</p>
-    <p>If the `msg.payload` is an XML string it will be passed directly though.</p>
+        (usually 8087 or 8089), set to return strings, <i>keep connection open</i> mode, and split on <code>&lt;/event&gt;</code>.</p>
+    <p>If the <code>msg.payload</code> is an XML string it will be passed directly though.</p>
 
     <h3>Sending data packages...</h3>
     <dl class="message-properties">
@@ -136,25 +139,26 @@
         <dd>each object must contain at least a <b>filename</b> (string) and <b>content</b> a buffer of the file/data.
             eg <code>[{filename:"foo.kml", content: &lt;buffer of the file&gt;}]</code></dd>
     </dl>
-
     <h3>Sending marker position...</h3>
     <dl class="message-properties">
         <dt>payload <span class="property-type">object</span></dt>
-        <dd>a "standard" <b>node-red worldmap</b> format msg.payload containing `name, lat, lon, type or SIDC,
-            (alt), (speed), (bearing), (layer)`, where type is the CoT type eg a-f-g-u or the SIDC is
-            the standard mil 2525C code, eg SFGPU. The layer will get turned int a hastag which can then
-            be selected on/off in the TAK app.</dd>
+        <dd>a "standard" <b>node-red worldmap</b> format msg.payload containing `name, lat, lon, SIDC or cottype or aistype,
+            (alt), (speed), (bearing), (layer)`, where SIDC is the standard mil 2525C code, eg SFGPU, or cottype is the
+            CoT type, eg a-f-g-u, or aistype is the AIS type code, eg 80 for a tanker. The layer will get turned into a hashtag
+            which can then be selected on/off in the TAK app layers control.</dd>
     </dl>
 
     <h3>Updating gateway position...</h3>
     <dl class="message-properties">
         <dt>payload <span class="property-type">string | object</span></dt>
-        <dd>Either an NMEA string starting `$GPGGA` or an object containing `lat` and `lon` and
-            optional `alt` properties (but no name property).</dd>
+        <dd>Either an NMEA string starting `$GPGGA`, for example from a locally attached serial GPS, or an object
+            containing `lat` and `lon` and optional `alt` properties (but no name property).</dd>
     </dl>
-
     <h3>Details</h3>
     <p>This should work almost directly with messages received from an email-in node for example -
         but you will need to add the recipients in the sendTo property and may need to filter out
         unwanted messages first.</p>
-</script>
+    <p>As well as accepting simple worldmap type marker object it will accept "draw" actions from the
+        worldmap drawing layer and convert them to CoT objects for display.</p>
+    </p>
+</script>