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

package/package.json

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

package/src/core/SceneCore.js

@@ -29,6 +29,7 @@ var extractColorsFromOBJ = parsers.extractColorsFromOBJ;
 var extractTextElementsFromOBJ = parsers.extractTextElementsFromOBJ;
 var extractWallOpacityFromOBJ = parsers.extractWallOpacityFromOBJ;
 var extractShapeOpacityFromOBJ = parsers.extractShapeOpacityFromOBJ;
+var extractCalibrationBoundaryAreaIdsFromOBJ = parsers.extractCalibrationBoundaryAreaIdsFromOBJ;
 
 /**
  * SceneCore 构造函数
@@ -64,6 +65,8 @@ function SceneCore(config) {
   this.floorGroups = [];           // 楼层Group数组
   this.floorHeight = 3;            // 每层高度（米）
   this.isMultiFloor = Array.isArray(config.objUrl); // 是否多楼层模式
+  /** @type {string[]} 从 OBJ 注释解析的校准边界区域 ID（仅此类区域需隐藏） */
+  this._calibrationBoundaryAreaIds = [];
 }
 
 /**
@@ -426,6 +429,8 @@ SceneCore.prototype._loadKimapFile = function(kimapUrl, themeUrl, objLoader, mtl
           if (mapConfig && mapConfig.isCalibrated) {
             self._mapConfig = mapConfig;
           }
+
+          self._calibrationBoundaryAreaIds = extractCalibrationBoundaryAreaIdsFromOBJ(objContent);
           
           // 提取颜色信息（作为备用）
           var colorMap = materials ? {} : extractColorsFromOBJ(objContent);
@@ -499,6 +504,7 @@ SceneCore.prototype._loadOBJFile = function(url, objLoader, resolve, reject) {
         url,
         function(object) {
           console.log('OBJ文件下载完成，开始处理...');
+          self._calibrationBoundaryAreaIds = [];
           self._processLoadedModel(object, null, {});
           resolve();
         },
@@ -593,6 +599,8 @@ SceneCore.prototype._loadKimapFileToGroup = function(kimapUrl, themeUrl, objLoad
             if (mapConfig && mapConfig.isCalibrated) {
               self._mapConfig = mapConfig;
             }
+
+            self._calibrationBoundaryAreaIds = extractCalibrationBoundaryAreaIdsFromOBJ(objContent);
           }
 
           var colorMap = materials ? {} : extractColorsFromOBJ(objContent);
@@ -646,6 +654,9 @@ SceneCore.prototype._loadOBJFileToGroup = function(url, objLoader, floorGroup, f
     url,
     function(object) {
       console.log('楼层OBJ文件下载完成，开始处理...');
+      if (floorIndex === 0) {
+        self._calibrationBoundaryAreaIds = [];
+      }
       self._processLoadedModelToGroup(object, null, {}, floorGroup, floorIndex);
       resolve();
     },
@@ -760,6 +771,8 @@ SceneCore.prototype._processLoadedModel = function(object, materials, colorMap)
 
   // 检测并隐藏大面积黑色底面mesh
   self._hideLargeBlackGroundMesh(self.mapModel);
+  // 仅隐藏「校准边界」区域（真实世界尺寸检测用），普通 Area_ 地面保留
+  self._hideCalibrationBoundaryAreaMeshes(self.mapModel);
 
   // 自动调整相机位置
   self._adjustCameraToModel();
@@ -804,6 +817,7 @@ SceneCore.prototype._processLoadedModelToGroup = function(object, materials, col
 
   // 检测并隐藏大面积黑色底面mesh
   self._hideLargeBlackGroundMesh(object);
+  self._hideCalibrationBoundaryAreaMeshes(object);
 };
 
 /**
@@ -885,9 +899,90 @@ SceneCore.prototype._isHiddenGroundMesh = function(name) {
   });
 };
 
+/**
+ * 遍历 mesh 上所有材质的 name（支持多材质）
+ * @private
+ */
+SceneCore.prototype._eachMeshMaterialName = function(mesh, callback) {
+  var m = mesh.material;
+  if (!m) return;
+  if (Array.isArray(m)) {
+    for (var i = 0; i < m.length; i++) {
+      if (m[i] && m[i].name) {
+        callback(m[i].name);
+      }
+    }
+  } else if (m.name) {
+    callback(m.name);
+  }
+};
+
+/**
+ * 是否任一材质名以指定前缀开头
+ * @private
+ */
+SceneCore.prototype._meshMaterialStartsWith = function(mesh, prefix) {
+  var found = false;
+  this._eachMeshMaterialName(mesh, function(name) {
+    if (name.indexOf(prefix) === 0) {
+      found = true;
+    }
+  });
+  return found;
+};
+
+/**
+ * 隐藏「校准边界」区域 mesh（绘制端 isCalibrationBoundary / OBJ 中 Y=-0.02）
+ * 普通地面 Area_ 必须保留可见；仅此类检测用区域不显示。
+ * @private
+ */
+SceneCore.prototype._hideCalibrationBoundaryAreaMeshes = function(object) {
+  var self = this;
+  var explicitIds = self._calibrationBoundaryAreaIds || [];
+  var hasExplicit = explicitIds.length > 0;
+  var idSet = {};
+  for (var j = 0; j < explicitIds.length; j++) {
+    idSet[explicitIds[j]] = true;
+  }
+
+  object.traverse(function(child) {
+    if (!(child instanceof THREE.Mesh)) return;
+    if (!child.material || !child.geometry) return;
+
+    var areaIdsOnMesh = [];
+    self._eachMeshMaterialName(child, function(name) {
+      if (name.indexOf('Area_') === 0) {
+        areaIdsOnMesh.push(name.replace(/^Area_/, ''));
+      }
+    });
+    if (areaIdsOnMesh.length === 0) return;
+
+    child.geometry.computeBoundingBox();
+    var bb = child.geometry.boundingBox;
+    if (!bb) return;
+
+    // objExporter：校准边界顶点 Y=-0.02，普通区域 Y=0（局部几何空间）
+    var geoLooksCalib = bb.max.y < -0.005;
+
+    var matchExplicit = false;
+    for (var k = 0; k < areaIdsOnMesh.length; k++) {
+      if (hasExplicit && idSet[areaIdsOnMesh[k]]) {
+        matchExplicit = true;
+        break;
+      }
+    }
+
+    if (matchExplicit || (!hasExplicit && geoLooksCalib)) {
+      child.visible = false;
+      console.log('[KimapSDK] 已隐藏校准边界区域:', areaIdsOnMesh.join(','),
+        '(explicit:', matchExplicit, 'geometryY:', geoLooksCalib, ')');
+    }
+  });
+};
+
 /**
  * 检测并隐藏模型自带的大面积底垫mesh
- * 基于世界空间包围盒的启发式判断（薄片+贴底+相对面积）
+ * 基于世界空间包围盒的启发式判断（薄片+贴底+相对面积+颜色）
  * @private
  */
 SceneCore.prototype._hideLargeBlackGroundMesh = function(object) {
@@ -900,45 +995,127 @@ SceneCore.prototype._hideLargeBlackGroundMesh = function(object) {
   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); // 贴底判定容差
+  // 2. 动态阈值（相对于模型尺度，调整为更宽松的值）
+  // slabMaxThickness: 厚度上限，降低以检测更薄的底板
+  var slabMaxThickness = Math.max(0.02, 0.003 * maxDim);
+  // minFootprint: 最小占地面积，降低以检测更小的底板
+  var minFootprint = Math.max(0.5, 0.005 * modelSize.x * modelSize.z);
+  // epsilon: 贴底判定容差，放宽以检测更多情况
+  var epsilon = Math.max(0.05, 0.01 * modelSize.y);
 
   var debugMode = this.config && this.config.debugBottomMeshes === true;
 
+  /**
+   * 获取材质的亮度（检查是否为黑色/深色）
+   * @param {THREE.Object3D} child - 3D对象
+   * @returns {number} 亮度值（0-1），-1表示无颜色信息
+   */
+  function getMaterialLuminance(child) {
+    var mat = child.material;
+    if (!mat) return -1;
+    var color = mat.color;
+    if (!color) return -1;
+    var r = color.r, g = color.g, b = color.b;
+    return 0.299 * r + 0.587 * g + 0.114 * b;
+  }
+
+  /**
+   * 检查是否为需要跳过颜色检测的物体类型
+   * 这些物体即使颜色较深也不应该被隐藏
+   * @param {string} name - 物体名称
+   * @returns {boolean} 是否跳过
+   */
+  function shouldSkipColorCheck(name) {
+    if (!name) return false;
+    var lowerName = name.toLowerCase();
+    // 跳过有明确类型的物体
+    var skipPatterns = ['wall_', 'area_', 'shape_', 'stair_', 'door_', 'window_', 'furniture_', 'desk_', 'chair_', 'table_', 'cabinet_', 'bed_', 'sofa_', 'shelf_', 'rack_', 'plant_', 'tree_', 'lamp_', 'light_'];
+    return skipPatterns.some(function(pattern) {
+      return lowerName.startsWith(pattern);
+    });
+  }
+
+  /**
+   * 检查是否为底垫mesh
+   * 条件1: 贴底 + 薄片 + 够大（原有逻辑）
+   * 条件2: 贴底 + 超薄 + 深色（新增：检测无名称的黑色底板）
+   * 条件3: 贴底 + 中等厚度 + 超大深色（新增：检测无名称的厚深色底板）
+   * 条件4: 极薄 + 极大深色面（检测超大面积薄板）
+   * @param {THREE.Mesh} child - 网格对象
+   * @param {THREE.Vector3} sizeWorld - 世界空间尺寸
+   * @param {number} worldMinY - 世界空间最小Y
+   * @returns {boolean} 是否为底垫mesh
+   */
+  function isBottomSlab(child, sizeWorld, worldMinY) {
+    var luminance = getMaterialLuminance(child);
+    var childName = child.name || '';
+    var skipColor = shouldSkipColorCheck(childName);
+
+    // 条件1: 原有逻辑（贴底 + 薄片 + 够大）- 始终适用
+    var cond1 = (
+      worldMinY <= modelMinY + epsilon &&
+      sizeWorld.y < slabMaxThickness &&
+      sizeWorld.x * sizeWorld.z > minFootprint
+    );
+
+    // 条件2: 贴底 + 超薄 + 深色（只对无明确名称的物体生效）
+    var cond2 = !skipColor && (
+      worldMinY <= modelMinY + epsilon * 2 &&
+      sizeWorld.y < slabMaxThickness * 0.5 &&
+      luminance >= 0 && luminance < 0.15
+    );
+
+    // 条件3: 贴底 + 较大面积 + 深色（只对无明确名称的物体生效）
+    var cond3 = !skipColor && (
+      worldMinY <= modelMinY + epsilon &&
+      sizeWorld.x * sizeWorld.z > minFootprint * 5 &&
+      luminance >= 0 && luminance < 0.1
+    );
+
+    // 条件4: 极薄 + 极大深色面（只对无明确名称的物体生效）
+    var cond4 = !skipColor && (
+      worldMinY <= modelMinY + epsilon &&
+      sizeWorld.y < slabMaxThickness * 0.3 &&
+      sizeWorld.x * sizeWorld.z > minFootprint * 2 &&
+      luminance >= 0 && luminance < 0.2
+    );
+
+    return cond1 || cond2 || cond3 || cond4;
+  }
+
   object.traverse(function(child) {
     if (!(child instanceof THREE.Mesh)) return;
     if (child.visible === false) return;
 
-    // 名称已明确匹配的，保持隐藏（不在此重复打印）
+    // 名称已明确匹配的，保持隐藏
     if (self._isHiddenGroundMesh(child.name)) return;
 
+    // Area_ 地面为薄片且贴模型底边，会被 cond1 误判为底垫；校准区由 _hideCalibrationBoundaryAreaMeshes 单独处理
+    if (self._meshMaterialStartsWith(child, 'Area_')) return;
+
     if (!child.geometry || !child.geometry.attributes.position) return;
 
-    // 2. 计算世界空间包围盒（考虑旋转/缩放）
+    // 计算世界空间包围盒（考虑旋转/缩放）
     child.geometry.computeBoundingBox();
     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               // 够大
-    );
+    // 底垫判定
+    var isSlab = isBottomSlab(child, sizeWorld, worldMinY);
 
     if (debugMode) {
+      var luminance = getMaterialLuminance(child);
       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
+        'luminance:', luminance >= 0 ? luminance.toFixed(2) : 'N/A',
+        'isSlab:', isSlab
       );
     }
 
-    if (isBottomSlab) {
+    if (isSlab) {
       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));

package/src/core/parsers.js

@@ -242,6 +242,29 @@ function extractShapeOpacityFromOBJ(objContent) {
   return shapeOpacity;
 }
 
+/**
+ * 从 OBJ 中提取「真实世界尺寸校准边界」区域 ID（与绘制端 objExporter 中 # KIMAP_AREA_CALIBRATION_BOUNDARY 对应）
+ * 仅此类区域不应显示；普通 Area_ 地面应保留。
+ */
+function extractCalibrationBoundaryAreaIdsFromOBJ(objContent) {
+  var ids = [];
+  if (!objContent || typeof objContent !== 'string') {
+    return ids;
+  }
+  var lines = objContent.split('\n');
+  var prefix = '# KIMAP_AREA_CALIBRATION_BOUNDARY ';
+  for (var i = 0; i < lines.length; i++) {
+    var line = lines[i].trim();
+    if (line.indexOf(prefix) === 0) {
+      var id = line.substring(prefix.length).trim();
+      if (id) {
+        ids.push(id);
+      }
+    }
+  }
+  return ids;
+}
+
 module.exports = {
   extractBorderFromOBJ: extractBorderFromOBJ,
   extractMapConfigFromOBJ: extractMapConfigFromOBJ,
@@ -249,5 +272,6 @@ module.exports = {
   extractCoordinateSystem: extractCoordinateSystem,
   extractTextElementsFromOBJ: extractTextElementsFromOBJ,
   extractWallOpacityFromOBJ: extractWallOpacityFromOBJ,
-  extractShapeOpacityFromOBJ: extractShapeOpacityFromOBJ
+  extractShapeOpacityFromOBJ: extractShapeOpacityFromOBJ,
+  extractCalibrationBoundaryAreaIdsFromOBJ: extractCalibrationBoundaryAreaIdsFromOBJ
 };