CN117827983A - Method for extracting BIM model by adopting view based on object-relational database - Google Patents

Abstract

The invention provides a method for extracting a BIM model by adopting views based on an object-relational database, which comprises the following steps: s1, establishing a mapping relation between data types in an industrial basic class standard and an object-relation database; s2, designing a table of an object-relational database, and storing a BIM model into the object-relational database designed based on the industrial basic class standard; s3, creating a model view for extracting data from BIM data, wherein the model view comprises entity types to be extracted, entity filtering expressions and access modes of entity attributes; s4, extracting the needed BIM model data from the object-relation type database through the model view. The BIM extraction method adopts an object-relational database to provide a method for creating various model views, and has the characteristics of wide application range, simplicity, high efficiency and the like.

Description

Method for extracting BIM model by adopting view based on object-relational database

Technical Field

The invention relates to the field of traffic infrastructure engineering digitization, in particular to a method for extracting a BIM model by adopting views based on an object-relational database.

Background

The building information model (BIM, building Information Modeling) is a building model built based on various relevant information data of a building engineering project, and simulates real information of a building by digital information simulation. A perfect BIM model can integrate data of each stage of investigation, design, construction, operation and maintenance, so that project personnel in each stage of the whole life cycle of a building can have accurate and complete data.

BIM data is difficult to realize penetration in the whole life cycle of traffic infrastructure engineering projects, which severely restricts the application and popularization of BIM technology. In the business level, BIM data penetration has mainly the following two aspects:

1) The problem of stage and stage-to-stage communication is that the BIM model is produced again and is difficult to reuse after the design, the construction and the operation and maintenance are explored.

2) The problem of communication between applications at the same stage is also difficult to solve in practice by a common, standardized data format.

A great deal of research and practice have been made on the problem of BIM data penetration in academia and engineering circles, and the main idea is to establish an IFC (Industry Foundation Classes, industrial basic class) standard data source and extract required data from the IFC standard data source in an application scene.

The IFC standard is a set of unified data formats for defining building information models, which aims to solve the problem of interaction between building, engineering and construction software applications. The IFC standard adopts EXPRESS language to define various entities in building information and association relation among the entities, provides a standard for building product data expression and exchange for building life-time-oriented BIM, and is a technical standard for current dominant BIM construction.

In the current BIM application, BIM data exchange and BIM model extraction modes mainly comprise the following two modes:

1) And performing BIM data exchange and BIM model extraction based on the IFC file.

The BIM data exchange based on the IFC file is easy to realize, and the current mainstream BIM application supports the export of the IFC file. However, version control cannot be performed in this way, multi-user cooperative work is not supported, and the efficiency of data exchange access is low.

BIM model extraction is carried out based on the IFC file, multi-step operations such as extraction, deletion and the like are needed based on the original IFC file, the operation is complex, the efficiency is low, and data exchange is inconvenient.

2) And performing BIM data exchange and BIM model extraction based on the database.

BIM data exchange is carried out based on the database, and BIM data in the whole life cycle is stored and managed by constructing a BIM database conforming to the IFC standard. Depending on the type of database employed, database-based BIM data exchange mainly includes the following two types:

a) BIM data exchange based on relational databases.

The relational database has the advantages of mature technology, simple structure, flexible use, safety and reliability. However, because of the complex data structure in the IFC standard, there are horizontal relationships between entities and vertical entity inheritance relationships, and BIM data cannot be mapped well to tables in the relational database using this approach.

b) BIM data exchange based on object oriented databases.

The object-oriented database can support complex data models, is convenient to apply and has high efficiency. However, the object-oriented database technology is still immature, and has the defects of safety and stability.

The BIM extraction method based on the database maintains the advantage of BIM data exchange based on the database, and has relatively higher extraction efficiency. However, the existing BIM model extraction method based on the database needs users to be familiar with IFC standards, configure model views and annotate contents to be extracted, and the model view creation process is complex and has certain requirements on operation users, so that a simpler method for creating model views and extracting BIM models is needed.

Disclosure of Invention

In order to solve the problems faced in BIM model extraction, the invention adopts an object-relational database to provide various modes for creating model views, and can conveniently extract the BIM model.

The invention provides a method for extracting a BIM model by adopting views based on an object-relational database, which comprises the following steps:

s1, establishing a mapping relation between data types in an industrial basic class standard and an object-relation database;

s2, designing a table of an object-relational database, and storing a BIM model into the object-relational database designed based on the industrial basic class standard;

s3, creating a model view for extracting data from BIM data, wherein the model view comprises entity types to be extracted, entity filtering expressions and access modes of entity attributes;

s4, extracting the needed BIM model data from the object-relation type database through the model view.

Further, the establishing the mapping relation between the data types and the object-relation database in the industrial basic class standard includes:

1) Mapping simple types in the industrial basic class standard to basic data types in an object-relational database;

2) Mapping the definition type in the industrial basic class standard to a basic data type in an object-relation database, and if the definition type has data range limitation, creating a domain type in the database;

