Large-scale asset dependency relationship management method and terminal based on three-dimensional visualization

Abstract

The invention provides a large-scale asset dependency relationship management method and terminal based on three-dimensional visualization, and the method comprises the steps: obtaining all data assets, creating a corresponding node for each data asset, creating a corresponding arrow object for the dependency relationship between the data assets, and storing the nodes and the arrow object; the nodes are uniformly distributed in a preset area of a horizontal plane through a grid distribution method, and the heights of the nodes in the Z-axis direction in the preset area are adjusted; based on a force steering graph algorithm, calculating the sum of repulsive forces and the sum of gravitational forces borne by the nodes, and dynamically adjusting the positions of the nodes in the three-dimensional coordinate system according to the sum of the repulsive forces and the sum of the gravitational forces; the problems that traditional asset management lacks a global view angle and the dependency relationship is complex are solved, the visualization effect of the data asset dependency relationship is greatly improved, and the stability and interaction ability of data asset management are further enhanced.

Description

Technical Field

[0001] The present invention relates to the technical field of data asset management, and in particular to a large-scale asset dependency management method and terminal based on three-dimensional visualization. Background Art

[0002] In the fields of game development, digital twin-based project management, and scientific research data analysis, the management and analysis of large-scale asset dependencies are crucial. Accurately understanding and handling the dependencies between assets helps optimize resource management, improve performance, reduce costs, and deeply study the structure and dynamic changes of complex systems.

[0003] At present, the reference relationship viewer that comes with the Unreal Engine is one of the more common tools. It has a certain asset reference relationship viewing function, which can view which assets a certain asset is referenced by, and which assets a certain asset references.

[0004] However, Unreal's built-in reference viewer has obvious limitations. In actual projects, the dependencies between assets often present complex and diverse forms, such as Figures 6 to 8 As shown, such as tree dependencies, circular dependencies, cross dependencies, etc. However, the viewer can only display the dependency relationships of a single asset, and it is difficult to clearly present multi-level and cross-dependencies. When faced with complex project engineering, this limitation makes it difficult for developers to maintain and clean up assets. If the reference relationship between assets is ignored or the order of operations is improper, it is very likely to cause various functions to be abnormal, and even cause the program to report errors and crash. For example, when processing a large number of data assets such as textures, models, and sound files, due to the inability to fully grasp the complex dependencies between assets, the dependency chain may be inadvertently destroyed, thereby affecting the normal operation of the game.

[0005] Given the shortcomings of existing technologies in handling large-scale asset dependencies, a solution is needed that can more effectively display and manage asset dependencies to improve the efficiency and accuracy of related work and reduce potential risks. Summary of the invention

[0006] The technical problem to be solved by the present invention is to provide a large-scale asset dependency management method and terminal based on three-dimensional visualization, which intuitively displays the dependencies between assets in a 3D visualization manner, improves the readability of complex dependencies, and solves the limitation that existing tools can only view single assets.

[0007] In order to solve the above technical problems, the technical solution adopted by the present invention is:

[0008] A large-scale asset dependency management method based on three-dimensional visualization comprises the following steps:

[0009] S1. Obtain all data assets and create a corresponding node for each data asset, and at the same time create a corresponding arrow object for the dependency relationship between the data assets, and store the nodes and the arrow objects;

[0010] S2. Evenly distribute the nodes in a preset area of ​​a horizontal plane by a grid distribution method, and adjust the height of the nodes in the Z-axis direction in the preset area;

[0011] S3. Based on the force-directed graph algorithm, the sum of the repulsive forces and the sum of the attractive forces on each of the nodes is calculated, and the position of the node in the three-dimensional coordinate system is dynamically adjusted according to the sum of the repulsive forces and the sum of the attractive forces.

[0012] In order to solve the above technical problems, another technical solution adopted by the present invention is:

[0013] A large-scale asset dependency management terminal based on three-dimensional visualization includes a processor, a memory, and a computer program stored in the memory and executable on the processor. When the processor executes the computer program, the steps in the large-scale asset dependency management method based on three-dimensional visualization are implemented.

[0014] The beneficial effects of the present invention are as follows: the present invention provides a large-scale asset dependency management method and terminal based on three-dimensional visualization, obtains the dependency of data assets, takes assets as nodes and dependencies as arrows, establishes a 3D view, and provides a more comprehensive display of dependencies; evenly distributes the nodes in a preset area, and adjusts the height of the nodes in the Z-axis direction, intuitively displays the relationship, dependency and interaction between assets, and optimizes the visualization effect; based on the force-directed graph algorithm, dynamically adjusts the position of the node according to the sum of the repulsive force and the sum of the attractive force, adjusts the node position, reduces the probability of crossing between arrows, and makes the relationship between complex assets clearer and easier to read; solves the problem of lack of global perspective and complex dependency in traditional asset management, greatly improves the visualization effect of data asset dependency, and further enhances the stability and interactive ability of data asset management. BRIEF DESCRIPTION OF THE DRAWINGS

[0015] Figure 1 A flowchart of a large-scale asset dependency management method based on three-dimensional visualization according to an embodiment of the present invention;

[0016] Figure 2 This is a structural diagram of a large-scale asset dependency management terminal based on three-dimensional visualization according to an embodiment of the present invention;

