js-angusj-clipper
Version:
Polygon and line clipping and offsetting library for Javascript / Typescript - a port of Angus Johnson's clipper to WebAssembly / Asm.JS
80 lines • 9.84 kB
JavaScript
;
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
exports.PolyTree = void 0;
var PolyNode_1 = require("./PolyNode");
/**
* PolyTree is intended as a read-only data structure that should only be used to receive solutions from clipping and offsetting operations. It's an
* alternative to the Paths data structure which also receives these solutions. PolyTree's two major advantages over the Paths structure are: it properly
* represents the parent-child relationships of the returned polygons; it differentiates between open and closed paths. However, since PolyTree is a more
* complex structure than the Paths structure, and since it's more computationally expensive to process (the Execute method being roughly 5-10% slower), it
* should used only be when parent-child polygon relationships are needed, or when open paths are being 'clipped'.
*
* A PolyTree object is a container for any number of PolyNode children, with each contained PolyNode representing a single polygon contour (either an outer
* or hole polygon). PolyTree itself is a specialized PolyNode whose immediate children represent the top-level outer polygons of the solution. (It's own
* Contour property is always empty.) The contained top-level PolyNodes may contain their own PolyNode children representing hole polygons that may also
* contain children representing nested outer polygons etc. Children of outers will always be holes, and children of holes will always be outers.
*
* PolyTrees can also contain open paths. Open paths will always be represented by top level PolyNodes. Two functions are provided to quickly separate out
* open and closed paths from a polytree - openPathsFromPolyTree and closedPathsFromPolyTree.
*/
var PolyTree = /** @class */ (function (_super) {
__extends(PolyTree, _super);
function PolyTree() {
var _this = _super.call(this) || this;
_this._total = 0;
return _this;
}
Object.defineProperty(PolyTree.prototype, "total", {
/**
* Returns the total number of PolyNodes (polygons) contained within the PolyTree. This value is not to be confused with childs.length which returns the
* number of immediate children only (Childs) contained by PolyTree.
*/
get: function () {
return this._total;
},
enumerable: false,
configurable: true
});
/**
* This method returns the first outer polygon contour if any, otherwise undefined.
*
* This function is equivalent to calling childs[0].
*/
PolyTree.prototype.getFirst = function () {
if (this.childs.length > 0) {
return this.childs[0];
}
else {
return undefined;
}
};
/**
* Internal use.
* Constructs a PolyTree from a native PolyTree.
*/
PolyTree.fromNativePolyTree = function (nativeLib, nativePolyTree, freeNativePolyTree) {
var pt = new PolyTree();
PolyNode_1.PolyNode.fillFromNativePolyNode(pt, nativeLib, nativePolyTree, undefined, 0, false); // do NOT free them, they are freed on destruction of the polytree
pt._total = nativePolyTree.total();
if (freeNativePolyTree) {
nativePolyTree.delete(); // this deletes all inner paths, contours etc
}
return pt;
};
return PolyTree;
}(PolyNode_1.PolyNode));
exports.PolyTree = PolyTree;
//# sourceMappingURL=data:application/json;base64,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