IFC Element Positioning and Labeling with Respect to Axes: A Reproducible Methodology Using xBIM

Abstract

This paper presents a unified algorithm for the automatic labeling of BIM elements on floor plans with respect to IFC axis grids. Axes from IfcGrid/IfcGridAxis (letters, numbers, or mixed tags such as [LT-3] or [G\'\']) are grouped by orientation, assigned a canonical normal, and indexed using an order scalar derived from the projection of axis midpoints. With this one-dimensional indexing, the algorithm identifies point elements (axis intersections), linear elements (nearest host plus orthogonal range), and area elements (ranges in two axis families) without user intervention. The system automatically selects the classification path (area ? line ? point) according to element size. The geometric core relies on projection and bracketing, selecting bounding axes by applying tolerance and proximity criteria. Robustness is achieved through automatic flipping of normal vectors, endpoint selection by 1D distance, and canonical ascending label formatting ([A–B], [9–11], [LT-2–LT-3]). The implementation in .NET (VB) employs xBIM for IFC parsing and footprint extraction. Evaluation on synthetic and real IFC datasets measures label accuracy, endpoint accuracy, and projection error, with ablation studies on tolerance and auto-flip. Limitations include curvilinear grids, nearly parallel families, and complex footprints. The approach is simple, interpretable, and reproducible, supporting traceability in BIM workflows.

Introduction

The paper presents a tolerance-aware algorithm for automatically generating human-readable labels (e.g., [A–B, 10–11]) for architectural and structural elements (columns, beams, slabs) in BIM (IFC) models, based on grid axes (IfcGrid / IfcGridAxis). Unlike traditional approaches that require manual tagging or fragile heuristics, this method is unified, robust, and automated, working across different element types and grid tag formats.

Core Idea

The method projects an element’s 2D floor plan geometry onto two approximately orthogonal axis groups and brackets the projection using the nearest grid lines within a defined tolerance. It handles numeric and alphanumeric grid labels, supports slight misalignments and rounding errors, and normalizes the output into ascending, drawing-friendly tags.

Key Components

1. Axis Grouping and Indexing

• Axes from the IFC grid are grouped by orientation using angular clustering.

• Each group gets a canonical normal vector (perpendicular direction) and an order value (orderVal) by projecting axis midpoints.

• Axes are sorted within each group using orderVal.

2. Bracketing by Projection

• Element geometry (point, segment, polygon) is projected onto each group’s normal.

• Nearest axes are selected to bracket the geometry using a tolerance band.

• An auto-flip rule handles direction inconsistencies when projections fall on one side.

• The selected axes are normalized in ascending order.

3. Element Types (Unified Approach)

• Point elements (e.g., columns): labeled by grid intersections.

• Linear elements (e.g., beams, walls): labeled by host axis + range along the orthogonal group.

• Area elements (e.g., slabs): labeled by ranges in both axis groups.

• The system auto-detects the element type based on size and geometry.

Robustness Features

• Handles rounding errors, floating-point precision, and label inconsistency.

• Uses robust geometric predicates (e.g., orientation tests) for near-degenerate cases.

• Tolerances are used for all key decisions: bracketing, proximity, containment.

Fallback: No IfcGrid

• If no explicit grid is present in the IFC model, the algorithm can recover axis families via Hough transform on existing geometry.

Output Format

• Canonical labels are formatted as:

  • Numeric: [5–7]

  • Alphabetic: [A–C]

  • Prefix + Number: [LT-1 – LT-3]

• Mixed or ambiguous tags are sorted geometrically (not lexically).

Implementation

• Implemented in VB.NET on .NET Framework 4.6.x using xBIM Toolkit.

• Engine-agnostic: requires only 2D geometry (segments and element footprint).

• Open, reproducible, and extensible.

Main Contributions

1. A single, unified algorithm for labeling all element types.

2. Orientation-based axis indexing with robust ordering and auto-flip.

3. Tolerance-based, stable bracketing to avoid label flickering.

4. Output labels are drawing-aligned and normalized across tag types.

5. Reproducible implementation using open-source tools.

Conclusion

This study introduced a unified algorithm for labeling BIM elements on floor plans with respect to IFC grids. The method is capable of handling point, linear, and area elements without user intervention. Its main contributions include an orientation-based indexing scheme with canonical normal vectors and order scalars, projection-based bracketing with endpoint proximity and auto-flip rules, explicit metric tolerances, and canonical ascending formatting of tags. Together, these components enable stable and human-readable labels even in the presence of heterogeneous tags, irregular spacings, and minor geometric misalignments. The approach provides several practical benefits. First, robustness is achieved by combining projections with endpoint proximity, which prevents unstable jumps caused by discretization or noise, while the auto-flip rule corrects inconsistent sign conventions between axis families and element geometry. Second, neutrality with respect to tags is ensured by relying on the internal orderVal scalar, which is valid for alphanumeric and mixed labels such as A, B, G\'\', LT-3, 11. Third, scalability is supported because indexing is performed once and labeling is linear in the number of vertices, with direct parallelization by element. Finally, the algorithm is independent of any visualization engine, requiring only 2D segments (axes) and element footprints, and can therefore be integrated into batch pipelines or interactive software. To facilitate reproducibility, we provide guidelines regarding input data (axis lists and floor-plan geometries), reference parameters (metric tolerances, angular thresholds, and minimum dimensions), and software implementation in .Net (VB) with xBIM for IFC parsing. An evaluation protocol is also suggested, combining accuracy metrics with ablation studies to assess the influence of tolerance, auto-flip, and endpoint selection. Several research directions arise from this work. Adaptive tolerances based on axis spacing statistics may increase robustness, while extensions to curvilinear and radial grids could broaden applicability. Methods such as Hough or RANSAC can serve to recover implicit grids when IfcGrid is not available. In terms of performance, binary search on one-dimensional arrays, SIMD projection routines, and parallel execution provide promising avenues for acceleration. Overall, the “project and bracket by proximity” approach offers a simple, interpretable, and reproducible solution to the recurring problem of grid-based labeling. Its combination of robustness, neutrality, and scalability makes it suitable for both industrial BIM workflows and academic research. Open implementations and publication of parameters, scripts, and test models will support independent verification and extension to more complex scenarios without sacrificing the traceability required in BIM environments.

References

[1] buildingSMART International. (2024). IfcGrid (IFC 4.3.2 documentation). https://standards.buildingsmart.org/IFC/DEV/IFC4_2/FINAL/HTML/schema/ifcproductextension/lexical/ifcgrid.htm [2] buildingSMART International. (2024). IfcGridAxis (IFC 4.3.2 documentation). https://standards.buildingsmart.org/IFC/RELEASE/IFC2x3/TC1/HTML/ifcgeometricconstraintresource/lexical/ifcgridaxis.htm [3] buildingSMART International. (2024). IFC Schema Specifications. https://technical.buildingsmart.org/standards/ifc/ifc-schema-specifications/ [4] xBIM Team. (s. f.). XbimEssentials (GitHub repository). https://github.com/xBimTeam/XbimEssentials [5] xBIM Project. (s. f.). xBIM Toolkit (site and documentation). https://docs.xbim.net [6] de Berg, M., Cheong, O., van Kreveld, M., & Overmars, M. (2008). Computational Geometry: Algorithms and Applications (3.ª ed.). Springer. [7] Hormann, K., & Agathos, A. (2001). The point in polygon problem for arbitrary polygons. Computational Geometry, 20(3), 131–144. [8] Duda, R. O., & Hart, P. E. (1972). Use of the Hough transformation to detect lines and curves in pictures. Communications of the ACM, 15(1), 11–15. [9] Shewchuk, J. R. (1997). Adaptive precision floating-point arithmetic and fast robust geometric predicates. Discrete & Computational Geometry, 18, 305–363. [10] Goodrich, M. T., Guibas, L. J., Hershberger, J., & Tanenbaum, P. J. (1997). Snap rounding line segments efficiently in two and three dimensions. En Proceedings of the 13th Annual ACM Symposium on Computational Geometry (pp. 284–293). ACM. [11] Hershberger, J. (2013). Stable snap rounding. Computational Geometry, 48(7), 575–585.

Copyright

Copyright © 2025 J. N. Zaragoza-Grife, P. Damian-Reyes, R. C. Lopez-Sanchez, A. C. Cabrera-Perez. This is an open access article distributed under the Creative Commons Attribution License, which permits unrestricted use, distribution, and reproduction in any medium, provided the original work is properly cited.