@kimap/indoor-positioning-sdk-vue2 3.1.7 → 3.1.10

package/package.json

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

package/src/KimapCore.js

@@ -303,6 +303,15 @@ SceneCore.prototype.setCameraPosition = function() {
   var maxX = this.coordinateSystem.maxX;
   var maxY = this.coordinateSystem.maxY;
   
+  // 如果 maxX 或 maxY 未定义，使用默认值（稍后会根据实际模型尺寸重新调整）
+  if (maxX === undefined || maxY === undefined) {
+    console.log('⚠️ 坐标系统尺寸未定义，使用默认相机位置（将在模型加载后自动调整）');
+    // 使用一个合理的默认位置：从斜上方俯视原点
+    this.camera.position.set(origin.x, 15, origin.z + 10);
+    this.camera.lookAt(origin.x, 0, origin.z);
+    return;
+  }
+  
   var centerX = origin.x + maxX / 2;
   var centerZ = origin.z;
   var distance = Math.max(maxX, maxY) * 1.5;
@@ -497,19 +506,47 @@ SceneCore.prototype.loadMap = function(OBJLoader, MTLLoader) {
             self.mapModel = object;
             self.scene.add(self.mapModel);
             
-            // 计算包围盒并调整模型位置，使其居中对齐
+            // 计算包围盒
             var box = new THREE.Box3().setFromObject(self.mapModel);
             var center = new THREE.Vector3();
             box.getCenter(center);
             
+            console.log('📦 模型原始包围盒:', {
+              min: { x: box.min.x.toFixed(2), y: box.min.y.toFixed(2), z: box.min.z.toFixed(2) },
+              max: { x: box.max.x.toFixed(2), y: box.max.y.toFixed(2), z: box.max.z.toFixed(2) },
+              center: { x: center.x.toFixed(2), y: center.y.toFixed(2), z: center.z.toFixed(2) }
+            });
+            
+            // 如果有边界信息，使用边界信息来定位模型
+            // 目标：让模型的 min 点对齐到边界的 min 点
             var origin = self.coordinateSystem.origin;
-            self.mapModel.position.set(
-              origin.x - center.x,      // X方向居中
-              origin.y - box.min.y,     // Y方向：底部对齐地面
-              origin.z - center.z       // Z方向居中
-            );
+            var offsetX, offsetY, offsetZ;
+            
+            if (border) {
+              // 计算需要的偏移量：将模型的 min 点移动到边界的 min 点
+              offsetX = origin.x + border.min.x - box.min.x;
+              offsetY = origin.y + border.min.y - box.min.y;
+              offsetZ = origin.z + border.min.z - box.min.z;
+              
+              console.log('✅ 使用边界信息定位模型');
+              console.log('🎯 目标边界:', border);
+            } else {
+              // 没有边界信息，使用传统的居中对齐方式
+              offsetX = origin.x - center.x;
+              offsetY = origin.y - box.min.y;
+              offsetZ = origin.z - center.z;
+              
+              console.log('⚠️ 未找到边界信息，使用居中对齐方式');
+            }
             
-            console.log('✅ 模型已居中对齐到原点');
+            self.mapModel.position.set(offsetX, offsetY, offsetZ);
+            
+            console.log('📍 模型位置偏移:', {
+              x: offsetX.toFixed(2),
+              y: offsetY.toFixed(2),
+              z: offsetZ.toFixed(2)
+            });
+            console.log('✅ 模型已对齐');
             
             // 统计模型信息
             var meshCount = 0;
@@ -618,37 +655,74 @@ SceneCore.prototype.loadMap = function(OBJLoader, MTLLoader) {
             
             // 基于模型包围盒自动调整相机位置和控制器目标，避免依赖配置中的 maxX/maxY
             try {
+              console.log('=== 开始自动调整相机位置 ===');
+              
               // 使用模型当前位置重新计算包围盒和中心
               var finalBox = new THREE.Box3().setFromObject(self.mapModel);
               var finalCenter = new THREE.Vector3();
               finalBox.getCenter(finalCenter);
+              
+              console.log('📦 模型最终包围盒:', {
+                min: { x: finalBox.min.x.toFixed(2), y: finalBox.min.y.toFixed(2), z: finalBox.min.z.toFixed(2) },
+                max: { x: finalBox.max.x.toFixed(2), y: finalBox.max.y.toFixed(2), z: finalBox.max.z.toFixed(2) }
+              });
+              console.log('🎯 模型中心:', {
+                x: finalCenter.x.toFixed(2),
+                y: finalCenter.y.toFixed(2),
+                z: finalCenter.z.toFixed(2)
+              });
 
               var finalSize = new THREE.Vector3();
               finalBox.getSize(finalSize);
               var maxSize = Math.max(finalSize.x, finalSize.z);
+              
+              console.log('📏 模型尺寸:', {
+                x: finalSize.x.toFixed(2),
+                y: finalSize.y.toFixed(2),
+                z: finalSize.z.toFixed(2),
+                maxSize: maxSize.toFixed(2)
+              });
 
               // 根据模型尺寸计算一个合理的视距
               var distance = maxSize * 1.5;
+              
+              console.log('📹 计算相机距离:', distance.toFixed(2));
 
               // 相机从斜上方俯视模型中心
-              self.camera.position.set(
-                finalCenter.x,
-                finalCenter.y + distance,
-                finalCenter.z + distance * 0.5
-              );
+              var cameraX = finalCenter.x;
+              var cameraY = finalCenter.y + distance;
+              var cameraZ = finalCenter.z + distance * 0.5;
+              
+              self.camera.position.set(cameraX, cameraY, cameraZ);
               self.camera.lookAt(finalCenter.x, finalCenter.y, finalCenter.z);
+              
+              console.log('📹 相机位置:', {
+                x: cameraX.toFixed(2),
+                y: cameraY.toFixed(2),
+                z: cameraZ.toFixed(2)
+              });
+              console.log('👀 相机朝向:', {
+                x: finalCenter.x.toFixed(2),
+                y: finalCenter.y.toFixed(2),
+                z: finalCenter.z.toFixed(2)
+              });
 
               // 更新控制器目标为模型中心
               if (self.controls) {
                 self.controls.target.copy(finalCenter);
                 self.controls.update();
+                console.log('🎮 控制器目标已更新');
               }
 
               // 更新坐标系范围为模型的实际尺寸，供其它功能使用
               self.coordinateSystem.maxX = finalSize.x;
               self.coordinateSystem.maxY = finalSize.z;
+              
+              console.log('✅ 相机自动调整完成');
+              console.log('=========================');
             } catch (e) {
-              console.warn('根据模型自动调整相机位置失败:', e && e.message ? e.message : e);
+              console.error('❌ 根据模型自动调整相机位置失败:', e && e.message ? e.message : e);
+              console.error('错误堆栈:', e.stack);
             }
             
             resolve();