Loadable family instance dynamic generation method based on parameterized key cache

Abstract

The invention provides a loadable family instance dynamic generation method based on parameterized key cache, and relates to the technical field of building information models. The method comprises the steps of performing traversal operation on family parameters of a loadable family to obtain a plurality of key parameters under the condition that parameters are modified or an instance is newly built; if the unique key is not the null character string, triggering cache retrieval, and retrieving whether a key of the unique key exists in a cache dictionary; if yes, generating a loadable family instance based on model data corresponding to the unique key; and if not, calling a geometric constraint solver and a geometric engine to calculate model data, storing a calculation result into the cache dictionary, and then generating the loadable family instance. Through dynamic key generation, intelligent cache multiplexing and real-time synchronization mechanisms, repeated calculation is reduced, and the real-time interaction efficiency of a BIM project is improved.

Description

Technical Field

[0001] The present application relates to the technical field of building information modeling, and in particular to a method for dynamically generating loadable family instances based on parameterized key caching. Background Art

[0002] In BIM technology, loadable families are used as the core unit of parametric design, and two-dimensional and three-dimensional model instances with different forms are generated by driving geometric constraints and parameter values. In traditional implementation methods, each time a parameter is modified or a family instance is created, geometric constraint solving and model rendering must be re-executed, resulting in the following problems: High overhead of repeated calculations: When frequent parameter modifications or batch operations (such as arrays and copies) are performed, the geometry engine needs to repeatedly calculate the model data of the same parameter combination, resulting in a waste of CPU / GPU resources; Insufficient real-time performance: In large-scale projects, there are significant delays in geometry solving and rendering, which affects the smoothness of design interaction; Inefficient caching mechanism: The existing static cache is not optimized for dynamic parameter correlation, has a low cache hit rate, and cannot adapt to the data consistency requirements after family file changes.

[0003] Most existing improvement schemes adopt fixed parameter cache strategies, but fail to solve core problems such as parameter screening, dynamic key generation, and cache synchronization, resulting in poor adaptability and low resource utilization. Therefore, a dynamic and intelligent cache management method is urgently needed to improve the performance of BIM software. Summary of the invention

[0004] The present application provides a method for dynamically generating loadable family instances based on parameterized 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 mechanism.

[0005] In a first aspect, an embodiment of the present application provides a method for dynamically generating a loadable family instance based on a parameterized key cache, comprising: 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 it exists, a loadable family instance is generated based on the model data corresponding to the unique key; if it does not exist, the geometric constraint solver and the geometric engine are called to calculate the model data, and the calculation results are stored in the cache dictionary to generate the loadable family instance.

[0006] In the above implementation, by screening the key parameters of the two-dimensional and three-dimensional models that can be loaded into the family instance, a unique string key can be dynamically generated to establish an accurate mapping between the parameter combination and the model data, so as 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 form, the generated key only contains necessary parameters, which can reduce redundancy or omissions, improve the cache hit rate and the accuracy of the calculation results. In this way, efficient cache reuse can be achieved and the consumption of repeated calculations can be reduced.

[0007] In some embodiments, generating a unique key based on the parameter value of the key parameter includes: converting the parameter value into a string value, and adding it as part of the key, that is, Key+=value; wherein 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, it remains unchanged.

[0008] 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 constraints, including one or more of length, spacing, angle, radius, diameter, and vector height; the primitive attribute parameters control primitive attributes, including controlling 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.

[0009] In some embodiments, the method may further include: In response to a parameter modification operation, if the key parameters are involved, cache retrieval is triggered; if only modifications of non-key parameters are involved, the parameter data of the loadable family instance is updated.

[0010] In some embodiments, the method may further include: 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.

[0011] In some embodiments, the method may further include: 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.

[0012] In some embodiments, 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.

[0013] In some embodiments, 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.

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

[0015] Compared with the prior art, the beneficial effects of the present application are: by screening the key parameters of the two-dimensional and three-dimensional models that affect the 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, so that the repeated invocation of the geometric constraint solver and the geometric engine for calculation under the same parameter combination can be avoided, and by automatically determining whether the parameters affect the two-dimensional and three-dimensional model morphology, the generated key only contains necessary parameters, which can reduce redundancy or omissions, improve the cache hit rate and the accuracy of the calculation results. Thus, efficient cache reuse can be achieved and the consumption of repeated calculations can be reduced. BRIEF DESCRIPTION OF THE DRAWINGS