[0017] Figure 3A specific flow chart of a large-scale asset dependency management method based on three-dimensional visualization according to an embodiment of the present invention;

[0018] Figure 4 A class diagram of a large-scale asset dependency management method based on three-dimensional visualization according to an embodiment of the present invention;

[0019] Figure 5 A cross-functional flow chart of a large-scale asset dependency management method based on three-dimensional visualization according to an embodiment of the present invention;

[0020] Figure 6 A schematic diagram of a tree dependency relationship in a large-scale asset dependency relationship;

[0021] Figure 7 A schematic diagram of a circular dependency in a large-scale asset dependency relationship;

[0022] Figure 8 A schematic diagram of cross-dependencies in a large-scale asset dependency relationship;

[0023] Description of labels:

[0024] 1. A large-scale asset dependency management terminal based on three-dimensional visualization; 2. Processor; 3. Memory. DETAILED DESCRIPTION

[0025] In order to explain the technical content, achieved objectives and effects of the present invention in detail, the following is an explanation in combination with the implementation modes and the accompanying drawings.

[0026] Please refer to Figure 1 , a large-scale asset dependency management method based on three-dimensional visualization, comprising the steps of:

[0027] S1. Obtain all data assets and create a corresponding node for each data asset, and at the same time create a corresponding arrow object for the dependency relationship between the data assets, and store the nodes and the arrow objects;

[0028] S2. Evenly distribute the nodes in a preset area of ​​a horizontal plane by a grid distribution method, and adjust the height of the nodes in the Z-axis direction in the preset area;

[0029] S3. Based on the force-directed graph algorithm, the sum of the repulsive forces and the sum of the attractive forces on each of the nodes is calculated, and the position of the node in the three-dimensional coordinate system is dynamically adjusted according to the sum of the repulsive forces and the sum of the attractive forces.

[0030] From the above description, it can be seen that the beneficial effects of the present invention are: obtaining the dependency relationship of data assets, taking assets as nodes and dependencies as arrows, establishing a 3D view, and providing a more comprehensive display of dependencies; evenly distributing nodes in a preset area, and adjusting the height of the nodes in the Z-axis direction, intuitively displaying the relationship, dependency and interaction between assets, and optimizing the visualization effect; based on the force-directed graph algorithm, dynamically adjusting the position of the node according to the sum of the repulsive force and the sum of the attractive force, adjusting the node position, reducing the probability of intersection between arrows, and making the relationship between complex assets clearer and easier to read; solving the problem of lack of global perspective and complex dependency relationships in traditional asset management, greatly improving the visualization effect of data asset dependency relationships, and further enhancing the stability and interactive capabilities of data asset management.

[0031] Furthermore, before step S1, the following steps are also included:

[0032] S0. Parse the reference information between the data assets in the memory, use the reference relationship between the data assets as the directed edge, construct a directed graph data structure, and based on the directed graph data structure, identify and record the circular dependency relationship therein through a graph traversal algorithm.

[0033] From the above description, we can see that by constructing a directed graph to identify circular dependencies in dependencies, we can clearly sort out data asset relationships, which is helpful to avoid problems in code compilation, building or running due to unclear circular dependencies.

[0034] Further, step S2 comprises the steps of:

[0035] S21, dividing a square area with a preset side length on a horizontal plane of the three-dimensional coordinate system to obtain the preset area;

[0036] The side length of the preset area is determined according to the rounded-up value of the square root of the total number of data assets and the unit spacing of nodes in the horizontal direction, and the unit spacing of nodes in the horizontal direction is configured through a configuration file;

[0037] S22, sorting all the data assets based on the file path, and evenly distributing the nodes corresponding to the sorted data assets in the preset area in sequence;

[0038] S23. Adjust the height of each node in the Z-axis direction based on the dependence and dependency relationship between each data asset and other data assets.

[0039] From the above description, it can be seen that by dividing the preset area according to specific rules on the horizontal plane of the three-dimensional coordinate system, and evenly distributing the nodes corresponding to the data assets according to the file path sorting, it is beneficial to arrange the assets under the same directory together as much as possible, so that the arrows in the 3D space will cross as little as possible; then, based on the dependency and dependence relationship between data assets, the height of the node in the Z-axis direction is adjusted, which realizes the reasonable planning of the spatial layout of data assets, the orderly distribution of nodes and the visual presentation of dependency relationships, which is convenient for management, analysis and troubleshooting of related problems.

[0040] Furthermore, the height of each node in the Z-axis direction in step S23 is specifically:

[0041] Z = (NM) × H;

[0042] Among them, Z is the Z-axis height of any node; N means that any node needs to rely on N other data assets; M means that any node is relied on by other M data assets; H is the unit spacing of nodes in the vertical direction, which is configured through the configuration file.

[0043] From the above description, it can be seen that a specific calculation formula for the height of each node in the Z-axis direction is provided, which is related to the number of assets that the node depends on and is depended on and the unit spacing of nodes in the vertical direction.

[0044] Further, step S3 comprises the steps of:

[0045] S31, selecting any node as the current node, and selecting any node other than the current node as another node;

[0046] S32, calculating the repulsive force between the current node and the other node according to the actual distance between the current node and the other node in the horizontal direction and the unit spacing of the nodes in the horizontal direction;