3) Mapping the enumerated types in the industrial base class standard to the enumerated types in the object-relational database;

4) Mapping the aggregate type in the industry base class standard into an array in an object-relational database;

5) Mapping entity types in the industrial basic class standard into link entity types or combination types in an object-relation database;

6) The selection type in the industry base class standard is mapped.

Further, the table of the design object-relational database includes:

1) Processing the transverse and longitudinal relations of the industrial basic class standard complex data structure, and reducing the complexity of the mapping relation between the industrial basic class standard and the database table;

2) Taking the inverse attribute as a table field, and performing redundancy design on the table field in the object-relation database;

3) The universal unique identifier is used as the main key type of the database table, and the universal unique identifier is used as a unified operation mode for the entity capable of being independently exchanged and the resource entity for building the table.

Further, the creating a model view for extracting data from BIM data includes:

1) The model view is created by self definition through a graphical interface, and the creation difficulty of a user is reduced by adopting a mode of configuring the graphical interface, annotating Chinese and automatically generating related information;

2) Predefining model view templates for different scenes at different stages of the building full life cycle;

3) By semantically inputting the content to be extracted, the system automatically creates a model view.

Further, the extracting the required BIM model data from the object-relational database through the model view includes the steps of:

s41, reading and analyzing the model view, and acquiring the entity type to be extracted, a corresponding filtering expression and a corresponding attribute access mode;

s42, creating an entity type list and a loading queue;

s43, storing the entity types to be extracted into an entity type list;

s44, traversing the entity type list, and extracting the steps S45-S48 for each entity type;

s45, generating a database query statement according to a filtering expression and an attribute access mode of entity types in the model view, and extracting entity data from a database;

s46, processing the attribute with the filtering redundancy mark;

s47, storing linked entity instances of the attributes which are of the entity type in the read-only or read-write attributes into a loading queue;

s48, traversing the loading queue, and repeating the steps S45-S47 for each link entity type in the loading queue to extract entity data;

And S49, finishing the traversal of the entity type list, and finishing BIM data extraction.

Furthermore, the method for creating the model view through the graphic interface in a self-defined way reduces the creation difficulty of the user by adopting the modes of graphic interface configuration, chinese annotation and automatic generation of related information, and comprises the following steps:

1) Inputting an entity to be extracted, and adding the entity through an adding button of a graphical interface;

2) Generating an entity extraction configuration page, wherein a filtering expression of an entity can be set;

3) Configuring access modes of attributes, wherein the attributes comprise display attributes and inverse attributes;

4) If the read-only or read-write attribute has the attribute with the entity type, the step 2) is skipped until no newly added entity needing to be extracted exists;

5) And generating a model view after all the configurations are completed.

Further, the system automatically creates a model view by inputting the content to be extracted through the semantics, and the method comprises the following steps:

1) Setting a format of spoken language input so as to facilitate the understanding of semantics by the system;

2) Obtaining a target entity by analyzing the content to be extracted which is input in a user spoken language mode;

3) Adding a target entity to an entity type to be extracted, and then setting a filtering expression of the entity type;

4) Setting a display attribute and an access mode of an inverse attribute of a target entity;

5) Reading other entities linked with the target entity;

6) Filtering the redundant information;

7) And creating a generated model view after all the configurations are completed.

Further, the processing of the transverse and longitudinal relations of the industrial basic standard-like complex data structure comprises:

1) Adopting a link entity type to process the relation between the transverse entities in the IFC standard;

2) The longitudinal entity inheritance relation in the IFC standard is dealt with by a table inheritance design mechanism of an object-relational database.

Further, the mapping the selection type in the industrial basic class standard includes:

1) If the selectable types in the options are all entity types for building a database table, mapping to a link entity type;

2) If the alternative types in the options are all simple types, defined types, enumerated types, or a combination of these types, mapping them into a combination type containing two fields, the first field storing the selected type and the second field storing its value;

3) If the alternative types in the options are selected, namely, the alternative types are nested, the alternative types are converted into single-layer selection types and then are mapped in the two modes.

The method for extracting the BIM model by adopting the view based on the object-relational database provided by the invention has the characteristics of wide application range, simplicity, high efficiency and the like. The method specifically comprises the following beneficial effects:

1) The method adopts an object-relational database, has the function of the relational database, supports the object-oriented characteristic, and can process the complex data structure of the IFC standard in the transverse and longitudinal directions through a table inheritance mechanism and using a link entity type.

2) In mapping selection types in the IFC standard to the database, the complexity of the data is reduced by processing the nested selection types as single-layer selection types.

3) The query and BIM model extraction efficiency is improved through the table field redundancy design, unified processing modes of different entities and other measures.

4) By providing three modes of a graphical interface for configuring the model view, a predefined model view template and semantic input extraction content, the model view is created, the creation process of the model view is simplified, the use threshold of a user is reduced, and the user requirements with different degrees of knowledge on the IFC standard can be met.

Drawings

FIG. 1 is a step diagram of a BIM model extraction method according to an embodiment of the invention;