[0016] Figure 1 A schematic diagram of the steps of a method for dynamically generating loadable family instances based on a parameterized key cache provided in an embodiment of the present application.

[0017] Figure 2 A flowchart of a method for dynamically generating loadable family instances based on parameterized key cache provided in an embodiment of the present application. DETAILED DESCRIPTION

[0018] The present application is further described in detail below in conjunction with test examples and specific implementation methods. However, this should not be understood as the scope of the above subject matter of the present application being limited to the following embodiments, and all technologies implemented based on the content of the present application belong to the scope of protection of the present application.

[0019] Unless otherwise specified, in the description of the specific embodiments of the present application, the terms indicating the orientation or position relationship such as "up", "down", "left", "right", "center", "inside", "outside", "side", etc. are all expressions based on the orientation or position relationship shown in the drawings, or the orientation or position relationship when the product / equipment / device is usually used. These terms of orientation or position relationship are only for the convenience of describing the scheme of the present application or simplifying the description in the specific embodiments to facilitate the technicians to quickly understand the scheme, rather than indicating or implying that a specific device / component / element must have a specific orientation, or be constructed and operated in a specific position relationship, and therefore cannot be understood as a limitation on the present application.

[0020] 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 number, specific order, or primary and secondary relationship of the indicated technical features. In the description of the embodiments of the present application, the meaning of "multiple" is two or more, unless otherwise clearly and specifically defined.

[0021] Reference to "embodiments" herein means that a particular feature, structure, or characteristic described in conjunction with the embodiments may be included in at least one embodiment of the present application. The appearance of the phrase in various locations in the specification does not necessarily refer to the same embodiment, nor is it an independent or alternative embodiment that is mutually exclusive with other embodiments. It is explicitly and implicitly understood by those skilled in the art that the embodiments described herein may be combined with other embodiments.

[0022] Example 1 The core of this application is to dynamically generate parameter keys and establish cache mapping, which specifically includes the following steps: parameter screening, key generation, cache management, synchronization mechanism and batch optimization. By screening the key parameters that affect the model morphology, converting them into standardized strings to generate unique keys, using dictionary structures to store the mapping relationship between keys and model data, supporting efficient retrieval and updates, responding to parameter modifications, project file operations and family file changes, dynamically maintaining cache consistency, and reusing the same cache data in batch operations to avoid repeated calculations.

[0023] Please refer to Figure 1 and Figure 2 , Figure 1 A schematic diagram of the steps of a method for dynamically generating loadable family instances based on a parameterized key cache provided in an embodiment of the present application. Figure 2 A flow chart of a method for dynamically generating a loadable family instance based on a parameterized key cache provided in an embodiment of the present application. The method for dynamically generating a loadable family instance based on a parameterized key cache may include: S1. When modifying parameters or creating a new instance, the family parameters of the loadable family are traversed to obtain multiple key parameters.

[0024] Among them, the key parameters are parameters that affect the two-dimensional or three-dimensional models of loadable family instances. The key parameters may 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, parallelism, verticality, tangency, angle, and radius; 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.

[0025] 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 direction of the primitive and is marked as a primitive attribute parameter; "array spacing" drives batch generation logic and is marked as an operation logic parameter. The rule engine automatically determines the parameter type to avoid non-critical parameters interfering with key generation, shortening the key length, thereby increasing the dictionary retrieval speed and significantly improving the cache hit rate.

[0026] In the embodiment of the present application, the cache data structure adopts a dictionary.<string, object> ) stores 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 triangle patch vertex coordinates and normal vector data generated by the geometry engine, and the vector graphics metadata and layer information of the two-dimensional view.

[0027] For example, the value corresponding to the key Key="20001500.5001" includes the triangle patch vertex and normal vector data calculated and generated by the geometric constraint solver and the geometric engine, the graphic metadata of the two-dimensional legend, and the layer information.

[0028] The topological relationship matrix describes the mathematical relationship of geometric constraints, the triangular patch data is used for three-dimensional rendering, and the vector graphics metadata contains two-dimensional 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 adapts to different graphics APIs (such as OpenGL and DirectX) to improve cross-platform compatibility. It can directly affect system resource usage and response speed, especially in large-scale scenarios with millions of instances.

