Cross-platform parametric design methods, devices, equipment, media, and programs

Abstract

This disclosure provides a cross-platform parametric design method, apparatus, device, medium, and program, relating to the field of computer technology. The method includes: acquiring parametric design data from a first application software, the parametric design data including a geometric model file generated by the first application software and a corresponding parameter configuration file; inputting the parametric design data into a pre-built two-layer processing framework consisting of a geometry processing layer based on an OCCT geometric kernel and a scene description layer based on a USD format, used to map parameters in the parametric design data to geometric entities and encapsulate them into USD assets containing parametric feature information; outputting the USD assets to a second application software, enabling the second application software to modify parameters based on the parametric feature information in the USD assets, and triggering the two-layer processing framework to perform geometric reconstruction and synchronization of the modified parameters. This disclosure realizes cross-platform application of parametric design data and improves parametric design efficiency.

Description

Technical Field

[0001] This disclosure relates to the field of computer technology, and in particular to a cross-platform parametric design method, apparatus, device, medium and program. Background Technology

[0002] Parametric design has become a key means to improve product design efficiency. Currently, mainstream 3D design software typically uses proprietary formats to store complete parametric models containing feature history and constraint relationships, which can work efficiently within their own platforms.

[0003] However, existing technologies face significant challenges when cross-platform collaboration is required, such as importing models from design software into simulation, visualization, or other specialized applications for further processing. Typically, models are exchanged using neutral formats like STEP (Standard for the Exchange of Product Model Data), but these formats primarily transmit the model's final geometry, resulting in the loss of parametric design information during the exchange. The model degenerates into an uneditable, static geometry, forcing any design modifications to be made within the original software, severely hindering the efficiency and consistency of cross-platform workflows.

[0004] Furthermore, while existing scene description technologies can effectively organize complex 3D scenes, they generally lack native support for CAD (Computer-Aided Design) level parametric geometric operations and constraints. At the same time, parameter adjustments and optimizations during the design process still heavily rely on manual trial and error, lacking automation and intelligence.

[0005] Therefore, existing technologies present a contradiction between parametric intelligence and data exchange efficiency, and there is an urgent need for a new method that can achieve lossless transmission, intelligent processing, and collaborative editing of parametric design information in cross-platform exchange.

[0006] It should be noted that the information disclosed in the background section above is only used to enhance the understanding of the background of this disclosure, and therefore may include information that does not constitute prior art known to those skilled in the art. Summary of the Invention

[0007] This disclosure provides a cross-platform parametric design method, apparatus, device, medium, and program, which at least to some extent overcomes the problem of low efficiency in parametric design due to related technologies.

[0008] Other features and advantages of this disclosure will become apparent from the following detailed description, or may be learned in part from practice of this disclosure.

[0009] According to one aspect of this disclosure, a cross-platform parametric design method is provided, comprising: acquiring parametric design data from a first application software, the parametric design data including a geometric model file generated by the first application software and a corresponding parameter configuration file; inputting the parametric design data into a pre-built two-layer processing framework, the two-layer processing framework including a geometry processing layer based on an OCCT geometric kernel and a scene description layer based on a USD format, the two-layer processing framework being used to map parameters in the parametric design data to geometric entities and encapsulate them into USD assets containing parametric feature information; and outputting the USD assets to a second application software, so that the second application software can modify the parameters based on the parametric feature information in the USD assets and trigger the two-layer processing framework to perform geometric reconstruction and synchronization of the modified parameters.

[0010] In some embodiments, mapping the parameters in the parametric design data to geometric entities and encapsulating them into USD assets containing parametric feature information includes: defining feature classes for describing parametric operations in the scene description layer, the feature classes including stretching, arraying, and offsetting; defining a corresponding set of attribute parameters for each feature class; converting the information describing parametric features in the parameter configuration file into corresponding USD Prim attributes according to the defined feature classes and their attribute parameter sets, and storing them in the USD asset.

[0011] In some embodiments, the two-layer processing framework is triggered to perform geometric reconstruction and synchronization of the modified parameters, including: reading a predefined objective function from the attributes of the USD asset; using the modified parameters as initial values, performing iterative calculations using a gradient-based optimization algorithm to find the optimal parameter combination that satisfies the objective function.

[0012] In some embodiments, before triggering the two-layer processing framework to perform geometric reconstruction and synchronization of the modified parameters, the method further includes: constructing a constraint dependency graph with parameters and geometric entities as nodes and constraint relationships between parameters as edges; performing topological sorting on the constraint dependency graph to determine the solution order and detecting cyclic dependencies; solving the constraint relationships using a numerical iterative algorithm according to the solution order, and relaxing conflicting constraints.

[0013] In some embodiments, the geometric model file is a STEP format file; the parameter configuration file is a JSON format file; mapping the parameters in the parametric design data to geometric entities includes: parsing the JSON format file to obtain the feature tree information described therein; extracting the corresponding feature parameters from each feature node contained in the feature tree information; and establishing a correspondence between the extracted feature parameters and the specific geometric entities parsed by the OCCT geometric kernel from the STEP format file.

[0014] In some embodiments, the dual-layer processing framework uses an incremental update mechanism to synchronize the modified parameters, including: the dual-layer processing framework determines the specific geometric component affected by the parameter modification; only the affected specific geometric component is recalculated using the OCCT geometric kernel; the recalculated geometric data and scene attributes are updated to the USD asset, and the second application software is notified to perform a partial refresh.

[0015] According to another aspect of this disclosure, a cross-platform parametric design apparatus is also provided, comprising: a data acquisition module for acquiring parametric design data from a first application software, the parametric design data including a geometric model file generated by the first application software and a corresponding parameter configuration file; a data input module for inputting the parametric design data into a pre-built two-layer processing framework, the two-layer processing framework including a geometry processing layer based on an OCCT geometric kernel and a scene description layer based on a USD format, the two-layer processing framework being used to map parameters in the parametric design data to geometric entities and encapsulate them into USD assets containing parametric feature information; and a data output module for outputting the USD assets to a second application software, so that the second application software can modify parameters based on the parametric feature information in the USD assets and trigger the two-layer processing framework to perform geometric reconstruction and synchronization of the modified parameters.

[0016] According to another aspect of this disclosure, an electronic device is also provided, comprising: a processor; and a memory for storing executable instructions of the processor; wherein the processor is configured to perform the cross-platform parametric design method described in any of the preceding claims by executing the executable instructions.

