@kimap/indoor-positioning-sdk-vue2 5.3.6 → 5.3.9

package/package.json

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

package/src/core/KimapSDK.js

@@ -105,11 +105,6 @@ KimapSDK.prototype.init = function() {
       // 默认显示第一个楼层（而不是ALL模式）
       if (self.isMultiFloor && self.floorGroups && self.floorGroups.length > 0) {
         self._showSingleFloor(0);
-      } else if (self.dataUrl && self.config.objUrl) {
-        // 单楼层/单模型模式：自动加载家具
-        self.loadKMData().then(function(result) {
-          console.log('家具自动加载完成:', result);
-        });
       }
 
       return self;
@@ -1263,25 +1258,24 @@ KimapSDK.prototype._createTechGround = function() {
   this.techGroundGroup.visible = false; // 默认隐藏
   this.core.scene.add(this.techGroundGroup);
 
-  // 创建半透明深色地面（ALL 模式背景，不遮挡模型）
+  // 创建网格地面
+  var gridHelper = new THREE.GridHelper(groundSize, 50, 0x0066aa, 0x003355);
+  gridHelper.position.y = -0.1;
+  gridHelper.material.opacity = 0.3;
+  gridHelper.material.transparent = true;
+  this.techGroundGroup.add(gridHelper);
+
+  // 创建地面平面
   var groundGeometry = new THREE.PlaneGeometry(groundSize, groundSize);
   var groundMaterial = new THREE.MeshBasicMaterial({
-    color: 0x1a2a3a, // 深蓝灰色，比之前稍浅以免太暗
+    color: 0x0a1628,
     transparent: true,
-    opacity: 0.4, // 降低透明度避免遮挡
-    side: THREE.DoubleSide
+    opacity: 0.8
   });
   var ground = new THREE.Mesh(groundGeometry, groundMaterial);
   ground.rotation.x = -Math.PI / 2;
-  ground.position.y = -0.15;
+  ground.position.y = -0.2;
   this.techGroundGroup.add(ground);
-
-  // 创建网格地面
-  var gridHelper = new THREE.GridHelper(groundSize, 50, 0x0066aa, 0x003355);
-  gridHelper.position.y = -0.1;
-  gridHelper.material.opacity = 0.3;
-  gridHelper.material.transparent = true;
-  this.techGroundGroup.add(gridHelper);
 };
 
 /**
@@ -1960,21 +1954,19 @@ KimapSDK.prototype._loadSingleFurniture = function(furniture, serverUrl) {
                   // =====================================================
                   furnitureGroup.renderOrder = 3000;
 
-                  // 只对透明材质关闭 depthWrite，避免不透明家具被遮挡
+                  // 遍历模型，设置材质的深度测试和写入
                   obj.traverse(function(child) {
                     if (child instanceof THREE.Mesh) {
                       if (Array.isArray(child.material)) {
                         child.material.forEach(function(mat) {
-                          // 仅对透明材质关闭 depthWrite
-                          if (mat.transparent || mat.opacity < 1) {
-                            mat.depthWrite = false;
-                          }
+                          mat.depthWrite = false;
+                          mat.depthTest = true;
+                          mat.transparent = true;
                         });
                       } else if (child.material) {
-                        // 仅对透明材质关闭 depthWrite
-                        if (child.material.transparent || child.material.opacity < 1) {
-                          child.material.depthWrite = false;
-                        }
+                        child.material.depthWrite = false;
+                        child.material.depthTest = true;
+                        child.material.transparent = true;
                       }
                     }
                   });
@@ -2021,21 +2013,19 @@ KimapSDK.prototype._loadSingleFurniture = function(furniture, serverUrl) {
                   // 应用Y轴微小偏移
                   obj.position.y += totalYOffset;
 
-                  // 只对透明材质关闭 depthWrite，避免不透明家具被遮挡
+                  // 遍历模型，设置材质的深度测试和写入
                   obj.traverse(function(child) {
                     if (child instanceof THREE.Mesh) {
                       if (Array.isArray(child.material)) {
                         child.material.forEach(function(mat) {
-                          // 仅对透明材质关闭 depthWrite
-                          if (mat.transparent || mat.opacity < 1) {
-                            mat.depthWrite = false;
-                          }
+                          mat.depthWrite = false;
+                          mat.depthTest = true;
+                          mat.transparent = true;
                         });
                       } else if (child.material) {
-                        // 仅对透明材质关闭 depthWrite
-                        if (child.material.transparent || child.material.opacity < 1) {
-                          child.material.depthWrite = false;
-                        }
+                        child.material.depthWrite = false;
+                        child.material.depthTest = true;
+                        child.material.transparent = true;
                       }
                     }
                   });

package/src/core/SceneCore.js

@@ -180,11 +180,11 @@ SceneCore.prototype.initControls = function(OrbitControls) {
  */
 SceneCore.prototype.setupLights = function() {
   // 环境光
-  var ambientLight = new THREE.AmbientLight(0xffffff, 0.6);
+  var ambientLight = new THREE.AmbientLight(0xffffff, 0.25);
   this.scene.add(ambientLight);
-
+  
   // 主光源（从上方）
-  var directionalLight1 = new THREE.DirectionalLight(0xffffff, 0.8);
+  var directionalLight1 = new THREE.DirectionalLight(0xffffff, 0.05);
   directionalLight1.position.set(10, 20, 10);
   directionalLight1.castShadow = true;
   directionalLight1.shadow.camera.left = -50;
@@ -192,14 +192,14 @@ SceneCore.prototype.setupLights = function() {
   directionalLight1.shadow.camera.top = 50;
   directionalLight1.shadow.camera.bottom = -50;
   this.scene.add(directionalLight1);
-
+  
   // 辅助光源
-  var directionalLight2 = new THREE.DirectionalLight(0xffffff, 0.3);
+  var directionalLight2 = new THREE.DirectionalLight(0xffffff, 0);
   directionalLight2.position.set(-10, 15, -10);
   this.scene.add(directionalLight2);
-
+  
   // 半球光
-  var hemisphereLight = new THREE.HemisphereLight(0xffffff, 0x444444, 0.4);
+  var hemisphereLight = new THREE.HemisphereLight(0xffffff, 0x444444, 0.3);
   this.scene.add(hemisphereLight);
 };
 
@@ -698,10 +698,10 @@ SceneCore.prototype._processLoadedModel = function(object, materials, colorMap)
   var areaLevel = 1; // 区域层级从1开始
   
   self.mapModel.traverse(function(child) {
-    // 隐藏底平面交互层（综合检查对象名、父对象名、材质名、启发式）
-    if (self._shouldHideGroundMesh(child)) {
+    // 隐藏底平面交互层（扩展匹配规则）
+    if (self._isHiddenGroundMesh(child.name)) {
       child.visible = false;
-      console.log('✅ 隐藏交互层底平面:', child.name || (child.parent && child.parent.name) || '(启发式)');
+      console.log('✅ 隐藏交互层底平面:', child.name);
       return;
     }
 
@@ -757,7 +757,10 @@ SceneCore.prototype._processLoadedModel = function(object, materials, colorMap)
     
     areaLevel++;
   });
-  
+
+  // 检测并隐藏大面积黑色底面mesh
+  self._hideLargeBlackGroundMesh(self.mapModel);
+
   // 自动调整相机位置
   self._adjustCameraToModel();
 };
@@ -789,7 +792,7 @@ SceneCore.prototype._processLoadedModelToGroup = function(object, materials, col
 
   // 处理材质
   object.traverse(function(child) {
-    if (self._shouldHideGroundMesh(child)) {
+    if (self._isHiddenGroundMesh(child.name)) {
       child.visible = false;
       return;
     }
@@ -798,6 +801,9 @@ SceneCore.prototype._processLoadedModelToGroup = function(object, materials, col
       self._processMaterial(child, materials, colorMap);
     }
   });
+
+  // 检测并隐藏大面积黑色底面mesh
+  self._hideLargeBlackGroundMesh(object);
 };
 
 /**
@@ -855,13 +861,13 @@ SceneCore.prototype._adjustCameraToAllFloors = function() {
 
 /**
  * 判断是否为需要隐藏的底面/交互层mesh
- * 检查对象名、父对象名、材质名，以及启发式（薄黑水平面）
  * @private
  */
 SceneCore.prototype._isHiddenGroundMesh = function(name) {
   if (!name) return false;
   var lowerName = name.toLowerCase();
-  // 扩展匹配规则：包含以下关键字的mesh将被隐藏
+  // 仅匹配明确标识为底板/交互层的名称关键字
+  // 避免泛词如 'ground'/'plane'/'base' 单独出现时误伤墙体/装饰件
   var hiddenPatterns = [
     'hiddengroundplane',
     'interactionlayer',
@@ -870,7 +876,9 @@ SceneCore.prototype._isHiddenGroundMesh = function(name) {
     'groundlayer',
     'floor_ground',
     'bottom',
-    'ground_base'
+    'ground_base',
+    'floorbase',
+    'mapbase'
   ];
   return hiddenPatterns.some(function(pattern) {
     return lowerName.includes(pattern);
@@ -878,38 +886,64 @@ SceneCore.prototype._isHiddenGroundMesh = function(name) {
 };
 
 /**
- * 判断mesh是否应隐藏（综合检查对象名、父对象名、材质名、启发式）
+ * 检测并隐藏模型自带的大面积底垫mesh
+ * 基于世界空间包围盒的启发式判断（薄片+贴底+相对面积）
  * @private
  */
-SceneCore.prototype._shouldHideGroundMesh = function(child) {
-  // 1. 检查自身名称
-  if (child.name && this._isHiddenGroundMesh(child.name)) return true;
-  // 2. 检查父对象名称（OBJ loader 可能将名称放在父级）
-  if (child.parent && child.parent.name && this._isHiddenGroundMesh(child.parent.name)) return true;
-  // 3. 检查材质名（绘制平台导出的 HiddenGroundPlane_Material）
-  if (child.material && child.material.name) {
-    var mtlName = child.material.name.toLowerCase();
-    if (mtlName.includes('hiddengroundplane') || mtlName.includes('interactionlayer')) return true;
-  }
-  // 4. 启发式：近似水平、很薄、近黑色的大面积mesh（模型下的黑底）
-  if (child.isMesh && child.geometry) {
+SceneCore.prototype._hideLargeBlackGroundMesh = function(object) {
+  var self = this;
+
+  // 1. 计算模型整体世界空间包围盒
+  var modelBox = new THREE.Box3().setFromObject(object);
+  var modelMinY = modelBox.min.y;
+  var modelSize = new THREE.Vector3();
+  modelBox.getSize(modelSize);
+  var maxDim = Math.max(modelSize.x, modelSize.z);
+
+  // 2. 动态阈值（相对于模型尺度）
+  var slabMaxThickness = Math.max(0.05, 0.01 * maxDim); // 厚度上限
+  var minFootprint = Math.max(1, 0.05 * modelSize.x * modelSize.z); // 最小占地面积（比固定 1000 更灵活）
+  var epsilon = Math.max(0.01, 0.002 * modelSize.y); // 贴底判定容差
+
+  var debugMode = this.config && this.config.debugBottomMeshes === true;
+
+  object.traverse(function(child) {
+    if (!(child instanceof THREE.Mesh)) return;
+    if (child.visible === false) return;
+
+    // 名称已明确匹配的，保持隐藏（不在此重复打印）
+    if (self._isHiddenGroundMesh(child.name)) return;
+
+    if (!child.geometry || !child.geometry.attributes.position) return;
+
+    // 2. 计算世界空间包围盒（考虑旋转/缩放）
     child.geometry.computeBoundingBox();
-    var box = child.geometry.boundingBox;
-    var size = new THREE.Vector3();
-    box.getSize(size);
-    var height = size.y;
-    var area = size.x * size.z;
-    var isThinHorizontal = height < 0.05 && area > 1;
-    if (isThinHorizontal && child.material) {
-      var col = child.material.color;
-      if (col) {
-        var r = col.r, g = col.g, b = col.b;
-        var isNearBlack = (r + g + b) < 0.15;
-        if (isNearBlack) return true;
-      }
+    var worldBox = new THREE.Box3().setFromObject(child);
+    var sizeWorld = new THREE.Vector3();
+    worldBox.getSize(sizeWorld);
+    var worldMinY = worldBox.min.y;
+
+    // 3. 底垫判定：必须同时满足「贴底」+「薄片」+「够大」
+    var isBottomSlab = (
+      worldMinY <= modelMinY + epsilon &&                    // 贴底
+      sizeWorld.y < slabMaxThickness &&                      // 薄片
+      sizeWorld.x * sizeWorld.z > minFootprint               // 够大
+    );
+
+    if (debugMode) {
+      console.log('[debugBottomMeshes]', child.name || 'unnamed',
+        'worldMinY:', worldMinY.toFixed(3),
+        'size:', sizeWorld.x.toFixed(1), 'x', sizeWorld.z.toFixed(1), 'x', sizeWorld.y.toFixed(3),
+        'isBottomSlab:', isBottomSlab
+      );
     }
-  }
-  return false;
+
+    if (isBottomSlab) {
+      child.visible = false;
+      console.log('[KimapSDK] Hidden bottom slab mesh:', child.name || 'unnamed',
+        'size:', sizeWorld.x.toFixed(1), 'x', sizeWorld.z.toFixed(1), 'x', sizeWorld.y.toFixed(3));
+    }
+  });
 };
 
 /**
@@ -967,8 +1001,10 @@ SceneCore.prototype._processMaterial = function(child, materials, colorMap) {
           depthWrite = opacity >= 0.8;
         }
       }
-      // 直接使用原始颜色，不做混白处理
-      finalColor = mtlColor;
+      // 混合10%白色，让颜色更浅一点
+      var color = new THREE.Color(mtlColor);
+      color.lerp(new THREE.Color(0xffffff), 0.3);
+      finalColor = color.getHex();
     }
     
     child.material = new THREE.MeshStandardMaterial({