A method for simplifying adaptive generation of wall family types and model lightening

Abstract

The application discloses a simplified wall family type adaptive generation and model lightening method, which mainly comprises the following steps: system initialization, adaptive generation of wall family type and mapping, and wall object simplification. The system initialization refers to the initialization of global variables involved in the system operation; the adaptive generation of wall family type and mapping refers to the adaptive generation of corresponding family types and corresponding mappings according to the thicknesses of various wall family instances in a BIM model; and the wall object simplification refers to the replacement of the family types of original wall objects by means of the mapping to load the newly generated wall family types in the previous step, so as to realize the lightening of the components.

Description

Technical Field

[0001] This invention relates to a method for lightweighting BIM models, specifically a method for simplifying adaptive generation of wall family types and lightweighting models. Background Technology

[0002] Currently, BIM technology has been widely applied in various fields such as architecture, environmental protection, fire protection, transportation, surveying and mapping, geographic information systems, and digital cities. In these applications, building models play a crucial role. However, BIM models carry a large amount of data: for example, the layout of pipelines and the detailed construction of doors and windows, with the data volume of a single building model often reaching hundreds of megabytes. Loading tens of thousands of such models in a city-level scenario would cause the system to become extremely slow.

[0003] A BIM model of a single building contains numerous walls with complex structures, often comprising structural layers, surface layers, coating layers, and other structural components. Storing this information requires significant storage space. However, in most practical applications (such as indoor evacuation route planning, solar radiation analysis, and airflow analysis), it is unnecessary to focus on the various structural layers within the walls; only the wall's location and simple geometric outline are relevant. Therefore, there is an urgent need to develop a method to lightweight the BIM model while ensuring smooth computation and analysis, thereby improving operational efficiency.

[0004] To simplify walls, simplified wall family types need to be constructed based on the existing wall thicknesses in the BIM model. Since a single building's BIM model contains various wall types with different thicknesses, manually constructing simplified wall families and their corresponding mappings is tedious and prone to oversights (such as missing walls with relevant dimensions present in the BIM model). Therefore, a method is needed to automatically generate these simplified wall family types and their corresponding mappings, enabling lightweight operations on the BIM model. Summary of the Invention

[0005] Purpose of the invention: To address the problems existing in the prior art, this invention provides a simplified method for adaptive generation of wall family types and lightweight model, thereby solving the aforementioned technical problems.

[0006] To achieve the above objectives, the technical solution adopted by this invention is: a simplified adaptive generation and lightweight model method for wall family types, comprising the following steps:

[0007] Step S1: Define a method named Execute and initialize the system environment;

[0008] Step S2: Based on the wall family instances existing in the model, create a simplified wall family type and construct the mapping relationship;

[0009] Step S3: Based on the simplified wall family type and mapping relationship created in Step S2, replace the family type corresponding to each wall family instance in the model with the corresponding simplified wall family type.

[0010] Furthermore, the Execute method in step S1 includes three parameters: an object commandData of type ExternalCommandData, an object message of type string, and an object elements of type ElementSet.

[0011] Furthermore, the specific method for initializing the system environment in step S1 is as follows:

[0012] Step S11: Obtain an object uiApp of type UIApplication from the commandData object;

[0013] Step S12: Obtain an object doc of type Document from the uiApp object;

[0014] Step S13: Define an object baseType of type ElementType.

[0015] Furthermore, step S2 is specifically implemented by the following steps:

[0016] Step S21: Locate the wall family type T with the family name "Basic Wall" and the family type "Regular-200mm" (this type is the default wall family type provided by the system; if this type does not exist, it needs to be created manually).

[0017] Step S22: Based on the wall family instances existing in the model, and using wall family type T as a template, create a simplified wall family type and construct the mapping relationship.

[0018] Furthermore, step S21 is specifically implemented by the following steps:

[0019] Step S211: Filter out all wall family types existing in the system and store them in the collection wallsType;

[0020] Step S212: Iterate through the filtered wall family type set wallsType, and for each element eleType, get its type name. If the obtained type name is "regular-200mm", assign it to baseType.

[0021] Furthermore, step S22 is specifically implemented by the following steps:

[0022] Step S221: Define the type as Dictionary<string,WallType> The mapping of wallMapping;

[0023] Step S222: Filter out all wall family instances existing in the system and store them in the collection wallsIns;

[0024] Step S223: Iterate through the filtered set of wall family instances wallsIns. For each wall family instance elemtWall in the set, create a simplified family type with the same thickness as it and build the mapping relationship between them.