FIG. 2 is a process for selecting type nesting in a BIM model extraction method according to an embodiment of the present invention;

FIG. 3 is a schematic diagram of creating a BIM model view according to an embodiment of the invention;

FIG. 4 is a schematic diagram of an xml format model view file in a BIM model extraction method according to an embodiment of the present invention;

FIG. 5 is a flowchart of BIM model extraction in a BIM model extraction method according to an embodiment of the invention.

Detailed Description

For a further understanding of the present invention, preferred embodiments of the invention are described below in conjunction with the examples, but it should be understood that these descriptions are merely intended to illustrate further features and advantages of the invention, and are not limiting of the claims of the invention.

The embodiment of the invention provides a method for extracting a BIM model by adopting a view on an object-relational database based on an IFC standard, which is based on the IFC standard, and a BIM database is established for BIM data exchange by designing and processing a complex data structure in the IFC standard through the object-relational database; the model view is created by providing a graphical interface for configuring the model view in advance, defining a model view template and extracting contents through semantic input, so that the creation process of the model view is simplified, the use threshold of a user is reduced, and the user requirements with different degrees of understanding the IFC standard can be met.

The embodiment of the invention carries out BIM data exchange based on the object-relational database, and stores and manages BIM data in a full life cycle by constructing the object-relational database which accords with the IFC standard. The object-relational database has the function of the relational database and supports the characteristics of the object. The object-relational database is built by first mapping six data types in the IFC standard to the database and then building a table of the database based on such mapping.

As shown in fig. 1, the specific steps of the embodiment of the present invention are as follows.

S1, establishing a mapping relation between data types in the IFC standard and an object-relation database.

There are six data types in the IFC standard, each of which requires a type mapping relationship to be established with the object-relational database.

S11, mapping the simple type in the IFC standard into the basic data type in the object-relation type database.

The simple type in the IFC standard represents the smallest unit of data, including a numeric type, an integer type, a real type, a boolean type, a logical type, a string type, a binary type, and the like. The specific mapping relationships used in the examples of the present invention are shown in table 1 below.

Table 1: the IFC simple type and database type mapping relation of the embodiment of the invention

IFC simple type	Database type
		NUMBER (numerical value)	DOUBLE
INTEGER (INTEGER)	INTEGER
		REAL (REAL number)	DOUBLE
BOOLEAN (Boolean)	BOOLEAN
		LOGICAL (logic)	BOOLEAN
STRING (character STRING)	TEXT
		BINARY (BINARY system)	BIT VARYING(255)

S12, mapping the definition type in the IFC standard into a basic data type in an object-relation type database, and if the definition type has data range limitation, creating a domain type in the database.

The definition type in the IFC standard is an extension of the simple type, and usually only a name of the definition type is defined on the basis of the simple type, so that the meaning and grammar of the type can be more easily understood, and the definition type can be directly mapped into the basic data type in the database according to the underlying simple type.

For example, ifcvvolumemecure is a type defined on the basis of a simple type read, which is commonly used to represent the volume of an object. REAL is mapped to DOUBLE type in the database in S11, so IfcVolumeMessage is also mapped to DOUBLE type in the database.

If the definition type has a data scope limit, a domain type is created in the database, and a scope constraint is added on the basis of the basic data type. The domain type of the database is a user-defined data type that is based on another underlying type. The domain type may have constraints to limit its valid value to a subset of the values allowed by the underlying type, as desired.

For example, ifcHourInDay describes hours of the day, representing a positive INTEGER of > =0, <24, so domain types can be created in the database based on inter base types, with limit values ranging from > =0, <24.

S13, mapping the enumeration type in the IFC standard into the enumeration type in the object-relation type database.

The enumeration type in the IFC standard is a data type that allows a limited set of values to be defined, which are called enumeration members. The enumeration types in the IFC standard may be mapped directly to enumeration types in the object-relational database.

S14, mapping the aggregation type in the IFC standard into an array in the object-relation type database.

The aggregate types in the IFC standard represent a collection of certain basic type elements, which can be mapped into an array of corresponding types in the object-relational database according to the types of the elements in the aggregate types. For example, if an element of the REAL type is stored in one aggregate type in the IFC standard, it is mapped into an array of DOUBLE types in the database.

S15, mapping the entity type in the IFC standard into a link entity type or a combination type in the object-relation type database.

Each entity in the IFC standard has many different types of attributes, which may be simple types, defined types, enumerated types, etc., as mentioned above. When there is a relationship between two entities, then the entity type is used as the data type of one attribute to represent the link of one entity to the other entity. When entity a links to entity B, the data type in entity a for which there is at least one attribute is entity B type.

For example, an example of a dot line, where a physical point represents a point, a physical line represents a straight line, and two points can define a straight line, the physical line has two attributes p0 and p1, and the data type of each attribute is a point (point).

The mapping of entity types in the IFC standard in the embodiment of the invention is divided into the following two cases:

