Method for Dynamically Generating Loadable Family Instances Based on Parameterized Key Caching

Abstract

The present application provides a method for dynamically generating loadable family instances based on parameterized key caching, which relates to the field of building information model technology. The method includes: when modifying parameters or creating a new instance, traversing the family parameters of the loadable family to obtain a plurality of key parameters; if the unique key is not an empty string, triggering cache retrieval and checking whether there is a key of the unique key in the cache dictionary; if it exists, generating a loadable family instance based on the model data corresponding to the unique key; if it does not exist, calling a geometric constraint solver and a geometric engine to calculate the model data, storing the calculation result in the cache dictionary, and then generating the loadable family instance. Through dynamic key generation, intelligent cache reuse and real-time synchronization mechanisms, repeated calculations can be reduced and the real-time interaction efficiency of BIM projects can be improved.

Description

Technical Field

[0001] This application relates to the technical field of building information modeling, and specifically relates to a method for dynamically generating loadable family instances based on parametric key caching. Background Art

[0002] In BIM technology, loadable families, as the core units of parametric design, drive the generation of 2D and 3D model instances with different forms through geometric constraint conditions and parameter values. In traditional implementation methods, each time parameters are modified or family instances are created, geometric constraint solving and model rendering need to be re-executed, resulting in the following problems:

[0003] High overhead of repeated calculations: When parameters are frequently modified or batch operations (such as arrays and copies) are performed, the geometric engine needs to repeatedly calculate the model data of the same parameter combination, resulting in waste of CPU / GPU resources; Insufficient real-time performance: In large-scale projects, the delay of geometric solving and rendering is significant, affecting the smoothness of design interaction; Inefficient caching mechanism: Existing static caches are not optimized for dynamic parameter correlations, with a low cache hit rate and inability to adapt to the data consistency requirements after family file changes.

[0004] Existing improvement solutions mostly adopt fixed parameter caching strategies, but do not solve core problems such as parameter screening, dynamic key generation, and cache synchronization, resulting in poor adaptability and low resource utilization. Therefore, there is an urgent need for a dynamic and intelligent cache management method to improve the performance of BIM software. Summary of the Invention

[0005] This application provides a method for dynamically generating loadable family instances based on parametric key caching, aiming to reduce repeated calculations and improve the real-time interaction efficiency of BIM projects through dynamic key generation, intelligent cache reuse, and real-time synchronization mechanisms.

[0006] In a first aspect, an embodiment of this application provides a method for dynamically generating loadable family instances based on parametric key caching, including:

[0007] In the case of parameter modification or new instance creation, perform a traversal operation on the family parameters of the loadable family to obtain multiple key parameters; where the key parameters are parameters that affect the 2D and 3D models of the loadable family instance.

[0008] Generate a unique key according to the parameter values of the key parameters.

[0009] If the unique key is not an empty string, trigger cache retrieval, and check whether there is a key corresponding to the unique key in the cache dictionary; if it exists, generate a loadable family instance based on the model data corresponding to the unique key; if it does not exist, call a geometric constraint solver and a geometric engine to calculate the model data, store the calculation result in the cache dictionary, and then generate the loadable family instance.

[0010] In the above implementation, by screening the key parameters that affect the 2D and 3D models of loadable family instances, a unique string key can be dynamically generated, and an accurate mapping between the parameter combination and the model data can be established. This can avoid repeatedly calling the geometric constraint solver and the geometric engine for calculation under the same parameter combination. By automatically determining whether the parameters affect the 2D and 3D model forms, the generated key only contains necessary parameters, which can reduce redundancy or omission, improve the cache hit rate and the accuracy of calculation results. Thus, efficient cache reuse can be achieved and the consumption of repeated calculation can be reduced.

[0011] In some embodiments, generating a unique key according to the parameter values of the key parameters includes: converting the parameter values into a string value, namely value, and adding it as a part of the key, that is, Key += value; wherein, the conversion of the parameter value type into a string is carried out according to the following rules: if the parameter value is a real number or an angle, 3 decimal places after the decimal point are reserved; if the parameter value is a boolean value, it is replaced by 0 or 1; if the parameter value is an enumeration value, the serial number is saved in order; if the parameter value is an integer or a string, it remains unchanged.

