@kimap/indoor-positioning-sdk-vue2 4.2.7 → 4.2.9

package/package.json

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

package/src/KMUtil.js

@@ -805,6 +805,61 @@
     return Math.sqrt((a.x - b.x) ** 2 + (a.z - b.z) ** 2);
   }
 
+  /**
+   * 找到最近的可行位置（不在障碍物内）
+   * @param {Object} point - 原始点 {x, z}
+   * @param {Array} obstacles - 障碍物列表
+   * @param {number} searchRadius - 搜索半径（米），默认2米
+   * @param {number} step - 搜索步长（米），默认0.1米
+   * @returns {Object} 可行的点 {x, z}
+   */
+  function findNearestFreePoint(point, obstacles, searchRadius = 2, step = 0.1) {
+    // 如果当前点已经可行，直接返回
+    if (!isPointInObstacles(point.x, point.z, obstacles)) {
+      return point;
+    }
+
+    console.log(`点 (${point.x.toFixed(2)}, ${point.z.toFixed(2)}) 在障碍物内，搜索最近可行位置...`);
+
+    // 螺旋搜索最近的可行点
+    let bestPoint = null;
+    let minDistance = Infinity;
+
+    // 使用圆形搜索模式
+    const angles = 16; // 16个方向
+    const radiusSteps = Math.ceil(searchRadius / step);
+
+    for (let r = 1; r <= radiusSteps; r++) {
+      const currentRadius = r * step;
+      
+      for (let a = 0; a < angles; a++) {
+        const angle = (a / angles) * Math.PI * 2;
+        const testX = point.x + Math.cos(angle) * currentRadius;
+        const testZ = point.z + Math.sin(angle) * currentRadius;
+        
+        // 检查这个点是否可行
+        if (!isPointInObstacles(testX, testZ, obstacles)) {
+          const dist = Math.sqrt(
+            (testX - point.x) ** 2 + (testZ - point.z) ** 2
+          );
+          
+          if (dist < minDistance) {
+            minDistance = dist;
+            bestPoint = { x: testX, z: testZ };
+          }
+          
+          // 找到第一个可行点就返回（最近的）
+          console.log(`✅ 找到可行位置: (${testX.toFixed(2)}, ${testZ.toFixed(2)}), 距离: ${dist.toFixed(2)}米`);
+          return bestPoint;
+        }
+      }
+    }
+
+    // 如果没找到可行点，返回原点（降级处理）
+    console.warn(`⚠️ 在${searchRadius}米范围内未找到可行位置，使用原点`);
+    return point;
+  }
+
   /**
    * 简化路径 - 移除不必要的中间点
    * 使用Douglas-Peucker算法的简化版本
@@ -969,13 +1024,25 @@
       return [start, end];
     }
 
+    // 调整起点和终点，确保它们不在障碍物内
+    const adjustedStart = findNearestFreePoint(start, obstacles, 2, 0.1);
+    const adjustedEnd = findNearestFreePoint(end, obstacles, 2, 0.1);
+
+    // 如果起点或终点被调整了，记录日志
+    if (adjustedStart.x !== start.x || adjustedStart.z !== start.z) {
+      console.log(`起点已调整: (${start.x.toFixed(2)}, ${start.z.toFixed(2)}) → (${adjustedStart.x.toFixed(2)}, ${adjustedStart.z.toFixed(2)})`);
+    }
+    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）
-    if (!pathIntersectsObstacles(start.x, start.z, end.x, end.z, obstacles, 0.1)) {
-      return [start, end];
+    if (!pathIntersectsObstacles(adjustedStart.x, adjustedStart.z, adjustedEnd.x, adjustedEnd.z, obstacles, 0.1)) {
+      return [adjustedStart, adjustedEnd];
     }
 
     // 使用A*算法规划路径（gridSize: 0.2米 = 20cm）
-    const rawPath = aStarPathfinding(start, end, obstacles, 0.2);
+    const rawPath = aStarPathfinding(adjustedStart, adjustedEnd, obstacles, 0.2);
     
     // 如果路径只有2个点（直线），直接返回
     if (rawPath.length <= 2) {

package/src/KimapCore.browser.js

@@ -1736,7 +1736,8 @@
             var scaleX = size.x > 0 ? furniture.targetSize.width / size.x : 1;
             var scaleY = size.y > 0 ? furniture.targetSize.height / size.y : 1;
             var scaleZ = size.z > 0 ? furniture.targetSize.depth / size.z : 1;
-            var uniformScale = (scaleX + scaleY + scaleZ) / 3;
+            // 使用X和Z的平均值作为统一缩放（保持水平比例，与3D预览一致）
+            var uniformScale = (scaleX + scaleZ) / 2;
             
             // 应用归一化缩放和用户缩放
             var finalScale = uniformScale * furniture.scale.x;
@@ -1744,9 +1745,10 @@
             
             console.log('🔧 家具模型缩放:', {
               type: furniture.type,
-              originalSize: { x: size.x.toFixed(3), y: size.y.toFixed(3), z: size.z.toFixed(3) },
+              originalSize: { x: size.x.toFixed(3), y: size.y.toFixed(3), z: size.z.toFixed(3), unit: '模型单位' },
               targetSize: furniture.targetSize,
-              uniformScale: uniformScale.toFixed(3),
+              scaleFactors: { x: scaleX.toFixed(3), y: scaleY.toFixed(3), z: scaleZ.toFixed(3) },
+              uniformScale: uniformScale.toFixed(3) + ' (平均X和Z)',
               userScale: furniture.scale.x,
               finalScale: finalScale.toFixed(3)
             });
@@ -2239,6 +2241,59 @@
     return Math.sqrt((a.x - b.x) * (a.x - b.x) + (a.z - b.z) * (a.z - b.z));
   }
 
+  /**
+   * 找到最近的可行位置（不在障碍物内）
+   */
+  function findNearestFreePointInternal(point, obstacles, searchRadius, step) {
+    searchRadius = searchRadius || 2;
+    step = step || 0.1;
+    
+    // 如果当前点已经可行，直接返回
+    if (!isPointInObstaclesInternal(point.x, point.z, obstacles)) {
+      return point;
+    }
+
+    console.log('点 (' + point.x.toFixed(2) + ', ' + point.z.toFixed(2) + ') 在障碍物内，搜索最近可行位置...');
+
+    // 螺旋搜索最近的可行点
+    var bestPoint = null;
+    var minDistance = Infinity;
+
+    // 使用圆形搜索模式
+    var angles = 16; // 16个方向
+    var radiusSteps = Math.ceil(searchRadius / step);
+
+    for (var r = 1; r <= radiusSteps; r++) {
+      var currentRadius = r * step;
+      
+      for (var a = 0; a < angles; a++) {
+        var angle = (a / angles) * Math.PI * 2;
+        var testX = point.x + Math.cos(angle) * currentRadius;
+        var testZ = point.z + Math.sin(angle) * currentRadius;
+        
+        // 检查这个点是否可行
+        if (!isPointInObstaclesInternal(testX, testZ, obstacles)) {
+          var dist = Math.sqrt(
+            (testX - point.x) * (testX - point.x) + (testZ - point.z) * (testZ - point.z)
+          );
+          
+          if (dist < minDistance) {
+            minDistance = dist;
+            bestPoint = { x: testX, z: testZ };
+          }
+          
+          // 找到第一个可行点就返回（最近的）
+          console.log('✅ 找到可行位置: (' + testX.toFixed(2) + ', ' + testZ.toFixed(2) + '), 距离: ' + dist.toFixed(2) + '米');
+          return bestPoint;
+        }
+      }
+    }
+
+    // 如果没找到可行点，返回原点（降级处理）
+    console.warn('⚠️ 在' + searchRadius + '米范围内未找到可行位置，使用原点');
+    return point;
+  }
+
   /**
    * 简化路径 - 移除不必要的中间点
    * @param {Array} path - 原始路径点 [{x, z}, ...]
@@ -2954,10 +3009,23 @@
       obstacles = (data && data.layers) ? KMUtil.extractObstaclesFromFloor(data, true) : KMUtil.extractObstacles(data, true);
     }
     if (obstacles.length === 0) return [start, end];
-    if (!pathIntersectsObstaclesInternal(start.x, start.z, end.x, end.z, obstacles, 0.1)) return [start, end];
+    
+    // 调整起点和终点，确保它们不在障碍物内
+    var adjustedStart = findNearestFreePointInternal(start, obstacles, 2, 0.1);
+    var adjustedEnd = findNearestFreePointInternal(end, obstacles, 2, 0.1);
+
+    // 如果起点或终点被调整了，记录日志
+    if (adjustedStart.x !== start.x || adjustedStart.z !== start.z) {
+      console.log('起点已调整: (' + start.x.toFixed(2) + ', ' + start.z.toFixed(2) + ') → (' + adjustedStart.x.toFixed(2) + ', ' + adjustedStart.z.toFixed(2) + ')');
+    }
+    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) + ')');
+    }
+
+    if (!pathIntersectsObstaclesInternal(adjustedStart.x, adjustedStart.z, adjustedEnd.x, adjustedEnd.z, obstacles, 0.1)) return [adjustedStart, adjustedEnd];
     
     // 使用A*算法（与KMUtil.js一致，gridSize: 0.2米）
-    var rawPath = aStarPathfinding(start, end, obstacles, 0.2);
+    var rawPath = aStarPathfinding(adjustedStart, adjustedEnd, obstacles, 0.2);
     
     // 如果路径只有2个点（直线），直接返回
     if (rawPath.length <= 2) {

package/src/core/KimapSDK.js

@@ -898,7 +898,8 @@ KimapSDK.prototype._loadSingleFurniture = function(furniture, serverUrl) {
           var scaleX = size.x > 0 ? furniture.targetSize.width / size.x : 1;
           var scaleY = size.y > 0 ? furniture.targetSize.height / size.y : 1;
           var scaleZ = size.z > 0 ? furniture.targetSize.depth / size.z : 1;
-          var uniformScale = (scaleX + scaleY + scaleZ) / 3;
+          // 使用X和Z的平均值作为统一缩放（保持水平比例，与3D预览一致）
+          var uniformScale = (scaleX + scaleZ) / 2;
           
           // 应用归一化缩放和用户缩放
           var finalScale = uniformScale * furniture.scale.x;