1) For the entity type for which the database table is to be built (see S2 for building or not), it is mapped to a linked entity type containing two fields.

In the database, a link entity type (link entity) is a custom type created in the database and is used for representing a link relationship between database table records corresponding to two entity instances. The first field of the mapped link entity type stores the type name of the link entity, corresponding to the table name in the database. The second field stores the primary key value of the linked entity data in the database table record. The table name and primary key value may correspond to a table entry representing the value of the instance of the entity type.

For example, in the dotted line example, a database table is built for the entity point type, and then an example table record of the database table point is shown in table 2, where id is a primary key, and x, y, and z represent coordinates of points in three-dimensional space. An example table record of the database table line at this time is shown in table 3, wherein the p0 and p1 fields are of the link entity type (linkEntity), and the field value (point, 1) of the p0 column represents the table record of the database table point with the primary key value (id) of 1, that is, the point where x, y, and z are (10,10,10).

Table 2: example table records for database table points

id	x	y	z
				1	10	10	10
2	20	20	20

Table 3: example table records for database table line

id	p0	p1
			1	(point,1)	(point,2)

2) The entity types for which no table is built are mapped to the combined type.

The combination type in the database is a new data type formed by combining a plurality of data types together. For entity types not listed, the attributes in the entity are combined together to create a combined type named the entity.

For example, assuming that no database table is built for the entity point types in the dotted example, a combined type (x, y, z) named point is created, which combines the three DOUBLE types of x, y, z together to represent the coordinates of a point in three-dimensional space. An example table record for the database table line at this time is shown in table 4, where the p0 and p1 fields are of the combined type point, and the field value (10,10,10) of the p0 column indicates a point where the values of x, y, and z are all 10.

Table 4: example table record 2 for database table line

id	p0	p1
			1	(10,10,10)	(20,20,20)

S16, mapping the selection type in the IFC standard.

The selection type in the IFC standard refers to a specific data type, which contains both information of the selected type and value, and allows a suitable type to be selected among a plurality of options as the type of value. The selection type is generally composed of a plurality of options, and each option can be any type in the IFC standard, and all options can be the same type or different types.

The advantage of selecting types is that the process of data definition can be simplified and complex relationships between objects can be better described. But because of the various combinations that their options may have, there are many cases when mapping to database types.

1) If the alternative types in the options are all entity types that build the database table, then the mapping is to link entity types linkEntity.

2) If the selectable types in the options are all simple types, defined types, enumerated types, or combinations of types, they are mapped to a combination type typeValue that contains two fields, the first field storing the selected type and the second field storing its value.

3) If the alternative types in the options are selected, namely, the alternative types are nested, the alternative types are converted into single-layer selection types and then are mapped in the two modes. The conversion mode is to move all the options in the inner layer selection type to the options in the outer layer selection type, and if a plurality of selection types exist in the options or the selection types have multi-layer nesting, all the options are moved to the outermost layer. By converting the nested selection type into the single-layer selection type, the situation of whether the mapping is carried out on the database or the multi-layer nesting is avoided, the complexity of data is reduced, and the data processing mode is simplified.

For example, the selection type IfcValue has options IfcMeasureValue, ifcSimpleValue and ifcderivemmeasurevalue, where the type of IfcSimpleValue is also the selection type, and the structure is shown on the left side of fig. 2. The option in ifcsmplevalue is moved to the option in ifcsvalue and the original ifcsmplevalue option is deleted, the structure is shown on the right side of fig. 2. This converts the IfcValue from the original two-layer nest to a single-layer selection type.

S2, designing a table of the object-relation database, and storing the BIM model into the object-relation database designed based on the IFC standard.

The entity types in the IFC standard are divided into an independently exchangeable entity and a non-independently exchangeable entity, which is also called a resource entity, and are respectively processed as follows:

1) The present embodiment creates a database table for each independently exchangeable entity.

2) Each resource entity is specifically analyzed according to its data complexity. If the data structure is relatively simple, a corresponding combination type is created and stored as a table field in the other entity database tables using the resource entity, as in the operation in step S15. If the data structure is complex, it is difficult to use the composition type representation, a database table is built.

The operation in the database table building process mainly comprises the following steps:

s21, processing the transverse and longitudinal relations of the IFC standard complex data structure, and reducing the complexity of the IFC standard and database table mapping relation.

The processing of the complex data transverse and longitudinal relations in the IFC standard adopts the following modes:

1) The link entity type is used to handle the relationship between the entities in the lateral direction in the IFC standard.

By linking the relationship between the entities in the lateral direction in the IFC standard, that is, the link relationship between the different entities, by the link entity type linking entity mentioned above, it is possible to directly link from the current entity to another entity having a relationship with the current entity. For example, in the dotted line example of step S15, the line entity line is linked to the point entity point through the link entity type linkEntity.

2) The longitudinal entity inheritance relation in the IFC standard is dealt with by a table inheritance design mechanism of an object-relational database.