[0047] S33, calculating the gravitational force between the current node and the another node according to the dependency relationship between the current node and the another node;

[0048] S34. Based on a preset number of iterations, repeat steps S31 to S33 in each round of iteration, calculate the sum of gravitational forces and the sum of repulsive forces on each of the nodes, and adjust the position of each node in the three-dimensional coordinate system according to the sum of gravitational forces and the sum of repulsive forces.

[0049] From the above description, we can know that by calculating the repulsive force and attractive force between nodes respectively, we can accurately simulate the interaction relationship of data assets in the three-dimensional space layout. Multiple rounds of iterations are performed based on the preset number of iterations. During the iteration process, the node position is adjusted according to the calculated spring force in each round, and gradually moved to the optimal position, which can enable the system to achieve a dynamic balance in mechanics, that is, the state of minimizing the total energy.

[0050] Further, step S32 is specifically as follows:

[0051] If the actual distance between the current node and the other node in the horizontal direction is greater than or equal to the unit spacing of the nodes in the horizontal direction, the specific calculation formula of the repulsive force is:

[0052]

[0053] Among them, Frep is the repulsive force between the current node and another node, is the unit direction vector, L is the unit spacing of nodes in the horizontal direction, which is configured through the configuration file, k 1 is the repulsion factor, d is the horizontal distance between the current node and another node, is the vector in the horizontal direction of the current node, is the vector in the horizontal direction of another node;

[0054] Otherwise, the specific calculation formula of the repulsive force is:

[0055]

[0056] Among them, Frep' is the repulsive force between the current node and another node, is the unit direction vector, L is the unit spacing of nodes in the horizontal direction, which is configured through the configuration file, k 1 is the repulsion factor, and d is the horizontal distance between the current node and another node.

[0057] From the above description, it can be seen that according to the relationship between the actual distance between the current node and another node in the horizontal direction and the unit spacing of the nodes in the horizontal direction, different repulsion calculation formulas are used to flexibly control the node spacing, accurately simulate the repulsion transformation, and adapt to the dynamic adjustment of the layout.

[0058] Further, step S33 is specifically as follows:

[0059] If the current node does not depend on the other node, the gravity calculation formula is:

[0060]

[0061] Among them, Fattr is the gravitational force between the current node and another node, is the unit direction vector, γ is the path similarity, and k2 is the gravity factor, which is set through the configuration file;

[0062] Otherwise, the gravity is calculated as:

[0063]

[0064] Among them, Fattr' is the gravitational force between the current node and another node, is the unit direction vector, k2 is the gravitational factor, which is set through the configuration file;

[0065] The path similarity γ is the ratio of the number of consistent characters in the paths of the current node and the other node to the maximum number of path characters in the two paths.

[0066] From the above description, it can be seen that different gravity calculation formulas are used according to the dependency relationship between the current node and another node, and the path similarity based on the ratio of the number of consistent characters in the paths of the two nodes to the maximum number of path characters is introduced. At the same time, the gravity factor is set with the help of the configuration file, which realizes a more accurate calculation of the gravity between nodes, can more realistically reflect the dependency relationship between data assets, and help to more reasonably and accurately reflect the layout of the relationship between data assets.

[0067] Furthermore, step S3 further includes the following steps:

[0068] S4. Render and display the nodes and dependencies according to the user's current field of view.

[0069] From the above description, it can be seen that rendering and displaying nodes and dependencies based on the user's current field of view can present data asset-related information on demand, avoid visual interference caused by excessive information, enable users to focus on the parts they are concerned about, and improve the efficiency and convenience of viewing and analyzing data assets and their relationships; at the same time, it reduces unnecessary rendering calculations, reduces the consumption of system resources, and avoids system freezes or crashes under high load conditions.

[0070] Further, step S4 is specifically as follows:

[0071] Monitor all the nodes, and if the node is within the user's current field of view, keep the node activated;

[0072] Otherwise, put the node into the object pool;

[0073] Render and display the nodes in the activated state and the dependencies between the nodes.

[0074] From the above description, it can be seen that the nodes are monitored and processed according to the user's field of view, the nodes outside the field of view are placed in the object pool, and only the activated nodes and dependencies within the field of view are rendered. This not only optimizes the system performance and resource utilization and reduces unnecessary resource consumption, but also can quickly take out the corresponding objects from the object pool and reactivate them after the field of view changes, reducing the resource reloading and initialization time and improving the system's response speed.

[0075] Please refer to Figure 2 A large-scale asset dependency management terminal based on three-dimensional visualization includes a processor, a memory, and a computer program stored in the memory and executable on the processor. When the processor executes the computer program, the steps in the above-mentioned large-scale asset dependency management method based on three-dimensional visualization are implemented.

[0076] From the above description, it can be seen that the beneficial effects of the present invention are: obtaining the dependency relationship of data assets, taking assets as nodes and dependencies as arrows, establishing a 3D view, and providing a more comprehensive display of dependencies; evenly distributing nodes in a preset area, and adjusting the height of the nodes in the Z-axis direction, intuitively displaying the relationship, dependency and interaction between assets, and optimizing the visualization effect; based on the force-directed graph algorithm, dynamically adjusting the position of the node according to the sum of the repulsive force and the sum of the attractive force, adjusting the node position, reducing the probability of intersection between arrows, and making the relationship between complex assets clearer and easier to read; solving the problem of lack of global perspective and complex dependency relationships in traditional asset management, greatly improving the visualization effect of data asset dependency relationships, and further enhancing the stability and interactive capabilities of data asset management.