[0012] In some embodiments, the key parameters include geometric association parameters, primitive attribute parameters, and operation logic parameters; wherein, the geometric association parameters are bound to geometric constraint conditions, including one or more of length, spacing, angle, radius, diameter, and elevation; the primitive attribute parameters control the primitive attributes, including one or more of controlling scaling, stretching length, rotation angle, and visibility; the operation logic parameters are associated with array operations or action control logic, including one or more of the driving parameters associated with array operations and the driving parameters associated with action controls.

[0013] In some embodiments, the method may further include:

[0014] In the case of responding to a parameter modification operation, if the key parameters are involved, cache retrieval is triggered; if only the modification of non-key parameters is involved, the parameter data of the loadable family instance is updated.

[0015] In some embodiments, the method may further include:

[0016] If the project file using the loadable family is closed, the cache data is cleared; if the project file is reopened, the cache is rebuilt according to the original instances.

[0017] In some embodiments, the method may further include:

[0018] If the family file information of the loadable family is modified, retrieve whether the current project file contains a family file with the same name. If it exists, clear the cache data; and generate cache data based on the parameter values in the original family instance and the modified family file information, and update the family instances with the same parameter key.

[0019] In some embodiments, the method further includes:

[0020] In operations of array or batch generation, for all loadable family instances corresponding to the same key, reuse the same cache data to generate multiple instances.

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

[0022] If the unique key is an empty string, directly update the model using the initial two-dimensional and three-dimensional model data in the family.

[0023] In some embodiments, the model data includes the triangular patch vertex and normal vector data jointly calculated by a geometric constraint solver and a geometric engine, the graphic metadata of the two-dimensional legend, and the layer information.

[0024] Compared with the prior art, the beneficial effects of the present application are as follows: By screening the key parameters that affect the two-dimensional and three-dimensional models of loadable family instances, a unique string key can be dynamically generated, and an accurate mapping between the parameter combination and the model data can be established. It is possible to avoid repeatedly calling the geometric constraint solver and the geometric engine for calculation under the same parameter combination. By automatically determining whether the parameters affect the two-dimensional and three-dimensional model forms, the generated key only contains necessary parameters, which can reduce redundancy or omission, improve the cache hit rate and the accuracy of calculation results. Thus, efficient cache reuse can be achieved and the consumption of repeated calculation can be reduced. Brief Description of the Drawings

[0025] Figure 1 It is a step schematic diagram of a method for dynamically generating loadable family instances based on parameterized key caching provided by an embodiment of the present application.

[0026] Figure 2 It is a flow schematic diagram of a method for dynamically generating loadable family instances based on parameterized key caching provided by an embodiment of the present application. Detailed Embodiments

[0027] The present application will be further described in detail below in combination with test examples and specific embodiments. However, it should not be understood that the scope of the above subject matter of the present application is limited to the following embodiments. All technologies implemented based on the content of the present application belong to the scope of protection of the present application.

[0028] Unless otherwise specified, in the description of the specific embodiments of the present application, the expression terms indicating the orientation or positional relationship such as "upper", "lower", "left", "right", "center", "inner", "outer", "side", etc. are all based on the orientation or positional relationship shown in the drawings, or the orientation or positional relationship when the product / device / device is normally used and placed. These terms of orientation or positional relationship are only for the convenience of describing the solution of the present application or simplifying the description in the specific embodiments, so as to facilitate technicians to quickly understand the solution, rather than indicating or implying that a specific device / component / element must have a specific orientation, or be constructed and operated in a specific positional relationship. Therefore, it should not be construed as a limitation to the present application.

[0029] In the description of the embodiments of the present application, the technical terms "first", "second", etc. only distinguish one entity or operation from another entity or operation, and cannot be understood as indicating or implying relative importance or implicitly indicating the quantity, specific order or primary-secondary relationship of the indicated technical features. In the description of the embodiments of the present application, the meaning of "a plurality" is two or more, unless otherwise specifically defined.

[0030] Referring to "embodiment" herein means that the specific features, structures or characteristics described in connection with the embodiment may be included in at least one embodiment of the present application. The appearance of this phrase in various positions in the specification does not necessarily refer to the same embodiment, nor is it an independent or alternative embodiment mutually exclusive with other embodiments. Those skilled in the art explicitly and implicitly understand that the embodiments described herein can be combined with other embodiments.

[0031] Embodiment 1