[0025] Furthermore, step S223 is specifically implemented by the following steps:

[0026] Step S2231: Define an array index L, an integer variable, with an initial value of 0;

[0027] Step S2232: If the value of L is less than the length of wallsIns, proceed to step S2233; otherwise, end the traversal of the collection wallsIns.

[0028] Step S2233: Define a variable wType of type WallType, and assign the type of wallsIns[L] to wType;

[0029] Step S2234: Define a variable wTypeName of type string, and assign the type name of wType to wTypeName;

[0030] Step S2235: Obtain the keyword set keys from wallMapping;

[0031] Step S2236: If the set keys already contains wTypeName, proceed to step S223D; otherwise, proceed to step S2237.

[0032] Step S2237: Obtain the composite structure wallStructure of wType, and get the total thickness of wallStructure, and assign it to the variable wallThick;

[0033] Step S2238: Define and start a transaction T1;

[0034] Step S2239: Using the object baseType from step S212 as a template, copy a new wall family type object newType, and name the wall family type newName as follows:

[0035] newName=baseType.Name+"_new_"+wType.Name(Formula 1);

[0036] Step S223A: Obtain the composite structure wallStructure1 of newType and set its thickness value to wallThick;

[0037] Step S223B: Commit transaction T1;

[0038] Step S223C: Add the type name wTypeName and the newType object to the mapping wallMapping;

[0039] Step S223D: Add 1 to L, then proceed to step S2232.

[0040] Furthermore, step S3 is specifically implemented by the following steps:

[0041] S31: Filter out all wall family instances existing in the system and store them in the collection instanceWalls;

[0042] S32: Iterate through the filtered set of wall family instances, instanceWalls, and for each wall family instance eleWallIns in the set, set its family type to the simplified family type.

[0043] Furthermore, step S32 is specifically implemented by the following steps:

[0044] S321: Define and start a transaction transinsta;

[0045] S322: Traverse the collection instanceWalls, sequentially obtain the wall family instances wallIns and proceed to the next step;

[0046] S323: Get the family type name wallTypeName corresponding to the wall family instance wallIns;

[0047] S324: Find the family type typeChang corresponding to wallTypeName from the mapping wallMapping;

[0048] S325: Set the family type of wallIns to typeChang;

[0049] S326: If the set instanceWalls has been traversed, proceed to step S327; otherwise, proceed to step S322.

[0050] S327: Commit transaction transinsta.

[0051] The beneficial effects of this invention are: compared with other lightweight methods, this method can automatically generate simplified wall family types and corresponding mappings based on the BIM model to be simplified, avoiding the operation of searching for wall dimensions one by one from the model, which can improve operational efficiency and avoid human error. Attached Figure Description

[0052] Figure 1 This is a schematic diagram of the algorithm flow of the present invention;

[0053] Figure 2 The newly generated wall family type after the method involved in this invention is run;

[0054] Figure 3 The method involved in this invention is simplified, and a comparison diagram of the wall object is provided.

[0055] Figure 4 The family name involved in step S21 of this invention is "basic wall", and the family type is "conventional-200mm" wall family type construction diagram. Detailed Implementation

[0056] To make the objectives, technical solutions, and advantages of this invention clearer, the invention will be further described in detail below with reference to the accompanying drawings and embodiments. However, it should be understood that the specific embodiments described herein are merely illustrative and are not intended to limit the scope of the invention.

[0057] Unless otherwise defined, all technical and scientific terms used herein have the same meaning as commonly understood by one of ordinary skill in the art to which this invention pertains. The terminology used herein in the description of this invention is for the purpose of describing particular embodiments only and is not intended to limit the invention.

[0058] Example

[0059] like Figure 1-4 As shown, a simplified method for adaptive generation of wall family types and lightweight modeling includes the following steps:

[0060] Step S1: Define a method named Execute and initialize the system environment.

[0061] In this preferred embodiment, the implementation code for the main steps of system environment initialization involved in step S1 is as follows:

[0062]

[0063] Step S2: Based on the wall family instances existing in the model, create simplified wall family types and construct mapping relationships.

[0064] In this preferred embodiment, the specific code involved in step S2 is as follows:

[0065]

[0066]

[0067]

[0068]

[0069] Step S3: Based on the simplified wall family type and mapping relationship created in Step S2, replace the family type corresponding to each wall family instance in the model with the corresponding simplified wall family type.

[0070] In this preferred embodiment, the specific code involved in step S3 is as follows:

[0071]

[0072]

[0073] After the method involved in this invention is run, the newly generated wall family type is as follows: Figure 2 As shown, before and after simplification using this method, the BIM model wall objects are as follows: Figure 3 Place.