[0017] According to another aspect of this disclosure, a computer-readable storage medium is also provided, on which a computer program is stored, which, when executed by a processor, implements the cross-platform parametric design method described in any of the preceding claims.

[0018] According to another aspect of this disclosure, a computer program product is also provided, including a computer program that, when executed by a processor, implements the cross-platform parametric design method of any of the above.

[0019] The cross-platform parametric design method, apparatus, device, medium, and program provided in the embodiments of this disclosure acquire parametric design data from a first application software. This parametric design data includes a geometric model file generated by the first application software and a corresponding parameter configuration file. The parametric design data is then input into a pre-built two-layer processing framework. This framework includes a geometry processing layer based on an OCCT geometric kernel and a scene description layer based on the USD format. The two-layer processing framework maps parameters in the parametric design data to geometric entities and encapsulates them into USD assets containing parametric feature information. The USD assets are then output to a second application software, enabling the second application software to modify parameters based on the parametric feature information in the USD assets and triggering the two-layer processing framework to perform geometric reconstruction and synchronization of the modified parameters. This disclosure completely solves the core pain point of traditional CAD parametric data, which relies on specific software and cannot be used across platforms. By converting parametric design data into standard USD assets, it ensures the complete and lossless transmission of parametric feature information during the transfer from the first application software to the second application software. Because the second application software can directly read and modify parameters in USD assets, users can quickly perform design verification and iteration in a wider range of application environments without returning to the original CAD software, greatly shortening the design cycle. When parameters are modified in downstream software, the underlying OCCT geometric kernel is automatically triggered to perform precise geometric reconstruction and update the USD assets in real time. This minimizes manual intervention, avoids errors caused by manual conversion and updates, and ensures high data consistency and reliability throughout the design process. By leveraging the complementary advantages of OCCT and USD, a unified intelligent design infrastructure is constructed. This solution creatively combines OCCT's precise geometric processing capabilities with USD's powerful scene description and data nesting capabilities, forming a two-layer processing framework where the geometric processing layer and scene description layer work together. This not only solves the current data interoperability problem but also lays a unified technical foundation for building a next-generation intelligent design system that supports advanced applications such as parameter optimization and simulation-driven design.

[0020] It should be understood that the above general description and the following detailed description are exemplary and explanatory only, and are not intended to limit this disclosure. Attached Figure Description

[0021] The accompanying drawings, which are incorporated in and form part of this specification, illustrate embodiments consistent with this disclosure and, together with the description, serve to explain the principles of this disclosure. It is obvious that the drawings described below are merely some embodiments of this disclosure, and those skilled in the art can obtain other drawings based on these drawings without any inventive effort.

[0022] Figure 1 This illustration shows a schematic diagram of a CAD drawing created using SOLIDWORKS in an embodiment of this disclosure. Figure 2 A schematic diagram of a CAD model of an industrial design software according to an embodiment of the present disclosure is shown; Figure 3 This diagram illustrates a flowchart of a cross-platform parametric design method according to an embodiment of the present disclosure; Figure 4 This illustration shows a flowchart of yet another cross-platform parametric design method in an embodiment of this disclosure; Figure 5 This illustration shows a flowchart of yet another cross-platform parametric design method in an embodiment of this disclosure; Figure 6 This illustration shows a flowchart of yet another cross-platform parametric design method in an embodiment of this disclosure; Figure 7 This illustration shows a flowchart of yet another cross-platform parametric design method in an embodiment of this disclosure; Figure 8 This illustration shows a flowchart of yet another cross-platform parametric design method in an embodiment of this disclosure; Figure 9 This invention discloses a complete flowchart of a cross-platform parametric design workflow implementation method according to an embodiment of the present disclosure. Figure 10 This diagram illustrates a cross-platform parametric design apparatus according to an embodiment of the present disclosure. Figure 11 A structural block diagram of an electronic device according to an embodiment of the present disclosure is shown. Detailed Implementation

[0023] Exemplary embodiments will now be described more fully with reference to the accompanying drawings. However, these exemplary embodiments can be implemented in many forms and should not be construed as limited to the examples set forth herein; rather, they are provided so that this disclosure will be more comprehensive and complete, and will fully convey the concept of the exemplary embodiments to those skilled in the art. The described features, structures, or characteristics may be combined in any suitable manner in one or more embodiments.

[0024] Furthermore, the accompanying drawings are merely illustrative of this disclosure and are not necessarily drawn to scale. The same reference numerals in the drawings denote the same or similar parts, and therefore repeated descriptions of them will be omitted. Some block diagrams shown in the drawings are functional entities and do not necessarily correspond to physically or logically independent entities. These functional entities may be implemented in software, in one or more hardware modules or integrated circuits, or in different network and / or processor devices and / or microcontroller devices.

[0025] The specific implementation methods of the embodiments of this disclosure will now be described in detail with reference to the accompanying drawings.

[0026] In the field of computer-aided design, parametric design, through defining feature history trees, dimensional constraints, and equations, has become a key technology for improving design efficiency and model reusability. Mainstream commercial CAD systems, such as SOLIDWORKS and CATIA, provide powerful parametric capabilities within their closed ecosystems. However, this highly integrated parametric capability has significant limitations. When models need to be exchanged across platforms for collaborative design, simulation analysis, or virtual reality (VR) applications, parametric information is easily lost due to its reliance on proprietary formats. Typically, models are transferred using neutral formats such as STEP (Standard for the Exchange of Product model data), but these formats primarily record the final boundary representation (BREP) geometry of the model, causing its parametric design history and constraint relationships to be stripped away during the exchange process, degenerating the intelligent model into an uneditable static geometry.

[0027] Existing technologies offer independent solutions that attempt to address certain problems, but all have inherent limitations. The open-source geometry kernel Open CASCADE Technology (OCCT) provides accurate BREP modeling and Boolean operations, but its native parametric interface is limited, making it difficult to independently manage scene information for complex assemblies. On the other hand, the Universal Scene Description (USD) format excels at hierarchical organization, attribute inheritance, and efficient combination of complex 3D scenes, but when applied in CAD fields outside the film and television industry, it lacks native support for CAD-level parametric geometric operations such as stretching, rotation, arraying, and offsetting, and cannot handle rigorous geometric constraint solving.

