@kimap/indoor-positioning-sdk-vue2 4.3.4 → 4.3.6

package/package.json

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

package/src/KMUtil.js

@@ -309,6 +309,12 @@
 
     var obstacles = [];
 
+    // 0. 如果直接传入的是家具数组，转换为kidata格式
+    if (Array.isArray(kidata)) {
+      console.log('KMUtil: 检测到直接传入家具数组，数量:', kidata.length);
+      kidata = { furnitures: kidata };
+    }
+
     // 1. 优先从kidata的floors中提取障碍物
     if (kidata.floors && Array.isArray(kidata.floors)) {
       console.log('KMUtil: 从kidata.floors提取障碍物，楼层数量:', kidata.floors.length);
@@ -644,8 +650,24 @@
  * start/end: { x, z }
  * obstacles: [{ type, bounds:{minX,minZ,maxX,maxZ} }, ...]
  * gridSize: 每步移动距离（米），推荐 0.2〜0.5
+ * clearance: 人体安全间隙（米），障碍物会被扩大这个距离
  */
-  function aStarPathfinding(start, end, obstacles, gridSize = 0.2) {
+  function aStarPathfinding(start, end, obstacles, gridSize = 0.2, clearance = 0.4) {
+    // 扩大障碍物边界，考虑人体体积
+    const expandedObstacles = obstacles.map(function(obs) {
+      return {
+        type: obs.type,
+        bounds: {
+          minX: obs.bounds.minX - clearance,
+          minZ: obs.bounds.minZ - clearance,
+          maxX: obs.bounds.maxX + clearance,
+          maxZ: obs.bounds.maxZ + clearance
+        },
+        center: obs.center,
+        radius: obs.radius ? obs.radius + clearance : undefined,
+        points: obs.points
+      };
+    });
     const openList = [];
     const closed = new Set();
 
@@ -697,11 +719,11 @@
         const nk = `${Math.round(nx / gridSize)},${Math.round(nz / gridSize)}`;
         if (closed.has(nk)) continue;
 
-        // 点是否落在障碍物区域
-        if (isPointInObstacles(nx, nz, obstacles)) continue;
+        // 点是否落在障碍物区域（使用扩大后的障碍物）
+        if (isPointInObstacles(nx, nz, expandedObstacles)) continue;
 
-        // 本段路径是否穿越障碍物（含斜线）
-        if (segmentIntersectsObstacles(current.x, current.z, nx, nz, obstacles)) {
+        // 本段路径是否穿越障碍物（含斜线，使用扩大后的障碍物）
+        if (segmentIntersectsObstacles(current.x, current.z, nx, nz, expandedObstacles)) {
           continue;
         }
 
@@ -812,11 +834,25 @@
    * @param {Array} obstacles - 障碍物列表
    * @param {number} searchRadius - 搜索半径（米），默认2米
    * @param {number} step - 搜索步长（米），默认0.1米
+   * @param {number} clearance - 人体安全间隙（米），默认0.4米
    * @returns {Object} 可行的点 {x, z}
    */
-  function findNearestFreePoint(point, obstacles, searchRadius = 2, step = 0.1) {
+  function findNearestFreePoint(point, obstacles, searchRadius = 2, step = 0.1, clearance = 0.4) {
+    // 扩大障碍物边界，考虑人体体积
+    var expandedObstacles = obstacles.map(function(obs) {
+      return {
+        type: obs.type,
+        bounds: {
+          minX: obs.bounds.minX - clearance,
+          minZ: obs.bounds.minZ - clearance,
+          maxX: obs.bounds.maxX + clearance,
+          maxZ: obs.bounds.maxZ + clearance
+        }
+      };
+    });
+    
     // 如果当前点已经可行，直接返回
-    if (!isPointInObstacles(point.x, point.z, obstacles)) {
+    if (!isPointInObstacles(point.x, point.z, expandedObstacles)) {
       return point;
     }
 
@@ -838,8 +874,8 @@
         const testX = point.x + Math.cos(angle) * currentRadius;
         const testZ = point.z + Math.sin(angle) * currentRadius;
         
-        // 检查这个点是否可行
-        if (!isPointInObstacles(testX, testZ, obstacles)) {
+        // 检查这个点是否可行（使用扩大后的障碍物）
+        if (!isPointInObstacles(testX, testZ, expandedObstacles)) {
           const dist = Math.sqrt(
             (testX - point.x) ** 2 + (testZ - point.z) ** 2
           );
@@ -866,11 +902,25 @@
    * 使用Douglas-Peucker算法的简化版本
    * @param {Array} path - 原始路径点 [{x, z}, ...]
    * @param {Array} obstacles - 障碍物列表
+   * @param {number} clearance - 人体安全间隙（米），默认0.4米
    * @returns {Array} 简化后的路径点
    */
-  function simplifyPath(path, obstacles) {
+  function simplifyPath(path, obstacles, clearance = 0.4) {
     if (path.length <= 2) return path;
 
+    // 扩大障碍物边界，考虑人体体积
+    var expandedObstacles = obstacles.map(function(obs) {
+      return {
+        type: obs.type,
+        bounds: {
+          minX: obs.bounds.minX - clearance,
+          minZ: obs.bounds.minZ - clearance,
+          maxX: obs.bounds.maxX + clearance,
+          maxZ: obs.bounds.maxZ + clearance
+        }
+      };
+    });
+
     const simplified = [path[0]];
     let current = 0;
 
@@ -878,14 +928,14 @@
     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
+          expandedObstacles
         );
         
         if (canConnect) {
@@ -1041,9 +1091,13 @@
       });
     }
 
-    // 调整起点和终点，确保它们不在障碍物内
-    const adjustedStart = findNearestFreePoint(start, obstacles, 2, 0.1);
-    const adjustedEnd = findNearestFreePoint(end, obstacles, 2, 0.1);
+    // 人体安全距离：考虑人的肩宽（约0.5米）+ 安全余量
+    // 使用0.4米（40cm）作为最小间隙，确保人可以舒适通过
+    const PERSON_CLEARANCE = options.clearance || 0.4;
+    
+    // 调整起点和终点，确保它们不在障碍物内（考虑人体体积）
+    const adjustedStart = findNearestFreePoint(start, obstacles, 2, 0.1, PERSON_CLEARANCE);
+    const adjustedEnd = findNearestFreePoint(end, obstacles, 2, 0.1, PERSON_CLEARANCE);
 
     // 如果起点或终点被调整了，记录日志
     if (adjustedStart.x !== start.x || adjustedStart.z !== start.z) {
@@ -1052,10 +1106,10 @@
     if (adjustedEnd.x !== end.x || adjustedEnd.z !== end.z) {
       console.log(`终点已调整: (${end.x.toFixed(2)}, ${end.z.toFixed(2)}) → (${adjustedEnd.x.toFixed(2)}, ${adjustedEnd.z.toFixed(2)})`);
     }
-
-    // 检查直线是否可行（margin: 0.1米 = 10cm）
-    const hasIntersection = pathIntersectsObstacles(adjustedStart.x, adjustedStart.z, adjustedEnd.x, adjustedEnd.z, obstacles, 0.1);
-    console.log(`🔍 直线路径检查: ${hasIntersection ? '有障碍物❌' : '无障碍物✅'}`);
+    
+    // 检查直线是否可行
+    const hasIntersection = pathIntersectsObstacles(adjustedStart.x, adjustedStart.z, adjustedEnd.x, adjustedEnd.z, obstacles, PERSON_CLEARANCE);
+    console.log(`🔍 直线路径检查 (安全距离=${PERSON_CLEARANCE}m): ${hasIntersection ? '有障碍物❌' : '无障碍物✅'}`);
     
     if (!hasIntersection) {
       console.log('✅ 直线可达，返回两点路径');
@@ -1064,8 +1118,8 @@
     
     console.log('🚧 需要绕行，开始A*路径规划...');
 
-    // 使用A*算法规划路径（gridSize: 0.2米 = 20cm）
-    const rawPath = aStarPathfinding(adjustedStart, adjustedEnd, obstacles, 0.2);
+    // 使用A*算法规划路径（gridSize: 0.3米 = 30cm，考虑人体宽度）
+    const rawPath = aStarPathfinding(adjustedStart, adjustedEnd, obstacles, 0.3, PERSON_CLEARANCE);
     console.log(`🗺️ A*原始路径: ${rawPath.length}个点`);
     
     // 如果路径只有2个点（直线），直接返回
@@ -1074,13 +1128,10 @@
       return rawPath;
     }
     
-    // 第一步：简化路径，移除不必要的中间点
-    const simplifiedPath = simplifyPath(rawPath, obstacles);
+    // 第一步：简化路径，移除不必要的中间点（考虑人体体积）
+    const simplifiedPath = simplifyPath(rawPath, obstacles, PERSON_CLEARANCE);
     console.log(`📐 简化后路径: ${simplifiedPath.length}个点`);
     
-    // 第二步：平滑路径（可通过options.smoothPath控制是否启用，默认启用）
-    const ena
-    
     return simplifiedPath;
   };