[0074] Compared to other lightweight methods, this method can automatically generate simplified wall family types and corresponding mappings based on the BIM model to be simplified, avoiding the operation of looking up wall thicknesses one by one from the model, which can improve operational efficiency and avoid human error.

[0075] The above description is only a preferred embodiment of the present invention and is not intended to limit the present invention. Any modifications, equivalent substitutions or improvements made within the spirit and principles of the present invention should be included within the protection scope of the present invention.

[0076] The method described in this invention is applicable to all building components with composite structures (floor slabs, ceilings, roofs, etc.). With slight extensions, the method described in this invention can be applied to the aforementioned building components.

Claims

1. A simplified method for adaptive generation of wall family types and lightweight model, characterized in that: Includes the following steps: Step S1: Define a method named Execute and initialize the system environment; Step S2: Based on the wall family instances existing in the model, create simplified wall family types and construct mapping relationships; Step S3: Based on the simplified wall family type and mapping relationship created in Step S2, replace the family type corresponding to each wall family instance in the model with the corresponding simplified wall family type; The Execute method in step S1 contains three parameters: an object commandData of type ExternalCommandData, an object message of type string, and an object elements of type ElementSet. The specific method for system environment initialization in step S1 is as follows: Step S11: Obtain an object uiApp of type UIApplication from the commandData object; Step S12: Obtain an object doc of type Document from the uiApp object; Step S13: Define an object baseType of type ElementType; Step S2 is specifically implemented by the following steps: Step S21: Locate the wall family type T with the family name "Basic Wall" and the family type "Regular - 200mm". This type is the default wall family type provided by the system. If this type does not exist, create it manually. Step S22: Based on the wall family instances existing in the model, and using wall family type T as a template, create a simplified wall family type and construct the mapping relationship; Step S21 is specifically implemented by the following steps: Step S211: Filter out all wall family types existing in the system and store them in the collection wallsType; Step S212: Iterate through the filtered wall family type set wallsType, and for each element eleType, get its type name. If the obtained type name is "regular-200mm", assign it to baseType. Step S22 is specifically implemented by the following steps: Step S221: Define the type as Dictionary<string, WallType> The mapping of wallMapping; Step S222: Filter out all wall family instances existing in the system and store them in the collection wallsIns; Step S223: Iterate through the filtered set of wall family instances wallsIns. For each wall family instance elemtWall in the set, create a simplified family type with the same thickness as it and build the mapping relationship between them. Step S223 is specifically implemented by the following steps: Step S2231: Define an array index L, an integer variable, with an initial value of 0; Step S2232: If the value of L is less than the length of wallsIns, proceed to step S2233; otherwise, end the traversal of the collection wallsIns. Step S2233: Define a variable wType of type WallType, and assign the type of wallsIns[L] to wType; Step S2234: Define a variable wTypeName of type string, and assign the type name of wType to wTypeName; Step S2235: Obtain the keyword set keys from wallMapping; Step S2236: If the set keys already contains wTypeName, proceed to step S223D; otherwise, proceed to step S2237. Step S2237: Obtain the composite structure wallStructure of wType, and get the total thickness of wallStructure, and assign it to the variable wallThick; Step S2238: Define and start a transaction T1; Step S2239: Using the object baseType from step S212 as a template, copy a new wall family type object newType, and name the wall family type newName as follows: newName = baseType.Name +"_new_"+wType.Name; Step S223A: Obtain the composite structure wallStructure1 of newType and set its thickness value to wallThick; Step S223B: Commit transaction T1; Step S223C: Add the type name wTypeName and the newType object to the mapping wallMapping; Step S223D: Increment L by 1, then proceed to step S2232; Step S3 is specifically implemented by the following steps: S31: Filter out all wall family instances existing in the system and store them in the collection instanceWalls; S32: Iterate through the filtered set of wall family instances, instanceWalls, and set the family type of each wall family instance, eleWallIns, to the simplified family type. Step S32 is specifically implemented by the following steps: S321: Define and start a transaction transinsta; S322: Traverse the collection instanceWalls, sequentially obtain the wall family instances wallIns and proceed to the next step; S323: Get the family type name wallTypeName corresponding to the wall family instance wallIns; S324: Find the family type typeChang corresponding to wallTypeName from the mapping wallMapping; S325: Set the family type of wallIns to typeChang; S326: If the set instanceWalls has been traversed, proceed to step S327; otherwise, proceed to step S322. S327: Commit transaction transinsta.

Images