@kimap/indoor-positioning-sdk-vue2 4.2.0 → 4.2.2

package/package.json

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

package/src/core/KimapSDK.js

@@ -10,6 +10,9 @@ var SceneCore = require('./SceneCore.js');
 // THREE.js 将在运行时加载
 var THREE = null;
 var loadThree = loaders.loadThree;
+var loadOBJLoader = loaders.loadOBJLoader;
+var loadFBXLoader = loaders.loadFBXLoader;
+var loadGLTFLoader = loaders.loadGLTFLoader;
 
 /**
  * KimapSDK 构造函数
@@ -140,7 +143,98 @@ KimapSDK.prototype.startRenderLoop = function() {
  * @private
  */
 KimapSDK.prototype._extractWallsFromModel = function() {
-  // 实现省略，保持原有逻辑
+  var self = this;
+  
+  if (!self.core || !self.core.mapModel) {
+    console.warn('KimapSDK: 3D模型未加载，无法提取墙面数据');
+    return;
+  }
+  
+  var walls = [];
+  var floorGroups = {};
+  
+  // 遍历场景中的所有对象，查找墙面
+  self.core.mapModel.traverse(function(child) {
+    if (child.name && child.name.startsWith('Wall_')) {
+      var box = new THREE.Box3().setFromObject(child);
+      var min = box.min;
+      var max = box.max;
+      
+      var centerX = (min.x + max.x) / 2;
+      var centerZ = (min.z + max.z) / 2;
+      var width = max.x - min.x;
+      var depth = max.z - min.z;
+      var height = max.y - min.y;
+      
+      var isHorizontal = width > depth;
+      var thickness = isHorizontal ? depth : width;
+      
+      var points;
+      if (isHorizontal) {
+        points = [
+          { x: min.x * 100, y: centerZ * 100 },
+          { x: max.x * 100, y: centerZ * 100 }
+        ];
+      } else {
+        points = [
+          { x: centerX * 100, y: min.z * 100 },
+          { x: centerX * 100, y: max.z * 100 }
+        ];
+      }
+      
+      var floorLevel = Math.floor(min.y / 3);
+      
+      var wallData = {
+        type: 'wall',
+        id: child.name,
+        visible: true,
+        passable: false,
+        points: points,
+        thickness: thickness * 1000,
+        height: height * 1000,
+        floorLevel: floorLevel
+      };
+      
+      walls.push(wallData);
+      
+      if (!floorGroups[floorLevel]) {
+        floorGroups[floorLevel] = [];
+      }
+      floorGroups[floorLevel].push(wallData);
+    }
+  });
+  
+  console.log('✅ 从3D模型中提取墙面数据:', walls.length, '个墙面');
+  
+  var floors = [];
+  Object.keys(floorGroups).sort().forEach(function(level) {
+    var floorId = 'floor_' + level;
+    var floorName = (parseInt(level) + 1) + '楼';
+    
+    floors.push({
+      id: floorId,
+      name: floorName,
+      level: parseInt(level),
+      height: 3000,
+      elevation: parseInt(level) * 3000,
+      isDefault: level === '0',
+      layers: [
+        {
+          id: floorId + '_layer_walls',
+          name: '墙体图层',
+          visible: true,
+          elements: floorGroups[level]
+        }
+      ]
+    });
+  });
+  
+  if (floors.length > 0) {
+    self.setFloors(floors);
+    console.log('✅ 已自动设置楼层数据（从3D模型提取）');
+  } else {
+    console.warn('⚠️ 未从3D模型中提取到墙面数据');
+  }
 };
 
 // ==================== DOM 标记相关方法 ====================
@@ -306,19 +400,7 @@ KimapSDK.prototype.getDrawPoints = function() {
 };
 
 // ==================== 3D 模型加载相关方法 ====================