[0077] The invention discloses a large-scale asset dependency management method and terminal based on three-dimensional visualization, which are suitable for large-scale asset management and complex system visualization.

[0078] Please refer to Figure 1 , Embodiment 1 of the present invention is:

[0079] A large-scale asset dependency management method based on three-dimensional visualization comprises the following steps:

[0080] S1. Obtain all data assets and create a corresponding node for each data asset, and at the same time create a corresponding arrow object for the dependency relationship between the data assets, and store the nodes and the arrow objects;

[0081] S2. Evenly distribute the nodes in a preset area of ​​a horizontal plane by a grid distribution method, and adjust the height of the nodes in the Z-axis direction in the preset area;

[0082] S3. Based on the force-directed graph algorithm, the sum of the repulsive forces and the sum of the attractive forces on each of the nodes is calculated, and the position of the node in the three-dimensional coordinate system is dynamically adjusted according to the sum of the repulsive forces and the sum of the attractive forces.

[0083] Please refer to Figure 1 , Figures 3 to 5 , Embodiment 2 of the present invention is:

[0084] A large-scale asset dependency management method based on three-dimensional visualization, based on the first embodiment, in this embodiment, Figure 3 , Figure 4 The class diagram shown and Figure 5 The cross-functional flowchart shown is further explained.

[0085] In this embodiment, the solution of the present invention is described in detail based on Unreal Engine. In other equivalent embodiments, it is not limited to Unreal Engine.

[0086] Step 1. System initialization.

[0087] like Figure 3 and Figure 5 As shown, a large-scale asset dependency management method based on three-dimensional visualization needs to be initialized before running, and the StartSystem() method of the AssetVisualizationSystem class is called to initialize the entire visualization tool.

[0088] In this embodiment, Figure 4 As shown in the figure, AssetVisualizationSystem is a key class used in the large-scale asset dependency method. It is mainly responsible for the management and coordination of the entire visualization, and plays a core role in multiple key processes such as initialization, obtaining asset reference information, processing user interactions, and resource release.

[0089] After the visualization tool is initialized, instantiate the core API encapsulation class.

[0090] In this embodiment, Figure 4 , AssetVisualizationSystem creates an instance of CoreApiWrapper. CoreApiWrapper encapsulates the underlying API interface of Unreal Engine. When the subsequent application is used in different engines and platforms, you only need to modify this class to flexibly switch to the corresponding engine or platform.

[0091] Step 2. Call the API to obtain asset reference data.

[0092] In this embodiment, Figure 4As shown, AssetVisualizationSystem calls the GetAssetReferences() method through CoreApiWrapper to request reference information of all assets from Unreal Engine.

[0093] CoreApiWrapper uses the underlying API interface to obtain detailed reference information for each asset, including which assets reference the current asset (Parents) and which assets the current asset references (Children). The return type is a TArray <assetreferenceinfo>A list of types.

[0094] Here, CoreApiWrapper encapsulates the Unreal API. When applying to other engines and platforms in the future, this class can be modified as needed to achieve adaptability.

[0095] Step 3. Storing and resolving asset dependencies, including:

[0096] Step 3.1: Instantiate the asset reference data management class.

[0097] In this embodiment, ssetVisualizationSystem creates an instance of AssetReferenceDataManager, which is responsible for storing and managing reference information of all assets.

[0098] Step 3.2: Store asset reference information.

[0099] In this embodiment, Figure 4 , pass the TArray passed in step 2 <assetreferenceinfo>After being processed by the AddAssetReferenceInfo function, it is stored in the AssetReferenceInfoMap of the AssetReferenceDataManager.

[0100] Step 3.3: Parse asset dependencies, wherein reference information between data assets in memory is parsed, and a directed graph data structure is constructed using the reference relationships between the data assets as directed edges. Based on the directed graph data structure, circular dependencies are identified and recorded through a graph traversal algorithm.

[0101] In this embodiment, the AssetReferenceDataManager calls the ParseAllAssetReferences() method to parse the asset reference information in the memory, build a directed graph data structure, and identify and record the circular dependency path.

[0102] Each asset is regarded as a node in the graph, and the reference relationship between assets is regarded as a directed edge, forming a complex dependency network. The graph traversal algorithm (depth-first search) is used to detect whether there is a loop in the graph and record all circular dependency paths.

[0103] Step 4. Initialize the 3D view, including:

[0104] Step 4.1: Create a 3D View Manager.

[0105] In this embodiment, the Asset3DManager class is instantiated to be responsible for rendering the 3D view.

[0106] Step 4.2: Create all 3D nodes and arrows, specifically:

[0107] All data assets are acquired and corresponding nodes are created for each of the data assets. Meanwhile, corresponding arrow objects are created for the dependency relationships between the data assets, and the nodes and arrow objects are stored.

[0108] In this embodiment, Asset3DManager calls the CreateAll3DActor() method to create a corresponding Asset3DActor node object for each asset and store it in the ActorMap.

