@kimap/indoor-positioning-sdk-vue2 5.2.0 → 5.2.2

package/package.json

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

package/src/KimapCore.browser.js

@@ -277,6 +277,37 @@
     return wallOpacity;
   }
 
+  // 从OBJ内容中提取形状透明度信息（矩形、圆形、多边形）
+  function extractShapeOpacityFromOBJ(objContent) {
+    var shapeOpacity = {};
+    var lines = objContent.split('\n');
+    var currentShapeId = null;
+    var currentShapeType = null;
+    
+    for (var i = 0; i < lines.length; i++) {
+      var line = lines[i].trim();
+      
+      if (line.indexOf('o Shape_') === 0) {
+        // 提取形状ID和类型（格式：Shape_<type>_<id>）
+        var match = line.match(/Shape_([^_]+)_(.+)/);
+        if (match) {
+          currentShapeType = match[1];
+          currentShapeId = match[2];
+        }
+      } else if (currentShapeId && line.indexOf('# SHAPE_OPACITY') === 0) {
+        var opacity = parseFloat(line.split(' ')[2]);
+        if (!shapeOpacity[currentShapeId]) {
+          shapeOpacity[currentShapeId] = {};
+        }
+        shapeOpacity[currentShapeId].opacity = opacity;
+        shapeOpacity[currentShapeId].type = currentShapeType;
+      }
+    }
+    
+    console.log('[Parsers] 提取到的形状透明度:', Object.keys(shapeOpacity).length, '个形状');
+    return shapeOpacity;
+  }
+
   /**
    * 3D 场景核心
    */
@@ -406,7 +437,7 @@
     
     var centerX = origin.x + maxX / 2;
     var centerZ = origin.z;
-    var distance = Math.max(maxX, maxY) * 1.5;
+    var distance = Math.max(maxX, maxY) * 1.2;
     
     this.camera.position.set(centerX, distance, centerZ + distance * 0.5);
     this.camera.lookAt(centerX, 0, centerZ);
@@ -646,6 +677,13 @@
                   self._wallOpacity = wallOpacity;
                 }
                 
+                // 提取形状透明度信息（矩形、圆形、多边形）
+                var shapeOpacity = extractShapeOpacityFromOBJ(objContent);
+                if (shapeOpacity && Object.keys(shapeOpacity).length > 0) {
+                  console.log('✅ 从OBJ提取到形状透明度:', Object.keys(shapeOpacity).length, '个形状');
+                  self._shapeOpacity = shapeOpacity;
+                }
+                
                 var object = objLoader.parse(objContent);
                 self.processModel(object, colorMap);
                 