-// 注意：这部分代码较长，包含 kidata 加载、家具模型加载等
-// 为了保持文件精简，这里只保留核心方法签名
-// 完整实现请参考原 KimapCore.js 文件
-
-KimapSDK.prototype.loadKidata = function(kidataUrl) {
-  // 实现：加载 kidata 文件
-  // 原代码约 200 行
-};
-
-KimapSDK.prototype._loadFurnitureModels = function() {
-  // 实现：加载家具 3D 模型
-  // 原代码约 150 行
-};
+// loadKidata 和 _loadFurnitureModels 的完整实现在文件后面部分
 
 // ==================== 楼层管理相关方法 ====================
 
@@ -671,10 +753,188 @@ KimapSDK.prototype._loadFurnitureModels = function(kidataObj) {
     this.core.scene.add(this.furnitureGroup);
   }
   
+  // 清空现有家具
+  while (this.furnitureGroup.children.length > 0) {
+    var child = this.furnitureGroup.children[0];
+    this.furnitureGroup.remove(child);
+    
+    // 释放资源
+    if (child.geometry) child.geometry.dispose();
+    if (child.material) {
+      if (Array.isArray(child.material)) {
+        child.material.forEach(function(m) { m.dispose(); });
+      } else {
+        child.material.dispose();
+      }
+    }
+  }
+  
+  // 优先使用dataUrl，如果不存在则使用serverUrl（兼容旧版本）
+  var serverUrl = kidataObj.dataUrl || kidataObj.serverUrl;
+  var loadPromises = [];
+  var loadedCount = 0;
+  var failedCount = 0;
+  
   console.log('📦 开始加载', kidataObj.furnitures.length, '个家具模型');
   