[0109] At the same time, the CreateAll3DArrow() method is called to create an Asset3DArrow arrow object based on the reference relationship between assets and store it in ArrowMap. The color of the arrow is set based on whether there is a circular dependency.

[0110] Step 4.3: Initialize the 3D node positions, evenly distribute the nodes in a preset area of ​​the horizontal plane by a grid distribution method, and adjust the height of the nodes in the Z-axis direction in the preset area, specifically:

[0111] Dividing a square area with a preset side length on a horizontal plane of the three-dimensional coordinate system to obtain the preset area;

[0112] The side length of the preset area is determined according to the rounded-up value of the square root of the total number of data assets and the unit spacing of nodes in the horizontal direction, and the unit spacing of nodes in the horizontal direction is configured through a configuration file;

[0113] Sorting all the data assets based on the file path, and evenly distributing the nodes corresponding to the sorted data assets in the preset area in sequence;

[0114] Based on the dependency and dependence relationship between each data asset and other data assets, the height of each node in the Z-axis direction is adjusted. The height in the Z-axis direction is calculated as follows:

[0115] Z = (NM) × H;

[0116] Among them, Z is the Z-axis height of any node; N means that any node needs to rely on N other data assets; M means that any node is relied on by other M data assets; H is the unit spacing of nodes in the vertical direction, which is configured through the configuration file.

[0117] In this embodiment, a square area is divided on a horizontal plane, and its side length is calculated as follows: ceil(sqrt(total number of assets))*unit spacing of nodes in the horizontal direction, and all assets are sorted according to their file paths, and assets in the same directory are arranged together as much as possible.

[0118] In this embodiment, all asset nodes are evenly distributed in the square area, similar to the layout of chess pieces on a Go board. When the number of nodes is not the square of an integer, the ceil function in the above side length calculation formula is responsible for rounding up; and for unfilled grids, the empty grids can be left blank without additional processing.

[0119] Step 5. Dynamically adjust the node position, including:

[0120] Step 5.1: Multi-threaded adjustment of node positions; Step 5.2: Iterative adjustment until energy is minimized.

[0121] Steps 5.1 to 5.2 are as follows:

[0122] Based on the force-directed graph algorithm, the sum of the repulsive forces and the sum of the attractive forces on each of the nodes is calculated, and the position of the node in the three-dimensional coordinate system is dynamically adjusted according to the sum of the repulsive forces and the sum of the attractive forces.

[0123] In this embodiment, Asset3DManager starts multiple threads and calls Update3DActorPos() to dynamically adjust the position of each Asset3DActor node through the force-directed graph algorithm. The main thread obtains the real-time position every frame, so that the node is gradually moved to the optimal position.

[0124] The following steps are involved:

[0125] Any node is selected as the current node, and any node other than the current node is selected as another node.

[0126] In this embodiment, the calculation process consists of two layers of nested for loops, both of which traverse all Asset3DActor nodes. Each node traversed by the outer for loop is the current node, and each node traversed by the inner for loop is another node.

[0127] The repulsive force between the current node and the another node is calculated according to an actual distance between the current node and the another node in the horizontal direction and a unit spacing between nodes in the horizontal direction.

[0128] If the actual distance between the current node and the other node in the horizontal direction is greater than or equal to the unit spacing of the nodes in the horizontal direction, the specific calculation formula of the repulsive force is:

[0129]

[0130]

[0131] Among them, Frep is the repulsive force between the current node and another node, is the unit direction vector, L is the unit spacing of nodes in the horizontal direction, which is configured through the configuration file, k 1 is the repulsion factor, d is the horizontal distance between the current node and another node, is the vector in the horizontal direction of the current node, is the vector in the horizontal direction of another node;

[0132] Otherwise, the specific calculation formula of the repulsive force is:

[0133]

[0134] Among them, Frep' is the repulsive force between the current node and another node, is the unit direction vector, L is the unit spacing of nodes in the horizontal direction, which is configured through the configuration file, k 1 is the repulsion factor, and d is the horizontal distance between the current node and another node.

[0135] In this embodiment, if the actual distance between two nodes is smaller than the pre-configured unit spacing of nodes in the horizontal direction, an additional larger repulsive force will be applied.

[0136] In this embodiment, the unit spacing of nodes in the horizontal direction is configured through a configuration file. Based on the effect seen by the naked eye in actual applications, it is determined whether the nodes are too sparse or too dense, and corresponding adjustments are made manually.

[0137] The attraction between the current node and the another node is calculated according to the dependency relationship between the current node and the another node.

[0138] If the current node does not depend on the other node, the gravity calculation formula is:

[0139]

[0140] Among them, Fattr is the gravitational force between the current node and another node, is the unit direction vector, γ is the path similarity, k 2 is the gravity factor, which is set through the configuration file;

[0141] Otherwise, the gravity is calculated as:

[0142]

[0143] Among them, Fattr' is the gravitational force between the current node and another node, is the unit direction vector, k 2 is the gravity factor, which is set through the configuration file;

[0144] The path similarity γ is the ratio of the number of consistent characters in the paths of the current node and the other node to the maximum number of path characters in the two paths.