Through the design mechanism of table inheritance, the operation of building the table of the entity with inheritance relation can be simplified. For example, the entity IfcRoot has four attributes of GlobalId, ownerHistory, name and Description, and there are also corresponding 4 table fields when it is tabulated. The entity IfcPropertyDefinition inherits IfcRoot, has more hasassocities based on four attributes of the parent class, needs to point out all 5 table fields when it is tabulated in the traditional relational database, and loses inheritance relation with IfcRoot. However, the table inheritance mechanism is used in the object-relational database, and the table establishment operation of the entity ifc property definition can be completed only by indicating that the ifc property definition table inherits the IfcRoot table and the newly added hasassocitytable field. Compared with the traditional relational database, the method simplifies the table construction operation and maintains the inheritance relation with the Ifcroot.

After the complex data transverse and longitudinal relations in the IFC standard are processed in the mode, the complexity of the IFC standard and the database table mapping relation can be reduced.

S22, redundant design is carried out on the table fields in the object-relation type database by taking the inverse attributes as the table fields.

The redundancy design is a denormalization means of the database, has the advantages of less connection operation, quick search, quick statistics, less table lookup, easy search and the like, and has the defects of larger storage space, larger database deletion and modification operation cost and the like. For BIM data, the query operation is most frequent, and in the process of BIM model extraction, the query efficiency can be improved directly, so that the redundancy design is more advantageous and more disadvantageous to properly use.

The attribute type of the entity type in the IFC standard has an inverse attribute that represents a relationship with one of the other entities, and in this entity attribute, a piece of data having the same meaning is stored. When the entity type is built, redundant design is adopted, and the inverse attribute is used as a table field, so that the current entity can be directly linked to other entities related to the current entity, multi-table association during query can be reduced, and query performance and BIM (building information modeling) extraction efficiency are improved.

For example, in the IfcWall entity, there is an inverse attribute HasOpenings representing the link relationship with the related building element attribute in the IfcRelVoidsElement entity, where the relationship between the building element and the opening element is also stored. If a redundant design is used, the wall opening is obtained by linking directly through the target wall table entry to the entry in the ifcrelvoids element entity table. Otherwise, the IfcRelVoidsElement entity table needs to be traversed, and the table record of the storage target wall is found, so that the opening on the wall can be obtained, and the required query cost is larger.

S23, using UUID as a main key type of the database table, and unifying operation modes for the entity capable of being independently exchanged and the resource entity for building the table.

UUID (Universally Unique Identifier) is a universally unique identifier, also a data type in an object-relational database, which is a machine-generated identifier that is unique within a certain range. When it is used as the primary key type, there is no case where the primary key is repeated.

The independently exchangeable entity has the GlobalId attribute as its unique identifier, but the resource entity has no unique identifier, and the GlobalId can only be stored in the database using a string, and using it as a primary key reduces the query speed. Therefore, a UUID type primary key is added for each entity for building a table, so that unified operation modes can be adopted for the entity capable of being independently exchanged and the resource entity for building the table, and query and BIM model extraction speeds are improved.

Through the above steps, the object-relational database is designed based on the IFC standard, and the BIM model is stored in the database.

The BIM model may be stored in a file format or in a database in a variety of storage ways. The form stored in file format for the BIM model conforming to the IFC standard is a file with suffix name. IFC. After the object-relational database is designed based on the IFC standard in the previous step, the BIM model conforming to the IFC standard can be stored in the object-relational database through an upper layer application program.

S3, creating a model view for extracting data from BIM data, wherein the model view comprises entity types to be extracted, entity filtering expressions and access modes of entity attributes.

The database is used for storing the BIM model, and the BIM model in the database is a complete model, but not all data in the BIM model is needed at all times, and only a part of data in the BIM model is needed in most cases. The Model View (Model View) is a tool for extracting a desired part of data from a database, and contents in the Model View include an entity to be extracted, an entity filtering expression, an access manner of an entity attribute, and the like.

The embodiment of the invention extracts the BIM model from the object-relational database designed based on the steps S1 and S2, firstly creates a model view, and then extracts data from the BIM model by reading and analyzing the model view. The creation of the model view is a relatively difficult process, in the embodiment of the invention, according to different degrees of knowledge of the user on the IFC standard, a plurality of modes are adopted to reduce the difficulty of the creation of the model view as much as possible, and three creation modes are provided as follows:

S31, creating a model view through self definition of a graphical interface, and reducing the creation difficulty of a user by adopting modes of graphical interface configuration, chinese annotation, automatic generation of related information and the like.

This approach is suitable for users with some knowledge of the IFC criteria. For example, FIG. 3 is a schematic diagram of a graphical interface for creation of a model view associated with a wall, which also provides Chinese annotations when configured, which can be automatically converted to a desired format after configuration is complete, which helps reduce the difficulty of creating the model view for a user. The specific creation steps are as follows:

1) Inputting the entity to be extracted, and adding the entity through an adding button of the graphical interface.

For example, the IfcWall entity in fig. 3 is added via an add button on the graphical interface.

2) Generating entity extraction configuration page, filtering expression of entity can be set.

