@fleet-frontend/mower-maps 0.0.9-beta.9 → 0.1.0-beta.1

package/dist/index.js

@@ -69,7 +69,8 @@ const DEFAULT_LINE_WIDTHS = {
 const DEFAULT_OPACITIES = {
     FULL: 1.0,
     HIGH: 0.7,
-    MEDIUM: 0.6};
+    MEDIUM: 0.6,
+    DOODLE: 0.8};
 /**
  * 默认半径设置
  */
@@ -228,7 +229,6 @@ class SvgMapView {
      */
     removeLayer(layer) {
         const index = this.layers.indexOf(layer);
-        console.log('removeLayer----->', index);
         if (index !== -1) {
             this.layers.splice(index, 1);
             this.refresh();
@@ -276,7 +276,6 @@ class SvgMapView {
             width: boundWidth + padding * 2,
             height: boundHeight + padding * 2,
         };
-        console.log('viewbox->', this.viewBox);
         // 根据宽高比选择合适的preserveAspectRatio设置
         if (Math.abs(contentAspectRatio - containerAspectRatio) < 0.01) {
             // 宽高比接近，使用slice填满容器
@@ -286,7 +285,6 @@ class SvgMapView {
             // 宽高比差异较大，使用meet确保内容完全可见
             this.svg.setAttribute('preserveAspectRatio', 'xMidYMid meet');
         }
-        console.log('fitToView');
         this.updateViewBox();
     }
     /**
@@ -357,7 +355,6 @@ class SvgMapView {
      * 绘制图层，不传参数则默认绘制所有图层
      */
     onDrawLayers(type) {
-        console.log('onDrawLayers----->', type);
         if (type) {
             const layer = this.layers.find((layer) => layer.getType() === type);
             if (layer) {
@@ -434,7 +431,6 @@ class SvgMapView {
     refresh() {
         if (this.destroyed)
             return;
-        console.log('refresh----->');
         this.render();
     }
     // ==================== 拖拽功能 ====================
@@ -780,7 +776,7 @@ const createImpl = (createState) => {
 };
 const create = (createState) => createState ? createImpl(createState) : createImpl;
 
-const useSubBoundaryBorderStore = create((set, get) => ({
+const usePartitionDataStore = create((set, get) => ({
     subBoundaryBorder: {},
     // 追加单个数据
     addSubBoundaryBorder: (key, element) => set((state) => ({
@@ -811,6 +807,2484 @@ const useSubBoundaryBorderStore = create((set, get) => ({
     clearSvgElements: () => set({ svgElements: {} }),
 }));
 
+/**
+ * splaytree v3.1.2
+ * Fast Splay tree for Node and browser
+ *
+ * @author Alexander Milevski <info@w8r.name>
+ * @license MIT
+ * @preserve
+ */
+
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation. All rights reserved.
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+this file except in compliance with the License. You may obtain a copy of the
+License at http://www.apache.org/licenses/LICENSE-2.0
+
+THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
+WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
+MERCHANTABLITY OR NON-INFRINGEMENT.
+
+See the Apache Version 2.0 License for specific language governing permissions
+and limitations under the License.
+***************************************************************************** */
+
+function __generator(thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+}
+
+var Node = /** @class */ (function () {
+    function Node(key, data) {
+        this.next = null;
+        this.key = key;
+        this.data = data;
+        this.left = null;
+        this.right = null;
+    }
+    return Node;
+}());
+
+/* follows "An implementation of top-down splaying"
+ * by D. Sleator <sleator@cs.cmu.edu> March 1992
+ */
+function DEFAULT_COMPARE(a, b) {
+    return a > b ? 1 : a < b ? -1 : 0;
+}
+/**
+ * Simple top down splay, not requiring i to be in the tree t.
+ */
+function splay(i, t, comparator) {
+    var N = new Node(null, null);
+    var l = N;
+    var r = N;
+    while (true) {
+        var cmp = comparator(i, t.key);
+        //if (i < t.key) {
+        if (cmp < 0) {
+            if (t.left === null)
+                break;
+            //if (i < t.left.key) {
+            if (comparator(i, t.left.key) < 0) {
+                var y = t.left; /* rotate right */
+                t.left = y.right;
+                y.right = t;
+                t = y;
+                if (t.left === null)
+                    break;
+            }
+            r.left = t; /* link right */
+            r = t;
+            t = t.left;
+            //} else if (i > t.key) {
+        }
+        else if (cmp > 0) {
+            if (t.right === null)
+                break;
+            //if (i > t.right.key) {
+            if (comparator(i, t.right.key) > 0) {
+                var y = t.right; /* rotate left */
+                t.right = y.left;
+                y.left = t;
+                t = y;
+                if (t.right === null)
+                    break;
+            }
+            l.right = t; /* link left */
+            l = t;
+            t = t.right;
+        }
+        else
+            break;
+    }
+    /* assemble */
+    l.right = t.left;
+    r.left = t.right;
+    t.left = N.right;
+    t.right = N.left;
+    return t;
+}
+function insert(i, data, t, comparator) {
+    var node = new Node(i, data);
+    if (t === null) {
+        node.left = node.right = null;
+        return node;
+    }
+    t = splay(i, t, comparator);
+    var cmp = comparator(i, t.key);
+    if (cmp < 0) {
+        node.left = t.left;
+        node.right = t;
+        t.left = null;
+    }
+    else if (cmp >= 0) {
+        node.right = t.right;
+        node.left = t;
+        t.right = null;
+    }
+    return node;
+}
+function split(key, v, comparator) {
+    var left = null;
+    var right = null;
+    if (v) {
+        v = splay(key, v, comparator);
+        var cmp = comparator(v.key, key);
+        if (cmp === 0) {
+            left = v.left;
+            right = v.right;
+        }
+        else if (cmp < 0) {
+            right = v.right;
+            v.right = null;
+            left = v;
+        }
+        else {
+            left = v.left;
+            v.left = null;
+            right = v;
+        }
+    }
+    return { left: left, right: right };
+}
+function merge$1(left, right, comparator) {
+    if (right === null)
+        return left;
+    if (left === null)
+        return right;
+    right = splay(left.key, right, comparator);
+    right.left = left;
+    return right;
+}
+/**
+ * Prints level of the tree
+ */
+function printRow(root, prefix, isTail, out, printNode) {
+    if (root) {
+        out("" + prefix + (isTail ? '└── ' : '├── ') + printNode(root) + "\n");
+        var indent = prefix + (isTail ? '    ' : '│   ');
+        if (root.left)
+            printRow(root.left, indent, false, out, printNode);
+        if (root.right)
+            printRow(root.right, indent, true, out, printNode);
+    }
+}
+var Tree = /** @class */ (function () {
+    function Tree(comparator) {
+        if (comparator === void 0) { comparator = DEFAULT_COMPARE; }
+        this._root = null;
+        this._size = 0;
+        this._comparator = comparator;
+    }
+    /**
+     * Inserts a key, allows duplicates
+     */
+    Tree.prototype.insert = function (key, data) {
+        this._size++;
+        return this._root = insert(key, data, this._root, this._comparator);
+    };
+    /**
+     * Adds a key, if it is not present in the tree
+     */
+    Tree.prototype.add = function (key, data) {
+        var node = new Node(key, data);
+        if (this._root === null) {
+            node.left = node.right = null;
+            this._size++;
+            this._root = node;
+        }
+        var comparator = this._comparator;
+        var t = splay(key, this._root, comparator);
+        var cmp = comparator(key, t.key);
+        if (cmp === 0)
+            this._root = t;
+        else {
+            if (cmp < 0) {
+                node.left = t.left;
+                node.right = t;
+                t.left = null;
+            }
+            else if (cmp > 0) {
+                node.right = t.right;
+                node.left = t;
+                t.right = null;
+            }
+            this._size++;
+            this._root = node;
+        }
+        return this._root;
+    };
+    /**
+     * @param  {Key} key
+     * @return {Node|null}
+     */
+    Tree.prototype.remove = function (key) {
+        this._root = this._remove(key, this._root, this._comparator);
+    };
+    /**
+     * Deletes i from the tree if it's there
+     */
+    Tree.prototype._remove = function (i, t, comparator) {
+        var x;
+        if (t === null)
+            return null;
+        t = splay(i, t, comparator);
+        var cmp = comparator(i, t.key);
+        if (cmp === 0) { /* found it */
+            if (t.left === null) {
+                x = t.right;
+            }
+            else {
+                x = splay(i, t.left, comparator);
+                x.right = t.right;
+            }
+            this._size--;
+            return x;
+        }
+        return t; /* It wasn't there */
+    };
+    /**
+     * Removes and returns the node with smallest key
+     */
+    Tree.prototype.pop = function () {
+        var node = this._root;
+        if (node) {
+            while (node.left)
+                node = node.left;
+            this._root = splay(node.key, this._root, this._comparator);
+            this._root = this._remove(node.key, this._root, this._comparator);
+            return { key: node.key, data: node.data };
+        }
+        return null;
+    };
+    /**
+     * Find without splaying
+     */
+    Tree.prototype.findStatic = function (key) {
+        var current = this._root;
+        var compare = this._comparator;
+        while (current) {
+            var cmp = compare(key, current.key);
+            if (cmp === 0)
+                return current;
+            else if (cmp < 0)
+                current = current.left;
+            else
+                current = current.right;
+        }
+        return null;
+    };
+    Tree.prototype.find = function (key) {
+        if (this._root) {
+            this._root = splay(key, this._root, this._comparator);
+            if (this._comparator(key, this._root.key) !== 0)
+                return null;
+        }
+        return this._root;
+    };
+    Tree.prototype.contains = function (key) {
+        var current = this._root;
+        var compare = this._comparator;
+        while (current) {
+            var cmp = compare(key, current.key);
+            if (cmp === 0)
+                return true;
+            else if (cmp < 0)
+                current = current.left;
+            else
+                current = current.right;
+        }
+        return false;
+    };
+    Tree.prototype.forEach = function (visitor, ctx) {
+        var current = this._root;
+        var Q = []; /* Initialize stack s */
+        var done = false;
+        while (!done) {
+            if (current !== null) {
+                Q.push(current);
+                current = current.left;
+            }
+            else {
+                if (Q.length !== 0) {
+                    current = Q.pop();
+                    visitor.call(ctx, current);
+                    current = current.right;
+                }
+                else
+                    done = true;
+            }
+        }
+        return this;
+    };
+    /**
+     * Walk key range from `low` to `high`. Stops if `fn` returns a value.
+     */
+    Tree.prototype.range = function (low, high, fn, ctx) {
+        var Q = [];
+        var compare = this._comparator;
+        var node = this._root;
+        var cmp;
+        while (Q.length !== 0 || node) {
+            if (node) {
+                Q.push(node);
+                node = node.left;
+            }
+            else {
+                node = Q.pop();
+                cmp = compare(node.key, high);
+                if (cmp > 0) {
+                    break;
+                }
+                else if (compare(node.key, low) >= 0) {
+                    if (fn.call(ctx, node))
+                        return this; // stop if smth is returned
+                }
+                node = node.right;
+            }
+        }
+        return this;
+    };
+    /**
+     * Returns array of keys
+     */
+    Tree.prototype.keys = function () {
+        var keys = [];
+        this.forEach(function (_a) {
+            var key = _a.key;
+            return keys.push(key);
+        });
+        return keys;
+    };
+    /**
+     * Returns array of all the data in the nodes
+     */
+    Tree.prototype.values = function () {
+        var values = [];
+        this.forEach(function (_a) {
+            var data = _a.data;
+            return values.push(data);
+        });
+        return values;
+    };
+    Tree.prototype.min = function () {
+        if (this._root)
+            return this.minNode(this._root).key;
+        return null;
+    };
+    Tree.prototype.max = function () {
+        if (this._root)
+            return this.maxNode(this._root).key;
+        return null;
+    };
+    Tree.prototype.minNode = function (t) {
+        if (t === void 0) { t = this._root; }
+        if (t)
+            while (t.left)
+                t = t.left;
+        return t;
+    };
+    Tree.prototype.maxNode = function (t) {
+        if (t === void 0) { t = this._root; }
+        if (t)
+            while (t.right)
+                t = t.right;
+        return t;
+    };
+    /**
+     * Returns node at given index
+     */
+    Tree.prototype.at = function (index) {
+        var current = this._root;
+        var done = false;
+        var i = 0;
+        var Q = [];
+        while (!done) {
+            if (current) {
+                Q.push(current);
+                current = current.left;
+            }
+            else {
+                if (Q.length > 0) {
+                    current = Q.pop();
+                    if (i === index)
+                        return current;
+                    i++;
+                    current = current.right;
+                }
+                else
+                    done = true;
+            }
+        }
+        return null;
+    };
+    Tree.prototype.next = function (d) {
+        var root = this._root;
+        var successor = null;
+        if (d.right) {
+            successor = d.right;
+            while (successor.left)
+                successor = successor.left;
+            return successor;
+        }
+        var comparator = this._comparator;
+        while (root) {
+            var cmp = comparator(d.key, root.key);
+            if (cmp === 0)
+                break;
+            else if (cmp < 0) {
+                successor = root;
+                root = root.left;
+            }
+            else
+                root = root.right;
+        }
+        return successor;
+    };
+    Tree.prototype.prev = function (d) {
+        var root = this._root;
+        var predecessor = null;
+        if (d.left !== null) {
+            predecessor = d.left;
+            while (predecessor.right)
+                predecessor = predecessor.right;
+            return predecessor;
+        }
+        var comparator = this._comparator;
+        while (root) {
+            var cmp = comparator(d.key, root.key);
+            if (cmp === 0)
+                break;
+            else if (cmp < 0)
+                root = root.left;
+            else {
+                predecessor = root;
+                root = root.right;
+            }
+        }
+        return predecessor;
+    };
+    Tree.prototype.clear = function () {
+        this._root = null;
+        this._size = 0;
+        return this;
+    };
+    Tree.prototype.toList = function () {
+        return toList(this._root);
+    };
+    /**
+     * Bulk-load items. Both array have to be same size
+     */
+    Tree.prototype.load = function (keys, values, presort) {
+        if (values === void 0) { values = []; }
+        if (presort === void 0) { presort = false; }
+        var size = keys.length;
+        var comparator = this._comparator;
+        // sort if needed
+        if (presort)
+            sort(keys, values, 0, size - 1, comparator);
+        if (this._root === null) { // empty tree
+            this._root = loadRecursive(keys, values, 0, size);
+            this._size = size;
+        }
+        else { // that re-builds the whole tree from two in-order traversals
+            var mergedList = mergeLists(this.toList(), createList(keys, values), comparator);
+            size = this._size + size;
+            this._root = sortedListToBST({ head: mergedList }, 0, size);
+        }
+        return this;
+    };
+    Tree.prototype.isEmpty = function () { return this._root === null; };
+    Object.defineProperty(Tree.prototype, "size", {
+        get: function () { return this._size; },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Tree.prototype, "root", {
+        get: function () { return this._root; },
+        enumerable: true,
+        configurable: true
+    });
+    Tree.prototype.toString = function (printNode) {
+        if (printNode === void 0) { printNode = function (n) { return String(n.key); }; }
+        var out = [];
+        printRow(this._root, '', true, function (v) { return out.push(v); }, printNode);
+        return out.join('');
+    };
+    Tree.prototype.update = function (key, newKey, newData) {
+        var comparator = this._comparator;
+        var _a = split(key, this._root, comparator), left = _a.left, right = _a.right;
+        if (comparator(key, newKey) < 0) {
+            right = insert(newKey, newData, right, comparator);
+        }
+        else {
+            left = insert(newKey, newData, left, comparator);
+        }
+        this._root = merge$1(left, right, comparator);
+    };
+    Tree.prototype.split = function (key) {
+        return split(key, this._root, this._comparator);
+    };
+    Tree.prototype[Symbol.iterator] = function () {
+        var current, Q, done;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    current = this._root;
+                    Q = [];
+                    done = false;
+                    _a.label = 1;
+                case 1:
+                    if (!!done) return [3 /*break*/, 6];
+                    if (!(current !== null)) return [3 /*break*/, 2];
+                    Q.push(current);
+                    current = current.left;
+                    return [3 /*break*/, 5];
+                case 2:
+                    if (!(Q.length !== 0)) return [3 /*break*/, 4];
+                    current = Q.pop();
+                    return [4 /*yield*/, current];
+                case 3:
+                    _a.sent();
+                    current = current.right;
+                    return [3 /*break*/, 5];
+                case 4:
+                    done = true;
+                    _a.label = 5;
+                case 5: return [3 /*break*/, 1];
+                case 6: return [2 /*return*/];
+            }
+        });
+    };
+    return Tree;
+}());
+function loadRecursive(keys, values, start, end) {
+    var size = end - start;
+    if (size > 0) {
+        var middle = start + Math.floor(size / 2);
+        var key = keys[middle];
+        var data = values[middle];
+        var node = new Node(key, data);
+        node.left = loadRecursive(keys, values, start, middle);
+        node.right = loadRecursive(keys, values, middle + 1, end);
+        return node;
+    }
+    return null;
+}
+function createList(keys, values) {
+    var head = new Node(null, null);
+    var p = head;
+    for (var i = 0; i < keys.length; i++) {
+        p = p.next = new Node(keys[i], values[i]);
+    }
+    p.next = null;
+    return head.next;
+}
+function toList(root) {
+    var current = root;
+    var Q = [];
+    var done = false;
+    var head = new Node(null, null);
+    var p = head;
+    while (!done) {
+        if (current) {
+            Q.push(current);
+            current = current.left;
+        }
+        else {
+            if (Q.length > 0) {
+                current = p = p.next = Q.pop();
+                current = current.right;
+            }
+            else
+                done = true;
+        }
+    }
+    p.next = null; // that'll work even if the tree was empty
+    return head.next;
+}
+function sortedListToBST(list, start, end) {
+    var size = end - start;
+    if (size > 0) {
+        var middle = start + Math.floor(size / 2);
+        var left = sortedListToBST(list, start, middle);
+        var root = list.head;
+        root.left = left;
+        list.head = list.head.next;
+        root.right = sortedListToBST(list, middle + 1, end);
+        return root;
+    }
+    return null;
+}
+function mergeLists(l1, l2, compare) {
+    var head = new Node(null, null); // dummy
+    var p = head;
+    var p1 = l1;
+    var p2 = l2;
+    while (p1 !== null && p2 !== null) {
+        if (compare(p1.key, p2.key) < 0) {
+            p.next = p1;
+            p1 = p1.next;
+        }
+        else {
+            p.next = p2;
+            p2 = p2.next;
+        }
+        p = p.next;
+    }
+    if (p1 !== null) {
+        p.next = p1;
+    }
+    else if (p2 !== null) {
+        p.next = p2;
+    }
+    return head.next;
+}
+function sort(keys, values, left, right, compare) {
+    if (left >= right)
+        return;
+    var pivot = keys[(left + right) >> 1];
+    var i = left - 1;
+    var j = right + 1;
+    while (true) {
+        do
+            i++;
+        while (compare(keys[i], pivot) < 0);
+        do
+            j--;
+        while (compare(keys[j], pivot) > 0);
+        if (i >= j)
+            break;
+        var tmp = keys[i];
+        keys[i] = keys[j];
+        keys[j] = tmp;
+        tmp = values[i];
+        values[i] = values[j];
+        values[j] = tmp;
+    }
+    sort(keys, values, left, j, compare);
+    sort(keys, values, j + 1, right, compare);
+}
+
+const epsilon$1 = 1.1102230246251565e-16;
+const splitter = 134217729;
+const resulterrbound = (3 + 8 * epsilon$1) * epsilon$1;
+
+// fast_expansion_sum_zeroelim routine from oritinal code
+function sum(elen, e, flen, f, h) {
+    let Q, Qnew, hh, bvirt;
+    let enow = e[0];
+    let fnow = f[0];
+    let eindex = 0;
+    let findex = 0;
+    if ((fnow > enow) === (fnow > -enow)) {
+        Q = enow;
+        enow = e[++eindex];
+    } else {
+        Q = fnow;
+        fnow = f[++findex];
+    }
+    let hindex = 0;
+    if (eindex < elen && findex < flen) {
+        if ((fnow > enow) === (fnow > -enow)) {
+            Qnew = enow + Q;
+            hh = Q - (Qnew - enow);
+            enow = e[++eindex];
+        } else {
+            Qnew = fnow + Q;
+            hh = Q - (Qnew - fnow);
+            fnow = f[++findex];
+        }
+        Q = Qnew;
+        if (hh !== 0) {
+            h[hindex++] = hh;
+        }
+        while (eindex < elen && findex < flen) {
+            if ((fnow > enow) === (fnow > -enow)) {
+                Qnew = Q + enow;
+                bvirt = Qnew - Q;
+                hh = Q - (Qnew - bvirt) + (enow - bvirt);
+                enow = e[++eindex];
+            } else {
+                Qnew = Q + fnow;
+                bvirt = Qnew - Q;
+                hh = Q - (Qnew - bvirt) + (fnow - bvirt);
+                fnow = f[++findex];
+            }
+            Q = Qnew;
+            if (hh !== 0) {
+                h[hindex++] = hh;
+            }
+        }
+    }
+    while (eindex < elen) {
+        Qnew = Q + enow;
+        bvirt = Qnew - Q;
+        hh = Q - (Qnew - bvirt) + (enow - bvirt);
+        enow = e[++eindex];
+        Q = Qnew;
+        if (hh !== 0) {
+            h[hindex++] = hh;
+        }
+    }
+    while (findex < flen) {
+        Qnew = Q + fnow;
+        bvirt = Qnew - Q;
+        hh = Q - (Qnew - bvirt) + (fnow - bvirt);
+        fnow = f[++findex];
+        Q = Qnew;
+        if (hh !== 0) {
+            h[hindex++] = hh;
+        }
+    }
+    if (Q !== 0 || hindex === 0) {
+        h[hindex++] = Q;
+    }
+    return hindex;
+}
+
+function estimate(elen, e) {
+    let Q = e[0];
+    for (let i = 1; i < elen; i++) Q += e[i];
+    return Q;
+}
+
+function vec(n) {
+    return new Float64Array(n);
+}
+
+const ccwerrboundA = (3 + 16 * epsilon$1) * epsilon$1;
+const ccwerrboundB = (2 + 12 * epsilon$1) * epsilon$1;
+const ccwerrboundC = (9 + 64 * epsilon$1) * epsilon$1 * epsilon$1;
+
+const B = vec(4);
+const C1 = vec(8);
+const C2 = vec(12);
+const D = vec(16);
+const u = vec(4);
+
+function orient2dadapt(ax, ay, bx, by, cx, cy, detsum) {
+    let acxtail, acytail, bcxtail, bcytail;
+    let bvirt, c, ahi, alo, bhi, blo, _i, _j, _0, s1, s0, t1, t0, u3;
+
+    const acx = ax - cx;
+    const bcx = bx - cx;
+    const acy = ay - cy;
+    const bcy = by - cy;
+
+    s1 = acx * bcy;
+    c = splitter * acx;
+    ahi = c - (c - acx);
+    alo = acx - ahi;
+    c = splitter * bcy;
+    bhi = c - (c - bcy);
+    blo = bcy - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = acy * bcx;
+    c = splitter * acy;
+    ahi = c - (c - acy);
+    alo = acy - ahi;
+    c = splitter * bcx;
+    bhi = c - (c - bcx);
+    blo = bcx - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    B[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    B[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    u3 = _j + _i;
+    bvirt = u3 - _j;
+    B[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    B[3] = u3;
+
+    let det = estimate(4, B);
+    let errbound = ccwerrboundB * detsum;
+    if (det >= errbound || -det >= errbound) {
+        return det;
+    }
+
+    bvirt = ax - acx;
+    acxtail = ax - (acx + bvirt) + (bvirt - cx);
+    bvirt = bx - bcx;
+    bcxtail = bx - (bcx + bvirt) + (bvirt - cx);
+    bvirt = ay - acy;
+    acytail = ay - (acy + bvirt) + (bvirt - cy);
+    bvirt = by - bcy;
+    bcytail = by - (bcy + bvirt) + (bvirt - cy);
+
+    if (acxtail === 0 && acytail === 0 && bcxtail === 0 && bcytail === 0) {
+        return det;
+    }
+
+    errbound = ccwerrboundC * detsum + resulterrbound * Math.abs(det);
+    det += (acx * bcytail + bcy * acxtail) - (acy * bcxtail + bcx * acytail);
+    if (det >= errbound || -det >= errbound) return det;
+
+    s1 = acxtail * bcy;
+    c = splitter * acxtail;
+    ahi = c - (c - acxtail);
+    alo = acxtail - ahi;
+    c = splitter * bcy;
+    bhi = c - (c - bcy);
+    blo = bcy - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = acytail * bcx;
+    c = splitter * acytail;
+    ahi = c - (c - acytail);
+    alo = acytail - ahi;
+    c = splitter * bcx;
+    bhi = c - (c - bcx);
+    blo = bcx - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    u[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    u[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    u3 = _j + _i;
+    bvirt = u3 - _j;
+    u[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    u[3] = u3;
+    const C1len = sum(4, B, 4, u, C1);
+
+    s1 = acx * bcytail;
+    c = splitter * acx;
+    ahi = c - (c - acx);
+    alo = acx - ahi;
+    c = splitter * bcytail;
+    bhi = c - (c - bcytail);
+    blo = bcytail - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = acy * bcxtail;
+    c = splitter * acy;
+    ahi = c - (c - acy);
+    alo = acy - ahi;
+    c = splitter * bcxtail;
+    bhi = c - (c - bcxtail);
+    blo = bcxtail - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    u[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    u[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    u3 = _j + _i;
+    bvirt = u3 - _j;
+    u[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    u[3] = u3;
+    const C2len = sum(C1len, C1, 4, u, C2);
+
+    s1 = acxtail * bcytail;
+    c = splitter * acxtail;
+    ahi = c - (c - acxtail);
+    alo = acxtail - ahi;
+    c = splitter * bcytail;
+    bhi = c - (c - bcytail);
+    blo = bcytail - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = acytail * bcxtail;
+    c = splitter * acytail;
+    ahi = c - (c - acytail);
+    alo = acytail - ahi;
+    c = splitter * bcxtail;
+    bhi = c - (c - bcxtail);
+    blo = bcxtail - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    u[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    u[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    u3 = _j + _i;
+    bvirt = u3 - _j;
+    u[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    u[3] = u3;
+    const Dlen = sum(C2len, C2, 4, u, D);
+
+    return D[Dlen - 1];
+}
+
+function orient2d(ax, ay, bx, by, cx, cy) {
+    const detleft = (ay - cy) * (bx - cx);
+    const detright = (ax - cx) * (by - cy);
+    const det = detleft - detright;
+
+    const detsum = Math.abs(detleft + detright);
+    if (Math.abs(det) >= ccwerrboundA * detsum) return det;
+
+    return -orient2dadapt(ax, ay, bx, by, cx, cy, detsum);
+}
+
+/**
+ * A bounding box has the format:
+ *
+ *  { ll: { x: xmin, y: ymin }, ur: { x: xmax, y: ymax } }
+ *
+ */
+
+const isInBbox = (bbox, point) => {
+  return bbox.ll.x <= point.x && point.x <= bbox.ur.x && bbox.ll.y <= point.y && point.y <= bbox.ur.y;
+};
+
+/* Returns either null, or a bbox (aka an ordered pair of points)
+ * If there is only one point of overlap, a bbox with identical points
+ * will be returned */
+const getBboxOverlap = (b1, b2) => {
+  // check if the bboxes overlap at all
+  if (b2.ur.x < b1.ll.x || b1.ur.x < b2.ll.x || b2.ur.y < b1.ll.y || b1.ur.y < b2.ll.y) return null;
+
+  // find the middle two X values
+  const lowerX = b1.ll.x < b2.ll.x ? b2.ll.x : b1.ll.x;
+  const upperX = b1.ur.x < b2.ur.x ? b1.ur.x : b2.ur.x;
+
+  // find the middle two Y values
+  const lowerY = b1.ll.y < b2.ll.y ? b2.ll.y : b1.ll.y;
+  const upperY = b1.ur.y < b2.ur.y ? b1.ur.y : b2.ur.y;
+
+  // put those middle values together to get the overlap
+  return {
+    ll: {
+      x: lowerX,
+      y: lowerY
+    },
+    ur: {
+      x: upperX,
+      y: upperY
+    }
+  };
+};
+
+/* Javascript doesn't do integer math. Everything is
+ * floating point with percision Number.EPSILON.
+ *
+ * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/EPSILON
+ */
+
+let epsilon = Number.EPSILON;
+
+// IE Polyfill
+if (epsilon === undefined) epsilon = Math.pow(2, -52);
+const EPSILON_SQ = epsilon * epsilon;
+
+/* FLP comparator */
+const cmp = (a, b) => {
+  // check if they're both 0
+  if (-epsilon < a && a < epsilon) {
+    if (-epsilon < b && b < epsilon) {
+      return 0;
+    }
+  }
+
+  // check if they're flp equal
+  const ab = a - b;
+  if (ab * ab < EPSILON_SQ * a * b) {
+    return 0;
+  }
+
+  // normal comparison
+  return a < b ? -1 : 1;
+};
+
+/**
+ * This class rounds incoming values sufficiently so that
+ * floating points problems are, for the most part, avoided.
+ *
+ * Incoming points are have their x & y values tested against
+ * all previously seen x & y values. If either is 'too close'
+ * to a previously seen value, it's value is 'snapped' to the
+ * previously seen value.
+ *
+ * All points should be rounded by this class before being
+ * stored in any data structures in the rest of this algorithm.
+ */
+
+class PtRounder {
+  constructor() {
+    this.reset();
+  }
+  reset() {
+    this.xRounder = new CoordRounder();
+    this.yRounder = new CoordRounder();
+  }
+  round(x, y) {
+    return {
+      x: this.xRounder.round(x),
+      y: this.yRounder.round(y)
+    };
+  }
+}
+class CoordRounder {
+  constructor() {
+    this.tree = new Tree();
+    // preseed with 0 so we don't end up with values < Number.EPSILON
+    this.round(0);
+  }
+
+  // Note: this can rounds input values backwards or forwards.
+  //       You might ask, why not restrict this to just rounding
+  //       forwards? Wouldn't that allow left endpoints to always
+  //       remain left endpoints during splitting (never change to
+  //       right). No - it wouldn't, because we snap intersections
+  //       to endpoints (to establish independence from the segment
+  //       angle for t-intersections).
+  round(coord) {
+    const node = this.tree.add(coord);
+    const prevNode = this.tree.prev(node);
+    if (prevNode !== null && cmp(node.key, prevNode.key) === 0) {
+      this.tree.remove(coord);
+      return prevNode.key;
+    }
+    const nextNode = this.tree.next(node);
+    if (nextNode !== null && cmp(node.key, nextNode.key) === 0) {
+      this.tree.remove(coord);
+      return nextNode.key;
+    }
+    return coord;
+  }
+}
+
+// singleton available by import
+const rounder = new PtRounder();
+
+/* Cross Product of two vectors with first point at origin */
+const crossProduct = (a, b) => a.x * b.y - a.y * b.x;
+
+/* Dot Product of two vectors with first point at origin */
+const dotProduct = (a, b) => a.x * b.x + a.y * b.y;
+
+/* Comparator for two vectors with same starting point */
+const compareVectorAngles = (basePt, endPt1, endPt2) => {
+  const res = orient2d(basePt.x, basePt.y, endPt1.x, endPt1.y, endPt2.x, endPt2.y);
+  if (res > 0) return -1;
+  if (res < 0) return 1;
+  return 0;
+};
+const length = v => Math.sqrt(dotProduct(v, v));
+
+/* Get the sine of the angle from pShared -> pAngle to pShaed -> pBase */
+const sineOfAngle = (pShared, pBase, pAngle) => {
+  const vBase = {
+    x: pBase.x - pShared.x,
+    y: pBase.y - pShared.y
+  };
+  const vAngle = {
+    x: pAngle.x - pShared.x,
+    y: pAngle.y - pShared.y
+  };
+  return crossProduct(vAngle, vBase) / length(vAngle) / length(vBase);
+};
+
+/* Get the cosine of the angle from pShared -> pAngle to pShaed -> pBase */
+const cosineOfAngle = (pShared, pBase, pAngle) => {
+  const vBase = {
+    x: pBase.x - pShared.x,
+    y: pBase.y - pShared.y
+  };
+  const vAngle = {
+    x: pAngle.x - pShared.x,
+    y: pAngle.y - pShared.y
+  };
+  return dotProduct(vAngle, vBase) / length(vAngle) / length(vBase);
+};
+
+/* Get the x coordinate where the given line (defined by a point and vector)
+ * crosses the horizontal line with the given y coordiante.
+ * In the case of parrallel lines (including overlapping ones) returns null. */
+const horizontalIntersection = (pt, v, y) => {
+  if (v.y === 0) return null;
+  return {
+    x: pt.x + v.x / v.y * (y - pt.y),
+    y: y
+  };
+};
+
+/* Get the y coordinate where the given line (defined by a point and vector)
+ * crosses the vertical line with the given x coordiante.
+ * In the case of parrallel lines (including overlapping ones) returns null. */
+const verticalIntersection = (pt, v, x) => {
+  if (v.x === 0) return null;
+  return {
+    x: x,
+    y: pt.y + v.y / v.x * (x - pt.x)
+  };
+};
+
+/* Get the intersection of two lines, each defined by a base point and a vector.
+ * In the case of parrallel lines (including overlapping ones) returns null. */
+const intersection$1 = (pt1, v1, pt2, v2) => {
+  // take some shortcuts for vertical and horizontal lines
+  // this also ensures we don't calculate an intersection and then discover
+  // it's actually outside the bounding box of the line
+  if (v1.x === 0) return verticalIntersection(pt2, v2, pt1.x);
+  if (v2.x === 0) return verticalIntersection(pt1, v1, pt2.x);
+  if (v1.y === 0) return horizontalIntersection(pt2, v2, pt1.y);
+  if (v2.y === 0) return horizontalIntersection(pt1, v1, pt2.y);
+
+  // General case for non-overlapping segments.
+  // This algorithm is based on Schneider and Eberly.
+  // http://www.cimec.org.ar/~ncalvo/Schneider_Eberly.pdf - pg 244
+
+  const kross = crossProduct(v1, v2);
+  if (kross == 0) return null;
+  const ve = {
+    x: pt2.x - pt1.x,
+    y: pt2.y - pt1.y
+  };
+  const d1 = crossProduct(ve, v1) / kross;
+  const d2 = crossProduct(ve, v2) / kross;
+
+  // take the average of the two calculations to minimize rounding error
+  const x1 = pt1.x + d2 * v1.x,
+    x2 = pt2.x + d1 * v2.x;
+  const y1 = pt1.y + d2 * v1.y,
+    y2 = pt2.y + d1 * v2.y;
+  const x = (x1 + x2) / 2;
+  const y = (y1 + y2) / 2;
+  return {
+    x: x,
+    y: y
+  };
+};
+
+class SweepEvent {
+  // for ordering sweep events in the sweep event queue
+  static compare(a, b) {
+    // favor event with a point that the sweep line hits first
+    const ptCmp = SweepEvent.comparePoints(a.point, b.point);
+    if (ptCmp !== 0) return ptCmp;
+
+    // the points are the same, so link them if needed
+    if (a.point !== b.point) a.link(b);
+
+    // favor right events over left
+    if (a.isLeft !== b.isLeft) return a.isLeft ? 1 : -1;
+
+    // we have two matching left or right endpoints
+    // ordering of this case is the same as for their segments
+    return Segment.compare(a.segment, b.segment);
+  }
+
+  // for ordering points in sweep line order
+  static comparePoints(aPt, bPt) {
+    if (aPt.x < bPt.x) return -1;
+    if (aPt.x > bPt.x) return 1;
+    if (aPt.y < bPt.y) return -1;
+    if (aPt.y > bPt.y) return 1;
+    return 0;
+  }
+
+  // Warning: 'point' input will be modified and re-used (for performance)
+  constructor(point, isLeft) {
+    if (point.events === undefined) point.events = [this];else point.events.push(this);
+    this.point = point;
+    this.isLeft = isLeft;
+    // this.segment, this.otherSE set by factory
+  }
+  link(other) {
+    if (other.point === this.point) {
+      throw new Error("Tried to link already linked events");
+    }
+    const otherEvents = other.point.events;
+    for (let i = 0, iMax = otherEvents.length; i < iMax; i++) {
+      const evt = otherEvents[i];
+      this.point.events.push(evt);
+      evt.point = this.point;
+    }
+    this.checkForConsuming();
+  }
+
+  /* Do a pass over our linked events and check to see if any pair
+   * of segments match, and should be consumed. */
+  checkForConsuming() {
+    // FIXME: The loops in this method run O(n^2) => no good.
+    //        Maintain little ordered sweep event trees?
+    //        Can we maintaining an ordering that avoids the need
+    //        for the re-sorting with getLeftmostComparator in geom-out?
+
+    // Compare each pair of events to see if other events also match
+    const numEvents = this.point.events.length;
+    for (let i = 0; i < numEvents; i++) {
+      const evt1 = this.point.events[i];
+      if (evt1.segment.consumedBy !== undefined) continue;
+      for (let j = i + 1; j < numEvents; j++) {
+        const evt2 = this.point.events[j];
+        if (evt2.consumedBy !== undefined) continue;
+        if (evt1.otherSE.point.events !== evt2.otherSE.point.events) continue;
+        evt1.segment.consume(evt2.segment);
+      }
+    }
+  }
+  getAvailableLinkedEvents() {
+    // point.events is always of length 2 or greater
+    const events = [];
+    for (let i = 0, iMax = this.point.events.length; i < iMax; i++) {
+      const evt = this.point.events[i];
+      if (evt !== this && !evt.segment.ringOut && evt.segment.isInResult()) {
+        events.push(evt);
+      }
+    }
+    return events;
+  }
+
+  /**
+   * Returns a comparator function for sorting linked events that will
+   * favor the event that will give us the smallest left-side angle.
+   * All ring construction starts as low as possible heading to the right,
+   * so by always turning left as sharp as possible we'll get polygons
+   * without uncessary loops & holes.
+   *
+   * The comparator function has a compute cache such that it avoids
+   * re-computing already-computed values.
+   */
+  getLeftmostComparator(baseEvent) {
+    const cache = new Map();
+    const fillCache = linkedEvent => {
+      const nextEvent = linkedEvent.otherSE;
+      cache.set(linkedEvent, {
+        sine: sineOfAngle(this.point, baseEvent.point, nextEvent.point),
+        cosine: cosineOfAngle(this.point, baseEvent.point, nextEvent.point)
+      });
+    };
+    return (a, b) => {
+      if (!cache.has(a)) fillCache(a);
+      if (!cache.has(b)) fillCache(b);
+      const {
+        sine: asine,
+        cosine: acosine
+      } = cache.get(a);
+      const {
+        sine: bsine,
+        cosine: bcosine
+      } = cache.get(b);
+
+      // both on or above x-axis
+      if (asine >= 0 && bsine >= 0) {
+        if (acosine < bcosine) return 1;
+        if (acosine > bcosine) return -1;
+        return 0;
+      }
+
+      // both below x-axis
+      if (asine < 0 && bsine < 0) {
+        if (acosine < bcosine) return -1;
+        if (acosine > bcosine) return 1;
+        return 0;
+      }
+
+      // one above x-axis, one below
+      if (bsine < asine) return -1;
+      if (bsine > asine) return 1;
+      return 0;
+    };
+  }
+}
+
+// Give segments unique ID's to get consistent sorting of
+// segments and sweep events when all else is identical
+let segmentId = 0;
+class Segment {
+  /* This compare() function is for ordering segments in the sweep
+   * line tree, and does so according to the following criteria:
+   *
+   * Consider the vertical line that lies an infinestimal step to the
+   * right of the right-more of the two left endpoints of the input
+   * segments. Imagine slowly moving a point up from negative infinity
+   * in the increasing y direction. Which of the two segments will that
+   * point intersect first? That segment comes 'before' the other one.
+   *
+   * If neither segment would be intersected by such a line, (if one
+   * or more of the segments are vertical) then the line to be considered
+   * is directly on the right-more of the two left inputs.
+   */
+  static compare(a, b) {
+    const alx = a.leftSE.point.x;
+    const blx = b.leftSE.point.x;
+    const arx = a.rightSE.point.x;
+    const brx = b.rightSE.point.x;
+
+    // check if they're even in the same vertical plane
+    if (brx < alx) return 1;
+    if (arx < blx) return -1;
+    const aly = a.leftSE.point.y;
+    const bly = b.leftSE.point.y;
+    const ary = a.rightSE.point.y;
+    const bry = b.rightSE.point.y;
+
+    // is left endpoint of segment B the right-more?
+    if (alx < blx) {
+      // are the two segments in the same horizontal plane?
+      if (bly < aly && bly < ary) return 1;
+      if (bly > aly && bly > ary) return -1;
+
+      // is the B left endpoint colinear to segment A?
+      const aCmpBLeft = a.comparePoint(b.leftSE.point);
+      if (aCmpBLeft < 0) return 1;
+      if (aCmpBLeft > 0) return -1;
+
+      // is the A right endpoint colinear to segment B ?
+      const bCmpARight = b.comparePoint(a.rightSE.point);
+      if (bCmpARight !== 0) return bCmpARight;
+
+      // colinear segments, consider the one with left-more
+      // left endpoint to be first (arbitrary?)
+      return -1;
+    }
+
+    // is left endpoint of segment A the right-more?
+    if (alx > blx) {
+      if (aly < bly && aly < bry) return -1;
+      if (aly > bly && aly > bry) return 1;
+
+      // is the A left endpoint colinear to segment B?
+      const bCmpALeft = b.comparePoint(a.leftSE.point);
+      if (bCmpALeft !== 0) return bCmpALeft;
+
+      // is the B right endpoint colinear to segment A?
+      const aCmpBRight = a.comparePoint(b.rightSE.point);
+      if (aCmpBRight < 0) return 1;
+      if (aCmpBRight > 0) return -1;
+
+      // colinear segments, consider the one with left-more
+      // left endpoint to be first (arbitrary?)
+      return 1;
+    }
+
+    // if we get here, the two left endpoints are in the same
+    // vertical plane, ie alx === blx
+
+    // consider the lower left-endpoint to come first
+    if (aly < bly) return -1;
+    if (aly > bly) return 1;
+
+    // left endpoints are identical
+    // check for colinearity by using the left-more right endpoint
+
+    // is the A right endpoint more left-more?
+    if (arx < brx) {
+      const bCmpARight = b.comparePoint(a.rightSE.point);
+      if (bCmpARight !== 0) return bCmpARight;
+    }
+
+    // is the B right endpoint more left-more?
+    if (arx > brx) {
+      const aCmpBRight = a.comparePoint(b.rightSE.point);
+      if (aCmpBRight < 0) return 1;
+      if (aCmpBRight > 0) return -1;
+    }
+    if (arx !== brx) {
+      // are these two [almost] vertical segments with opposite orientation?
+      // if so, the one with the lower right endpoint comes first
+      const ay = ary - aly;
+      const ax = arx - alx;
+      const by = bry - bly;
+      const bx = brx - blx;
+      if (ay > ax && by < bx) return 1;
+      if (ay < ax && by > bx) return -1;
+    }
+
+    // we have colinear segments with matching orientation
+    // consider the one with more left-more right endpoint to be first
+    if (arx > brx) return 1;
+    if (arx < brx) return -1;
+
+    // if we get here, two two right endpoints are in the same
+    // vertical plane, ie arx === brx
+
+    // consider the lower right-endpoint to come first
+    if (ary < bry) return -1;
+    if (ary > bry) return 1;
+
+    // right endpoints identical as well, so the segments are idential
+    // fall back on creation order as consistent tie-breaker
+    if (a.id < b.id) return -1;
+    if (a.id > b.id) return 1;
+
+    // identical segment, ie a === b
+    return 0;
+  }
+
+  /* Warning: a reference to ringWindings input will be stored,
+   *  and possibly will be later modified */
+  constructor(leftSE, rightSE, rings, windings) {
+    this.id = ++segmentId;
+    this.leftSE = leftSE;
+    leftSE.segment = this;
+    leftSE.otherSE = rightSE;
+    this.rightSE = rightSE;
+    rightSE.segment = this;
+    rightSE.otherSE = leftSE;
+    this.rings = rings;
+    this.windings = windings;
+    // left unset for performance, set later in algorithm
+    // this.ringOut, this.consumedBy, this.prev
+  }
+  static fromRing(pt1, pt2, ring) {
+    let leftPt, rightPt, winding;
+
+    // ordering the two points according to sweep line ordering
+    const cmpPts = SweepEvent.comparePoints(pt1, pt2);
+    if (cmpPts < 0) {
+      leftPt = pt1;
+      rightPt = pt2;
+      winding = 1;
+    } else if (cmpPts > 0) {
+      leftPt = pt2;
+      rightPt = pt1;
+      winding = -1;
+    } else throw new Error(`Tried to create degenerate segment at [${pt1.x}, ${pt1.y}]`);
+    const leftSE = new SweepEvent(leftPt, true);
+    const rightSE = new SweepEvent(rightPt, false);
+    return new Segment(leftSE, rightSE, [ring], [winding]);
+  }
+
+  /* When a segment is split, the rightSE is replaced with a new sweep event */
+  replaceRightSE(newRightSE) {
+    this.rightSE = newRightSE;
+    this.rightSE.segment = this;
+    this.rightSE.otherSE = this.leftSE;
+    this.leftSE.otherSE = this.rightSE;
+  }
+  bbox() {
+    const y1 = this.leftSE.point.y;
+    const y2 = this.rightSE.point.y;
+    return {
+      ll: {
+        x: this.leftSE.point.x,
+        y: y1 < y2 ? y1 : y2
+      },
+      ur: {
+        x: this.rightSE.point.x,
+        y: y1 > y2 ? y1 : y2
+      }
+    };
+  }
+
+  /* A vector from the left point to the right */
+  vector() {
+    return {
+      x: this.rightSE.point.x - this.leftSE.point.x,
+      y: this.rightSE.point.y - this.leftSE.point.y
+    };
+  }
+  isAnEndpoint(pt) {
+    return pt.x === this.leftSE.point.x && pt.y === this.leftSE.point.y || pt.x === this.rightSE.point.x && pt.y === this.rightSE.point.y;
+  }
+
+  /* Compare this segment with a point.
+   *
+   * A point P is considered to be colinear to a segment if there
+   * exists a distance D such that if we travel along the segment
+   * from one * endpoint towards the other a distance D, we find
+   * ourselves at point P.
+   *
+   * Return value indicates:
+   *
+   *   1: point lies above the segment (to the left of vertical)
+   *   0: point is colinear to segment
+   *  -1: point lies below the segment (to the right of vertical)
+   */
+  comparePoint(point) {
+    if (this.isAnEndpoint(point)) return 0;
+    const lPt = this.leftSE.point;
+    const rPt = this.rightSE.point;
+    const v = this.vector();
+
+    // Exactly vertical segments.
+    if (lPt.x === rPt.x) {
+      if (point.x === lPt.x) return 0;
+      return point.x < lPt.x ? 1 : -1;
+    }
+
+    // Nearly vertical segments with an intersection.
+    // Check to see where a point on the line with matching Y coordinate is.
+    const yDist = (point.y - lPt.y) / v.y;
+    const xFromYDist = lPt.x + yDist * v.x;
+    if (point.x === xFromYDist) return 0;
+
+    // General case.
+    // Check to see where a point on the line with matching X coordinate is.
+    const xDist = (point.x - lPt.x) / v.x;
+    const yFromXDist = lPt.y + xDist * v.y;
+    if (point.y === yFromXDist) return 0;
+    return point.y < yFromXDist ? -1 : 1;
+  }
+
+  /**
+   * Given another segment, returns the first non-trivial intersection
+   * between the two segments (in terms of sweep line ordering), if it exists.
+   *
+   * A 'non-trivial' intersection is one that will cause one or both of the
+   * segments to be split(). As such, 'trivial' vs. 'non-trivial' intersection:
+   *
+   *   * endpoint of segA with endpoint of segB --> trivial
+   *   * endpoint of segA with point along segB --> non-trivial
+   *   * endpoint of segB with point along segA --> non-trivial
+   *   * point along segA with point along segB --> non-trivial
+   *
+   * If no non-trivial intersection exists, return null
+   * Else, return null.
+   */
+  getIntersection(other) {
+    // If bboxes don't overlap, there can't be any intersections
+    const tBbox = this.bbox();
+    const oBbox = other.bbox();
+    const bboxOverlap = getBboxOverlap(tBbox, oBbox);
+    if (bboxOverlap === null) return null;
+
+    // We first check to see if the endpoints can be considered intersections.
+    // This will 'snap' intersections to endpoints if possible, and will
+    // handle cases of colinearity.
+
+    const tlp = this.leftSE.point;
+    const trp = this.rightSE.point;
+    const olp = other.leftSE.point;
+    const orp = other.rightSE.point;
+
+    // does each endpoint touch the other segment?
+    // note that we restrict the 'touching' definition to only allow segments
+    // to touch endpoints that lie forward from where we are in the sweep line pass
+    const touchesOtherLSE = isInBbox(tBbox, olp) && this.comparePoint(olp) === 0;
+    const touchesThisLSE = isInBbox(oBbox, tlp) && other.comparePoint(tlp) === 0;
+    const touchesOtherRSE = isInBbox(tBbox, orp) && this.comparePoint(orp) === 0;
+    const touchesThisRSE = isInBbox(oBbox, trp) && other.comparePoint(trp) === 0;
+
+    // do left endpoints match?
+    if (touchesThisLSE && touchesOtherLSE) {
+      // these two cases are for colinear segments with matching left
+      // endpoints, and one segment being longer than the other
+      if (touchesThisRSE && !touchesOtherRSE) return trp;
+      if (!touchesThisRSE && touchesOtherRSE) return orp;
+      // either the two segments match exactly (two trival intersections)
+      // or just on their left endpoint (one trivial intersection
+      return null;
+    }
+
+    // does this left endpoint matches (other doesn't)
+    if (touchesThisLSE) {
+      // check for segments that just intersect on opposing endpoints
+      if (touchesOtherRSE) {
+        if (tlp.x === orp.x && tlp.y === orp.y) return null;
+      }
+      // t-intersection on left endpoint
+      return tlp;
+    }
+
+    // does other left endpoint matches (this doesn't)
+    if (touchesOtherLSE) {
+      // check for segments that just intersect on opposing endpoints
+      if (touchesThisRSE) {
+        if (trp.x === olp.x && trp.y === olp.y) return null;
+      }
+      // t-intersection on left endpoint
+      return olp;
+    }
+
+    // trivial intersection on right endpoints
+    if (touchesThisRSE && touchesOtherRSE) return null;
+
+    // t-intersections on just one right endpoint
+    if (touchesThisRSE) return trp;
+    if (touchesOtherRSE) return orp;
+
+    // None of our endpoints intersect. Look for a general intersection between
+    // infinite lines laid over the segments
+    const pt = intersection$1(tlp, this.vector(), olp, other.vector());
+
+    // are the segments parrallel? Note that if they were colinear with overlap,
+    // they would have an endpoint intersection and that case was already handled above
+    if (pt === null) return null;
+
+    // is the intersection found between the lines not on the segments?
+    if (!isInBbox(bboxOverlap, pt)) return null;
+
+    // round the the computed point if needed
+    return rounder.round(pt.x, pt.y);
+  }
+
+  /**
+   * Split the given segment into multiple segments on the given points.
+   *  * Each existing segment will retain its leftSE and a new rightSE will be
+   *    generated for it.
+   *  * A new segment will be generated which will adopt the original segment's
+   *    rightSE, and a new leftSE will be generated for it.
+   *  * If there are more than two points given to split on, new segments
+   *    in the middle will be generated with new leftSE and rightSE's.
+   *  * An array of the newly generated SweepEvents will be returned.
+   *
+   * Warning: input array of points is modified
+   */
+  split(point) {
+    const newEvents = [];
+    const alreadyLinked = point.events !== undefined;
+    const newLeftSE = new SweepEvent(point, true);
+    const newRightSE = new SweepEvent(point, false);
+    const oldRightSE = this.rightSE;
+    this.replaceRightSE(newRightSE);
+    newEvents.push(newRightSE);
+    newEvents.push(newLeftSE);
+    const newSeg = new Segment(newLeftSE, oldRightSE, this.rings.slice(), this.windings.slice());
+
+    // when splitting a nearly vertical downward-facing segment,
+    // sometimes one of the resulting new segments is vertical, in which
+    // case its left and right events may need to be swapped
+    if (SweepEvent.comparePoints(newSeg.leftSE.point, newSeg.rightSE.point) > 0) {
+      newSeg.swapEvents();
+    }
+    if (SweepEvent.comparePoints(this.leftSE.point, this.rightSE.point) > 0) {
+      this.swapEvents();
+    }
+
+    // in the point we just used to create new sweep events with was already
+    // linked to other events, we need to check if either of the affected
+    // segments should be consumed
+    if (alreadyLinked) {
+      newLeftSE.checkForConsuming();
+      newRightSE.checkForConsuming();
+    }
+    return newEvents;
+  }
+
+  /* Swap which event is left and right */
+  swapEvents() {
+    const tmpEvt = this.rightSE;
+    this.rightSE = this.leftSE;
+    this.leftSE = tmpEvt;
+    this.leftSE.isLeft = true;
+    this.rightSE.isLeft = false;
+    for (let i = 0, iMax = this.windings.length; i < iMax; i++) {
+      this.windings[i] *= -1;
+    }
+  }
+
+  /* Consume another segment. We take their rings under our wing
+   * and mark them as consumed. Use for perfectly overlapping segments */
+  consume(other) {
+    let consumer = this;
+    let consumee = other;
+    while (consumer.consumedBy) consumer = consumer.consumedBy;
+    while (consumee.consumedBy) consumee = consumee.consumedBy;
+    const cmp = Segment.compare(consumer, consumee);
+    if (cmp === 0) return; // already consumed
+    // the winner of the consumption is the earlier segment
+    // according to sweep line ordering
+    if (cmp > 0) {
+      const tmp = consumer;
+      consumer = consumee;
+      consumee = tmp;
+    }
+
+    // make sure a segment doesn't consume it's prev
+    if (consumer.prev === consumee) {
+      const tmp = consumer;
+      consumer = consumee;
+      consumee = tmp;
+    }
+    for (let i = 0, iMax = consumee.rings.length; i < iMax; i++) {
+      const ring = consumee.rings[i];
+      const winding = consumee.windings[i];
+      const index = consumer.rings.indexOf(ring);
+      if (index === -1) {
+        consumer.rings.push(ring);
+        consumer.windings.push(winding);
+      } else consumer.windings[index] += winding;
+    }
+    consumee.rings = null;
+    consumee.windings = null;
+    consumee.consumedBy = consumer;
+
+    // mark sweep events consumed as to maintain ordering in sweep event queue
+    consumee.leftSE.consumedBy = consumer.leftSE;
+    consumee.rightSE.consumedBy = consumer.rightSE;
+  }
+
+  /* The first segment previous segment chain that is in the result */
+  prevInResult() {
+    if (this._prevInResult !== undefined) return this._prevInResult;
+    if (!this.prev) this._prevInResult = null;else if (this.prev.isInResult()) this._prevInResult = this.prev;else this._prevInResult = this.prev.prevInResult();
+    return this._prevInResult;
+  }
+  beforeState() {
+    if (this._beforeState !== undefined) return this._beforeState;
+    if (!this.prev) this._beforeState = {
+      rings: [],
+      windings: [],
+      multiPolys: []
+    };else {
+      const seg = this.prev.consumedBy || this.prev;
+      this._beforeState = seg.afterState();
+    }
+    return this._beforeState;
+  }
+  afterState() {
+    if (this._afterState !== undefined) return this._afterState;
+    const beforeState = this.beforeState();
+    this._afterState = {
+      rings: beforeState.rings.slice(0),
+      windings: beforeState.windings.slice(0),
+      multiPolys: []
+    };
+    const ringsAfter = this._afterState.rings;
+    const windingsAfter = this._afterState.windings;
+    const mpsAfter = this._afterState.multiPolys;
+
+    // calculate ringsAfter, windingsAfter
+    for (let i = 0, iMax = this.rings.length; i < iMax; i++) {
+      const ring = this.rings[i];
+      const winding = this.windings[i];
+      const index = ringsAfter.indexOf(ring);
+      if (index === -1) {
+        ringsAfter.push(ring);
+        windingsAfter.push(winding);
+      } else windingsAfter[index] += winding;
+    }
+
+    // calcualte polysAfter
+    const polysAfter = [];
+    const polysExclude = [];
+    for (let i = 0, iMax = ringsAfter.length; i < iMax; i++) {
+      if (windingsAfter[i] === 0) continue; // non-zero rule
+      const ring = ringsAfter[i];
+      const poly = ring.poly;
+      if (polysExclude.indexOf(poly) !== -1) continue;
+      if (ring.isExterior) polysAfter.push(poly);else {
+        if (polysExclude.indexOf(poly) === -1) polysExclude.push(poly);
+        const index = polysAfter.indexOf(ring.poly);
+        if (index !== -1) polysAfter.splice(index, 1);
+      }
+    }
+
+    // calculate multiPolysAfter
+    for (let i = 0, iMax = polysAfter.length; i < iMax; i++) {
+      const mp = polysAfter[i].multiPoly;
+      if (mpsAfter.indexOf(mp) === -1) mpsAfter.push(mp);
+    }
+    return this._afterState;
+  }
+
+  /* Is this segment part of the final result? */
+  isInResult() {
+    // if we've been consumed, we're not in the result
+    if (this.consumedBy) return false;
+    if (this._isInResult !== undefined) return this._isInResult;
+    const mpsBefore = this.beforeState().multiPolys;
+    const mpsAfter = this.afterState().multiPolys;
+    switch (operation.type) {
+      case "union":
+        {
+          // UNION - included iff:
+          //  * On one side of us there is 0 poly interiors AND
+          //  * On the other side there is 1 or more.
+          const noBefores = mpsBefore.length === 0;
+          const noAfters = mpsAfter.length === 0;
+          this._isInResult = noBefores !== noAfters;
+          break;
+        }
+      case "intersection":
+        {
+          // INTERSECTION - included iff:
+          //  * on one side of us all multipolys are rep. with poly interiors AND
+          //  * on the other side of us, not all multipolys are repsented
+          //    with poly interiors
+          let least;
+          let most;
+          if (mpsBefore.length < mpsAfter.length) {
+            least = mpsBefore.length;
+            most = mpsAfter.length;
+          } else {
+            least = mpsAfter.length;
+            most = mpsBefore.length;
+          }
+          this._isInResult = most === operation.numMultiPolys && least < most;
+          break;
+        }
+      case "xor":
+        {
+          // XOR - included iff:
+          //  * the difference between the number of multipolys represented
+          //    with poly interiors on our two sides is an odd number
+          const diff = Math.abs(mpsBefore.length - mpsAfter.length);
+          this._isInResult = diff % 2 === 1;
+          break;
+        }
+      case "difference":
+        {
+          // DIFFERENCE included iff:
+          //  * on exactly one side, we have just the subject
+          const isJustSubject = mps => mps.length === 1 && mps[0].isSubject;
+          this._isInResult = isJustSubject(mpsBefore) !== isJustSubject(mpsAfter);
+          break;
+        }
+      default:
+        throw new Error(`Unrecognized operation type found ${operation.type}`);
+    }
+    return this._isInResult;
+  }
+}
+
+class RingIn {
+  constructor(geomRing, poly, isExterior) {
+    if (!Array.isArray(geomRing) || geomRing.length === 0) {
+      throw new Error("Input geometry is not a valid Polygon or MultiPolygon");
+    }
+    this.poly = poly;
+    this.isExterior = isExterior;
+    this.segments = [];
+    if (typeof geomRing[0][0] !== "number" || typeof geomRing[0][1] !== "number") {
+      throw new Error("Input geometry is not a valid Polygon or MultiPolygon");
+    }
+    const firstPoint = rounder.round(geomRing[0][0], geomRing[0][1]);
+    this.bbox = {
+      ll: {
+        x: firstPoint.x,
+        y: firstPoint.y
+      },
+      ur: {
+        x: firstPoint.x,
+        y: firstPoint.y
+      }
+    };
+    let prevPoint = firstPoint;
+    for (let i = 1, iMax = geomRing.length; i < iMax; i++) {
+      if (typeof geomRing[i][0] !== "number" || typeof geomRing[i][1] !== "number") {
+        throw new Error("Input geometry is not a valid Polygon or MultiPolygon");
+      }
+      let point = rounder.round(geomRing[i][0], geomRing[i][1]);
+      // skip repeated points
+      if (point.x === prevPoint.x && point.y === prevPoint.y) continue;
+      this.segments.push(Segment.fromRing(prevPoint, point, this));
+      if (point.x < this.bbox.ll.x) this.bbox.ll.x = point.x;
+      if (point.y < this.bbox.ll.y) this.bbox.ll.y = point.y;
+      if (point.x > this.bbox.ur.x) this.bbox.ur.x = point.x;
+      if (point.y > this.bbox.ur.y) this.bbox.ur.y = point.y;
+      prevPoint = point;
+    }
+    // add segment from last to first if last is not the same as first
+    if (firstPoint.x !== prevPoint.x || firstPoint.y !== prevPoint.y) {
+      this.segments.push(Segment.fromRing(prevPoint, firstPoint, this));
+    }
+  }
+  getSweepEvents() {
+    const sweepEvents = [];
+    for (let i = 0, iMax = this.segments.length; i < iMax; i++) {
+      const segment = this.segments[i];
+      sweepEvents.push(segment.leftSE);
+      sweepEvents.push(segment.rightSE);
+    }
+    return sweepEvents;
+  }
+}
+class PolyIn {
+  constructor(geomPoly, multiPoly) {
+    if (!Array.isArray(geomPoly)) {
+      throw new Error("Input geometry is not a valid Polygon or MultiPolygon");
+    }
+    this.exteriorRing = new RingIn(geomPoly[0], this, true);
+    // copy by value
+    this.bbox = {
+      ll: {
+        x: this.exteriorRing.bbox.ll.x,
+        y: this.exteriorRing.bbox.ll.y
+      },
+      ur: {
+        x: this.exteriorRing.bbox.ur.x,
+        y: this.exteriorRing.bbox.ur.y
+      }
+    };
+    this.interiorRings = [];
+    for (let i = 1, iMax = geomPoly.length; i < iMax; i++) {
+      const ring = new RingIn(geomPoly[i], this, false);
+      if (ring.bbox.ll.x < this.bbox.ll.x) this.bbox.ll.x = ring.bbox.ll.x;
+      if (ring.bbox.ll.y < this.bbox.ll.y) this.bbox.ll.y = ring.bbox.ll.y;
+      if (ring.bbox.ur.x > this.bbox.ur.x) this.bbox.ur.x = ring.bbox.ur.x;
+      if (ring.bbox.ur.y > this.bbox.ur.y) this.bbox.ur.y = ring.bbox.ur.y;
+      this.interiorRings.push(ring);
+    }
+    this.multiPoly = multiPoly;
+  }
+  getSweepEvents() {
+    const sweepEvents = this.exteriorRing.getSweepEvents();
+    for (let i = 0, iMax = this.interiorRings.length; i < iMax; i++) {
+      const ringSweepEvents = this.interiorRings[i].getSweepEvents();
+      for (let j = 0, jMax = ringSweepEvents.length; j < jMax; j++) {
+        sweepEvents.push(ringSweepEvents[j]);
+      }
+    }
+    return sweepEvents;
+  }
+}
+class MultiPolyIn {
+  constructor(geom, isSubject) {
+    if (!Array.isArray(geom)) {
+      throw new Error("Input geometry is not a valid Polygon or MultiPolygon");
+    }
+    try {
+      // if the input looks like a polygon, convert it to a multipolygon
+      if (typeof geom[0][0][0] === "number") geom = [geom];
+    } catch (ex) {
+      // The input is either malformed or has empty arrays.
+      // In either case, it will be handled later on.
+    }
+    this.polys = [];
+    this.bbox = {
+      ll: {
+        x: Number.POSITIVE_INFINITY,
+        y: Number.POSITIVE_INFINITY
+      },
+      ur: {
+        x: Number.NEGATIVE_INFINITY,
+        y: Number.NEGATIVE_INFINITY
+      }
+    };
+    for (let i = 0, iMax = geom.length; i < iMax; i++) {
+      const poly = new PolyIn(geom[i], this);
+      if (poly.bbox.ll.x < this.bbox.ll.x) this.bbox.ll.x = poly.bbox.ll.x;
+      if (poly.bbox.ll.y < this.bbox.ll.y) this.bbox.ll.y = poly.bbox.ll.y;
+      if (poly.bbox.ur.x > this.bbox.ur.x) this.bbox.ur.x = poly.bbox.ur.x;
+      if (poly.bbox.ur.y > this.bbox.ur.y) this.bbox.ur.y = poly.bbox.ur.y;
+      this.polys.push(poly);
+    }
+    this.isSubject = isSubject;
+  }
+  getSweepEvents() {
+    const sweepEvents = [];
+    for (let i = 0, iMax = this.polys.length; i < iMax; i++) {
+      const polySweepEvents = this.polys[i].getSweepEvents();
+      for (let j = 0, jMax = polySweepEvents.length; j < jMax; j++) {
+        sweepEvents.push(polySweepEvents[j]);
+      }
+    }
+    return sweepEvents;
+  }
+}
+
+class RingOut {
+  /* Given the segments from the sweep line pass, compute & return a series
+   * of closed rings from all the segments marked to be part of the result */
+  static factory(allSegments) {
+    const ringsOut = [];
+    for (let i = 0, iMax = allSegments.length; i < iMax; i++) {
+      const segment = allSegments[i];
+      if (!segment.isInResult() || segment.ringOut) continue;
+      let prevEvent = null;
+      let event = segment.leftSE;
+      let nextEvent = segment.rightSE;
+      const events = [event];
+      const startingPoint = event.point;
+      const intersectionLEs = [];
+
+      /* Walk the chain of linked events to form a closed ring */
+      while (true) {
+        prevEvent = event;
+        event = nextEvent;
+        events.push(event);
+
+        /* Is the ring complete? */
+        if (event.point === startingPoint) break;
+        while (true) {
+          const availableLEs = event.getAvailableLinkedEvents();
+
+          /* Did we hit a dead end? This shouldn't happen.
+           * Indicates some earlier part of the algorithm malfunctioned. */
+          if (availableLEs.length === 0) {
+            const firstPt = events[0].point;
+            const lastPt = events[events.length - 1].point;
+            throw new Error(`Unable to complete output ring starting at [${firstPt.x},` + ` ${firstPt.y}]. Last matching segment found ends at` + ` [${lastPt.x}, ${lastPt.y}].`);
+          }
+
+          /* Only one way to go, so cotinue on the path */
+          if (availableLEs.length === 1) {
+            nextEvent = availableLEs[0].otherSE;
+            break;
+          }
+
+          /* We must have an intersection. Check for a completed loop */
+          let indexLE = null;
+          for (let j = 0, jMax = intersectionLEs.length; j < jMax; j++) {
+            if (intersectionLEs[j].point === event.point) {
+              indexLE = j;
+              break;
+            }
+          }
+          /* Found a completed loop. Cut that off and make a ring */
+          if (indexLE !== null) {
+            const intersectionLE = intersectionLEs.splice(indexLE)[0];
+            const ringEvents = events.splice(intersectionLE.index);
+            ringEvents.unshift(ringEvents[0].otherSE);
+            ringsOut.push(new RingOut(ringEvents.reverse()));
+            continue;
+          }
+          /* register the intersection */
+          intersectionLEs.push({
+            index: events.length,
+            point: event.point
+          });
+          /* Choose the left-most option to continue the walk */
+          const comparator = event.getLeftmostComparator(prevEvent);
+          nextEvent = availableLEs.sort(comparator)[0].otherSE;
+          break;
+        }
+      }
+      ringsOut.push(new RingOut(events));
+    }
+    return ringsOut;
+  }
+  constructor(events) {
+    this.events = events;
+    for (let i = 0, iMax = events.length; i < iMax; i++) {
+      events[i].segment.ringOut = this;
+    }
+    this.poly = null;
+  }
+  getGeom() {
+    // Remove superfluous points (ie extra points along a straight line),
+    let prevPt = this.events[0].point;
+    const points = [prevPt];
+    for (let i = 1, iMax = this.events.length - 1; i < iMax; i++) {
+      const pt = this.events[i].point;
+      const nextPt = this.events[i + 1].point;
+      if (compareVectorAngles(pt, prevPt, nextPt) === 0) continue;
+      points.push(pt);
+      prevPt = pt;
+    }
+
+    // ring was all (within rounding error of angle calc) colinear points
+    if (points.length === 1) return null;
+
+    // check if the starting point is necessary
+    const pt = points[0];
+    const nextPt = points[1];
+    if (compareVectorAngles(pt, prevPt, nextPt) === 0) points.shift();
+    points.push(points[0]);
+    const step = this.isExteriorRing() ? 1 : -1;
+    const iStart = this.isExteriorRing() ? 0 : points.length - 1;
+    const iEnd = this.isExteriorRing() ? points.length : -1;
+    const orderedPoints = [];
+    for (let i = iStart; i != iEnd; i += step) orderedPoints.push([points[i].x, points[i].y]);
+    return orderedPoints;
+  }
+  isExteriorRing() {
+    if (this._isExteriorRing === undefined) {
+      const enclosing = this.enclosingRing();
+      this._isExteriorRing = enclosing ? !enclosing.isExteriorRing() : true;
+    }
+    return this._isExteriorRing;
+  }
+  enclosingRing() {
+    if (this._enclosingRing === undefined) {
+      this._enclosingRing = this._calcEnclosingRing();
+    }
+    return this._enclosingRing;
+  }
+
+  /* Returns the ring that encloses this one, if any */
+  _calcEnclosingRing() {
+    // start with the ealier sweep line event so that the prevSeg
+    // chain doesn't lead us inside of a loop of ours
+    let leftMostEvt = this.events[0];
+    for (let i = 1, iMax = this.events.length; i < iMax; i++) {
+      const evt = this.events[i];
+      if (SweepEvent.compare(leftMostEvt, evt) > 0) leftMostEvt = evt;
+    }
+    let prevSeg = leftMostEvt.segment.prevInResult();
+    let prevPrevSeg = prevSeg ? prevSeg.prevInResult() : null;
+    while (true) {
+      // no segment found, thus no ring can enclose us
+      if (!prevSeg) return null;
+
+      // no segments below prev segment found, thus the ring of the prev
+      // segment must loop back around and enclose us
+      if (!prevPrevSeg) return prevSeg.ringOut;
+
+      // if the two segments are of different rings, the ring of the prev
+      // segment must either loop around us or the ring of the prev prev
+      // seg, which would make us and the ring of the prev peers
+      if (prevPrevSeg.ringOut !== prevSeg.ringOut) {
+        if (prevPrevSeg.ringOut.enclosingRing() !== prevSeg.ringOut) {
+          return prevSeg.ringOut;
+        } else return prevSeg.ringOut.enclosingRing();
+      }
+
+      // two segments are from the same ring, so this was a penisula
+      // of that ring. iterate downward, keep searching
+      prevSeg = prevPrevSeg.prevInResult();
+      prevPrevSeg = prevSeg ? prevSeg.prevInResult() : null;
+    }
+  }
+}
+class PolyOut {
+  constructor(exteriorRing) {
+    this.exteriorRing = exteriorRing;
+    exteriorRing.poly = this;
+    this.interiorRings = [];
+  }
+  addInterior(ring) {
+    this.interiorRings.push(ring);
+    ring.poly = this;
+  }
+  getGeom() {
+    const geom = [this.exteriorRing.getGeom()];
+    // exterior ring was all (within rounding error of angle calc) colinear points
+    if (geom[0] === null) return null;
+    for (let i = 0, iMax = this.interiorRings.length; i < iMax; i++) {
+      const ringGeom = this.interiorRings[i].getGeom();
+      // interior ring was all (within rounding error of angle calc) colinear points
+      if (ringGeom === null) continue;
+      geom.push(ringGeom);
+    }
+    return geom;
+  }
+}
+class MultiPolyOut {
+  constructor(rings) {
+    this.rings = rings;
+    this.polys = this._composePolys(rings);
+  }
+  getGeom() {
+    const geom = [];
+    for (let i = 0, iMax = this.polys.length; i < iMax; i++) {
+      const polyGeom = this.polys[i].getGeom();
+      // exterior ring was all (within rounding error of angle calc) colinear points
+      if (polyGeom === null) continue;
+      geom.push(polyGeom);
+    }
+    return geom;
+  }
+  _composePolys(rings) {
+    const polys = [];
+    for (let i = 0, iMax = rings.length; i < iMax; i++) {
+      const ring = rings[i];
+      if (ring.poly) continue;
+      if (ring.isExteriorRing()) polys.push(new PolyOut(ring));else {
+        const enclosingRing = ring.enclosingRing();
+        if (!enclosingRing.poly) polys.push(new PolyOut(enclosingRing));
+        enclosingRing.poly.addInterior(ring);
+      }
+    }
+    return polys;
+  }
+}
+
+/**
+ * NOTE:  We must be careful not to change any segments while
+ *        they are in the SplayTree. AFAIK, there's no way to tell
+ *        the tree to rebalance itself - thus before splitting
+ *        a segment that's in the tree, we remove it from the tree,
+ *        do the split, then re-insert it. (Even though splitting a
+ *        segment *shouldn't* change its correct position in the
+ *        sweep line tree, the reality is because of rounding errors,
+ *        it sometimes does.)
+ */
+
+class SweepLine {
+  constructor(queue) {
+    let comparator = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : Segment.compare;
+    this.queue = queue;
+    this.tree = new Tree(comparator);
+    this.segments = [];
+  }
+  process(event) {
+    const segment = event.segment;
+    const newEvents = [];
+
+    // if we've already been consumed by another segment,
+    // clean up our body parts and get out
+    if (event.consumedBy) {
+      if (event.isLeft) this.queue.remove(event.otherSE);else this.tree.remove(segment);
+      return newEvents;
+    }
+    const node = event.isLeft ? this.tree.add(segment) : this.tree.find(segment);
+    if (!node) throw new Error(`Unable to find segment #${segment.id} ` + `[${segment.leftSE.point.x}, ${segment.leftSE.point.y}] -> ` + `[${segment.rightSE.point.x}, ${segment.rightSE.point.y}] ` + "in SweepLine tree.");
+    let prevNode = node;
+    let nextNode = node;
+    let prevSeg = undefined;
+    let nextSeg = undefined;
+
+    // skip consumed segments still in tree
+    while (prevSeg === undefined) {
+      prevNode = this.tree.prev(prevNode);
+      if (prevNode === null) prevSeg = null;else if (prevNode.key.consumedBy === undefined) prevSeg = prevNode.key;
+    }
+
+    // skip consumed segments still in tree
+    while (nextSeg === undefined) {
+      nextNode = this.tree.next(nextNode);
+      if (nextNode === null) nextSeg = null;else if (nextNode.key.consumedBy === undefined) nextSeg = nextNode.key;
+    }
+    if (event.isLeft) {
+      // Check for intersections against the previous segment in the sweep line
+      let prevMySplitter = null;
+      if (prevSeg) {
+        const prevInter = prevSeg.getIntersection(segment);
+        if (prevInter !== null) {
+          if (!segment.isAnEndpoint(prevInter)) prevMySplitter = prevInter;
+          if (!prevSeg.isAnEndpoint(prevInter)) {
+            const newEventsFromSplit = this._splitSafely(prevSeg, prevInter);
+            for (let i = 0, iMax = newEventsFromSplit.length; i < iMax; i++) {
+              newEvents.push(newEventsFromSplit[i]);
+            }
+          }
+        }
+      }
+
+      // Check for intersections against the next segment in the sweep line
+      let nextMySplitter = null;
+      if (nextSeg) {
+        const nextInter = nextSeg.getIntersection(segment);
+        if (nextInter !== null) {
+          if (!segment.isAnEndpoint(nextInter)) nextMySplitter = nextInter;
+          if (!nextSeg.isAnEndpoint(nextInter)) {
+            const newEventsFromSplit = this._splitSafely(nextSeg, nextInter);
+            for (let i = 0, iMax = newEventsFromSplit.length; i < iMax; i++) {
+              newEvents.push(newEventsFromSplit[i]);
+            }
+          }
+        }
+      }
+
+      // For simplicity, even if we find more than one intersection we only
+      // spilt on the 'earliest' (sweep-line style) of the intersections.
+      // The other intersection will be handled in a future process().
+      if (prevMySplitter !== null || nextMySplitter !== null) {
+        let mySplitter = null;
+        if (prevMySplitter === null) mySplitter = nextMySplitter;else if (nextMySplitter === null) mySplitter = prevMySplitter;else {
+          const cmpSplitters = SweepEvent.comparePoints(prevMySplitter, nextMySplitter);
+          mySplitter = cmpSplitters <= 0 ? prevMySplitter : nextMySplitter;
+        }
+
+        // Rounding errors can cause changes in ordering,
+        // so remove afected segments and right sweep events before splitting
+        this.queue.remove(segment.rightSE);
+        newEvents.push(segment.rightSE);
+        const newEventsFromSplit = segment.split(mySplitter);
+        for (let i = 0, iMax = newEventsFromSplit.length; i < iMax; i++) {
+          newEvents.push(newEventsFromSplit[i]);
+        }
+      }
+      if (newEvents.length > 0) {
+        // We found some intersections, so re-do the current event to
+        // make sure sweep line ordering is totally consistent for later
+        // use with the segment 'prev' pointers
+        this.tree.remove(segment);
+        newEvents.push(event);
+      } else {
+        // done with left event
+        this.segments.push(segment);
+        segment.prev = prevSeg;
+      }
+    } else {
+      // event.isRight
+
+      // since we're about to be removed from the sweep line, check for
+      // intersections between our previous and next segments
+      if (prevSeg && nextSeg) {
+        const inter = prevSeg.getIntersection(nextSeg);
+        if (inter !== null) {
+          if (!prevSeg.isAnEndpoint(inter)) {
+            const newEventsFromSplit = this._splitSafely(prevSeg, inter);
+            for (let i = 0, iMax = newEventsFromSplit.length; i < iMax; i++) {
+              newEvents.push(newEventsFromSplit[i]);
+            }
+          }
+          if (!nextSeg.isAnEndpoint(inter)) {
+            const newEventsFromSplit = this._splitSafely(nextSeg, inter);
+            for (let i = 0, iMax = newEventsFromSplit.length; i < iMax; i++) {
+              newEvents.push(newEventsFromSplit[i]);
+            }
+          }
+        }
+      }
+      this.tree.remove(segment);
+    }
+    return newEvents;
+  }
+
+  /* Safely split a segment that is currently in the datastructures
+   * IE - a segment other than the one that is currently being processed. */
+  _splitSafely(seg, pt) {
+    // Rounding errors can cause changes in ordering,
+    // so remove afected segments and right sweep events before splitting
+    // removeNode() doesn't work, so have re-find the seg
+    // https://github.com/w8r/splay-tree/pull/5
+    this.tree.remove(seg);
+    const rightSE = seg.rightSE;
+    this.queue.remove(rightSE);
+    const newEvents = seg.split(pt);
+    newEvents.push(rightSE);
+    // splitting can trigger consumption
+    if (seg.consumedBy === undefined) this.tree.add(seg);
+    return newEvents;
+  }
+}
+
+// Limits on iterative processes to prevent infinite loops - usually caused by floating-point math round-off errors.
+const POLYGON_CLIPPING_MAX_QUEUE_SIZE = typeof process !== "undefined" && process.env.POLYGON_CLIPPING_MAX_QUEUE_SIZE || 1000000;
+const POLYGON_CLIPPING_MAX_SWEEPLINE_SEGMENTS = typeof process !== "undefined" && process.env.POLYGON_CLIPPING_MAX_SWEEPLINE_SEGMENTS || 1000000;
+class Operation {
+  run(type, geom, moreGeoms) {
+    operation.type = type;
+    rounder.reset();
+
+    /* Convert inputs to MultiPoly objects */
+    const multipolys = [new MultiPolyIn(geom, true)];
+    for (let i = 0, iMax = moreGeoms.length; i < iMax; i++) {
+      multipolys.push(new MultiPolyIn(moreGeoms[i], false));
+    }
+    operation.numMultiPolys = multipolys.length;
+
+    /* BBox optimization for difference operation
+     * If the bbox of a multipolygon that's part of the clipping doesn't
+     * intersect the bbox of the subject at all, we can just drop that
+     * multiploygon. */
+    if (operation.type === "difference") {
+      // in place removal
+      const subject = multipolys[0];
+      let i = 1;
+      while (i < multipolys.length) {
+        if (getBboxOverlap(multipolys[i].bbox, subject.bbox) !== null) i++;else multipolys.splice(i, 1);
+      }
+    }
+
+    /* BBox optimization for intersection operation
+     * If we can find any pair of multipolygons whose bbox does not overlap,
+     * then the result will be empty. */
+    if (operation.type === "intersection") {
+      // TODO: this is O(n^2) in number of polygons. By sorting the bboxes,
+      //       it could be optimized to O(n * ln(n))
+      for (let i = 0, iMax = multipolys.length; i < iMax; i++) {
+        const mpA = multipolys[i];
+        for (let j = i + 1, jMax = multipolys.length; j < jMax; j++) {
+          if (getBboxOverlap(mpA.bbox, multipolys[j].bbox) === null) return [];
+        }
+      }
+    }
+
+    /* Put segment endpoints in a priority queue */
+    const queue = new Tree(SweepEvent.compare);
+    for (let i = 0, iMax = multipolys.length; i < iMax; i++) {
+      const sweepEvents = multipolys[i].getSweepEvents();
+      for (let j = 0, jMax = sweepEvents.length; j < jMax; j++) {
+        queue.insert(sweepEvents[j]);
+        if (queue.size > POLYGON_CLIPPING_MAX_QUEUE_SIZE) {
+          // prevents an infinite loop, an otherwise common manifestation of bugs
+          throw new Error("Infinite loop when putting segment endpoints in a priority queue " + "(queue size too big).");
+        }
+      }
+    }
+
+    /* Pass the sweep line over those endpoints */
+    const sweepLine = new SweepLine(queue);
+    let prevQueueSize = queue.size;
+    let node = queue.pop();
+    while (node) {
+      const evt = node.key;
+      if (queue.size === prevQueueSize) {
+        // prevents an infinite loop, an otherwise common manifestation of bugs
+        const seg = evt.segment;
+        throw new Error(`Unable to pop() ${evt.isLeft ? "left" : "right"} SweepEvent ` + `[${evt.point.x}, ${evt.point.y}] from segment #${seg.id} ` + `[${seg.leftSE.point.x}, ${seg.leftSE.point.y}] -> ` + `[${seg.rightSE.point.x}, ${seg.rightSE.point.y}] from queue.`);
+      }
+      if (queue.size > POLYGON_CLIPPING_MAX_QUEUE_SIZE) {
+        // prevents an infinite loop, an otherwise common manifestation of bugs
+        throw new Error("Infinite loop when passing sweep line over endpoints " + "(queue size too big).");
+      }
+      if (sweepLine.segments.length > POLYGON_CLIPPING_MAX_SWEEPLINE_SEGMENTS) {
+        // prevents an infinite loop, an otherwise common manifestation of bugs
+        throw new Error("Infinite loop when passing sweep line over endpoints " + "(too many sweep line segments).");
+      }
+      const newEvents = sweepLine.process(evt);
+      for (let i = 0, iMax = newEvents.length; i < iMax; i++) {
+        const evt = newEvents[i];
+        if (evt.consumedBy === undefined) queue.insert(evt);
+      }
+      prevQueueSize = queue.size;
+      node = queue.pop();
+    }
+
+    // free some memory we don't need anymore
+    rounder.reset();
+
+    /* Collect and compile segments we're keeping into a multipolygon */
+    const ringsOut = RingOut.factory(sweepLine.segments);
+    const result = new MultiPolyOut(ringsOut);
+    return result.getGeom();
+  }
+}
+
+// singleton available by import
+const operation = new Operation();
+
+const union = function (geom) {
+  for (var _len = arguments.length, moreGeoms = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+    moreGeoms[_key - 1] = arguments[_key];
+  }
+  return operation.run("union", geom, moreGeoms);
+};
+const intersection = function (geom) {
+  for (var _len2 = arguments.length, moreGeoms = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+    moreGeoms[_key2 - 1] = arguments[_key2];
+  }
+  return operation.run("intersection", geom, moreGeoms);
+};
+const xor = function (geom) {
+  for (var _len3 = arguments.length, moreGeoms = new Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) {
+    moreGeoms[_key3 - 1] = arguments[_key3];
+  }
+  return operation.run("xor", geom, moreGeoms);
+};
+const difference = function (subjectGeom) {
+  for (var _len4 = arguments.length, clippingGeoms = new Array(_len4 > 1 ? _len4 - 1 : 0), _key4 = 1; _key4 < _len4; _key4++) {
+    clippingGeoms[_key4 - 1] = arguments[_key4];
+  }
+  return operation.run("difference", subjectGeom, clippingGeoms);
+};
+var index = {
+  union: union,
+  intersection: intersection,
+  xor: xor,
+  difference: difference
+};
+
 /**
  * 路径图层
  * 专门处理路径元素的渲染
@@ -845,10 +3319,14 @@ class ChannelLayer extends BaseLayer {
     }
     /**
      * 创建排除分区内部的 clipPath 定义
+     * 思路： 由于channel不能画在分区内部，所以我们根据svg大小设定了可画区域是svg的viewBox，对应的矩形大小，然后把分区进行镂空，就可以得到可画区域
+     * 1. 先计算所有分区的边界,如果能拿到边界的svg的大小，就使用这个如果拿不到，就根据分区去计算
+     * 2. 获取需要镂空的路径，其中，如果分区存在相交，需要把两个分区进行合并获取外轮廓路径。
+     * 3. 将svg大小的矩形设置为顺时针，然后将需要镂空的路径设置为逆时针，结合fill-rule为evenodd，就可以得到可画区域
      */
     createExclusionClipPathDefinitions(svgGroup) {
         // 获取所有分区边界数据
-        const subBoundaryBorder = useSubBoundaryBorderStore.getState().subBoundaryBorder;
+        const subBoundaryBorder = usePartitionDataStore.getState().subBoundaryBorder;
         if (!subBoundaryBorder || Object.keys(subBoundaryBorder).length === 0) {
             return {};
         }
@@ -859,7 +3337,7 @@ class ChannelLayer extends BaseLayer {
             defs = document.createElementNS('http://www.w3.org/2000/svg', 'defs');
             svgGroup.appendChild(defs);
         }
-        // �� 修改：计算包含所有分区和通道的边界框
+        // 计算包含所有分区和通道的边界框
         let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
         // 1. 先计算所有分区的边界,如果能拿到边界的svg的大小，就使用这个如果拿不到，就根据分区去计算
         const svg = document.getElementById(SVG_MAP_VIEW_ID);
@@ -883,68 +3361,34 @@ class ChannelLayer extends BaseLayer {
                 }
             }
         }
-        // 2. 再计算所有通道的边界
-        for (const element of this.elements) {
-            // const tunnelConnection = element.originalData?.connection;
-            // if (tunnelConnection && Array.isArray(tunnelConnection)) {
-            //   const clipPathId = `channel-exclude-${
-            //     element.originalData?.id || Math.random().toString(36).substr(2, 9)
-            //   }`;
-            //   // 检查是否已存在该 clipPath
-            //   const existingClipPath = defs.querySelector(`#${clipPathId}`);
-            //   if (existingClipPath) continue;
-            //   // 创建 clipPath
-            //   const clipPath = document.createElementNS('http://www.w3.org/2000/svg', 'clipPath');
-            //   clipPath.setAttribute('id', clipPathId);
-            //   clipPath.setAttribute('clipPathUnits', 'userSpaceOnUse');
-            //   // === 合成一个 path ===
-            //   let d = `M ${minX} ${minY} L ${maxX} ${minY} L ${maxX} ${maxY} L ${minX} ${maxY} Z`;
-            //   for (const partitionId of tunnelConnection) {
-            //     const boundaryData = subBoundaryBorder[partitionId];
-            //     if (boundaryData && boundaryData.coordinates.length >= 3) {
-            //       d += ` M ${boundaryData.coordinates[0][0]} ${boundaryData.coordinates[0][1]}`;
-            //       for (let i = 1; i < boundaryData.coordinates.length; i++) {
-            //         d += ` L ${boundaryData.coordinates[i][0]} ${boundaryData.coordinates[i][1]}`;
-            //       }
-            //       d += ' Z';
-            //     }
-            //   }
-            //   const path = document.createElementNS('http://www.w3.org/2000/svg', 'path');
-            //   path.setAttribute('d', d);
-            //   path.setAttribute('clip-rule', 'evenodd'); // 关键
-            //   clipPath.appendChild(path);
-            //   defs.appendChild(clipPath);
-            //   clipPathIdsMap[element.originalData?.id.toString()] = clipPathId;
-            // } else {
-            const clipPathId = `channel-exclude-all-${element.originalData?.id || Math.random().toString(36).substr(2, 9)}`;
-            // 检查是否已存在该 clipPath
-            const existingClipPath = defs.querySelector(`#${clipPathId}`);
-            if (existingClipPath)
-                continue;
-            // 创建 clipPath
-            const clipPath = document.createElementNS('http://www.w3.org/2000/svg', 'clipPath');
-            clipPath.setAttribute('id', clipPathId);
-            clipPath.setAttribute('clipPathUnits', 'userSpaceOnUse');
-            // === 合成一个 path ===
-            let d = `M ${minX} ${minY} L ${maxX} ${minY} L ${maxX} ${maxY} L ${minX} ${maxY} Z`;
-            for (const partitionId in subBoundaryBorder) {
-                const boundaryData = subBoundaryBorder[partitionId];
-                if (boundaryData && boundaryData.coordinates.length >= 3) {
-                    d += ` M ${boundaryData.coordinates[0][0]} ${boundaryData.coordinates[0][1]}`;
-                    for (let i = 1; i < boundaryData.coordinates.length; i++) {
-                        d += ` L ${boundaryData.coordinates[i][0]} ${boundaryData.coordinates[i][1]}`;
-                    }
-                    d += ' Z';
-                }
+        // 整理出clipPath路径
+        const clipPathId = 'channel-exclude-all';
+        // 创建 clipPath
+        const clipPath = document.createElementNS('http://www.w3.org/2000/svg', 'clipPath');
+        clipPath.setAttribute('id', clipPathId);
+        clipPath.setAttribute('fill-rule', 'evenodd');
+        // === 合成一个 path ===
+        // 外轮廓（顺时针）
+        let d = `M ${minX} ${minY} L ${maxX} ${minY} L ${maxX} ${maxY} L ${minX} ${maxY} Z`;
+        // 获取所有需要挖空的分区路径
+        const partitionPaths = this.mergeOverlappingPartitions(subBoundaryBorder);
+        // 将所有分区路径追加到clipPath中（逆时针，形成挖空）
+        partitionPaths.forEach((partitionCoords) => {
+            if (partitionCoords.length >= 3) {
+                // 判断方向并构建路径
+                const isCounterclockwise = this.isCounterclockwise(partitionCoords);
+                const partitionPath = this.buildPathData(partitionCoords, isCounterclockwise);
+                d += ` ${partitionPath}`;
             }
-            const path = document.createElementNS('http://www.w3.org/2000/svg', 'path');
-            path.setAttribute('d', d);
-            path.setAttribute('clip-rule', 'evenodd'); // 关键
-            clipPath.appendChild(path);
-            defs.appendChild(clipPath);
+        });
+        const path = document.createElementNS('http://www.w3.org/2000/svg', 'path');
+        path.setAttribute('d', d);
+        clipPath.appendChild(path);
+        defs.appendChild(clipPath);
+        // 为所有通道映射clipPath
+        for (const element of this.elements) {
             clipPathIdsMap[element.originalData?.id.toString()] = clipPathId;
         }
-        // }
         return clipPathIdsMap;
     }
     /**
@@ -954,6 +3398,7 @@ class ChannelLayer extends BaseLayer {
         const { coordinates, style } = element;
         if (coordinates.length < 2)
             return;
+        // 这里需要判断点是否在任意一个分区内，如果在的话，就把当前路径绘制成透明的
         // 构建路径数据，使用整数坐标以避免渲染问题
         let pathData = `M ${coordinates[0][0]} ${coordinates[0][1]}`;
         for (let i = 1; i < coordinates.length; i++) {
@@ -996,6 +3441,157 @@ class ChannelLayer extends BaseLayer {
         topPath.classList.add('vector-path-top');
         svgGroup.appendChild(topPath);
     }
+    /**
+     * 判断多边形是否为逆时针方向
+     * 使用叉积法计算多边形的有向面积
+     */
+    isCounterclockwise(coordinates) {
+        if (coordinates.length < 3)
+            return false;
+        let sum = 0;
+        for (let i = 0; i < coordinates.length; i++) {
+            const current = coordinates[i];
+            const next = coordinates[(i + 1) % coordinates.length];
+            // 计算叉积
+            sum += (next[0] - current[0]) * (next[1] + current[1]);
+        }
+        // 如果sum > 0，则为逆时针；如果sum < 0，则为顺时针
+        return sum > 0;
+    }
+    /**
+     * 检查两个多边形是否相交
+     */
+    doPolygonsIntersect(polygon1, polygon2) {
+        try {
+            // 使用polygon-clipping的intersection方法检查是否相交
+            const intersection = index.intersection([polygon1], [polygon2]);
+            return intersection.length > 0;
+        }
+        catch (error) {
+            console.warn('Intersection check failed:', error);
+            return false;
+        }
+    }
+    /**
+     * 根据方向构建路径数据
+     */
+    buildPathData(coordinates, isCounterclockwise) {
+        if (coordinates.length < 3)
+            return '';
+        let pathData = `M ${coordinates[0][0]} ${coordinates[0][1]}`;
+        if (isCounterclockwise) {
+            // 逆时针方向，按原顺序构建
+            for (let i = 1; i < coordinates.length; i++) {
+                pathData += ` L ${coordinates[i][0]} ${coordinates[i][1]}`;
+            }
+        }
+        else {
+            // 顺时针方向，需要反转顺序
+            for (let i = coordinates.length - 1; i > 0; i--) {
+                pathData += ` L ${coordinates[i][0]} ${coordinates[i][1]}`;
+            }
+        }
+        pathData += ' Z';
+        return pathData;
+    }
+    /**
+     * 智能合并重叠的分区，返回所有需要挖空的路径
+     */
+    mergeOverlappingPartitions(subBoundaryBorder) {
+        try {
+            // 将所有分区转换为polygon-clipping格式
+            const polygons = [];
+            const partitionIds = [];
+            Object.entries(subBoundaryBorder).forEach(([partitionId, boundaryData]) => {
+                if (boundaryData?.coordinates && boundaryData.coordinates.length >= 3) {
+                    // 确保坐标格式正确（去掉第三个z坐标）
+                    const coords = boundaryData.coordinates.map((coord) => [coord[0], coord[1]]);
+                    polygons.push(coords);
+                    partitionIds.push(partitionId);
+                }
+            });
+            if (polygons.length === 0)
+                return [];
+            if (polygons.length === 1)
+                return [polygons[0]];
+            // console.info('原始分区数量:', polygons.length);
+            // 检查哪些分区之间有相交
+            const intersectingGroups = [];
+            const processed = new Set();
+            // console.info('polygons===', polygons);
+            for (let i = 0; i < polygons.length; i++) {
+                if (processed.has(i))
+                    continue;
+                const currentGroup = [i];
+                processed.add(i);
+                // 查找与当前分区相交的所有分区
+                for (let j = i + 1; j < polygons.length; j++) {
+                    if (processed.has(j))
+                        continue;
+                    if (this.doPolygonsIntersect(polygons[i], polygons[j])) {
+                        currentGroup.push(j);
+                        processed.add(j);
+                        // console.info(`分区 ${partitionIds[i]} 与分区 ${partitionIds[j]} 相交`);
+                    }
+                }
+                if (currentGroup.length > 1) {
+                    // 有相交的分区，进行合并
+                    intersectingGroups.push(currentGroup);
+                }
+            }
+            // console.info('相交分组:', intersectingGroups);
+            // 存储最终需要挖空的所有路径
+            const finalPaths = [];
+            // 1. 合并相交的分区组
+            intersectingGroups.forEach((group) => {
+                if (group.length > 1) {
+                    const groupPolygons = group.map((index) => polygons[index]);
+                    // console.info('groupPolygons===', groupPolygons);
+                    try {
+                        // 将坐标包装成polygon-clipping期望的格式
+                        const wrappedPolygons = groupPolygons.map((poly) => [poly]); // 包装成Polygon格式
+                        // 使用reduce方法逐个合并
+                        let merged = wrappedPolygons[0];
+                        for (let i = 1; i < wrappedPolygons.length; i++) {
+                            merged = index.union(merged, wrappedPolygons[i]);
+                        }
+                        if (merged.length > 0) {
+                            // 转换坐标格式
+                            const firstPolygon = merged[0];
+                            if (firstPolygon && firstPolygon.length > 0) {
+                                const coords = firstPolygon[0].map((point) => [point[0], point[1]]);
+                                finalPaths.push(coords);
+                            }
+                        }
+                    }
+                    catch (error) {
+                        console.warn('合并相交分区失败:', error);
+                        // 如果合并失败，添加原始分区
+                        group.forEach((index) => finalPaths.push(polygons[index]));
+                    }
+                }
+            });
+            // 2. 添加没有相交的分区
+            // console.info('polygons===', polygons);
+            const newIntersectingGroups = intersectingGroups.flat();
+            // console.info('newIntersectingGroups===', newIntersectingGroups);
+            for (let i = 0; i < polygons.length; i++) {
+                if (!newIntersectingGroups.includes(i)) {
+                    finalPaths.push(polygons[i]);
+                }
+            }
+            // console.info('finalPaths===', finalPaths);
+            // console.info('最终挖空路径数量:', finalPaths.length);
+            return finalPaths;
+        }
+        catch (error) {
+            console.error('polygon-clipping union failed:', error);
+            // 如果合并失败，返回原始分区
+            return Object.values(subBoundaryBorder)
+                .filter((boundaryData) => boundaryData?.coordinates && boundaryData.coordinates.length >= 3)
+                .map((boundaryData) => boundaryData.coordinates.map((coord) => [coord[0], coord[1]]));
+        }
+    }
 }
 
 /**
@@ -1012,26 +3608,29 @@ class PathLayer extends BaseLayer {
         this.type = LAYER_DEFAULT_TYPE.PATH;
     }
     /**
-     * 创建所有分区并集的 clipPath
+     * 为每个分区创建独立的 clipPath
      */
-    createUnionClipPath(svgGroup) {
-        const { subBoundaryBorder, obstacles, svgElements } = useSubBoundaryBorderStore.getState();
+    createPartitionClipPaths(svgGroup) {
+        const { subBoundaryBorder, obstacles, svgElements } = usePartitionDataStore.getState();
         // 确保 defs 元素存在
         let defs = svgGroup.querySelector('defs');
         if (!defs) {
             defs = document.createElementNS('http://www.w3.org/2000/svg', 'defs');
             svgGroup.appendChild(defs);
         }
-        const clipPathId = 'clip-union-partitions';
-        // 如果已存在，先移除
-        const existing = defs.querySelector(`#${clipPathId}`);
-        if (existing)
-            defs.removeChild(existing);
-        // 合成所有分区的 path
-        let d = '';
-        // 1. 外圈（主边界，顺时针）
-        Object.values(subBoundaryBorder).forEach((item) => {
-            const bCoords = item.coordinates;
+        const clipPathIds = {};
+        // 为每个分区创建独立的 clipPath
+        Object.keys(subBoundaryBorder).forEach((partitionId) => {
+            const partitionData = subBoundaryBorder[partitionId];
+            const clipPathId = `clip-partition-${partitionId}`;
+            // 如果已存在，先移除
+            const existing = defs.querySelector(`#${clipPathId}`);
+            if (existing)
+                defs.removeChild(existing);
+            // 合成该分区的 path
+            let d = '';
+            // 1. 该分区的外圈边界（顺时针）
+            const bCoords = partitionData.coordinates;
             if (bCoords.length >= 3) {
                 d += `M ${bCoords[0][0]} ${bCoords[0][1]}`;
                 for (let i = 1; i < bCoords.length; i++) {
@@ -1039,35 +3638,59 @@ class PathLayer extends BaseLayer {
                 }
                 d += ' Z ';
             }
-        });
-        // 2. 内圈（禁区，逆时针）
-        Object.values(obstacles).forEach((item) => {
-            const bCoords = item.coordinates;
-            if (bCoords.length >= 3) {
-                d += `M ${bCoords[bCoords.length - 1][0]} ${bCoords[bCoords.length - 1][1]}`;
-                for (let i = bCoords.length - 2; i >= 0; i--) {
-                    d += ` L ${bCoords[i][0]} ${bCoords[i][1]}`;
+            // 2. 所有禁区（逆时针）- 禁区影响所有分区
+            Object.values(obstacles).forEach((item) => {
+                const obstacleCoords = item.coordinates;
+                if (obstacleCoords.length >= 3) {
+                    d += `M ${obstacleCoords[obstacleCoords.length - 1][0]} ${obstacleCoords[obstacleCoords.length - 1][1]}`;
+                    for (let i = obstacleCoords.length - 2; i >= 0; i--) {
+                        d += ` L ${obstacleCoords[i][0]} ${obstacleCoords[i][1]}`;
+                    }
+                    d += ' Z ';
                 }
-                d += ' Z ';
-            }
-        });
-        // 3. svgElements（直接拼接path字符串，建议逆时针）
-        if (Array.isArray(svgElements)) {
-            svgElements.forEach((svgPath) => {
+            });
+            // 3. 所有 svgElements（逆时针）- SVG元素影响所有分区
+            Object.values(svgElements).forEach((svgPath) => {
                 const svgPathString = svgPath?.metadata?.svg;
                 if (svgPathString && typeof svgPathString === 'string' && svgPathString.trim()) {
-                    d += svgPathString + ' ';
+                    // 处理转义字符
+                    const processedSvgString = svgPathString.replace(/\\n/g, '\n').replace(/\\"/g, '"');
+                    // 解析 SVG 字符串
+                    const parser = new DOMParser();
+                    const svgDoc = parser.parseFromString(processedSvgString, 'image/svg+xml');
+                    const svgElement = svgDoc.documentElement;
+                    if (svgElement.tagName === 'svg') {
+                        // 查找 path 元素
+                        const pathElement = svgElement.querySelector('path');
+                        if (pathElement) {
+                            const pathData = pathElement.getAttribute('d');
+                            if (pathData) {
+                                // 获取 SVG 元素的变换参数
+                                const centerCoords = svgPath.coordinates?.[0] || [0, 0];
+                                const center = [centerCoords[0], centerCoords[1]];
+                                const userScale = svgPath.metadata.scale || 1;
+                                const direction = svgPath.metadata?.direction || 0;
+                                const originalWidth = parseFloat(svgElement.getAttribute('width') || '76');
+                                const originalHeight = parseFloat(svgElement.getAttribute('height') || '68');
+                                // 应用变换到路径数据
+                                const transformedPathData = this.transformSvgPath(pathData, center, userScale, direction, originalWidth, originalHeight);
+                                d += transformedPathData + ' ';
+                            }
+                        }
+                    }
                 }
             });
-        }
-        const path = document.createElementNS('http://www.w3.org/2000/svg', 'path');
-        path.setAttribute('d', d);
-        const clipPath = document.createElementNS('http://www.w3.org/2000/svg', 'clipPath');
-        clipPath.setAttribute('id', clipPathId);
-        clipPath.setAttribute('clipPathUnits', 'userSpaceOnUse');
-        clipPath.appendChild(path);
-        defs.appendChild(clipPath);
-        return clipPathId;
+            const path = document.createElementNS('http://www.w3.org/2000/svg', 'path');
+            path.setAttribute('d', d);
+            const clipPath = document.createElementNS('http://www.w3.org/2000/svg', 'clipPath');
+            clipPath.setAttribute('id', clipPathId);
+            // clipPath.setAttribute('clipPathUnits', 'userSpaceOnUse');
+            clipPath.setAttribute('clip-rule', 'evenodd');
+            clipPath.appendChild(path);
+            defs.appendChild(clipPath);
+            clipPathIds[partitionId] = clipPathId;
+        });
+        return clipPathIds;
     }
     /**
      * SVG渲染方法
@@ -1079,52 +3702,158 @@ class PathLayer extends BaseLayer {
         this.scale = scale || 1;
         this.lineScale = lineScale || 1;
         svgGroup.style.isolation = 'isolate';
-        // 1. 创建分区并集 clipPath
-        const clipPathId = this.createUnionClipPath(svgGroup);
-        // 2. 创建一个组，应用 clipPath
-        const group = document.createElementNS('http://www.w3.org/2000/svg', 'g');
-        group.setAttribute('clip-path', `url(#${clipPathId})`);
-        group.setAttribute('opacity', '0.6'); // 统一透明度，防止叠加脏乱
-        // 3. 渲染所有路径
+        // 1. 为每个分区创建独立的 clipPath
+        const clipPathIds = this.createPartitionClipPaths(svgGroup);
+        // 2. 按分区渲染路径
+        this.renderPathsByPartition(svgGroup, clipPathIds);
+    }
+    /**
+     * 按分区渲染路径
+     */
+    renderPathsByPartition(svgGroup, clipPathIds) {
+        // 按分区+类型+样式分组路径数据
+        const partitionTypeGroups = new Map();
+        // 收集所有路径数据并按分区+类型+样式分组
         for (const element of this.elements) {
-            const { id, elements } = element;
+            const pathElement = element;
+            const { id, elements } = pathElement;
             this.boundaryPaths[id] = [];
+            elements.forEach((pathElement) => {
+                const { coordinates, style, type } = pathElement;
+                if (type === 'trans' || style.lineColor === 'transparent') {
+                    return;
+                }
+                if (coordinates.length < 2)
+                    return;
+                // 构建路径数据
+                let pathData = `M ${coordinates[0][0]} ${coordinates[0][1]}`;
+                for (let i = 1; i < coordinates.length; i++) {
+                    pathData += ` L ${coordinates[i][0]} ${coordinates[i][1]}`;
+                }
+                // 根据路径类型设置不同的颜色
+                let lineColor;
+                if (type === 'trans') {
+                    lineColor = style.transLineColor || 'transparent';
+                }
+                else if (type === 'mowing') {
+                    lineColor = style.mowingLineColor || style.lineColor || '#000000';
+                }
+                else if (type === 'edge') {
+                    lineColor = style.edgeLineColor || style.lineColor || '#000000';
+                }
+                else {
+                    lineColor = style.lineColor || '#000000';
+                }
+                // 按分区+类型+样式分组存储
+                const groupKey = `${id}-${lineColor}-${style.lineWidth || 1}`;
+                if (!partitionTypeGroups.has(groupKey)) {
+                    partitionTypeGroups.set(groupKey, {
+                        pathData: [],
+                        elements: [],
+                        style: { ...style, lineColor },
+                        type,
+                    });
+                }
+                partitionTypeGroups.get(groupKey).pathData.push(pathData);
+                partitionTypeGroups.get(groupKey).elements.push(pathElement);
+            });
+        }
+        // 为每个分区创建独立的组并应用对应的 clipPath
+        const partitionGroups = new Map();
+        partitionTypeGroups.forEach((groupData, groupKey) => {
+            const { pathData, elements, style } = groupData;
+            if (pathData.length === 0)
+                return;
+            // 从groupKey中提取分区ID
+            const partitionId = groupKey.split('-')[0];
+            // 获取该分区的 clipPath ID
+            const clipPathId = clipPathIds[partitionId];
+            if (!clipPathId)
+                return;
+            // 获取或创建该分区的组
+            let group = partitionGroups.get(partitionId);
+            if (!group) {
+                group = document.createElementNS('http://www.w3.org/2000/svg', 'g');
+                group.setAttribute('clip-path', `url(#${clipPathId})`);
+                group.setAttribute('opacity', '0.5');
+                partitionGroups.set(partitionId, group);
+                svgGroup.appendChild(group);
+            }
+            // 创建该类型的 path 元素
+            const path = document.createElementNS('http://www.w3.org/2000/svg', 'path');
+            const mergedPathData = pathData.join(' ');
+            path.setAttribute('d', mergedPathData);
+            // 设置样式属性
+            path.setAttribute('fill', 'none');
+            path.setAttribute('stroke', style.lineColor);
+            path.setAttribute('mix-blend-mode', 'normal');
+            const lineWidth = Math.max(style.lineWidth || 1, 0.5);
+            path.setAttribute('stroke-width', lineWidth.toString());
+            path.setAttribute('stroke-linecap', 'round');
+            path.setAttribute('stroke-linejoin', 'round');
+            path.classList.add('vector-path');
+            // 将 path 添加到组中
+            group.appendChild(path);
+            // 保存引用到 boundaryPaths 中
             elements.forEach((element) => {
-                this.renderPathToGroup(group, id, element);
+                const { id } = element;
+                if (!this.boundaryPaths[id]) {
+                    this.boundaryPaths[id] = [];
+                }
+                this.boundaryPaths[id].push(path);
             });
-        }
-        svgGroup.appendChild(group);
+        });
     }
     /**
-     * 渲染单个路径到指定的组中
-     */
-    renderPathToGroup(group, id, element) {
-        const { coordinates, style } = element;
-        if (coordinates.length < 2)
-            return;
-        const path = document.createElementNS('http://www.w3.org/2000/svg', 'path');
-        // 构建路径数据
-        let pathData = `M ${coordinates[0][0]} ${coordinates[0][1]}`;
-        for (let i = 1; i < coordinates.length; i++) {
-            pathData += ` L ${coordinates[i][0]} ${coordinates[i][1]}`;
+     * 变换 SVG 路径数据
+     */
+    transformSvgPath(pathData, center, scale, direction, originalWidth, originalHeight) {
+        // 解析路径数据并应用变换
+        const commands = pathData.match(/[MmLlHhVvCcSsQqTtAaZz][^MmLlHhVvCcSsQqTtAaZz]*/g) || [];
+        let transformedCommands = [];
+        for (const command of commands) {
+            const type = command[0];
+            const params = command
+                .slice(1)
+                .trim()
+                .split(/[\s,]+/)
+                .filter(Boolean)
+                .map(Number);
+            if (type === 'Z' || type === 'z') {
+                // 闭合路径，不需要变换
+                transformedCommands.push(command);
+                continue;
+            }
+            // 处理坐标参数
+            let transformedParams = [];
+            for (let i = 0; i < params.length; i += 2) {
+                if (i + 1 < params.length) {
+                    let x = params[i];
+                    let y = params[i + 1];
+                    // 应用变换：先平移到中心，然后缩放、旋转，最后平移到目标位置
+                    // 1. 平移到原点（相对于原始尺寸的中心）
+                    x -= originalWidth / 2;
+                    y -= originalHeight / 2;
+                    // 2. 应用缩放
+                    x *= scale;
+                    y *= scale;
+                    // 3. 应用旋转
+                    const cos = Math.cos(-direction);
+                    const sin = Math.sin(-direction);
+                    const newX = x * cos - y * sin;
+                    const newY = x * sin + y * cos;
+                    // 4. 平移到目标位置
+                    x = newX + center[0];
+                    y = newY + center[1];
+                    transformedParams.push(x, y);
+                }
+            }
+            // 重建命令
+            if (transformedParams.length > 0) {
+                transformedCommands.push(type + transformedParams.join(' '));
+            }
         }
-        path.style.mixBlendMode = 'normal';
-        // 设置路径属性
-        path.setAttribute('d', pathData);
-        // 直接给fill的颜色设置透明度会导致path重叠的部分颜色叠加，所以使用fill填充实色，通过fill-opacity设置透明度
-        path.setAttribute('fill', 'none');
-        // path.setAttribute('fill-opacity', '0.4');
-        path.setAttribute('stroke', style.lineColor || '#000000');
-        path.setAttribute('mix-blend-mode', 'normal');
-        const lineWidth = Math.max(style.lineWidth || 1, 0.5);
-        path.setAttribute('stroke-width', lineWidth.toString());
-        path.setAttribute('stroke-linecap', 'round');
-        path.setAttribute('stroke-linejoin', 'round');
-        // 注意：这里不设置 opacity，因为透明度由父组控制
-        // path.setAttribute('vector-effect', 'non-scaling-stroke');
-        path.classList.add('vector-path');
-        this.boundaryPaths[id].push(path);
-        group.appendChild(path);
+        return transformedCommands.join(' ');
     }
 }
 
@@ -1548,15 +4277,18 @@ const DOODLE_STYLES = {
     lineColor: '#ff5722',
     fillColor: '#ff9800', // 粉色半透明填充
     lineWidth: DEFAULT_LINE_WIDTHS.TIME_LIMIT_OBSTACLE,
-    opacity: DEFAULT_OPACITIES.HIGH,
+    opacity: DEFAULT_OPACITIES.DOODLE,
 };
 const PATH_EDGE_STYLES = {
     lineWidth: DEFAULT_LINE_WIDTHS.PATH,
     opacity: DEFAULT_OPACITIES.MEDIUM,
-    edgeLineColor: 'rgba(231, 238, 246)',
     transLineColor: 'transparent',
+    edgeLineColor: 'rgba(231, 238, 246)',
     mowedLineColor: 'rgba(231, 238, 246)',
     mowingLineColor: 'rgba(123, 200, 187)',
+    //  edgeLineColor: 'red',
+    //  mowedLineColor: 'red',
+    // mowingLineColor: 'red',
 };
 const CHANNEL_STYLES = {
     lineColor: 'purple',
@@ -1590,13 +4322,13 @@ const DEFAULT_STYLES = {
 function convertPointsFormat(points) {
     if (!points || points.length === 0)
         return null;
-    return points.map(point => {
+    return points.map((point) => {
         if (point.length >= 2) {
             // 对前两个元素应用缩放因子，保留其他元素
             return [
                 point[0] * SCALE_FACTOR,
                 -point[1] * SCALE_FACTOR, // Y轴翻转，与Python代码一致
-                ...point.slice(2) // 保留第三个及以后的元素
+                ...point.slice(2), // 保留第三个及以后的元素
             ];
         }
         return point;
@@ -1611,7 +4343,7 @@ function convertPositionFormat(position) {
         return null;
     return {
         x: position[0] * SCALE_FACTOR,
-        y: -position[1] * SCALE_FACTOR // Y轴翻转
+        y: -position[1] * SCALE_FACTOR, // Y轴翻转
     };
 }
 /**
@@ -1620,9 +4352,146 @@ function convertPositionFormat(position) {
 function convertCoordinate(x, y) {
     return {
         x: x * SCALE_FACTOR,
-        y: -y * SCALE_FACTOR // Y轴翻转
+        y: -y * SCALE_FACTOR, // Y轴翻转
     };
 }
+/**
+ * @param x                 x坐标
+ * @param y                 y坐标
+ * @param isAllowInBoundary 是否允许点在边界上的判断
+ * @return ture-点在边界上即可视为在边界内，false-严格判断点在边界内
+ */
+function isPointIn(x, y, pointList, isAllowInBoundary) {
+    let count = 0;
+    let size = pointList.length;
+    let p1, p2, p3;
+    for (let i = 0; i < size; i++) {
+        p1 = pointList[i];
+        p2 = pointList[(i + 1) % size];
+        if (p1.y == null || p2.y == null || p1.x == null || p2.x == null) {
+            continue;
+        }
+        if (p1.y === p2.y) {
+            continue;
+        }
+        if (y > Math.min(p1.y, p2.y) && y < Math.max(p1.y, p2.y)) {
+            const interX = ((y - p1.y) * (p2.x - p1.x)) / (p2.y - p1.y) + p1.x;
+            if (interX >= x) {
+                count++;
+            }
+            else if (interX == x) {
+                return isAllowInBoundary;
+            }
+        }
+        else {
+            if (y == p2.y && x <= p2.x) {
+                p3 = pointList[(i + 2) % size];
+                if (y >= Math.min(p1.y, p3.y) && y <= Math.max(p1.y, p3.y)) {
+                    // 若当前点的y坐标位于 p1和p3组成的线段关于y轴的投影中，则记为该点的射线只穿过端点一次。
+                    ++count;
+                }
+                else {
+                    // 若当前点的y坐标不能包含在p1和p3组成的线段关于y轴的投影中，则点射线通过的两条线段组成了一个弯折的部分，
+                    // 此时我们记射线穿过该端点两次
+                    count += 2;
+                }
+            }
+        }
+    }
+    return count % 2 == 1;
+}
+/**
+ * 用于判断三个点的方向的辅助方法
+ */
+function orientation(p, q, r) {
+    const val = (q.y - p.y) * (r.x - q.x) - (q.x - p.x) * (r.y - q.y);
+    if (val == 0)
+        return 0; // colinear
+    return val > 0 ? 1 : 2; // clock or counterclock wise
+}
+/**
+ * 检查点q是否在线段pr上的辅助方法
+ */
+function onSegment(p, q, r) {
+    if (q.x <= Math.max(p.x, r.x) &&
+        q.x >= Math.min(p.x, r.x) &&
+        q.y <= Math.max(p.y, r.y) &&
+        q.y >= Math.min(p.y, r.y)) {
+        return true;
+    }
+    return false;
+}
+/**
+ * 判断两条线段是否相交的方法
+ */
+function doTwoLinesIntersect(p1, q1, p2, q2) {
+    //处理p1和q1两个点相同的情况
+    if (p1.x - q1.x == 0 && p1.y - q1.y == 0) {
+        return false;
+    }
+    if (p2.x - q2.x == 0 && p2.y - q2.y == 0) {
+        return false;
+    }
+    // 计算四个点的方向
+    const o1 = orientation(p1, q1, p2);
+    const o2 = orientation(p1, q1, q2);
+    const o3 = orientation(p2, q2, p1);
+    const o4 = orientation(p2, q2, q1);
+    // 一般情况，如果四个方向两两不同，则线段相交
+    if (o1 != o2 && o3 != o4) {
+        return true;
+    }
+    // 特殊情况，当线段的端点在另一条线段上时
+    if (o1 == 0 && onSegment(p1, q1, p2))
+        return true;
+    if (o2 == 0 && onSegment(p1, q1, q2))
+        return true;
+    if (o3 == 0 && onSegment(p2, q2, p1))
+        return true;
+    if (o4 == 0 && onSegment(p2, q2, q1))
+        return true;
+    // 如果以上情况都不满足，则线段不相交
+    return false;
+}
+/**
+ * 判断多点折线是否相交
+ */
+function doIntersect(points1, points2) {
+    if (points1 == null || points2 == null || points1.length < 3 || points2.length < 3) {
+        return false;
+    }
+    for (let i = 0; i < points1.length - 1; i++) {
+        for (let j = 0; j < points2.length - 1; j++) {
+            if (doTwoLinesIntersect(points1[i], points1[i + 1], points2[j], points2[j + 1])) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+/**
+ * 两个图形是否完全分离，互相不包含
+ */
+function isOutsideToEachOther(points1, points2) {
+    // 相交关系
+    if (doIntersect(points1, points2)) {
+        return false;
+    }
+    // 点关系，判断每个图形的点都在另一个图形外部
+    for (let point of points1) {
+        if (isPointIn(point.x, point.y, points2, true)) {
+            //                Log.i("ycf", "isOutsideToEachOther: mapPoint1=" + mapPoint);
+            return false;
+        }
+    }
+    for (let point of points2) {
+        if (isPointIn(point.x, point.y, points1, true)) {
+            //                Log.i("ycf", "isOutsideToEachOther: mapPoint2=" + mapPoint);
+            return false;
+        }
+    }
+    return true;
+}
 
 /**
  * 按Python逻辑创建路径段：根据连续的两点之间的关系确定线段类型
@@ -1631,7 +4500,7 @@ function createPathSegmentsByType(list) {
     const segments = {
         edge: [],
         mowing: [],
-        trans: []
+        trans: [],
     };
     if (list.length < 2)
         return segments;
@@ -1641,12 +4510,16 @@ function createPathSegmentsByType(list) {
     for (const currentPoint of list) {
         const currentCoord = {
             x: currentPoint.postureX,
-            y: currentPoint.postureY
+            y: currentPoint.postureY,
         };
         if (lastPoint !== null) {
             // 判断上一个点和当前点是否需要绘制 (iso端逻辑)
-            const lastShouldDraw = lastPoint.pathType === '00' || lastPoint.pathType === '01' || lastPoint.knifeRotation === '01';
-            const currentShouldDraw = currentPoint.pathType === '00' || currentPoint.pathType === '01' || currentPoint.knifeRotation === '01';
+            const lastShouldDraw = lastPoint.pathType === '00' ||
+                lastPoint.pathType === '01' ||
+                lastPoint.knifeRotation === '01';
+            const currentShouldDraw = currentPoint.pathType === '00' ||
+                currentPoint.pathType === '01' ||
+                currentPoint.knifeRotation === '01';
             let segmentType;
             if (lastShouldDraw && currentShouldDraw) {
                 // 需要绘制的两点之间用实线连接
@@ -1665,9 +4538,9 @@ function createPathSegmentsByType(list) {
                 currentSegment = [
                     {
                         x: lastPoint.postureX,
-                        y: lastPoint.postureY
+                        y: lastPoint.postureY,
                     },
-                    currentCoord
+                    currentCoord,
                 ];
                 currentSegmentType = segmentType;
             }
@@ -1885,6 +4758,136 @@ function calculateMapGpsCenter(mapData) {
     };
 }
 
+/**
+ * 并查集（Union-Find）是一种非常高效的数据结构，用于处理动态连通性问题。
+ * 它可以快速判断网络中任意两点是否连通，并能将不连通的集合合并。
+ */
+class UnionFind {
+    /**
+     * 构造函数，n为图的节点总数
+     * @param {number} n - 节点总数
+     */
+    constructor(n) {
+        this.count = n; // 连通分量的数量
+        this.parent = new Array(n); // parent[i]表示第i个元素所指向的父节点
+        // 初始时，每个节点的父节点是自己
+        for (let i = 0; i < n; i++) {
+            this.parent[i] = i;
+        }
+    }
+    /**
+     * 查找元素p所对应的集合编号（根节点）
+     * @param {number} p - 要查找的元素
+     * @returns {number} 根节点的编号
+     */
+    find(p) {
+        while (p !== this.parent[p]) {
+            this.parent[p] = this.parent[this.parent[p]]; // 路径压缩
+            p = this.parent[p];
+        }
+        return p;
+    }
+    /**
+     * 判断元素p和元素q是否属于同一集合
+     * @param {number} p - 第一个元素
+     * @param {number} q - 第二个元素
+     * @returns {boolean} 是否连通
+     */
+    isConnected(p, q) {
+        return this.find(p) === this.find(q);
+    }
+    /**
+     * 合并元素p和元素q所属的集合
+     * @param {number} p - 第一个元素
+     * @param {number} q - 第二个元素
+     */
+    union(p, q) {
+        const rootP = this.find(p);
+        const rootQ = this.find(q);
+        if (rootP === rootQ) {
+            return; // 已经在同一个集合中
+        }
+        // 将较小的根节点作为父节点（按秩合并的简化版本）
+        if (rootP < rootQ) {
+            this.parent[rootQ] = rootP;
+        }
+        else {
+            this.parent[rootP] = rootQ;
+        }
+        // 两个集合合并成一个集合，连通分量减1
+        this.count--;
+    }
+    /**
+     * 获取当前的连通分量个数
+     * @returns {number} 连通分量数量
+     */
+    getCount() {
+        return this.count;
+    }
+    /**
+     * 获取联通的组
+     * @param {Array} list - 原始元素列表
+     * @returns {Array<Set>} 联通组列表
+     */
+    getConnectedGroup(list) {
+        if (!list || list.length === 0 || !this.parent || this.parent.length === 0) {
+            return null;
+        }
+        if (list.length !== this.parent.length) {
+            return null;
+        }
+        const map = new Map();
+        // 遍历所有元素，按根节点分组
+        for (let i = 0; i < this.parent.length; i++) {
+            const root = this.parent[i];
+            if (!map.has(root)) {
+                map.set(root, new Set());
+            }
+            map.get(root).add(list[i]);
+        }
+        return Array.from(map.values());
+    }
+    /**
+     * 重置并查集
+     * @param {number} n - 新的节点总数
+     */
+    reset(n) {
+        this.count = n;
+        this.parent = new Array(n);
+        for (let i = 0; i < n; i++) {
+            this.parent[i] = i;
+        }
+    }
+}
+
+function isTunnelConnected(a, b, connectIds) {
+    if (!a || !b)
+        return false;
+    if (!connectIds || connectIds?.length === 0)
+        return false;
+    const temp = [a?.id, b?.id];
+    temp.sort();
+    return connectIds?.includes(temp?.join('-'));
+}
+function isOverlayConnected(a, b) {
+    if (!a || !b) {
+        return false;
+    }
+    if (!a?.points?.length || !b?.points?.length) {
+        return false;
+    }
+    const aPoints = a?.points?.map(item => ({ x: item[0], y: item[1] }));
+    const bPoints = b?.points?.map(item => ({ x: item[0], y: item[1] }));
+    try {
+        if (isOutsideToEachOther(aPoints, bPoints)) {
+            return false;
+        }
+    }
+    catch (error) {
+        console.log('error->', error);
+    }
+    return true;
+}
 /**
  * 通过 mapData 和 pathData 生成所有 boundary 的数据
  * @param mapData 地图数据
@@ -1893,11 +4896,12 @@ function calculateMapGpsCenter(mapData) {
  */
 function generateBoundaryData(mapData, pathData) {
     const boundaryData = [];
+    let chargingPileBoundary = undefined;
     if (!mapData || !mapData.sub_maps) {
         return boundaryData;
     }
     // 第一步：收集所有TUNNEL数据的connection信息
-    const connectedBoundaryIds = new Set();
+    const connectIds = [];
     // 遍历mapData中的tunnels字段
     if (mapData.tunnels && Array.isArray(mapData.tunnels)) {
         for (const tunnel of mapData.tunnels) {
@@ -1905,10 +4909,8 @@ function generateBoundaryData(mapData, pathData) {
             if (connection) {
                 // connection可能是单个数字或数组
                 if (Array.isArray(connection)) {
-                    connection.forEach(id => connectedBoundaryIds.add(id));
-                }
-                else if (typeof connection === 'number') {
-                    connectedBoundaryIds.add(connection);
+                    connection.sort();
+                    connectIds.push(connection.join('-'));
                 }
             }
         }
@@ -1919,9 +4921,9 @@ function generateBoundaryData(mapData, pathData) {
         if (!subMap.elements)
             continue;
         // 每个sub_map的elements是边界坐标，没有sub_map只有一个boundary数据
-        const boundaryElement = subMap.elements.find(element => element.type === 'BOUNDARY');
+        const boundaryElement = subMap.elements.find((element) => element.type === 'BOUNDARY');
         //  如果当前subMap存在充电桩且充电桩存在tunnel，说明当前subMap中的boundary是初始boundary，这个boundary不为孤立区域
-        const hasTunnelToChargingPile = subMap.elements.some(element => element.type === 'CHARGING_PILE' && element.tunnel);
+        const hasTunnelToChargingPile = subMap.elements.some((element) => element.type === 'CHARGING_PILE' && element.tunnel);
         // 创建基础的 boundary 数据（来自 mapData）
         const boundary = {
             // 从 BOUNDARY 元素复制属性
@@ -1930,8 +4932,6 @@ function generateBoundaryData(mapData, pathData) {
             area: subMap?.area,
             points: convertPointsFormat(boundaryElement?.points) || [],
             type: boundaryElement.type,
-            // 判断是否为孤立子区域
-            isIsolated: hasTunnelToChargingPile ? false : !connectedBoundaryIds.has(boundaryElement.id)
         };
         // 如果有 pathData，尝试匹配对应的分区数据
         if (pathData) {
@@ -1947,8 +4947,33 @@ function generateBoundaryData(mapData, pathData) {
                 boundary.endTime = partitionData.endTime;
             }
         }
+        if (hasTunnelToChargingPile) {
+            chargingPileBoundary = boundary;
+        }
         boundaryData.push(boundary);
     }
+    const unionFind = new UnionFind(boundaryData?.length);
+    for (let i = 0; i < boundaryData?.length - 1; i++) {
+        for (let j = i + 1; j < boundaryData?.length; j++) {
+            const boundary1 = boundaryData[i];
+            const boundary2 = boundaryData[j];
+            const isChannelConnect = isTunnelConnected(boundary1, boundary2, connectIds);
+            const isOverlayConnect = isOverlayConnected(boundary1, boundary2);
+            if (isChannelConnect || isOverlayConnect) {
+                unionFind.union(i, j);
+            }
+        }
+    }
+    const tunnelAndOverlayList = unionFind.getConnectedGroup(boundaryData);
+    const chargingPileConnectBoundarys = tunnelAndOverlayList?.find(item => item?.has(chargingPileBoundary));
+    for (let boundary of boundaryData) {
+        if (chargingPileConnectBoundarys?.has(boundary)) {
+            boundary.isIsolated = false;
+        }
+        else {
+            boundary.isIsolated = true;
+        }
+    }
     return boundaryData;
 }
 
@@ -1960,100 +4985,9 @@ var RealTimeDataType;
     RealTimeDataType[RealTimeDataType["STATUS"] = 4] = "STATUS";
 })(RealTimeDataType || (RealTimeDataType = {}));
 
-/**
- * 射线法判断点是否在多边形内部
- * @param x 点的x坐标
- * @param y 点的y坐标
- * @param pointList 多边形顶点列表，格式：[[x1, y1], [x2, y2], ...]
- * @param isAllowInBoundary 是否允许点在边界上的判断
- * @returns true-点在多边形内部，false-点在多边形外部
- */
-function isPointIn(x, y, pointList, isAllowInBoundary = false) {
-    let count = 0;
-    const size = pointList.length;
-    for (let i = 0; i < size; i++) {
-        const p1 = pointList[i];
-        const p2 = pointList[(i + 1) % size];
-        // 检查点坐标是否有效
-        if (p1[1] === null || p2[1] === null || p1[0] === null || p2[0] === null) {
-            continue;
-        }
-        // 跳过水平线段
-        if (p1[1] === p2[1]) {
-            continue;
-        }
-        // 检查射线是否与当前边相交
-        if (y > Math.min(p1[1], p2[1]) && y < Math.max(p1[1], p2[1])) {
-            // 计算射线与边的交点x坐标
-            const interX = ((y - p1[1]) * (p2[0] - p1[0])) / (p2[1] - p1[1]) + p1[0];
-            if (interX >= x) {
-                count++;
-            }
-            else if (interX === x) {
-                return isAllowInBoundary; // 点在边界上
-            }
-        }
-        else {
-            // 处理特殊情况：点在边的端点上
-            if (y === p2[1] && x <= p2[0]) {
-                const p3 = pointList[(i + 2) % size];
-                if (y >= Math.min(p1[1], p3[1]) && y <= Math.max(p1[1], p3[1])) {
-                    // 若当前点的y坐标位于 p1和p3组成的线段关于y轴的投影中，
-                    // 则记为该点的射线只穿过端点一次
-                    count++;
-                }
-                else {
-                    // 若当前点的y坐标不能包含在p1和p3组成的线段关于y轴的投影中，
-                    // 则点射线通过的两条线段组成了一个弯折的部分，
-                    // 此时我们记射线穿过该端点两次
-                    count += 2;
-                }
-            }
-        }
-    }
-    // 奇数个交点表示在内部，偶数个交点表示在外部
-    return count % 2 === 1;
-}
-// 使用示例
-// const boundaryPoints: number[][] = [
-//     [0, 0],
-//     [10, 0],
-//     [10, 10],
-//     [0, 10]
-// ];
-// const testPoint = [5, 5];
-// // 判断点是否在边界内
-// const isInside = isPointIn(testPoint[0], testPoint[1], boundaryPoints);
-// console.log(`点 (${testPoint[0]}, ${testPoint[1]}) 是否在边界内: ${isInside}`);
-// // 带间距检查的包含判断
-// const isInsideWithSpace = contains(testPoint[0], testPoint[1], boundaryPoints, true);
-// console.log(`点 (${testPoint[0]}, ${testPoint[1]}) 是否在边界内（带间距）: ${isInsideWithSpace}`);
-// // 查找包含点的边界
-// const boundaryLayers = [
-//     { id: 1, pointList: [[0, 0], [10, 0], [10, 10], [0, 10]] },
-//     { id: 2, pointList: [[20, 20], [30, 20], [30, 30], [20, 30]] }
-// ];
-// const foundBoundary = findContainsBoundary(testPoint[0], testPoint[1], boundaryLayers);
-// if (foundBoundary) {
-//     console.log(`找到包含点的边界，ID: ${foundBoundary.id}`);
-// } else {
-//     console.log('未找到包含点的边界');
-// }
-
 // src/utils/handleRealTime.ts
 // import { BoundaryDataBuilder } from '../processor/builder/BoundaryDataBuilder';
 // import { MapElement } from '../types/elements';
-// 根据postureX和postureY，结合射线法，获取到分区id
-const getPartitionId = (partitionBoundary, postureX, postureY) => {
-    if (!postureX || !postureY) {
-        return null;
-    }
-    // 射线法，判断当前的点在哪个分区里
-    const partitionId = partitionBoundary.find((item) => {
-        return isPointIn(postureX, postureY, item.points || []);
-    })?.id;
-    return partitionId;
-};
 /**
  * 处理实时数据的消息，这里的实时数据消息有两种，一种是实时轨迹，一种是割草进度，其中这两种下发的时间频次不一样
  * 实时轨迹的路径需要依靠割草进度时候的割草状态判断，目前只能根据上一次获取到的割草进度的状态来处理，如果一开始没有割草的状态，则默认为不割草，后续会根据割草进度来更新
@@ -2061,7 +4995,9 @@ const getPartitionId = (partitionBoundary, postureX, postureY) => {
  * @param param0
  * @returns
  */
-const handleMultipleRealTimeData = ({ realTimeData, isMowing, pathData, partitionBoundary, }) => {
+const handleMultipleRealTimeData = ({ realTimeData, isMowing, pathData, 
+// partitionBoundary,
+currentMowingPartition, }) => {
     // 先将数据进行倒排，这样好插入数据
     if (realTimeData.length > 0) {
         realTimeData.reverse();
@@ -2071,15 +5007,16 @@ const handleMultipleRealTimeData = ({ realTimeData, isMowing, pathData, partitio
     // 目前的方式是，如果是location数据，判断是否割草，取决于前一次的process数据的割草状态+本次的location的verchState
     // 关于location的分区，需要通过地图数据，结合射线法，判断当前的点在哪个分区里
     let mowingStatus = isMowing || false;
+    let newCurrentMowingPartitionId = currentMowingPartition;
+    console.info('handleMultipleRealTimeData==newCurrentMowingPartitionId=================', newCurrentMowingPartitionId);
     realTimeData.forEach((item) => {
         // 这里需要区分，是割草进度还是割草轨迹
         if (item.type === REAL_TIME_DATA_TYPE.LOCATION) {
             // 割草轨迹
             const { postureX, postureY, vehicleState } = item;
-            const currentPartitionId = getPartitionId(partitionBoundary, Number(postureX), Number(postureY));
-            if (currentPartitionId && newPathData?.[currentPartitionId]) {
-                const currentPathData = newPathData[currentPartitionId];
-                newPathData[currentPartitionId] = {
+            if (newCurrentMowingPartitionId && newPathData?.[newCurrentMowingPartitionId]) {
+                const currentPathData = newPathData[newCurrentMowingPartitionId];
+                newPathData[newCurrentMowingPartitionId] = {
                     ...currentPathData,
                     points: [
                         ...(currentPathData?.points || []),
@@ -2089,7 +5026,7 @@ const handleMultipleRealTimeData = ({ realTimeData, isMowing, pathData, partitio
                             knifeRotation: mowingStatus && vehicleState === RobotStatus.MOWING ? '01' : '00', // "knifeRotation": "01",//刀盘是否转动 00-否 01-是
                             // knifeRotation: '01', // "knifeRotation": "01",//刀盘是否转动 00-否 01-是
                             pathType: '', //"pathType": "01",//路径类型 : 00-巡边 01-弓字型割草 02-地图测试 03-转移路径 04-避障路径 05-恢复/脱困路径
-                            partitionId: currentPartitionId.toString(), // TODO：不知道为什么这里的id需要是字符串类型？
+                            partitionId: newCurrentMowingPartitionId.toString(), // TODO：不知道为什么这里的id需要是字符串类型？
                         },
                     ],
                 };
@@ -2106,17 +5043,22 @@ const handleMultipleRealTimeData = ({ realTimeData, isMowing, pathData, partitio
             else {
                 mowingStatus = false;
             }
-            const currentPartitionId = currentMowBoundary ? currentMowBoundary.toString() : null;
-            if (currentMowProgress && currentPartitionId && newPathData?.[currentPartitionId]) {
-                newPathData[currentPartitionId].partitionPercentage = currentMowProgress / 100;
-                newPathData[currentPartitionId].finishedArea =
-                    (newPathData[currentPartitionId].area * currentMowProgress) / 10000;
+            newCurrentMowingPartitionId = currentMowBoundary
+                ? currentMowBoundary.toString()
+                : newCurrentMowingPartitionId || '';
+            if (currentMowProgress &&
+                newCurrentMowingPartitionId &&
+                newPathData?.[newCurrentMowingPartitionId]) {
+                newPathData[newCurrentMowingPartitionId].partitionPercentage = currentMowProgress / 100;
+                newPathData[newCurrentMowingPartitionId].finishedArea =
+                    (newPathData[newCurrentMowingPartitionId].area * currentMowProgress) / 10000;
             }
         }
     });
     return {
         pathData: newPathData,
         isMowing: mowingStatus,
+        currentMowingPartition: newCurrentMowingPartitionId || '',
     };
 };
 /**
@@ -2125,11 +5067,12 @@ const handleMultipleRealTimeData = ({ realTimeData, isMowing, pathData, partitio
  * @param isMowing 上一次的割草状态
  * @returns 新的割草状态
  */
-const getProcessMowingDataFromRealTimeData = ({ realTimeData, isMowing, pathData, }) => {
+const getProcessMowingDataFromRealTimeData = ({ realTimeData, isMowing, pathData, currentMowingPartition, }) => {
     let newMowingStatus = isMowing;
     let newPathData = pathData || {};
     // 找到返回的第一个实时进度的点
     const firstProcessData = realTimeData.find((item) => item.type === RealTimeDataType.PROCESS);
+    const currentMowBoundary = firstProcessData?.currentMowBoundary || currentMowingPartition || '';
     if (firstProcessData) {
         // console.log('firstProcessData==', firstProcessData);
         const { action, subAction, currentMowBoundary, currentMowProgress } = firstProcessData;
@@ -2150,6 +5093,7 @@ const getProcessMowingDataFromRealTimeData = ({ realTimeData, isMowing, pathData
     return {
         isMowing: newMowingStatus,
         pathData: newPathData,
+        currentMowingPartition: currentMowBoundary || '',
     };
 };
 
@@ -2165,13 +5109,15 @@ var hNoPosition = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAEoAAABKCAYAAAA
 
 var hDisabled = "data:image/png;base64,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";
 
+var x3Edger = "data:image/png;base64,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";
+
 var x3Mower = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAADEAAAAwCAYAAAC4wJK5AAAACXBIWXMAABYlAAAWJQFJUiTwAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAABAKSURBVHgBrVp7bN3XXf+e83vc3+8+fW1fx24T23FSp3bStJCA1i6rbQm6SqsKYkuRxqj4o0xjQqBJgNRMI4kEEtKEBALRKhqIIZVJMavY2q3T6MNrYWodTMsKXhsW51k7sRNfX9/H730O33N+j/u7fiRutGP/7u99zvl839/v+QH8HBrnnESHRBxH58k+tUHq2s+t3XVn6YmfPn0axsfH8fw4VCozuJ+E8+fn5P0jR8KH5uYARkfrXByvrKzw48eP8+npaYJ7RojAy4nYw120uwIRU1NMolqt0nK5TJrNCn1i+V+HqL8+rIBXooSXGMPnGD5JcWN0zVFITSHqWl3tvfzTQ1PVRqPBK5UKm5ycFE9JAHcDRN3pgzHlkehyf2ZuTnGu5+nTte9NKEutr+LYD3IOJZyFmAq3jS4S9k7wXRwosCDr2XjuQMatw6OzCz9hBP7buVj68+mVlYvIkSAchgsgcsidzm1HnIgBIOXp/HyFjI/30WNX/nqk2Fw9g3eP1br2ktVd90O9ey+4Rhf4ambbvjL2GuhWDSqL70Fx9RJkrNUaI+rfvjj4+J+5rhsgV1ksYrDDdkcQEWXIqVOcTEwAtayfKY+8feIPFBKccLLdpQsHf52sdw0BwyG5/BH/fFs6SiqjeFHcG24N7r3wI+hbfFeM9JZtln73xa4vL5TLCx8LyE44Ia3MzMwMvXQJ1M9efu5rwIITtZ4R+L8HnwKXZCDwOW4MWi0L1qqr4NiWBL+xezF/wzShv/9eoCpKG26KSqH/2juwB8FoXuvKeqbn0y899sUL5YUQSASc3zWIth7MKEMTCGDmb75GOTx7ffcRsjD2JPg4cd9l8NHVa/DqD78DVy5fCGcqAEi53gIIbsVSGQ4fPgqfmvo0aDoFVaNQsG7A2Ow3EUjjyi299/HZA49hZxDshCN3BCH04Ho+r/7OO9/4U8L4iRu7j8DC+K+B5wa4MXj7P34Er736UvxCe/Jy/hGgZKTOe6ViF3z+6d+DSl8vqBkBZBmB/CPoCOSqsfcTb/WO3Vxa+mJw8iTw2wGhtwNwGocaGRmhn3v/5RHq+8+2sj0hAC8A1EGYef0H8Nq/fTeaWGqMaJJSpEikHvFPoi4carUqvPBPz6HfuIkcDaBu9sGV+x/HO8rgbvvyGV0fVQBmKLmD0NPtAIhpDJyZUxZcV82vL54JUIg/OPp0JEIBvDc3C//+5g8TJeYQKjTnLDyOQEnDANF9Hl/nCeZabRVe+OZzUF9vQoDEudF/GJaGH0ZFZE88efnMpLCEURcfD4RowpGVyyaZePX5h9BTHVu+5yGw9BKCCKDZbEgAMQN4+JNiBpfXeHSNR+fyGYgYgscsvCmBzL7zpuxbGIhrI4+Cp2a57rdO4F1FGJVUhLBzECKEaDaXqeZZExwovz74CQiCAA1TAB9+8D+wtrYKPBEMaB/zNheSOwk3Op5sX8H7595+C0ExHIOBSzNQ6x5Bb88fQOeoYJhCMbT5+CDmMQZye+qUEjboaVnSyPcBY0yKy/kP5yGSioTiyaRTYhRf5rzzPO1EeMQNy2pJ8xywQBJrrXsQIxbSdeSDb+3N5/N3J04DhQJRebfCff+wJbwwstrzfLlfW70VUTFCIo5YJD6x6GzggvhJDBdvPw/RO+L/o6tX0OK5uPlgaUX5ukZJudHoouPjJ8l2IrVl7CTM6p58njYcTfhW8BXh0HxplYQ4tZBqCUFT7iCOe8KJk8SAx1zI5bIwMTkFw8MjG5Q/PN6zZxiKXV2yD4N3C06AEgRlw9BJoRBGxzsGIcLkV155BSdtUODBoGWgQnuBBCJl1rHaIpQW//TENoQevb298PW//Cswszl5zljIKbEXgIU+iOdZpPAUBgQIQnlrj23X6dJSgUxNkZ2DmBY0RBZqWkhLMZ6QU2k9EIRt2wnVE4uTZkrMjdhXYPvy7/+hBNBoNGHu3KycaNoMx510I9j99x0A4gfyXAl3Mi9JRbh3BoHyhD+7owHwNSQXAiCBL8SJdQ6eaglTOibHJZV7KxV5/u2z34JXvv+9UPwEFxJPHu5GD4zBV/7oBFAcR5wj2aBeX8ejAkQWim+c7raKXa3eJKqqEPGKSzUidEGA8IMgmXJimRI/0bnFyi9ERoAX+0azGYlam1M87VfwGQ/HcYkuZE4IlEQoMsOTGH9s1bYEIXKGcrmX1yNyuqjYwlMLkaoJ/9BhViGxUbCRM4nFbfsDngYMKRscGQbxJwhlEy28x4Q+9YBwvLBN21KcxsdXeLVqEK3cReWATFAx1IcgJU4xZ9NxXhpIOkETl1mSb0SNsU7E8hILdU9wIdR+qGsq0R0RTZ/earpbcwLzXjIwcA8YfiCHVF1bdi5FIhanFJC0X4ivxfERi/0HYxEnWId/6HwrtEyCE9wWYkdIgErZbNQlObYTp02cEANg/gADA4uoSwWhfZgf23IygjpBEA0rqS8oSaCoEXhyN4bSGk0ms9Ti8J1rQcIlnjKfkAoAo0IOxDkUjzihIgj0bqCICVWrAOUqzmt6ZyCEsr3xxhtYckGOGFkey6/kRCRWEZcjc8fh87s5fGlElgSg7QEB1m0Ory2H78twAieXMcwk6wudYlvcxFuSE6h/JGARkQJ0knm825CcOHXq1J1BiM6mp1d4uYwzQ89/cdfDv7XQ/8AT3OV/jBEmMc18/GTyzgD1gDeDJPERnBCHeVTO0AIBvP/+T+CTxybhc7/5BXh08lcRVEgYGVSy0HL5EaF8dKquVlz82dDkbyMvF8NRDsJ2bQtOiAoelmTOvETKxV5+5b5PXbUcth7YdRJyQWpnXM0LKd5ygbecNqzIdNYdAVjD4wBe/Jd/hn37D0C5uxdK5W4pMm0RjbYIRMzLqwNHFwkp1AAzPoD/xW18ZyBEXWB6+izuDVBbLcxICe9qLhaqQU4qNQ5GNjq5568bOOEgJUhoURiF12ta5A8o3Lp5E/7kK1+Cw79wFAwhUgCpIDDka2+lH3b17wEdQ4WKyQvjwfLAR/2/VIs5sZ112mR747zaMEYySC3zF2e//he1XP8zb3RPYX7RkjHUi9/+BlLShZ222HpJTgYs8SkdIQoejx88CiP7xhFkBu7LefAr1TfX69nB33h33+PndH3IPn583Bfxw8b+6UYAYi9M7NraLTJ27vlD1Go840e+IVburnLPBs/cdmQd3rfDKWKYRxRQFBU33KsqqHhMKVY78FicV/rQrJtZMHHTNB2Y6xVyaxee0XWN5PM6eeqpp7Z0eFv6iQLmEp6Xw3zI6cK8l1MRtUZmUEzqnoHhDo/LZF7dmUtsFDmIqC6iCCFehIYbpYo8LxRK0L9rDwLTsISjQwZdtUhVueMNimj6xo1rovgMW+UUtJPl0iuSHy8vU79g0aYDyvLeh8n8oc+mwgUGQ8MHkFKZJHyAtK/jbT/IY3CJY+NpHwnpgHQACUMQUAzqVnkvfHj0C5hR9iJ2X+npKVAhIVulqTRNJdEmJiZoP4bhZcgp9bFjyuLhz2AJWENZ5lF6itZA1RDIaGzhAVJc6OAGQKdosVS8FAWG8bv79h9KPHtorTBOK+6G6w8+SYTkcW7LXFv4io3cUDq5TYjrPkAbZkvblQe92b17wracxxr1JrSalkxPWRQ+GBkTLi7MQzuLSLrZfAk2ihZPPcdhaOgADA6NhuCFyBGQeqJpaDzLfYQG/j+g0Po9Pbng3LlhduhQp3JvEifH+THdmzexRGIoVtNRmgig2WhhscxNHJOgaLHUjaXIRzpEJJSsDQqeApBE7akL2WwB7h87kuib4IKHzs5q2SCIZyHxXNT9dR4o9boQqZlNK01qig387NmzUu4urVm0iCGT4wS0UbewQ0cm7wIERNQSEcHIvoPQ07MLvfHbWMVbShE9EviI0hB57WT6uDNzBeTAKOzDPlRcCmBRRCuqlT4WqB3HwQK1itYqg/XajJIt6jSj3MIe9U0ZnprihPAPgJVvNLEqQT+H3HCI4IDYZGQZx0y8He8Uiz3wyCc/k4hIq1WXxySZ+OYmqJ9CHMVIsudkgoJo4dgeKegFBRq+UgMdy6qFOyv2gQP7EUCTeIqDZjagcUoqvHUYRrMkGmVR6plWXhFbmWYBHVYO9/GWT225jpA8FqP2niexlDCxYmxPVGOxvpDJaGRhYXNylA47JFkcx+deNofVXle4J8542ypF0SenWIJAR3XR9bxDJFWWEaIQSg/p8BNxQZvzdqIU3xb3qKIso9Nb8T3vYPs6S3RKQ9uEWS3m2rdQ1Ax+OxCyoWyTrOZzm/pMGsWY4mIVkYRLuflc4btjYyMvcAX8WyvVSrNh9aHfAs9heY97eSpqVUGQR2rnQhEkgF73hugfaQsKURpoeRo501w2s3orkzdaFFOI/3pv/u+R+n3xmJLrjNWp4jMFdJYrFPnICMBtQYh6ExZv+cqKz7PZXOCyxmuJfY9sM1Uo5LLmOZ8ENRzY7+4ureL2oYhWxX9g2+iIdSKsI4vYQYmPgaTKPU8+AkwRqY7LNQz0PM/FKiP6cYVoWcP4Qb3RfDoUNRI70p96nsoMVuOG0cdEwSBeVo7bJj+Ry/0yyWR8LLwRRVM0v2nVLyKlD2OMX8DCbL1YzP/d/tHhlxnzLA1ok4Jp4fKOhTUKi7rM9oFYSHhcJiW2onELna+NbthyPbAzRsbmimvpoFiB59kO4w4WmGyMp1B2qZ/N6ufX1xu9qNCjYvYZQ/9PtJbPqpncWsFUHcvi/sWLrWBycpinI9qNOkEqlWV2vl4PytlerFsqzvC9+77fP+C8jgwIF3Sp6qG2OxnTdN117nHeCHxqcpkqlQAwq0TzKU7yWGSzQo3BpQDTMLkt6pJggl0PuNGr8ZytINKA+PWmxnRFM7Km89ChsWeZSr+KwonG1HQJsa1MxnU8j/r5fIWNj7+7adWoQ9OFyIj1ue5uS8nlPN00ixm1kMl4rqVmuK5gigGsRfxcTndvOuue6XNfrFCXSi6/gRIvaqZ2qZsbukoqUr+W091DCe/hWgSxbVdOYteufrh2DSvv1MPxFC0IKIIhKGW+tJo6JnmEZNxsVrWrOdcd0R/2jx4FXxiX24IQ18SihmVZSqNhalqlS7WW1lTMHzDHMEXkFGCtGaVr2cfQILh6tY+Njh6JOp2REXD4CUR4Lf48Im7xpxFhCz+f0PU6RufdimF4okvVNxyKKbUQlMDFsYq+6tv2Ak4eAgzHk68PtgQRN0zG6cDAgOI4e2h/fxctlXJUUBBpi3d3B4KtpnktiD9niEqRof3dzsPFA6bXIsNvOgTVyZm5OarXexTFXVd2CS7oq8LRcl3XAyRM8PLLdX7y5GQQv5fuc6uSTQzMFxlepWJiWV0ntVofqVYL0cvvstnZeT41NRUH4Mnr5E6rhNAZgot3og9ckCBHWLU6F1wCYYFCr16v1/nCwgKOMc8F57ZaRd1yRB5+8QK3o+rH/f5iuxaNxWPidVQTO8aTv1uO9/+uiKVx8nF2DAAAAABJRU5ErkJggg==";
 
 var x3NoPosition = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAEsAAABLCAYAAAA4TnrqAAAACXBIWXMAABYlAAAWJQFJUiTwAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAACP6SURBVHgB7XzJjxxXmt/33ouIzKyFrCqxWCSLIlncRKnV0+rFaw/a1vhiA776asCX8bkPY4w9A5iGx9PdtmEfjbn4H/DFMAwYBmZBj2Z6gFFrtIxaCyWSKorFrUSy9syMiPfe/H7fi8jKWiix1WL3ZQJMZlZEZkS83/uW37e8MPIr3uLNq12ZnM+k7ne3s5DJ9o70TW56MY8iOzIpMlidlHp+XgbGXK3lV7gZ+SVuMV7NtlcnjvnhcDrL4oytuxNihs57i/uwxrkQvQ96T87ZmH5lYy21ZHiXYGpv4yaOrQ0Gw7XZpatr8kvcnjlYBGh92T2f53Em1nHOZdZ4L5bgZPo5HHIPwUTJcKAmYkGivuGVAUW8xxr/YV9p6qKXPawG9uHU0r+5J894eyZgYVRmffkHM3kMSzG3cxy8ACBjABJfClADEgDTv50T8dHgo3FFxAdjIjacKoqLCSyCBvnCuSQ6gqhA+ggAnbi+s/K4GJafmKWrA3kG21cKFsZm1tf/x0y+s34eyjML9XKZAmScD94SIAXMuwQaASNY2DzEzeGLQWpjbebT3RFIT00ESMZLsPxVcBDIGgi34MUY9EsOwNWW4MV70ydPfmLMv/pKQfvKwFpb/sFsLtX5mJlZzHeGYWPurZPM2UDUAIRwn4kGQ7OulTKKiTjrQzQAgUPXvSpReqxVQaE4ARicXaXK4QXAeJCfbfQ4Vidpwz6cMlpzd/orlLRfGKyf/vQP8pcX1s/VtjqXGet8WTqxwIZGSQGDhmTG6cWiz7xxGaXFmAz7KnENNNBHBdL7GuOk2uEIZFVFjNKEU0GA4A0zmitPQKyavzF1VLCMHo/BVgQMOrvjquKTyXO/dR9iHeUX2L40WKpyt344YyW+hHuehP5kdFkqVQEjy10Wqtq5BJSFn8ssJAj3i79rE6KFtfaA11qVJvwwQD54Av2fb7gKZDACCQiJDdyspaDiS9ZRKQGOpVRVdR2p3ASujrEILpeyroFVsNgfqsrK3enSL/8iUvalwCJQcue/nd6ut65QiqBgGXyX8wTChjxgTl1haFgKZ7wNJmQOx2mhgALUD98zBKumclq6xsDxAwr9FLG3Ne4ZVRNDBihRJSoLCiuEDpeGIIZabA7gbO19VcPHQsltRTGMVmoXMuAYAJj1pcTtI1X91pcF7EuBNXjwHy/VA1mCCDnKhokhp0QRDGez3IeKKphjQM45GBRKHYGKAM0QjkgRA1gUHm9g5wky3aiqZASEsO0xcLyGkqM2CqDVXiUJFBbDB6ShpCRByrA/Vricxy88Zq9SlTSUMgAHYYS0QfcxjQDOFPb9qYXfuS8/5/ZzgRV/+pv51vzpy8bkiybUVLqMUkVpom0iKC7zkAWTw+piX8igRQ52uACktPEA1JNuAiiD0QK0ALnDKC3hxTisKiKwglTVEE0Fy1C26EotXCbYhUparAL/hnhGk0GiDKRJAF4GAhLx2WI/gMJJ9B3SRumqsYcSlzl/s3fqd5d/nvE/NVgkl/3b9tsY2Ay0ioQa9hyApMkvSA9AFqEPUMAA8Kh6AKyOdQZxyylVGASlTSXMUkTwG0gADuMIRoSrmPSiIcYe7hK18RFD5t8ABUbbUB2dDhp6W+IegCrBMRWALPmOU1ZwJrXjLZh6SIMPCYQRxalKAlfXXZffMKd++9bTYvDUYG3d+OE3JPMnjFGVyeH/MWgEcQAMwpGLraBirghUSeNzKFFBVQt8jx6BHgDDhEK7ABq+7wNtGGxyhNYALIiJwiVJFSlZNEzYE4xiCZoKjxCSegFAR5oAUmZKmEF4yTjECSqIVQWhhWSZCoZvKCYDSFkF7SvVY1ocR9gUQ03vU2/HeO3Y87+78jQYPBVYg9u/fxlGAtQASmapZlLgrhHehcLDbmGQRQLKF9AAgCKQNMmhWAUu0YUzAsCmoFRBbvDuVQ2FKpnAsTRUyQ+SZ8GyhAQYjvFjhHrWNOu44SrSMwAsTBypQoXdJeawDFFVEaDlFe5vaF1e+tqrpBE0qHyZgIMq5qYUVUlf13V4+2nizC8Ea2356vlu1rvgQwkVAh0AIA7GO1B9MkgVpctUBCLHTHZwsx2EJ5S8jqUPl9CBi4e0CYIYShscAVQTFt71y6K7NZye2BwemSjrIrfKrKR1hc0HK5P5ej/Pq/LY1IM1nB8M15UMenAPAMEADEiZ2CGChApTMIB+DyG1Q1x2CLMBb2PLGuqpgJkWsAhVzCBhMPreDHqhfOOLvGT2eQc//fT7vSzkAIrG3DhVPUgEVRFkCapmKEm0VwX+7qjKWdPBDRSWf9vYgfXuQDgIZIHYJB/Wne77d76xdHfjxML28MjU+PW6nc6e64MLCKZ9z77ZicePFmeX71w58f4ypBlqB/sXISUkt7jHxNkAcwo6yfpVrR2dBKMjb5THgroEeAqKMGlzZyfLX4Jdfufz0kBPBIsGffNW9m1l41Q9df8W7z6HdQVQtEuUGHyGM8Y7VC5AemLHUsJMAFChq+9CCYvFeytfX/p49cp5sd3s5PxzcuHoEZmenJBetysM8hAP6Tu39jPfCVi/LGVza1tWHz2ee3dldu7j+1cufO+FP3r9SGdrE2YthwQjDIVMC/1qZLRgiA5IPBkJwnJbeB5UGkIbRw+SGB1lFAHn0eHH7iz2X38SJk9Uw8Eq7FQ/LsEekUjCkFMFqw7ECuCorcrhxShFXUoWTEkHF+4CsC7fMZEdECOgEIqyyif//Po/fuXxztzM6ZMLcv75RSQZ3OgG4r6bifturFFJNffcPwBw7310Q9Y2NuXCsWs3vnnmjQ9FbRYShJINAVwf0cIA3nCAQGkIaRtAF4b4dR8WfqSWqoY+DKN1FdSGTqHuTtq3zNxvr8vTStanP/l+r96JZ+HfGeCCS5EOERyGLbWyb9x0Qf4kpA+QKmgBgKoJEsWki+vCVsXORv/I0R9/9Oq3jZ3pvvLiOZk5Mq0jVj8Xg0rOCJQxtHY/J+jav/lXkeXyyktX5JNPV+T6ipzfqSZ637342jsMRyNDKNwUlIuuFopYQ54MORqYKSkcjR0IHbJpmFjPaAKcEVQN0Rm+uzM0l3GJ1w/DxR62c25x9iXAAnZO+0TAYLMQtniqYrQw6EbVD9E/pI1A0S7REwYEORH2yoMuSHdjZ3rmNQCV5XPdX7tySY5MT4mmDQLTAkFBSJ/j7v7m79j8ndxh3PviMdzMmcWT8u2XX5TVrbMn/9/P/vl34SSmOEGAtAsGh/e6SJGEpeMplOpEzYhkdEgAzdFBkVbzM9NJYBST26s/OnUYLgfUcPuT/3QSdPHrhjQBtiCzlgST3q8wdZ1DyKB2dQf8qoN56gEgSJTvIr7txvR5AjPQ3RhOzvz42qvfUqBeuKxq16ocVaqqavn41m3YoDVZ29ySioZc9awRu7FbzHMn83OzcunMaXludobBUJJK/S7UcjiUN9/7QOanlu/+g/OvvQPD1Ie92oEZG8B67cCUDcB54ekM/+7DUEE1uU9KMJoS2gNaQYpBsgrviERi76PydfPqXmN/QA0hS2eUGEKyMkgSEafdcnwvEAwHsnBIVOVJSNtZomEvKF3UEnDF4rVrv/EtMUe6L1+6pFY1qpQkMLZ3BvLaT9+S7X4/qZga8gbIMZza/WVZy8q9VX1dOLMo33jhouwSDFywKOTly5fk3Wty8u2Vnf43Tr/xoVoQzCQmDjloz+i9ohnH0DLQOyQI6dk5vBJa44g8JQu0DMTE+s7a2WwRp15+ohoygWdtPAL91rSKZ05SaUJgZsqqyAYybsZ8yKaD9eEqEHV4RXg7ciyqwTu3v3OxCpPdr126SN+kQFHtqD6PYZT/8C9ely0AFTStF5P9Es1mqMTEuKuKu6+g4H20/Kn+fliCiGv+Ib163Y6cPrEg1x9cPn9v4/Q8rkd1xMQxFEOpCFEFbG2OwWQ2j5pnYwzLgSIMJ1aqitIkJTuT9oAq7gGrV8STtf4AQQGAck7z5PS7TjT4FauwxUxjPyGvU+kEiOBSgDjf6E9PffTg0rnFhQUYYoaByeYQsO2dvvz49Tebge4CIa19anKiu0DJrj2LMvrO440t+cmbfz06b3qJnDh2TI5MTsr7d1++oPcjXmNY2Cp4dNIbaIRHkO+ZmHAIzwLjn0JTR+C6mjOhjcYLzK2Ij3549FCw6AFx0UXThB+eVA1oM6WCczpN1jEFozkrzxQB/s5g1CMvRAboaDTvb5x4jvZp4bnnGoPczn6U19/9QIbDcgRSCE+Son0S1Ujb+At8Sz6GlO0a/nSNU5ikx9uzs5UHeQO3IkhIfWkgT27IzEdUDaHDYro7MnebUtzqxCAYXiMtu73tzx4K1ulLx2b0B4FAiUoVOJvjj/GZegw+GlJMx4sRPAJFrwjpwo3ipiS/s3by2DRmN+wD4QEM+QMMkFt7TBrVOwys3d8naTsMyJ9d/2TXOzag9YoUBSw/PLeAe8tU8vEOe5DuXTQdRClQ6QomeUKO03imukMq0SGh4Zw5Gv/kanYArJ0df0rreThPppKFzKdWY7wWE6jUEBhYamRJIitPyFMhk9sAlvEGYE/doJro9jrdpBpjlGDlwQNhdDwCJsQ9gO7Sh/C54I2/qqqCJ90cXYsvOpMiz2WnRGiA+wsq9dAu3CMNvGHwDpscmW+TNC5NUjtPaSLts4oDfoZwy+283Du+ByyGNnCXcypZtFOG1WGbTgQt1KIDs77kJRRaBYnFGEpZYMaAF2e+yjEoVlulXKh54TPpQUq4NHZK9oIhY3ZqP0hxDODRqzlG+7WXhwWZgAb2MWlRbZGoDU/3m+wucmyN2tG7By2Hp7eQ8ml6DAlqvJCcnWnBSiK23kE5HRpb10azSiC8wMWSQDCdRMcXQu34czhyo4UsGkQW7pTNe+4AD01VnDzL9cbTREjD2BvqkHDaZejNl9qIcBTsjFGI48/NyuTERPPd0X/K/qcmeyz1j6IC+H5mV6VigjKyFJk0gDUfag0dFT9o7clTRXnP1ErDMJsFINaGMPIaEsZaXn50D1jrG/VcF4oqWU5KbWjcMwLmiXFCX+vJsWaVGMEqbYEW7hwjCZUwsLztwXR3j01qB4z3re2dEYC7g262BqO2UkXJ4b4c4/1H33kFYM3J+EYyakz7Q2k+p8TXdlmrKtZVkXL8FBFmYa1T7Wi+DdvsYZuQkatZO8OYPaedwmFVsxhgwa0xw5bH+F8mjfmt7SxJQpzRngN+h9UDyAkj9PQbngo/pN3KcCQwOV4B/5CSdnpKrbXrjY2GsL9C18SCe6RnPGRu1G/871+7fGEEFGlHHANGY0qzC/b0xKTwvrnRuA4HmYKlVcSYqt/sEYDc2ET+M4eyD/iDpX3WnC1CRktkqU38qfcsIZRm++aAqaQEFkRqggPmmMkiIQGqaIEAaTEBwQxOxGKf0dKda4CsTbp/1tl5/0m58jzfIwUEYYhKQYzjKDYphHEJlL0oa9CN7ToC5j//q3daXA5sU7Dl/+Kf/sYISG6Vz7JkGmgqCJpmYDkEjAcUlRl81i+Z1TGauLFpGDBHNHBq7JF/xll91iNY9xUs6HnPKNVOkmWlxYDimwaUKscsK+DEvqYtY/HKku1BYmivOIO7t2vGpYUhS7UnVyWyGwLul7X2r8leT//a6Q+EtVgZOyajs0lSiHGk4tgHxiCs93AInFUm/gLnn6fJ1evjC5RGpgeRcAwKqvh0mzTy+E/5SMZmsiEr6lQR0suKNbuY0GIVKqq5RzaLYhqdaVBUxWf6jCA1hkHGJ348KdWw7xGA+6ro8QAM0uaXG/ukAj82C7LnUjxmx8FqNZnqF9MJ1JKkVifLhD5L4TqUWvm6oeLoZNMLSpNghWYhP8/yrdribN12ehmVVmcg2at2LOpO1Toa09TWydylKShYvSaFtsGhFRnvE/CyLyjeg8q+rQUp7pMxPdYIuTF7UW2/mUpmMgYo7XDlG3GjU0qTa8cmJPjdO1EVDMqF6pC0S1oJI5Ut1f4lb5ix4y4qy1dvCESM8lG2Jdim94C2K2WXCDs+p64gED2jKhzYgJZslueNjI1X7VY4ROdkHMzD/jIj6VI1NLtZnPHzU0isbeU97S8gDmPn0XszyQGZ1KmTxJHEJzZ9K55S1nrZLA0VnBy+wCc1rMwQkpXr5LBNkSZIw0L+guwkhdLRNncBg2gUKGOT1+C7zpLZM/7xfLoSyCbdMi5ddATTEz1l3NzuffZwL44NUDouXk4SUGbENRqwGqlrsfJJatIXg3InJXkh2V5GiUlBAs2Ili5SoiW3EWoHzdBGOhgzm/IvIdHRjFTPqa3SSghzhZrD1Q6GWukCwcC+iqOFutNA2kbCmmEzXwVj10i73Lh9S2aPHJXnF06OgTfCSD9PAaR/9r1/qO/ttgV68L//6E+lRBgz/iMFrBEnVZIREg1YjVTx9c5HH+i+uUlJQWUiM/pVO/qPxDFTHwmHyMSyspqWKLM8EG3jt5iWbgaKSldROcqNtkOxATad2tMdkMeFdApNXrC2yZOy6U4DoYYYNd85UmyUr5z5y/u3Hy4dZYwo+7Zxqbl49vk9QEkD4KWzp+W9j2/qd++tPpSj5yZlCenj9rstGTVjQFIyzZiBf2HhZ4+OTjzeGu1IqX6j1lhVMOVWEJWYlG7MFVnSejaHsZMiecNaTVNrXjJfmpquk8VybxumRzGOGjERRoovm17ZgQYDiOQQZSg2dsAkxu7UKfp44diHGw83j08OBnIgQzxurh6tb8hhW1ntZnLfQEpn8fgxYRZjElyqVcEWl2TQd/+u66R+89N3+yeO3t+MLQVqGR69d3LvUEMy/VwJO+0z7Y9amWR11WUjqKEnQ845qqhnVd/WpKTOIZkYtRISg/Zq8vzQWeW/bP9B+oLB1G4LY2jVUNuwQ1C9WNuez++tL06wXjoO1AQ4U0ojp235zj158/1rcgL1w3a7hX3MhLbAMkT6P3/8Z2DyF6XTyZv9aT5b0CYgcQuzs3ps2KjvG7e+e/yfvPB/N7udOoWk0kToY0YVxDrSb7GXEOkYxnNkD8a2RpUtK7XRvhfHTjOCdazTr7ZxROeE7SxtAGetVioDAx/GPtoJq1ZVeYMyeO3N8zZNiI/bw+n8J9e/tzg1dcyeOr4g49u4A2sxfAtgxfdln2NIWxwD7CdvvjM6vj9QevniBZnIuqOdV5Yu0Gbmf3Hj1dOvvvD/36PqqbfTi3JGnU6+clNKmDTelEw91JqtdxqkRm0j52Dz2NGyvmV9P6ZOOfanNFtKt6WGH7ZW0xuw+zGdPMGfkimG7T+60wgSf1Oln85PzS+ozxzfEhs3+yilGQEwTsEOYRZjZEIOOW9zjPYLGY9T88fl4faxqaHvuqR/av3jyF/WJIlNXoipTg0zaEaYplOSpH8nrc5QjU22IfUBSOzrl502dGqsydwG3SupL8IbfKzY8BpHyqVMLMaRice2U07kRZ6NhSa72+LC/FiAsgvBOHiHgSRjx0XMAdCOo0Rm9oVW3SL5FqSWXQoFYmjDAmWKamqY+fKNa9UZj8qmWdNqBQfvGV+Sb4/Awnc2JX1IHlH4asoFTJXi5JbJBaMLR4LarPZwaw/0phgluEMHu7S4qLN+GCDmkPcoh0lcHIMZE3B8XiUr7puD1uBv9qeKFkarzEqzeypJQaWLTby0QEx6MaZ22o/PVxIcbi72u7I+Aiuri03ljZrAYZjJVJWmroImVqiKFEn9eQiNVHnN2Ct42sIYDgR9Yxuzp6chXeNAPenLozBGnixx/Hvp9Kk9AJndmLDdqa2ENpVkW0MftRoBqxLZtKR1aLaQU09Y/MP4nUtAab99iLNvD3Yl67Pi/uqoLOBsbCMZzQT5qF6jkeVUNWKzTppoZoZSI79y2OKA/o3zn6XFU08E6DDAxoGRMfC4UaJON05kP0jONfGGJhvUVmmJKZn1RjMCZxriFbl2ShcgsMcrObpomuobeybMVluZ1rM+//x/7wPgHfYDM0fB32iGh3nVLFMLmE5KmOo20ZBmi6pvjTbIDqvc7QcpjunI8bk5+Tq8134QngTSk/YxTPr1b70ynl3Yo4qtKTB0T5psoZMy7MSKWlHQjDtNCuhCRfGpSUh1jQFTXSmQpb0CpF076ggclXmQhXmAE05JVccEhouaPGzKm8p+mUNOZVPmxwgeMkVsOmaawYQ2X2EO05lmMHT1ZNwffrKsvCvu+8phAI7vI+DffPEFmUNi8HBbtVvWD8lJBbXfmk0yWrdBkjekflXaYi4D6rLHLdrG7BC4yAAYI+sX5uEBsAberHZNfY7egKPHP5bCmGvR7F5aAsI+dFIRsFvDuo2Sd4adtQpdHKWi9gK2b1CXz53R14OHqY7IUv548LznNw2KVDuGPKzctNfYm9mQfZnYpHyiDsqSKTJlR6PCQfG+GbvVLmP3JnQwNPaX1FyXe5Bqhv7c3L9bPwDWzNl/+3jj1u/3XVr9EFODIWqPdRlIVglSamZixABdZPO+8RUvyHQ17EOtRr4ZYIxPtk6mGewCqjZ8Py6zB79jdmXtsHPtD6UOvZy2frMdi/ZbV2do9AsTw65mfgOVfLaCsLbHpiH1lJ6UMkYu3cjX9p5ubAuxXEnZFM+ccU3dVc9A243ZsdpWDbFFNQ0nrVUVkUc0bITVVuvY5iH2DXqvoW8HdtgAx21dW0M8TDfjU3gKrkfAEBkDNSsu2IzrdJEU4jaMKQ8213pLclasfsKE0Xazt/hhVd4aP9+elqOjZ+TWYEXOBvo/VmhZIVL7ZPmJxISSk0iEYUMVW6uZyGG3sEcOJ0nWqKVxtAQH5batTfn03h1htZoGmEaa5FVfTcuklrxtqgDQ37IBt8WJOSruYxWaPKhfDjWVw/CG/K297rgkIsdL7apYV8VVyKzIqdRuYXpZNkZYKFyHBnXUFUJey+ZKjeTu0r7u5WzvrF6t+8s/WAaol0zQ5aFeo8XACNWwzFwBx8z5ugq6lg1ibm1ptO9Jsl6xs/lgc7gXqGbbAFhFtl3OT364tTOcLFDXsxvVpI6yX/Zy+ZwtsyiZuhR8TOTb1XRnq1yY2KluPLo0t7G55Y41gXRrs9jcxq1jS0YmFTJ4JdQG1QVmD2Bfa+HioipyOQtpvJY5lYerhDFC/KwOB1ZeHGhm654Z3tpayc/S2WobGHScS0utRQ7RZ4Xxw1p7y9kFTzhB7yKb9iEXS89dv3lj9cKL9x9+JgvHjo3OyWD40ca6vHL63XsXjn+4lqTF2YZcm2SZNOeYvOkoBSrJi6dCX2wcB/m3erIqdsPK+sQC2y9b6SKT+fT+Xenmw+35I6v3cdIh5AeARbbvqJTRzlh6Ri5yQbTscnCHlLvU7Hosw72l8wd74g92/kG61pavLhuTX2LZC/pb+1g7jyI0jH9pUkURIPkyZV5jabk+C9pzdGLj0eUT1968dk+++XhzXQdA1ekPB3Lq6O0HF+Y/vtPUPTVJHLWlvrlwMlImLaA0qbgTEn5RUrO2jOrcoCugMV87+ebN1a35yQ9uVlNTvVTe57Vy19/69Ys//kOcjgsKKlyt9Fyyoq2QMUkVgSNgJFnNSljcDZcthmkTluWQ7dC4lY0ig7vdvw9XMZ3W6ZgcWY6u1MMcN9nBGHoYRA/aztVeBdiDtnRjGB22dG8Mjh59//6VFymJzlb+zNyt1ZNHb2+kyKMpobOYy+DApPVeKQOQ6iVJqGI80B6c+FzqCknVTdIW/8H9KyfWduamq7pwU521x5dPXL9WZP1tHO9zSQoEcQBZHOKEA8uXywZVDfU0AukJ/RgK2Kw4hI2ppqy7/qTFT08K8rVlEh7078JGwvRZgGU6ECx2zxVQuW6IQ7yL9rnDXndwQ10EB83yE+1mziIXPWlSg3SEHTcMy7R8kIpW1jZVF1oKqzFaWwUyjU9t1x5q6jZoK3YjeVqJCEmd2P0fk8fTMrkrwZC54GlodJlKgM0yA9S6tC8enIgA9lHtYk/8EN/jajPsj5u9E/VfPWmVxRPB4rZx++rlwuZLXNloKl9gpgtjS7YddjEIrskBo6t1MRNXgll2NLMJ13C9oS50Si2KEtJSEa1nM0yzScJso2ShrdxELXkbSRVZLceoqwixcXUpvdEAxchXtToxdPIp0ANLSsP1hyUOwkQIFwsMceKhECRIVlo4wLU82G/iMFaOpZly6vTZ1435l9tPwuNzwaKw91d+7+/hnmaZsMbNUdVQSII6UroAFlJk9IrYH3MoVo7fcOlczjXRBE3Sii+2msBusw3IN6UYtX16OIRUm7QNDO3+pvqlCSM7uiMXRdo1Y9RLQK8LNmPqSBYSZF0AVeE3Q64aAzglPpdiC9CbMMRFKE0lAUJqoOJ6alDwG1+0WPNzFzqp5/l04u3NOPgOROgI+6ATEc5VP9JguFAMZhSunaxeV8R7tgc6tiblymYMval2BbDua9JKOaYEcpesFAsDtOdN2w7bPnVlTRK33cy4Jjt4TaXaTdcsA2QSZz4QgVSnMtp3B2POJSiRoEFFuYxOAsBR0GpcD6B6rkWs60pWp8/8zucC9YVg6Xb6+/3pz/7nW4Phnb/TrJhk+Im7rKHpvG/8Rd9IB6wdXSpNfHIDnCdvRlsztHAWtNmt6Y8SzfHoIUpT6jRg1UVz1FGrxZpSqSW1WGiPB8M7r48eQX4g2IYfSUoVWUnLgAP7DS3qx5QmLv91UiLuqG1GoGwVyRsNuZf1hfMbH62Ha5+fp22ER55i4yxvrvxgDiSLq8RyrrxgIw7qYh3RtskqYyGcfeb6SAKj0VWz2l77CFiYTPaKNF/7JJKFSjZJ7Y4Sh5RtSp1ctm24Yphr2Rqm0hRofdk1y8cYIJJhEVOZt9GF5rqmGnSHhJkGPEP4V5MXApwAh4dog0uDQVKLTrGZL3RRDfn+4Gme+fDUYIn8B9iveAqj/BqXRyLyLHT9YWjtE/vKfaYdwOyZ5+NUXOMFkyFqjXrLOClF2n3DR0E0yUcoHPNLGnCp6dJHGKC+Z2NqzVWqxQxK4rLBJ0bmdb+hvHE1ftTVqqJdK5Yxc0kHkOJDSlaoQCm2eovPvS3yr/uNz/1CsL5YDUUa9hyltygr8vhHm4PN4Xe4isCnUmvQZ8dEbapkexPLwzVjS6YvaH5pWlKpiClFk55Bw2KjcgKKEzMoTLWFJtfO3gEloWrakPpgu31Mjecp38mlqKRqWvuTZn/Ux43QG+hjVjANlWYVTFbzSRiFTUDh/Bu9xe5fi9wdPi1QioM85Zakq9nu/9eJQRh+M6DuJVQ5sLwUeEMHasTxmfaT6+NSYBf4eAIju72coqGO03yT3Z8UptHTJ39IEsbUGpAKvZp1YhTaZglYxkLpHRjUTL94VqZMWWrYGjXIZ/7Ki/b5IVjmF0tzf6qcui4XH8HgX22TlV8tWHuAu3rVym9Kd6e0L+Du5kGNcnbgww1aXTvN5gl1SfBHXBPD0i7KAApQxSqmCpf+ndi48lL2RKWQkTZMPSwBqPQxY6HNZcS06sbpM7UIIgFpcus09kwkqeE3bFGu9GlINqmg65Uf9+Z+b0V2G3yeWqq+PFjJFGuP/uDuj05DWi74iitZcy6HcuylV6BoTAge7b2pkYEp4MsqXa2srSpB7CikCWwmswqclqJsejKbSzEh24BwQi2GsktRn9HCNgOtKyBN5LgEi6ab4AT4IFfx2Q9siMQtxO1ecfldmX9vR+Tfq6gezH0/I7D2Aye3/1e3dDfPge4sIu3laOUl99bzSQT09OyF1aUtDMC158sqVtpMqAWDJGaqYqm01LbK8X/bFPGIDE2d54PZ4BxdKsIzwvQpbmTRgU87yqCCJOuukuHgVvfcnRWRP6h/ZU85OmzbenD1hK2y87DHk6IRh3A1unZfqv3iAwp8s4pB2ibn9IQ2bS1XvBQxkUZH05ltWlbRPEsrtg/1UbtFbsWH3oBSVHV6nhb3hbg6FcL1r/IpbV8pWO0WH/znE31fnoEqHkkrrDSfYLgeRp9ew2CQDp19wsqWoiqrmnfSiEa6FBR2H3pdc6ZS5NKjjpLtUhVUaxjq1FwYclvc7Zf9+8/i4YnPBKx2izevzmxZOQXvOIORTChwEpoVDI1UcZ0Qywhqx5ofJofZ5IYpUUnKWKKqm5qerpeIWVOoif1hVd+bOSe3n+XjOZ8pWOObAmfcSbjHacRt046dOSY0T5YUxYOkj0Qtc4U+4Wj3x1bBScoJ6h2Y0Cs3uSgMu35pj+D8pYE1vjG5KJ/IVL+OU1U362U2m0K9A6Vvm6f26dTFQgqO4kaVMUFnqgFKJFs7O7I1/9Kv/gGvf7t9wfY3LX5XLVhDK/MAAAAASUVORK5CYII=";
 
 var x3Disabled = "data:image/png;base64,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";
 
-function getMowerImageByModal(mowerModal) {
+function getMowerImageByModal(mowerModal, hasEdger) {
     if (mowerModal.includes('i')) {
         return iMower;
     }
@@ -2179,7 +5125,7 @@ function getMowerImageByModal(mowerModal) {
         return hMower;
     }
     else if (mowerModal.includes('x3')) {
-        return x3Mower;
+        return hasEdger ? x3Edger : x3Mower;
     }
     return iMower;
 }
@@ -2207,12 +5153,12 @@ function getNoPositionMowerImageByModal(mowerModal) {
     }
     return iNoPosition;
 }
-function getMowerImage(positonConfig, modelType) {
+function getMowerImage(positonConfig, modelType, hasEdger) {
     if (!positonConfig)
         return '';
     const model = modelType?.toLowerCase() || 'i';
     const state = positonConfig.vehicleState;
-    const mowerImage = getMowerImageByModal(model);
+    const mowerImage = getMowerImageByModal(model, hasEdger);
     const disabledImage = getDisabledMowerImageByModal(model);
     const noPositionImage = getNoPositionMowerImageByModal(model);
     const positonOutOfRange = isOutOfRange(positonConfig);
@@ -2262,7 +5208,7 @@ var freeSelf = typeof self == 'object' && self && self.Object === Object && self
 var root = freeGlobal || freeSelf || Function('return this')();
 
 /** Built-in value references. */
-var Symbol = root.Symbol;
+var Symbol$1 = root.Symbol;
 
 /** Used for built-in method references. */
 var objectProto$9 = Object.prototype;
@@ -2278,7 +5224,7 @@ var hasOwnProperty$7 = objectProto$9.hasOwnProperty;
 var nativeObjectToString$1 = objectProto$9.toString;
 
 /** Built-in value references. */
-var symToStringTag$1 = Symbol ? Symbol.toStringTag : undefined;
+var symToStringTag$1 = Symbol$1 ? Symbol$1.toStringTag : undefined;
 
 /**
  * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.
@@ -2333,7 +5279,7 @@ var nullTag = '[object Null]',
     undefinedTag = '[object Undefined]';
 
 /** Built-in value references. */
-var symToStringTag = Symbol ? Symbol.toStringTag : undefined;
+var symToStringTag = Symbol$1 ? Symbol$1.toStringTag : undefined;
 
 /**
  * The base implementation of `getTag` without fallbacks for buggy environments.
@@ -2450,7 +5396,7 @@ function arrayMap(array, iteratee) {
 var isArray = Array.isArray;
 
 /** Used to convert symbols to primitives and strings. */
-var symbolProto = Symbol ? Symbol.prototype : undefined,
+var symbolProto = Symbol$1 ? Symbol$1.prototype : undefined,
     symbolToString = symbolProto ? symbolProto.toString : undefined;
 
 /**
@@ -4694,8 +7640,8 @@ var PathSegmentType;
  */
 var UnitsType;
 (function (UnitsType) {
-    UnitsType["Metric"] = "metric";
-    UnitsType["Imperial"] = "imperial";
+    UnitsType["Metric"] = "Metric";
+    UnitsType["Imperial"] = "Imperial";
 })(UnitsType || (UnitsType = {}));
 /**
  * 面积单位类型枚举
@@ -4982,6 +7928,12 @@ class BoundaryBorderLayer extends BaseLayer {
             this.mowingBoundarys = mowingBoundarys;
         }
     }
+    /**
+     * 获取当前割草任务的边界
+     */
+    getMowingBoundarys() {
+        return this.mowingBoundarys;
+    }
     /**
      * SVG渲染方法
      */
@@ -4990,13 +7942,31 @@ class BoundaryBorderLayer extends BaseLayer {
             return;
         }
         this.scale = scale;
-        console.log('draw boundary border->', this.elements, this.mowingBoundarys);
-        // 只渲染边界边框类型的元素
+        // 将元素分为两组：非割草边界和割草边界
+        const nonMowingElements = [];
+        const mowingElements = [];
+        // 只处理边界边框类型的元素
         for (const element of this.elements) {
             if (element.type === 'boundary_border') {
-                this.renderBoundaryBorder(svgGroup, element);
+                const { originalData } = element;
+                const { id } = originalData || {};
+                // 检查是否为割草边界
+                if (this.mowingBoundarys.includes(Number(id))) {
+                    mowingElements.push(element);
+                }
+                else {
+                    nonMowingElements.push(element);
+                }
             }
         }
+        // 先渲染非割草边界
+        for (const element of nonMowingElements) {
+            this.renderBoundaryBorder(svgGroup, element);
+        }
+        // 再渲染割草边界（放在最后）
+        for (const element of mowingElements) {
+            this.renderBoundaryBorder(svgGroup, element);
+        }
     }
     /**
      * 渲染边界边框
@@ -5801,7 +8771,7 @@ class MapDataProcessor {
                                 result.push(boundaryBorderElement);
                                 // 将边界边框存储到 store 中，以分区ID为key
                                 if (element.id) {
-                                    const { addSubBoundaryBorder } = useSubBoundaryBorderStore.getState();
+                                    const { addSubBoundaryBorder } = usePartitionDataStore.getState();
                                     addSubBoundaryBorder(element.id.toString(), {
                                         ...boundaryBorderElement,
                                     });
@@ -5820,7 +8790,7 @@ class MapDataProcessor {
                             const obstacleElement = ObstacleDataBuilder.fromMapElement(mapElement, this.mapConfig.obstacle);
                             if (obstacleElement) {
                                 result.push(obstacleElement);
-                                const { addObstacles } = useSubBoundaryBorderStore.getState();
+                                const { addObstacles } = usePartitionDataStore.getState();
                                 addObstacles(`obstacle-${obstacleElement.originalData.id}`, {
                                     ...obstacleElement,
                                 });
@@ -5873,6 +8843,7 @@ class MapDataProcessor {
                         break;
                     }
                     case 'TIME_LIMIT_OBSTACLE': {
+                        console.info('TIME_LIMIT_OBSTACLE', element);
                         try {
                             // 如果有SVG数据，直接创建SVG绘制元素
                             if ('svg' in element &&
@@ -5887,7 +8858,7 @@ class MapDataProcessor {
                                 const svgElement = SvgElementDataBuilder.fromMapElement(mapElement, this.mapConfig.doodle);
                                 if (svgElement) {
                                     result.push(svgElement);
-                                    const { addSvgElements } = useSubBoundaryBorderStore.getState();
+                                    const { addSvgElements } = usePartitionDataStore.getState();
                                     addSvgElements(`time-limit-obstacle-${svgElement.originalData.id}`, {
                                         ...svgElement,
                                     });
@@ -5902,7 +8873,7 @@ class MapDataProcessor {
                                 const polygonElement = ObstacleDataBuilder.createTimeLimitObstacle(mapElement, this.mapConfig.obstacle);
                                 if (polygonElement) {
                                     result.push(polygonElement);
-                                    const { addObstacles } = useSubBoundaryBorderStore.getState();
+                                    const { addObstacles } = usePartitionDataStore.getState();
                                     addObstacles(`time-limit-obstacle-${polygonElement.originalData.id}`, {
                                         ...polygonElement,
                                     });
@@ -6065,7 +9036,7 @@ class PathDataProcessor {
  * 专门处理边界标签的创建、定位和管理
  */
 class BoundaryLabelsManager {
-    constructor(svgView, boundaryData) {
+    constructor(svgView, boundaryData, { unitType, language }) {
         this.container = null;
         this.overlayDiv = null;
         this.globalClickHandler = null;
@@ -6076,6 +9047,8 @@ class BoundaryLabelsManager {
         this.svgView = svgView;
         this.boundaryData = boundaryData;
         this.initializeContainer();
+        this.unitType = unitType;
+        this.language = language;
     }
     /**
      * 初始化容器
@@ -6141,7 +9114,7 @@ class BoundaryLabelsManager {
         labelDiv.setAttribute('data-boundary-id', boundary.id.toString());
         // 样式设置
         labelDiv.style.position = 'absolute';
-        labelDiv.style.backgroundColor = 'rgba(30, 30, 31, 0.3)';
+        labelDiv.style.backgroundColor = 'rgba(30, 30, 31, 0.6)';
         labelDiv.style.color = 'rgba(255, 255, 255, 1)';
         labelDiv.style.padding = '6px';
         labelDiv.style.borderRadius = '12px';
@@ -6158,7 +9131,7 @@ class BoundaryLabelsManager {
         labelDiv.style.zIndex = BoundaryLabelsManager.Z_INDEX.DEFAULT.toString();
         // 计算进度
         const progress = boundary.finishedArea && boundary.area
-            ? `${Math.round((boundary.finishedArea / boundary.area) * 100)}%`
+            ? `${Math.floor((boundary.finishedArea / boundary.area) * 100)}%`
             : '0%';
         // 基础内容（始终显示）
         const baseContent = document.createElement('div');
@@ -6175,12 +9148,15 @@ class BoundaryLabelsManager {
             this.currentExpandedBoundaryId === boundary.id ? 'block' : 'none';
         extendedContent.style.borderTop = '1px solid rgba(255,255,255,0.2)';
         extendedContent.style.paddingTop = '6px';
+        const boundaryLayer = this.svgView.getLayer(LAYER_DEFAULT_TYPE.BOUNDARY_BORDER);
+        const mowingBoundarys = boundaryLayer.getMowingBoundarys();
         // 面积信息
-        const totalArea = convertAreaByUnits(boundary.area || 0, 'metric');
-        const finishedArea = convertAreaByUnits(boundary.finishedArea || 0, 'metric');
+        const totalArea = convertAreaByUnits(boundary.area || 0, this.unitType);
+        const finishedArea = convertAreaByUnits(boundary.finishedArea || 0, this.unitType);
         const coverageText = `Coverage: ${finishedArea.value}/${totalArea.value}`;
+        const isMowing = mowingBoundarys.includes(boundary.id);
         // 日期信息
-        const dateText = formatBoundaryDateText(boundary.endTime || 0);
+        const dateText = formatBoundaryDateText(isMowing ? Date.now() / 1000 : boundary.endTime || 0);
         const covertHtml = `<div style="margin-bottom: 3px; font-weight: bold;">${coverageText}</div>`;
         const dateHtml = `<div>${dateText}</div>`;
         extendedContent.innerHTML = boundary.finishedArea > 0 ? `${covertHtml}${dateHtml}` : covertHtml;
@@ -6298,7 +9274,6 @@ class BoundaryLabelsManager {
             // 计算边界中心点的地图坐标
             const mapCenter = this.calculatePolygonCentroid(boundary.points);
             if (!mapCenter) {
-                console.warn(`BoundaryLabelsManager: 无法计算边界 ${boundary.name} (ID: ${boundary.id}) 的中心点`);
                 return;
             }
             // 直接使用预计算的数据进行坐标转换
@@ -6383,7 +9358,6 @@ class BoundaryLabelsManager {
         area = area / 2;
         // 如果面积为0，回退到简单的平均值计算
         if (Math.abs(area) < 1e-10) {
-            console.warn('BoundaryLabelsManager: 多边形面积为0，使用平均值计算重心');
             return this.calculateAverageCenter(validPoints);
         }
         centroidX = centroidX / (6 * area);
@@ -7294,6 +10268,10 @@ class MowerPositionManager {
     getElement() {
         return this.container;
     }
+    //
+    setEdger(edger) {
+        this.hasEdger = edger;
+    }
     /**
      * 根据最后一次有效的位置更新数据
      */
@@ -7317,7 +10295,6 @@ class MowerPositionManager {
             postureY = chargingPilesPositionConfig.postureY || 0;
             postureTheta = chargingPilesPositionConfig.postureTheta || 0;
         }
-        console.log('updatePositionByLastPosition->', postureX, postureY, postureTheta, chargingPilesPositionConfig);
         // 检查是否需要更新图片
         this.updateMowerImage(chargingPilesPositionConfig);
         // 立即更新位置
@@ -7334,7 +10311,6 @@ class MowerPositionManager {
         const postureX = positionConfig?.postureX || this.lastPosition?.x || 0;
         const postureY = positionConfig?.postureY || this.lastPosition?.y || 0;
         const postureTheta = positionConfig?.postureTheta || this.lastPosition?.rotation || 0;
-        console.log('updatePosition  manager', JSON.stringify(this.currentPosition), this.currentPosition, !this.currentPosition, positionConfig, this.lastPosition, animationTime);
         // 停止当前动画（如果有）
         this.stopAnimation();
         // 第一个点
@@ -7344,7 +10320,6 @@ class MowerPositionManager {
                 y: postureY,
                 rotation: postureTheta,
             };
-            console.log('updatePosition first->', this.currentPosition);
             this.setElementPosition(this.currentPosition.x, this.currentPosition.y, this.currentPosition.rotation);
             return;
         }
@@ -7366,7 +10341,7 @@ class MowerPositionManager {
         const imgElement = this.mowerElement.querySelector('img');
         if (!imgElement)
             return;
-        const imageSrc = getMowerImage(positonConfig, this.modelType);
+        const imageSrc = getMowerImage(positonConfig, this.modelType, this.hasEdger);
         if (imageSrc) {
             imgElement.src = imageSrc;
             imgElement.style.display = 'block';
@@ -7453,12 +10428,10 @@ class MowerPositionManager {
             y: this.onlyUpdateTheta ? 0 : this.targetPosition.y - this.startPosition.y,
             rotation: radNormalize(targetTheta - startTheta),
         };
-        console.log('startAnimationToPosition-->', this.deltaPosition, this.onlyUpdateTheta, this.targetPosition, this.startPosition);
         // 开始动画循环
         this.animateStep();
     }
     forceUpdatePosition() {
-        console.log('forceUpdatePosition-->', this.currentPosition, this.targetPosition, this.startPosition);
         this.animateStep();
     }
     /**
@@ -7553,13 +10526,6 @@ class MowerPositionManager {
     }
 }
 
-// 记录割草状态，状态变更的时候，变量不触发重新渲染
-const useProcessMowingState = create((set) => ({
-    processStateIsMowing: false,
-    updateProcessStateIsMowing: (isMowing) => set({ processStateIsMowing: isMowing }),
-    resetProcessStateIsMowing: () => set({ processStateIsMowing: false }),
-}));
-
 /**
  * 高级节流函数
  * @param func 要节流的函数
@@ -7599,15 +10565,52 @@ function throttleAdvanced(func, delay, options = { leading: true, trailing: true
         }
     };
 }
+/**
+ * 检测当前设备是否为移动设备
+ * @returns {boolean} 如果是移动设备返回true，否则返回false
+ */
+function isMobileDevice() {
+    // 确保在浏览器环境中运行
+    if (typeof window === 'undefined' || typeof navigator === 'undefined') {
+        return false;
+    }
+    // 检查用户代理字符串
+    const userAgent = navigator.userAgent.toLowerCase();
+    const mobileKeywords = [
+        'android', 'webos', 'iphone', 'ipad', 'ipod',
+        'blackberry', 'windows phone', 'mobile'
+    ];
+    const isMobileUserAgent = mobileKeywords.some(keyword => userAgent.includes(keyword));
+    // 检查触摸屏支持
+    const hasTouchScreen = 'ontouchstart' in window ||
+        (navigator.maxTouchPoints && navigator.maxTouchPoints > 0);
+    // 检查屏幕尺寸（移动设备通常屏幕较小）
+    const isSmallScreen = window.innerWidth <= 768;
+    // 综合判断：用户代理包含移动设备关键词，或者有触摸屏且屏幕较小
+    return isMobileUserAgent || (hasTouchScreen && isSmallScreen);
+}
+
+// 记录割草状态，状态变更的时候，变量不触发重新渲染
+const useCurrentMowingDataStore = create((set) => ({
+    // 当前进度数据返回的割草状态是否为在割草
+    processStateIsMowing: false,
+    updateProcessStateIsMowing: (isMowing) => set({ processStateIsMowing: isMowing }),
+    resetProcessStateIsMowing: () => set({ processStateIsMowing: false }),
+    // 当前割草的分区id
+    currentMowingPartitionId: '',
+    updateCurrentMowingPartitionId: (partitionId) => set({ currentMowingPartitionId: partitionId }),
+    resetCurrentMowingPartitionId: () => set({ currentMowingPartitionId: '' }),
+}));
 
 // Google Maps 叠加层类 - 带编辑功能
 class MowerMapOverlay {
-    constructor(bounds, mapData, partitionBoundary, mowerPositionConfig, modelType, pathData, isEditMode = false, mapConfig = {}, antennaConfig = {}, mowPartitionData = null, defaultTransform, onMapLoad, onPathLoad, dragCallbacks) {
+    constructor(bounds, mapData, partitionBoundary, mowerPositionConfig, modelType, pathData, isEditMode = false, unitType = UnitsType.Imperial, language = 'en', mapConfig = {}, antennaConfig = {}, mowPartitionData = null, defaultTransform, onMapLoad, onPathLoad, dragCallbacks) {
         this.div = null;
         this.svgMapView = null;
         this.offscreenContainer = null;
         this.overlayView = null;
         this.defaultTransform = { x: 0, y: 0, rotation: 0 };
+        this.hasEdger = false;
         // boundary数据
         this.boundaryData = [];
         // 边界标签管理器
@@ -7650,6 +10653,8 @@ class MowerMapOverlay {
         this.partitionBoundary = partitionBoundary;
         this.pathData = pathData;
         this.isEditMode = isEditMode;
+        this.unitType = unitType;
+        this.language = language;
         this.mapConfig = mapConfig;
         this.antennaConfig = antennaConfig;
         this.onMapLoad = onMapLoad;
@@ -7696,7 +10701,6 @@ class MowerMapOverlay {
         this.isUserAnimation = animationTime > 0;
         // 更新割草机位置配置
         this.mowerPositionConfig = positionConfig;
-        console.log('updatePosition  overlay', positionConfig);
         // 更新割草机位置管理器
         if (this.mowerPositionManager) {
             this.mowerPositionManager.updatePosition(positionConfig, animationTime);
@@ -7714,6 +10718,12 @@ class MowerMapOverlay {
             this.overlayView.setMap(map);
         }
     }
+    setEdger(edger) {
+        this.hasEdger = edger;
+        if (this.mowerPositionManager) {
+            this.mowerPositionManager.setEdger(edger);
+        }
+    }
     getMap() {
         return this.overlayView ? this.overlayView.getMap() : null;
     }
@@ -7741,7 +10751,6 @@ class MowerMapOverlay {
         this.svgMapView?.renderLayer(LAYER_DEFAULT_TYPE.BOUNDARY_BORDER);
     }
     onAdd() {
-        console.log('onAdd');
         // 创建包含SVG的div
         this.div = document.createElement('div');
         this.div.style.borderStyle = 'none';
@@ -7809,7 +10818,10 @@ class MowerMapOverlay {
         if (!this.div || !this.svgMapView)
             return;
         // 创建边界标签管理器
-        this.boundaryLabelsManager = new BoundaryLabelsManager(this.svgMapView, this.boundaryData);
+        this.boundaryLabelsManager = new BoundaryLabelsManager(this.svgMapView, this.boundaryData, {
+            unitType: this.unitType,
+            language: this.language,
+        });
         // 设置叠加层div引用
         this.boundaryLabelsManager.setOverlayDiv(this.div);
         // 添加所有边界标签
@@ -7853,11 +10865,10 @@ class MowerMapOverlay {
         if (!this.div || !this.svgMapView)
             return;
         // 创建割草机位置管理器，传入动画完成回调
-        this.mowerPositionManager = new MowerPositionManager(this.svgMapView, this.mowerPositionConfig, this.modelType, this.div, () => {
-            console.log('动画完成');
-        }, this.updatePathDataByMowingPositionThrottled.bind(this));
+        this.mowerPositionManager = new MowerPositionManager(this.svgMapView, this.mowerPositionConfig, this.modelType, this.div, () => { }, this.updatePathDataByMowingPositionThrottled.bind(this));
         // 设置叠加层div引用
         this.mowerPositionManager.setOverlayDiv(this.div);
+        this.mowerPositionManager.setEdger(this.hasEdger);
         // 获取容器并添加到主div
         const container = this.mowerPositionManager.getElement();
         if (container) {
@@ -7937,7 +10948,7 @@ class MowerMapOverlay {
         this.rotateHandle.style.pointerEvents = 'auto';
         this.rotateHandle.innerHTML = DEFAULT_ROTATE_ICON;
         this.editContainer.appendChild(this.rotateHandle);
-        // 创建拖拽手柄（左上角）
+        // 创建拖拽手柄（左下角）- 仅在移动设备上显示
         this.dragHandle = document.createElement('div');
         this.dragHandle.style.position = 'absolute';
         this.dragHandle.style.bottom = '-20px';
@@ -7948,6 +10959,10 @@ class MowerMapOverlay {
         this.dragHandle.style.zIndex = EDIT_STYLES.Z_INDEX.HANDLE;
         this.dragHandle.style.pointerEvents = 'auto';
         this.dragHandle.innerHTML = DEFAULT_DRAG_ICON;
+        // 在PC设备上隐藏拖拽手柄
+        if (!isMobileDevice()) {
+            this.dragHandle.style.display = 'none';
+        }
         this.editContainer.appendChild(this.dragHandle);
         // 将编辑容器添加到主div
         this.div.appendChild(this.editContainer);
@@ -7989,7 +11004,6 @@ class MowerMapOverlay {
                 this.boundaryLabelsManager.collapseAllLabels();
             }
             this.dragCallbacks?.onDragStart?.(this.getCurrentDragState());
-            console.log('开始旋转操作');
         });
         // 旋转手柄的触摸事件
         this.rotateHandle.addEventListener('touchstart', (e) => {
@@ -8005,39 +11019,41 @@ class MowerMapOverlay {
                 this.boundaryLabelsManager.collapseAllLabels();
             }
             this.dragCallbacks?.onDragStart?.(this.getCurrentDragState());
-            console.log('开始旋转操作（触摸）');
-        }, { passive: false });
-        // 拖拽手柄的鼠标事件
-        this.dragHandle.addEventListener('mousedown', (e) => {
-            e.preventDefault();
-            e.stopPropagation();
-            e.stopImmediatePropagation();
-            this.isDragging = true;
-            this.startPos = { x: e.clientX, y: e.clientY };
-            this.dragHandle.style.cursor = 'grabbing';
-            // 开始编辑时关闭所有展开的边界标签
-            if (this.boundaryLabelsManager) {
-                this.boundaryLabelsManager.collapseAllLabels();
-            }
-            this.dragCallbacks?.onDragStart?.(this.getCurrentDragState());
-            console.log('开始拖动操作（通过手柄）');
-        });
-        // 拖拽手柄的触摸事件
-        this.dragHandle.addEventListener('touchstart', (e) => {
-            e.preventDefault();
-            e.stopPropagation();
-            e.stopImmediatePropagation();
-            this.isDragging = true;
-            const touch = e.touches[0];
-            this.startPos = { x: touch.clientX, y: touch.clientY };
-            this.dragHandle.style.cursor = 'grabbing';
-            this.dragCallbacks?.onDragStart?.(this.getCurrentDragState());
-            console.log('开始拖动操作（通过手柄，触摸）');
         }, { passive: false });
+        // 拖拽手柄的鼠标事件 - 仅在移动设备上启用
+        if (isMobileDevice()) {
+            this.dragHandle.addEventListener('mousedown', (e) => {
+                e.preventDefault();
+                e.stopPropagation();
+                e.stopImmediatePropagation();
+                this.isDragging = true;
+                this.startPos = { x: e.clientX, y: e.clientY };
+                this.dragHandle.style.cursor = 'grabbing';
+                // 开始编辑时关闭所有展开的边界标签
+                if (this.boundaryLabelsManager) {
+                    this.boundaryLabelsManager.collapseAllLabels();
+                }
+                this.dragCallbacks?.onDragStart?.(this.getCurrentDragState());
+            });
+            // 拖拽手柄的触摸事件
+            this.dragHandle.addEventListener('touchstart', (e) => {
+                e.preventDefault();
+                e.stopPropagation();
+                e.stopImmediatePropagation();
+                this.isDragging = true;
+                const touch = e.touches[0];
+                this.startPos = { x: touch.clientX, y: touch.clientY };
+                this.dragHandle.style.cursor = 'grabbing';
+                this.dragCallbacks?.onDragStart?.(this.getCurrentDragState());
+            }, { passive: false });
+        }
         // 编辑容器的鼠标事件（整个区域拖拽）
         this.editContainer.addEventListener('mousedown', (e) => {
-            console.log('开始拖动操作（整个叠加层）');
-            if (e.target === this.dragHandle || e.target === this.rotateHandle) {
+            // 在移动设备上，检查是否点击了拖拽手柄或旋转手柄
+            // 在PC设备上，只检查旋转手柄（拖拽手柄已隐藏）
+            const isDragHandleClick = isMobileDevice() && e.target === this.dragHandle;
+            const isRotateHandleClick = e.target === this.rotateHandle;
+            if (isDragHandleClick || isRotateHandleClick) {
                 return;
             }
             e.preventDefault();
@@ -8054,8 +11070,11 @@ class MowerMapOverlay {
         });
         // 编辑容器的触摸事件（整个区域拖拽）
         this.editContainer.addEventListener('touchstart', (e) => {
-            console.log('开始拖动操作（整个叠加层，触摸）');
-            if (e.target === this.dragHandle || e.target === this.rotateHandle) {
+            // 在移动设备上，检查是否点击了拖拽手柄或旋转手柄
+            // 在PC设备上，只检查旋转手柄（拖拽手柄已隐藏）
+            const isDragHandleClick = isMobileDevice() && e.target === this.dragHandle;
+            const isRotateHandleClick = e.target === this.rotateHandle;
+            if (isDragHandleClick || isRotateHandleClick) {
                 return;
             }
             e.preventDefault();
@@ -8115,7 +11134,6 @@ class MowerMapOverlay {
                 e.preventDefault();
                 e.stopPropagation();
                 e.stopImmediatePropagation();
-                console.log('结束编辑操作');
             }
             // 如果是拖拽结束，将像素偏移量转换为地理坐标偏移量
             if (this.isDragging) {
@@ -8137,7 +11155,6 @@ class MowerMapOverlay {
                 e.preventDefault();
                 e.stopPropagation();
                 e.stopImmediatePropagation();
-                console.log('结束编辑操作（触摸）');
             }
             // 如果是拖拽结束，将像素偏移量转换为地理坐标偏移量
             if (this.isDragging) {
@@ -8249,7 +11266,6 @@ class MowerMapOverlay {
         this.div.style.transform = transform;
         // 更新鼠标起始位置为当前位置，为下次计算做准备
         this.startPos = { x: mouseCurrentX, y: mouseCurrentY };
-        console.log('旋转角度:', this.currentRotation, '角度增量:', angleDifferenceDegrees);
     }
     // 将像素偏移量转换为地理坐标偏移量
     convertPixelOffsetToLatLng() {
@@ -8279,14 +11295,6 @@ class MowerMapOverlay {
         // 累积更新地理坐标偏移量（不是直接赋值！）
         this.latLngOffset.lat += latOffset;
         this.latLngOffset.lng += lngOffset;
-        console.log('精确转换偏移量:', {
-            pixelOffset: this.tempPixelOffset,
-            centerLatLng: { lat: centerLatLng.lat(), lng: centerLatLng.lng() },
-            offsetLatLng: { lat: offsetLatLng.lat(), lng: offsetLatLng.lng() },
-            latOffset,
-            lngOffset,
-            newLatLngOffset: this.latLngOffset,
-        });
         // 重置临时像素偏移量
         this.tempPixelOffset = { x: 0, y: 0 };
         this.draw();
@@ -8324,8 +11332,6 @@ class MowerMapOverlay {
             editData: editData,
             timestamp: new Date().toISOString(),
         };
-        // 在这里可以添加保存逻辑，比如发送到服务器
-        console.log('保存编辑数据:', saveData);
         // 显示保存成功提示
         this.showSaveSuccess();
         return saveData;
@@ -8418,6 +11424,9 @@ class MowerMapOverlay {
             y: transform.y,
             rotation: transform.rotation,
         };
+        // defaultTransform的x对应经度偏移量，y对应纬度偏移量
+        this.latLngOffset.lng = this.defaultTransform.x;
+        this.latLngOffset.lat = this.defaultTransform.y;
         this.setManagerRotation(this.currentRotation);
         this.draw();
     }
@@ -8457,7 +11466,6 @@ class MowerMapOverlay {
             if (this.pathData && this.svgMapView) {
                 this.loadPathData(this.pathData, this.mowPartitionData);
             }
-            console.log('initializeSvgMapView');
             // 刷新绘制图层
             this.svgMapView.refresh();
             // 获取生成的SVG并添加到叠加层div中
@@ -8574,8 +11582,10 @@ class MowerMapOverlay {
      */
     updatePathDataByMowingPosition(position) {
         // 找到当前position所在的分区id，将该点更新到pathData中
-        const currentPartitionId = getPartitionId(this.partitionBoundary, position.x, position.y);
-        const processStateIsMowing = useProcessMowingState.getState().processStateIsMowing;
+        // 先查找当前的分区id是多少，然后确定当前的点是否在当前分区id中，如果不在，则重新获取分区id并重新设置
+        const currentPartitionId = useCurrentMowingDataStore.getState().currentMowingPartitionId;
+        console.info('updatePathDataByMowingPosition==currentPartitionId=================', currentPartitionId);
+        const processStateIsMowing = useCurrentMowingDataStore.getState().processStateIsMowing;
         if (currentPartitionId && this.pathData?.[currentPartitionId]) {
             const currentPathData = this.pathData[currentPartitionId];
             this.pathData[currentPartitionId] = {
@@ -8613,7 +11623,6 @@ class MowerMapOverlay {
         this.boundaryLabelsManager?.updateBoundaryData(boundaryData);
     }
     draw() {
-        console.log('ondraw');
         // 防御性检查：如果this.div为null，说明onAdd还没被调用，直接返回
         if (!this.div) {
             return;
@@ -8881,7 +11890,7 @@ const getValidGpsBounds = (mapData, rotation = 0) => {
 // 默认配置
 const defaultMapConfig = DEFAULT_STYLES;
 // 地图渲染器组件
-const MowerMapRenderer = React.forwardRef(({ mapConfig, modelType, mapRef, mapJson, pathJson, realTimeData, antennaConfig, onMapLoad, onPathLoad, onError, className, style, googleMapInstance, isEditMode = false, dragCallbacks, defaultTransform, debug = false, }, ref) => {
+const MowerMapRenderer = React.forwardRef(({ edger = false, unitType = UnitsType.Imperial, language = 'en', mapConfig, modelType, mapRef, mapJson, pathJson, realTimeData, antennaConfig, onMapLoad, onPathLoad, onError, className, style, googleMapInstance, isEditMode = false, dragCallbacks, defaultTransform, debug = false, }, ref) => {
     const [elementCount, setElementCount] = React.useState(0);
     const [pathCount, setPathCount] = React.useState(0);
     const [currentError, setCurrentError] = React.useState(null);
@@ -8889,9 +11898,10 @@ const MowerMapRenderer = React.forwardRef(({ mapConfig, modelType, mapRef, mapJs
     // const mapRef = useMap();
     const [isGoogleMapsReady, setIsGoogleMapsReady] = React.useState(false);
     const [hasInitializedBounds, setHasInitializedBounds] = React.useState(false);
-    const { clearSubBoundaryBorder, clearObstacles } = useSubBoundaryBorderStore();
+    const { clearSubBoundaryBorder, clearObstacles, clearSvgElements } = usePartitionDataStore();
+    const { resetCurrentMowingPartitionId } = useCurrentMowingDataStore();
     const currentProcessMowingStatusRef = React.useRef(false);
-    const { updateProcessStateIsMowing, processStateIsMowing } = useProcessMowingState();
+    const { updateProcessStateIsMowing, processStateIsMowing, updateCurrentMowingPartitionId, currentMowingPartitionId, } = useCurrentMowingDataStore();
     const [mowPartitionData, setMowPartitionData] = React.useState(null);
     // Debug相关状态
     const [debugInfo, setDebugInfo] = React.useState({});
@@ -8923,7 +11933,7 @@ const MowerMapRenderer = React.forwardRef(({ mapConfig, modelType, mapRef, mapJs
                 postureX: 0,
                 postureY: 0,
                 postureTheta: 0,
-                vehicleState: RobotStatus.PARKED,
+                vehicleState: RobotStatus.DISCONNECTED,
             };
         let currentPositionData;
         if (realTimeData.length === 1 && realTimeData[0].type === RealTimeDataType.LOCATION) {
@@ -8949,10 +11959,9 @@ const MowerMapRenderer = React.forwardRef(({ mapConfig, modelType, mapRef, mapJs
             lastPostureY: currentPositionData?.lastPostureY
                 ? Number(currentPositionData.lastPostureY)
                 : 0,
-            vehicleState: currentPositionData?.vehicleState || RobotStatus.CHARGING,
+            vehicleState: currentPositionData?.vehicleState || RobotStatus.DISCONNECTED,
         };
     }, [realTimeData, modelType]);
-    console.log('mowerPositionData', mowerPositionData);
     // 处理错误
     const handleError = (error) => {
         setCurrentError(error);
@@ -8977,7 +11986,6 @@ const MowerMapRenderer = React.forwardRef(({ mapConfig, modelType, mapRef, mapJs
         const googleBounds = new window.google.maps.LatLngBounds(new window.google.maps.LatLng(swLat, swLng), // 西南角
         new window.google.maps.LatLng(neLat, neLng) // 东北角
         );
-        console.log('fitBounds----->', googleBounds);
         mapRef.fitBounds(googleBounds);
     }, [mapJson, mapRef, defaultTransform]);
     // 初始化Google Maps叠加层
@@ -9018,9 +12026,8 @@ const MowerMapRenderer = React.forwardRef(({ mapConfig, modelType, mapRef, mapJs
                 overlayRef.current.setMap(null);
                 overlayRef.current = null;
             }
-            console.log('initializeGoogleMapsOverlay', mowPartitionData);
             // 创建叠加层
-            const overlay = new MowerMapOverlay(googleBounds, mapJson, partitionBoundary, mowerPositionData, modelType, pathJson || {}, isEditMode, mergedMapConfig, mergedAntennaConfig, null, defaultTransform, (count) => {
+            const overlay = new MowerMapOverlay(googleBounds, mapJson, partitionBoundary, mowerPositionData, modelType, pathJson || {}, isEditMode, unitType, language, mergedMapConfig, mergedAntennaConfig, null, defaultTransform, (count) => {
                 setElementCount(count);
                 onMapLoad?.(count);
             }, (count) => {
@@ -9030,6 +12037,7 @@ const MowerMapRenderer = React.forwardRef(({ mapConfig, modelType, mapRef, mapJs
             // 设置地图
             overlay.setMap(mapInstance);
             overlayRef.current = overlay;
+            overlay.setEdger(edger);
             // 只在首次初始化时自适应视图
             if (!hasInitializedBounds) {
                 mapInstance.fitBounds(googleBounds);
@@ -9053,7 +12061,7 @@ const MowerMapRenderer = React.forwardRef(({ mapConfig, modelType, mapRef, mapJs
             postureY: chargingPiles?.originalData.position[1],
             postureTheta: chargingPiles?.originalData.direction - Math.PI || 0,
         }, 0);
-    }, [mapJson]);
+    }, [mapJson, mowerPositionData]);
     // 初始化效果
     React.useEffect(() => {
         initializeGoogleMapsOverlay();
@@ -9061,6 +12069,8 @@ const MowerMapRenderer = React.forwardRef(({ mapConfig, modelType, mapRef, mapJs
         return () => {
             clearSubBoundaryBorder();
             clearObstacles();
+            clearSvgElements();
+            resetCurrentMowingPartitionId();
             updateProcessStateIsMowing(false);
             currentProcessMowingStatusRef.current = false;
             if (overlayRef.current) {
@@ -9092,7 +12102,6 @@ const MowerMapRenderer = React.forwardRef(({ mapConfig, modelType, mapRef, mapJs
         const isOffLine = mowerPositionData.vehicleState === RobotStatus.DISCONNECTED;
         const isInChargingPile = inChargingPiles.includes(mowerPositionData.vehicleState);
         // 如果在充电桩上，则直接更新位置到充电桩的位置
-        console.log('usefeect mowerPositionData----->', mowerPositionData);
         if (isInChargingPile) {
             overlayRef.current.updatePosition({
                 ...mowerPositionData,
@@ -9125,7 +12134,6 @@ const MowerMapRenderer = React.forwardRef(({ mapConfig, modelType, mapRef, mapJs
                 }
             }
             else {
-                console.log('hook updatePosition----->', mowerPositionData);
                 overlayRef.current.updatePosition(mowerPositionData, isStandby ? 0 : 2000);
             }
         }
@@ -9244,7 +12252,6 @@ const MowerMapRenderer = React.forwardRef(({ mapConfig, modelType, mapRef, mapJs
         if (!realTimeData || realTimeData.length === 0 || !Array.isArray(realTimeData)) {
             return;
         }
-        console.log('usefeect realTimeData----->', realTimeData, mapJson, pathJson, overlayRef.current);
         let curMowPartitionData = mowPartitionData;
         // realtime中包含当前割草任务的数据，根据数据进行path路径和边界的高亮操作,
         const mowingPartition = realTimeData.find((item) => item.type === RealTimeDataType.PARTITION);
@@ -9252,9 +12259,8 @@ const MowerMapRenderer = React.forwardRef(({ mapConfig, modelType, mapRef, mapJs
             setMowPartitionData(mowingPartition);
             curMowPartitionData = mowingPartition;
         }
-        const positionData = realTimeData?.find(item => item?.type === RealTimeDataType.LOCATION);
-        const statusData = realTimeData?.find(item => item?.type === RealTimeDataType.STATUS);
-        console.log('current->1', positionData, statusData);
+        const positionData = realTimeData?.find((item) => item?.type === RealTimeDataType.LOCATION);
+        const statusData = realTimeData?.find((item) => item?.type === RealTimeDataType.STATUS);
         if (statusData || positionData) {
             const currentStatus = statusData?.vehicleState || positionData?.vehicleState;
             // 车辆回桩不会回传最后的park的位置，所以根据实时数据的状态数据判断车辆回到桩上
@@ -9264,32 +12270,28 @@ const MowerMapRenderer = React.forwardRef(({ mapConfig, modelType, mapRef, mapJs
             else if (currentStatus === RobotStatus.WORKING) {
                 // 兜底收不到割草地块的实时数据，使用状态来兜底
                 overlayRef.current.resetBorderLayerHighlight();
-                setMowPartitionData(null);
-                curMowPartitionData = null;
+                setMowPartitionData({});
+                curMowPartitionData = {};
             }
-            else if (currentStatus === RobotStatus.MOWING && (curMowPartitionData && !curMowPartitionData?.partitionIds)) {
+            else if (currentStatus === RobotStatus.MOWING &&
+                curMowPartitionData &&
+                !curMowPartitionData?.partitionIds) {
                 // 如果当前是割草状态，但是地块数据初始化过且不存在则认为是全局割草，则把所有地块都高亮
-                const allPartitionIds = mapJson?.sub_maps?.map(item => item?.id);
-                console.log('allPartitionIds->', allPartitionIds, mapJson);
+                const allPartitionIds = mapJson?.sub_maps?.map((item) => item?.id);
                 setMowPartitionData({
-                    partitionIds: allPartitionIds
+                    partitionIds: allPartitionIds,
                 });
                 curMowPartitionData = {
-                    partitionIds: allPartitionIds
+                    partitionIds: allPartitionIds,
                 };
             }
         }
-        if (!mapJson ||
-            !pathJson ||
-            !overlayRef.current)
+        if (!mapJson || !pathJson || !overlayRef.current)
             return;
         // 根据后端推送的实时数据，进行不同处理
-        // TODO：需要根据返回的数据，处理车辆的移动位置
-        console.log('realTimeData----->', realTimeData, curMowPartitionData);
         if (curMowPartitionData) {
             const isMowing = curMowPartitionData?.partitionIds && curMowPartitionData.partitionIds.length > 0;
             overlayRef.current.updateMowPartitionData(curMowPartitionData);
-            console.log('isMowing', isMowing, curMowPartitionData);
             if (!isMowing) {
                 overlayRef.current.resetBorderLayerHighlight();
             }
@@ -9297,28 +12299,36 @@ const MowerMapRenderer = React.forwardRef(({ mapConfig, modelType, mapRef, mapJs
                 overlayRef.current.setBorderLayerHighlight(curMowPartitionData);
             }
         }
+        // 处理实时路径数据
         // 如果一次性推送的是多条数据，则把多条数据处理后存入pathData，然后更新路径数据和边界标签信息
-        // 如果一次只推送一条数据，则只解析里面的进度数据，然后更新边界标签信息，剩下的实时轨迹数据由车辆运动产生时存入pathData
+        // 如果一次只推送一条数据，则只解析里面的进度数据，然后更新边界标签信息，剩下的实时轨迹数据由车辆运动产生时存入pathData（在MowerMapOverlay中updatePathDataByMowingPosition处理）
         if (realTimeData.length > 1) {
-            const { pathData, isMowing } = handleMultipleRealTimeData({
+            const { pathData, isMowing, currentMowingPartition } = handleMultipleRealTimeData({
                 realTimeData,
                 isMowing: processStateIsMowing,
                 pathData: pathJson,
-                partitionBoundary,
+                currentMowingPartition: currentMowingPartitionId,
             });
             updateProcessStateIsMowing(isMowing);
+            if (currentMowingPartition !== currentMowingPartitionId) {
+                updateCurrentMowingPartitionId(currentMowingPartition);
+            }
             if (pathData) {
                 overlayRef.current.updatePathData(pathData, curMowPartitionData);
                 overlayRef.current.updateBoundaryLabelInfo(pathData);
             }
         }
         else {
-            const { isMowing, pathData } = getProcessMowingDataFromRealTimeData({
+            const { isMowing, pathData, currentMowingPartition } = getProcessMowingDataFromRealTimeData({
                 realTimeData,
                 isMowing: processStateIsMowing,
                 pathData: pathJson,
+                currentMowingPartition: currentMowingPartitionId,
             });
             updateProcessStateIsMowing(isMowing);
+            if (currentMowingPartition !== currentMowingPartitionId) {
+                updateCurrentMowingPartitionId(currentMowingPartition);
+            }
             overlayRef.current.updatePathData(pathData, curMowPartitionData);
             // 更新进度数据
             if (pathData) {
@@ -9327,7 +12337,6 @@ const MowerMapRenderer = React.forwardRef(({ mapConfig, modelType, mapRef, mapJs
         }
     }, [realTimeData, mapJson, pathJson]);
     React.useEffect(() => {
-        console.log('defaultTransform----->', defaultTransform, overlayRef.current, mapJson);
         if (!overlayRef.current || !defaultTransform)
             return;
         overlayRef.current?.setTransform(defaultTransform);
@@ -9342,6 +12351,11 @@ const MowerMapRenderer = React.forwardRef(({ mapConfig, modelType, mapRef, mapJs
         );
         mapRef.fitBounds(googleBounds);
     }, [defaultTransform]);
+    React.useEffect(() => {
+        if (!overlayRef || !overlayRef.current)
+            return;
+        overlayRef.current.setEdger(edger);
+    }, [edger]);
     // 提供ref方法
     React.useImperativeHandle(ref, () => ({
         fitToView: () => {