initial commit

js/kiri-slicer.js

@@ -0,0 +1,781 @@
+/** Copyright 2014-2017 Stewart Allen -- All Rights Reserved */
+
+"use strict";
+
+var gs_kiri_slicer = exports;
+
+(function() {
+
+    if (!self.kiri) self.kiri = {};
+    if (self.kiri.slicer) return;
+
+    var slicer = self.kiri.slicer = {
+        slice: slice,
+        sliceWidget: sliceWidget
+    };
+
+    var KIRI = self.kiri,
+        BASE = self.base,
+        CONF = BASE.config,
+        UTIL = BASE.util,
+        POLY = BASE.polygons,
+        time = UTIL.time,
+        newSlice = KIRI.newSlice,
+        newOrderedLine = BASE.newOrderedLine;
+
+    /**
+     * Convenience method. Gets a Widget's points and calls slice()
+     *
+     * @param {Widget} widget
+     * @param {Object} options
+     * @param {Function} ondone callback when slicing complete
+     * @param {Function} onupdate callback on incremental updates
+     */
+    function sliceWidget(widget, options, ondone, onupdate) {
+        slice(widget.getPoints(), widget.getBoundingBox(), options, ondone, onupdate);
+    }
+
+    /**
+     * Given an array of points as triples, a bounding box and a set of
+     * slicing controls, emit an array of Slice objects to the ondone()
+     * function. onupdate() will be called with two parameters (% completion
+     * and an optional message) so that the UI can report progress to the user.
+     *
+     * @param {Array} points vertex array
+     * @param {Bounds} bounds bounding box for points
+     * @param {Object} options slicing parameters
+     * @param {Function} ondone callback when slicing done
+     * @param {Function} onupdate callback to report slicing progress
+     */
+    function slice(points, bounds, options, ondone, onupdate) {
+        var topoMode = options.topo,
+            ox = 0,
+            oy = 0;
+
+        // handle rotating meshes for CAM finishing.
+        // slicer expects things just so, so we alter
+        // geometry to satisfy
+        if (options.swapX || options.swapY) {
+            points = points.slice();
+
+            var btmp = new THREE.Box3(),
+                pref = {},
+                cached;
+
+            btmp.setFromPoints(points);
+            if (options.swapX) ox = -btmp.max.x;
+            if (options.swapY) oy = -btmp.max.y;
+
+            // array re-uses points so we need
+            // to be careful not to alter a point
+            // more than once
+            for (var p, index=0; index<points.length; index++) {
+                p = points[index];
+                cached = pref[p.key];
+                // skip points already altered
+                if (cached) {
+                    points[index] = cached;
+                    continue;
+                }
+                cached = p.clone();
+                if (options.swapX) cached.swapXZ();
+                else if (options.swapY) cached.swapYZ();
+                cached.rekey();
+                pref[p.key] = cached;
+                points[index] = cached;
+            }
+
+            // update temp bounds from new points
+            btmp.setFromPoints(points);
+            for (var p, index=0; index<points.length; index++) {
+                p = points[index];
+                if (p.mod === 1) continue;
+                p.mod = 1;
+                p.z -= btmp.min.z;
+            }
+
+            // update temp bounds from points with altered Z
+            btmp.setFromPoints(points);
+            bounds = btmp;
+        }
+
+        var zMin = options.zmin || Math.floor(bounds.min.z),
+            zMax = options.zmax || Math.ceil(bounds.max.z),
+            zInc = options.height,
+            zOff = true ? zInc / 2 : 0,
+            zIndexes = [],
+            zList = {},
+            zFlat = {},
+            zScale,
+            zPos,
+            timeStart = time(),
+            slices = [],
+            zSum = 0.0,
+            buckets = [],
+            i, j = 0, k, p1, p2, p3, px,
+            CPRO = KIRI.driver.CAM.process;
+
+        // gather z-index stats
+        // these are used for auto-slicing in laser
+        // and to flats detection in CAM mode
+        for (i = 0; i < points.length;) {
+            p1 = points[i++];
+            p2 = points[i++];
+            p3 = points[i++];
+            zSum += (Math.abs(p1.z - p2.z) + Math.abs(p2.z - p3.z) + Math.abs(p3.z - p1.z));
+            // laser auto-detect z slice points
+            if (zInc === 0) {
+                zList[UTIL.round(p1.z,5)] = 1;
+                zList[UTIL.round(p2.z,5)] = 1;
+                zList[UTIL.round(p3.z,5)] = 1;
+            }
+            // cam auto-detect flats
+            if (options.cam) {
+                if (p1.z === p2.z && p2.z === p3.z && p1.z > bounds.min.z) {
+                    var zkey = p1.z < bounds.max.z ? p1.z + 0.001 : p1.z,
+                        area = Math.abs(UTIL.area2(p1,p2,p3))/2;
+                    if (!zFlat[zkey]) {
+                        zFlat[zkey] = area;
+                    } else {
+                        zFlat[zkey] += area;
+                    }
+                }
+            }
+        }
+
+        /** bucket polygons into z-bounded groups */
+        var bucketCount = Math.max(1, Math.ceil(zMax / (zSum / points.length)) - 1);
+
+        zScale = 1 / (zMax / bucketCount);
+
+        if (bucketCount > 1) {
+            // create empty buckets
+            for (i = 0; i < bucketCount + 1; i++) buckets.push([]);
+
+            // copy triples into all matching z-buckets
+            for (i = 0; i < points.length;) {
+                p1 = points[i++];
+                p2 = points[i++];
+                p3 = points[i++];
+                var zm = Math.min(p1.z, p2.z, p3.z),
+                    zM = Math.max(p1.z, p2.z, p3.z),
+                    bm = Math.floor(zm * zScale),
+                    bM = Math.ceil(zM * zScale);
+                for (j = bm; j < bM; j++) {
+                    buckets[j].push(p1);
+                    buckets[j].push(p2);
+                    buckets[j].push(p3);
+                }
+            }
+        }
+
+        // create zIndexes array (0 = auto-detect)
+        if (zInc === 0) {
+            // find unique z-index offsets for slicing
+            var key, zl = [];
+            for (key in zList) {
+                if (!zList.hasOwnProperty(key)) continue;
+                zl.push(parseFloat(key));
+            }
+            zl.sort(function(a,b) { return a - b});
+            for (i = 0; i < zl.length-1; i++) {
+                zIndexes.push((zl[i] + zl[i+1]) / 2);
+            }
+            zIndexes.sort(function(a,b) { return a - b});
+        } else if (options.cam) {
+            // re-divide slice height so that top and
+            // bottom slices fall exactly on those faces
+            zInc = (zMax - zMin) / (Math.floor(zMax / zInc) + 1);
+            for (i = zMin; i < zMax; i += zInc) {
+                zIndexes.push(i);
+            }
+            for (key in zFlat) {
+                // todo make threshold for flat detection configurable
+                if (!zFlat.hasOwnProperty(key) || zFlat[key] < 100) continue;
+                key = parseFloat(key);
+                if (!zIndexes.contains(key) && key >= zMin) zIndexes.push(key);
+            }
+            // sort top down
+            zIndexes.sort(function(a,b) {
+                return b-a;
+            });
+        } else {
+            // FDM is the simplest case.  Just offset and slice at
+            // predicable offsets.  First offset is half a slice height.
+            // this was once configurable, but that turned out not to be
+            // terribly useful.  In future, first layer height may be
+            // adjusted separately, but that would also require other
+            // settings changes (flow rate, etc).
+            // ... only this one special case for first layer :)
+            if (options.firstHeight) {
+                zIndexes.push(options.firstHeight / 2);
+                zMin = options.firstHeight;
+            }
+            for (i = zMin + zOff; i < zMax; i += zInc) {
+                zIndexes.push(i);
+            }
+        }
+
+        // create a Slice for each z offset in the zIndexes array
+        for (var i = 0; i < zIndexes.length; i++) {
+            zPos = zIndexes[i];
+            sliceZ(zPos);
+            // kill slicing if onupdate() returns 42
+            if (onupdate(i / zIndexes.length) === 42) {
+                return ondone(null);
+            }
+        }
+
+        // for cam, mark top and bottom as mandatory (hasFlats)
+        if (options.cam && slices.length > 0) {
+            slices[0].hasFlats = true;
+            slices[slices.length-1].hasFlats = true;
+        }
+
+        // connect slices into linked list for island/bridge projections
+        for (i=1; i<slices.length; i++) {
+            slices[i-1].up = slices[i];
+            slices[i].down = slices[i-1];
+        }
+
+        slices.slice_time = time() - timeStart;
+
+        // pass Slices array back to ondone function
+        ondone(slices);
+
+        /** ***** SLICING FUNCTIONS ***** */
+
+        /**
+         * given a point, append to the correct
+         * 'where' objec tarray (on, over or under)
+         *
+         * @param {Point} p
+         * @param {number} z offset
+         * @param {Obejct} where
+         */
+        function checkUnderOverOn(p, z, where) {
+            var delta = p.z - z;
+            if (Math.abs(delta) < CONF.precision_slice_z) { // on
+                where.on.push(p);
+            } else if (delta < 0) { // under
+                where.under.push(p);
+            } else { // over
+                where.over.push(p);
+            }
+        }
+
+        /**
+         * Given a point over and under a z offset, calculate
+         * and return the intersection point on that z plane
+         *
+         * @param {Point} over
+         * @param {Point} under
+         * @param {number} z offset
+         * @returns {Point} intersection point
+         */
+        function intersectPoints(over, under, z) {
+            var ip = [];
+            for (var i = 0; i < over.length; i++) {
+                for (var j = 0; j < under.length; j++) {
+                    ip.push(over[i].intersectZ(under[j], z));
+                }
+            }
+            return ip;
+        }
+
+        /**
+         * Ensure points are unique with a cache/key algorithm
+         */
+        function getCachedPoint(phash, p) {
+            var cached = phash[p.key];
+            if (!cached) {
+                phash[p.key] = p;
+                return p;
+            }
+            return cached;
+        }
+        /**
+         * Given two points and hints about their edges,
+         * return a new Line object with points sorted
+         * lexicographically by key.  This allows for future
+         * line de-duplication and joins.
+         *
+         * @param {Object} phash
+         * @param {Point} p1
+         * @param {Point} p2
+         * @param {boolean} [coplanar]
+         * @param {boolean} [edge]
+         * @returns {Line}
+         */
+        function makeZLine(phash, p1, p2, coplanar, edge) {
+            p1 = getCachedPoint(phash, p1);
+            p2 = getCachedPoint(phash, p2);
+            var line = newOrderedLine(p1,p2);
+            line.coplanar = coplanar || false;
+            line.edge = edge || false;
+            return line;
+        }
+
+        /**
+         * process a single z-slice on a single mesh and
+         * add to slices array
+         *
+         * @param {number} z
+         */
+        function sliceZ(z) {
+            var    phash = {},
+                lines = [],
+                slice = newSlice(z, options.view ? options.view.newGroup() : null),
+                bucket = bucketCount == 1 ? points : buckets[Math.floor(z * zScale)];
+
+            if (!bucket) return;
+
+            // iterate over matching buckets for this z offset
+            for (var i = 0; i < bucket.length;) {
+                p1 = bucket[i++];
+                p2 = bucket[i++];
+                p3 = bucket[i++];
+                var where = {under: [], over: [], on: []};
+                checkUnderOverOn(p1, z, where);
+                checkUnderOverOn(p2, z, where);
+                checkUnderOverOn(p3, z, where);
+                if (where.under.length === 3 || where.over.length === 3) {
+                    // does not intersect
+                } else if (where.on.length === 2) {
+                    // one side of triangle is on the Z plane
+                    lines.push(makeZLine(phash, where.on[0], where.on[1], false, true));
+                } else if (where.on.length === 3) {
+                    // triangle is coplanar with Z
+                    //lines.push(makeZLine(phash, where.on[0], where.on[1], true));
+                    //lines.push(makeZLine(phash, where.on[1], where.on[2], true));
+                    //lines.push(makeZLine(phash, where.on[2], where.on[0], true));
+                } else if (where.under.length === 0 || where.over.length === 0) {
+                    // does not intersect (but one point is on the plane)
+                } else {
+                    // compute two point intersections and construct line
+                    var line = intersectPoints(where.over, where.under, z);
+                    if (line.length < 2 && where.on.length === 1) {
+                        line.push(where.on[0]);
+                    }
+                    if (line.length === 2) {
+                        lines.push(makeZLine(phash, line[0], line[1]));
+                    } else {
+                        console.log({msg: "invalid ips", line: line, where: where});
+                    }
+                }
+            }
+
+            // allow empty slices in CAM swap mode (for topos w/ gaps)
+            if (lines.length == 0 && !(options.swapX || options.swapY)) return;
+
+            slice.index = slices.length;
+            slice.lines = removeDuplicateLines(lines);
+
+            // annotate slices with cam flats for finishing waterlines
+            if (options.cam) slice.hasFlats = zFlat[z] > 0;
+
+            // for topo slices, we just need the raw lines
+            if (!topoMode) {
+                slice.groups = connectLines(slice.lines, slices.length);
+                POLY.nest(slice.groups).forEach(function(top) { slice.addTop(top) });
+            }
+
+            // fixup un-rotates polygons for CAM
+            if (options.swapX || options.swapY) {
+                var move = {x:ox, y:oy, z:0};
+                slice.camMode = options.swapX ? CPRO.FINISH_X : CPRO.FINISH_Y;
+                if (topoMode) {
+                    var lines = slice.lines, llen = lines.length, idx, line;
+                    // shared points causing problems
+                    for (idx=0; idx<llen; idx++) { line = lines[idx];
+                        line.p1 = line.p1.clone();
+                        line.p2 = line.p2.clone();
+                    }
+                    for (idx=0; idx<llen; idx++) { line = lines[idx];
+                        if (options.swapX) {
+                            line.p1.swapXZ();
+                            line.p2.swapXZ();
+                        } else {
+                            line.p1.swapYZ();
+                            line.p2.swapYZ();
+                        }
+                        line.p1.move(move);
+                        line.p2.move(move);
+                    }
+                } else {
+                    slice.tops.forEach(function(top) {
+                        top.poly.swap(options.swapX, options.swapY);
+                        top.poly.move(move);
+                        top.poly.inner = null;
+                    });
+                    drape(slice, options.swapX, options.swapY);
+                }
+            }
+
+            slices.push(slice);
+        }
+    }
+
+    /**
+     * Given an array of input lines (line soup), find the path through
+     * joining line ends that encompasses the greatest area without self
+     * interesection.  Eliminate used points and repeat.  Unjoined lines
+     * are permitted and handled after all other cases are handled.
+     *
+     * @param {Line[]} input
+     * @param {number} [index]
+     * @returns {Array}
+     */
+    function connectLines(input, index) {
+        // map points to all other points they're connected to
+        var DBUG = BASE.debug,
+            CONF = BASE.config,
+            pmap = {},
+            points = [],
+            output = [],
+            connect = [],
+            search = 1,
+            nextMod = 1,
+            debug = (BASE.debug.get('z-index') === index) && BASE.debug.get('connect'),
+            bridge = CONF.bridgeLineGapDistance,
+            p1, p2;
+
+        function cachedPoint(p) {
+            var cp = pmap[p.key];
+            if (cp) return cp;
+            points.push(p);
+            pmap[p.key] = p;
+            p.mod = nextMod++; // unique seq ID for points
+            p.toString = function() { return this.mod }; // point array concat
+            return p;
+        }
+
+        function addConnected(p1, p2) {
+            if (!p1.group) p1.group = [ p2 ];
+            else p1.group.push(p2);
+        }
+
+        function sliceAtTerm(path, term) {
+            var idx, len = path.length;
+            for (idx = 0; idx < len-1; idx++) {
+                if (path[idx] === term) {
+                    return path.slice(idx);
+                }
+            }
+            return path;
+        }
+
+        /**
+         * using minimal recursion, follow points through connected lines
+         * to form candidate output paths.
+         */
+        function findPathsMinRecurse(point, path, paths, from) {
+            var stack = [ ];
+            if (paths.length > 10000) {
+                DBUG.log("excessive path options @ "+paths.length+" #"+input.length);
+                return;
+            }
+            for (;;) {
+                stack.push(point);
+
+                var last = point,
+                    links = point.group;
+
+                path.push(point);
+                // use del to mark traversed path
+                point.del = true;
+                // set so point isn't used in another polygon search
+                point.pos = search++;
+                // seed path with two points to prevent redundant opposing seeks
+                if (path.length === 1) {
+                    from = point;
+                    point = links[0];
+                    continue;
+                }
+
+                if (links.length > 2) {
+                    // TODO optimize when > 2 and limit to left-most and right-most branches
+                    // for now, pursue all possible branches
+                    links.forEach(function(nextp) {
+                        // do not backtrack
+                        if (nextp === from) {
+                            return;
+                        }
+                        if (nextp.del) {
+                            paths.push(sliceAtTerm(path,nextp));
+                        } else {
+                            findPathsMinRecurse(nextp, path.slice(), paths, point);
+                        }
+                    });
+                    break;
+                } else {
+                    point = links[0] === from ? links[1] : links[0];
+                    from = last;
+                    // hit an open end
+                    if (!point) {
+                        path.open = true;
+                        paths.push(path);
+                        break;
+                    }
+                    // hit a point previously in the path (or start)
+                    if (point.del) {
+                        paths.push(sliceAtTerm(path,point));
+                        break;
+                    }
+                }
+            }
+
+            for (var i=0; i<stack.length; i++) stack[i].del = false;
+            // stack.forEach(function(p) { p.del = false });
+        }
+
+        // emit a polygon if it can be cleaned and still have 2 or more points
+        function emit(poly) {
+            poly = poly.clean();
+            if (poly.length > 2) output.push(poly.clean());
+            // if (poly.length > 2) output.push(poly);
+        }
+
+        // given an array of paths, emit longest to shortest
+        // eliminating points from the paths as they are emitted
+        // shorter paths any point eliminated are eliminated as candidates.
+        function emitLongestAsPolygon(paths) {
+            var longest = null,
+                emitted = 0,
+                closed = 0,
+                open = 0;
+
+            paths.forEach(function(path, index) {
+                // use longest perimeter vs longest path?
+                if (!longest || path.length > longest.length) longest = path;
+                if (!path.open) closed++; else open++;
+            });
+
+            if (debug) DBUG.log({closed:closed, open:open});
+            // it gets more complicated with multiple possible output paths
+            if (closed > 1 && open === 0) {
+                // add polygon to path (for area sorting)
+                paths.forEach(function(path) { path.poly = BASE.newPolygon().addPoints(path) });
+
+                // sort descending by area VS (length below -- better in most cases)
+                // paths.sort(function(a,b) { return b.poly.area() - a.poly.area() });
+
+                // sort descending by length
+                paths.sort(function(a,b) { return b.poly.length - a.poly.length });
+
+                if (debug) DBUG.log({paths:paths});
+
+                // emit polygons largest to smallest
+                // omit polygon if it intersects previously emitted (has del points)
+                paths.forEach(function(path) {
+                    if (path.length < 3) return;
+                    var len = path.length, i;
+                    for (i = 0; i < len; i++) if (path[i].del) return;
+                    for (i = 0; i < len; i++) path[i].del = true;
+                    emit(path.poly);
+                    emitted++;
+                });
+
+                if (debug) DBUG.log({longest:longest.length, paths:paths.length, closed:closed, emitted:emitted});
+            } else {
+                if (longest.open) {
+                    connect.push(longest);
+                } else {
+                    emit(BASE.newPolygon().addPoints(longest));
+                }
+            }
+        }
+
+        // create point map, unique point list and point group arrays
+        input.forEach(function(line) {
+            p1 = cachedPoint(line.p1.round(7));
+            p2 = cachedPoint(line.p2.round(7));
+            addConnected(p1,p2);
+            addConnected(p2,p1);
+        });
+
+        // first trace paths starting at dangling endpoinds (bad polygon soup)
+        points.forEach(function(point) {
+            // must not have been used and be a dangling end
+            if (point.pos === 0 && point.group.length === 1) {
+                var path = [],
+                    paths = [];
+                findPathsMinRecurse(point, path, paths);
+                if (paths.length > 0) emitLongestAsPolygon(paths);
+            }
+        });
+
+        // for each point, find longest path back to self
+        points.forEach(function(point) {
+            // must not have been used or be at a split
+            if (point.pos === 0 && point.group.length === 2) {
+                var path = [],
+                    paths = [];
+                findPathsMinRecurse(point, path, paths);
+                if (paths.length > 0) emitLongestAsPolygon(paths);
+            }
+        });
+
+        // return true if points are deemed "close enough" close a polygon
+        function close(p1,p2) {
+            return p1.distToSq2D(p2) <= 0.01;
+        }
+
+        // reconnect dangling/open polygons to closest endpoint
+        for (var i=0; i<connect.length; i++) {
+
+            var array = connect[i],
+                last = array[array.length-1],
+                tmp, dist, j;
+
+            if (!bridge) {
+                emit(BASE.newPolygon().addPoints(array).setOpen());
+                continue;
+            }
+
+            if (array.delete) continue;
+
+            loop: for (var merged=0;;) {
+                var closest = { dist:Infinity };
+                for (j=i+1; j<connect.length; j++) {
+                    tmp = connect[j];
+                    if (tmp.delete) continue;
+                    dist = last.distToSq2D(tmp[0]);
+                    if (dist < closest.dist && dist <= bridge) {
+                        closest = {
+                            dist: dist,
+                            array: tmp
+                        }
+                    }
+                    dist = last.distToSq2D(tmp[tmp.length-1]);
+                    if (dist < closest.dist && dist <= bridge) {
+                        closest = {
+                            dist: dist,
+                            array: tmp,
+                            reverse: true
+                        }
+                    }
+                }
+
+                if (tmp = closest.array) {
+                    if (closest.reverse) tmp.reverse();
+                    tmp.delete = true;
+                    array.appendAll(tmp);
+                    last = array[array.length-1];
+                    merged++;
+                    // tail meets head (closed)
+                    if (close(array[0], last)) {
+                        emit(BASE.newPolygon().addPoints(array));
+                        break loop;
+                    }
+                } else {
+                    // no more closest polys (open set)
+                    emit(BASE.newPolygon().addPoints(array));
+                    break loop;
+                }
+            }
+        }
+
+        return output;
+    }
+
+    /**
+     * eliminate duplicate lines and interior-only lines (coplanar)
+     *
+     * lines are sorted using lexicographic point keys such that
+     * they are comparable even if their points are reversed. hinting
+     * for deletion, co-planar and suspect shared edge is detectable at
+     * this time.
+     *
+     * @param {Line[]} lines
+     * @returns {Line[]}
+     */
+    function removeDuplicateLines(lines) {
+        var output = [],
+            tmplines = [],
+            points = [],
+            pmap = {};
+
+        function cachePoint(p) {
+            var cp = pmap[p.key];
+            if (cp) return cp;
+            points.push(p);
+            pmap[p.key] = p;
+            return p;
+        }
+
+        function addLinesToPoint(point, line) {
+            cachePoint(point);
+            if (!point.group) point.group = [ line ];
+            else point.group.push(line);
+        }
+
+        // mark duplicates for deletion preserving edges
+        lines.sort(function (l1, l2) {
+            if (l1.key === l2.key) {
+                l1.del = !l1.edge;
+                l2.del = !l2.edge;
+                return 0;
+            }
+            return l1.key < l2.key ? -1 : 1;
+        });
+
+        // associate points with their lines, cull deleted
+        lines.forEach(function(line) {
+            if (!line.del) {
+                tmplines.push(line);
+                addLinesToPoint(line.p1, line);
+                addLinesToPoint(line.p2, line);
+            }
+        });
+
+        // merge collinear lines
+        points.forEach(function(point) {
+            if (point.group.length != 2) return;
+            var l1 = point.group[0],
+                l2 = point.group[1];
+            if (l1.isCollinear(l2)) {
+                l1.del = true;
+                l2.del = true;
+                // find new endpoints that are not shared point
+                var p1 = l1.p1 != point ? l1.p1 : l1.p2,
+                    p2 = l2.p1 != point ? l2.p1 : l2.p2,
+                    newline = base.newOrderedLine(p1,p2);
+                // remove deleted lines from associated points
+                p1.group.remove(l1);
+                p1.group.remove(l2);
+                p2.group.remove(l1);
+                p2.group.remove(l2);
+                // associate new line with points
+                p1.group.push(newline);
+                p2.group.push(newline);
+                // add new line to lines array
+                newline.edge = l1.edge || l2.edge;
+                tmplines.push(newline);
+            }
+        });
+
+        // mark duplicates for deletion
+        // but preserve one if it's an edge
+        tmplines.sort(function (l1, l2) {
+            if (l1.key === l2.key) {
+                l1.del = true;
+                l2.del = !l2.edge;
+                return 0;
+            }
+            return l1.key < l2.key ? -1 : 1;
+        });
+
+        // create new line array culling deleted
+        tmplines.forEach(function(line) {
+            if (!line.del) {
+                output.push(line);
+                line.p1.group = null;
+                line.p2.group = null;
+            }
+        });
+
+        return output;
+    }
+
+})();