[0032] The core of the present application lies in dynamically generating parameter keys and establishing cache mapping, specifically including the following steps: parameter screening, key generation, cache management, synchronization mechanism and batch optimization. By screening the key parameters that affect the model form, converting them into standardized strings to generate unique keys, using a dictionary structure to store the mapping relationship between keys and model data, supporting efficient retrieval and update, and at the same time responding to parameter modification, project file operations and family file changes, dynamically maintaining cache consistency, and reusing the same cache data in batch operations to avoid repeated calculations.

[0033] Please refer to Figure 1 and Figure 2 , Figure 1 which is a schematic diagram of the steps of the method for dynamically generating loadable family instances based on parameterized key caching provided by the embodiments of the present application. Figure 2 which is a flowchart of the method for dynamically generating loadable family instances based on parameterized key caching. The method for dynamically generating loadable family instances based on parameterized key caching may include:

[0034] S1. When modifying parameters or creating a new instance, perform a traversal operation on the family parameters of the loadable family to obtain multiple key parameters.

[0035] Among them, the key parameters are the parameters that affect the 2D and 3D models of the loadable family instances. The key parameters can include geometric association parameters, primitive attribute parameters, and operation logic parameters; among them, the geometric association parameters are bound to geometric constraint conditions and include one or more of length, spacing, parallelism, perpendicularity, tangency, angle, radius; the primitive attribute parameters control primitive attributes and include one or more of controlling scaling, stretching length, rotation angle, visibility; the operation logic parameters are associated with array operations or action control logic and include one or more of the drive parameters associated with array operations and the drive parameters associated with action controls.

[0036] For example, in the "wall family" instance, the parameter "thickness" is bound to geometric constraints and marked as a geometric association parameter; "rotation angle" controls the primitive direction and is marked as a primitive attribute parameter; "array spacing" drives the batch generation logic and is marked as an operation logic parameter. Automatically determining the parameter type through the rule engine to avoid non-key parameters interfering with key generation can shorten the key length, thereby improving the dictionary retrieval speed and significantly increasing the cache hit rate.

[0037] In the embodiment of the present application, the cache data structure uses a dictionary (Dictionary<string, object>) to store the mapping relationship between the key and the model data. The model data includes the topological relationship matrix output by the geometric constraint solver, the vertex coordinates and normal vector data of the triangular patches generated by the geometric engine, and the vector graphic metadata and layer information of the 2D view.

[0038] For example, the value corresponding to the key Key = "20001500.5001" includes the vertex and normal vector data of the triangular patches jointly calculated by the geometric constraint solver and the geometric engine, the graphic metadata of the 2D legend, and the layer information.

[0039] The topological relationship matrix describes the mathematical relationship of geometric constraints. The triangular patch data is used for 3D rendering. The vector graphic metadata contains 2D information such as lines and fill patterns. This lightweight storage architecture achieves millisecond-level retrieval efficiency, supports high-performance expansion of millions of instances, and at the same time adapts to different graphics APIs (such as OpenGL, DirectX) to improve cross-platform compatibility. It can directly affect the system resource occupancy and response speed, especially having scalability in large-scale scenarios with millions of instances.

[0040] S2. Generate a unique key according to the parameter values of the key parameters.

[0041] Among them, the way to generate a unique key can be specifically as follows: convert the parameter value into a string value and add it as a part of the key, that is, Key += value; among them, the conversion of the parameter value type into a string is carried out according to the following rules: if the parameter value is a real number or an angle, retain 3 decimal places after the decimal point; if the parameter value is a boolean value, replace it with 0 or 1; if the parameter value is an enumerated value, save it using the serial number in order; if the parameter value is an integer or a string, it remains unchanged.

[0042] For example, the length 1500.3456mm is converted to "1500.346", and the rotation angle 45.678° is converted to "45.678"; the boolean parameter is mapped to 0 (False) or 1 (True), for example, visibility = True → "1"; the enumerated parameter is stored according to the predefined serial number, for example, the material type "glass" corresponds to the enumerated value 2 → "2"; the integer or string parameter is directly concatenated, for example, the quantity parameter 10 → "10". The converted strings are concatenated in the parameter order to form the final key. For example, for a family instance parameter with a length of 1500.346mm, a rotation angle of 45.678°, visibility True, and a material type of 2, the key Key = "1500.34645.67812" is generated. This method avoids key conflicts caused by parameter format differences (such as the number of decimal places, enumerated descriptions), supports the reuse of cached data between different BIM software, and improves the collaboration efficiency.