[0028] In real-world industrial workflows, the consequences of these limitations are particularly pronounced. For example, when attempting to use parametric models from SOLIDWORKS for simulation visualization in the Unity engine, engineers need to manually export STEP geometry files and additionally write JavaScript Object Notation (JSON) configuration files to try and record some parameter relationships. This highly manual intervention-dependent approach is not only inefficient and error-prone, but also fails to achieve automated geometry reconstruction and scene synchronization after parameter modifications, resulting in slow design iterations and difficulty in guaranteeing simulation accuracy. Figure 1 The diagram shows a CAD drawing created by SOLIDWORKS, which enables model editing through feature numbers, but is limited to the software itself. Figure 2 This shows a CAD model diagram of an industrial design software, such as... Figure 2 As shown, when downstream applications, such as certain industrial design software or simulation platforms, load... Figure 1 When creating a model, typically only static display and basic operations on the model's geometry are possible, with the original parametric editing capabilities completely lost. Therefore, traditional technical solutions struggle to support the effective transfer and reuse of parametric models in cross-platform workflows.

[0029] This disclosure provides a cross-platform parametric design method that can be executed by any electronic device with computing capabilities.

[0030] Figure 3 This illustration shows a flowchart of a cross-platform parametric design method according to an embodiment of the present disclosure, such as... Figure 3 As shown, the cross-platform parametric design method provided in this embodiment includes the following steps: S302, Obtain parametric design data from the first application software. The parametric design data includes a geometric model file generated by the first application software and a corresponding parameter configuration file.

[0031] It's important to note that this step is the starting point for cross-platform processing, aiming to solve the problem of completely exporting parametric data from the source. The first application software can be any computer-aided design (CAD) software with parametric design capabilities, such as SOLIDWORKS or CATIA. These software programs internally use proprietary formats to store complete parametric models. Parametric design data is a set of data exported to retain the model's design logic even after being removed from the original software environment. Parametric design data includes the geometric model file generated by the first application software and the corresponding parameter configuration file. The geometric model file is typically a neutral format file such as STEP (Standard for the Exchange of Product model data), which records the boundary representation (BREP) geometric information of the model, i.e., the final shape of the model. The parameter configuration file is a structured data file, such as a JSON (JavaScript Object Notation) file, used to record parametric design information associated with the geometric model, including but not limited to feature tree structure, dimensional parameters, variable equations, and geometric constraints.

[0032] By exporting both geometric and parametric information from the first application software, a complete data foundation is provided for subsequent steps, overcoming the fundamental defect of traditional workflows where only geometric models are exchanged, resulting in the loss of parametric information.

[0033] S304 inputs parametric design data into a pre-built two-layer processing framework. The two-layer processing framework includes a geometry processing layer based on the OCCT geometry kernel and a scene description layer based on the USD format. The two-layer processing framework is used to map the parameters in the parametric design data to geometric entities and encapsulate them into USD assets containing parametric feature information.

[0034] It's important to note that the two-layer processing framework is a pre-built software architecture. The geometry processing layer, based on the OCCT (OpenCASCADE Technology) geometry kernel, handles all precise geometric calculations. OCCT, as an open-source geometry engine, provides powerful BREP modeling, Boolean operations, and feature operations such as stretching and rotation. The scene description layer, based on the USD (Universal Scene Description) format, manages the scene's hierarchical structure, attribute storage, and data exchange. The USD format is extended here, defining feature classes for describing parametric CAD operations through a custom schema, such as UsdStretch for stretching and UsdArray for arrays.

[0035] Mapping and encapsulation refer to the two-layer processing framework parsing the parameter configuration file, associating the parametric features described therein, such as an extrusion feature and its depth parameters, with specific geometric entities, such as the extruded faces, parsed from the STEP file by the OCCT layer. These features and parameters are then converted into USD Prim attributes according to the USD Schema, ultimately generating a self-contained USD asset. This USD asset not only contains references to geometry but, more importantly, embeds complete and understandable parametric feature information. The two-layer processing framework achieves lossless conversion of parametric design data from the source format to a general intermediate format.

[0036] S306, output USD assets to the second application software so that the second application software can modify parameters based on the parameterized feature information in the USD assets, and trigger the two-layer processing framework to perform geometric reconstruction and synchronization of the modified parameters.

[0037] It should be noted that the second application software refers to any downstream application that needs to receive and use the CAD model, such as Unity or other applications used for real-time simulation, visualization, or virtual reality. The USD asset is the output of the parametric design data after it has been input into the two-layer processing framework. When a user modifies the parameters exposed in the USD asset in the second application software, an event is triggered that notifies the two-layer processing framework to perform geometric reconstruction and synchronization operations.

[0038] Among them, geometric reconstruction is the process by which the OCCT geometry layer regenerates the geometric model based on the new parameters. Synchronization involves synchronizing the updated geometry and scene state back to the USD asset and notifying the second application software to refresh the display. This enables downstream applications to directly perform parametric design and editing on the imported CAD model, achieving automated modification, reconstruction, and synchronization. This completely changes the traditional working mode of loading static models and greatly improves the efficiency and intelligence of cross-platform collaboration.

[0039] The solution provided in this disclosure addresses the problem of platform lock-in in parametric information, enabling lossless transfer of parametric design data across platforms. It bridges the gap between geometric modeling and scene description by implementing a unified data carrier through a two-layer framework of OCCT and USD. Furthermore, it overcomes the inefficiency of parametric design by improving the efficiency of cross-platform parametric design work through geometric reconstruction and synchronization mechanisms.

[0040] In some embodiments of this disclosure, such as Figure 4 As shown, mapping parameters in parametric design data to geometric entities and encapsulating them into USD assets containing parametric feature information also includes the following steps: S402, in the scene description layer, defines feature classes for describing parameterized operations. Feature classes include stretching, arraying, and offsetting. S404 defines a corresponding set of attribute parameters for each feature class; S406 converts the information describing parameterized features in the parameter configuration file into the corresponding USD Prim attributes according to the defined feature classes and their attribute parameter sets, and stores them in the USD asset.

[0041] It should be noted that the process of mapping parameters in parametric design data to geometric entities and encapsulating them into USD assets containing parametric feature information is mainly achieved through the following steps: In the scene description layer based on the USD format, feature classes are defined to describe parametric operations. Feature classes are typed abstractions of basic modeling operations in CAD design. For example, a UsdStretch class is defined to represent a stretching operation, a UsdArray class to represent an array operation, and a UsdOffset class to represent an offset operation. By defining these feature classes, a structured standard is provided for subsequent parametric information storage.