@@ -769,11 +807,18 @@
                      child.material.name.startsWith('Stair_')) {
             roughness = 0.6;
             metalness = 0;
-            // 保持从MTL中获取的真实透明度
-            if (opacity === 1.0) {
-              opacity = 0.9;
+            
+            // 从OBJ提取的形状透明度数据中读取
+            if (self._shapeOpacity) {
+              var shapeId = child.material.name.replace('Shape_', '').replace(/^rectangle_/, '').replace(/^circle_/, '').replace(/^polygon_/, '');
+              if (self._shapeOpacity[shapeId]) {
+                opacity = self._shapeOpacity[shapeId].opacity;
+                transparent = opacity < 1.0;
+                // 高透明度时关闭depthWrite
+                depthWrite = opacity >= 0.8;
+                console.log('[SceneCore] 应用形状透明度:', shapeId, '=', opacity);
+              }
             }
-            transparent = opacity < 1.0;
             // 混合10%白色，让颜色更浅一点
             var color = new THREE.Color(mtlColor);
             color.lerp(new THREE.Color(0xffffff), 0.1);
@@ -906,7 +951,7 @@
    */
   SceneCore.prototype.adjustCameraToModel = function(modelSize) {
     var maxDimension = Math.max(modelSize.x, modelSize.z);
-    var distance = maxDimension * 1.5;
+    var distance = maxDimension * 1.2;
     
     // 计算模型中心（模型已经移动到原点，所以中心就是尺寸的一半）
     var centerX = modelSize.x / 2;
@@ -1771,6 +1816,60 @@
     this.core.controls.target.set(centerX, 0, centerZ);
     this.core.controls.update();
   };
+
+  /**
+   * 自动调整相机视角，使其能够完整看到整个地图模型
+   * @param {Object} options - 配置选项
+   * @param {number} [options.distanceFactor=1.0] - 相机距离因子，值越小相机越近
+   * @param {number} [options.xFactor=0.5] - X轴偏移因子
+   * @param {number} [options.yFactor=0.4] - Y轴偏移因子（高度）
+   * @param {number} [options.zFactor=0.5] - Z轴偏移因子
+   */
+  KimapSDK.prototype.autoAdjustCamera = function(options) {
+    var self = this;
+    
+    if (!self.core || !self.core.mapModel) {
+      console.warn('KimapSDK: 地图模型未加载，无法调整相机');
+      return;
+    }
+
+    var opts = options || {};
+    var distanceFactor = opts.distanceFactor !== undefined ? opts.distanceFactor : 1.0;
+    var xFactor = opts.xFactor !== undefined ? opts.xFactor : 0.5;
+    var yFactor = opts.yFactor !== undefined ? opts.yFactor : 0.4;
+    var zFactor = opts.zFactor !== undefined ? opts.zFactor : 0.5;
+
+    var box = new THREE.Box3().setFromObject(self.core.mapModel);
+    var center = new THREE.Vector3();
+    var size = new THREE.Vector3();
+
+    box.getCenter(center);
+    box.getSize(size);
+
+    var maxDim = Math.max(size.x, size.y, size.z);
+    var distance = maxDim * distanceFactor;
+
+    self.core.camera.position.set(
+      center.x + distance * xFactor,
+      center.y + distance * yFactor,
+      center.z + distance * zFactor
+    );
+
+    self.core.camera.lookAt(center);
+    
+    if (self.core.controls) {
+      self.core.controls.target.copy(center);
+      self.core.controls.update();
+    }
+
+    console.log('KimapSDK: 相机已自动调整', {
+      center: center,
+      distance: distance,
+      size: size
+    });
+    
+    return self;
+  };
   
   /**
    * 相机控制 - 正视图
@@ -1899,8 +1998,6 @@
     var fileName = objUrl.split('/').pop().replace(/\.(obj|kimap)$/i, '');
     var kidataUrl = directory + '/' + fileName + '.kidata';
     
-    console.log('📦 开始加载3D家具模型数据:', kidataUrl);
-    
     return fetch(kidataUrl)
       .then(function(response) {
         if (!response.ok) {
@@ -1918,31 +2015,25 @@
         
         // 如果kidata包含楼层数据，设置为projectLayers
         if (kidataObj.floors && Array.isArray(kidataObj.floors)) {
-          console.log('KimapSDK: kidata包含楼层数据，楼层数量:', kidataObj.floors.length);
           // 设置第一个楼层为当前楼层（如果没有其他楼层数据）
           if (!self.projectLayers && kidataObj.floors.length > 0) {
             self.projectLayers = kidataObj.floors[0].layers;
-            console.log('KimapSDK: 从kidata设置楼层数据，图层数量:', self.projectLayers.length);
           }
         }
         
-        console.log('✅ Kidata文件解密成功:', {
-          version: kidataObj.version,
-          serverUrl: kidataObj.serverUrl,
-          furnitureCount: kidataObj.furnitures ? kidataObj.furnitures.length : 0,
-          floorCount: kidataObj.floors ? kidataObj.floors.length : 0
-        });
-        
         // 加载3D家具模型
         return self._loadFurnitureModels(kidataObj);
       })
       .then(function(result) {
-        console.log('✅ 3D家具模型加载完成:', result);
+        console.log('✅ 家具加载完成：成功 ' + result.loaded + ' 个，失败 ' + result.failed + ' 个');
+        
+        // 加载完成后应用形状透明度
+        self._applyShapeOpacity(kidataObj);
         
         return { success: true, loaded: result.loaded, failed: result.failed };
       })
       .catch(function(error) {
-        console.error('❌ 加载3D家具模型失败:', error);
+        console.error('❌ 家具加载失败：', error.message);
         return { success: false, error: error.message };
       });
   };
@@ -2026,7 +2117,6 @@
           }
         })
         .catch(function(error) {
-          console.error('加载家具模型失败:', furniture.type, error);
           failedCount++;
         });
       
@@ -2082,8 +2172,6 @@
       loader.load(
         modelUrl,
         function(obj) {
-          console.log('🔧 [家具模型加载] 开始处理:', furniture.type);
-          
           // 计算模型的边界框
           var box = new THREE.Box3().setFromObject(obj);
           var size = new THREE.Vector3();
@@ -2111,16 +2199,6 @@
           var finalScaleY = scaleY * userScaleY;
           var finalScaleZ = scaleZ * userScaleZ;
           
-          console.log('🔧 [家具缩放] 原始模型尺寸:', { x: size.x.toFixed(4), y: size.y.toFixed(4), z: size.z.toFixed(4) });
-          console.log('🔧 [家具缩放] 目标尺寸:', { width: targetWidth.toFixed(4), height: targetHeight.toFixed(4), depth: targetDepth.toFixed(4) });
-          console.log('🔧 [家具缩放] 轴向缩放因子:', { scaleX: scaleX.toFixed(4), scaleY: scaleY.toFixed(4), scaleZ: scaleZ.toFixed(4) });
-          console.log('🔧 [家具缩放] 用户缩放:', { x: userScaleX, y: userScaleY, z: userScaleZ });
-          console.log('🔧 [家具缩放] 最终缩放:', { 
-            x: finalScaleX.toFixed(4), 
-            y: finalScaleY.toFixed(4), 
-            z: finalScaleZ.toFixed(4) 
-          });
-          
           obj.scale.set(finalScaleX, finalScaleY, finalScaleZ);
 
           // ========== 修复2: 位置处理（与绘制平台一致）==========
@@ -2142,11 +2220,6 @@
           var scaledBottomY = scaledBox.min.y;
           var elevation = furniture.position.y; // 离地高度（米）
 
-          console.log('🔧 [家具] scaledCenter:', scaledCenter);
-          console.log('🔧 [家具] scaledBottomY:', scaledBottomY);
-          console.log('🔧 [家具] elevation:', elevation);
-          console.log('🔧 [家具] furniture.position:', furniture.position);
-
           // ========== 旋转处理：使用Group包装（围绕家具中心旋转）==========
           var hasRotation = furniture.rotation && (
             furniture.rotation.x !== 0 ||
@@ -2172,8 +2245,6 @@
               -scaledCenter.z
             );
 
-            console.log('🔧 [家具位置] obj.position（中心偏移）:', obj.position);
-
             // 2. 将obj添加到Group
             furnitureGroup.add(obj);
 
@@ -2185,20 +2256,15 @@
               furniture.position.z
             );
 
-            console.log('🔧 [家具位置] furnitureGroup.position（世界位置）:', furnitureGroup.position);
-
             // 4. 应用旋转到Group（围绕Group原点，即家具中心）
             if (furniture.rotation.y) {
               furnitureGroup.rotation.y = furniture.rotation.y;
-              console.log('🔧 [家具旋转] 应用Y轴旋转:', furniture.rotation.y.toFixed(4), 'rad =', (furniture.rotation.y * 180 / Math.PI).toFixed(1) + '°');
             }
             if (furniture.rotation.x) {
               furnitureGroup.rotation.x = furniture.rotation.x;
-              console.log('🔧 [家具旋转] 应用X轴旋转:', furniture.rotation.x.toFixed(4), 'rad =', (furniture.rotation.x * 180 / Math.PI).toFixed(1) + '°');
             }
             if (furniture.rotation.z) {
               furnitureGroup.rotation.z = furniture.rotation.z;
-              console.log('🔧 [家具旋转] 应用Z轴旋转:', furniture.rotation.z.toFixed(4), 'rad =', (furniture.rotation.z * 180 / Math.PI).toFixed(1) + '°');
             }
 
             // 添加层级设置，确保家具在区域之上
@@ -2220,7 +2286,6 @@
               });
             }
 
-            console.log('✅ 家具模型加载成功（有旋转）:', furniture.type);
             resolve(furnitureGroup);
           } else {
             // 无旋转时直接设置obj的世界位置
@@ -2231,8 +2296,6 @@
               furniture.position.z - scaledCenter.z
             );
 
-            console.log('🔧 [家具位置] obj.position（世界位置）:', obj.position);
-
             obj.renderOrder = 3000;
 
             // 应用颜色
@@ -2257,13 +2320,11 @@
               furnitureType: furniture.type
             };
 
-            console.log('✅ 家具模型加载成功（无旋转）:', furniture.type);
             resolve(obj);
           }
         },
         undefined,
         function(error) {
-          console.error('❌ 家具模型加载失败:', furniture.type, error);
           reject(error);
         }
       );
@@ -2708,6 +2769,100 @@
     }
   };
 
+  /**
+   * 应用矩形/圆形/多边形透明度
+   * @private
+   */
+  KimapSDK.prototype._applyShapeOpacity = function(kidataObj) {
+    if (!kidataObj || !kidataObj.floors || !this.core || !this.core.scene) {
+      console.log('[KimapSDK] _applyShapeOpacity: 缺少必要数据');
+      return;
+    }
+    
+    console.log('[KimapSDK] 开始应用形状透明度...');
+    
+    var shapeCount = 0;
+    var shapesInKidata = [];
+    var self = this;
+    
+    // 收集kidata中的所有形状数据（rectangle, circle, polygon）
+    kidataObj.floors.forEach(function(floor) {
+      if (floor.layers) {
+        floor.layers.forEach(function(layer) {
+          if (layer.elements) {
+            layer.elements.forEach(function(element) {
+              if (element.type === 'rectangle' || element.type === 'circle' || element.type === 'polygon') {
+                shapesInKidata.push({
+                  id: element.id,
+                  type: element.type,
+                  opacity: element.opacity !== undefined ? element.opacity : 0.9
+                });
+              }
+            });
+          }
+        });
+      }
+    });
+    
+    console.log('[KimapSDK] Kidata中形状数量:', shapesInKidata.length);
+    
+    if (shapesInKidata.length === 0) {
+      console.log('[KimapSDK] Kidata中没有形状数据');
+      return;
+    }
+    
+    // 遍历场景中的所有对象，通过材质名称识别形状
+    this.core.scene.traverse(function(object) {
+      if (object instanceof THREE.Mesh && object.material) {
+        var materialName = object.material.name || '';
+        
+        // 通过材质名称识别形状（Shape_前缀）
+        if (materialName.startsWith('Shape_')) {
+          // 从材质名称中提取形状ID（格式：Shape_<type>_<id>）
+          var parts = materialName.split('_');
+          var shapeId = parts[parts.length - 1];
+          
+          // 在kidata中查找对应的形状数据
+          var shapeData = shapesInKidata.find(function(s) {
+            return s.id === shapeId;
+          });
+          
+          if (shapeData) {
+            var opacity = shapeData.opacity;
+            
+            console.log('[KimapSDK] 应用形状透明度:', {
+              id: shapeId,
+              type: shapeData.type,
+              opacity: opacity,
+              materialName: materialName
+            });
+            
+            // 应用透明度到材质
+            if (Array.isArray(object.material)) {
+              object.material.forEach(function(mat) {
+                mat.transparent = opacity < 1;
+                mat.opacity = opacity;
+                mat.needsUpdate = true;
+              });
+            } else {
+              object.material.transparent = opacity < 1;
+              object.material.opacity = opacity;
+              object.material.needsUpdate = true;
+            }
+            
+            shapeCount++;
+          }
+        }
+      }
+    });
+    
+    if (shapeCount > 0) {
+      console.log('[KimapSDK] ✅ 应用形状透明度完成:', shapeCount, '个形状');
+    } else {
+      console.log('[KimapSDK] ⚠️ 未找到匹配的形状对象');
+    }
+  };
+
   /**
    * 从kidata内容加载家具模型（不处理文本和墙体透明度）
    * @param {string} kidataContent - kidata文件内容（加密或未加密）
@@ -2725,27 +2880,21 @@
       
       // 如果kidata包含楼层数据，设置为projectLayers
       if (kidataObj.floors && Array.isArray(kidataObj.floors)) {
-        console.log('[KimapSDK] kidata包含楼层数据，楼层数量:', kidataObj.floors.length);
         if (!self.projectLayers && kidataObj.floors.length > 0) {
           self.projectLayers = kidataObj.floors[0].layers;
-          console.log('[KimapSDK] 从kidata设置楼层数据，图层数量:', self.projectLayers.length);
         }
       }
       
-      console.log('[KimapSDK] ✅ Kidata文件解密成功:', {
-        version: kidataObj.version,
-        furnitureCount: kidataObj.furnitures ? kidataObj.furnitures.length : 0,
-        floorCount: kidataObj.floors ? kidataObj.floors.length : 0
-      });
-      
       // 只加载3D家具模型
       return self._loadFurnitureModels(kidataObj)
         .then(function(result) {
-          console.log('[KimapSDK] ✅ 3D家具模型加载完成:', result);
+          // 加载完成后应用形状透明度
+          self._applyShapeOpacity(kidataObj);
+          
           return { success: true, loaded: result.loaded, failed: result.failed };
         });
     } catch (error) {
-      console.error('[KimapSDK] ❌ Kidata加载失败:', error);
+      console.error('❌ Kidata加载失败：', error.message);
       return Promise.reject(error);
     }
   };

package/src/core/KimapSDK.js

@@ -603,6 +603,60 @@ KimapSDK.prototype.getCoordinateSystem = function() {
   return this.core ? this.core.coordinateSystem : null;
 };
 
+/**
+ * 自动调整相机视角，使其能够完整看到整个地图模型
+ * @param {Object} options - 配置选项
+ * @param {number} [options.distanceFactor=1.0] - 相机距离因子，值越小相机越近
+ * @param {number} [options.xFactor=0.5] - X轴偏移因子
+ * @param {number} [options.yFactor=0.4] - Y轴偏移因子（高度）
+ * @param {number} [options.zFactor=0.5] - Z轴偏移因子
+ */
+KimapSDK.prototype.autoAdjustCamera = function(options) {
+  var self = this;
+  
+  if (!self.core || !self.core.mapModel) {
+    console.warn('KimapSDK: 地图模型未加载，无法调整相机');
+    return;
+  }
+
+  var opts = options || {};
+  var distanceFactor = opts.distanceFactor !== undefined ? opts.distanceFactor : 1.0;
+  var xFactor = opts.xFactor !== undefined ? opts.xFactor : 0.5;
+  var yFactor = opts.yFactor !== undefined ? opts.yFactor : 0.4;
+  var zFactor = opts.zFactor !== undefined ? opts.zFactor : 0.5;
+
+  var box = new THREE.Box3().setFromObject(self.core.mapModel);
+  var center = new THREE.Vector3();
+  var size = new THREE.Vector3();
+
+  box.getCenter(center);
+  box.getSize(size);
+
+  var maxDim = Math.max(size.x, size.y, size.z);
+  var distance = maxDim * distanceFactor;
+
+  self.core.camera.position.set(
+    center.x + distance * xFactor,
+    center.y + distance * yFactor,
+    center.z + distance * zFactor
+  );
+
+  self.core.camera.lookAt(center);
+  
+  if (self.core.controls) {
+    self.core.controls.target.copy(center);
+    self.core.controls.update();
+  }
+
+  console.log('KimapSDK: 相机已自动调整', {
+    center: center,
+    distance: distance,
+    size: size
+  });
+  
+  return self;
+};
+
 KimapSDK.prototype.getConfig = function() {
   var config = {};
   
@@ -684,8 +738,6 @@ KimapSDK.prototype.loadKMData = function() {
   var fileName = objUrl.split('/').pop().replace(/\.(obj|kimap)$/i, '');
   var kidataUrl = directory + '/' + fileName + '.kidata';
   
-  console.log('📦 开始加载3D家具模型数据:', kidataUrl);
-  
   return fetch(kidataUrl)
     .then(function(response) {
       if (!response.ok) {
@@ -703,31 +755,22 @@ KimapSDK.prototype.loadKMData = function() {
       
       // 如果kidata包含楼层数据，设置为projectLayers
       if (kidataObj.floors && Array.isArray(kidataObj.floors)) {
-        console.log('KimapSDK: kidata包含楼层数据，楼层数量:', kidataObj.floors.length);
         // 设置第一个楼层为当前楼层（如果没有其他楼层数据）
         if (!self.projectLayers && kidataObj.floors.length > 0) {
           self.projectLayers = kidataObj.floors[0].layers;
-          console.log('KimapSDK: 从kidata设置楼层数据，图层数量:', self.projectLayers.length);
         }
       }
       
-      console.log('✅ Kidata文件解密成功:', {
-        version: kidataObj.version,
-        serverUrl: kidataObj.serverUrl,
-        furnitureCount: kidataObj.furnitures ? kidataObj.furnitures.length : 0,
-        floorCount: kidataObj.floors ? kidataObj.floors.length : 0
-      });
-      
       // 加载3D家具模型
       return self._loadFurnitureModels(kidataObj);
     })
     .then(function(result) {
-      console.log('✅ 3D家具模型加载完成:', result);
+      console.log('✅ 家具加载完成：成功 ' + result.loaded + ' 个，失败 ' + result.failed + ' 个');
       
       return { success: true, loaded: result.loaded, failed: result.failed };
     })
     .catch(function(error) {
-      console.error('❌ 加载3D家具模型失败:', error);
+      console.error('❌ 家具加载失败：', error.message);
       return { success: false, error: error.message };
     });
 };
@@ -787,8 +830,6 @@ KimapSDK.prototype._loadFurnitureModels = function(kidataObj) {
   var loadedCount = 0;
   var failedCount = 0;
   
-  console.log('📦 开始加载', kidataObj.furnitures.length, '个家具模型');
-  
   // 加载每个家具模型
   kidataObj.furnitures.forEach(function(furniture) {
     var promise = self._loadSingleFurniture(furniture, serverUrl)
@@ -801,7 +842,6 @@ KimapSDK.prototype._loadFurnitureModels = function(kidataObj) {
         }
       })
       .catch(function(error) {
-        console.error('加载家具模型失败:', furniture.type, error);
         failedCount++;
       });
     
@@ -888,8 +928,6 @@ KimapSDK.prototype._loadSingleFurniture = function(furniture, serverUrl) {
                 // GLTF/GLB格式返回的是gltf对象，需要提取scene
                 var obj = (ext === '.glb' || ext === '.gltf') ? result.scene : result;
 
-                console.log('🔧 [家具模型加载] 开始处理:', furniture.type);
-
                 // ========== 修复1: 分别计算X、Y、Z轴的缩放因子 ==========
                 // 计算模型的边界框
                 var box = new THREE.Box3().setFromObject(obj);
@@ -918,16 +956,6 @@ KimapSDK.prototype._loadSingleFurniture = function(furniture, serverUrl) {
                 var finalScaleY = scaleY * userScaleY;
                 var finalScaleZ = scaleZ * userScaleZ;
 
-                console.log('🔧 [家具缩放] 原始模型尺寸:', { x: size.x.toFixed(4), y: size.y.toFixed(4), z: size.z.toFixed(4) });
-                console.log('🔧 [家具缩放] 目标尺寸:', { width: targetWidth.toFixed(4), height: targetHeight.toFixed(4), depth: targetDepth.toFixed(4) });
-                console.log('🔧 [家具缩放] 缩放因子(预览一致):', { scaleX: scaleX.toFixed(4), scaleY: scaleY.toFixed(4), scaleZ: scaleZ.toFixed(4) });
-                console.log('🔧 [家具缩放] 用户缩放:', { x: userScaleX, y: userScaleY, z: userScaleZ });
-                console.log('🔧 [家具缩放] 最终缩放(预览一致):', {
-                  x: finalScaleX.toFixed(4),
-                  y: finalScaleY.toFixed(4),
-                  z: finalScaleZ.toFixed(4)
-                });
-
                 // 应用与预览一致的非等比缩放
                 obj.scale.set(finalScaleX, finalScaleY, finalScaleZ);
 
@@ -950,11 +978,6 @@ KimapSDK.prototype._loadSingleFurniture = function(furniture, serverUrl) {
                 var scaledBottomY = scaledBox.min.y;
                 var elevation = furniture.position.y; // 离地高度（米）
 
-                console.log('🔧 [家具] scaledCenter:', scaledCenter);
-                console.log('🔧 [家具] scaledBottomY:', scaledBottomY);
-                console.log('🔧 [家具] elevation:', elevation);
-                console.log('🔧 [家具] furniture.position:', furniture.position);
-
                 // ========== 旋转处理：使用Group包装（围绕家具中心旋转）==========
                 var hasRotation = furniture.rotation && (
                   furniture.rotation.x !== 0 ||
@@ -980,8 +1003,6 @@ KimapSDK.prototype._loadSingleFurniture = function(furniture, serverUrl) {
                     -scaledCenter.z
                   );
 
-                  console.log('🔧 [家具位置] obj.position（中心偏移）:', obj.position);
-
                   // 2. 将obj添加到Group
                   furnitureGroup.add(obj);
 
@@ -993,21 +1014,16 @@ KimapSDK.prototype._loadSingleFurniture = function(furniture, serverUrl) {
                     furniture.position.z
                   );
 
-                  console.log('🔧 [家具位置] furnitureGroup.position（世界位置）:', furnitureGroup.position);
-
                   // 4. 应用旋转到Group（围绕Group原点，即家具中心）
                   // 注意：kidata JSON中 rotation 存储的是弧度值，直接使用
                   if (furniture.rotation.y) {
                     furnitureGroup.rotation.y = furniture.rotation.y;
-                    console.log('🔧 [家具旋转] 应用Y轴旋转:', furniture.rotation.y.toFixed(4), 'rad =', (furniture.rotation.y * 180 / Math.PI).toFixed(1) + '°');
                   }
                   if (furniture.rotation.x) {
                     furnitureGroup.rotation.x = furniture.rotation.x;
-                    console.log('🔧 [家具旋转] 应用X轴旋转:', furniture.rotation.x.toFixed(4), 'rad =', (furniture.rotation.x * 180 / Math.PI).toFixed(1) + '°');
                   }
                   if (furniture.rotation.z) {
                     furnitureGroup.rotation.z = furniture.rotation.z;
-                    console.log('🔧 [家具旋转] 应用Z轴旋转:', furniture.rotation.z.toFixed(4), 'rad =', (furniture.rotation.z * 180 / Math.PI).toFixed(1) + '°');
                   }
 
                   // =====================================================
@@ -1028,12 +1044,6 @@ KimapSDK.prototype._loadSingleFurniture = function(furniture, serverUrl) {
                     }
                   });
 
-                  console.log('[KimapSDK] ✅ 家具模型层级设置:', {
-                    id: furniture.id,
-                    renderOrder: furnitureGroup.renderOrder,
-                    depthWriteDisabled: true
-                  });
-
                   // 应用颜色
                   if (furniture.color) {
                     var color = new THREE.Color(furniture.color);
@@ -1050,7 +1060,6 @@ KimapSDK.prototype._loadSingleFurniture = function(furniture, serverUrl) {
                     });
                   }
 
-                  console.log('✅ 家具模型加载成功（有旋转）:', furniture.type);
                   resolveLoad(furnitureGroup);
                 } else {
                   // 无旋转时直接设置obj的世界位置
@@ -1061,8 +1070,6 @@ KimapSDK.prototype._loadSingleFurniture = function(furniture, serverUrl) {
                     furniture.position.z - scaledCenter.z
                   );
 
-                  console.log('🔧 [家具位置] obj.position（世界位置）:', obj.position);
-
                   // =====================================================
                   // 层级系统：解决多区域与3D家具叠加时的频闪问题
                   // =====================================================
@@ -1092,13 +1099,6 @@ KimapSDK.prototype._loadSingleFurniture = function(furniture, serverUrl) {
                     }
                   });
 
-                  console.log('[KimapSDK] ✅ 家具模型层级设置:', {
-                    id: furniture.id,
-                    renderOrder: obj.renderOrder,
-                    yOffset: totalYOffset.toFixed(6) + 'm',
-                    depthWriteDisabled: true
-                  });
-
                   // 应用颜色
                   if (furniture.color) {
                     var color = new THREE.Color(furniture.color);
@@ -1121,7 +1121,6 @@ KimapSDK.prototype._loadSingleFurniture = function(furniture, serverUrl) {
                     furnitureType: furniture.type
                   };
 
-                  console.log('✅ 家具模型加载成功（无旋转）:', furniture.type);
                   resolveLoad(obj);
                 }
               },
@@ -1161,27 +1160,18 @@ KimapSDK.prototype.loadKidataForFurniture = function(kidataContent) {
     
     // 如果kidata包含楼层数据，设置为projectLayers
     if (kidataObj.floors && Array.isArray(kidataObj.floors)) {
-      console.log('[KimapSDK] kidata包含楼层数据，楼层数量:', kidataObj.floors.length);
       if (!self.projectLayers && kidataObj.floors.length > 0) {
         self.projectLayers = kidataObj.floors[0].layers;
-        console.log('[KimapSDK] 从kidata设置楼层数据，图层数量:', self.projectLayers.length);
       }
     }
     
-    console.log('[KimapSDK] ✅ Kidata文件解密成功:', {
-      version: kidataObj.version,
-      furnitureCount: kidataObj.furnitures ? kidataObj.furnitures.length : 0,
-      floorCount: kidataObj.floors ? kidataObj.floors.length : 0
-    });
-    
     // 只加载3D家具模型
     return self._loadFurnitureModels(kidataObj)
       .then(function(result) {
-        console.log('[KimapSDK] ✅ 3D家具模型加载完成:', result);
         return { success: true, loaded: result.loaded, failed: result.failed };
       });
     } catch (error) {
-      console.error('[KimapSDK] ❌ Kidata加载失败:', error);
+      console.error('❌ Kidata加载失败：', error.message);
       return Promise.reject(error);
     }
   };

package/src/core/SceneCore.js

@@ -28,6 +28,7 @@ var extractMapConfigFromOBJ = parsers.extractMapConfigFromOBJ;
 var extractColorsFromOBJ = parsers.extractColorsFromOBJ;
 var extractTextElementsFromOBJ = parsers.extractTextElementsFromOBJ;
 var extractWallOpacityFromOBJ = parsers.extractWallOpacityFromOBJ;
+var extractShapeOpacityFromOBJ = parsers.extractShapeOpacityFromOBJ;
 
 /**
  * SceneCore 构造函数
@@ -385,6 +386,13 @@ SceneCore.prototype._loadKimapFile = function(kimapUrl, themeUrl, objLoader, mtl
             console.log('[SceneCore] ✅ 从OBJ提取到墙体透明度:', Object.keys(wallOpacity).length, '个墙体');
             self._wallOpacity = wallOpacity;
           }
+          
+          // 提取形状透明度信息（矩形、圆形、多边形）
+          var shapeOpacity = extractShapeOpacityFromOBJ(objContent);
+          if (shapeOpacity && Object.keys(shapeOpacity).length > 0) {
+            console.log('[SceneCore] ✅ 从OBJ提取到形状透明度:', Object.keys(shapeOpacity).length, '个形状');
+            self._shapeOpacity = shapeOpacity;
+          }
         
           // 解析OBJ内容
           var object = objLoader.parse(objContent);
@@ -627,11 +635,17 @@ SceneCore.prototype._processMaterial = function(child, materials, colorMap) {
     } else if (child.material.name.startsWith('Shape_') || child.material.name.startsWith('Stair_')) {
       roughness = 0.6;
       metalness = 0;
-      // 保持从MTL中获取的真实透明度
-      if (opacity === 1.0) {
-        opacity = 0.9;
+      // 从OBJ提取的形状透明度数据中读取
+      if (self._shapeOpacity) {
+        var shapeId = child.material.name.replace('Shape_', '').replace(/^rectangle_/, '').replace(/^circle_/, '').replace(/^polygon_/, '');
+        if (self._shapeOpacity[shapeId]) {
+          opacity = self._shapeOpacity[shapeId].opacity;
+          transparent = opacity < 1.0;
+          // 高透明度时关闭depthWrite
+          depthWrite = opacity >= 0.8;
+          console.log('[SceneCore] 应用形状透明度:', shapeId, '=', opacity);
+        }
       }
-      transparent = opacity < 1.0;
       // 混合10%白色，让颜色更浅一点
       var color = new THREE.Color(mtlColor);
       color.lerp(new THREE.Color(0xffffff), 0.1);

package/src/core/parsers.js

@@ -213,11 +213,46 @@ function extractWallOpacityFromOBJ(objContent) {
   return wallOpacity;
 }
 
+/**
+ * 从OBJ内容中提取形状透明度信息（矩形、圆形、多边形）
+ * 格式: # SHAPE_OPACITY 0.9
+ */
+function extractShapeOpacityFromOBJ(objContent) {
+  var shapeOpacity = {};
+  var lines = objContent.split('\n');
+  var currentShapeId = null;
+  var currentShapeType = null;
+  
+  for (var i = 0; i < lines.length; i++) {
+    var line = lines[i].trim();
+    
+    if (line.indexOf('o Shape_') === 0) {
+      // 提取形状ID和类型（格式：Shape_<type>_<id>）
+      var match = line.match(/Shape_([^_]+)_(.+)/);
+      if (match) {
+        currentShapeType = match[1];
+        currentShapeId = match[2];
+      }
+    } else if (currentShapeId && line.indexOf('# SHAPE_OPACITY') === 0) {
+      var opacity = parseFloat(line.split(' ')[2]);
+      if (!shapeOpacity[currentShapeId]) {
+        shapeOpacity[currentShapeId] = {};
+      }
+      shapeOpacity[currentShapeId].opacity = opacity;
+      shapeOpacity[currentShapeId].type = currentShapeType;
+    }
+  }
+  
+  console.log('[Parsers] 提取到的形状透明度:', Object.keys(shapeOpacity).length, '个形状');
+  return shapeOpacity;
+}
+
 module.exports = {
   extractBorderFromOBJ: extractBorderFromOBJ,
   extractMapConfigFromOBJ: extractMapConfigFromOBJ,
   extractColorsFromOBJ: extractColorsFromOBJ,
   extractCoordinateSystem: extractCoordinateSystem,
   extractTextElementsFromOBJ: extractTextElementsFromOBJ,
-  extractWallOpacityFromOBJ: extractWallOpacityFromOBJ
+  extractWallOpacityFromOBJ: extractWallOpacityFromOBJ,
+  extractShapeOpacityFromOBJ: extractShapeOpacityFromOBJ
 };