[0043] By uniformly converting parameter values of different data types (such as numerical values, booleans, enumerations) into a standardized string format, it supports cross-platform and cross-model cache consistency management, can solve the key conflict problem caused by parameter format differences, and ensures cache reliability.

[0044] S3. If the unique key is not an empty string, trigger cache retrieval, and retrieve whether there is a key of the unique key in the cache dictionary; if it exists, generate a loadable family instance based on the model data corresponding to the unique key; if it does not exist, call the geometric constraint solver and the geometric engine to calculate the model data, store the calculation result in the cache dictionary, and then generate the loadable family instance.

[0045] For example, when creating an instance of the "door and window family", the parameters include width (geometric association parameter), material type (non-critical parameter), and visibility (primitive attribute parameter). Only the width and visibility can be selected as critical parameters. Subsequently, the critical parameter values are converted into strings according to the preset rules and concatenated into a unique key. For example, width = 2000mm (integer → "2000"), visibility = True (boolean → "1"), and the key Key = "20001" is generated.

[0046] If the unique key is not empty, retrieve the key in the cache dictionary. If it exists, directly read the model data to generate an instance. If it does not exist, call the geometric constraint solver to calculate the topological relationship, and render through the geometric engine to generate three-dimensional triangular patches and two-dimensional vector graphic data. Store the result in the cache and then generate an instance. Through dynamic key mapping, the same parameter combination only needs to be calculated for the first time, and the cache can be directly reused later, which is especially suitable for large-scale projects.

[0047] In addition, if the unique key is an empty string, the initial two- and three-dimensional model data in the family can be directly used to update the model. The empty key processing mechanism can be compatible with non-parametric family files. When there are no critical parameters in the loadable family, the generated key Key = "", and the system directly uses the initial model data to generate an instance.

[0048] In the embodiments of the present application, when the user frequently modifies the family parameters, if the parameter value does not affect the two- and three-dimensional model data, there will be no additional computational cost. If it has an impact, calculate the parameter key Key. When the parameter key hits the cache, directly read the model data to update the family instance, reduce the call frequency of the geometric solution engine and the geometric engine, reduce the CPU / GPU occupancy, and significantly improve the performance of the BIM software. If there is no matching cache data, the cache data is dynamically updated, which can adapt to the parameter combinations of different types of families and ensure the correctness of model creation.

[0049] Through the method provided in the embodiments of the present application, in the design and use process, use the quick layout function, such as array, layout by view, layout of the whole building, etc. to realize the scenario of batch creation of parametric family instances. The geometric constraint solving and model data calculation processes are at most only once, the program responds quickly, and the design efficiency of designers is improved. Through the key-value pair storage of the parameter key and the model calculation result, such as hash table, dictionary structure, etc., millisecond-level cache retrieval and update can be realized.

[0050] In the above implementation process, by screening the key parameters that affect the two- and three-dimensional models of the loadable family instance, a unique string key is dynamically generated, and an accurate mapping between the parameter combination and the model data is established. It is possible to avoid repeatedly calling the geometric constraint solver and the geometric engine for calculation under the same parameter combination. By automatically determining whether the parameter affects the two- and three-dimensional model form, the generated key only contains necessary parameters, which can reduce redundancy or omission, improve the cache hit rate and the accuracy of the calculation result. Thus, efficient cache reuse can be achieved and the consumption of repeated calculations can be reduced.

[0051] Embodiment 2

[0052] This embodiment is an example of the trigger and update mechanism in the method for dynamically generating loadable family instances based on parametric key caching in Embodiment 1 above.

[0053] In the case of a response parameter modification operation, if the key parameter is involved, cache retrieval is triggered; if only the modification of non-key parameters is involved, the parameter data of the loadable family instance is updated.

[0054] Exemplarily, when a user creates a new family instance through a graphical interface or a secondary developer performs loadable family instantiation, cache retrieval can be triggered, and the steps of traversing family parameters, generating keys, and generating loadable family instances are executed. When a user modifies a parameter value through the property page of a loadable family instance or a secondary developer modifies the parameter value of a family instance, it is determined whether these parameters will affect the two-dimensional and three-dimensional model data. If they will affect, the steps in the above method are executed; if they will not affect, only the parameter data of this family instance is updated, and subsequent calculations will not be performed.