[0042] Secondly, create a corresponding attribute parameter set for each defined feature class. The attribute parameter set is used to precisely describe all the parameters required for the corresponding feature operation. For example, for the UsdStretch feature class, its attribute parameter set may include the stretch distance, stretch direction vector, and the index of the face on which it is based; for the UsdArray feature class, its attribute parameter set may include the number of arrays, array direction, and array spacing.

[0043] Finally, the transformation and storage of execution information are performed. Specifically, the parameter configuration file, such as a JSON file, obtained from the first application software is parsed to identify the parameterized feature information described therein. Then, based on the previously defined feature classes and their attribute parameter sets, the identified feature information is classified and matched, and converted into attributes that conform to the USD format specification and correspond to a specific USD Prim. For example, a stretching feature and its parameters described in the JSON are converted and stored as an attribute of type UsdStretch on the USD Prim and its related parameter values. Ultimately, all the transformed parameterized feature information is completely encapsulated within the USD asset.

[0044] Through the above methods, this embodiment of the disclosure achieves the standardized mapping and solidification of parametric design information from different sources and with inconsistent formats into a unified USD asset, laying a reliable data foundation for subsequent cross-platform parametric editing.

[0045] In some embodiments of this disclosure, such as Figure 5As shown, triggering the two-layer processing framework to perform geometric reconstruction and synchronization of the modified parameters also includes the following steps: S502, reads a predefined objective function from the properties of the USD asset; S504 uses the modified parameters as initial values ​​and employs a gradient-based optimization algorithm for iterative calculations to find the optimal parameter combination that satisfies the objective function.

[0046] It should be noted that this embodiment introduces geometric reconstruction and synchronization into an automated optimization process, making parameter modification no longer a simple manual adjustment, but an automatic optimization process aimed at a specific design goal. When a user modifies a parameter in the USD asset in the second application software, the two-layer processing framework can be triggered to execute the optimization process.

[0047] First, a predefined objective function is read from the specific properties of the USD asset. The predefined objective function is a mathematical expression of the design optimization, pre-defining the performance metric that needs to be maximized or minimized. For example, the objective function could be a function of the model volume, with the optimization objective being to minimize the volume while satisfying all constraints, thereby achieving a lightweight design.

[0048] Secondly, using the user-modified parameter values ​​as the starting point for optimization, a gradient-based optimization algorithm is employed for iterative calculation. In a preferred embodiment, the Adam (Adaptive Moment Estimation) optimizer can be used. This algorithm calculates the gradient of the objective function with respect to each parameter, which can be approximated using numerical differentiation methods, and updates the parameters by comprehensively considering the first and second moments of the gradient. The iterative calculation process continues until a set of parameter values ​​is found that optimizes the objective function, such as minimizing the volume, while also satisfying other geometric constraints.

[0049] This disclosure integrates optimization algorithms deeply into the parametric design process, realizing the transformation from manual trial and error to automatic optimization. It can automatically handle complex design problems with multiple variables and constraints, significantly improving design efficiency and quality, and enabling CAD systems to intelligently assist engineers in obtaining better design solutions.

[0050] In some embodiments of this disclosure, such as Figure 6 As shown, before triggering the two-layer processing framework to perform geometric reconstruction and synchronization of the modified parameters, the method also includes a constraint solving step: S602, construct a constraint dependency graph with parameters and geometric entities as nodes and the constraint relationships between parameters as edges; S604, perform topological sorting on the constraint dependency graph to determine the solution order and detect cyclic dependencies; S606, following the solution order, uses a numerical iterative algorithm to solve the constraint relationships and relaxes conflicting constraints.

[0051] It should be noted that this embodiment introduces a topology-sensitive constraint solving mechanism to ensure the geometric consistency and effectiveness of the model after parameter modification. When the user modifies the parameters, the two-layer processing framework will first execute this constraint solving process before triggering geometric reconstruction.

[0052] First, a constraint dependency graph is constructed. The constraint dependency graph uses parameters and geometric entities as nodes, and the constraint relationships between parameters as edges. The constraint dependency graph clearly represents the complex constraint network in the model, providing a foundation for subsequent solutions.

[0053] Secondly, a topological sort is performed on the constraint dependency graph. An algorithm determines the solution order of nodes, ensuring that when solving the constraint of a given node, the nodes it depends on have already been solved. Simultaneously, this process checks for cyclic dependencies (i.e., over-constraints) in the graph, which is a prerequisite for ensuring the solvability of constraints.

[0054] Finally, following the order determined by the topological sorting, numerical iterative algorithms, such as the Newton-Raphson method, are used to solve the constraint relationships. For constraints with conflicts, a relaxation mechanism is introduced to seek the optimal approximate solution by minimizing the sum of squares of constraint violations, ensuring that reasonable geometric results can still be obtained when constraints cannot be fully satisfied.

[0055] The embodiments disclosed herein can effectively handle complex geometric constraints and prevent model failure or geometric inconsistency problems caused by parameter modifications. The constraint solving method and the geometric reconstruction and synchronization of the two-layer processing framework in the embodiments of this disclosure form a complete intelligent parameter adjustment solution, which not only ensures the optimization of design objectives but also ensures the geometric validity of the model, significantly improving the reliability and intelligence level of parametric design.

[0056] In some embodiments of this disclosure, the geometric model file is a STEP format file; the parameter configuration file is a JSON format file; such as Figure 7 As shown, mapping parameters in parametric design data to geometric entities includes the following steps: S702, parses the JSON format file to obtain the feature tree information described therein; S704, extract the corresponding feature parameters from each feature node contained in the feature tree information; S706, establish the correspondence between the extracted feature parameters and the specific geometric entities parsed from the STEP format file by the OCCT geometric kernel.

[0057] It should be noted that this embodiment specifically defines the key steps for mapping parameters to geometric entities, ensuring that data from different sources can be accurately correlated. The geometric model file adopts the STEP format, which is a product data exchange standard developed by the International Organization for Standardization (ISO) and can completely transmit the boundary representation geometric information of the model. The parameter configuration file adopts the JSON format. JSON is a lightweight data exchange format with good readability and parsability, suitable for storing structured parameter information.

