A parametric construction drawing generation method based on constraint solving algorithm

Abstract

The present invention relates to the field of civil engineering informationization and automated design technology, and in particular to a parametric construction drawing generation method based on a constraint solving algorithm, which defines the basic structure and variable parameters of the construction drawing by embedding an engineering design model with a parametric template, generates a parameter constraint relationship set in combination with the geometric constraints, dimensional constraints and logical constraints input by the user, converts the constraint rules into intermediate expressions and constructs a syntax tree using a formula parser, and generates an executable parameter association rule set through semantic verification. The audit module verifies the compliance of the drawings based on the engineering specification database and generates correction suggestions; the multi-terminal collaborative interface and the external BIM model parameter mapping realize cross-system data linkage. The present invention effectively avoids the problems of detail loss and specification deviation in three-dimensional model projection, and improves the efficiency of drawing generation and the robustness of multi-professional collaboration.

Description

Technical Field

[0001] The present invention relates to the technical field of civil engineering informationization and automated design, and in particular to a method for generating parametric construction drawings based on a constraint solving algorithm. Background Art

[0002] The existing engineering drawing field primarily relies on secondary development of 3D modeling software to generate drawings, specifically using section projection or directional model conversion based on the AutoCAD platform. However, these technical solutions have inherent flaws: First, the core technology of the underlying graphics platform is constrained by foreign commercial software architectures, resulting in insufficient system autonomy and controllability, leading to potential data security risks. Second, 2D drawings generated by conventional section projection lack structural feature representation in the orthogonal direction of the axis. In particular, 3D spatial relationships such as connection nodes of special-shaped components and concealed pipelines are difficult to fully map to 2D views, resulting in construction drawings that fail to meet the requirements of engineering drawing specifications for structural expression integrity. Third, directional secondary development based on the AutoCAD platform is limited by the strong coupling relationship between fixed drawing templates and specific model types. When the topology of the 3D model changes, the existing parametric drawing mechanism is prone to data discontinuity such as component misalignment and annotation inaccuracy, forcing developers to repeatedly adapt code for model iterations, significantly increasing development and maintenance costs while reducing the robustness and scalability of the drawing generation system. Summary of the Invention

[0003] In view of the shortcomings of the existing technology, the present invention provides a parametric construction drawing generation method based on a constraint solving algorithm to solve the problems of loss of details, non-compliance with drawing specifications, and difficulty in drawing generation in the process of converting three-dimensional models to construction drawings during the forward design process.

[0004] In order to solve the above technical problems, the specific technical solutions of the present invention are as follows:

[0005] The present invention provides a method for generating parametric construction drawings based on a constraint solving algorithm, comprising:

[0006] Step S101: creating an engineering design model, wherein a parametric template is embedded in the engineering design model, wherein the parametric template defines the basic structure of the construction drawing and variable parameters associated with the engineering requirements;

[0007] Step S102, based on the constraint conditions input by the user, setting geometric associations, dimensional associations and logical associations for the variable parameters in the parametric template to generate a parameter constraint relationship set;

[0008] Step S103, parsing the association rules in the parameter constraint relationship set by a formula parser to generate a parameter association rule set that can be recognized by a constraint solving engine;

[0009] Step S104: inputting the parameter association rule set into a constraint solving engine for iterative calculation, and the constraint solving engine outputting a parameter solution that satisfies all constraint conditions based on a preset conflict resolution strategy;

[0010] Step S105 , updating the variable parameters in the parametric template according to the values ​​in the parameter solution, and mapping the updated parametric template into a two-dimensional construction drawing through a projection algorithm.

[0011] Furthermore, in the parametric construction drawing generation method based on the constraint solving algorithm described in the present invention, the parameter constraint relationship set includes:

[0012] Geometric constraints for defining relative positions and topological relationships of graphic elements in the engineering design model and generating geometric association rules based on the basic structure of the parametric template;

[0013] Dimension constraints, used to define the length, angle or proportional relationship of graphic elements according to the numerical range input by the user, and converted into dimension association rules by the formula parser;

[0014] Logical constraints are used to generate logical expressions based on the formulated associations between parameters or conditional triggering rules. The logical expressions are parsed by the formula parser and then input into the constraint solving engine.

[0015] Furthermore, the method for generating parametric construction drawings based on a constraint solving algorithm of the present invention parses the association rules in the parameter constraint relationship set by a formula parser to generate a parameter association rule set that can be recognized by a constraint solving engine, including:

[0016] Convert geometric association rules, dimension association rules and logical expressions into intermediate expressions in a unified format;

[0017] Constructing a syntax tree for the intermediate expression, and verifying the compatibility of the syntax tree with the parameterized template of the engineering design model through a semantic verification module;

[0018] A parameter association rule set executable by the constraint solving engine is generated according to the syntax tree that passes the verification.

[0019] Furthermore, in the parametric construction drawing generation method based on the constraint solving algorithm of the present invention, the creation of the parametric template includes:

[0020] Extracting common structural features based on historical engineering drawings to generate an initial template library associated with the engineering design model;

[0021] In response to a user selecting a template in the initial template library, the selected template is loaded into the engineering design model, and custom parameters associated with the template are added according to engineering requirements input by the user.

[0022] Furthermore, the method for generating parametric construction drawings based on a constraint solving algorithm according to the present invention further includes:

[0023] When the constraint solving engine detects a conflict in the generated parameter association rule set, it iterates and backtracks based on the conflict parameter priorities preset in the engineering design model to determine the weight distribution of the conflict parameters;

[0024] An adjustable range of the conflicting parameters is generated according to the weight distribution, and the adjustable range is fed back through the user interface of the engineering design model to trigger the user to modify the constraint relationship.

[0025] Furthermore, in the parametric construction drawing generation method based on the constraint solving algorithm of the present invention, the iterative backtracking includes:

[0026] Determining a weight allocation rule in a conflict resolution strategy based on the priority of the conflict parameters;

[0027] The conflicting parameters are relaxed based on the weight distribution rule, and the calculation results are fed back to the parameterized template in the engineering design model until the constraint solving engine outputs a conflict-free parameter solution.

[0028] Furthermore, the method for generating parametric construction drawings based on a constraint solving algorithm according to the present invention further includes:

[0029] Generate a version snapshot including current parameter solutions and constraint relationships based on the version management module of the engineering design model;

[0030] In response to a user's selection operation on a historical version snapshot, the parameter solutions and constraint relationships in the version snapshot are loaded into the engineering design model, and constraint solving and drawing generation are retriggered.

[0031] Furthermore, the method for generating parametric construction drawings based on a constraint solving algorithm according to the present invention further includes:

[0032] Importing the generated two-dimensional construction drawings into the review module of the engineering design model, and performing compliance verification on the geometric structure and parameters in the drawings according to the preset engineering specifications;

[0033] When a violation is detected, a correction suggestion associated with the violation mark is generated, and a correction operation on the constraint relationship is triggered through a user interface of the engineering design model.

[0034] Furthermore, the method for generating parametric construction drawings based on a constraint solving algorithm according to the present invention further includes:

[0035] Receiving a parameter adjustment instruction input by a remote user through the multi-terminal collaborative interface of the engineering design model, the parameter adjustment instruction including a target parameter identifier and an updated value;

[0036] The constraint relationship is dynamically updated based on the parameter adjustment instruction, and the parameter solution calculation and the regeneration of the two-dimensional construction drawings are synchronously triggered by the constraint solving engine.

[0037] Furthermore, the method for generating parametric construction drawings based on a constraint solving algorithm according to the present invention further includes:

[0038] Based on the multi-disciplinary collaborative data interface, the parametric template is associated with the external BIM design model and a synchronization rule between the variable parameters in the parametric template and the parameters of the external BIM design model is established;

[0039] When a parameter change of the external BIM design model is detected, the constraint relationship of the parametric template is automatically updated based on the synchronization rule, and constraint solving and drawing generation are triggered.

[0040] Beneficial effects of the present invention:

[0041] The present invention significantly improves the integrity and efficiency of construction drawing generation through the collaborative mechanism of parametric templates and constraint solving engines. Parametric templates solidify geometric topological relationships and parameter association rules based on engineering drawing specifications, and combine dynamic analysis of geometric constraints, dimensional constraints and logical constraints to effectively avoid the problem of detail loss during three-dimensional model projection. For example, orthogonal projection and dynamic sectioning algorithms are used to fully express the structure of special-shaped nodes and the spatial relationship of hidden pipelines. The constraint solving engine automatically handles parameter conflicts and generates compliant solutions based on the iterative calculation and weight distribution rules of the conflict resolution strategy, driving the projection algorithm to generate annotations and view expressions that comply with drawing specifications, solving the problems of manual annotation errors and specification deviations in traditional methods. The multi-terminal collaborative interface and external model mapping rules realize cross-system parameter linkage, combined with the difference storage and backtracking mechanism of version snapshots, significantly reducing the cost of repeated adaptation during model iteration, improving the robustness and real-time performance of drawing generation in multi-professional collaborative scenarios, and forming a closed-loop design process from parameter drive to specification verification. BRIEF DESCRIPTION OF THE DRAWINGS

[0042] In order to more clearly illustrate the technical solution of the present invention, the following is a brief introduction to the drawings required for use in the embodiments. Obviously, for ordinary technicians in this field, other drawings can be obtained based on the drawings without paying any creative labor.

