A CAD system adaptable to multiple modeling engines and its implementation method

Abstract

The present disclosure provides a CAD system and implementation method that is adaptable to multiple modeling engines, the system comprising: a modeling tool module and at least two modeling implementation modules; the modeling tool module is used to determine a target modeling implementation module based on a selected target modeling engine; a modeling interface is called to receive a target modeling method call request and input data inputted by a CAD front end, and dispatch the request to the target modeling implementation module; the modeling implementation module is used to call an adaptive modeling engine API in a method of the same name that implements the target modeling method, receive input data in the form of a data interface transmitted by the modeling tool module, convert the input data into data executable by the adaptive modeling engine, and use the converted data executable by the adaptive modeling engine to perform modeling operations; the module is also used to obtain output data of the adaptive modeling engine after execution, convert the output data of the adaptive modeling engine into the form of a data interface, and return the data to the modeling tool module, thereby achieving decoupling of the CAD system from the modeling engine.

Description

Technical Field

[0001] The present disclosure relates to the field of software design, and in particular to a CAD system adaptable to multiple modeling engines and an implementation method thereof. Background Art

[0002] CAD (Computer Aided Design) uses computers and graphics equipment to assist designers in their design work. A core component of a CAD system is the modeling engine. This engine processes geometric data related to three-dimensional objects, including the creation, modification, analysis, and display of 3D shapes. Currently, a number of self-developed modeling engines have emerged in the development of industrial software. However, due to their late development and recent launch, they still lag behind decades-old modeling engines in maturity.

[0003] Currently, most CAD software is designed with a specific modeling engine in mind, and typically doesn't support runtime engine changes. This results in a tight coupling between the application layer and the modeling engine, leading to the following technical issues: 1) inability to flexibly switch or replace the modeling engine; 2) difficulty in cross-engine compatibility testing and expansion; and 3) dependency on specific commercial engines, which, if restricted by the engine's licensing, can severely impact the software's functional integrity.

[0004] Therefore, how to achieve the separation of the modeling engine and the CAD front-end logic, support the rapid switching and integration of different modeling engines, and take into account the technical autonomy and engineering stability of CAD software is an urgent problem that needs to be solved. Summary of the Invention

[0005] The present disclosure provides a CAD system and implementation method that adapts to multiple modeling engines, thereby achieving code decoupling between the CAD system and the modeling engines, so that the CAD system can switch between multiple modeling engines.

[0006] In a first aspect, the present disclosure provides a CAD system adapted to multiple modeling engines, comprising:

[0007] A modeling tool module (101) and at least two modeling implementation modules (102, 102');

[0008] The modeling tool module (101) is used to determine the target modeling implementation module (102, 102') based on the selected target modeling engine; call the modeling interface to receive the target modeling method call request and input data inputted from the CAD front end, forward it to the method of the same name that implements the target modeling method in the target modeling implementation module (102, 102'), and pass the input data to the target modeling implementation module through the data interface;

[0009] The modeling implementation module (102, 102') is used to call the adaptive modeling engine API in the method of the same name that implements the target modeling method, receive input data in the form of a data interface transmitted by the modeling tool module 101, convert the input data into data executable by the adaptive modeling engine, and use the converted data executable by the adaptive modeling engine to perform modeling operations; it is also used to obtain output data of the adaptive modeling engine after execution, convert the output data of the adaptive modeling engine into the form of a data interface, and return it to the modeling tool module (101).

[0010] In some embodiments, it also includes: each modeling implementation module (102, 102') includes a data wrapper class inherited from the data interface, and the input data is forwarded to the modeling implementation module through the modeling tool module in the form of a data interface, and the modeling implementation module is responsible for converting it into a data wrapper class, which is used to encapsulate data executable by the modeling engine and output data of the modeling engine.

[0011] In some embodiments, it also includes: the data executable by the adaptive modeling engine and the output data of the adaptive modeling engine both use handle type data, and the handle type data is used to point to geometric entity data.

[0012] In some embodiments, it also includes: only one pure virtual method for obtaining data identification is defined inside the data interface, and the return value of this method is used as the unique identification of the input data, as the basis for sorting and determining the same entity.

[0013] In some embodiments, the system further comprises a unit testing module (104) for transmitting a preset test request to the modeling tool module (101) after selecting a target modeling engine; wherein the test request comprises a target modeling method call request and input data;

[0014] The test operation monitoring module (105) is used to monitor the process of the system executing the preset test request and obtain the test result.

[0015] In some embodiments, the system further includes a modeling engine comparison module (106) for obtaining and recording the execution status and output results of each modeling engine when executing the same preset test request, evaluating the execution status and output results of each modeling engine according to multiple evaluation dimensions, generating a comparison analysis report and sending it to the visualization display module (107), and generating model results of each modeling engine executing the same preset test request, and sending the model results to the visualization display module (107) in the form of a comparative display;

[0016] The evaluation dimensions include at least one or more of geometric accuracy, mesh quality, topological structure integrity, attribute retention, execution efficiency and stability.

[0017] The visualization display module (107) is used to display the comparison analysis report and the model comparison visualization results for users to perform intuitive comparison analysis.

[0018] In a second aspect, the present disclosure further provides a method for implementing a CAD system that is adaptable to multiple modeling engines, the method being used to execute the CAD system that is adaptable to multiple modeling engines, comprising:

[0019] Through the modeling tool module (101), based on the selected target modeling engine, a target modeling implementation module (102, 102') is determined; a modeling interface is called to receive a target modeling method call request and input data inputted from the CAD front end, and forwarded to a method of the same name that implements the target modeling method in the target modeling implementation module (102, 102'), and the input data is transferred to the target modeling implementation module through the data interface;

[0020] Through the modeling implementation module (102, 102'), the adaptive modeling engine API is called in the method of the same name that implements the target modeling method, input data in the form of a data interface transmitted by the modeling tool module (101) is received, the input data is converted into data executable by the adaptive modeling engine, and the modeling operation is performed using the converted data executable by the adaptive modeling engine; and after the execution, the adaptive modeling engine output data is obtained, the adaptive modeling engine output data is converted into the form of a data interface, and returned to the modeling tool module (101).

[0021] In some embodiments, the method further comprises:

[0022] After selecting a target modeling engine, the unit testing module (104) transmits a preset test request to the modeling tool module (101);

[0023] The test operation monitoring module (105) monitors the process of the system executing the preset test request and obtains the test result.

[0024] In some embodiments, the method further comprises:

[0025] Obtain and record the execution status and output results of each modeling engine when executing the same preset test request through the modeling engine comparison module (106), evaluate the execution status and output results of each modeling engine according to multiple evaluation dimensions, generate a comparison analysis report and send it to the visualization display module 107, and generate model results of each modeling engine executing the same preset test request, and send the model results to the visualization display module (107) in the form of comparative display;

[0026] The comparison analysis report and the model comparison visualization results are displayed through the visualization display module (107) for users to conduct intuitive comparison analysis.

[0027] In a third aspect, the present disclosure provides an electronic device, comprising: a processor, and a memory communicatively connected to the processor;

[0028] Memory stores computer-executable instructions;

[0029] The processor executes the computer-executable instructions stored in the memory to implement the method of the present disclosure.

[0030] In a fourth aspect, the present disclosure provides a computer-readable storage medium, in which computer-executable instructions are stored. When the computer-executable instructions are executed by a processor, they are used to implement the method of the present disclosure.

[0031] The beneficial effects of the present disclosure are that, compared with the prior art, the present disclosure has the following advantages:

[0032] 1) This paper proposes a design approach that decouples the CAD system from the modeling engine code. By introducing a unified modeling interface, IModelingGlobal, and a data interface, ITag, a standardized cross-engine modeling interface system is constructed, decoupling the CAD system front-end from the back-end modeling engine. This architecture supports flexible switching and expansion of multiple modeling engines (both domestically developed and imported), avoiding over-reliance on a single engine. The system supports switching and dynamic loading of multiple modeling engines, enabling compatible calls of the same front-end instructions executed on different engines, meeting the engineering requirements of switching between multi-source modeling kernels.

[0033] 2) By defining a lightweight data interface, ITag, and employing a "boxing-unboxing" mechanism to encapsulate and unpack data, we minimize the transmission cost of input and output data between the CAD system and the modeling engine. Each modeling task requires only a single interface conversion to complete the entire data flow, significantly reducing performance losses and ensuring efficient and real-time modeling.

[0034] 3) To address the potential issues arising from the use of multiple modeling engines, a unit testing module and a test run monitoring module have been introduced to support the automated batch construction of modeling instructions and input data, enabling compatible calls of the same front-end test instructions executed on different engines. This fully covers the modeling function interface, enabling continuous verification of modeling logic, fault location, and regression verification, thereby improving overall system stability and quality controllability.

[0035] 4) The modeling engine comparison module can analyze and evaluate the modeling execution and output results of multiple modeling engines under the same input data, and supports the generation of comparison analysis reports from multiple dimensions such as geometric accuracy, topological integrity, attribute retention, execution efficiency and stability. The model results of each modeling engine executing the same preset test request are sent to the visualization display module in the form of a comparative display. Engineering personnel can combine the comparison analysis report and the model comparison visualization results to comprehensively judge the advantages and disadvantages of each engine in terms of modeling accuracy, stability and performance. This assists engineering personnel in completing the selection evaluation of the modeling engine and the adaptation decision of the optimal engine, and provides data support and decision-making basis for the subsequent modeling engine selection of the CAD system. BRIEF DESCRIPTION OF THE DRAWINGS