[0058] The parameter configuration file in JSON format is parsed to obtain the feature tree information described therein. The feature tree information records the model's construction history, including the various feature nodes that make up the model and their hierarchical relationships, such as their order and parent-child dependencies. From each feature node in the parsed feature tree information, the corresponding feature parameters are extracted. Each feature node represents a specific modeling operation; for example, the "Extrude 1" node might contain parameters such as extrusion distance and sketch plane orientation; the "Chamfer 1" node might contain parameters such as chamfer distance and chamfer edge. By extracting these parameters, the original inputs driving geometric changes are obtained. A correspondence is established between the extracted feature parameters and the specific geometric entities parsed from the STEP format file by the OCCT geometric kernel. This is the foundation for implementing parameter-driven modeling; for example, associating the "extrusion distance" parameter in the "Extrude 1" feature with the specific extrusion surface parsed by OCCT. This mapping relationship ensures that subsequent parameter modifications are accurately applied to the corresponding geometric entities.

[0059] The embodiments disclosed herein achieve accurate conversion from original design data to an operable parametric model, providing a precise data foundation for subsequent cross-platform parametric editing, ensuring that parameter modifications can be correctly mapped to the corresponding parts of the geometric model, and guaranteeing the accurate transmission of design intent.

[0060] In some embodiments of this disclosure, such as Figure 8 As shown, the two-layer processing framework uses an incremental update mechanism to synchronize modified parameters, including the following steps: S802, a two-layer processing framework determines the specific geometric components affected by parameter modifications; S804 only calls the OCCT geometry kernel to recalculate for the specific affected geometric components; S806 updates the changed geometric data and scene attributes to the USD asset after recalculation and notifies the second application software to perform a partial refresh.

[0061] It should be noted that this embodiment significantly improves the efficiency and response speed of model synchronization after parameter modifications by introducing an incremental update mechanism. When a user modifies parameters in the second application software, the two-layer processing framework does not regenerate the entire model, but intelligently analyzes the scope of the change's impact. The framework analyzes the specific geometric components affected by the parameter modification. By analyzing the dependencies between parameters and geometric entities, it accurately identifies the local areas that need updating. The framework only calls the OCCT geometric kernel to perform local recalculation for these affected specific geometric components. This avoids unnecessary global geometric reconstruction, greatly reducing computational load and time consumption. Finally, the framework updates the recalculated changed geometric data and corresponding scene attributes, such as position and display status, in the USD asset, and only notifies the second application software to perform local updates on the changed components.

[0062] Through the above-mentioned incremental update mechanism, the embodiments of this disclosure effectively solve the performance bottleneck problem faced by complex assembly models when modifying parameters, realize a near real-time interactive design experience, and significantly improve the efficiency and practicality of parametric design processing.

[0063] In some embodiments of this disclosure, Figure 9 A complete flowchart illustrating a cross-platform parametric design workflow implementation is provided. For example... Figure 9 As shown, this workflow begins with the original SolidWorks asset and, through the method of this invention, ultimately achieves scene construction and simulation. The following is a detailed explanation of each step in conjunction with the flowchart.

[0064] First, the SolidWorks assets are configured with parametric functionality. At this stage, operators add specific configuration tags to existing parametric features in the model (such as extrusions and rotations). These tags are used to identify and map features in subsequent processes. Simultaneously, the system generates a structured JSON configuration file based on the design intent. The JSON configuration file records the feature tree, equation variables, and reference relationships between features. To ensure the accuracy of entity references from SolidWorks geometric entities to subsequent geometric kernels, intermediate verification can be performed using open-source tools such as FreeCAD to ensure the correct connection of entity reference relationships in the JSON configuration.

[0065] Next, the workflow enters the data export stage, which involves exporting STEP assets and configuration JSON. The geometric information of the model is exported from SolidWorks to generate a standard STEP file; simultaneously, the parametric configuration prepared in the previous step is exported as a JSON file. The STEP file and the JSON file together constitute the parametric design data, which is then converted into USD parametric assets. This step corresponds to the core architecture in the claims, which involves inputting the parametric design data into a pre-built two-layer processing framework. This framework consists of two layers: 1. OCCT layer: As a geometry processing layer, it is responsible for parsing STEP files, performing accurate boundary representation (BREP) modeling, Boolean operations, and executing parametric geometric operations such as stretching, arraying, and offsetting.

[0066] 2. USD Layer: As a scene description layer, it defines feature classes for describing CAD parametric operations by extending its Schema, such as UsdStretch, UsdArray, UsdOffset, etc., and defines a corresponding set of attribute parameters for each feature class.

[0067] In this step, the system reads the JSON configuration file, transforms its parameterized feature information according to the defined USDSchema, and establishes a mapping relationship with specific geometric entities (such as faces and edges) parsed from the STEP file by the OCCT layer. Finally, all information is encapsulated into a self-contained USD asset (such as model.usda) containing complete parameterized feature attributes. This achieves lossless transmission of parameter information, embedding parameterized features into USD Prim attributes, laying the foundation for seamless cross-platform exchange.

[0068] After obtaining the USD parametric assets, the workflow enters the application and editing phase. Users can upload the assets to a shared or personal center for distribution and management. When editing the scene model, the system supports CAD-based assembly loading and utilizes functions such as CAD trajectory extraction to handle complex assembly relationships.

[0069] Users can perform operations such as parameterized transport line simulation configuration based on the CAD interface in second-party application software like Unity, directly modifying the parameters exposed in the USD assets. At this time, the intelligent kernel of this invention is triggered: on the one hand, parameter modification response and optimization algorithms are initiated. The system reads a predefined objective function from the USD assets, such as minimizing volume, and uses the user-modified value as the initial point. It then uses a gradient-based optimization algorithm (such as the Adam optimizer) for iterative calculation, automatically finding the optimal parameter combination that satisfies the objective function, improving design efficiency by 2-4 times. On the other hand, the topology-sensitive constraint solving algorithm runs synchronously. It constructs a constraint dependency graph of parameters and geometric entities, performs topology sorting and loop detection, and uses numerical iterative methods to solve constraint relationships, ensuring the geometric validity and topological consistency of the model after parameter changes. After optimization and solving are completed, the OCCT geometry layer only recalculates the affected components and uses an incremental update mechanism to synchronize to the USD assets, achieving efficient refreshing.