[0029] S2. Generate a unique key according to the parameter value of the key parameter.

[0030] Among them, the method of generating a unique key can be specifically as follows: convert the parameter value into a string value, and add it as part of the key, that is, Key+=value; wherein 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, it remains unchanged.

[0031] For example, the length of 1500.3456mm is converted to "1500.346", and the rotation angle of 45.678° is converted to "45.678"; Boolean parameters are mapped to 0 (False) or 1 (True), such as visibility = True → "1"; enumeration parameters are stored according to predefined serial numbers, such as the material type "glass" corresponds to the enumeration value 2 → "2"; integer or string parameters are directly spliced, such as the quantity parameter 10 → "10". The converted string is spliced ​​into the final key in the order of parameters. For example, the parameters of a family instance are length 1500.346mm, rotation angle 45.678°, visibility True, material type 2, and the generated key Key="1500.34645.67812". This method avoids key conflicts caused by differences in parameter formats (such as decimal places, enumeration descriptions), supports cache data reuse between different BIM software, and improves collaboration efficiency.

[0032] By converting parameter values ​​of different data types (such as numbers, Booleans, and enumerations) into standardized string formats, it supports cross-platform and cross-model cache consistency management, solves key conflicts caused by parameter format differences, and ensures cache reliability.

[0033] S3. 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 it exists, a loadable family instance is generated based on the model data corresponding to the unique key; if it does not exist, the geometric constraint solver and the 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.

[0034] For example, when creating a "Door and Window Family" instance, the parameters include width (geometry-related parameter), material type (non-key parameter), and visibility (element attribute parameter). You can filter only width and visibility as key parameters. Then, the key parameter values ​​are converted into strings according to 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.

[0035] If the unique key is not empty, the key is retrieved from the cache dictionary: if it exists, the model data is directly read to generate an instance; if it does not exist, the geometric constraint solver is called to calculate the topological relationship, and the 3D triangle patch and 2D vector graphics data are generated through the geometric engine rendering, and the result is stored in the cache to 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 reused directly afterwards, which is especially suitable for large-scale projects.

[0036] In addition, if the unique key is an empty string, the initial data of the 2D or 3D model in the family can be used directly to update the model. The empty key processing mechanism is compatible with non-parametric family files. When the loadable family does not have any key parameters, the generated key Key="" is used, and the system directly generates instances using the initial model data.

[0037] In the embodiment of the present application, when the user frequently modifies the family parameters, if the parameter value does not affect the two-dimensional or three-dimensional model data, no additional calculation cost will be incurred. If it does affect, the parameter key Key will be calculated. When the parameter key hits the cache, the model data is directly read to update the family instance, reducing the calling frequency of the geometry solver and geometry engine, reducing the CPU / GPU occupancy, and significantly improving the performance of the BIM software. If there is no matching cache data, the cache data is dynamically updated, and the parameter combination of different types of families can be adaptively adjusted to ensure the correctness of model creation.

[0038] Through the method provided in the embodiment of the present application, during the design process, quick layout functions such as array, layout by view, and layout of the entire building are used to achieve batch creation of parametric family instances. The geometric constraint solving and model data calculation process is performed only once at most, and the program responds quickly, improving the designer's design efficiency. By storing key-value pairs of parameter keys and model calculation results, such as hash tables and dictionary structures, millisecond-level cache retrieval and updates can be achieved.

[0039] In the above implementation process, by screening the key parameters of the two-dimensional and three-dimensional models that can be loaded into the family instance, a unique string key can be dynamically generated to establish an accurate mapping between the parameter combination and the model data, so as 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 form, the generated key only contains necessary parameters, which can reduce redundancy or omissions, improve the cache hit rate and the accuracy of the calculation results. In this way, efficient cache reuse can be achieved and the consumption of repeated calculations can be reduced.

[0040] Example 2 This embodiment is an example of the triggering and updating mechanism in the method for dynamically generating loadable family instances based on parameterized key cache in the above-mentioned embodiment 1.

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

[0042] For example, when a user creates a new family instance through a graphical interface or a secondary development user instantiates a loadable family, a cache search can be triggered to perform the steps of traversing family parameters, generating keys, and generating loadable family instances. When a user modifies the parameter value through the property page of the loadable family instance or a secondary development user modifies the parameter value of the family instance. It is determined whether these parameters will affect the two-dimensional or three-dimensional model data. If so, the steps in the above method are executed. If not, only the family instance parameter data will be updated, and no subsequent calculations will be performed.