The filtering expression is a filtering condition when extracting the entity, that is, adding a filtering condition to the entity to be extracted. For example, there are 5 walls in one item, and their names (Name attribute values) are "wall#1", "wall#2", and "wall#5", and only the data of the Wall named "wall#1" is now desired, and the filter expression of the IfcWall entity is set to name= "wall#1".

3) The access mode of the attribute is configured, and the attribute comprises a display attribute and an inverse attribute.

The configurable attributes herein include display attributes and inverse attributes by which links to other entities associated with the current entity can be made. The access mode can be read-free, read-only or read-write.

For example, according to the configuration in fig. 3, when an IfcWall entity is extracted, its Description attribute is not extracted, and the user has read modification authority to Name, ownerHistory and HasOpenings attributes, but cannot be modified by reading only the globalsid attribute.

4) If the attribute configured as read-only or read-write has the attribute with the type of entity, the method jumps to 2) continuing to configure the filtering expression and the attribute extracted by the entity until no newly added entity needing to be extracted exists.

For example, in fig. 3, the type of the lownerhistory attribute is an ifclownerhistory entity (representing history information), the type of the hasopenins attribute is an IfcRelVoidsElement entity (herein representing a relationship between wall surfaces and opening elements on the wall surfaces, such as an opening for installing windows and doors), and they are configured to be readable and writable, then the extraction configuration pages of the ifclownerhistory and IfcRelVoidsElement entities are generated below.

5) And generating a model view after all the configurations are completed.

The model view is used for extracting a part of needed data from the complete BIM data of the database, and can be expressed in various forms, and can be in the form of binary stream or file, for example, xml, json and other formats. The process of generating the model view is herein the conversion of information configured through the graphical interface into a particular form of model view. For example, a model view in xml file format is generated from the content configured in fig. 3, and part of the content of the file is shown in fig. 4.

S32, predefining model view templates for different scenes at different stages of the whole life cycle of the building.

The model view template can be used for directly using the template to extract the information of the corresponding stage emphasis, a user can directly select the model view template according to the requirements, and the model view can be created after the template is briefly modified on the graphic interface, so that the method is suitable for users without knowing IFC standards.

The predefining is defined by professional personnel who know IFC standard and different stages of construction engineering according to the data required by different stages and different scenes, and the graphical interface shown in figure 3 is used for predefining model views with different pertinence which meet the professional requirements. The user can enter the template selection interface by clicking the template button in the upper left corner of fig. 3, and after selecting the required template, the user can enter the configuration interface which is the same as that of fig. 3, and can directly use the template without modification to generate a model view, and can slightly modify the current template, for example, add/delete the entity to be extracted, set an entity filtering expression, modify the entity attribute access mode, and the like.

The use of the model view template can greatly simplify the complexity of engineering application and improve the working efficiency. For example, for pier stud information, design phase templates and construction phase templates are predefined. The designer can extract pier column design information through the pier column design stage template, and the information at the moment is more focused on the identification information, the size information, the design information and the like of the pier column. The construction method can extract pier construction information through the pier construction stage template, and the construction progress information, pier model information and the like are more focused on the information at the moment. And when the model view is used each time, the creation of the model view can be completed by only calling the corresponding template.

S33, inputting the content to be extracted through semantics, and automatically creating a model view by the system.

The user inputs the content to be extracted in a spoken language mode, the system automatically analyzes the semantics of the content, analyzes the extracted content input by the user, generates the entity to be extracted and a corresponding entity filtering expression, configures the access mode of the entity attribute and creates a model view.

This approach is suitable for use by users who do not know the IFC criteria, who need only input which data they want, without additional configuration. For example, the user enters what is to be extracted as a "wall of material planks" and the system automatically creates a model view. The specific operation steps are as follows:

1) The format of the spoken language input is set to facilitate the understanding of semantics by the system.

For example, the extracted content input by the user is limited to conform to a certain format, and the format may be [ attribute/entity type ] [ extraction condition ] [ attribute value/entity name ] [ entity type ], such as "[ material ] [ wall ]", and "[ height ] [ wall ]" of greater than ] [70cm ].

2) And obtaining the target entity by analyzing the content to be extracted which is input by the user in a spoken language mode.

For example, the spoken input of the user is analyzed to obtain the target entities IfcWall and IfcMaterial.

3) The target entity is added to the entity type to be extracted, and then a filtering expression of the entity type is set.

IfcWall and IfcMaterial are added to the entity type to be extracted, and then the filtering expression of the IfcMaterial entity type is set to "name=board" (the limiting material is a wood board).

4) And setting the display attribute and the access mode of the inverse attribute of the target entity. For example, both may be set as read-write.

5) The other entities of the target entity link are read. For the display attribute and the inverse attribute of the target entity, if the attribute has the attribute of which the type is the entity, namely, the target entity has other linked entities, the entity is added to the entity type needing to be extracted, the access mode of the display attribute is set as read-write, and the access mode of the inverse attribute is not read until no newly added entity needing to be extracted.