[0036] The accompanying drawings, which are incorporated in and constitute a part of this specification, illustrate embodiments consistent with the present disclosure and, together with the description, serve to explain the principles of the present disclosure.

[0037] Figure 1 A schematic diagram of the CAD system structure adapted to multiple modeling engines provided in an embodiment of the present disclosure;

[0038] Figure 2-Figure 5 A diagram showing a list of modeling interface method types included in the IModelingGlobal interface provided in an embodiment of the present disclosure;

[0039] Figure 6 A schematic diagram of the drawing results using an imported engine in a CAD system developed based on the present disclosure provided in an embodiment of the present disclosure;

[0040] Figure 7 A schematic diagram of the drawing results using a self-developed engine in a CAD system developed based on the present disclosure provided in an embodiment of the present disclosure;

[0041] The above drawings illustrate specific embodiments of the present disclosure, which will be described in more detail below. These drawings and textual descriptions are not intended to limit the scope of the present disclosure in any way, but rather to illustrate the concepts of the present disclosure to those skilled in the art by reference to specific embodiments. DETAILED DESCRIPTION

[0042] The present disclosure is further described below in conjunction with the accompanying drawings. The following embodiments are only used to more clearly illustrate the technical solutions of the present disclosure and are not intended to limit the scope of protection of the present disclosure.

[0043] It should be noted that the order of the steps in the present disclosure is only for illustrative purposes. During actual implementation, the order can be adjusted as needed, or some steps can be executed in parallel. Unless the execution of a certain step is clearly dependent on the result of the previous step, the order between the steps does not constitute a limitation on the present disclosure.

[0044] Example 1

[0045] like Figure 1 As shown, this embodiment provides a CAD system 100 that is adaptable to multiple modeling engines, including: a modeling tool module 101 and at least two modeling implementation modules (102, 102').

[0046] The modeling tool module 101 is used to determine the target modeling implementation module (102, 102') based on the selected target modeling engine; call the modeling interface to receive the target modeling method call request and input data inputted from the CAD front end, forward it to the method of the same name that implements the target modeling method in the target modeling implementation module (102, 102'), and pass the input data to the target modeling implementation module through the data interface;

[0047] In the specific implementation, the modeling interface is the IModelingGlobal interface, which is used to provide a set of minimum modeling methods required by CAD software. It only provides definitions and declarations, and does not provide method implementations.

[0048] The IModelingGlobal interface includes but is not limited to:

[0049] 1) Query methods, for example, obtaining all topological faces, edges, and vertices of a topological body;

[0050] 2) Creation methods, for example, creating a straight line topology body (Body), an arc topology body (Body), or a B-spline curve topology body (Body);

[0051] 3) Computational methods, for example, calculating the center of mass, length, and area of ​​a topological body;

[0052] 4) Serialization methods, for example, serializing a topology body (Body) and deserializing a topology body (Body);

[0053] 5) Meshing methods, such as meshing topological bodies, topological faces, and topological edges;

[0054] 6) Operation methods, such as Boolean operations between topological bodies, seam topological bodies, chamfering, stretching, sweeping, lofting, and imprinting.

[0055] like Figure 2-Figure 5 As shown, the modeling method types included in the IModelingGlobal interface are exemplarily shown.

[0056] The data interface is the ITag interface, which is used to transfer data and does not include implementation.