[0070] Finally, the edited and optimized model can be exported as a parametric Step asset (ensuring it can be correctly loaded by other tools such as FreeCAD), and ultimately used for scene building and simulation, completing the entire closed loop from design to simulation.

[0071] This disclosure combines the precise geometric calculations of OCCT with the scene description capabilities of USD to achieve intelligent parametric CAD design. By extending the OCCT parametric interface and USD storage representation, it supports automated configuration and optimization of operations such as stretching, arraying, and offsetting. Compared with existing technologies, this disclosure has the following advantages: lossless transmission of parameter information, embedding parametric features into USD Prim attributes to achieve seamless cross-platform (such as SolidWorks to Unity) exchange, avoiding parameter loss and improving interoperability by more than 30%; intelligent optimization and constraint solving, integrating gradient descent (Adam optimizer variant) and topological constraint algorithms to automatically solve for optimal parameter combinations and handle multi-constraint problems (including boundary constraints, geometric constraints, and topological consistency). This module automates parameter adjustment and constraint satisfaction, allowing the CAD system to shift from "passively responding to user input" to "intelligently solving for optimal design," improving design efficiency by 2-4 times; workflow integration, supporting SolidWorks parametric conversion, STEP model configuration, and Unity editing and export, automatically generating JSON configuration files and USD assets, and enabling assembly import, pose adjustment, and simulation collision following.

[0072] Specifically, this disclosure adopts a two-layer architecture: the OCCT layer handles geometric parametric operations (such as extrusion, arraying, and offsetting), and the USD layer stores the scene and parameter representations. The extended OCCT interface supports assembly import and saving, and the USD Schema defines parametric features. Intelligent parameter adjustment and constraint satisfaction are achieved through gradient optimization and topology constraint solving algorithms. The entire workflow is integrated into SolidWorks conversion and Unity editing. Detailed steps include the following: 1. Establish a two-layer data structure. The OCCT layer is responsible for BREP representation and precise calculations (such as Boolean operations and face stretching), while the USD layer manages scene hierarchy and attribute storage. Define a custom USD schema, including UsdStretch, UsdArray, and UsdOffset, with attributes including paramName, directionVec, and face index.

[0073] 2. Parametric Feature Storage and Conversion. Parametric feature information is stored in custom attributes of the USD Prim (e.g., fs:inputs:*). For SolidWorks models, equation variables are configured, and the corresponding feature trees are converted into JSON file format, including name, componentType (UsdOffset / UsdStretch), and Sparameter. The model file is described by Step, and the JSON configuration maps to entity names in OCCT. A converter is then used to convert Step+JSON to model.usda, ultimately obtaining the CAD asset described in USD.

[0074] 3. Parameter Modification Response and Optimization Algorithm. When a user modifies parameters, features are read from USD, the OCCT interface is called to recalculate geometry, and validity is verified (degeneration and self-intersection are detected). Gradient-based optimization is integrated, defining an objective function (e.g., minimizing material usage), using the Adam optimizer (learning rate 0.01, β1=0.9, β2=0.999), calculating the gradient using numerical differentiation, and iteratively updating USD parameters in conjunction with boundary constraints. The core of this part is the parameter modification response mechanism and the gradient-based parameter optimization algorithm. The parameter modification response is event-driven, and the gradient-based parameter optimization algorithm uses a variant of Adam, automatically iteratively solving for optimal value combinations in a continuous parameter space, supporting equality / inequality constraints (e.g., parameter boundaries, geometric validity). Gradient descent provides a global direction, integrating with subsequent constraint solutions to form a closed loop.

[0075] Detailed steps of gradient-based parameterized optimization algorithm: Define the objective function and constraints (extracted from USD Prim attributes, e.g., objective function f(params) = height * width * depth, minimizing volume); Initialization parameters (initial USD value); Calculate the gradient (numerical differentiation, avoiding the complexity of symbolic differentiation); Iterative update: The parameters are adjusted using the Adam formula, and the adaptive learning rate is combined with first / second moment estimation to improve the convergence speed; Verify by calling OCCT to check geometry (BRepCheck_Analyzer detects self-intersections) and updating USD.

[0076] 4. Solving Topology-Sensitive Constraints. Construct a constraint dependency graph (nodes = parameters, edges = constraints such as coincidence, parallelism), and perform topological sorting (DFS algorithm to detect loops). Use constraint propagation and backtracking strategies to solve the problem and relax conflicts. Utilize OCCT topology information (such as the TopTools package) to guide the solution, improving efficiency by 50%. The topology constraint algorithm ensures local feasibility and is integrated with parameter optimization to form a closed loop.