6) And filtering the redundant information. And for the entity type linked in the reverse attribute of the target entity, marking the attribute of the target entity stored in the entity type as filtering redundancy, and specially processing the marked attribute in the BIM model extraction stage to delete unnecessary redundant data.

For example, the inverse property ContainedInStructure of IfcWall (which is contained in which spatial structure) links the entity type IfcRelContainedInspatial structure (describing the relationship of building elements and spatial structures), while the entity type IfcRelContainedInspatial structure's property, associated elements, will store IfcWall, thus marking the property Relatedelements as "filter redundancy". It will be appreciated that one building floor will be associated with a building element such as a floor, wall, window, door, etc., but only the wall need be extracted here, so that after the attribute is labeled "filter redundancy", unnecessary redundancy data such as floors, windows, doors, etc. will be deleted during the BIM model extraction stage.

And creating a generated model view after all the configurations are completed. The automatically configured information is converted into the format of the model view, which can also be in the form of a binary stream or a file.

The three methods for generating the model view effectively reduce the difficulty of creating the model view, enable users with more knowledge of the IFC standard to freely configure the extracted entity and attribute, enable users with less knowledge of the IFC standard to easily complete the creation of the model view, and enlarge the applicable range of the BIM model extraction method.

S4, extracting the needed BIM model data from the object-relation type database through the model view.

FIG. 5 is a flowchart of extracting BIM model related data, and according to the model view created in step S3, part or all of the required data can be extracted from the BIM model, specifically as follows:

s41, reading and analyzing the model view, and obtaining the entity type to be extracted, the corresponding filtering expression and the corresponding attribute access mode.

For example, according to the created model view, after parsing, the entity type to be extracted is IfcWall, the expression is not filtered, the Description attribute is not read, and the attribute such as GlobalId, ownerHistory, name is read.

S42, creating an entity type list EntityList and a loading queue LoadQueue.

Lists and queues are common data structures. A list is an ordered data structure that is accessed by traversing the entire list from beginning to end. A queue is a first-in, first-out data structure in which data is inserted from the tail of the queue and popped one data at a time from the head of the queue upon access.

The entity type list EntityList is used for storing the entity types needing to be extracted, which are acquired in S41.

The load queue LoadQueue is used for storing other entities linked in the entity attribute values and for extracting the actual values of the entity attributes later.

S43, storing the entity types to be extracted into an entity type list EntityList.

S44, traversing the entity type list EntityList, and extracting each entity type in the steps S45-S48.

S45, generating a query SQL statement according to the filtering expression and the attribute access mode of the entity type in the model view, and extracting entity data from the database.

For example, for the IfcWall entity type, a filter expression is not set, the Description attribute thereof is not read, the attribute of GlobalId, ownerHistory, name is read, and the SQL statement generated when extracting data is "SELECT global_id, owner_history, name,".

S46, processing the attribute with the filtering redundancy mark.

If the attribute in the extracted entity data is marked as filtering redundancy, the attribute data is analyzed after the entity data is extracted, and if the types of some data in the attribute data do not exist in the EntityList, namely the types of the data do not need to be extracted, the data are deleted. The "filter redundancy" flag is only added in the model view created by extracting content through semantic input.

S47, storing the linked entity instance into LoadQueue for the attribute with the entity type in the read-only or read-write attribute.

For example, the link entity type linkEntity value stored in the OwnerHistory and HasOpenins attributes when the Ifcwall entity type is extracted is stored in LoadQueue.

S48, traversing the loading queue, and repeating the steps S45-S47 for each link entity type linkEntity in the loading queue to extract entity data.

And (3) taking out one link entity type from the LoadQuue each time, and performing S45-S47 steps, wherein the S47 step possibly stores new entities into the LoadQuue, so that when all the link entity types in the LoadQuue are taken out, namely when the LoadQuue is empty, the S48 step is executed.

And S49, finishing traversing the entity type list EntityList to finish BIM model extraction.

Through steps S3 and S4, the creation of the model view and BIM model extraction are completed. On the basis of a BIM model, the extracted BIM model part data can focus on different stages and different scenes, and the aim of using the BIM model is fulfilled differently. After BIM model extraction, other applications at the upper layer can further process model display, data table display, drawing and the like according to the extracted data.

The above description of the embodiments is only for aiding in the understanding of the method of the present invention and its core ideas. It should be noted that it will be apparent to those skilled in the art that various modifications and adaptations of the invention can be made without departing from the principles of the invention and these modifications and adaptations are intended to be within the scope of the invention as defined in the following claims.

Claims (9)

1. A method for extracting a BIM model based on an object-relational database using views, comprising the steps of:

s1, establishing a mapping relation between data types in an industrial basic class standard and an object-relation database;

s2, designing a table of an object-relational database, and storing a BIM model into the object-relational database designed based on the industrial basic class standard;

s3, creating a model view for extracting data from BIM data, wherein the model view comprises entity types to be extracted, entity filtering expressions and access modes of entity attributes;