[0145] In this embodiment, the lengths of the strings of the two paths to be compared are first obtained, and then a for loop is written to traverse from subscript 0 to the shorter of the two paths from the beginning to the end, character by character; in each round of the for loop, if the two characters currently being compared are found to be consistent, the counter is increased by 1; if they are inconsistent, the comparison is terminated; finally, the number of consistent characters is divided by the larger number of characters in the two paths, which is used as the function return value, that is, the path similarity, which is in the range of [0,1].

[0146] In this embodiment, if the current asset references another asset, additional gravity is added.

[0147] Based on a preset number of iterations, the above steps are repeated in each round of iteration to calculate the sum of gravitational forces and the sum of repulsive forces on each node, and the position of each node in the three-dimensional coordinate system is adjusted according to the sum of gravitational forces and the sum of repulsive forces.

[0148] In this embodiment, the number of iterations is set in the configuration file in combination with the actual situation. Visual observation can be performed during the iteration process to determine whether it has reached dynamic equilibrium. If the positions of all nodes remain basically unchanged during the iteration process, it has reached dynamic equilibrium and achieved the goal. For example, after 100 iterations, the node positions tend to be stable and reach the energy minimization state.

[0149] In this embodiment, in each round of iteration, each node is traversed and the sum of its repulsive force and attractive force with other nodes is calculated, and the total force of the node is finally obtained as the sum of repulsive force minus the sum of attractive force. The node position is gradually adjusted in multiple rounds of iteration until the force is balanced.

[0150] In this embodiment, if the positions of two nodes happen to overlap, they will be skipped during calculation to avoid division by zero errors. In this case, the positions of these nodes will be determined by the attraction and repulsion between them and other nodes.

[0151] Step 5.3: Check the field of view and manage the object pool, including:

[0152] Render and display nodes and dependencies based on the user's current field of view.

[0153] Specifically:

[0154] Monitor all the nodes, and if the node is within the user's current field of view, keep the node activated;

[0155] Otherwise, put the node into the object pool;

[0156] Render and display the nodes in the activated state and the dependencies between the nodes.

[0157] In this embodiment, Asset3DManager calls the CheckVisibility() method of ActorPool to check whether each node is within the current field of view. If the node is within the field of view, the node is kept activated and continues to be displayed in the 3D space; if the node is not within the field of view, the ReturnActor() or ReturnArrow() method of ActorPool is called to put the Asset3DActor or Asset3DArrow object that is not within the field of view into the object pool to optimize rendering performance.

[0158] Step 6. Handle user interactions, including:

[0159] Step 6.1: Accept and process user instructions.

[0160] In this embodiment, the AssetVisualizationSystem receives interaction instructions from the user, such as moving, rotating, selecting assets, etc., and processes them by calling the HandleUserInteraction() method.

[0161] Step 6.2: Update the viewpoint and refresh the view.

[0162] In this embodiment, according to the change of the user's viewpoint, AssetVisualizationSystem calls the UpdateViewPerFrame() method of Asset3DManager to recalculate and update the display content of the asset node. The system calculates the distance between the current camera and the asset node. When the system detects that the user is observing an asset node closely, the system calls the Update3DActorContent() method to display the detailed information of the asset; otherwise, the information is hidden to avoid cluttering the view.

[0163] Step 7. Resource release, including:

[0164] Step 7.1: Receive exit instruction.

[0165] In this embodiment, when an exit instruction is received, AssetVisualizationSystem calls the ExitSystem() method to start the resource release process.

[0166] Step 7.2: Release 3D resources.

[0167] In this embodiment, AssetVisualizationSystem calls the Reset() method of Asset3DManager to release all 3D node and arrow resources; Asset3DManager calls the ClearPool() method of ActorPool to clear the Asset3DActor and Asset3DArrow objects that are no longer needed in the object pool, and receives the completion confirmation of ClearPool().

[0168] Step 7.3: Clean up data management.

[0169] In this embodiment, the AssetVisualizationSystem calls the ClearData() method of the AssetReferenceDataManager to clear all asset reference information and dependency data.

[0170] Please refer to Figure 1 , Figures 3 to 5 , Embodiment 3 of the present invention is:

[0171] A large-scale asset dependency management method based on three-dimensional visualization provides a step flow of applying the present invention in an actual development environment based on the first and second embodiments, including the step flow of integrating and using the present invention in Unreal Engine.

[0172] Step 1. Prepare the integration environment, including:

[0173] Step 1.1: Open the Unreal project.

[0174] In this embodiment, the target project is opened in Unreal Engine to ensure that all assets of the project have been imported and the environment configuration is complete.

[0175] Step 1.2: Integrate the code module of this tool.

[0176] In this embodiment, the code module of this tool is imported into the Unreal project; a plug-in folder of this tool is created under the Plugins directory, and all relevant source code files are added to the directory; in the Build.cs file of the project, a reference to the plug-in module of this tool is added to ensure that it can be loaded when the project is built.

[0177] Step 2. Start the visualization system, including:

[0178] Step 2.1: Call the StartSystem() method.

[0179] In this embodiment, in the upper-layer business logic code, the system is started by calling the StartSystem() method of the AssetVisualizationSystem class.

[0180] In this embodiment, the method will initialize the necessary components, including CoreApiWrapper, AssetReferenceDataManager and Asset3DManager.