[0043] For example, modifying the "material type" (a non-critical parameter) only updates the instance attribute data and does not trigger cache retrieval; modifying the "length" (a critical parameter) triggers key generation and cache retrieval. This mechanism skips the geometry engine call when frequently adjusting non-critical parameters (such as color and annotation), reduces invalid calculations, and is suitable for the detail optimization stage of complex projects.

[0044] Example 3 This embodiment is an example of the project file cache management in the above-mentioned embodiment 1.

[0045] 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.

[0046] Project file cache management ensures system resource efficiency by dynamically maintaining cache data. When the user closes the project file, the system automatically clears the cache dictionary to free up memory; after reopening the project, the key is regenerated based on the instance parameter value and the cache is rebuilt. For example, when a project file that uses a loadable family is saved and closed, the system will clear the cache data Data. When the project is reopened, the steps in the above method are repeated based on the original family instance to recalculate the Data data.

[0047] Example 4 This embodiment is an example of synchronization of family file changes in the above-mentioned embodiment 1.

[0048] 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.

[0049] 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 parameters or adjusting constraint logic) and reloads the project, the system searches whether the current project contains a family file with the same name. If so, the old cached data is cleared, and the key and model data are regenerated based on the original instance parameter values ​​and the new family definition. For example, when the user makes changes to the family file information and reloads it into the project, the program searches whether the current project contains a family file with the same name. If so, the Data data is cleared, and based on the family parameter values ​​in the original family instance and combined with the new family file parameter information, the annotations in the above method are repeated. While generating the Data cache data, the family instances with the same parameter keys are updated.

[0050] In the above implementation process, when the family file is modified and reloaded, the cache data of all related instances in the project are automatically associated and updated to ensure data consistency. This can prevent the historical cache data from being invalidated or incorrectly applied due to changes in family definitions, which is a key guarantee for system security.

[0051] Example 5 This embodiment is an example of batch operation cache reuse in the above-mentioned embodiment 1.

[0052] 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.

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

[0054] In the above implementation process, multiple family instances generated by the array share the same cache data, and support local cache trigger updates during incremental parameter modification. This can significantly improve batch operation efficiency and cover the core requirements of typical engineering application scenarios.

[0055] Based on the same application concept, the embodiment of the present application also provides a system for dynamically generating loadable family instances based on parameterized key cache, which may include: The traversal module is used to traverse the family parameters of the loadable family to obtain multiple key parameters when modifying the parameters or creating a new instance; wherein the key parameters are the parameters of the two-dimensional and three-dimensional models that affect the loadable family instance.

[0056] The key generation module is used to generate a unique key according to the parameter value of the key parameter.

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

[0058] It should be understood that the various modules of the loadable family instance dynamic generation system based on parameterized key cache provided in the above embodiments are only illustrated by the division of the functional modules in the above description. In actual applications, the above functions can be assigned to different functional modules as needed, 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.

[0059] The functional modules in the above embodiments may be integrated into one processing unit, or each unit may exist physically separately, or two or more units may be integrated into one unit, and the above integrated unit may be implemented in the form of hardware or in the form of software functional units. In addition, the specific names of the functional units and modules are only for the convenience of distinguishing each other, and are not used to limit the protection scope of the embodiments of the present application.

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

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

[0062] The embodiments described above 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 aforementioned embodiments, a person skilled in the art should understand that the technical solutions described in the aforementioned embodiments may still be modified, or some of the technical features may be replaced by equivalents. Such modifications or replacements do not deviate the essence of the corresponding technical solutions 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 the cache dictionary to see if there is a key with the unique key; If it exists, a loadable family instance is generated based on the model data corresponding to the unique key; if it does not exist, the geometric constraint solver and the 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.

2. The method according to claim 1, characterized in that 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, it remains unchanged.

3. The method according to claim 1, characterized in that 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.

4. The method according to claim 1, characterized in that: The method further comprises: In response to a parameter modification operation, if the key parameters are involved, cache retrieval is triggered; if only modifications of non-key parameters are involved, the parameter data of the loadable family instance is updated.

5. The method according to claim 4, characterized in that The method further comprises: 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.

6. The method according to claim 1 or 5, 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.

7. 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.

8. 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.

9. 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