[0043] Figure 1 A flowchart of a method for generating parametric construction drawings based on a constraint solving algorithm is provided in an embodiment of the present invention. DETAILED DESCRIPTION

[0044] In order to make the purpose, technical solutions and advantages of the present invention clearer, the technical solutions of the present invention will be clearly and completely described below in conjunction with the specific embodiments of the present invention and the corresponding drawings. Obviously, the embodiments described are only part of the embodiments of the present invention, not all of the embodiments. Based on the embodiments of the present invention, all other embodiments obtained by ordinary technicians in this field without making creative work are within the scope of protection of the present invention. The technical solutions provided by each embodiment of the present invention are described in detail below in conjunction with the drawings. In order to better understand the purpose of the present invention, the present invention is further described in detail below.

[0045] See also Figure 1 The present invention provides a method for generating parametric construction drawings based on a constraint solving algorithm, comprising:

[0046] Step S101: creating an engineering design model, wherein a parametric template is embedded in the engineering design model, wherein the parametric template defines the basic structure of the construction drawing and variable parameters associated with the engineering requirements;

[0047] Step S102, based on the constraint conditions input by the user, setting geometric associations, dimensional associations and logical associations for the variable parameters in the parametric template to generate a parameter constraint relationship set;

[0048] Step S103, parsing the association rules in the parameter constraint relationship set by a formula parser to generate a parameter association rule set that can be recognized by a constraint solving engine;

[0049] Step S104: inputting the parameter association rule set into a constraint solving engine for iterative calculation, and the constraint solving engine outputting a parameter solution that satisfies all constraint conditions based on a preset conflict resolution strategy;

[0050] Step S105 , updating the variable parameters in the parametric template according to the values ​​in the parameter solution, and mapping the updated parametric template into a two-dimensional construction drawing through a projection algorithm.

[0051] The process of creating an engineering design model requires the construction of a digital model framework that includes parametric templates. The construction of parametric templates is based on the structured analysis of historical engineering drawings. The common structural features in the drawings (such as the coordinates of the axis intersection of beam-column nodes and the topological relationship of pipeline layout) are identified through feature extraction algorithms to generate an initial template library associated with the engineering design model. The templates in the template library are stored in a structured data format, including fields such as parameter name, parameter type, value range, and association rules. After the user selects a basic template from the template library through the graphical user interface, he can add custom parameters associated with the template based on the current engineering requirements (for example, defining the column section diameter as an interval parameter and binding it to the geometric property field of the template), and finally forming a parametric template embedded in the engineering design model, which serves as the core carrier for subsequent constraint setting and drawing generation.

[0052] When setting parameter associations based on user-entered constraints, three types of association rules must be defined: geometric constraints, dimensional constraints, and logical constraints. Geometric constraints are entered through a graphical user interface and are used to define the relative positions and topological relationships of graphic elements (e.g., centerline alignment tolerances for adjacent columns, minimum clearance constraints between pipes and beam bottoms). Geometric association rules are generated based on the underlying structure of the parametric template. Dimensional constraints define the length, angle, or proportional relationship of graphic elements based on user-entered numerical ranges (e.g., plate thickness parameter intervals, the proportional relationship between beam span and plate thickness). After format verification, they are converted into dimensional association rules. Logical constraints describe the dynamic associations between parameters through formulaic expressions or conditional triggering rules (e.g., a rule that triggers column section adjustment when floor height exceeds a threshold) to generate logical expressions. After format unification and integrity verification, these three types of constraints are integrated into a parameter constraint relationship set consisting of constraint type, action parameters, and expression data, which serves as input data for subsequent parsing and solving.

[0053] When parsing a set of parameter constraint relationships using a formula parser, the three sub-steps of format conversion, syntax tree construction, and semantic verification must be completed in sequence. First, geometric association rules, dimensional association rules, and logical expressions are uniformly converted into intermediate expressions (such as structured data based on JSON or XML), eliminating format differences between different constraint types. Second, the intermediate expressions are hierarchically parsed using a syntax tree construction algorithm to generate an abstract syntax tree (tree nodes include operators, parameter identifiers, and constant values) that reflects the dependencies between parameters. Finally, the semantic verification module traverses the syntax tree nodes to verify parameter existence (parameters involved in implementing constraints are defined in the parameterized template), type compatibility (for example, length parameters cannot be directly operated on with angle parameters), and value range compliance (for example, plate thickness parameters must be within a set range). The syntax trees that pass verification are serialized into a set of parameter association rules (such as the matrix form of a linear system of equations or a piecewise function instruction set) that can be recognized by the constraint solving engine.

[0054] After the parameter association rule set is input into the constraint solving engine, the engine performs iterative calculations based on a preset conflict resolution strategy. The engine loads the priority of conflicting parameters during initialization (e.g., structural safety parameters take precedence over economic parameters). When a conflict is detected in the rule set (e.g., different constraint rules have conflicting value requirements for the same parameter), the conflicting parameters are weighted according to their priority (high-priority parameters retain strict constraints, while low-priority parameters have looser constraints). The value range of the conflicting parameters is then adjusted through relaxation calculations (e.g., allowing the size of secondary components to fluctuate within a certain range). The calculation results are fed back to the parametric template of the engineering design model in real time, driving the dynamic update of the template parameters. The iterative process continues until a parameter solution that satisfies all constraints is output or the preset iteration threshold is reached (if convergence has not occurred, an adjustable range for the conflicting parameters is generated and the user is prompted to correct the constraints).

[0055] After updating the variable parameters in the parametric template according to the parametric solution, the updated template is mapped into a two-dimensional construction drawing using a projection algorithm. Based on the principle of orthogonal projection and combined with the geometric structure and sizing rules defined in the parametric template, the projection algorithm automatically generates a main view and selects cutting locations based on component density to generate cross-sectional views (such as detailed views of beam-column joints). The annotation module generates dimension annotations based on the values ​​in the parametric solution (for example, converting the column section diameter parameter value into annotation text and associating it with the parameter identifier), ultimately outputting two-dimensional construction drawings in DWG format. The generated drawings are recorded by the version management module as version snapshots that include the current parametric solution, constraint relationships, and projection parameters (using differential storage technology to only save parameter changes), allowing users to trace back historical states and re-trigger the constraint solving and drawing generation processes.

[0056] Specifically, in the parametric construction drawing generation method based on the constraint solving algorithm described in the present invention, the parameter constraint relationship set includes:

[0057] Geometric constraints for defining relative positions and topological relationships of graphic elements in the engineering design model and generating geometric association rules based on the basic structure of the parametric template;

[0058] Dimension constraints, used to define the length, angle or proportional relationship of graphic elements according to the numerical range input by the user, and converted into dimension association rules by the formula parser;

[0059] Logical constraints are used to generate logical expressions based on the formulated associations between parameters or conditional triggering rules. The logical expressions are parsed by the formula parser and then input into the constraint solving engine.

[0060] The geometric constraints in the parameter constraint relationship set are input through the graphical user interface and are used to limit the spatial position relationship and topological structure of the graphic elements in the engineering design model. In specific implementation, users can define relative position constraints for the basic structures in the parametric template (such as beam-column nodes and pipeline layouts), for example, setting the centerline alignment tolerance of adjacent column components to ±5mm, or the minimum clear distance constraint between the pipeline and the bottom of the beam to 200mm; at the same time, topological relationship constraints can be defined, such as requiring that two pipelines must not intersect in space, or that the beam component must completely cover the top area of ​​the column component. The above constraints generate geometric association rules based on the geometric features of the parametric template, such as describing the centerline alignment relationship through coordinate difference equations, or describing the inclusion relationship between components through spatial area coverage conditions, providing a spatial logical basis for subsequent constraint solving.

[0061] The setting of dimensional constraints relies on the numerical range and proportional relationship input by the user. Users can use numerical input boxes or slider tools to set specific ranges for the length, angle, or proportional parameters of graphic elements (such as limiting the plate thickness parameter to 120mm to 150mm), or define the proportional relationship between parameters (such as the ratio of beam span to plate thickness is 1.2:1). After format verification (such as excluding non-numeric input and verifying the rationality of the ratio), these input numerical ranges and proportional relationships are converted into dimensional association rules. For example, the plate thickness range is converted into an inequality constraint (120mm≤plate thickness≤150mm) and the proportional relationship is converted into a linear equation (beam span = 1.2×plate thickness). After being processed by the formula parser, the dimensional association rules form a numerical calculation basis that can be recognized by the constraint solving engine, ensuring that the dimensional parameters of the graphic elements meet the engineering design requirements.

[0062] Logical constraints describe the dynamic relationships between parameters through formulaic expressions or conditional triggering rules. Users can define formulaic relationships between parameters using the expression input box (e.g., column section diameter = floor height / 6 + 250mm) or set conditional triggering rules (e.g., when the floor height is ≥ 4.0m, the constraint that the length of the column stirrup reinforcement reinforcement zone is ≥ 500mm is automatically activated). These logical relationships are then syntax-checked (e.g., checking the legitimacy of operators and the validity of parameter identifiers) to generate logical expressions. For example, a conditional triggering rule can be converted into a piecewise function (e.g., when the floor height is ≥ 4.0m, the reinforcement zone length = 500mm; otherwise, the reinforcement zone length = 300mm). The logical expression is parsed by the formula parser into an executable instruction set (e.g., conditional statements or piecewise calculation rules) by the constraint solver. This expression drives dynamic adjustments between parameters, meeting the multi-scenario parameter linkage requirements of engineering design.