[0181] In this embodiment, the system will call the Unreal Engine API through CoreApiWrapper to obtain reference information of all assets, and pass this information to AssetReferenceDataManager for storage and parsing.

[0182] Step 3. Initialize the 3D view, including:

[0183] Step 3.1: Create and initialize 3D nodes and arrows.

[0184] In this embodiment, the system internally calls the CreateAll3DActor() and CreateAll3DArrow() methods of Asset3DManager to generate corresponding 3D nodes and arrows for each asset; calls the InitAssetPosition() method, and the system evenly distributes the nodes on the horizontal plane according to the grid distribution method, and adjusts their height in the Z-axis direction according to the dependency relationship.

[0185] Step 4. Dynamically adjust the 3D node layout, including:

[0186] Step 4.1: Call UpdateViewPerFrame().

[0187] In this embodiment, the system enters the main loop and calls the Update3DActorPos() method through multiple threads to implement dynamic layout adjustment based on the force-directed graph algorithm.

[0188] In this embodiment, the specific algorithm processing is: the system gradually adjusts the position of each node according to the repulsion and attraction between asset nodes. After each round of iteration, the node will move to a new position until the number of iterations reaches the value set in the configuration file (such as 100 rounds).

[0189] Step 5: User interaction processing, including:

[0190] Step 5.1: Capture user interaction events.

[0191] In this embodiment, the user can view the asset layout in the 3D view by rotating, moving, and zooming. The system calls the HandleUserInteraction() method to respond to these operations. When the user observes a node closely, the system dynamically calls the Update3DActorContent() method to display the detailed information of the node, and the non-focus area in the view automatically hides the detailed information to avoid a cluttered interface.

[0192] Step 6. Resource management and optimization, including:

[0193] Step 6.1: Call object pool management.

[0194] In this embodiment, the system calls the CheckVisibility() method of ActorPool in each frame to check which nodes and arrows are within the current field of view. If they are within the field of view, the nodes and arrows are kept activated; if they are not within the field of view, these nodes and arrows are returned to the object pool to save rendering resources.

[0195] Step 7. System shutdown and resource release, including:

[0196] Step 7.1: Call the ExitSystem() method.

[0197] In this embodiment, when the user exits the system, the ExitSystem() method is called to start the resource release process. The system will call the Reset() method of Asset3DManager to release all 3D nodes and arrow resources; then call the ClearPool() method of ActorPool to clear all objects in the object pool; finally, call the ClearData() method of AssetReferenceDataManager to clean up all asset reference data to ensure that system resources are completely released.

[0198] Step 8. Application effect verification, including:

[0199] Step 8.1: Verify the view layout effect.

[0200] In this embodiment, in the Unreal editor or runtime environment, the 3D asset layout is observed through the view to see whether it is reasonable; whether there is a circular dependency display, and whether the layout reduces the situation of arrow crossing.

[0201] Step 8.2: Performance testing and optimization.

[0202] In this embodiment, the Unreal performance analysis tool is used to evaluate the operating efficiency of the system. According to the test results, the parameters such as the repulsion factor, the attraction factor and the number of iterations in the configuration file can be adjusted to further optimize the performance of the system.

[0203] Step 9. System expansion and maintenance, including:

[0204] Step 9.1: Support different platforms and engines.

[0205] In this embodiment, if it is necessary to apply this solution to other engines or platforms, it is only necessary to modify the implementation in the CoreApiWrapper class according to the requirements to adapt it to the target environment.

[0206] Step 9.2: System maintenance and updates.

[0207] In this embodiment, when the number and complexity of assets increase, the stability and performance of the system can be maintained by adjusting the parameters in the configuration file. According to the needs, the functions of the system can also be expanded, such as supporting more types of asset data or adding new visualization effects.

[0208] Please refer to Figure 2 , Embodiment 4 of the present invention is:

[0209] A large-scale asset dependency management terminal 1 based on three-dimensional visualization includes a processor 2, a memory 3, and a computer program stored in the memory 3 and executable on the processor 2. When the processor 2 executes the computer program, the steps of a large-scale asset dependency management method based on three-dimensional visualization described in any one of the above embodiments 1 to 3 are implemented.

[0210] In summary, the present invention provides a large-scale asset dependency management method and terminal based on three-dimensional visualization, which obtains the dependency of data assets, takes assets as nodes and dependencies as arrows, establishes a 3D view, and provides a more comprehensive display of dependencies; evenly distributes the nodes in a preset area, and adjusts the height of the nodes in the Z-axis direction, intuitively displays the relationship, dependency and interaction between assets, and optimizes the visualization effect; based on the force-directed graph algorithm, dynamically adjusts the position of the node according to the sum of the repulsive force and the sum of the attractive force, adjusts the node position, reduces the probability of intersection between arrows, and makes the relationship between complex assets clearer and easier to read; solves the problem of lack of global perspective and complex dependency relationships in traditional asset management, greatly improves the visualization effect of data asset dependency relationships, and further enhances the stability and interactive capabilities of data asset management.

[0211] The above descriptions are merely embodiments of the present invention and are not intended to limit the patent scope of the present invention. Any equivalent transformations made using the contents of the present invention's specification and drawings, or directly or indirectly applied in related technical fields, are also included in the patent protection scope of the present invention.< / assetreferenceinfo> < / assetreferenceinfo>

Claims