s4, extracting the needed BIM model data from the object-relation type database through the model view.

2. The method for extracting the BIM model based on the view of the object-relational database according to claim 1, wherein the step of establishing the mapping relation between the data types in the industrial basic class standard and the object-relational database includes:

1) Mapping simple types in the industrial basic class standard to basic data types in an object-relational database;

2) Mapping the definition type in the industrial basic class standard to a basic data type in an object-relation database, and if the definition type has data range limitation, creating a domain type in the database;

3) Mapping the enumerated types in the industrial base class standard to the enumerated types in the object-relational database;

4) Mapping the aggregate type in the industry base class standard into an array in an object-relational database;

5) Mapping entity types in the industrial basic class standard into link entity types or combination types in an object-relation database;

6) The selection type in the industry base class standard is mapped.

3. The method for BIM model extraction using views based on the object-relational database according to claim 1, wherein the designing of the table of the object-relational database includes:

1) Processing the transverse and longitudinal relations of the industrial basic class standard complex data structure, and reducing the complexity of the mapping relation between the industrial basic class standard and the database table;

2) Taking the inverse attribute as a table field, and performing redundancy design on the table field in the object-relation database;

3) The universal unique identifier is used as the main key type of the database table, and the universal unique identifier is used as a unified operation mode for the entity capable of being independently exchanged and the resource entity for building the table.

4. The method for BIM model extraction using views based on object-relational databases of claim 1, wherein the creating a model view for extracting data from BIM data includes:

1) The model view is created by self definition through a graphical interface, and the creation difficulty of a user is reduced by adopting a mode of configuring the graphical interface, annotating Chinese and automatically generating related information;

2) Predefining model view templates for different scenes at different stages of the building full life cycle;

3) By semantically inputting the content to be extracted, the system automatically creates a model view.

5. The method for extracting BIM model based on the view of the object-relational database according to claim 1, wherein the extracting the required BIM model data from the object-relational database through the model view includes the steps of:

s41, reading and analyzing the model view, and acquiring the entity type to be extracted, a corresponding filtering expression and a corresponding attribute access mode;

s42, creating an entity type list and a loading queue;

S43, storing the entity types to be extracted into an entity type list;

s44, traversing the entity type list, and extracting the steps S45-S48 for each entity type;

s45, generating a database query statement according to a filtering expression and an attribute access mode of entity types in the model view, and extracting entity data from a database;

s46, processing the attribute with the filtering redundancy mark;

s47, storing linked entity instances of the attributes which are of the entity type in the read-only or read-write attributes into a loading queue;

s48, traversing the loading queue, and repeating the steps S45-S47 for each link entity type in the loading queue to extract entity data;

and S49, finishing the traversal of the entity type list, and finishing BIM data extraction.

6. The method for extracting BIM model based on object-relational database by adopting view according to claim 4, wherein the method for creating model view by graphic interface definition and reducing the creation difficulty of user by adopting graphic interface configuration, chinese annotation and automatic generation of related information comprises the following steps:

1) Inputting an entity to be extracted, and adding the entity through an adding button of a graphical interface;

2) Generating an entity extraction configuration page, wherein a filtering expression of an entity can be set;

3) Configuring access modes of attributes, wherein the attributes comprise display attributes and inverse attributes;

4) If the read-only or read-write attribute has the attribute with the entity type, the step 2) is skipped until no newly added entity needing to be extracted exists;

5) And generating a model view after all the configurations are completed.

7. The method for extracting BIM model based on object-relational database using view according to claim 4, wherein the content to be extracted by semantic input, the system automatically creates model view, comprising the steps of:

1) Setting a format of spoken language input so as to facilitate the understanding of semantics by the system;

2) Obtaining a target entity by analyzing the content to be extracted which is input in a user spoken language mode;

3) Adding a target entity to an entity type to be extracted, and then setting a filtering expression of the entity type;

4) Setting a display attribute and an access mode of an inverse attribute of a target entity;

5) Reading other entities linked with the target entity;

6) Filtering the redundant information;

7) And creating a generated model view after all the configurations are completed.

8. A method for BIM model extraction using views based on object-relational databases according to claim 3, wherein the processing of the lateral and longitudinal relationships of the industry base class standard complex data structure includes:

1) Adopting a link entity type to process the relation between the transverse entities in the IFC standard;

2) The longitudinal entity inheritance relation in the IFC standard is dealt with by a table inheritance design mechanism of an object-relational database.

9. The method for extracting the BIM model based on the view of the object-relational database according to claim 2, wherein the mapping the selection type in the industrial base class standard includes:

1) If the selectable types in the options are all entity types for building a database table, mapping to a link entity type;

2) If the alternative types in the options are all simple types, defined types, enumerated types, or a combination of these types, mapping them into a combination type containing two fields, the first field storing the selected type and the second field storing its value;

3) If the alternative types in the options are selected, namely, the alternative types are nested, the alternative types are converted into single-layer selection types and then are mapped in the two modes.