[0077] Detailed steps of the algorithm for solving topology-sensitive constraints: Construct a parameter constraint dependency graph G = {N, E}, where nodes include parameters and geometric entities (extracted from OCCT BREP), and edges represent constraint relationships (containing weights w and transformation matrices M). Topological sorting and decomposition: Using DFS to sort the graph, detecting cycles (Tarjan's algorithm to extract SCCs), and decomposing subgraphs; Constraint propagation and iterative solution: Propagate values ​​sequentially, use Newton-Raphson iteration for nonlinear constraints; backtrack conflict branches; Relaxation treatment: For over-constraints, introduce a relaxation variable s, optimize min ∑ w * s^2, and solve using Adam; Geometric verification and USD update: OCCT verifies self-intersection and updates USD Prim properties.

[0078] 5. Workflow Integration. Supports importing CAD assemblies (OCCT pose information), configuring parametric scripts (CadParamVariable) in Unity editing mode, and exporting USD+CAD assets. For specific scenarios, it adds global variable control and asynchronous event management, integrating with simulation; incremental updates only recalculate affected parts; adaptive mesh refinement adjusts density based on curvature and sensitivity.

[0079] The end result is that the model parametric functionality achievable in SolidWorks workflows can be perfectly implemented in industrial software and fully automated.

[0080] Based on the same inventive concept, this disclosure also provides a cross-platform parametric design apparatus, as described in the following embodiments. Since the principle by which this apparatus solves the problem is similar to that of the method embodiments described above, the implementation of this apparatus embodiment can refer to the implementation of the method embodiments described above, and repeated details will not be elaborated further.

[0081] Figure 10 This illustration shows a schematic diagram of a cross-platform parametric design apparatus according to an embodiment of the present disclosure, such as... Figure 10 As shown, the device includes: The data acquisition module 1001 is used to acquire parametric design data from the first application software, wherein the parametric design data includes a geometric model file generated by the first application software and a corresponding parameter configuration file. The data input module 1002 is used to input the parametric design data into a pre-built two-layer processing framework. The two-layer processing framework includes a geometry processing layer based on the OCCT geometry kernel and a scene description layer based on the USD format. The two-layer processing framework is used to map the parameters in the parametric design data to geometric entities and encapsulate them into USD assets containing parametric feature information. Data output module 1003: outputs the USD asset to the second application software, so that the second application software can modify the parameters based on the parameterized feature information in the USD asset, and triggers the two-layer processing framework to perform geometric reconstruction and synchronization of the modified parameters.

[0082] It should be noted that the examples and application scenarios implemented by the above modules and corresponding steps are the same, but are not limited to the content disclosed in the above method embodiments. It should also be noted that the above modules, as part of an apparatus, can be executed in a computer system such as a set of computer-executable instructions.

[0083] Those skilled in the art will understand that various aspects of this disclosure can be implemented as a system, method, or program product. Therefore, various aspects of this disclosure can be specifically implemented in the following forms: a completely hardware implementation, a completely software implementation (including firmware, microcode, etc.), or a combination of hardware and software aspects, collectively referred to herein as a "circuit," "module," or "system."

[0084] The following reference Figure 11 To describe an electronic device 1100 according to such an embodiment of the present disclosure. Figure 11 The electronic device 1100 shown is merely an example and should not impose any limitation on the functionality and scope of use of the embodiments disclosed herein.

[0085] like Figure 11As shown, the electronic device 1100 is manifested in the form of a general-purpose computing device. The components of the electronic device 1100 may include, but are not limited to: at least one processing unit 1110, at least one storage unit 1120, and a bus 1130 connecting different system components (including storage unit 1120 and processing unit 1110).

[0086] The storage unit stores program code that can be executed by the processing unit 1110, causing the processing unit 1110 to perform the steps described in the "Exemplary Methods" section of this specification according to various exemplary embodiments of this disclosure. For example, the processing unit 1110 can perform the following steps of the above method embodiment: acquiring parametric design data from a first application software, the parametric design data including a geometric model file generated by the first application software and a corresponding parameter configuration file; inputting the parametric design data into a pre-built two-layer processing framework, the two-layer processing framework including a geometry processing layer based on an OCCT geometry kernel and a scene description layer based on a USD format, the two-layer processing framework being used to map the parameters in the parametric design data to geometric entities and encapsulate them into USD assets containing parametric feature information; outputting the USD assets to a second application software, so that the second application software can modify the parameters based on the parametric feature information in the USD assets and trigger the two-layer processing framework to perform geometric reconstruction and synchronization of the modified parameters.

[0087] Storage unit 1120 may include readable media in the form of volatile storage units, such as random access memory (RAM) 11201 and / or cache memory 11202, and may further include read-only memory (ROM) 11203.

[0088] Storage unit 1120 may also include a program / utility 11204 having a set (at least one) program module 11205, such program module 11205 including but not limited to: operating system, one or more application programs, other program modules and program data, each or some combination of these examples may include an implementation of a network environment.

[0089] Bus 1130 can represent one or more of several types of bus structures, including a memory cell bus or memory cell controller, a peripheral bus, a graphics acceleration port, a processing unit, or a local bus using any of the various bus structures.

[0090] Electronic device 1100 can also communicate with one or more external devices 1140 (e.g., keyboard, pointing device, Bluetooth device, etc.), and with one or more devices that enable a user to interact with electronic device 1100, and / or with any device that enables electronic device 1100 to communicate with one or more other computing devices (e.g., router, modem, etc.). This communication can be performed via input / output (I / O) interface 1150. Furthermore, electronic device 1100 can also communicate with one or more networks (e.g., local area network (LAN), wide area network (WAN), and / or public networks, such as the Internet) via network adapter 1160. As shown, network adapter 1160 communicates with other modules of electronic device 1100 via bus 1130. It should be understood that, although not shown in the figures, other hardware and / or software modules can be used in conjunction with electronic device 1100, including but not limited to: microcode, device drivers, redundant processing units, external disk drive arrays, RAID systems, tape drives, and data backup storage systems.

[0091] From the above description of the embodiments, those skilled in the art will readily understand that the exemplary embodiments described herein can be implemented by software or by combining software with necessary hardware. Therefore, the technical solutions according to the embodiments of this disclosure can be embodied in the form of a software product, which can be stored in a non-volatile storage medium (such as a CD-ROM, USB flash drive, external hard drive, etc.) or on a network, including several instructions to cause a computing device (such as a personal computer, server, terminal device, or network device, etc.) to execute the methods according to the embodiments of this disclosure.

[0092] In particular, according to embodiments of this disclosure, the process described above with reference to the flowchart can be implemented as a computer program product, which includes a computer program that, when executed by a processor, implements the methods described in the above embodiments.

[0093] In exemplary embodiments of this disclosure, a computer-readable storage medium is also provided, which may be a readable signal medium or a readable storage medium. A program product capable of implementing the methods described above is stored thereon. In some possible implementations, various aspects of this disclosure may also be implemented as a program product including program code, which, when run on a terminal device, causes the terminal device to perform the steps described in the "Exemplary Methods" section of this specification according to various exemplary embodiments of this disclosure.

[0094] More specific examples of computer-readable storage media in this disclosure may include, but are not limited to: electrical connections having one or more wires, portable computer disks, hard disks, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM or flash memory), optical fiber, portable compact disk read-only memory (CD-ROM), optical storage devices, magnetic storage devices, or any suitable combination of the foregoing.

[0095] In this disclosure, a computer-readable storage medium may include a data signal propagated in baseband or as part of a carrier wave, carrying readable program code. Such propagated data signals may take various forms, including but not limited to electromagnetic signals, optical signals, or any suitable combination thereof. A readable signal medium may also be any readable medium other than a readable storage medium, capable of transmitting, propagating, or transmitting a program for use by or in connection with an instruction execution system, apparatus, or device.

[0096] Optionally, the program code contained on the computer-readable storage medium may be transmitted using any suitable medium, including but not limited to wireless, wired, optical fiber, RF, etc., or any suitable combination thereof.