[0063] Geometric constraints, dimensional constraints, and logical constraints together constitute a set of parameter constraint relationships, defining the value logic of variable parameters in parametric templates from three dimensions: spatial position, numerical size, and dynamic association. Geometric constraints ensure that the spatial layout of graphic elements conforms to topological requirements, dimensional constraints define the numerical range and proportional relationship of parameters, and logical constraints describe the conditional triggering and dynamic adjustment rules between parameters. These three are integrated into a structured data set through format unification and integrity verification, providing a comprehensive input basis for the subsequent rule conversion of the formula parser and the iterative calculation of the constraint solving engine, jointly supporting the integrity and executable nature of the parametric construction drawing generation method.

[0064] Specifically, the method for generating parametric construction drawings based on a constraint solving algorithm of the present invention parses the association rules in the parameter constraint relationship set by a formula parser to generate a parameter association rule set that can be recognized by a constraint solving engine, including:

[0065] Convert geometric association rules, dimension association rules and logical expressions into intermediate expressions in a unified format;

[0066] Constructing a syntax tree for the intermediate expression, and verifying the compatibility of the syntax tree with the parameterized template of the engineering design model through a semantic verification module;

[0067] A parameter association rule set executable by the constraint solving engine is generated according to the syntax tree that passes the verification.

[0068] The formula parser's parsing process for a set of parameter constraint relationships includes three consecutive technical steps: intermediate expression conversion, syntax tree construction, and semantic verification, which ultimately generates a set of parameter association rules that can be executed by the constraint solving engine.

[0069] The intermediate expression conversion phase requires unifying geometric association rules, dimensional association rules, and logical expressions into a structured data format. Geometric association rules (e.g., alignment tolerance of adjacent column centerlines ±5mm) are converted into a numerical expression using a coordinate interpolation equation: "|X1-X2|≤5mm." Dimensional association rules (e.g., the proportional relationship between beam span and slab thickness) are converted into a linear equation: "beam span = 1.2 × slab thickness." Logical expressions (e.g., triggering column stirrup reinforcement when floor height ≥ 4.0m) are converted into a piecewise function: "When H ≥ 4.0m, reinforced zone length = 500mm; otherwise, = 300mm." These different types of rules are then standardized (e.g., using JSON or XML structured data) to form a unified intermediate expression. This eliminates differences in the original constraint rules' representation and provides standardized input for subsequent analysis.

[0070] The syntax tree construction phase generates a hierarchical structure based on the intermediate expressions, reflecting the parameter dependencies. Using a syntax parsing algorithm (such as recursive descent parsing), the intermediate expressions are lexically and syntactically analyzed, breaking the expressions into basic units such as operators, parameter identifiers, and constant values. An abstract syntax tree (AST) is then constructed based on the operation precedence and logical relationships. For example, for the intermediate expression "beam span = 1.2 × plate thickness," the root node of the syntax tree is the equality operator, its left child is the parameter identifier "beam span," and its right child is the multiplication operator, whose left and right children are the constant "1.2" and the parameter identifier "plate thickness," respectively. The syntax tree's tree-like structure clearly illustrates the computational logic and dependency order between parameters, providing a structured analysis object for subsequent semantic verification.

[0071] The semantic verification phase verifies the compatibility of the syntax tree and the parametric template through the semantic verification module. The verification content includes: parameter existence verification (checking whether the parameter identifiers involved in the syntax tree are defined in the variable parameter list of the parametric template, such as confirming that "beam span" and "plate thickness" are parameters bound to the template), type matching verification (ensuring that the parameter types involved in the same operation are consistent, such as the length parameter cannot be directly added to the angle parameter), and value range verification (verifying whether the parameter value in the syntax tree conforms to the range set by the template, such as whether the plate thickness parameter is within the allowable range of 120mm to 150mm). If the verification finds an incompatibility issue (such as an undefined parameter or the wrong type), the system generates an error prompt and terminates the parsing process; if the verification passes, it confirms that the syntax tree is fully compatible with the parameter definition and constraint rules of the parametric template.

[0072] Based on the validated syntax tree, a set of parameter association rules executable by the constraint solver is generated. Based on the structural characteristics of the syntax tree, it is converted into an instruction format supported by the constraint solver: syntax trees in the form of linear equations (e.g., beam span = 1.2 × plate thickness) are converted into matrix-based linear constraint instructions (Ax = b, where A is the coefficient matrix and b is the constant vector); syntax trees in the form of piecewise functions (e.g., the encryption zone length rule triggered by floor height) are converted into an instruction set for conditional judgment and piecewise calculation. The generated parameter association rule set fully preserves the logical relationships and computational requirements of the original constraint rules, enabling the constraint solver to accurately identify and execute association calculations between parameters, providing an operational input basis for subsequent iterative solutions.

[0073] Specifically, in the parametric construction drawing generation method based on the constraint solving algorithm of the present invention, the creation of the parametric template includes:

[0074] Extracting common structural features based on historical engineering drawings to generate an initial template library associated with the engineering design model;

[0075] In response to a user selecting a template in the initial template library, the selected template is loaded into the engineering design model, and custom parameters associated with the template are added according to engineering requirements input by the user.

[0076] The process of creating a parametric template includes two consecutive technical steps: extracting common structural features and building a template library, and users selecting templates and adding custom parameters. It aims to form a core carrier to support the generation of construction drawings through the reuse and personalized expansion of historical data.

[0077] The extraction of common structural features and the construction of a template library are based on structured analysis of historical engineering drawings. First, historical engineering drawings (including standard format files such as DXF and DWG or system-customized sketch templates) are collected, and common structural features in the drawings are identified through feature extraction algorithms (such as axis intersection recognition based on computer vision and pipeline connection relationship extraction based on topological analysis), such as the axis intersection coordinates of beam-column nodes, spatial avoidance rules for pipeline layout, and geometric dimension thresholds of standard components. After the extracted features are deduplicated and normalized (such as unifying the unit system and merging similar topological structures), an initial template library associated with the engineering design model is generated. Each template in the template library is stored in a structured data format, including basic structure fields (such as geometric topological relationships and standard size parameters) and extended fields (such as parameter types and value ranges that can be customized), providing a data basis for subsequent template selection and parameter expansion.

[0078] The user selects a template and adds custom parameters through a graphical user interface. Users browse the initial template library and select a matching basic template (e.g., a standard-floor beam-column template for a high-rise building or an underground pipeline layout template) based on current project requirements (e.g., building type and component type). The system responds by loading the selected template into the engineering design model. The template's basic structure (e.g., axis grid and node connection rules) is automatically embedded into the model framework, serving as the baseline for drawing generation. Based on specific project requirements (e.g., adjusting component size thresholds or adding material property parameters), users can add custom parameters to the template through the parameter input interface (e.g., adding a "cantilever length" parameter to a beam-column template and setting its value range to 1000mm to 2000mm, or binding a "concrete strength grade" parameter to the template's material property fields). These added custom parameters are then associated with the template's basic structural fields (e.g., binding the cantilever length parameter to the geometric properties of a beam component). This ultimately creates a parametric template that incorporates both the basic structure and customized parameters, serving as the core data carrier for subsequent constraint setting and drawing generation.

[0079] The above two steps, through the combination of historical data reuse and personalized extension, not only ensure the engineering applicability of the template (a general structure based on mature design experience), but also support the flexibility of the design process (meeting specific engineering needs through customized parameters), providing a reusable and extensible template foundation for the parametric construction drawing generation method.

[0080] Specifically, the method for generating parametric construction drawings based on a constraint solving algorithm according to the present invention further includes:

[0081] When the constraint solving engine detects a conflict in the generated parameter association rule set, it iterates and backtracks based on the conflict parameter priorities preset in the engineering design model to determine the weight distribution of the conflict parameters;

[0082] An adjustable range of the conflicting parameters is generated according to the weight distribution, and the adjustable range is fed back through the user interface of the engineering design model to trigger the user to modify the constraint relationship.

[0083] When the constraint solving engine detects a conflict in the set of parameter association rules (i.e., different constraint rules have conflicting requirements for the same parameter value, such as a dimensional constraint requiring a beam span of 6000mm, while a geometric constraint requires a beam span of no more than 5800mm), the system performs an iterative backtracking process based on the conflicting parameter priorities preset in the engineering design model to determine the weight distribution of the conflicting parameters. The conflicting parameter priorities are typically defined during the initialization phase of the engineering design model and stored in a parameter priority table. For example, structural safety-related parameters (such as column bearing capacity and node connection strength) may be prioritized over economic parameters (such as concrete content and component size), or the parameter priority order may be customized according to specific engineering requirements (such as prioritizing pipeline clearance parameters over beam span parameters).

[0084] During the iterative backtracking process, the constraint solving engine assigns weights to the parameters involved in the conflict based on the conflict parameter priority table. The weight assignment rules are directly related to the priority: high-priority parameters retain strict constraints (such as the column section diameter must meet the minimum bearing capacity requirements), and low-priority parameters relax constraints (such as allowing the beam span to float within a certain range). For example, when the column section diameter conflicts with the beam span parameter, if the column section diameter has a higher priority, the engine retains its constraints (such as D≥600mm) and relaxes the constraints of the beam span parameter (such as adjusting the original constraint L≤5800mm to L≤6200mm). The engine continuously adjusts the weight values ​​of low-priority parameters through iterative calculations, gradually expanding its acceptable value range until the constraints of the conflicting parameters are no longer contradictory.