-  // 简化版本:暂时返回成功,实际加载逻辑可以后续完善
-  return Promise.resolve({ loaded: 0, failed: 0, message: '家具加载功能需要完整实现' });
+  // 加载每个家具模型
+  kidataObj.furnitures.forEach(function(furniture) {
+    var promise = self._loadSingleFurniture(furniture, serverUrl)
+      .then(function(mesh) {
+        if (mesh) {
+          self.furnitureGroup.add(mesh);
+          loadedCount++;
+        } else {
+          failedCount++;
+        }
+      })
+      .catch(function(error) {
+        console.error('加载家具模型失败:', furniture.type, error);
+        failedCount++;
+      });
+    
+    loadPromises.push(promise);
+  });
+  
+  return Promise.all(loadPromises).then(function() {
+    return { loaded: loadedCount, failed: failedCount };
+  });
+};
+
+/**
+ * 加载单个家具模型
+ * @private
+ * @param {Object} furniture - 家具数据
+ * @param {string} serverUrl - 模型服务器URL
+ * @returns {Promise<THREE.Object3D>} 返回加载的模型对象
+ */
+KimapSDK.prototype._loadSingleFurniture = function(furniture, serverUrl) {
+  var self = this;
+  
+  return new Promise(function(resolve, reject) {
+    // 构建模型URL
+    var baseUrl = serverUrl || self.dataUrl;
+
+    // 从 id 中解析扩展名
+    var rawId = furniture.id || '';
+    var ext = '.obj';
+    var id = rawId;
+
+    if (typeof rawId === 'string') {
+      var dotIndex = rawId.lastIndexOf('.');
+      if (dotIndex >= 0) {
+        ext = rawId.substring(dotIndex).toLowerCase();
+        id = rawId.substring(0, dotIndex);
+      }
+    }
+
+    var modelUrl;
+    var loaderPromise;
+
+    // 根据文件扩展名选择合适的loader
+    if (ext === '.fbx') {
+      modelUrl = baseUrl + '/' + furniture.type + '/' + id + ext;
+      loaderPromise = loadFBXLoader().then(function(FBXLoader) {
+        return new FBXLoader();
+      });
+    } else if (ext === '.glb' || ext === '.gltf') {
+      modelUrl = baseUrl + '/' + furniture.type + '/' + id + ext;
+      loaderPromise = loadGLTFLoader().then(function(GLTFLoader) {
+        return new GLTFLoader();
+      });
+    } else {
+      // 默认使用OBJ格式
+      modelUrl = baseUrl + '/' + furniture.type + '/' + id + '.obj';
+      loaderPromise = loadOBJLoader().then(function(OBJLoader) {
+        return new OBJLoader();
+      });
+    }
+    
+    // 等待loader加载完成后再加载模型
+    loaderPromise.then(function(loader) {
+      loader.load(
+        modelUrl,
+        function(result) {
+          // GLTF/GLB格式返回的是gltf对象，需要提取scene
+          var obj = (ext === '.glb' || ext === '.gltf') ? result.scene : result;
+        // 应用旋转
+        obj.rotation.set(
+          furniture.rotation.x,
+          furniture.rotation.y,
+          furniture.rotation.z
+        );
+        
+        // 应用缩放
+        if (furniture.targetSize) {
+          // 计算模型的边界框
+          var box = new THREE.Box3().setFromObject(obj);
+          var size = new THREE.Vector3();
+          box.getSize(size);
+          
+          // 计算归一化缩放因子
+          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;
+          
+          // 应用归一化缩放和用户缩放
+          var finalScale = uniformScale * furniture.scale.x;
+          obj.scale.set(finalScale, finalScale, finalScale);
+        } else {
+          // 兼容旧版本kidata，直接使用scale值
+          obj.scale.set(
+            furniture.scale.x,
+            furniture.scale.y,
+            furniture.scale.z
+          );
+        }
+        
+        // 应用颜色（如果有）
+        if (furniture.color) {
+          var color = new THREE.Color(furniture.color);
+          obj.traverse(function(child) {
+            if (child instanceof THREE.Mesh) {
+              if (Array.isArray(child.material)) {
+                child.material.forEach(function(mat) {
+                  if (mat.color) mat.color.copy(color);
+                });
+              } else if (child.material && child.material.color) {
+                child.material.color.copy(color);
+              }
+            }
+          });
+        }
+        
+        // 重新计算边界框，将模型底部对齐到地面
+        var scaledBox = new THREE.Box3().setFromObject(obj);
+        var bottomOffset = -scaledBox.min.y;
+        
+        // 应用位置（包含底部对齐偏移）
+        obj.position.set(
+          furniture.position.x,
+          furniture.position.y + bottomOffset,
+          furniture.position.z
+        );
+        
+        obj.userData = {
+          type: 'furniture',
+          furnitureId: furniture.id,
+          furnitureType: furniture.type
+        };
+        
+          resolve(obj);
+        },
+        undefined,
+        function(error) {
+          console.error('❌ 家具模型加载失败:', furniture.type, error);
+          reject(error);
+        }
+      );
+    }).catch(function(error) {
+      console.error('❌ 加载家具模型loader失败:', furniture.type, error);
+      reject(error);
+    });
+  });
 };
 
 /**

package/src/core/loaders.js

@@ -108,11 +108,31 @@ function loadMTLLoader() {
   });
 }
 
+/**
+ * 加载GLTFLoader
+ */
+function loadGLTFLoader() {
+  return new Promise(function(resolve, reject) {
+    if (!THREE) {
+      reject(new Error('Three.js未初始化，请先调用loadThree()'));
+      return;
+    }
+    
+    try {
+      var module = require('three/examples/jsm/loaders/GLTFLoader.js');
+      resolve(module.GLTFLoader);
+    } catch (error) {
+      reject(new Error('Failed to load GLTFLoader: ' + error.message));
+    }
+  });
+}
+
 module.exports = {
   setThreeInstance: setThreeInstance,
   loadThree: loadThree,
   loadOrbitControls: loadOrbitControls,
   loadOBJLoader: loadOBJLoader,
   loadFBXLoader: loadFBXLoader,
-  loadMTLLoader: loadMTLLoader
+  loadMTLLoader: loadMTLLoader,
+  loadGLTFLoader: loadGLTFLoader
 };