@kimap/indoor-positioning-sdk-vue2 3.1.12 → 3.1.13

package/package.json

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

package/src/KimapCore.js

@@ -303,15 +303,6 @@ 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;
@@ -506,47 +497,19 @@ 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;
-            var offsetX, offsetY, offsetZ;
-            
-            if (borderInfo) {
-              // 计算需要的偏移量：将模型的 min 点移动到边界的 min 点
-              offsetX = origin.x + borderInfo.min.x - box.min.x;
-              offsetY = origin.y + borderInfo.min.y - box.min.y;
-              offsetZ = origin.z + borderInfo.min.z - box.min.z;
-              
-              console.log('✅ 使用边界信息定位模型');
-              console.log('🎯 目标边界:', borderInfo);
-            } else {
-              // 没有边界信息，使用传统的居中对齐方式
-              offsetX = origin.x - center.x;
-              offsetY = origin.y - box.min.y;
-              offsetZ = origin.z - center.z;
-              
-              console.log('⚠️ 未找到边界信息，使用居中对齐方式');
-            }
-            
-            self.mapModel.position.set(offsetX, offsetY, offsetZ);
+            self.mapModel.position.set(
+              origin.x - center.x,      // X方向居中
+              origin.y - box.min.y,     // Y方向：底部对齐地面
+              origin.z - center.z       // Z方向居中
+            );
             
-            console.log('📍 模型位置偏移:', {
-              x: offsetX.toFixed(2),
-              y: offsetY.toFixed(2),
-              z: offsetZ.toFixed(2)
-            });
-            console.log('✅ 模型已对齐');
+            console.log('✅ 模型已居中对齐到原点');
             
             // 统计模型信息
             var meshCount = 0;
@@ -655,98 +618,37 @@ SceneCore.prototype.loadMap = function(OBJLoader, MTLLoader) {
             
             // 基于模型包围盒自动调整相机位置和控制器目标，避免依赖配置中的 maxX/maxY
             try {
-              console.log('=== 开始自动调整相机位置 ===');
-              
-              // 🔧 修复：只计算可见mesh的包围盒，排除隐藏的地平面
-              var finalBox = new THREE.Box3();
-              var visibleMeshCount = 0;
-              
-              self.mapModel.traverse(function(child) {
-                if (child instanceof THREE.Mesh && child.visible) {
-                  // 排除隐藏的交互层
-                  if (child.name === 'HiddenGroundPlane' || child.name.includes('InteractionLayer')) {
-                    return;
-                  }
-                  
-                  // 计算该mesh的包围盒并扩展总包围盒
-                  var meshBox = new THREE.Box3().setFromObject(child);
-                  finalBox.union(meshBox);
-                  visibleMeshCount++;
-                }
-              });
-              
-              console.log('✅ 计算了 ' + visibleMeshCount + ' 个可见mesh的包围盒');
-              
+              // 使用模型当前位置重新计算包围盒和中心
+              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;
-              
-              // 确保最小距离，避免相机太近
-              if (distance < 10) {
-                distance = 10;
-                console.log('⚠️ 相机距离太近，调整为最小值: 10');
-              }
-              
-              console.log('📹 计算相机距离:', distance.toFixed(2));
 
               // 相机从斜上方俯视模型中心
-              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.position.set(
+                finalCenter.x,
+                finalCenter.y + distance,
+                finalCenter.z + distance * 0.5
+              );
               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.error('❌ 根据模型自动调整相机位置失败:', e && e.message ? e.message : e);
-              console.error('错误堆栈:', e.stack);
+              console.warn('根据模型自动调整相机位置失败:', e && e.message ? e.message : e);
             }
             
             resolve();