@kimap/indoor-positioning-sdk-vue2 4.2.5 → 4.2.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kimap/indoor-positioning-sdk-vue2",
-  "version": "4.2.5",
+  "version": "4.2.6",
   "description": "Vue2自包含室内定位SDK - 完全兼容Webpack3+Babel6 | Vue2 Self-Contained Indoor Positioning SDK",
   "main": "index.js",
   "files": [

package/src/KMUtil.js

@@ -39,10 +39,12 @@
 
     // 遍历所有图层
     floorData.layers.forEach(function (layer) {
-      if (!layer.visible || !layer.elements) return;
+      // 只跳过明确设置为不可见的图层（visible === false），undefined视为可见
+      if (layer.visible === false || !layer.elements) return;
 
       layer.elements.forEach(function (element) {
-        if (!element.visible) return;
+        // 只跳过明确设置为不可见的元素（visible === false），undefined视为可见
+        if (element.visible === false) return;
 
         // 检查是否可穿行
         var passable = element.passable === true;
@@ -50,19 +52,32 @@
         // 处理墙体（始终作为障碍物）
         if (element.type === 'wall') {
           if (element.points && element.points.length >= 2) {
-            // thickness是毫米，转换为米
-            var thickness = (element.thickness || 100) / 1000;
-            var halfThickness = thickness / 2;
+            // thickness: 如果是米单位（< 1），直接使用；如果是毫米（>= 1），转换为米
+            var thickness = element.thickness;
+            if (thickness >= 1) {
+              thickness = thickness / 1000; // 毫米 → 米
+            }
+            var halfThickness = (thickness || 0.1) / 2;
 
             for (var i = 0; i < element.points.length - 1; i++) {
               var p1 = element.points[i];
               var p2 = element.points[i + 1];
 
-              // 点坐标是像素，转换为米（100像素 = 1米）
-              var x1 = p1.x / 100;
-              var z1 = p1.y / 100;
-              var x2 = p2.x / 100;
-              var z2 = p2.y / 100;
+              // 判断坐标格式：如果有z属性，说明已经是米坐标；如果有y属性，说明是像素坐标
+              var x1, z1, x2, z2;
+              if (p1.z !== undefined) {
+                // 新格式：已经是米坐标
+                x1 = p1.x;
+                z1 = p1.z;
+                x2 = p2.x;
+                z2 = p2.z;
+              } else {
+                // 旧格式：像素坐标，需要转换
+                x1 = p1.x / 100;
+                z1 = p1.y / 100;
+                x2 = p2.x / 100;
+                z2 = p2.y / 100;
+              }
 
               // 判断墙的方向
               var dx = Math.abs(x2 - x1);
@@ -103,11 +118,21 @@
             var p1 = element.points[0];
             var p2 = element.points[1];
 
-            // 像素转米
-            var x1 = p1.x / 100;
-            var z1 = p1.y / 100;
-            var x2 = p2.x / 100;
-            var z2 = p2.y / 100;
+            // 判断坐标格式
+            var x1, z1, x2, z2;
+            if (p1.z !== undefined) {
+              // 新格式：已经是米坐标
+              x1 = p1.x;
+              z1 = p1.z;
+              x2 = p2.x;
+              z2 = p2.z;
+            } else {
+              // 旧格式：像素坐标，需要转换
+              x1 = p1.x / 100;
+              z1 = p1.y / 100;
+              x2 = p2.x / 100;
+              z2 = p2.y / 100;
+            }
 
             obstacles.push({
               type: 'rectangle',
@@ -124,11 +149,24 @@
         else if (element.type === 'circle' && !passable) {
           if (element.points && element.points.length >= 1) {
             var center = element.points[0];
-            var centerX = center.x / 100;
-            var centerZ = center.y / 100;
 
-            // radius是毫米，转换为米
-            var radius = (element.radius || 500) / 1000;
+            // 判断坐标格式
+            var centerX, centerZ;
+            if (center.z !== undefined) {
+              // 新格式：已经是米坐标
+              centerX = center.x;
+              centerZ = center.z;
+            } else {
+              // 旧格式：像素坐标，需要转换
+              centerX = center.x / 100;
+              centerZ = center.y / 100;
+            }
+
+            // radius: 如果是米单位（< 1），直接使用；如果是毫米（>= 1），转换为米
+            var radius = element.radius || 0.5;
+            if (radius >= 1) {
+              radius = radius / 1000; // 毫米 → 米
+            }
 
             obstacles.push({
               type: 'circle',
@@ -151,8 +189,17 @@
             var points3D = [];
 
             element.points.forEach(function (p) {
-              var x = p.x / 100;
-              var z = p.y / 100;
+              // 判断坐标格式
+              var x, z;
+              if (p.z !== undefined) {
+                // 新格式：已经是米坐标
+                x = p.x;
+                z = p.z;
+              } else {
+                // 旧格式：像素坐标，需要转换
+                x = p.x / 100;
+                z = p.y / 100;
+              }
               points3D.push({ x: x, z: z });
               minX = Math.min(minX, x);
               minZ = Math.min(minZ, z);
@@ -190,6 +237,39 @@
             });
           }
         }
+        // 处理家具（furniture）
+        else if (element.type === 'furniture' && !passable) {
+          // 家具可能使用position或points来定义位置
+          var centerX, centerZ, width, depth;
+
+          if (element.position) {
+            // 使用position定义（米坐标）
+            centerX = element.position.x;
+            centerZ = element.position.z;
+            width = element.targetSize ? element.targetSize.width : 0.5;
+            depth = element.targetSize ? element.targetSize.depth : 0.5;
+          } else if (element.points && element.points.length >= 1) {
+            // 使用points定义（像素坐标）
+            var center = element.points[0];
+            centerX = center.x / 100;
+            centerZ = center.y / 100;
+            width = (element.width || 50) / 100;
+            depth = (element.depth || 50) / 100;
+          } else {
+            return; // 没有位置信息，跳过
+          }
+
+          var halfDiag = Math.sqrt(width * width + depth * depth) / 2;
+          obstacles.push({
+            type: 'furniture',
+            bounds: {
+              minX: centerX - halfDiag,
+              minZ: centerZ - halfDiag,
+              maxX: centerX + halfDiag,
+              maxZ: centerZ + halfDiag
+            }
+          });
+        }
       });
     });
 
@@ -228,15 +308,28 @@
 
     var obstacles = [];
 
-    // 1. 如果有layers，使用extractObstaclesFromFloor
-    if (kidata.layers && Array.isArray(kidata.layers)) {
+    // 1. 优先从kidata的floors中提取障碍物
+    if (kidata.floors && Array.isArray(kidata.floors)) {
+      console.log('KMUtil: 从kidata.floors提取障碍物，楼层数量:', kidata.floors.length);
+      // 使用第一个楼层的数据
+      if (kidata.floors.length > 0) {
+        var floorData = { layers: kidata.floors[0].layers };
+        obstacles = obstacles.concat(
+          KMUtil.extractObstaclesFromFloor(floorData, true)
+        );
+      }
+    }
+    // 2. 如果没有floors数据，回退到layers（兼容旧版本）
+    else if (kidata.layers && Array.isArray(kidata.layers)) {
+      console.log('KMUtil: 从kidata.layers提取障碍物（兼容模式）');
       obstacles = obstacles.concat(
         KMUtil.extractObstaclesFromFloor(kidata, true)
       );
     }
 
-    // 2. 处理furnitures（3D模型）
+    // 3. 处理furnitures（3D模型）
     if (kidata.furnitures && Array.isArray(kidata.furnitures)) {
+      console.log('KMUtil: 从kidata.furnitures提取家具障碍物，家具数量:', kidata.furnitures.length);
       kidata.furnitures.forEach(function (furniture) {
         var passable = furniture.passable === true;
         if (passable) return;
@@ -546,39 +639,26 @@
   }
 
   /**
-   * A*路径规划算法
-   * @param {Object} start - 起点 {x, z}（米）
-   * @param {Object} end - 终点 {x, z}（米）
-   * @param {Array} obstacles - 障碍物列表
-   * @param {number} gridSize - 网格大小（米），默认0.5米
-   */
-  /**
- * A* 路径规划（已修复水平镜像 / 三维坐标系映射）
- * start/end: { x, z } 世界坐标（米）
+ * A* 路径规划（适配你的坐标系：X 右、Z 下、单位米）
+ * start/end: { x, z }
  * obstacles: [{ type, bounds:{minX,minZ,maxX,maxZ} }, ...]
- * cellSize: 网格大小（米），默认 0.05
- * options: { inflationCells } 障碍膨胀（格数），默认 1
+ * gridSize: 每步移动距离（米），推荐 0.2〜0.5
  */
-  function aStarPathfinding(start, end, obstacles, gridSize) {
-    console.log('开始规划路径', obstacles)
-    gridSize = gridSize || 0.5;
+  function aStarPathfinding(start, end, obstacles, gridSize = 0.2) {
+    const openList = [];
+    const closed = new Set();
 
-    var openList = [];
-    var closedSet = {};
-
-    var startNode = {
+    const startNode = {
       x: start.x,
       z: start.z,
       g: 0,
       h: heuristic(start, end),
-      f: 0,
-      parent: null
+      parent: null,
     };
     startNode.f = startNode.g + startNode.h;
-
     openList.push(startNode);
 
-    var directions = [
+    const dirs = [
       { dx: gridSize, dz: 0 },
       { dx: -gridSize, dz: 0 },
       { dx: 0, dz: gridSize },
@@ -586,97 +666,267 @@
       { dx: gridSize, dz: gridSize },
       { dx: gridSize, dz: -gridSize },
       { dx: -gridSize, dz: gridSize },
-      { dx: -gridSize, dz: -gridSize }
+      { dx: -gridSize, dz: -gridSize },
     ];
 
-    var iterations = 0;
-    var maxIterations = 10000;
+    let iter = 0;
+    const maxIter = 20000;
 
-    while (openList.length > 0 && iterations < maxIterations) {
-      iterations++;
+    while (openList.length > 0 && iter < maxIter) {
+      iter++;
 
-      // 找到f值最小的节点
-      openList.sort(function (a, b) { return a.f - b.f; });
-      var current = openList.shift();
+      // 找 f 最小的节点
+      openList.sort((a, b) => a.f - b.f);
+      const current = openList.shift();
 
-      // 检查是否到达终点
-      if (Math.abs(current.x - end.x) < gridSize && Math.abs(current.z - end.z) < gridSize) {
-        var path = [];
-        var node = current;
+      const key = toKey(current, gridSize);
+      if (closed.has(key)) continue;
+      closed.add(key);
 
-        while (node) {
-          path.unshift({ x: node.x, z: node.z });
-          node = node.parent;
-        }
-
-        path.push(end);
-        return simplifyPath(path, obstacles);
+      // 是否到终点（误差小于 gridSize）
+      if (distance(current, end) <= gridSize * 1.1) {
+        return rebuildPath(current, end);
       }
 
-      var key = Math.round(current.x / gridSize) + ',' + Math.round(current.z / gridSize);
-      if (closedSet[key]) continue;
-      closedSet[key] = true;
+      // 扩展邻居
+      for (const d of dirs) {
+        const nx = current.x + d.dx;
+        const nz = current.z + d.dz;
 
-      // 扩展邻居节点
-      for (var d = 0; d < directions.length; d++) {
-        var dir = directions[d];
-        var newX = current.x + dir.dx;
-        var newZ = current.z + dir.dz;
+        const nk = `${Math.round(nx / gridSize)},${Math.round(nz / gridSize)}`;
+        if (closed.has(nk)) continue;
 
-        var neighborKey = Math.round(newX / gridSize) + ',' + Math.round(newZ / gridSize);
-        if (closedSet[neighborKey]) continue;
+        // 点是否落在障碍物区域
+        if (isPointInObstacles(nx, nz, obstacles)) continue;
 
-        // 检查是否在障碍物内
-        var blocked = false;
-        for (var o = 0; o < obstacles.length; o++) {
-          if (isPointInObstacle(newX, newZ, obstacles[o], gridSize / 2)) {
-            blocked = true;
-            break;
-          }
-        }
-        if (blocked) continue;
-
-        // 检查路径是否穿过障碍物
-        if (pathIntersectsObstacles(current.x, current.z, newX, newZ, obstacles, gridSize / 4)) {
+        // 本段路径是否穿越障碍物（含斜线）
+        if (segmentIntersectsObstacles(current.x, current.z, nx, nz, obstacles)) {
           continue;
         }
 
-        var g = current.g + Math.sqrt(dir.dx * dir.dx + dir.dz * dir.dz);
-        var h = heuristic({ x: newX, z: newZ }, end);
-        var f = g + h;
+        const g = current.g + Math.sqrt(d.dx * d.dx + d.dz * d.dz);
+        const h = heuristic({ x: nx, z: nz }, end);
 
-        // 检查是否已在openList中
-        var existingIndex = -1;
-        for (var e = 0; e < openList.length; e++) {
-          if (Math.abs(openList[e].x - newX) < 0.01 && Math.abs(openList[e].z - newZ) < 0.01) {
-            existingIndex = e;
-            break;
-          }
-        }
+        const exist = openList.find((n) => Math.abs(n.x - nx) < 1e-3 && Math.abs(n.z - nz) < 1e-3);
 
-        if (existingIndex >= 0 && openList[existingIndex].g <= g) {
-          continue;
-        }
-
-        if (existingIndex >= 0) {
-          openList.splice(existingIndex, 1);
-        }
+        if (exist && exist.g <= g) continue;
+        if (exist) openList.splice(openList.indexOf(exist), 1);
 
         openList.push({
-          x: newX,
-          z: newZ,
-          g: g,
-          h: h,
-          f: f,
-          parent: current
+          x: nx,
+          z: nz,
+          g,
+          h,
+          f: g + h,
+          parent: current,
         });
       }
     }
 
-    console.warn('A*算法未找到路径，返回直线');
+    console.warn("A* 未找到路径，返回直线。");
     return [start, end];
   }
 
+  /* ======== 工具函数 ========= */
+
+  // 曼哈顿 + 欧式启发
+  function heuristic(a, b) {
+    return Math.sqrt((a.x - b.x) ** 2 + (a.z - b.z) ** 2);
+  }
+
+  // 键
+  function toKey(n, grid) {
+    return `${Math.round(n.x / grid)},${Math.round(n.z / grid)}`;
+  }
+
+  // 回溯路径
+  function rebuildPath(node, end) {
+    const path = [];
+    while (node) {
+      path.unshift({ x: node.x, z: node.z });
+      node = node.parent;
+    }
+    path.push(end);
+    return path;
+  }
+
+  // 点是否在任意障碍物中
+  function isPointInObstacles(x, z, obstacles) {
+    return obstacles.some((o) => {
+      const b = o.bounds;
+      return x >= b.minX && x <= b.maxX && z >= b.minZ && z <= b.maxZ;
+    });
+  }
+
+  // 判断线段是否穿过障碍（矩形）
+  function segmentIntersectsObstacles(x1, z1, x2, z2, obstacles) {
+    return obstacles.some((o) => {
+      const b = o.bounds;
+      return segmentIntersectsRect(x1, z1, x2, z2, b);
+    });
+  }
+
+  // 线段 vs 轴对齐矩形
+  function segmentIntersectsRect(x1, z1, x2, z2, b) {
+    // 若两端点都在外侧，但线段穿过 bbox
+    if (lineIntersectsAABB(x1, z1, x2, z2, b)) return true;
+
+    // 若任意端点在矩形内，也算穿越
+    if (x1 >= b.minX && x1 <= b.maxX && z1 >= b.minZ && z1 <= b.maxZ) return true;
+    if (x2 >= b.minX && x2 <= b.maxX && z2 >= b.maxZ && z2 <= b.maxZ) return true;
+
+    return false;
+  }
+
+  // 利用 Liang–Barsky 算法判断线段与 AABB 是否相交
+  function lineIntersectsAABB(x1, z1, x2, z2, b) {
+    let t0 = 0, t1 = 1;
+    const dx = x2 - x1, dz = z2 - z1;
+
+    const checks = [
+      [-dx, x1 - b.minX],
+      [dx, b.maxX - x1],
+      [-dz, z1 - b.minZ],
+      [dz, b.maxZ - z1],
+    ];
+
+    for (const [p, q] of checks) {
+      if (p === 0 && q < 0) return false;
+      const r = q / p;
+      if (p < 0) { if (r > t1) return false; else if (r > t0) t0 = r; }
+      else if (p > 0) { if (r < t0) return false; else if (r < t1) t1 = r; }
+    }
+
+    return true;
+  }
+
+  // 距离
+  function distance(a, b) {
+    return Math.sqrt((a.x - b.x) ** 2 + (a.z - b.z) ** 2);
+  }
+
+  /**
+   * 简化路径 - 移除不必要的中间点
+   * 使用Douglas-Peucker算法的简化版本
+   * @param {Array} path - 原始路径点 [{x, z}, ...]
+   * @param {Array} obstacles - 障碍物列表
+   * @returns {Array} 简化后的路径点
+   */
+  function simplifyPath(path, obstacles) {
+    if (path.length <= 2) return path;
+
+    const simplified = [path[0]];
+    let current = 0;
+
+    // 贪心算法：尽可能跳过中间点
+    while (current < path.length - 1) {
+      let farthest = current + 1;
+      
+      // 从最远的点开始尝试，看能否直接连接
+      for (let i = path.length - 1; i > current + 1; i--) {
+        const canConnect = !segmentIntersectsObstacles(
+          path[current].x, 
+          path[current].z, 
+          path[i].x, 
+          path[i].z, 
+          obstacles
+        );
+        
+        if (canConnect) {
+          farthest = i;
+          break;
+        }
+      }
+      
+      simplified.push(path[farthest]);
+      current = farthest;
+    }
+
+    return simplified;
+  }
+
+  /**
+   * 使用Catmull-Rom样条曲线平滑路径
+   * @param {Array} path - 原始路径点 [{x, z}, ...]
+   * @param {Object} obstacles - 障碍物列表
+   * @param {number} tension - 张力参数（0-1），越小越平滑，默认0.5
+   * @param {number} segments - 每段曲线的分段数，默认10
+   * @returns {Array} 平滑后的路径点
+   */
+  function smoothPath(path, obstacles, tension = 0.5, segments = 10) {
+    if (path.length <= 2) return path;
+
+    const smoothed = [];
+    
+    // 添加起点
+    smoothed.push(path[0]);
+
+    // 对每个路径段进行平滑
+    for (let i = 0; i < path.length - 1; i++) {
+      const p0 = path[Math.max(0, i - 1)];
+      const p1 = path[i];
+      const p2 = path[i + 1];
+      const p3 = path[Math.min(path.length - 1, i + 2)];
+
+      // 生成Catmull-Rom曲线点
+      for (let t = 0; t < segments; t++) {
+        const u = t / segments;
+        const point = catmullRom(p0, p1, p2, p3, u, tension);
+        
+        // 检查平滑后的点是否穿过障碍物
+        if (smoothed.length > 0) {
+          const lastPoint = smoothed[smoothed.length - 1];
+          if (!segmentIntersectsObstacles(lastPoint.x, lastPoint.z, point.x, point.z, obstacles)) {
+            smoothed.push(point);
+          } else {
+            // 如果穿过障碍物，使用原始路径点
+            if (smoothed[smoothed.length - 1] !== p1) {
+              smoothed.push(p1);
+            }
+            break;
+          }
+        } else {
+          smoothed.push(point);
+        }
+      }
+    }
+
+    // 添加终点
+    smoothed.push(path[path.length - 1]);
+
+    return smoothed;
+  }
+
+  /**
+   * Catmull-Rom样条曲线插值
+   * @param {Object} p0 - 控制点0
+   * @param {Object} p1 - 起点
+   * @param {Object} p2 - 终点
+   * @param {Object} p3 - 控制点3
+   * @param {number} t - 插值参数（0-1）
+   * @param {number} tension - 张力参数
+   * @returns {Object} 插值点 {x, z}
+   */
+  function catmullRom(p0, p1, p2, p3, t, tension) {
+    const t2 = t * t;
+    const t3 = t2 * t;
+    
+    const v0 = (p2.x - p0.x) * tension;
+    const v1 = (p3.x - p1.x) * tension;
+    const w0 = (p2.z - p0.z) * tension;
+    const w1 = (p3.z - p1.z) * tension;
+
+    const x = (2 * p1.x - 2 * p2.x + v0 + v1) * t3 +
+              (-3 * p1.x + 3 * p2.x - 2 * v0 - v1) * t2 +
+              v0 * t + p1.x;
+
+    const z = (2 * p1.z - 2 * p2.z + w0 + w1) * t3 +
+              (-3 * p1.z + 3 * p2.z - 2 * w0 - w1) * t2 +
+              w0 * t + p1.z;
+
+    return { x, z };
+  }
+
 
 
   /**
@@ -724,8 +974,24 @@
       return [start, end];
     }
 
-    // 使用A*算法规划路径（gridSize: 0.5米 = 50cm）
-    return aStarPathfinding(start, end, obstacles, 0.5);
+    // 使用A*算法规划路径（gridSize: 0.2米 = 20cm）
+    const rawPath = aStarPathfinding(start, end, obstacles, 0.2);
+    
+    // 如果路径只有2个点（直线），直接返回
+    if (rawPath.length <= 2) {
+      return rawPath;
+    }
+    
+    // 第一步：简化路径，移除不必要的中间点
+    const simplifiedPath = simplifyPath(rawPath, obstacles);
+    
+    // 第二步：平滑路径（可通过options.smoothPath控制是否启用，默认启用）
+    const enableSmoothing = options.smoothPath !== false;
+    if (enableSmoothing && simplifiedPath.length > 2) {
+      return smoothPath(simplifiedPath, obstacles, 0.5, 8);
+    }
+    
+    return simplifiedPath;
   };
 
   /**