[0085] Based on the weight distribution results, the system generates an adjustable range for the conflicting parameters. The adjustable range is generated based on the constraints after the relaxation calculation. For example, the allowed value range of the beam span parameter after relaxation is 5800mm to 6200mm, or the allowed range of the concrete content parameter is 90% of the original lower limit to 110% of the original upper limit. The generated adjustable range is reflected through the user interface of the engineering design model, usually by highlighting the conflicting parameter, displaying the current value of the parameter and the adjustable range (such as "Current value of beam span: 6000mm, adjustable range: 5800-6200mm"), and an explanation of the cause of the conflict (such as "Conflict with column section diameter constraint, it is recommended to adjust the beam span to an acceptable range").

[0086] The adjustable range provided by the user interface triggers user-defined constraint modifications. Based on this feedback, users can adjust conflicting parameter constraints (e.g., changing the original beam span constraint from L≤5800mm to L≤6200mm) or adjust constraints on other associated parameters (e.g., lowering the priority of the concrete quantity parameter to further relax its constraints). Once these modifications are complete, the system regenerates the parameter constraint set and triggers the constraint solver to iterate until a conflict-free parameter solution is output.

[0087] The above process forms a closed-loop mechanism for conflict resolution through the weight allocation of preset priorities, relaxation calculation of iterative backtracking, and conflict feedback in the user interface. This not only ensures the strict constraints of core parameters (such as structural safety parameters), but also guides users to make reasonable corrections through adjustable ranges, thereby achieving the compatibility of the parameter association rule set and the feasibility of engineering design.

[0088] Specifically, the parametric construction drawing generation method based on the constraint solving algorithm of the present invention, the iterative backtracking includes:

[0089] Determining a weight allocation rule in a conflict resolution strategy based on the priority of the conflict parameters;

[0090] The conflicting parameters are relaxed based on the weight distribution rule, and the calculation results are fed back to the parameterized template in the engineering design model until the constraint solving engine outputs a conflict-free parameter solution.

[0091] The iterative backtracking process is the core mechanism of the constraint solving engine for handling parameter conflicts. It includes two consecutive steps: determining the weight distribution rules and providing relaxation calculation feedback. By dynamically adjusting the constraints of the conflicting parameters, it ultimately achieves the output of a conflict-free parameter solution.

[0092] The weighting rules are determined based on the conflicting parameter priorities preset in the engineering design model. These conflicting parameter priorities are typically stored in the engineering design model as a priority table, which clearly defines the order of priority for each parameter (e.g., the structural safety parameter "column section diameter" takes precedence over the economic parameter "beam span," or the pipeline clearance parameter takes precedence over the component size parameter). When the constraint solving engine detects a conflict (e.g., a geometric constraint requiring a beam span ≤5800mm, while a dimensional constraint requires a beam span of 6000mm), it first extracts the conflicting parameters (e.g., beam span, column section diameter) and queries the priority table to determine the priority level of each parameter. Based on the priority level, the engine generates a weighting rule: high-priority parameters retain their original constraints (e.g., column section diameter must be ≥600mm to meet load-bearing capacity requirements), while the constraints of low-priority parameters are relaxed (e.g., the original beam span constraint of ≤5800mm is adjusted to ≤6200mm), ensuring strict constraints on core parameters.

[0093] Relaxation calculations based on weight distribution rules are implemented by gradually adjusting the value ranges of conflicting parameters. The engine relaxes the constraints of low-priority parameters, for example, gradually relaxing the upper limit of the beam span from 5800mm to 5900mm, 6000mm, 6100mm, and 6200mm. After each adjustment, the parameter solution is recalculated and verified to ensure that all constraints are met. During the relaxation calculation process, the engine feeds back the adjusted parameter values ​​to the parametric template of the engineering design model in real time, driving the dynamic update of the corresponding parameters in the template (for example, when the beam span parameter value is updated from 5800mm to 6000mm, the geometric dimensions of the beam component in the template are adjusted synchronously). Iterative backtracking continues until the constraint solving engine outputs a parameter solution that meets all constraints (for example, beam span = 6000mm, column section diameter = 600mm, and there is no conflict between the two constraints), or the preset maximum number of iterations is reached (if convergence is not achieved, the user is prompted to intervene to correct the constraint relationship).

[0094] These two steps, through priority-driven weight assignment and gradual relaxation computational feedback, form a dynamic adjustment mechanism for conflicting parameters. The weight assignment rules enforce strict constraints on core parameters, while the relaxation computation balances conflicts by gradually widening the parameter range. Ultimately, compatibility within the parameter association rule set is achieved, providing a conflict-free parameter solution foundation for the subsequent generation of 2D construction drawings.

[0095] Specifically, the method for generating parametric construction drawings based on a constraint solving algorithm according to the present invention further includes:

[0096] Generate a version snapshot including current parameter solutions and constraint relationships based on the version management module of the engineering design model;

[0097] In response to a user's selection operation on a historical version snapshot, the parameter solutions and constraint relationships in the version snapshot are loaded into the engineering design model, and constraint solving and drawing generation are retriggered.

[0098] The version management module of the engineering design model realizes status traceability and rapid iteration of the design process by generating version snapshots and responding to historical snapshot loading operations. It specifically includes two technical steps: version snapshot generation and historical snapshot loading.

[0099] The generation of a version snapshot is automatically triggered by the version management module after the parameter solution is output. Each time the constraint solving engine outputs a conflict-free parameter solution and completes the generation of 2D construction drawings, the module extracts the core state data of the current engineering design model, including the specific values ​​of the parameter solution (such as a column section diameter of 650mm, a beam span of 6200mm, etc.), the rule set of constraint relationships (such as the alignment tolerance of geometric constraints, the proportional relationship of dimensional constraints, the conditional expression of logical constraints), and the configuration parameters of the projection algorithm (such as section location, annotation rules, etc.). To reduce storage overhead, the version management module uses differential storage technology, recording only the parameter changes between the current state and the previous version (such as a column section diameter increase of 50mm compared to the previous version) and the modified content of the constraint rules (such as the addition of a pipeline clearance constraint). Finally, a version snapshot containing this data is generated and stored in the model database, providing a data foundation for status tracing during the design process.

[0100] In response to a user's selection of a historical version snapshot, the version management module first verifies the compatibility of the selected snapshot (e.g., checking whether the parameter identifiers in the snapshot are consistent with the parametric template of the current engineering design model to ensure that there are no missing or renamed parameters). Once verified, the module loads the parameter solution values ​​and constraint relationship rules in the snapshot into the engineering design model: the parameter solution values ​​directly overwrite the corresponding parameters in the current model (e.g., restoring the column section diameter from 650mm to 600mm in the snapshot), and the constraint relationship rules are rebinded to the associated fields of the parametric template (e.g., restoring the proportional constraint rules for beam span and plate thickness). After loading is complete, the system automatically triggers the iterative calculation of the constraint solving engine, recalculates the parameter solution based on the constraint relationship of the historical snapshot (if the constraint relationship in the snapshot does not conflict with the current model, the snapshot parameter solution can be used directly; if there are environmental changes or model updates, the engine reverifies the constraint relationship and outputs a new parameter solution), and generates the corresponding version of the two-dimensional construction drawing through the projection algorithm.

[0101] This process achieves reversible traceability and rapid iteration of the design process through differential storage of version snapshots and precise loading of historical states. Version snapshots record key design states, preventing loss of design state due to parameter adjustments or constraint modifications. Loading historical snapshots allows users to quickly restore to any design node, re-triggering solutions and drawing generation, significantly improving engineering design flexibility and efficiency.

[0102] Specifically, the method for generating parametric construction drawings based on a constraint solving algorithm according to the present invention further includes:

[0103] Importing the generated two-dimensional construction drawings into the review module of the engineering design model, and performing compliance verification on the geometric structure and parameters in the drawings according to the preset engineering specifications;

[0104] When a violation is detected, a correction suggestion associated with the violation mark is generated, and a correction operation on the constraint relationship is triggered through a user interface of the engineering design model.

[0105] The audit module of the engineering design model achieves the matching of 2D construction drawings with engineering specifications through compliance verification and violation correction guidance. It specifically includes two technical steps: drawing import verification and violation correction triggering.

[0106] After the generated 2D construction drawings are imported into the review module, they are then verified for compliance based on a pre-set engineering specification database. This database, pre-integrated with mandatory engineering specifications such as the "Architectural Structural Drawing Standard" and the "Pipeline Layout Design Specification," stores specific provisions from these specifications (e.g., the requirement for stirrup reinforcement areas at beam-column joints and a minimum clearance of 200mm at pipeline intersections) and corresponding compliance rules (e.g., the length of the reinforcement area must be 500mm or longer and the clearance must be clearly defined). During the verification process, the module traverses the geometry (e.g., the integrity of the cross-sections at beam-column joints and the spatial avoidance relationships of pipelines) and parameter information (e.g., dimension values ​​and material property values) in the drawings. Using a pattern matching algorithm, the module compares the drawing content with the specification requirements. For the geometry, the module verifies whether the required view representation is met (e.g., whether complex joints generate cross-sections). For parameter information, the module verifies whether the value is within the permitted range (e.g., whether the plate thickness is 120mm or greater) or whether any necessary annotations are missing (e.g., the pipeline clearance is not clearly marked).

