node-red-contrib-tak-registration
Version:
A Node-RED node to register to TAK and to help wrap files as datapackages to send to TAK
308 lines (307 loc) • 11.1 kB
JavaScript
;
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
var Node_1 = __importDefault(require("./Node"));
var Edge_1 = __importDefault(require("./Edge"));
var EdgeRing_1 = __importDefault(require("./EdgeRing"));
var meta_1 = require("@turf/meta");
var invariant_1 = require("@turf/invariant");
/**
* Validates the geoJson.
*
* @param {GeoJSON} geoJson - input geoJson.
* @throws {Error} if geoJson is invalid.
*/
function validateGeoJson(geoJson) {
if (!geoJson)
throw new Error("No geojson passed");
if (geoJson.type !== "FeatureCollection" &&
geoJson.type !== "GeometryCollection" &&
geoJson.type !== "MultiLineString" &&
geoJson.type !== "LineString" &&
geoJson.type !== "Feature")
throw new Error("Invalid input type '" + geoJson.type + "'. Geojson must be FeatureCollection, GeometryCollection, LineString, MultiLineString or Feature");
}
/**
* Represents a planar graph of edges and nodes that can be used to compute a polygonization.
*
* Although, this class is inspired by GEOS's `geos::operation::polygonize::PolygonizeGraph`,
* it isn't a rewrite. As regards algorithm, this class implements the same logic, but it
* isn't a javascript transcription of the C++ source.
*
* This graph is directed (both directions are created)
*/
var Graph = /** @class */ (function () {
function Graph() {
this.edges = []; //< {Edge[]} dirEdges
// The key is the `id` of the Node (ie: coordinates.join(','))
this.nodes = {};
}
/**
* Creates a graph from a GeoJSON.
*
* @param {FeatureCollection<LineString>} geoJson - it must comply with the restrictions detailed in the index
* @returns {Graph} - The newly created graph
* @throws {Error} if geoJson is invalid.
*/
Graph.fromGeoJson = function (geoJson) {
validateGeoJson(geoJson);
var graph = new Graph();
meta_1.flattenEach(geoJson, function (feature) {
invariant_1.featureOf(feature, "LineString", "Graph::fromGeoJson");
// When a LineString if formed by many segments, split them
meta_1.coordReduce(feature, function (prev, cur) {
if (prev) {
var start = graph.getNode(prev), end = graph.getNode(cur);
graph.addEdge(start, end);
}
return cur;
});
});
return graph;
};
/**
* Creates or get a Node.
*
* @param {number[]} coordinates - Coordinates of the node
* @returns {Node} - The created or stored node
*/
Graph.prototype.getNode = function (coordinates) {
var id = Node_1.default.buildId(coordinates);
var node = this.nodes[id];
if (!node)
node = this.nodes[id] = new Node_1.default(coordinates);
return node;
};
/**
* Adds an Edge and its symetricall.
*
* Edges are added symetrically, i.e.: we also add its symetric
*
* @param {Node} from - Node which starts the Edge
* @param {Node} to - Node which ends the Edge
*/
Graph.prototype.addEdge = function (from, to) {
var edge = new Edge_1.default(from, to), symetricEdge = edge.getSymetric();
this.edges.push(edge);
this.edges.push(symetricEdge);
};
/**
* Removes Dangle Nodes (nodes with grade 1).
*/
Graph.prototype.deleteDangles = function () {
var _this = this;
Object.keys(this.nodes)
.map(function (id) { return _this.nodes[id]; })
.forEach(function (node) { return _this._removeIfDangle(node); });
};
/**
* Check if node is dangle, if so, remove it.
*
* It calls itself recursively, removing a dangling node might cause another dangling node
*
* @param {Node} node - Node to check if it's a dangle
*/
Graph.prototype._removeIfDangle = function (node) {
var _this = this;
// As edges are directed and symetrical, we count only innerEdges
if (node.innerEdges.length <= 1) {
var outerNodes = node.getOuterEdges().map(function (e) { return e.to; });
this.removeNode(node);
outerNodes.forEach(function (n) { return _this._removeIfDangle(n); });
}
};
/**
* Delete cut-edges (bridge edges).
*
* The graph will be traversed, all the edges will be labeled according the ring
* in which they are. (The label is a number incremented by 1). Edges with the same
* label are cut-edges.
*/
Graph.prototype.deleteCutEdges = function () {
var _this = this;
this._computeNextCWEdges();
this._findLabeledEdgeRings();
// Cut-edges (bridges) are edges where both edges have the same label
this.edges.forEach(function (edge) {
if (edge.label === edge.symetric.label) {
_this.removeEdge(edge.symetric);
_this.removeEdge(edge);
}
});
};
/**
* Set the `next` property of each Edge.
*
* The graph will be transversed in a CW form, so, we set the next of the symetrical edge as the previous one.
* OuterEdges are sorted CCW.
*
* @param {Node} [node] - If no node is passed, the function calls itself for every node in the Graph
*/
Graph.prototype._computeNextCWEdges = function (node) {
var _this = this;
if (typeof node === "undefined") {
Object.keys(this.nodes).forEach(function (id) {
return _this._computeNextCWEdges(_this.nodes[id]);
});
}
else {
node.getOuterEdges().forEach(function (edge, i) {
node.getOuterEdge((i === 0 ? node.getOuterEdges().length : i) - 1).symetric.next = edge;
});
}
};
/**
* Computes the next edge pointers going CCW around the given node, for the given edgering label.
*
* This algorithm has the effect of converting maximal edgerings into minimal edgerings
*
* XXX: method literally transcribed from `geos::operation::polygonize::PolygonizeGraph::computeNextCCWEdges`,
* could be written in a more javascript way.
*
* @param {Node} node - Node
* @param {number} label - Ring's label
*/
Graph.prototype._computeNextCCWEdges = function (node, label) {
var edges = node.getOuterEdges();
var firstOutDE, prevInDE;
for (var i = edges.length - 1; i >= 0; --i) {
var de = edges[i], sym = de.symetric, outDE = void 0, inDE = void 0;
if (de.label === label)
outDE = de;
if (sym.label === label)
inDE = sym;
if (!outDE || !inDE)
// This edge is not in edgering
continue;
if (inDE)
prevInDE = inDE;
if (outDE) {
if (prevInDE) {
prevInDE.next = outDE;
prevInDE = undefined;
}
if (!firstOutDE)
firstOutDE = outDE;
}
}
if (prevInDE)
prevInDE.next = firstOutDE;
};
/**
* Finds rings and labels edges according to which rings are.
*
* The label is a number which is increased for each ring.
*
* @returns {Edge[]} edges that start rings
*/
Graph.prototype._findLabeledEdgeRings = function () {
var edgeRingStarts = [];
var label = 0;
this.edges.forEach(function (edge) {
if (edge.label >= 0)
return;
edgeRingStarts.push(edge);
var e = edge;
do {
e.label = label;
e = e.next;
} while (!edge.isEqual(e));
label++;
});
return edgeRingStarts;
};
/**
* Computes the EdgeRings formed by the edges in this graph.
*
* @returns {EdgeRing[]} - A list of all the EdgeRings in the graph.
*/
Graph.prototype.getEdgeRings = function () {
var _this = this;
this._computeNextCWEdges();
// Clear labels
this.edges.forEach(function (edge) {
edge.label = undefined;
});
this._findLabeledEdgeRings().forEach(function (edge) {
// convertMaximalToMinimalEdgeRings
_this._findIntersectionNodes(edge).forEach(function (node) {
_this._computeNextCCWEdges(node, edge.label);
});
});
var edgeRingList = [];
// find all edgerings
this.edges.forEach(function (edge) {
if (edge.ring)
return;
edgeRingList.push(_this._findEdgeRing(edge));
});
return edgeRingList;
};
/**
* Find all nodes in a Maxima EdgeRing which are self-intersection nodes.
*
* @param {Node} startEdge - Start Edge of the Ring
* @returns {Node[]} - intersection nodes
*/
Graph.prototype._findIntersectionNodes = function (startEdge) {
var intersectionNodes = [];
var edge = startEdge;
var _loop_1 = function () {
// getDegree
var degree = 0;
edge.from.getOuterEdges().forEach(function (e) {
if (e.label === startEdge.label)
++degree;
});
if (degree > 1)
intersectionNodes.push(edge.from);
edge = edge.next;
};
do {
_loop_1();
} while (!startEdge.isEqual(edge));
return intersectionNodes;
};
/**
* Get the edge-ring which starts from the provided Edge.
*
* @param {Edge} startEdge - starting edge of the edge ring
* @returns {EdgeRing} - EdgeRing which start Edge is the provided one.
*/
Graph.prototype._findEdgeRing = function (startEdge) {
var edge = startEdge;
var edgeRing = new EdgeRing_1.default();
do {
edgeRing.push(edge);
edge.ring = edgeRing;
edge = edge.next;
} while (!startEdge.isEqual(edge));
return edgeRing;
};
/**
* Removes a node from the Graph.
*
* It also removes edges asociated to that node
* @param {Node} node - Node to be removed
*/
Graph.prototype.removeNode = function (node) {
var _this = this;
node.getOuterEdges().forEach(function (edge) { return _this.removeEdge(edge); });
node.innerEdges.forEach(function (edge) { return _this.removeEdge(edge); });
delete this.nodes[node.id];
};
/**
* Remove edge from the graph and deletes the edge.
*
* @param {Edge} edge - Edge to be removed
*/
Graph.prototype.removeEdge = function (edge) {
this.edges = this.edges.filter(function (e) { return !e.isEqual(edge); });
edge.deleteEdge();
};
return Graph;
}());
exports.default = Graph;