[0097] In practical implementation, program code for performing the operations of this disclosure can be written in any combination of one or more programming languages, including object-oriented programming languages ​​such as Java and C++, and conventional procedural programming languages ​​such as C or similar languages. The program code can execute entirely on the user's computing device, partially on the user's device, as a standalone software package, partially on the user's computing device and partially on a remote computing device, or entirely on a remote computing device or server. In cases involving remote computing devices, the remote computing device can be connected to the user's computing device via any type of network, including a local area network (LAN) or a wide area network (WAN), or it can be connected to an external computing device (e.g., via the Internet using an Internet service provider).

[0098] It should be noted that although several modules or units for the device used to perform actions have been mentioned in the detailed description above, this division is not mandatory. In fact, according to embodiments of this disclosure, the features and functions of two or more modules or units described above can be embodied in one module or unit. Conversely, the features and functions of one module or unit described above can be further divided and embodied by multiple modules or units.

[0099] Furthermore, although the steps of the method in this disclosure are described in a specific order in the accompanying drawings, this does not require or imply that the steps must be performed in that specific order, or that all the steps shown must be performed to achieve the desired result. Additional or alternative steps may be omitted, multiple steps may be combined into one step, and / or a step may be broken down into multiple steps.

[0100] From the above description of the embodiments, those skilled in the art will readily understand that the exemplary embodiments described herein can be implemented by software or by combining software with necessary hardware. Therefore, the technical solutions according to the embodiments of this disclosure can be embodied in the form of a software product, which can be stored in a non-volatile storage medium (such as a CD-ROM, USB flash drive, external hard drive, etc.) or on a network, including several instructions to cause a computing device (such as a personal computer, server, mobile terminal, or network device, etc.) to execute the methods according to the embodiments of this disclosure.

[0101] Other embodiments of this disclosure will readily occur to those skilled in the art upon consideration of the specification and practice of the invention disclosed herein. This disclosure is intended to cover any variations, uses, or adaptations of this disclosure that follow the general principles of this disclosure and include common knowledge or customary techniques in the art not disclosed herein. The specification and examples are to be considered exemplary only, and the true scope and spirit of this disclosure are indicated by the appended claims.

Claims

1. A cross-platform parametric design method, characterized in that, include: Obtain parametric design data from the first application software, wherein the parametric design data includes a geometric model file generated by the first application software and a corresponding parameter configuration file; The parametric design data is input into a pre-built two-layer processing framework, which includes a geometry processing layer based on the OCCT geometry kernel and a scene description layer based on the USD format. The two-layer processing framework is used to map the parameters in the parametric design data to geometric entities and encapsulate them into USD assets containing parametric feature information. The USD asset is output to the second application software, so that the second application software can modify the parameters based on the parameterized feature information in the USD asset, and trigger the two-layer processing framework to perform geometric reconstruction and synchronization of the modified parameters.

2. The cross-platform parametric design method according to claim 1, characterized in that, The parameters in the parametric design data are mapped to geometric entities and encapsulated into USD assets containing parametric feature information, including: In the scene description layer, feature classes are defined to describe parameterized operations, including stretching, arraying, and offsetting. Define a corresponding set of attribute parameters for each feature class; The information describing the parameterized features in the parameter configuration file is converted into the corresponding USD Prim attributes according to the defined feature classes and their attribute parameter sets, and stored in the USD asset.

3. The cross-platform parametric design method according to claim 1, characterized in that, Triggering the two-layer processing framework to perform geometric reconstruction and synchronization of the modified parameters includes: Read the predefined objective function from the properties of the USD asset; Using the modified parameters as initial values, a gradient-based optimization algorithm is used for iterative calculations to find the optimal combination of parameters that satisfies the objective function.

4. The cross-platform parametric design method according to claim 3, characterized in that, Before triggering the two-layer processing framework to perform geometric reconstruction and synchronization of the modified parameters, the method further includes: Construct a constraint dependency graph with parameters and geometric entities as nodes and the constraint relationships between parameters as edges; The constraint dependency graph is topologically sorted to determine the solution order and detect cyclic dependencies; The constraint relationships are solved using a numerical iterative algorithm according to the solution order, and conflicting constraints are relaxed.

5. The cross-platform parametric design method according to claim 1, characterized in that, The geometric model file is a STEP format file; The parameter configuration file is a JSON format file; Mapping the parameters in the parametric design data to geometric entities includes: Parse the JSON format file to obtain the feature tree information described therein; Extract the corresponding feature parameters from each feature node contained in the feature tree information; Establish the correspondence between the extracted feature parameters and the specific geometric entities parsed by the OCCT geometric kernel from the STEP format file.

6. The cross-platform parametric design method according to claim 1, characterized in that, The two-layer processing framework uses an incremental update mechanism to synchronize modified parameters, including: The two-layer processing framework determines the specific geometric components affected by the parameter modification; The OCCT geometry kernel is invoked only for the specific affected geometric components to be recalculated. The recalculated geometric data and scene attributes that have changed are updated to the USD asset, and the second application software is notified to perform a partial refresh.

7. A cross-platform parametric design device, characterized in that, include: The data acquisition module is used to acquire parametric design data from the first application software, wherein the parametric design data includes a geometric model file generated by the first application software and a corresponding parameter configuration file; The data input module is used to input the parametric design data into a pre-built two-layer processing framework. The two-layer processing framework includes a geometry processing layer based on the OCCT geometry kernel and a scene description layer based on the USD format. The two-layer processing framework is used to map the parameters in the parametric design data to geometric entities and encapsulate them into USD assets containing parametric feature information. Data output module; The USD asset is output to the second application software, so that the second application software can modify the parameters based on the parameterized feature information in the USD asset, and trigger the two-layer processing framework to perform geometric reconstruction and synchronization of the modified parameters.

8. An electronic device, characterized in that, include: processor; as well as Memory for storing the executable instructions of the processor; The processor is configured to execute the cross-platform parametric design method according to any one of claims 1 to 6 by executing the executable instructions.

9. A computer-readable storage medium having a computer program stored thereon, characterized in that, When the computer program is executed by the processor, it implements the cross-platform parametric design method according to any one of claims 1 to 6.

10. A computer program product comprising: A computer program or instruction, characterized in that, when executed by a processor, the computer program or instruction implements the cross-platform parametric design method according to any one of claims 1 to 6.

Images