[0107] When a violation is detected (such as the lack of stirrup reinforcement area marking at the beam-column joint, or the clear distance between pipelines being marked as "meets the specification" without a specific value), the review module generates correction suggestions associated with the location of the violation. The correction suggestions include the violation type (such as "missing marking" and "parameter out of bounds"), the location of the violation (such as the beam-column joint at the drawing coordinates [X1, Y1]), and specific correction instructions (such as "additional marking of stirrup reinforcement area length ≥ 500mm" and "marking pipeline clear distance as ≥ 200mm"). The correction suggestions are presented through the user interface of the engineering design model, usually in the form of a highlighted box marking the violation area and an additional pop-up window prompt. In some scenarios, they can be linked to the original text of the specification clause (such as "According to Article 3.2.1 of the "Architectural Structural Drawing Standard", the scope of the stirrup reinforcement area must be marked at the beam-column joint").

[0108] The correction suggestions fed back by the user interface directly trigger the correction operation of the constraint relationship. After the user clicks on the violation prompt, the system automatically jumps to the constraint setting interface and locates the constraint rules associated with the violation content (such as the missing conditional trigger rules in the logical constraints corresponding to the unmarked stirrup reinforcement encryption area). Users can adjust the constraint relationship according to the correction suggestions (such as adding the logical constraint of "when the floor height ≥4.0m, the stirrup reinforcement encryption area length ≥500mm"), or modify the parameter value range (such as adjusting the plate thickness size constraint from 120mm to 150mm to 130mm to 160mm to meet the specification requirements). After the constraint relationship is corrected, the system re-triggers the iterative calculation of the constraint solving engine and the generation process of two-dimensional construction drawings until the review module is verified and passed, forming a closed-loop verification mechanism for design data and engineering specifications.

[0109] This process ensures that the generated two-dimensional construction drawings meet engineering specifications through automatic comparison with the specification database, precise positioning of illegal locations, and targeted correction of constraint relationships. It also reduces manual verification costs through coordinated operations in the user interface, thereby improving the compliance and reliability of design results.

[0110] Specifically, the method for generating parametric construction drawings based on a constraint solving algorithm according to the present invention further includes:

[0111] Receiving a parameter adjustment instruction input by a remote user through the multi-terminal collaborative interface of the engineering design model, the parameter adjustment instruction including a target parameter identifier and an updated value;

[0112] The constraint relationship is dynamically updated based on the parameter adjustment instruction, and the parameter solution calculation and the regeneration of the two-dimensional construction drawings are synchronously triggered by the constraint solving engine.

[0113] The multi-terminal collaborative interface of the engineering design model achieves real-time synchronization and collaboration of cross-terminal design data by receiving remote parameter adjustment instructions, dynamically updating constraint relationships, and triggering drawing regeneration. It specifically includes three technical steps: instruction reception and processing, constraint relationship updating, and solution and drawing triggering.

[0114] When a multi-terminal collaborative interface receives parameter adjustment commands from remote users, it uses standardized communication protocols (such as WebSocket or HTTP) for data transmission. Remote users submit parameter adjustment commands through collaborative design terminals (such as mobile devices or remote workstations). These commands are encapsulated in a structured data format (such as JSON) and include the target parameter identifier (e.g., unique identifiers such as "P_beam span" and "P_column section diameter") and the updated value (e.g., "L=6200mm" and "D=700mm"). Upon receiving the command, the interface first performs identity authentication (e.g., verifying user permissions or digital signatures) and command integrity checks (e.g., checking the existence of the parameter identifier and whether the updated value format meets numerical requirements) to ensure the command's source is legitimate and its content is valid. Verified commands are parsed into key-value pairs of the target parameter identifier and the updated value, which serve as input data for constraint updates.

[0115] When dynamically updating constraints based on parameter adjustment commands, the system locates the constraint rules associated with that parameter in the engineering design model based on the target parameter identifier. For example, if the command is "P_Beam Span = 6200mm," the system first searches for the dimensional constraints associated with the beam span parameter (such as the original constraint "Beam Span ≤ 6000mm"), geometric constraints (such as "Beam Span Aligned with Column Spacing"), and logical constraints (such as "Beam Span = 1.2 × Plate Thickness"). It then adjusts the relevant constraint rules based on the updated values: The dimensional constraint is modified to "Beam Span ≤ 6200mm," and the geometric constraint alignment is verified to ensure that it is adjusted (for example, whether the column spacing allows the beam span to be extended to 6200mm). The system also checks whether the logical constraints require updating (for example, whether the plate thickness parameter needs to be adjusted to maintain the proportional relationship of "Beam Span = 1.2 × Plate Thickness"). After formatting the updated constraints (for example, ensuring syntactical correctness of the constraint rules), the updated constraints replace the original constraints in the engineering design model, forming a new set of parameter constraint relationships.

[0116] After the constraint relationship is updated, the system synchronously triggers the parameter solution calculation of the constraint solving engine and the regeneration of the two-dimensional construction drawings. The constraint solving engine loads the updated parameter constraint relationship set and re-executes the iterative calculation (such as checking whether the new constraint conflicts with other rules. If there is a conflict, the weight distribution and relaxation calculation are performed based on the preset priority) until a parameter solution that meets all constraint conditions is output. After the parameter solution is generated, the projection algorithm adjusts the geometric structure of the parametric template based on the updated parameter value (such as extending the length of the beam component to 6200mm) and regenerates the two-dimensional construction drawings (such as updating the dimensioning of the beam span and adjusting the cross-section of the relevant nodes). The generated drawings are synchronized to all related terminals through the multi-terminal collaborative interface, enabling remote users to view the latest design results in real time.

[0117] The above process achieves real-time linkage between parameter adjustment and drawing update in multi-terminal collaborative design scenarios through standardized command transmission and verification, precise constraint relationship positioning and updating, and a synchronous solution and drawing triggering mechanism, avoiding design conflicts caused by information asynchrony and improving the efficiency and consistency of multi-disciplinary and multi-location collaborative design.

[0118] Specifically, the method for generating parametric construction drawings based on a constraint solving algorithm according to the present invention further includes:

[0119] Based on the multi-disciplinary collaborative data interface, the parametric template is associated with the external BIM design model and a synchronization rule between the variable parameters in the parametric template and the parameters of the external BIM design model is established;

[0120] When a parameter change of the external BIM design model is detected, the constraint relationship of the parametric template is automatically updated based on the synchronization rule, and constraint solving and drawing generation are triggered.

[0121] The engineering design model realizes parameter linkage with the external BIM design model through a multi-disciplinary collaborative data interface. Specifically, it includes two technical steps: establishing parameter association mapping and updating parameter change response. It aims to improve the efficiency and consistency of multi-disciplinary collaborative design through cross-system data synchronization.

[0122] The multi-disciplinary collaborative data interface establishes a parameter mapping relationship between the parametric template and the external BIM model. This interface uses standardized data formats (such as the IFC Industry Foundation Classes standard) to communicate with the external BIM model. Key parameters from the external BIM model (such as column location coordinates, beam cross-sectional dimensions, and pipeline material properties) are first extracted and unique identifiers (such as "BIM_columnX coordinate" and "BIM_beam height") are assigned to each parameter. Furthermore, variable parameters defined in the parametric template (such as "Template_columnX coordinate" and "Template_beam height") are pre-bound to the template's geometric property fields (such as column location coordinates and beam cross-sectional height). The system uses the parameter mapping configuration interface to establish the mapping between external BIM parameters and parametric template parameters (e.g., "BIM_columnX coordinate" maps to "Template_columnX coordinate") and define synchronization rules (such as direct numerical synchronization, linear conversion rules like "Template_beam height = BIM_beam height + 50mm," or conditional mapping rules like "When BIM_pipeline material is steel pipe, Template_pipeline clearance = 200mm"). The mapping relationship and synchronization rules are stored in the engineering design model in the form of configuration files, which serve as the basis for cross-system parameter linkage.