1. A large-scale asset dependency management method based on three-dimensional visualization, characterized in that: Includes steps: S1. Obtain all data assets and create a corresponding node for each data asset, and at the same time create a corresponding arrow object for the dependency relationship between the data assets, and store the nodes and the arrow objects; S2. Evenly distribute the nodes in a preset area of ​​a horizontal plane by a grid distribution method, and adjust the height of the nodes in the Z-axis direction in the preset area; S3. Based on the force-directed graph algorithm, the sum of the repulsive forces and the sum of the attractive forces on each of the nodes is calculated, and the position of the node in the three-dimensional coordinate system is dynamically adjusted according to the sum of the repulsive forces and the sum of the attractive forces.

2. A large-scale asset dependency management method based on three-dimensional visualization according to claim 1, characterized in that: Before step S1, the method further includes the following steps: S0. Parse the reference information between the data assets in the memory, use the reference relationship between the data assets as the directed edge, construct a directed graph data structure, and based on the directed graph data structure, identify and record the circular dependency relationship therein through a graph traversal algorithm.

3. The large-scale asset dependency management method based on three-dimensional visualization according to claim 1 is characterized in that: Step S2 comprises the steps of: S21, dividing a square area with a preset side length on a horizontal plane of the three-dimensional coordinate system to obtain the preset area; The side length of the preset area is determined according to the rounded-up value of the square root of the total number of data assets and the unit spacing of nodes in the horizontal direction, and the unit spacing of nodes in the horizontal direction is configured through a configuration file; S22, sorting all the data assets based on the file path, and evenly distributing the nodes corresponding to the sorted data assets in the preset area in sequence; S23. Adjust the height of each node in the Z-axis direction based on the dependence and dependency relationship between each data asset and other data assets.

4. The large-scale asset dependency management method based on three-dimensional visualization according to claim 3 is characterized in that: The height of each node in the Z-axis direction in step S23 is specifically: Z = (NM) × H; Among them, Z is the Z-axis height of any node; N means that any node needs to rely on N other data assets; M means that any node is relied on by other M data assets; H is the unit spacing of nodes in the vertical direction, which is configured through the configuration file.

5. The large-scale asset dependency management method based on three-dimensional visualization according to claim 1 is characterized in that: Step S3 includes the steps of: S31, selecting any node as the current node, and selecting any node other than the current node as another node; S32, calculating the repulsive force between the current node and the other node according to the actual distance between the current node and the other node in the horizontal direction and the unit spacing of the nodes in the horizontal direction; S33, calculating the gravitational force between the current node and the another node according to the dependency relationship between the current node and the another node; S34. Based on a preset number of iterations, repeat steps S31 to S33 in each round of iteration, calculate the sum of gravitational forces and the sum of repulsive forces on each of the nodes, and adjust the position of each node in the three-dimensional coordinate system according to the sum of gravitational forces and the sum of repulsive forces.

6. A large-scale asset dependency management method based on three-dimensional visualization according to claim 5, characterized in that: Step S32 is specifically as follows: If the actual distance between the current node and the other node in the horizontal direction is greater than or equal to the unit spacing of the nodes in the horizontal direction, the specific calculation formula of the repulsive force is: Among them, Frep is the repulsive force between the current node and another node, is the unit direction vector, L is the unit spacing of nodes in the horizontal direction, which is configured through the configuration file, k1 is the repulsion factor, d is the horizontal distance between the current node and another node, is the vector in the horizontal direction of the current node, is the vector in the horizontal direction of another node; Otherwise, the specific calculation formula of the repulsive force is: Among them, Frep' is the repulsive force between the current node and another node, is the unit direction vector, L is the unit spacing of nodes in the horizontal direction, which is configured through the configuration file, k1 is the repulsion factor, and d is the horizontal distance between the current node and another node.

7. The large-scale asset dependency management method based on three-dimensional visualization according to claim 5 is characterized in that: Step S33 is specifically as follows: If the current node does not depend on the other node, the gravity calculation formula is: Among them, Fattr is the gravitational force between the current node and another node, is the unit direction vector, γ is the path similarity, and k2 is the gravity factor, which is set through the configuration file; Otherwise, the gravity is calculated as: Among them, Fattr' is the gravitational force between the current node and another node, is the unit direction vector, k2 is the gravitational factor, which is set through the configuration file; The path similarity γ is the ratio of the number of consistent characters in the paths of the current node and the other node to the maximum number of path characters in the two paths.

8. The large-scale asset dependency management method based on three-dimensional visualization according to claim 1 is characterized in that: Step S3 further includes the following steps: S4. Render and display the nodes and dependencies according to the user's current field of view.

9. A large-scale asset dependency management method based on three-dimensional visualization according to claim 8, characterized in that: Step S4 is specifically as follows: Monitor all the nodes, and if the node is within the user's current field of view, keep the node activated; Otherwise, put the node into the object pool; Render and display the nodes in the activated state and the dependencies between the nodes.

10. A large-scale asset dependency management terminal based on three-dimensional visualization, comprising a processor, a memory, and a computer program stored in the memory and executable on the processor, characterized in that: When the processor executes the computer program, the steps in the large-scale asset dependency management method based on three-dimensional visualization described in any one of claims 1 to 9 are implemented.

Images