[0057] In one embodiment, the modeling tool module 101 includes a ModelingGlobal class, which includes an instance of a target modeling implementation module. The ModelingGlobal class specifically implements the following functions: it is responsible for creating an instance of the target modeling implementation module based on the selected target modeling engine, and the instance calls the IModelingGlobal interface to receive the IModelingGlobal modeling method call request and input data passed in by the CAD front end, forwards it to the method with the same name as the IModelingGlobal modeling method in the target modeling implementation module (102, 102'), and passes the input data to the target modeling implementation module through the ITag data interface.

[0058] A modeling implementation module (102, 102') is used to call the adaptive modeling engine API in the method of the same name that implements the target modeling method, receive input data in the form of a data interface transmitted by the modeling tool module 101, convert the input data into data executable by the adaptive modeling engine, and use the converted data executable by the adaptive modeling engine to perform modeling operations;

[0059] The modeling implementation module (102, 102') is further used to obtain the output data of the adaptive modeling engine after execution, convert the output data of the adaptive modeling engine into the form of a data interface, and return it to the modeling tool module 101.

[0060] It is understandable that the modeling tool module 101 can further return the received modeling results in the form of a data interface to the CAD system front end, and complete the graphics drawing and result display.

[0061] Each modeling implementation module (102, 102') is connected to a specific modeling engine. Common modeling engines include imported engines such as Parasolid, Open CASCADE, ACIS, etc., as well as self-developed engines such as Glodon and Jiushao.

[0062] In some embodiments, each modeling implementation module (102, 102') includes an interface implementation class that inherits from the IModelingGlobal interface and implements all modeling methods in the IModelingGlobal interface. The modeling methods in the interface implementation class can call the corresponding modeling engine API of the modeling implementation module to perform modeling operations. In other words, the class in the modeling implementation module specifically implements the interface functions in the modeling tool module.

[0063] In some embodiments, each modeling implementation module (102, 102') includes a data wrapper class (Tag class) inherited from a data interface (ITag interface). Input data is forwarded to the modeling implementation module via the modeling tool module in the form of the data interface. The modeling implementation module is responsible for converting the data wrapper class into a data wrapper class. The data wrapper class is used to encapsulate data executable by the modeling engine and output data of the modeling engine.

[0064] Among them, the data packaging class is used to encapsulate the data executable by the adaptive modeling engine and receive the output data of the adaptive modeling engine. Subsequently, the modeling implementation module returns the data packaging class to the modeling tool module in the form of a data interface.

[0065] Optionally, both the executable data and the output data of the adaptive modeling engine are in the form of handle type data, and operations calling the adaptive modeling engine API all specify the operation target through the handle type data, wherein the handle type data is used to point to or identify geometric entity data.

[0066] In the specific implementation, the Parasolid modeling engine is taken as an example to illustrate how the system transmits data: the modeling implementation module includes a ParasolidTag class that inherits from the ITag interface. The ParasolidTag class has an m_entity member of the handle type PK_ENTITY_t, which is used to identify the geometric entity data (such as body / surface / line / point) required by the Parasolid modeling engine;

[0067] When data is passed in, it is forwarded to the modeling implementation module through the modeling tool module in the form of ITag interface. The modeling implementation module is responsible for converting it into the ParasolidTag class and obtaining the m_entity member data, that is, the data that can be executed by the modeling engine;

[0068] When outputting data, the modeling implementation module stores the output PK_ENTITY_t handle data obtained from the Parasolid modeling engine into the m_entity member of the ParasolidTag class, and then outputs it to the modeling tool module in the form of an ITag interface, and then forwards it to the CAD system front end.

[0069] In this embodiment, the modeling interface IModelingGlobal and the data interface ITag in the modeling tool module are inherited and implemented by each modeling implementation module to adapt to the calling mechanisms and core capabilities of different modeling engines. In other words, the system uses the modeling tool module's interfaces to access the modeling implementation module, making it "plug-in-like" and decoupling the code between the CAD system front-end and the back-end modeling engine. Furthermore, the system supports switching and dynamic loading between multiple modeling engines, enabling compatible calls of the same front-end instructions executed on different engines, meeting the engineering requirements of multi-source modeling kernel switching.

[0070] In addition, by defining a lightweight data interface ITag, during the modeling call process, the system only needs to perform one encapsulation (boxing) and one parsing (unboxing) operation for input and output data to complete the two-way transmission from front-end parameters to engine data structure, effectively reducing the performance overhead in the data conversion process and improving the system operation efficiency and stability.

[0071] In some embodiments, only one pure virtual method for obtaining a data identifier is defined within the data interface. The return value of this method serves as a unique identifier for the input data and as a basis for sorting and determining whether the data is the same entity.

[0072] Specifically, the ITag interface provides a unified data encapsulation structure for all data objects in the system. It only defines a pure virtual method GetCode(), which returns an integer value as the unique identifier of the input data and the basis for sorting and determining the same entity.

[0073] In this embodiment, the data wrapper class is also used to implement the pure virtual method when inheriting the data interface to return the unique identifier of the input data and to be used for sorting and equal value judgment of data objects.

[0074] It is understandable that since the ITag interface only defines one pure virtual method GetCode(), the data packaging class (i.e., the Tag class) in each modeling implementation module needs to implement the GetCode() method when inheriting the ITag interface to return the unique identifier of the input data, which is used for sorting and equivalence judgment of data objects.

[0075] In the CAD front-end user interface, it is generally necessary to display a list of geometric entities such as faces, edges, and vertices. Through the integer value returned by GetCode(), these entities can be quickly sorted according to the creation order, topological hierarchy or user-set priority, thereby improving the interface response speed and user operation efficiency; during the geometric calculation or assembly verification process, the system can quickly determine whether two objects represent the same geometric entity by comparing the GetCode() return values ​​of different data objects, so as to support key modeling functions such as Boolean operations, duplicate detection, and entity reference verification.

[0076] It can be seen that by adopting a minimized method design in the ITag interface and retaining only the GetCode() method, the needs of unique identification and efficient comparison of data objects are met, the complexity of the interface is reduced, and the maintainability and scalability of the system are improved.

[0077] In some embodiments, the system further includes: a modeling interface definition module 103 for defining a modeling interface and a data interface.

[0078] In this embodiment, the modeling tool module 101 relies on the modeling interface and data interface definitions in the modeling interface definition module 103 .

[0079] Example 2

[0080] Based on the system described in Example 1, this embodiment further includes the following unit modules:

[0081] The unit testing module 104 is used to transmit a preset test request to the modeling tool module 101 after selecting the target modeling engine. The test request includes a target modeling method call request and input data.

[0082] The unit testing module 104 performs functional verification on the methods in the ModelingGlobal class, specifically including writing test cases based on the IModelingGlobal interface methods and ITag interface data formats.

[0083] That is to say, the target modeling method call request and input data in the embodiment of the present disclosure can also be generated by the system's built-in unit testing module 104 to verify whether the implementation of each modeling engine meets expectations, thereby ensuring the correctness and stability of the core functions.

[0084] The test operation monitoring module 105 is used to monitor the process of the system executing the preset test request and obtain the test result.

[0085] Specifically, for the selected target modeling engine, the test operation monitoring module 105 monitors the process of the system executing the preset test requests. If there is an exception, crash or no response, the test is judged to have failed and an error report is generated; if all the preset test requests are executed and there is no exception, the test is judged to have passed.

[0086] In order to address the problems that may arise from the use of multiple modeling engines, this embodiment introduces a unit testing module 104 and a test operation monitoring module 105, which supports the automated batch construction of preset test requests, and implements compatibility calls for the same front-end test instructions executed on different engines. This can fully cover the modeling function interface, making it faster and easier to discover / fix problems in the modeling part.

[0087] Example 3

[0088] Based on the system described in Example 2, this embodiment further includes the following unit modules:

[0089] The modeling engine comparison module 106 is used to obtain and record the execution status and output results of each modeling engine when executing the same preset test request, evaluate the execution status and output results of each modeling engine based on multiple evaluation dimensions, generate a comparison analysis report and send it to the visualization display module 107, and generate model results of each modeling engine executing the same preset test request, and send the model results to the visualization display module 107 in the form of a comparative display.

[0090] When analyzing and selecting the compatibility of multiple modeling engines, the modeling engine comparison module comprehensively evaluates the output results of different engines based on multiple evaluation dimensions. The evaluation dimensions disclosed in this embodiment include at least one or more of geometric accuracy, mesh quality, topological structure integrity, attribute preservation, execution efficiency, and stability.

[0091] First, in terms of geometric accuracy, module 106 extracts geometric parameters such as curvature continuity, normal angle, and boundary position fitting error of key surfaces in the model returned by the engine, and determines whether there are any sudden changes in curvature, excessive surface gaps, or excessive fitting errors. This data can be obtained by comparing the geometric error values ​​between the original input parameters and the output entity, or by calculating them using the geometric analysis API provided by the modeling engine.

[0092] Secondly, in the mesh quality dimension, the system evaluates the triangular mesh structure output by the engine, including indicators such as the total number of facets, minimum internal angle, maximum aspect ratio, and distortion rate.

[0093] In the dimension of topological structure integrity, module 106 traverses the entity's topological elements such as edges, faces, and bodies, and combines the connection relationship of the geometric entities to determine whether it complies with the B-Rep closure rule to ensure that it has the correct engineering entity properties.

[0094] Regarding the evaluation of attribute retention, module 106 compares the color, material identification, user-defined attributes and other information included in the input data to see whether they are fully retained in the results returned by the modeling engine, in order to evaluate the integrity and consistency of the engine in feature modeling.

[0095] Regarding execution efficiency, module 106 captures the processing time and memory consumption of each modeling engine when executing modeling commands. For example, by recording the start and end times of modeling APIs and peak memory usage recorded by the system memory monitoring interface, the engine's execution efficiency can be assessed for tasks of varying complexity.

[0096] Finally, in the stability dimension, module 106 will capture whether there are problems such as crashes, interruptions, abnormal returns, invalid entity outputs, etc. during the modeling process, and check the validity of the output entities (such as whether it is a NULL handle or whether the structure is damaged).

[0097] Based on the evaluation results of each dimension, a comparison analysis report is generated and sent to the visualization display module 107.

[0098] Furthermore, the modeling engine comparison module 106 is also used to generate model results of each modeling engine executing the same preset test request, and send the model results to the visualization display module 107 in the form of comparative display.

[0099] For the model results returned by multiple modeling engines under the same input conditions, module 106 sends the model results (including mesh data, geometric entity information, etc.) to the visualization display module 107 in the form of comparative display, supporting visual comparison in the view in the form of side-by-side, overlay or transparent superposition, so as to intuitively identify the differences between multiple modeling engines in terms of geometric processing, topology generation, boundary surfaces, etc.

[0100] For example, Figure 6 and Figure 7 As shown in the figure, when two modeling engines are used to draw the same sphere model, although the overall geometry is consistent, there are still subtle differences in boundary processing and surface mesh generation. Through this visualization method, users can intuitively identify the differences in geometric accuracy, topology generation strategy, boundary continuity, etc. between multiple modeling engines, providing auxiliary judgment basis for engineers to independently select the appropriate modeling engine.

[0101] The visualization display module 107 is used to display the comparison analysis report and the model comparison visualization results for users to perform intuitive comparison and analysis.

[0102] Therefore, engineers can combine the comparison analysis report and model comparison visualization results displayed by the visualization display module 107 to comprehensively judge the advantages and disadvantages of each engine in terms of modeling accuracy, stability and performance, and thus independently complete the selection and switching of the adaptive modeling engine, providing auxiliary decision support for the system's multi-engine access and dynamic scheduling, and more importantly, providing data support and decision-making basis for the subsequent CAD system's modeling engine selection.

[0103] Example 4

[0104] This embodiment provides a method for implementing a CAD system that is adaptable to multiple modeling engines, which is used to execute the CAD system that is adaptable to multiple modeling engines as described in Embodiments 1 to 3. The method includes:

[0105] The target modeling implementation module (102, 102') is determined based on the selected target modeling engine through the modeling tool module 101; the modeling interface is called to receive the target modeling method call request and input data inputted from the CAD front end, and forwarded to the method of the same name that implements the target modeling method in the target modeling implementation module (102, 102'), and the input data is passed to the target modeling implementation module through the data interface;

[0106] Through the modeling implementation module (102, 102'), the adaptive modeling engine API is called in the method of the same name that implements the target modeling method, and the input data in the form of a data interface transmitted by the modeling tool module 101 is received. The input data is converted into data executable by the adaptive modeling engine, and the modeling operation is performed using the converted data executable by the adaptive modeling engine; and after the execution, the adaptive modeling engine output data is obtained, the adaptive modeling engine output data is converted into the form of a data interface, and returned to the modeling tool module 101.

[0107] In some embodiments, the method further comprises:

[0108] After selecting the target modeling engine, the unit testing module 104 transmits the preset test request to the modeling tool module 101;

[0109] The test execution monitoring module 105 monitors the process of the system executing the preset test request and obtains the test result.

[0110] In some embodiments, the method further comprises:

[0111] Through the modeling engine comparison module 106, the execution status and output results of each modeling engine when executing the same preset test request are obtained and recorded, the execution status and output results of each modeling engine are evaluated according to multiple evaluation dimensions, and a comparison analysis report is generated and sent to the visualization display module 107. In addition, the model results of each modeling engine executing the same preset test request are generated, and the model results are sent to the visualization display module 107 in the form of a comparative display.

[0112] The comparison analysis report and the model comparison visualization results are displayed through the visualization display module 107 for users to conduct intuitive comparison and analysis.

[0113] According to an embodiment of the present disclosure, an electronic device is provided. The electronic device may include: a processor, a communications interface, a memory, and a communications bus. The processor, the communications interface, and the memory communicate with each other via the communications bus. The processor may invoke logic instructions in the memory to execute a configuration software-based soft authorization implementation method.

[0114] In addition, the logical instructions in the above-mentioned memory can be implemented in the form of a software functional unit and can be stored in a computer-readable storage medium when sold or used as an independent product. Based on this understanding, the technical solution of the present disclosure is essentially or the part that contributes to the prior art or the part of the technical solution can be embodied in the form of a software product, and the computer software product is stored in a storage medium, including a number of instructions to enable a computer device (which can be a personal computer, a server, or a network device, etc.) to execute all or part of the steps of the method described in each embodiment of the present disclosure. The aforementioned storage medium includes: various media that can store program codes, such as a USB flash drive, a mobile hard disk, a read-only memory (ROM), a random access memory (RAM), a magnetic disk or an optical disk.

[0115] On the other hand, the present disclosure further provides a non-transitory computer-readable storage medium having a computer program stored thereon, which is implemented when the computer program is executed by a processor to execute the configuration software soft authorization implementation method provided by the above methods.

[0116] The device embodiments described above are merely illustrative. The units described as separate components may or may not be physically separate, and the components shown as units may or may not be physical units, i.e., they may be located in one location or distributed across multiple network units. Some or all of the modules may be selected based on actual needs to achieve the objectives of the present embodiment. Persons of ordinary skill in the art will be able to understand and implement the present invention without inventive effort.

[0117] Through the description of the above embodiments, those skilled in the art can clearly understand that each embodiment can be implemented by means of software plus a necessary general hardware platform, or of course, by hardware. Based on this understanding, the essence of the above technical solution or the part that contributes to the existing technology can be embodied in the form of a software product. The computer software product can be stored in a computer-readable storage medium, such as ROM / RAM, a magnetic disk, an optical disk, etc., and includes a number of instructions for enabling a computer device (which can be a personal computer, a server, or a network device, etc.) to execute the methods described in each embodiment or certain parts of the embodiments.

[0118] It should be understood that the above embodiments are only used to illustrate the technical solutions of the present disclosure, rather than to limit them. Although the present disclosure has been described in detail with reference to the aforementioned embodiments, those skilled in the art should understand that they can still modify the technical solutions described in the aforementioned embodiments, or make equivalent replacements for some of the technical features therein. However, these modifications or replacements do not deviate the essence of the corresponding technical solutions from the spirit and scope of the technical solutions of the various embodiments of the present disclosure.

Claims

1. A CAD system adapted to multiple modeling engines, characterized in that: include: A modeling tool module (101) and at least two modeling implementation modules (102, 102'); The modeling tool module (101) is used to determine the target modeling implementation module (102, 102') based on the selected target modeling engine; call the modeling interface to receive the target modeling method call request and input data inputted from the CAD front end, forward it to the method of the same name that implements the target modeling method in the target modeling implementation module (102, 102'), and pass the input data to the target modeling implementation module through the data interface; The modeling implementation modules (102, 102') are respectively connected to a specific modeling engine and include an interface implementation class inherited from the modeling interface. The modeling implementation modules (102, 102') are used to call the adaptive modeling engine API in the method of the same name that implements the target modeling method, receive input data in the form of a data interface transmitted by the modeling tool module (101), convert the input data into data executable by the adaptive modeling engine, and use the converted data executable by the adaptive modeling engine to perform modeling operations; It is also used to obtain the output data of the adaptive modeling engine after execution, convert the output data of the adaptive modeling engine into the form of a data interface, and return it to the modeling tool module (101); Each modeling implementation module (102, 102') includes a data packaging class inherited from a data interface. Input data is forwarded to the modeling implementation module via the modeling tool module in the form of a data interface. The modeling implementation module is responsible for converting the data into a data packaging class. The data packaging class is used to encapsulate data executable by the modeling engine and output data of the modeling engine. The data interface defines only one pure virtual method for obtaining the data identifier. The return value of this method serves as the unique identifier of the input data and the basis for sorting and determining the same entity.

2. The CAD system adapted to multiple modeling engines according to claim 1, characterized in that: Also includes: Both the data executable by the adaptive modeling engine and the output data of the adaptive modeling engine adopt handle type data, and the handle type data is used to point to geometric entity data.

3. The CAD system adapted to multiple modeling engines according to claim 1, characterized in that: It also includes a unit test module (104) for transmitting a preset test request to the modeling tool module (101) after selecting a target modeling engine; wherein the test request includes a target modeling method call request and input data; The test operation monitoring module (105) is used to monitor the process of the system executing the preset test request and obtain the test result.

4. The CAD system adapted to multiple modeling engines according to claim 3, characterized in that: It also includes a modeling engine comparison module (106) for obtaining and recording the execution status and output results of each modeling engine when executing the same preset test request, evaluating the execution status and output results of each modeling engine according to multiple evaluation dimensions, generating a comparison analysis report and sending it to the visualization display module (107), and generating model results of each modeling engine executing the same preset test request, and sending the model results to the visualization display module (107) in the form of a comparative display; The evaluation dimensions include at least one or more of geometric accuracy, mesh quality, topological structure integrity, attribute retention, execution efficiency and stability.

5. The CAD system adapted to multiple modeling engines according to claim 4, characterized in that: It also includes a visualization display module (107) for displaying the comparison analysis report and the model comparison visualization results for users to perform intuitive comparison analysis.

6. A method for implementing a CAD system adaptable to multiple modeling engines, for executing the CAD system adaptable to multiple modeling engines according to any one of claims 1 to 5, characterized in that: include: Determining a target modeling implementation module (102, 102') based on a selected target modeling engine through a modeling tool module (101); The modeling interface receives the target modeling method call request and input data inputted from the CAD front end, forwards it to the method of the same name that implements the target modeling method in the target modeling implementation module (102, 102'), and transmits the input data to the target modeling implementation module through the data interface; By means of a modeling implementation module (102, 102'), an adaptive modeling engine API is called in a method of the same name that implements a target modeling method, input data in the form of a data interface transmitted by a modeling tool module (101) is received, the input data is converted into data executable by the adaptive modeling engine, and a modeling operation is performed using the converted data executable by the adaptive modeling engine; and, after execution, obtaining the output data of the adaptive modeling engine, converting the output data of the adaptive modeling engine into a data interface format, and returning the data to the modeling tool module (101); The modeling implementation modules (102, 102') are respectively connected to a specific modeling engine and include an interface implementation class inherited from the modeling interface; Each modeling implementation module (102, 102') includes a data packaging class inherited from a data interface. Input data is forwarded to the modeling implementation module via the modeling tool module in the form of a data interface. The modeling implementation module is responsible for converting the data into a data packaging class. The data packaging class is used to encapsulate data executable by the modeling engine and output data of the modeling engine. The data interface defines only one pure virtual method for obtaining the data identifier. The return value of this method serves as the unique identifier of the input data and the basis for sorting and determining the same entity.

7. The method for implementing a CAD system adapted to multiple modeling engines according to claim 6, characterized in that: Also includes: After selecting a target modeling engine, the unit testing module (104) transmits a preset test request to the modeling tool module (101); The test operation monitoring module (105) monitors the process of the system executing the preset test request and obtains the test result.

8. The method for implementing a CAD system adapted to multiple modeling engines according to claim 7, characterized in that: Also includes: Obtain and record the execution status and output results of each modeling engine when executing the same preset test request through the modeling engine comparison module (106), evaluate the execution status and output results of each modeling engine according to multiple evaluation dimensions, generate a comparison analysis report and send it to the visualization display module (107), and generate model results of each modeling engine executing the same preset test request, and send the model results to the visualization display module (107) in the form of comparative display; The comparison analysis report and the model comparison visualization results are displayed through the visualization display module (107) for users to conduct intuitive comparison analysis.

Images