[0123] When a parameter change in the external BIM design model is detected, the system automatically updates the constraint relationships of the parametric template based on synchronization rules. Parameter changes in the external BIM model are captured through an event monitoring mechanism (e.g., the BIM software triggers a "parameter modification" event and sends a notification). After receiving the event, the interface parses the changed parameter identifier (e.g., "BIM_column X coordinate") and the new value (e.g., "X=5200mm"), and queries the mapping configuration file to obtain the corresponding parametric template parameters (e.g., "Template_column X coordinate") and synchronization rules (e.g., direct synchronization). The system updates the corresponding parameters in the parametric template based on the synchronization rules (e.g., updating "Template_column X coordinate" from 5000mm to 5200mm) and checks the constraint relationships associated with the parameters (e.g., column centerline alignment rules in geometric constraints, and the relationship between column spacing and beam span ratios in dimensional constraints). If a parameter update causes incompatible constraints (for example, after a column's X coordinate changes, the original dimension constraint of "column spacing = 6000mm" needs to be adjusted), the system automatically adjusts the relevant constraint rules (for example, changing the column spacing constraint to "column spacing = current column X coordinate - adjacent column X coordinate") to form a new set of parameter constraint relationships.

[0124] After the parameter constraint relationship is updated, the system triggers the iterative calculation of the constraint solving engine and the generation of two-dimensional construction drawings. The constraint solving engine loads the updated constraint relationship set and recalculates the parameter solution (such as verifying whether the associated parameters such as beam span and plate thickness meet the constraint conditions after the column X coordinate is changed. If there is a conflict, weight distribution and relaxation calculation are performed based on the preset priority) until a conflict-free parameter solution is output. The projection algorithm adjusts the geometric structure of the parametric template based on the updated parameter values ​​(such as adjusting the position of the column component and extending the length of the beam component to match the new column spacing) and regenerates the two-dimensional construction drawings (such as updating the column location annotation and adjusting the beam span dimension annotation). The generated drawings are synchronized to various professional design terminals through the user interface of the engineering design model and the multi-terminal collaborative interface, realizing real-time linkage between BIM model changes and construction drawing updates.

[0125] This process achieves deep collaboration between parametric templates and external BIM models through parameter mapping, event-driven change detection, and automatic adjustment of constraints within standardized data interfaces. Parameter synchronization rules ensure cross-system data consistency, while dynamic updates of constraints eliminate manual, repetitive adjustments, significantly improving the efficiency and accuracy of construction drawing generation in multi-disciplinary collaborative design.

[0126] The present invention provides a method for generating parametric construction drawings based on a constraint solving algorithm, and the specific implementation process is as follows:

[0127] The method achieves the automated generation and dynamic adjustment of construction drawings through the collaborative work of parametric templates and constraint solving engines. The following is a detailed description of the specific implementation steps of the technical solution:

[0128] During the creation phase of an engineering design model, a digital model framework, including parametric templates, must be constructed. These templates analyze common structural features of historical engineering drawings, extracting fundamental geometric topological relationships and variable parameter ranges to form an initial template library. Users select a base template from the template library through an interactive interface and can then add custom parameters based on current project requirements, such as component size thresholds, material properties, or connection rules. This template is then embedded into the engineering design model, serving as the core vehicle for subsequent constraint setting and drawing generation.

[0129] The constraint setting process revolves around the association rules between parameters. Users input geometric constraints, dimensional constraints, and logical constraints through a graphical interface: Geometric constraints are used to define the relative positions and topological relationships between components, such as the alignment of beam-column nodes or the spatial avoidance rules for pipes; Dimensional constraints generate length, angle, or proportional associations based on user-defined numerical ranges, such as the proportional limit between wall thickness and floor height; Logical constraints describe the dynamic relationship between parameters through formulaic expressions, such as triggering the resizing of adjacent components when the length of a component exceeds a threshold. All constraints are integrated into a set of parameter constraint relationships, forming the input data for subsequent analysis and solution.

[0130] The formula parser is responsible for converting the set of constraint relationships into a machine-readable rule format. The parsing process first unifies the geometric association rules, dimension association rules, and logical expressions into an intermediate expression format, such as structured data based on JSON or XML. The intermediate expressions are then hierarchically parsed using a syntax tree construction algorithm to generate a tree structure that reflects the dependencies between parameters. The semantic verification module verifies the syntax tree to check its compatibility with the parameter types and value ranges defined in the parameterized template to avoid rule conflicts or out-of-bounds errors. The syntax tree that passes the verification is converted into a set of parameter association rules that can be executed by the constraint solving engine, achieving the computability of the rules.

[0131] The constraint solving engine uses iterative calculation and conflict resolution strategies to process parameter association rule sets. When the engine is initialized, a preset conflict resolution strategy is loaded, such as a weight allocation rule or relaxation algorithm based on parameter priority. When a conflict is detected in the rule set, the engine iteratively backtracks according to the priority of the conflicting parameters and relaxes the conflicting parameters by adjusting the weight values, such as reducing the weight of non-critical components to prioritize meeting core size requirements. The calculation results are fed back to the parametric template of the engineering design model in real time, driving the dynamic update of the template parameters until a conflict-free parameter solution that meets all constraints is output. If the conflict cannot be resolved automatically, the engine generates an adjustable parameter range and prompts through the user interface, triggering manual intervention and constraint correction.

[0132] After the parametric solution is generated, the updated parametric template is mapped into a 2D construction drawing using a projection algorithm. Based on the principle of orthogonal projection, the projection algorithm combines the geometric structure and sizing rules defined in the parametric template to automatically generate plan views that conform to engineering drawing specifications. For example, for complex 3D node connections, the algorithm automatically generates sections and detailed views based on topological relationships, enabling the 2D drawing to fully express hidden components and spatial relationships. The generated drawings are saved as snapshots of the current parametric solution and constraint relationships via the version management module, allowing users to retrace historical states and re-trigger the solution process.

[0133] Drawing compliance is verified through the Audit module. Loading a pre-set engineering specification database, the Audit module automatically compares the geometry, annotations, and parameter ranges within the drawing. When violations are detected, the module generates corrective suggestions related to the violation, such as missing component dimensions or material parameters exceeding thresholds. These corrective suggestions are fed back through the user interface and directly linked to the Constraint Setup module, triggering adjustments to the corresponding constraint rules and regeneration of the drawing.

[0134] Multi-terminal collaboration and external model linkage are achieved through a dedicated interface. Remote users submit parameter adjustment instructions through the multi-terminal collaboration interface, which include the unique identifier and updated value of the target parameter. After receiving the instructions, the engineering design model dynamically updates the relevant constraints and simultaneously triggers the iterative calculation of the constraint solving engine and the real-time refresh of the drawings. For multi-disciplinary collaboration scenarios, the parametric template establishes a parameter mapping relationship with the external BIM design model through the data interface. When the parameters in the BIM model change, the mapping rules are automatically synchronized to the constraint relationship of the parametric template, driving the constraint solving and drawing updates to achieve consistency of data across systems.

[0135] The above steps are fully interconnected through the data hub of the engineering design model. Parametric templates serve as the core carrier throughout the entire lifecycle of constraint setting, rule parsing, conflict resolution, and drawing generation. The collaborative work of the constraint solving engine and formula parser solves the lag problem of parameter adjustment and drawing updates in traditional methods. The introduction of version management, compliance verification, and multi-terminal collaboration modules further enhances the system's robustness and engineering applicability, realizing the intelligent and automated process of construction drawing generation.

[0136] The parametric construction drawing generation method of the present invention is implemented by the following technical solutions:

[0137] During the creation phase of the engineering design model, it is necessary to build a digital model framework embedded with parametric templates. The parametric template is based on the DXF or DWG file of the historical engineering drawing or the system-customized sketch template. It uses the feature extraction algorithm to identify common structural features, such as the axis intersection coordinates of the beam-column node and the topological relationship of the pipeline layout, to generate an initial template library. After the user selects the template through the interactive interface, he can add custom parameters associated with the engineering requirements, such as defining the column section diameter as an interval parameter (500mm≤D≤800mm) and binding it to the geometric attribute field of the template. The template is stored in a structured data format, including parameter name, type, value range and association rule fields, providing a data basis for subsequent constraint settings.

[0138] During the constraint setting process, users define geometric, dimensional, and logical association rules through a graphical interface. Geometric constraints are generated based on the template's topological structure. For example, the centerline alignment tolerance for adjacent columns is set to ±5mm, and the minimum clearance between pipes and beam bottoms is constrained to 200mm. Dimensional constraints are set using numeric input boxes or sliders. For example, a plate thickness parameter is limited to [120mm, 150mm] and proportional to the adjacent beam span (L_beam = 1.2 × L_plate). Logical constraints are defined using formulaic expressions. For example, when the floor height H ≥ 4m, the column section diameter D is automatically adjusted (D = H / 8 + 300mm). All constraints are formatted and consolidated into a parametric constraint set, which includes the constraint type, action parameters, and expression data.

[0139] When parsing a set of constraints, the formula parser first converts geometric rules into distance equations (e.g., |X1-X2|≤5mm), dimensional ratio relationships into linear equations (e.g., k1×L1+k2×L2=0), and logical conditional statements into piecewise functions. The parsed intermediate expressions are then generated using a syntax tree construction algorithm to form an abstract syntax tree (AST). The tree nodes contain operators, parameter identifiers, and constant values. The semantic verification module traverses the syntax tree nodes, verifying parameter existence, type matching (e.g., a length parameter cannot be added to an angle parameter), and value range compliance (e.g., whether the plate thickness is within the interval [120mm, 150mm]). The syntax trees that pass verification are serialized into an instruction set recognizable by the constraint solver. For example, the linear equations are converted into the matrix form Ax=b, where A is the coefficient matrix and b is the constraint constant.

[0140] The constraint solving engine uses an iterative algorithm to process parameter association rule sets, loading conflict resolution strategies during initialization. For example, structural safety parameters (such as column bearing capacity) take precedence over economic parameters (such as concrete content). When a constraint conflict is detected, the engine relaxes the conflicting parameters based on priority: maintaining strict constraints for high-priority parameters (e.g., D ≥ 600 mm) while relaxing constraints for lower-priority parameters (e.g., allowing slab thickness to fluctuate within the range of [110 mm, 150 mm]). After each iteration, the updated parameter values ​​are fed back to the parametric template in real time, driving the geometric reconstruction of the 3D model. If convergence persists after more than 10 iterations, the engine generates adjustable ranges for the conflicting parameters (e.g., recommending a beam span of 4800-5200 mm) and highlights the constraints requiring manual correction through the user interface.

[0141] When the projection algorithm generates two-dimensional drawings, it uses a combination of orthogonal projection and dynamic sectioning. For the three-dimensional model in the parametric template, the main view is generated along the axis direction, and the sectioning position is automatically selected according to the component density. For example, when generating a section view at the beam-column node, the algorithm uses the 50% position of the beam height as the section plane, retaining the stirrup spacing (such as @100mm) and the number of longitudinal bars (such as 8Φ20). The annotation module automatically generates dimension annotations based on the values ​​in the parameter solution. For example, the column section diameter D=650mm is converted into the "D650" annotation text and associated with the template parameter identifier. The generated construction drawings are output in DWG format. At the same time, the current parameter solution, constraint relationship and projection parameters are recorded through the version management module to form a version snapshot.

[0142] The version management module uses differential storage technology, recording only the parameter changes between versions. When the user selects a historical snapshot, the module parses the snapshot data and reloads it into the engineering design model, triggering iterative calculations in the constraint solver engine. For example, when rolling back to version V2, the column diameter parameter is restored from 650mm to 600mm. The engine recalculates the associated beam span and slab thickness parameters, generating an updated 2D drawing, accurately restoring the historical state.

[0143] The audit module integrates a database of engineering specifications, including mandatory provisions such as the "Architectural Structural Drawing Standard." During verification, the module traverses the geometric elements and annotation information in the drawing, checking whether the stirrup reinforcement area at beam-column joints is marked (e.g., ≥500mm) and whether the minimum clearance distance at pipeline intersections is maintained (e.g., ≥200mm). If a violation is detected (e.g., a plate thickness of 110mm is marked but the constraint condition is set to ≥120mm), the module generates correction suggestions and locates the corresponding constraint relationship entry. The user can directly jump to the constraint setting interface to adjust the parameter range or association rules.

[0144] The multi-terminal collaborative interface implements data synchronization based on the WebSocket protocol. When a remote user submits a parameter adjustment instruction, the instruction message includes the parameter ID (such as "P_beam span"), the target value (such as L=8000mm) and a timestamp. After receiving the instruction, the engineering design model updates the corresponding constraint conditions and broadcasts them to all terminals, triggering constraint solving and drawing refresh. For BIM model linkage, the parameter change events of the external model are parsed through the IFC format. For example, when the column positioning coordinates in the BIM are modified to Δx=200mm, the mapping rule converts Δx into the axis offset of the parametric template, triggering the recalculation of the dimensions of the associated components, and updating the positioning annotations in the two-dimensional drawings, to achieve consistent linkage of cross-system data.

[0145] The above implementation method transforms the abstract steps of the claim into actionable technical details through a layered technical approach. The parametric template construction and parsing process supports the template creation step; the constraint solver's iterative strategy and conflict resolution mechanism improve the parametric solution generation process; and the collaborative projection algorithm and review module achieve a closed-loop between drawing generation and compliance verification. The data flow between these modules (e.g., parameter constraint set → syntax tree → solution instruction set) fully implements the technical features of the claim.

[0146] The present invention provides a parametric construction drawing generation method based on a constraint solving algorithm. Its core process achieves automated drawing production through the collaboration of parametric templates and a constraint solving engine. First, a parametric template is embedded in the engineering design model. This template defines the basic structure of the construction drawing (e.g., beam and column axis layout) and variable parameters associated with engineering requirements (e.g., component dimensions and material properties). Based on actual requirements, the user inputs geometric, dimensional, and logical constraints, such as defining the alignment tolerance of adjacent components or the proportional relationship between parameters, to generate a set of parametric constraint relationships. Subsequently, a formula parser converts the constraint rules into intermediate expressions and, through syntax tree construction and semantic verification, generates a set of parameter association rules that can be recognized by the constraint solving engine. The constraint solving engine processes the rule set using an iterative algorithm and, in combination with conflict resolution strategies (e.g., priority weighting), outputs a parametric solution that satisfies all constraints. Finally, a projection algorithm is used to map the updated parametric template into a two-dimensional construction drawing that complies with engineering drawing specifications, enabling parameter-driven dynamic drawing production.

[0147] Further refine the types and mechanisms of constraint relationships. Geometric constraints are used to define the relative positions of graphic elements (such as the column centerline alignment tolerance of ±5mm) and topological relationships (such as pipe avoidance rules) in engineering design models, and generate geometric association rules based on the basic structure of the parametric template. Dimensional constraints define the length, angle, or proportional relationship of components based on the numerical range entered by the user (such as wall thickness [120mm, 150mm]), and are converted into linear equations or proportional rules through a formula parser. Logical constraints describe the dynamic association between parameters through formulaic expressions (such as conditional trigger rules). For example, when the floor height exceeds a threshold, the column section size is automatically adjusted. The logical expression is parsed and input into the constraint solving engine. The three types of constraints work together to cover spatial layout, dimensional compliance, and dynamic adjustment requirements in engineering design.

[0148] The parsing process of the formula parser is divided into three stages. First, the geometric association rules, dimension association rules, and logical expressions are uniformly converted into an intermediate expression format (such as JSON or XML) to eliminate format differences between different constraint types. Subsequently, the intermediate expressions are hierarchically parsed using a syntax tree construction algorithm to generate a tree structure that reflects the parameter dependencies. The semantic verification module traverses the syntax tree nodes to verify whether the parameters exist, type matching (for example, the length parameter cannot be added to the angle parameter), and value range compliance (for example, whether the plate thickness is within the set range). The syntax tree that passes the verification is serialized into an instruction set that can be executed by the constraint solving engine (such as the matrix equation Ax=b), achieving rule computability and model compatibility.

[0149] The creation of parametric templates is based on data mining and reuse of historical engineering drawings. Feature extraction algorithms (such as axis intersection recognition and topological relationship analysis) extract common structural features from historical drawings to generate an initial template library associated with the engineering design model. After selecting a template through an interactive interface, users can add custom parameters based on current project requirements, such as adding a cantilever length parameter or adjusting the material strength threshold for a selected beam and column template. Templates loaded into the model automatically inherit the structural features of the historical data and support flexible parameter expansion, balancing design efficiency and personalized needs.

[0150] When the constraint solving engine detects a conflict in a set of parameter association rules, it iterates and backtracks based on the conflicting parameter priorities preset in the model (e.g., structural safety parameters take precedence over economic parameters). The engine assigns weights to conflicting parameters based on their priorities, for example, maintaining strict constraints on key component sizes while allowing minor parameters to fluctuate within a certain range. The calculation results are fed back to the parametric template in real time, driving the dynamic update of the template parameters. If a conflict still exists after iteration, the engine generates an adjustable range for the conflicting parameters (e.g., recommending that the beam span be adjusted to 4800-5200mm) and highlights the constraints that need to be corrected through the user interface, guiding the user to adjust the constraints or parameter thresholds.

[0151] The specific implementation of iterative backtracking involves weight assignment rules and relaxation calculations. The conflict resolution strategy defines weight assignment rules based on the priority of conflicting parameters. For example, the column bearing capacity parameter has a higher weight coefficient than the concrete content parameter. Based on this weighting rule, the engine performs relaxation calculations on conflicting parameters, gradually relaxing the constraints of lower-priority parameters (for example, allowing slab thickness to fluctuate within the range of [110mm, 150mm]) until a conflict-free parametric solution is output. The calculation results are synchronized to the parametric template in real time, ensuring dynamic updates and consistency of model data.

[0152] After generating 2D construction drawings, the version management module automatically records the current parameter solutions and constraint relationships, creating a version snapshot. This snapshot utilizes differential storage technology, saving only parameter changes to reduce storage overhead. When the user selects a historical version, the module parses the snapshot data and reloads it into the engineering design model, triggering iterative calculations in the constraint solver engine. For example, when rolling back to version V2, the column diameter parameter is restored from 650mm to 600mm. The engine then recalculates the associated beam span and slab thickness parameters, generating updated 2D drawings and enabling reversible traceability and rapid iteration of design status.

[0153] The audit module integrates with engineering specification databases (such as the Building Structural Drawing Standard) to perform compliance checks on generated 2D drawings. This process examines the geometry (e.g., beam-column joint connections) and annotation information (e.g., dimensional tolerances) within the drawings, checking for conformance to pre-set specifications. If a violation is detected (e.g., a plate thickness annotation value falls below a constraint), the module generates correction suggestions associated with the violation (e.g., a prompt to adjust the plate thickness to ≥120mm). The module then navigates to the corresponding constraint entry through the user interface, directly triggering the constraint correction and drawing regeneration.

[0154] The multi-terminal collaborative interface supports real-time adjustment of design parameters by remote users. Users submit parameter adjustment commands (e.g., changing the beam span to L=8000mm) through the interface. The command message includes the target parameter identifier and the updated value. Upon receiving the command, the engineering design model dynamically updates the constraints and simultaneously triggers iterative calculations in the constraint solver engine. The calculation results drive real-time adjustments to the parametric template, and an updated 2D drawing is generated using a projection algorithm, enabling data synchronization and rapid response in multi-terminal collaborative design.

[0155] Through a multi-disciplinary collaborative data interface, parametric templates establish parameter mappings with external BIM design models. For example, column location coordinates in the template are bound to axis coordinates in the BIM model, and synchronization rules are defined. When BIM model parameters change (e.g., a column position shift of Δx = 200mm), the mapping rules automatically update the constraints in the parametric template, triggering the constraint solver to recalculate and generate updated 2D drawings. This mechanism enables cross-system data linkage, avoids repeated manual adjustments, and improves the efficiency of multi-disciplinary collaboration.

[0156] Embodiments of the present invention in civil engineering scenarios:

[0157] The method presented in this paper is applied to generate construction drawings in the design of high-rise building beam-column structures. The engineering designer selected a standard floor parametric template from a historical project library. The template included an axis grid, beam-column node connection rules, and initial parameters (e.g., column cross-section diameter D = 600mm). Based on the current project requirements, a floor height of 3.6m was added as a variable parameter, and constraints were set: a geometric constraint defined a ±5mm alignment tolerance for adjacent column centerlines; a dimensional constraint established a proportional relationship between column diameter D and floor height H (D = H / 6 + 250mm); and a logical constraint added a conditional trigger rule. When the floor height H ≥ 4.0m, the association rule for the column stirrup reinforcement zone length ≥ 500mm was automatically activated. The formula parser converted the constraints into intermediate expressions, which were then validated through a syntax tree to generate a parameter association rule set. When the constraint solver detected a floor height of 4.2m, it calculated the column diameter D = 4.2 / 6 + 250 = 700mm, triggering the stirrup reinforcement rule. However, this conflicted with the original template beam span of 6000mm. The engine performs relaxation calculations on the beam span based on the structural safety priority and outputs L=6200mm as a feasible solution. The projection algorithm generates a two-dimensional drawing based on the updated parameters, automatically marks the column D700, beam L6200 and the range of the encrypted area, and generates detailed cross-sectional drawings of the beam-column node. The review module detects that the stirrup spacing annotation is missing in the cross-sectional drawing, feeds back to the constraint module and adds the stirrup @100mm annotation rule, re-triggers the solution and generates a complete drawing. The multi-terminal collaborative interface synchronously updates parameters to the BIM model. When the external model adjusts the column positioning coordinate Δx=200mm, the mapping rule drives the template parameter update and regenerates the positioning annotation to achieve cross-system data consistency.

[0158] The present invention systematically solves the technical difficulties in converting three-dimensional models into construction drawings through the collaborative mechanism of parametric templates and constraint solving engines. First, the parametric template is based on engineering drawing specifications to define the structural characteristics of construction drawings and the association rules of variable parameters. Geometric constraints are used to solidify the spatial topological relationship between components (such as the axis alignment tolerance of beam-column nodes), dimensional constraints are used to set the numerical ratio between parameters (such as the dynamic association between wall thickness and floor height), and logical constraints are used to describe the dynamic adjustment rules triggered by conditions (such as automatically strengthening the column section when the floor height exceeds the limit). The three types of constraints are converted into a computable set of association rules through a formula parser. The constraint solving engine iteratively outputs conflict-free parameter solutions based on the conflict resolution strategy, thereby achieving the geometric logical integrity of the drawings when the parameters are adjusted and avoiding the loss of details during the projection process.

[0159] To address drafting specification compliance issues, the system has a built-in audit module that is linked to the engineering specification database. When the projection algorithm generates two-dimensional drawings, it combines the structural definition and drafting rules in the parametric template to automatically generate standard-compliant view expressions (such as multi-directional cross-sections of complex nodes). The audit module traverses the geometric structure, annotation information, and parameter range of the drawing, and compares the preset specification items in real time (such as the completeness of the annotation of the stirrup reinforcement area and the pipeline clearance threshold). When violations are detected, it generates precisely positioned correction suggestions (such as the missing beam span size), and reversely links to the constraint setting module to trigger iterative updates of the constraint rules, thus achieving a closed-loop linkage between design data and drafting specifications.

[0160] To address the bottleneck in drawing generation efficiency, the system optimizes the process through a multi-terminal collaborative interface and an external model mapping mechanism. After the remote user submits a parameter adjustment instruction, the constraint solving engine performs synchronous calculations based on the dynamically updated constraint relationships, driving the real-time reconstruction of the parametric template and drawing refresh. The parameter mapping rules of the external BIM model (such as axis coordinate synchronization) are used to achieve cross-system data linkage, and automatically trigger constraint solving and drawing updates when external model changes are detected. The version management module records snapshots of parameter solutions and constraint relationships, supports one-click backtracking and re-solving of historical states, eliminates the redundant operations of manual repeated adaptation of model iterations in traditional methods, and significantly improves the robustness of drawing generation and the efficiency of multi-disciplinary collaboration.

Claims

1. A method for generating parametric construction drawings based on a constraint solving algorithm, characterized in that: include: Creating an engineering design model having a parametric template embedded therein, wherein the parametric template defines the basic structure of the construction drawings and variable parameters associated with the engineering requirements; Based on the constraints input by the user, geometric associations, dimensional associations and logical associations are set for the variable parameters in the parametric template to generate a parameter constraint relationship set; Parsing the association rules in the parameter constraint relationship set by a formula parser to generate a parameter association rule set that can be recognized by a constraint solving engine; Inputting the parameter association rule set into a constraint solving engine for iterative calculation, the constraint solving engine outputting a parameter solution that satisfies all constraint conditions based on a preset conflict resolution strategy; updating the variable parameters in the parametric template according to the values ​​in the parameter solution, and mapping the updated parametric template into a two-dimensional construction drawing through a projection algorithm; The parameter constraint relationship set includes: Geometric constraints for defining relative positions and topological relationships of graphic elements in the engineering design model and generating geometric association rules based on the basic structure of the parametric template; Dimension constraints, used to define the length, angle or proportional relationship of graphic elements according to the numerical range input by the user, and converted into dimension association rules by the formula parser; Logical constraints, used to generate logical expressions based on the formulated associations between parameters or conditional triggering rules, the logical expressions being parsed by the formula parser and then input into the constraint solving engine; The association rules in the parameter constraint relationship set are parsed by a formula parser to generate a parameter association rule set that can be recognized by the constraint solving engine, including: Convert geometric association rules, dimension association rules and logical expressions into intermediate expressions in a unified format; Constructing a syntax tree for the intermediate expression, and verifying the compatibility of the syntax tree with the parameterized template of the engineering design model through a semantic verification module; Generating a parameter association rule set executable by the constraint solving engine according to the syntax tree that has passed the verification; The creation of the parameterized template includes: Extracting common structural features based on historical engineering drawings to generate an initial template library associated with the engineering design model; In response to a user selecting a template in the initial template library, the selected template is loaded into the engineering design model, and custom parameters associated with the template are added according to engineering requirements input by the user.

2. The method for generating parametric construction drawings based on a constraint solving algorithm according to claim 1, wherein: Also includes: When the constraint solving engine detects a conflict in the generated parameter association rule set, it iterates and backtracks based on the conflict parameter priorities preset in the engineering design model to determine the weight distribution of the conflict parameters; An adjustable range of the conflicting parameters is generated according to the weight distribution, and the adjustable range is fed back through the user interface of the engineering design model to trigger the user to modify the constraint relationship.

3. The method for generating parametric construction drawings based on a constraint solving algorithm according to claim 2, wherein: The iterative backtracking includes: Determining a weight allocation rule in a conflict resolution strategy based on the priority of the conflict parameters; The conflicting parameters are relaxed based on the weight distribution rule, and the calculation results are fed back to the parameterized template in the engineering design model until the constraint solving engine outputs a conflict-free parameter solution.

4. The method for generating parametric construction drawings based on a constraint solving algorithm according to claim 3, wherein: Also includes: Generate a version snapshot including current parameter solutions and constraint relationships based on the version management module of the engineering design model; In response to a user's selection operation on a historical version snapshot, the parameter solutions and constraint relationships in the version snapshot are loaded into the engineering design model, and constraint solving and drawing generation are retriggered.

5. The method for generating parametric construction drawings based on a constraint solving algorithm according to claim 4, characterized in that: Also includes: Importing the generated two-dimensional construction drawings into the review module of the engineering design model, and performing compliance verification on the geometric structure and parameters in the drawings according to the preset engineering specifications; When a violation is detected, a correction suggestion associated with the violation mark is generated, and a correction operation on the constraint relationship is triggered through a user interface of the engineering design model.

6. The method for generating parametric construction drawings based on a constraint solving algorithm according to claim 5, characterized in that: Also includes: Receiving a parameter adjustment instruction input by a remote user through the multi-terminal collaborative interface of the engineering design model, the parameter adjustment instruction including a target parameter identifier and an updated value; The constraint relationship is dynamically updated based on the parameter adjustment instruction, and the parameter solution calculation and the regeneration of the two-dimensional construction drawings are synchronously triggered by the constraint solving engine.

7. The method for generating parametric construction drawings based on a constraint solving algorithm according to claim 6, wherein: Also includes: Based on the multi-disciplinary collaborative data interface, the parametric template is associated with the external BIM design model and a synchronization rule between the variable parameters in the parametric template and the parameters of the external BIM design model is established; When a parameter change of the external BIM design model is detected, the constraint relationship of the parametric template is automatically updated based on the synchronization rule, and constraint solving and drawing generation are triggered.

Images