[0055] For example, modifying the "material type" (non-key parameter) only updates the instance attribute data and does not trigger cache retrieval; modifying the "length" (key parameter) triggers key generation and cache retrieval. This mechanism skips geometric engine calls when frequently adjusting non-key parameters (such as colors and annotations), reduces invalid calculations, and is applicable to the detailed optimization stage of complex projects.

[0056] Embodiment 3

[0057] This embodiment is an example of the project file cache management in Embodiment 1 above.

[0058] If the project file using the loadable family is closed, the cache data is cleared; if the project file is reopened, the cache is rebuilt based on the original instances.

[0059] Project file cache management ensures system resource efficiency by dynamically maintaining cache data. When a user closes a project file, the system automatically clears the cache dictionary to release memory; after reopening the project, keys are regenerated based on the instance parameter values and the cache is rebuilt. For example, when the project file using the loadable family is saved and closed, the system will clear the cache data Data. When this project is reopened, based on the original family instances, the steps in the above method are repeatedly executed to recalculate the Data data.

[0060] Embodiment 4

[0061] This embodiment is an example of the family file change synchronization in Embodiment 1 above.

[0062] If the family file information of a loadable family is modified, it is retrieved whether the current project file contains a family file with the same name. If it exists, the cache data is cleared; and based on the parameter values in the original family instances, cache data is generated in combination with the modified family file information, and the family instances with the same parameter keys are updated.

[0063] Among them, the family file change synchronization mechanism ensures that the cached data is consistent with the latest family definition. When the user modifies the family file (such as adding new parameters or adjusting constraint logic) and reloads the project, the system retrieves whether the current project contains a family file with the same name. If it exists, the old cached data is cleared, and the key and model data are regenerated based on the original instance parameter values combined with the new family definition. For example, when the user modifies the family file information and reloads it into the project, the program retrieves whether the current project contains a family file with the same name. If they are the same, the Data is cleared, and based on the family parameter values in the original family instance, combined with the new family file parameter information, after repeating the annotation in the above method, while generating the Data cached data, the family instances with the same parameter key are updated.

[0064] In the above implementation process, when the family file is modified and reloaded, the cached data of all relevant instances in the project is automatically associated and updated to ensure data consistency. It can prevent the invalidation or incorrect application of historical cached data caused by changes in family definitions, which is a key guarantee for system security.

[0065] Embodiment 5

[0066] This embodiment is an example of batch operation cache reuse in the above Embodiment 1.

[0067] In the operation of array or batch generation, for all loadable family instances corresponding to the same key, the same cached data is reused to generate multiple instances.

[0068] The batch operation cache reuse strategy significantly improves the efficiency of array and batch generation. In the operations of linear, circular or matrix arrays, all instances under the same parameter combination share the same cached data. For example, when the user performs a linear array (quantity = 10, spacing = 3000mm) on the "luminaire family" and generates the key Key = "300010", all instances share the same cached data. If the spacing of one of the instances is modified to 4000mm, only this instance triggers the generation and calculation of a new key, and the remaining instances still reuse the original cache.

[0069] In the above implementation process, for multiple family instances generated by the array, the same cached data is shared, and it supports local cache trigger updates during incremental parameter modification. It can significantly improve the efficiency of batch operations and cover the core requirements of typical engineering application scenarios.

[0070] Based on the same application concept, an embodiment of the present application also provides a dynamic generation system for loadable family instances based on parametric key caching, which may include:

[0071] A traversal module, configured to perform a traversal operation on the family parameters of loadable families to obtain multiple key parameters in the case of modifying parameters or creating new instances; wherein, the key parameters are parameters that affect the two-dimensional and three-dimensional models of loadable family instances.

[0072] A key generation module, configured to generate a unique key according to the parameter value of the key parameter.

[0073] A retrieval and generation module, configured to trigger cache retrieval if the unique key is not an empty string, and retrieve whether there is a key of the unique key in the cache dictionary; if so, generate a loadable family instance based on the model data corresponding to the unique key; if not, call a geometric constraint solver and a geometric engine to calculate model data, store the calculation result in the cache dictionary, and then generate the loadable family instance.

