Removing duplicated geometries in IFC models using rigid body transformation estimation and flyweight design pattern
Abstract
Background
The digital process of Building Information Modeling (BIM) involves the creation and modification of CAD-based building models. The complexity of such models has been increasing steadily within the last few years. BIM Models are usually being exchanged using open and standardized data formats. In this context, the Industry Foundation Classes (IFC) are widely used. Therefore, software vendors provide interfaces for dealing with the IFC format. To obtain a high level of data integrity, however, IFC elements are often managed as completely distinct entities, which can result in the creation of multiple copies of identical pieces of information. Since the trend to provide web-based solutions for BIM applications is also becoming increasingly important, especially the conflict between available resource consumption and suitable response times must be considered. Although existing optimization algorithms can reduce the size of an IFC file by analyzing its structure syntactically, there is still the gap to detect identical pieces of geometries that are syntactically distinct. Also, when subsequently merging such geometries, the available sharing concepts must be questioned.
Methods
The contribution of this paper is twofold. On the one hand, we propose an algorithm to retrospectively detect identical geometries by estimating the rigid body transformation. On the other hand, we outline and evaluate the available possibilities for sharing geometries within the IFC data model. The so-called flyweight pattern is applied to provide and maintain the appropriate reuse of identical information.
Results
The methodologies are exemplary demonstrated by modeling and optimizing a typical tunnel lining structure, which contains many repetitive elements. As a result, a noticeable reduction of storage and processing time can be measured.
Conclusions
Establishing BIM in large building projects, where complexity not only depends on variation and geometric detail, but also depends on enormous repetition of these elements, a significant benefit is expected.
Keywords
Building information modeling IFC optimization Rigid body transformation Flyweight design patternIntroduction
Building Information Modeling (BIM) has been established in construction projects worldwide and requires the creation of digital building models. These so-called BIM models do not only include a CAD-based representation of geometries, but also define semantical layers. Such a model represents a central and consistent entity during the entire lifecycle of a building project. Also, many stakeholders (for example, planners, designers, and engineers) take part in a construction project, where they attempt to modify and add data to corresponding BIM models. Because they often use different software, an open and standardized data exchange is fundamentally important. Therefore, the Industry Foundation Classes (IFC), developed and maintained by buildingSMART organization (buildingSmart 2015), are commonly used.
With the increasing scale of project size, geometric detail and linked information, the complexity of such models has also been steadily increasing. This particularly implies that the size of the resulting IFC file increases. When passing multiple import and export stages, several reports (Backas 2001; Fischer and Calvin 2002; Bazjanac 2002; Pazlar and Turk 2006) have observed that it can lead to an unmanageable amount of data. Amongst other reasons, including adding unused instances, Sun et al. (2015) demonstrated that the bloat is mainly driven by producing redundant geometries for identical types of building elements, such as windows, doors, or columns. Because in BIM models data integrity is of crucial importance, it is supposed that many IFC software neglect the demand of model efficiency. That issue often plays a major role accepted as a data format in larger projects, such as BIM applications in infrastructure projects, which contain an even larger number of repetitive elements. Also, considering the demand of web-based BIM solutions the conflict between file size and limited bandwidth plays a significant role.
In fact, there is the demand of eliminating redundancy from bloat IFC files. Existing optimizers can already eliminate redundancy using syntactical analysis, but are not capable of identifying equivalence within absolute defined geometries. Since optimized IFC files will subsequently pass import and export stages again, there is also the demand to discuss sharing concepts and how they can be preserved. Therefore, a twofold methodology will be proposed. First, we introduce an algorithm to detect identical product geometries based on estimating rigid body transformation. Secondly, we discuss the possibilities of sharing identical geometries to reproduce an efficient model. Also, the second contribution includes the specification on how to deal with and preserve shared instances when performing import or export using the flyweight design pattern. For the proof of concept, a case study implements and evaluates the methodologies considering a tunnel lining model from a project in the field of mechanized tunneling.
Background
Industry foundation classes
For the association of objects the class IfcRelationship realizes the principle of objectified relations, where in this context, Fig. 1b outlines aggregations, product containments and property defines. When creating a product tree of a building, the relationship class IfcRelAggregates decomposes different spatial structures, for example, stories within a building. In contrast, the relationships of class IfcRelContainedInSpatialStructure assign products to a specific spatial level, usually representing physical elements.
Rigid body transformation estimation
Four major algorithms exist to solve Eq. 2. The first and the second involve matrix representations, either using singular value decomposition (SVD) (Kabsch 1976; Kabsch 1978; Arun et al. 1987), also known as Kabsch algorithm, or using eigensystems of orthonomal matrices (Horn et al., 1988). The third and fourth involve quaternion representations (Horn, 1987; Walker et al., 1991). A comparative overview is given by Eggert et al. (1997).
The flyweight design pattern
In object-oriented software design the application of design patterns are fundamentally important to create well-structured software and to maintain sophisticated concepts. Gamma et al. (1995) present an essential set of such patterns. These are subdivided into three categories, namely creational patterns, structural patterns, and behavioral patterns.
Related work
In literature, the topic of IFC Optimization deals with reduction of file size. While this usually implies the optimization of existing IFC files in a postprocessed manner, this paper also covers optimization methods in the design stage to directly produce optimal files.
Considering the stage of design, there exist some explicit sharing concepts defined in the IFC schema. For the reuse of geometric items the entity IfcMappedItem (first defined in IFC2x, c.f. Figure 3a) can be utilized. For sharing a representation, first a representation map is created to identify a representation for mapping and to define a placement origin. Then this map can be referenced as a mapping source by many mapped items to implement reuse. Furthermore, a Cartesian transformation operator can be attached to such a mapped item. Not only is the sharing of representations among multiple client product representations itself, but also the explicit knowledge about being shared a great advantage in preserving integrity on schema level.
For the reuse of properties, an attachment to the relating type object is possible (c.f. Fig. 3b). This works properly if it represents a predefined set of properties for a specific type. Sharing properties for only a subset of a client objects is forbidden by the schema which, consequently, would imply the creation of a distinct property set for each client individually. For instance, a manufactured date can be the same value for multiple clients, but is not generally a static value property of a type.
Methods
Basic algorithm
Comparing point sets by estimating the rigid-body transformation
\( {T}^{\prime }=\left(\begin{array}{cccc}1& 0& 0& {\overline{p}}_x^{\prime}\\ {}0& 1& 0& {\overline{p}}_y^{\prime}\\ {}0& 0& 1& {\overline{p}}_z^{\prime}\\ {}0& 0& 0& 1\end{array}\right),A=\left(\begin{array}{cccc}a& 0& 0& 0\\ {}0& a& 0& 0\\ {}0& 0& a& 0\\ {}0& 0& 0& 1\end{array}\right),T=\left(\begin{array}{cccc}1& 0& 0& {\overline{p}}_x\\ {}0& 1& 0& {\overline{p}}_y\\ {}0& 0& 1& {\overline{p}}_z\\ {}0& 0& 0& 1\end{array}\right). \)
Finally, when a transformation matrix M aligning two point sets has been calculated, Eq. 22 must be checked against all pairs of points. The point sets are equivalent if and only if each pair fulfills that equation. Lastly, if two product representations are detected to be equal, the representation of the second system can be substituted by the representation of the first system. Consequently, the matrix corresponding to the actual placement of the object in the second system must be pre-multiplied by the transformation matrix M.
Time complexity using O-Notation
Subroutine | Complexity | |
---|---|---|
1) Semantical grouping | O(N_{ p }(N_{ i } + log N_{ i }) | |
By type | O(1) | |
By property | O(N_{ i } + log N_{ i }) | |
2) Geometric comparison | \( O\left({N}_p^2{N}^2\right) \) | |
Topological comparison | O(N log N) | |
Compare underlying point sets | O(N^{2}) | |
Removing scale and translation | O(N) | |
Create H = Q*Q’ | O(N^{2}) | |
Singular value decomposition | O(1) | |
Point comparison p’ = M*p | O(N) or O(N^{2}) | |
3) Share identified duplicates | O(N_{ p }N^{2}) | |
Assign representation | O(1) | |
Pre-multiply transformation | O(N^{2}) | |
∑ | O(N_{ p }(N_{ i } log N_{ i } + N_{ p }N^{2})) |
This means that the complexity mainly depends on the number of products (N_{ p }) in an IFC model and the number of the point sets (N). Furthermore, when utilizing a grouping based on related properties, this also adds a specific factor (N_{ i } log N_{ i }). The overall complexity is polynomial, though it includes potential for parallel optimization, which promises reduction to the outer factors N_{ p } and N_{ i }.
Sharing data using implicit flyweights
Implicit sharing of identical parts can be applied throughout most entities within the IFC. Practically, any instance could be referenced by a multitude of other instances. However, for a shared instance it is not necessary to know whether it is to be a shared or non-shared component. According to the IFC Schema, there are some restrictions necessary to preserve model quality. On the one hand, when an entity includes an inverse attribute to a client entity with cardinality 1, an instance of the actual entity must not be shared amongst a multitude of these client objects. If it was shared, the inverse attribute could not be resolved consistently, and thus would violate model integrity. A typical example is the entity IfcProductDefinitionShape, considering the inverse attribute ‘OfProductDefintionShape’. In IFC2x3 it refers to a single instance of IfcProduct. Since IFC4, it has been relaxed to include multiple products. On the other hand, sharing geometric content does not only include pure instances, but also involves a distinction between local definitions and how these are placed into a world coordinate system applying multiple local transformations. Because the IFC payload normally includes a high ratio of such definitions, there is the need for specific investigation.
Supporting internal program models to decompose the geometric model representation into appropriate intrinsic and extrinsic states, they need to adopt the concept of scene graphs. Basically, a scene graph is a tree structure which decomposes a 3D scene into spatial structures, where each structure defines its specific local coordinate system. Besides a transformational component, each structure can define further local properties, states or levels of detail. Subsequently, the decomposition of geometric representation into intrinsic definition and placement can be derived. Geometric components, like shapes, can be implemented as an intrinsic part and, consequently, be shared among different leaf nodes. Instead, the parts that differ among client objects and that are responsible for their identification or behavior must be implemented extrinsically.
In case of creating flyweights on product representation level, the local placement of IfcElement serves as local coordinate system. Hence, using a product representation amongst multiple products, the individual linear transformation (or local placement) can be applied by using the IfcAxis2Placement3D entity. A corresponding 4 × 4 transformation matrix is converted as follows. Initially, the last row can be discarded, because it is used only for technical reason calculating homogenous transformation products. The translation component (4th column) is stored as position attribute, the z-Axis (3rd column) is stored as axis attribute and the x-Axis (1st column) is stored as ‘RefDirection’. The y-Axis is not stored explicitly since it can be derived from the cross product of \( \overrightarrow{x}\times \overrightarrow{z} \). In case of creating flyweights on the level of IfcRepresentation, implicit sharing is more restricted. While shape models or style models can be shared separately, a shape model still depends on its initial transformation and the corresponding coordinate system of IfcElement. To apply further local transformation, utilizing IfcMappedItem would be necessary. Lastly, constructing flyweights on the level of representation items enables the finest detail of sharing information. However, applying further transformations can only be applied using a mapped item again.
Implementing flyweight structures using implicit mappings not only avoids redundancy of geometric components, but also enables implicit sharing for non-geometric instances. However, for importing and editing IFC files, the behavior in case of modifying shared objects must be considered. When a shared object is being modified, it would affect each client object and therefore could easily violate the integrity. Consequently, some software vendors interpret each object reference as a new copy. In contrast, implementing a Copy-On-Write (COW) pattern would be more efficient. A new copy representing an Unshared Concrete Flyweight (cf. Section Rigid Body Transformation Estimation) is created only when a modification of an object is attempted. This pattern does not require the knowledge about inverse relations and, thus, can be implemented easily. However, when the amount of modification increases, it is likely that duplicates might be produced again. Otherwise, a full resolution and tracking of all references can provide a complete solution. Such a dependency tree can still be managed quite efficiently, for instance, using data structures like binary balanced trees.
Results and discussion
Furthermore, the models are investigated in terms of completeness by visual verification and by comparing the number of relevant instances to relocated in processed models. Besides the investigation of model qualities, also the efficiency of the algorithm itself by means of processing time is analyzed.
Starting with a detailed description of the cases study, it deals with data from the metro line tunneling project “Wehrhahnline” in Düsseldorf, Germany. The corresponding tunnel model represents the tube of the eastern branch of the project. It consists of 530 tunnel rings arranged in succession. These rings are entirely equivalent in structure and geometry, whereas positioning along the tunnel axis represents distinct information. Each ring itself is decomposed of eight prefabricated ring segments.
Based on these descriptions, models could have been created in various manners of including duplications or flyweight arrangements. Considering models which are affected by duplication, we separate between geometries using model coordinates and geometries using world coordinates. When using model coordinates, for each tunnel ring a template geometry would be placed into a local coordinate system, which assigns a specific transformation. Duplicating the ring geometry leads to entirely equivalent geometric definitions. In contrast, when using world coordinates, the coordinates of such geometries would already have been transformed into world coordinates. Such finalized geometries lead to completely distinct information representing the same geometry. For models using sharing strategies, only model coordinates are considered, because the strategies require these in principle. Therefore, we subdivide into explicit and implicit shared contents. Both categories have been described and thus we refer to Related work section for explicit sharing using IfcMappedItem as well as we refer to Methods section for implicit sharing using the levels of IfcProductRepresentation, IfcRepresentation and IfcRepresentationItem.
For the described tunnel model using world coordinates, the presented algorithm is utilized with specific input parameters and produces intermediate result as follows. Performing phase one, the grouping of products by entity type results into 3 groups, distinctly containing either instances of IfcSite, IfcBuilding or IfcBuildingElementProxy. The site, of course, appears only once. The instances of IfcBuilding number in total 531, representing one spatial structure of the tunnel and 530 included spatial structures of the rings. The group of proxy instances includes 4240 elements. When performing successive grouping by the value of attribute ‘ObjectType’, the proxy collection is subdivided into eight groups of 530 elements each. Then, phase 2 concentrates only on elements which include geometry. Performing topological comparison, first, it is recognized that each element includes exactly one instance of IfcProductRepresention, which exactly references to one instance of IfcShapeModel, which again references exactly to one instance of IfcFaceBasedSurfaceModel. Secondly, performing topological comparison also on these representation items, the same structures and the same number of instances are detected. In this subroutine, the underlying points of instance IfcCartestianPoint are also collected. When topological comparison terminates, in this case, the groups remain as previously constructed. Subsequently, these elements are compared geometrically. For the specific implementation of estimating the rigid body transformation, the software library Eigen (Jacob and Guennebaud, 2017) has been utilized to easily handle matrices in source code as well as computing fast singular value decomposition using Jacobian SVD method. After geometric comparison, the groups cannot be further subdivided, because all products within these groups has been found to be equivalent. Though, there are additional results by means of reconstructed transformations relative to the first appearance of a geometric construct. Last, for each group of products their representation is set to a single flyweight instance and the transformation results are pre-multiplied to the corresponding placement. Therefore, the utilized sharing concept depends on the initial configuration when starting the algorithm. However, we show results for any strategy. Because utilizing the same API’s for setting a 3D tunnel model into an IFC context as well as for performing the algorithm on the IFC instances, it turns out that the same results have been created, which has already been outlined by Fig. 8.
Time consumption for product comparisons within the generated groups of IFC instances
Entity | Object type | Time consumption [ms] |
---|---|---|
IfcBuildingElementProxy | “Keystone” | 2534 |
IfcBuildingElementProxy | “Counter Segment Left” | 2550 |
IfcBuildingElementProxy | “Counter Segment Right” | 2518 |
IfcBuildingElementProxy | “A” | 2528 |
IfcBuildingElementProxy | “B” | 2618 |
IfcBuildingElementProxy | “C” | 2709 |
IfcBuildingElementProxy | “D” | 2693 |
IfcBuildingElementProxy | “E” | 2673 |
Fortunately, in this case, the subroutine terminates after (N_{ p }-1) comparisons, because products have been found group-wise equivalent. However, the specific complexity O(N_{ p } N^{2}) remains of polynomial scale, which explains the large processing times. Lastly, sharing representations takes 47 ms, which also comes from the O(N_{ p }) complexity, but is somewhat higher than the grouping routine and caused by the factor needed for multiplying transformation matrices.
Considering the world coordinates based model, for each segment it utilizes completely new unshared instances starting from IfcProductDefinitionShape down to IfcCartesianPoint. Until IfcConnectedFaceSet it remains single duplication, but when defining faces and corresponding coordinates, it becomes clear why the file size bloats up. Instead, using a sharing concept, it dramatically reduces the number of instances in the latter case. Because of the eight different segments type of the tunnel rings, eight flyweight geometries exist. For these elements, of course, the underlying instance path must be created anyway. In comparison, most numbers reduce by the scale of 530, which equals the number of rings. Placements remain the same, because they represent distinct information. Considering the use of representation level and item level, they lose a little efficiency by using distinct instances on either product representation or representation level. Lastly, the explicit mapping method consumes similar amounts compared to the item level strategy. It creates explicit geometric representations for the eight segment types, which is why there exist eight additional instances of IfcShapeModel. Then it utilizes an IfcMappedItem for each segment, which for the whole tunnel results in 4240 occurrences. Furthermore, the number of placements and corresponding points increases, which is caused by the individual transformation of mapped items. Concluding the instance comparison, all numbers are reasonable with respect to the selected strategy.
Conclusion
Driven by the burden of large file sizes when dealing with the IFC file format, the paper investigates methods to reduce the size of IFC models. In literature, the duplication of elements is pointed out as the main reason. Especially, geometric duplicates can lead to unmanageable file sizes. In many cases, existing optimizers (Solibri IFC Optimizer and IFCCompressor) already can significantly reduce file size. However, when considering geometries, which have been placed directly into the world coordinates system, the optimizers do not eliminate such redundancy. Such models require the solution to the absolute orientation problem to identify duplicates.
The proposed methodology is twofold. On the one hand, it introduces an algorithm to detect world coordinates based geometries. The first phase of algorithm performs grouping based on semantical knowledge to ensure that only elements are compared, which are likely to include same content. Then, the second phase analyses geometry by comparing topological structures and, subsequently, determines a potential rigid body transformation. Finally, when duplicates have been detected, the algorithm assign a sharing technique. On the other hand, sharing techniques are discussed. These techniques are covered separately, because they do not only present modeling strategies when optimizing IFC files. In fact, they also are relevant when creating such models in the design stage aiming to prevent duplication beforehand.
For proof of concept, a case study on a tunnel lining model has been conducted. In both cases, (1) applying the algorithm on existing IFC files as well as (2) modeling in the design stage and exporting to IFC files, enormous reduction rates are observed. It has also been verified that such a reduction process does not influence visual output and semantical completeness. According to the specific sharing concept, the case study only shows negligible differences. Using an implicit strategy, sharing on various levels can be realized, but also requires the operating software to preserve integrity by either tracking instances or using the copy-on-write pattern. Explicit sharing, instead, provides integrity by schema and therefore, does not require such mechanism. However, sharing is limited to the representation item level.
Considering future BIM projects, the impact of such techniques should not be underestimated. On the one hand, projects are becoming steadily larger and, more importantly, will increasingly be applied to non-traditional sectors. This can be, for example, infrastructure projects like the construction of tunnels or bridges. Such projects introduce a very large project dimension per se, and highly likely include repetitive elements. On the other hand, when considering the software supply, requirements such as collaboration and mobile availability are increasingly influencing the development of web-based solutions. Therefore, resource consumption must be considered to utilize software over limited bandwidth channels and with limited resources on remote devices.
While this paper contributes to IFC data exchange by (1) providing improvement to the elimination of duplicated instances and by (2) investigating modeling techniques for sharing such duplicates, further topics like Model View Definitions (MVD) and Level of Geometry (LoG) are relevant as well. Often tasks in a BIM project require only a subset of information. By applying a specific MVD the IFC model can be filtered, leading to a reduced file size. Also, many models are over-detailed to be used in a specific application. By choosing an adequate Level of Geometry the file size can also be reduced. Finally, not only is an efficient exchange of data important, but also the efficient real-time exploration and interaction is of great significance. Therefore, an efficient visualization pipeline often plays a decisive role. Concepts like flyweight modeling and the usage of different LoGs can be adapted, for example, to improve the visualization in web-based environments.
Notes
Acknowledgements
Financial support is provided by the German Research Foundation (DFG) in the framework of the project D1 of the Collaborative Research Centre SFB 837. These supports are gratefully acknowledged. Furthermore, the authors would like to express their gratitude to the city of Düsseldorf for providing fundamental data in the frame of SFB 837 to complete this research.
Availability of data and materials
Not applicable.
Funding
Not applicable.
Authors’ contributions
All authors contributed extensively to the work presented in this paper. AV reviewed and analyzed the literature, developed the methodology and applied the case study, and drafted the manuscript. CK and MK supervised the entire processes of this study. All authors read and approved the final manuscript.
Competing interests
The authors declare that they have no competing interests..
Publisher’s Note
Springer Nature remains neutral with regard to jurisdictional claims in published maps and institutional affiliations.
References
- Arun, KS, Huang, TS, Blostein, SD. (1987). Least-squares fitting of two 3-D point sets. IEEE Transactions on Pattern Analysis and Machine Intelligence, PAMI-9(5), 698–700. https://doi.org/10.1109/TPAMI.1987.4767965.CrossRefGoogle Scholar
- Backas, Susan (2001): SPADAX Final Report. Available online at http://cic.vtt.fi/vera/documents/SPADEX_final_report.pdf, checked on 11/17/2015.
- Bazjanac, Vladimir (Ed.) (2002): Early Lessons from Deployment of IFC Compatible Software. 4th European Conference on Product and Process Modelling (ECPPM 2002). Portoroz, Slovenia, 2002.Google Scholar
- buildingSmart (2015): IFC Overview Summary. Available online at http://www.buildingsmart-tech.org/specifications/ifc-overview, checked on 12/22/2015.
- Davidson, Scott (2017): Grasshopper. Available online at http://www.grasshopper3d.com/, checked on 3/22/2017.
- Eggert, DW, Lorusso, A, Fisher, RB. (1997). Estimating 3-D rigid body transformations: A comparison of four major algorithms. Machine Vision and Applications, 9(5–6), 272–290.CrossRefGoogle Scholar
- Fischer, M, & Calvin, K (2002). PM4D final report. CIFE at Standford University. Available online at http://web.stanford.edu/group/4D/download/PM4D_Final_Report.pdf.
- Gamma, Erich; Helm, Richard; Johnson, Ralf; Vlissides, John (1995): Design Patterns. Elements of Reusable Object-Oriented Software. Reading, MA: Addison-Wesley.Google Scholar
- Horn, BKP. (1987). Closed-form solution of absolute orientation using unit quaternions. J. Opt. Soc. Am. A, 4(4), 629–642. https://doi.org/10.1364/JOSAA.4.000629.CrossRefGoogle Scholar
- Horn, BKP, Hilden, HM, Negahdaripour, S. (1988). Closed-form solution of absolute orientation using orthonormal matrices. J. Opt. Soc. Am. A, 5(7), 1127–1135. https://doi.org/10.1364/JOSAA.5.001127.MathSciNetCrossRefGoogle Scholar
- Hurley, John R.; Cattell, Raymond B. (1962): The Procrustes Program: Producing Direct Rotation to Test a Hypothesized Factor Structure. In Behavioral science 7 (2), p. 258.Google Scholar
- Jacob, Benoît; Guennebaud, Gaël (2017): Eigen. Version 3.1: Tuxfamily. Available online at http://eigen.tuxfamily.org, checked on 3/20/2017.
- Jones, AD. (1980): Manual of photogrammetry. With assistance of C.C. Slama, C. Theurer and S.W. Hendrikson. Fourth edition. Falls church, Va (12). Available online at https://doi.org/10.1080/00690805.1982.10438226.
- Kabsch, W. (1976). A solution for the best rotation to relate two sets of vectors. Acta Crystallographica Section A: Crystal Physics, Diffraction, Theoretical and General Crystallography, 32(5), 922–923.CrossRefGoogle Scholar
- Kabsch, W. (1978). A discussion of the solution for the best rotation to relate two sets of vectors. Acta Crystallographica Section A: Crystal Physics, Diffraction, Theoretical and General Crystallography, 34(5), 827–828.CrossRefGoogle Scholar
- Liu, X, Xie, N, Tang, K, Jia, J. (2016). Lightweighting for Web3D visualization of large-scale BIM scenes in real-time. Graphical Models, 88, 40–56.MathSciNetCrossRefGoogle Scholar
- McNeel, Robert (2017): Rhinoceros 5. Version 5: Robert McNeel & Associates. Available online at https://www.rhino3d.com, checked on 3/22/2017.
- Pazlar, Tomaz; Turk, Ziga (Eds.) (2006): Analysis of the geometric data exchange using the IFC. 6th European Conference on Product and Process Modelling (ECPPM 2006). Valencia, Spain.Google Scholar
- Pazlar, Tomaz; Turk, Ziga (Eds.) (2007): Evaluation of IFC Optimization. Proceedings of CIB W78 conference on Bringing ITC knowledge to Work.Google Scholar
- RDF Ltd. (2017): IFC engine DLL. Available online at http://www.ifcbrowser.com, checked on 3/22/2017.
- Schönemann, PH. (1966). A generalized solution of the orthogonal Procrustes problem. Psychometrika, 31(1), 1–10.MathSciNetCrossRefMATHGoogle Scholar
- Solibri Inc. (2015): Solibri IFC optimizer. Available online at http://www.solibri.com/products/solibri-ifc-optimizer/, checked on 1/7/2016.
- Sun, J, Liu, Y-S, Gao, G, Han, X-G. (2015). IFCCompressor: A content-based compression algorithm for optimizing industry foundation classes files. Automation in Construction, 50, 1–15.CrossRefGoogle Scholar
- Wahba, G. (1965): A least squares estimate of spacecraft attitude. In SIAM Review 7 (3), p. 409.Google Scholar
- Walker, MW, Shao, L, Volz, RA. (1991). Estimating 3-D location parameters using dual number quaternions. CVGIP: image understanding, 54(3), 358–367.CrossRefMATHGoogle Scholar
Copyright information
Open AccessThis article is distributed under the terms of the Creative Commons Attribution 4.0 International License (http://creativecommons.org/licenses/by/4.0/), which permits unrestricted use, distribution, and reproduction in any medium, provided you give appropriate credit to the original author(s) and the source, provide a link to the Creative Commons license, and indicate if changes were made.