[0074] It should be understood that when each module of the loadable family instance dynamic generation system based on parametric key caching provided in the above embodiments is in operation, only the division of the above-described functional modules in the above description content is used as an example. In actual applications, the above functions can be allocated to different functional modules according to needs, that is, the internal structure of the device can be divided into different functional modules to complete all or part of the functions described above.

[0075] Each functional module in the above embodiments can be integrated into a processing unit, or each unit can exist physically alone, or two or more units can be integrated into one unit. The above integrated unit can be implemented in the form of hardware or in the form of a software functional unit. In addition, the specific names of the functional units and modules are only for the convenience of mutual distinction and do not limit the protection scope of the embodiments of the present application.

[0076] Based on the same inventive concept, an embodiment of the present application further provides a computer device, which may include a memory, a processor, and a computer program stored in the memory and executable on the processor. When the processor executes the computer program, the method described in the above description content is implemented.

[0077] Based on the same inventive concept, an embodiment of the present application further provides a computer-readable storage medium, which stores a computer program, and when the computer program is executed by a processor, the method described in the above description content is implemented.

[0078] The above embodiments are only used to illustrate the technical solutions of the present application, rather than to limit them; although the present application has been described in detail with reference to the foregoing embodiments, those of ordinary skill in the art should understand that they can still modify the technical solutions recorded in the foregoing embodiments, or perform equivalent replacements on some of the technical features; and these modifications or replacements do not make the essence of the corresponding technical solutions deviate from the spirit and scope of the technical solutions of the embodiments of the present application, and should all be included in the protection scope of the present application.

Claims

1. A method for dynamically generating loadable family instances based on parameterized key cache, characterized in that: include: In the case of modifying parameters or creating a new instance, the family parameters of the loadable family are traversed to obtain a plurality of key parameters; wherein the key parameters are parameters that affect the two-dimensional and three-dimensional models of the loadable family instance; Generate a unique key according to the parameter value of the key parameter; If the unique key is not an empty string, a cache search is triggered to search whether a key of the unique key exists in the cache dictionary; if so, a loadable family instance is generated based on the model data corresponding to the unique key; if not, a geometric constraint solver and a geometric engine are called to calculate the model data, and the calculation result is stored in the cache dictionary to generate the loadable family instance; The generating a unique key according to the parameter value of the key parameter comprises: Convert the parameter value into a string value and add it as part of the key, that is, Key+=value; the parameter value type is converted into a string according to the following rules: if the parameter value is a real number or an angle, retain 3 decimal places after the decimal point; if the parameter value is a Boolean value, replace it with 0 or 1; if the parameter value is an enumeration value, save it in sequence using a serial number; if the parameter value is an integer or a string, leave it unchanged; The key parameters include geometric association parameters, primitive attribute parameters and operation logic parameters; wherein the geometric association parameters are bound to geometric constraints, including one or more of length, spacing, angle, radius, diameter, and vector height; the primitive attribute parameters control primitive attributes, including one or more of scaling, stretching length, rotation angle, and visibility; the operation logic parameters are associated with array operations or action control logic, including one or more of driving parameters associated with array operations and driving parameters associated with action controls; In response to a parameter modification operation, if the key parameter is involved, a cache search is triggered, and if only a modification of a non-key parameter is involved, the parameter data of the loadable family instance is updated; If the project file using the loadable family is closed, the cache data is cleared; if the project file is reopened, the cache is rebuilt according to the original instance.

2. The method according to claim 1, characterized in that The method further comprises: If the family file information of the loadable family is modified, the current project file is retrieved to see whether it contains a family file with the same name. If so, the cached data is cleared; and based on the parameter values ​​in the original family instance, the cached data is generated in combination with the modified family file information, and the family instance with the same parameter key is updated.

3. The method according to claim 1, characterized in that The method further comprises: In array or batch generation operations, for all loadable family instances corresponding to the same key, the same cache data is reused to generate multiple instances.

4. The method according to claim 1, characterized in that The method further comprises: If the unique key is an empty string, the initial data of the two-dimensional and three-dimensional models in the family are directly used to update the model.

5. The method according to claim 1, characterized in that The model data includes triangular facet vertex and normal vector data, and graphic metadata and layer information of a two-dimensional illustration jointly calculated and generated by a geometric constraint solver and a geometric engine.

Images